Skip to content
Back to search

golive

SkillGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mikehasa/golive-skill with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mikehasa/golive-skill'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mikehasa--golive-skill/badge.svg)](/listings/mikehasa--golive-skill)

HTML

<a href="/listings/mikehasa--golive-skill"><img src="/api/listings/mikehasa--golive-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You need **Node.js 20+**, npm/npx, Git, and a coding agent that can load skills and run commands. Installation has been checked for Codex and Claude Code; other clients are unverified.

**Install once for all your projects.** Run this from any directory:

npx skills add https://github.com/mikehasa/golive-skill --skill golive --global

Select your agent when prompted: use the arrow keys to move, Space to select, and Enter to confirm. That screen is waiting for input; installation continues after you confirm.

To skip the agent picker, use the command for your agent:

# Codex
npx skills add https://github.com/mikehasa/golive-skill --skill golive --global --agent codex --yes

# Claude Code
npx skills add https://github.com/mikehasa/golive-skill --skill golive --global --agent claude-code --yes

For installation in just one project, run from that project's repository and omit `--global`.

**Or paste this into your coding agent:**

Install the GoLive skill globally so I can use it across projects:
npx skills add https://github.com/mikehasa/golive-skill --skill golive --global

Target the agent I'm using: add --agent codex --yes for Codex, or
--agent claude-code --yes for Claude Code. Keep --global.
If the agent isn't clear, ask me which one.

Verify the installation with:
node <installed-skill-dir>/scripts/golive.mjs version --json
Tell me if I need to reload skills or start a new session.
Stop after installation; don't connect accounts or deploy yet.

The install includes the instructions, provider references and prebuilt runtime. It does not connect accounts or deploy anything. See [installation and updates](docs/DISTRIBUTION.md) for noninteractive agent flags, runtime verification and the optional own installer.

Install from npm

The same skill is published to npm as `golive@0.1.0-alpha.9` (dist-tags `alpha` and `latest`), which installs it offline, with no Git or Skills CLI involved:

# Codex
npx golive@alpha install --agent codex

# Claude Code
npx golive@alpha install --agent claude

Add `--global` to install into your home directory (`~/.agents/skills/golive` or `~/.claude/skills/golive`) instead of the current project; `--agent claude-code`, the spelling the Skills CLI channel uses, is accepted as well. The installer copies the complete skill the package ships with, refuses an existing destination, and never connects provider accounts.

**Both channels carry the same release.** The npm package publishes the version in this repository, including the standalone installer helpers, so an npm installation is an owned copy that updates in place. The earlier `0.1.0-alpha.0` snapshot has no updater: remove that copy and reinstall, or use the GitHub channel, which manages its own installs. The npm package also exposes the terminal CLI: the golive commands `npx golive@alpha help`, `version`, `update-check`, `credentials`, `detect`, `menu`, `init`, `doctor`, `plan`, `teardown`, `apply`, `verify`, `status` and `handoff` (`apply` needs the approved plan ID and explicit confirmation), plus the installer commands `install`, `install-status`, `update`, `rollback`, `update-policy` and `recover-lock` for the copies it owns. See [installation and updates](docs/DISTRIBUTION.md#alternative-installation-the-npm-package) for the channel's exact limits.

Install from ClawHub (OpenClaw)

If you use [OpenClaw](https://docs.openclaw.ai), the same skill is listed on [ClawHub](https://clawhub.ai/mikehasa/skills/golive), its public registry:

npx clawhub@latest install golive     # into ./skills, recorded in .clawhub/lock.json
npx clawhub@latest update golive      # later updates stay with ClawHub

ClawHub installs into the current directory's `skills/` folder rather than an agent's global skills directory, so it suits an OpenClaw workspace; Codex and Claude Code are the clients this project verifies, through the two channels above. The registry keeps its own metadata (`_meta.json`,

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 21 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "golive",
  3. "owner": {
  4. "name": "mikehasa"
  5. },
  6. "metadata": {
  7. "description": "GoLive: take an app from repo to live production on the user's own accounts.",
  8. "version": "0.1.0-alpha.9"
  9. },
  10. "plugins": [
  11. {
  12. "name": "golive",
  13. "description": "Deploy an app from its repo to live production on the user's own accounts, with the providers they choose.",
  14. "source": "./",
  15. "strict": false,
  16. "skills": [
  17. "./skills/golive"
  18. ]
  19. }
  20. ]
  21. }
README.md · README · 603 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # GoLive
  2. [English](README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [한국어](README.ko.md) · [Español](README.es.md) · [Português (Brasil)](README.pt-BR.md) · [Deutsch](README.de.md)
  3. **Take your agent-built product live: hosting, database, auth, domain, email, payments — on your own accounts. Then hand it over, or tear it all down.**
  4. Your coding agent can build an app in minutes. Getting it to real users still means accounts,
  5. hosting, databases, domains, secrets and connected services. GoLive is the open-source Agent Skill
  6. for that work: it **detects what your app needs, plans the exact changes, asks for your approval,
  7. applies them with your own logins, and verifies what actually works** — then records what it
  8. created, re-checks it for drift on demand, and can remove it again.
  9. Automate the parts providers expose. Guide you through the parts that need a human. Verify what
  10. can be observed, and make unfinished work clear. No GoLive account, hosted backend or product telemetry.
  11. > **Early alpha · 0.1.0-alpha.9**
  12. > Disposable live tests now cover six journeys: **hosting** (Vercel, Netlify), **database**
  13. > (Supabase, Neon), **custom-domain DNS** (Porkbun, GoDaddy), **transactional email** (Resend),
  14. > **test-mode payments** (Stripe) and **Supabase authentication**, plus the `teardown` uninstall
  15. > path. The ownership document and the on-demand `golive status` drift check are implemented
  16. > with test coverage (`golive status` also ran read-only in a live validation), while the broader
  17. > [roadmap](#the-full-go-live-checklist-and-roadmap) is our direction, not a claim that it is all built.
  18. ## Before you hand over production access
  19. Whether to give an agent your provider accounts comes down to four questions. These are this
  20. project's answers, with the limits stated where they exist.
  21. - **You still approve every write.** Nothing reaches a real account without a plan you have seen and
  22. approved: `apply` refuses without that plan's id and `--yes`, and it re-checks the plan's identity
  23. before writing, so a changed release or config invalidates the old approval. DNS writes need
  24. `--confirm-dns`, deletions need `--confirm-destroy`, and live-mode steps — live payments, production
  25. data, a real account — need `--confirm-live`, which now includes a project's **first production
  26. deploy**, because approving a plan alone used to be enough to write production for the first time.
  27. Credential values are read only in-process, never printed, and never in arguments, plans, state or
  28. reports; the file golive stores them in is plaintext at mode 0600 outside your repo, not a keychain.
  29. One limit worth naming: those flags are arguments the agent passes on your behalf, and an agent
  30. already logged in to your provider can write there with no golive plan at all.
  31. [Trust, access and control](docs/TRUST.md) separates what the code enforces from what is only an
  32. instruction the agent is asked to follow.
  33. - **A run stops rather than pushing on.** `apply` stops at the first failed check, missing
  34. confirmation, missing prerequisite or provider that contradicts the plan. Later steps do not run,
  35. and the next `apply` resumes at that step. [Recovery](docs/RECOVERY.md#the-run-stopped) covers
  36. reading the failure, which steps resume, and the cases that need a reviewed decision first.
  37. - **Rollback is narrow, opt-in and never automatic.** A failed check never triggers a rollback.
  38. `release.rollback: true` plans one step that re-points production at an earlier deployment golive
  39. itself recorded; a deployment built by a dashboard, a Git push or a pull request is not a target,
  40. and it touches no data, DNS, payment or email resource. Only Netlify supports these re-points
  41. today — on Vercel you correct production in the dashboard (Vercel's adapter has no read of what
  42. production serves). Promotion and rollback are implemented and mock-covered, **not live-validated**.
  43. - **Nothing is left behind silently — which is not the same as nothing being left behind.**
  44. `golive teardown` removes only resources it can prove it created, re-reads the DNS zone and the
  45. host project after deleting, and names every leftover it cannot remove — Supabase and Neon
  46. projects, the Resend sending domain, a zone or host project it cannot read — as a handoff saying
  47. what remains and how to remove it by hand. A removal also forgets the baseline golive recorded for
  48. that resource, so `golive status` does not report golive's own teardown as drift.
  49. Those answers in full: [trust, access and control](docs/TRUST.md) and
  50. [recovery](docs/RECOVERY.md). The [architecture](docs/ARCHITECTURE.md) is the product contract,
  51. [provider scope](docs/PROVIDERS.md) says what each provider can do today, the
  52. [validation record](docs/VALIDATION.md) separates what has been exercised live from what is only
  53. mock-covered, [distribution](docs/DISTRIBUTION.md) covers installation and updates, and
  54. [using GoLive with gstack](docs/GSTACK.md) covers the deploy path when gstack builds the app.
  55. [Install](#install) · [Use GoLive](#use-golive) · [See the workflow](#what-a-run-looks-like) · [Alpha scope](#what-this-alpha-supports) · [Roadmap](#the-full-go-live-checklist-and-roadmap) · [Contribute](CONTRIBUTING.md)
  56. ## Install
  57. You need **Node.js 20+**, npm/npx, Git, and a coding agent that can load skills and run commands.
  58. Installation has been checked for Codex and Claude Code; other clients are unverified.
  59. **Install once for all your projects.** Run this from any directory:
  60. ```bash
  61. npx skills add https://github.com/mikehasa/golive-skill --skill golive --global
  62. ```
  63. Select your agent when prompted: use the arrow keys to move, Space to select, and Enter to
  64. confirm. That screen is waiting for input; installation continues after you confirm.
  65. To skip the agent picker, use the command for your agent:
  66. ```bash
  67. # Codex
  68. npx skills add https://github.com/mikehasa/golive-skill --skill golive --global --agent codex --yes
  69. # Claude Code
  70. npx skills add https://github.com/mikehasa/golive-skill --skill golive --global --agent claude-code --yes
  71. ```
  72. For installation in just one project, run from that project's repository and omit `--global`.
  73. **Or paste this into your coding agent:**
  74. ```text
  75. Install the GoLive skill globally so I can use it across projects:
  76. npx skills add https://github.com/mikehasa/golive-skill --skill golive --global
  77. Target the agent I'm using: add --agent codex --yes for Codex, or
  78. --agent claude-code --yes for Claude Code. Keep --global.
  79. If the agent isn't clear, ask me which one.
  80. Verify the installation with:
  81. node <installed-skill-dir>/scripts/golive.mjs version --json
  82. Tell me if I need to reload skills or start a new session.
  83. Stop after installation; don't connect accounts or deploy yet.
  84. ```
  85. The install includes the instructions, provider references and prebuilt runtime. It does not
  86. connect accounts or deploy anything. See [installation and updates](docs/DISTRIBUTION.md) for
  87. noninteractive agent flags, runtime verification and the optional own installer.
  88. ### Install from npm
  89. The same skill is published to npm as `golive@0.1.0-alpha.9` (dist-tags `alpha` and `latest`), which
  90. installs it offline, with no Git or Skills CLI involved:
  91. ```bash
  92. # Codex
  93. npx golive@alpha install --agent codex
  94. # Claude Code
  95. npx golive@alpha install --agent claude
  96. ```
  97. Add `--global` to install into your home directory (`~/.agents/skills/golive` or
  98. `~/.claude/skills/golive`) instead of the current project; `--agent claude-code`, the spelling the
  99. Skills CLI channel uses, is accepted as well. The installer copies the complete skill the package
  100. ships with, refuses an existing destination, and never connects provider accounts.
  101. **Both channels carry the same release.** The npm package publishes the version in this repository,
  102. including the standalone installer helpers, so an npm installation is an owned copy that updates in
  103. place. The earlier `0.1.0-alpha.0` snapshot has no updater: remove that copy and reinstall, or use
  104. the GitHub channel, which manages its own installs.
  105. The npm package also exposes the terminal CLI: the golive commands `npx golive@alpha help`,
  106. `version`, `update-check`, `credentials`, `detect`, `menu`, `init`, `doctor`, `plan`, `teardown`,
  107. `apply`, `verify`, `status` and `handoff` (`apply` needs the approved plan ID and explicit
  108. confirmation), plus the installer commands `install`, `install-status`, `update`, `rollback`,
  109. `update-policy` and `recover-lock` for the copies it owns.
  110. See [installation and updates](docs/DISTRIBUTION.md#alternative-installation-the-npm-package) for
  111. the channel's exact limits.
  112. ### Install from ClawHub (OpenClaw)
  113. If you use [OpenClaw](https://docs.openclaw.ai), the same skill is listed on
  114. [ClawHub](https://clawhub.ai/mikehasa/skills/golive), its public registry:
  115. ```bash
  116. npx clawhub@latest install golive # into ./skills, recorded in .clawhub/lock.json
  117. npx clawhub@latest update golive # later updates stay with ClawHub
  118. ```
  119. ClawHub installs into the current directory's `skills/` folder rather than an agent's global skills
  120. directory, so it suits an OpenClaw workspace; Codex and Claude Code are the clients this project
  121. verifies, through the two channels above. The registry keeps its own metadata (`_meta.json`,
  122. `skill-card.md`, `.clawhub/`) beside the bundle, which golive's own integrity check ignores. See
  123. [installation and updates](docs/DISTRIBUTION.md#clawhub-openclaw-registry) for the channel's limits.
  124. ## Use GoLive
  125. Open your app repository in your coding agent. After installation, reload skills or start a new
  126. session if GoLive does not appear. The skill's name is **`golive`**. For the standalone installation
  127. above, type one of these **in your agent's chat**:
  128. | Agent | Example prompt |
  129. | --- | --- |
  130. | [Codex](https://learn.chatgpt.com/docs/build-skills#how-chatgpt-and-codex-use-skills) | `$golive Help me take this app live.` |
  131. | [Claude Code](https://code.claude.com/docs/en/skills) | `/golive Help me take this app live.` |
  132. You can also ask in plain language:
  133. ```text
  134. Use the golive skill to take this app live. Keep the providers it already uses.
  135. Show me the destination accounts and plan before changing anything.
  136. ```
  137. GoLive inspects the app, asks about missing providers, and presents the destination accounts and
  138. plan for your approval before making provider changes.
  139. These are chat prompts. `golive skill` is not a command. Installing through `npx skills add` does
  140. not add a `golive` command to your terminal; the agent runs the included CLI from the installed
  141. skill directory. The [npm package](#install-from-npm) can also install the skill offline and exposes
  142. that CLI as `npx golive@alpha <command>`; its terminal commands run individual operations rather
  143. than the conversational skill workflow.
  144. ## What a run looks like
  145. An illustrative conversation for an app that already uses Supabase:
  146. > **You:** Use golive to take this app live. Use test resources for now.
  147. >
  148. > **Agent:** This app uses Supabase. Where would you like to host it?
  149. >
  150. > 1. **Vercel** — built-in hosting workflow; live-tested with Supabase.
  151. > 2. **Netlify** — built-in hosting workflow; the live-tested pairing is Netlify + Neon.
  152. > 3. **Other** — tell me your provider; I'll try a guided setup using its official tools and docs.
  153. >
  154. > **You:** Vercel.
  155. >
  156. > **Agent:** We'll keep Supabase. Does this app already have a Supabase project,
  157. > or should we create a new test project?
  158. >
  159. > **You:** Create a new one.
  160. >
  161. > **Agent:** Run `vercel login` and `supabase login` in a separate terminal window.
  162. > I'll check which account and organization are connected when you're done.
  163. >
  164. > **You:** Done.
  165. >
  166. > **Agent:** Here's the plan: create a new test frontend project in your selected Vercel team,
  167. > create its database in your selected Supabase organization, transfer the required environment
  168. > values, and deploy. I'll show the actual destination names and IDs, resource settings and cost
  169. > information with the plan. Approve before I apply it.
  170. >
  171. > **You:** Approved.
  172. >
  173. > **Agent:** The deployment is live. Here is the URL, the verification report, and anything still
  174. > unverified. Next we'll test the app's own signup and data flows. When you're done with this test
  175. > project, `golive teardown` plans its removal for your approval before anything is deleted.
  176. GoLive keeps the provider choices already in your app and asks about missing pieces. You handle
  177. signups, browser logins, identity checks and purchases. If an API key is needed on macOS, a native
  178. hidden-input dialog explains why it is asking and where the key will be saved. Its value goes
  179. directly to the local credentials file, never to chat or command output. Other platforms use your
  180. own editor as a fallback. A later change to the plan needs
  181. another approval; connecting auth or a domain may require a follow-up after the first deploy.
  182. **Using another provider?** The skill has a general guided flow: check the provider's official
  183. CLI, an available official MCP integration or API, then guide you through its dashboard if needed.
  184. The agent still shows the destination, changes and cost before asking for approval, and checks
  185. what it can afterward. This is **best-effort guidance**, with no guarantee of completion or the
  186. same verification coverage as a built-in adapter. If a step cannot be completed or verified,
  187. you get the specific blocker and next action. See [guided provider scope](docs/PROVIDERS.md#guided-providers).
  188. ## What this alpha supports
  189. **Two hosting choices: Vercel and Netlify. Two database choices: Supabase and Neon.**
  190. | Live-tested path | What was exercised |
  191. | --- | --- |
  192. | **Vercel + Supabase** | Provisioning, environment wiring, deployment, authenticated CRUD and access isolation |
  193. | **Netlify + Neon** | Provisioning, environment wiring, deployment, Postgres connectivity, two-session API checks and browser CRUD |
  194. | **Vercel + Porkbun (custom domain)** | Domain attachment, an approved DNS record write under `--confirm-dns`, ownership verification and HTTPS serving on a disposable subdomain |
  195. | **Vercel + GoDaddy (custom domain)** | The same journey on a second subdomain, including the ownership TXT challenge Vercel requested after attaching |
  196. | **Vercel + Resend (email)** | Sending-domain setup, DNS records, domain verification and a real send through the app's own environment key (delivered; the fresh subdomain landed in spam) |
  197. | **Vercel + Stripe (test payments)** | Test-mode keys and webhook registration, an unsigned-request rejection, and a real test-card payment delivered as a signature-verified event |
  198. | **Supabase Auth (SMTP + password recovery)** | Custom-SMTP write read back with the raised auth email rate limit, and the whole recovery rotation on the seeded test account — accepted request, identical answer for an unknown address, spent token refused on replay, new password signing in and the old one refused |
  199. These were approved disposable runs on existing accounts; completed test resources were deleted
  200. afterward, and recent runs' disposable projects and records are cleaned up under the same
  201. supervision. Cross-pairings have mocked coverage, not equivalent live proof. Supabase CLI-login
  202. reuse separately passed read-only verification; the complete deployment test used an explicit
  203. token. A new user's first-account setup and every application framework have not been validated.
  204. The lifecycle commands have their own evidence: `golive teardown` was live-exercised on a disposable
  205. Netlify project (blocked without `--confirm-destroy`, then removed, the account's site list unchanged
  206. apart from it) and earlier runs removed the GoDaddy and Porkbun records golive had written, revoked the
  207. Resend sending keys it had issued and removed the Stripe test-mode endpoint it had registered.
  208. `golive status` ran read-only against a live project; `golive handoff --write` ran on a disposable
  209. Vercel-only fixture: both artifacts were written and audited (a provenance tag on every claim row, the
  210. ownership proof and the teardown gate named, no credential-shaped value in the document, its JSON twin,
  211. state or config), and the project was removed afterwards through the approved teardown flow — the stack
  212. was host-only, so the document's other-provider rows remain mock-covered. See
  213. [observed validation](docs/VALIDATION.md) for the evidence.
  214. Experimental adapters also exist for Supabase Auth configuration, the Supabase Auth signup journey,
  215. its password recovery and account isolation, and Cloudflare DNS. Supabase Auth settings — signup, email confirmation, minimum password length, the
  216. mailer it uses, plus the site URL and redirect allowlist — are automated through an approved plan and
  217. re-read for evidence, and that path passed a disposable live run: the policy write held in the
  218. read-back (`password minimum length: 6 → 12`) and `auth-policy` ended with the built-in-mailer
  219. advisory as its only finding. The opt-in signup journey (`auth.e2e`) passed the same run: one approved
  220. step seeded a real test account (`auth:test-user`, needs `--confirm-live`), the address could not sign
  221. in before confirming (`email_not_confirmed`), and the `auth-signup`/`auth-session` checks proved the
  222. signup email, the enforced confirmation, the confirmed login, the session token and the anonymous
  223. refusal. Two limits stay: the confirmation was applied through the Auth admin API rather than the
  224. seeded account's own email click, and inbox delivery is human-confirmed by design — golive never sees
  225. the inbox. A later approved run on a disposable fixture (a deployed Vercel site whose declared route
  226. answers 401 without a session, plus one RLS-protected table) exercised both app-side legs: an
  227. anonymous GET of `auth.protectedPath` answered 401 and the signed-in probe read that table as the
  228. authenticated user, so the probe's bearer fix is no longer mock-covered. What that evidence cannot
  229. show: that run's table line is a count rather than table names, and any 401 counted as protected — a
  230. WAF or maintenance page would read the same; both were fixed afterwards (issue #30: the probe names
  231. the tables it read, and a refused protected path is corroborated against the public root, with mocked
  232. coverage and no live re-run yet). Password recovery is **live-validated on the same provider**: the
  233. same 2026-09-24 run carried `auth.smtp: resend` (the custom-SMTP write and the raised auth email rate
  234. limit, both read back) and `auth.recovery: true`, whose one approved step (`auth:recovery`, needs
  235. `--confirm-live`) rotated that recorded test account's password through the provider's own recovery
  236. calls — request the email, mint the link with the admin API, exchange it for a session, set the new
  237. password with that session — and the `auth-recovery` check passed every leg: the request was accepted,
  238. an address with no account got the same answer (no account enumeration), the spent token was refused
  239. on replay, the new password signed in and the one it replaced did not. The inbox click and any captcha
  240. stay with the human (the `auth:recovery-email` handoff says so), the SMTP password is write-only (the
  241. provider answers a hash, so the read-back proves the settings, not a delivery), and the account was
  242. confirmed through the Auth admin API rather than the owner's click. Account isolation is implemented on the same
  243. provider too: `auth.isolation: true` with `auth.identityPath` and `auth.isolationPath` adds one
  244. approved step (`auth:isolation`, needs `--confirm-live`) that seeds a
  245. **second** real test account — the address derived from `auth.testEmail`, the password again only in
  246. that run's memory — and confirms it through the provider's admin API (no second inbox click: the
  247. journey is about the app's data, not delivery). The `auth-isolation` check then signs in as both
  248. accounts and reads the app's own two declared routes on the production URL: both must refuse an
  249. anonymous caller (a 200 is a critical finding), each account's identity route must answer with its
  250. own user id and never the other's, and the rows route must return only the caller's own rows —
  251. checked with one unique marker row per account written **through that route** with the account's
  252. session and read back, so another account's marker in the answer is a cross-account read and fails
  253. critically. When the routes are not declared, the non-blocking `auth:isolation-routes` handoff hands
  254. the app-code task over; a 404 or a refused session skips with that task named, never as a pass.
  255. Account isolation is **implemented and mock-covered, not live-validated yet** — its live run comes
  256. separately. The recovery run's own output contained two defects, both fixed here with mocked
  257. regressions: `teardown` reported the owner's *adopted* sending domain as created by golive (an empty
  258. creation-marker list made `[].every()` true, so every recorded domain read as golive's), and the
  259. `auth:recovery-email` handoff showed a standalone `verify` skip as its evidence while state recorded
  260. that step done. Its third finding — Resend kept reporting that domain verified while the records it
  261. listed were absent from the zone's authoritative nameserver — is fixed by
  262. [#52](https://github.com/mikehasa/golive-skill/issues/52): `email-verified` now resolves the records
  263. the provider itself lists for the domain before passing (a verified domain whose records are gone
  264. fails, a record golive wrote inside the propagation window only warns, and a provider that cannot list
  265. them skips rather than passing), and the email plan keeps the `email:dns` step or handoff for records
  266. that do not resolve, so a stale flag can no longer hide them. Mock-covered; not re-exercised live.
  267. The DNS, email and test-mode payment paths listed above are the tested ones, with the custom-domain
  268. runs using Porkbun and GoDaddy record writes; **Cloudflare DNS specifically is not a validated alpha
  269. path yet**, and other auth providers stay guided. See [provider scope](docs/PROVIDERS.md) and
  270. [observed validation](docs/VALIDATION.md).
  271. ## The full go-live checklist and roadmap
  272. A working URL is the beginning. Depending on the app, going live can mean all of the following.
  273. **GoLive should work out which items apply, help you finish them, and show evidence for the result.**
  274. A static site should not be asked to set up a database; a paid SaaS should not stop at a deployed homepage.
  275. This is our product roadmap as a launch checklist. Checkmarks and strikethroughs mark **specific
  276. live-tested milestones**, not a finished category or a completed checklist for your app.
  277. **✅ Live-tested** · **🚧 In progress / experimental** (code exists; complete journey pending) · **🗺️ Planned**
  278. ### Ship the app
  279. - [x] ✅ **Frontend hosting:** ~~Prove deployment on Vercel and Netlify.~~ Build, deploy and verify
  280. the intended project on the two tested paths.
  281. - [x] ✅ **Database:** ~~Prove provisioning and connection with Supabase and Neon.~~ The tested
  282. paths include environment wiring and application CRUD checks.
  283. - [x] ✅ **Environment wiring:** ~~Connect hosting and database credentials on both tested paths.~~
  284. Broader secret rotation and environment lifecycle management remain planned.
  285. - [ ] 🗺️ **Backend / servers:** dedicated API services, containers, persistent servers, runtime
  286. configuration and health checks. App routes already deploy through the supported hosts.
  287. - [ ] 🗺️ **Schema and data:** reviewed migrations, safe rollout, environment separation and app
  288. data checks. These were separately supervised in live tests; a reusable workflow is still planned.
  289. - [ ] 🗺️ **File and object storage:** buckets, uploads, access rules, signed URLs and lifecycle policies.
  290. ### Make it a complete product
  291. - [ ] 🚧 **Authentication:** signup, login, sessions, password recovery and account isolation.
  292. Supabase auth policy (signup, email confirmation, minimum password length, mailer) and the site
  293. URL/redirect allowlist are written through an approved plan, re-read for evidence and verified
  294. by the `auth-policy`/`auth-redirects` checks — exercised in an approved disposable run, where the
  295. policy write held at a twelve-character minimum. The opt-in journey (`auth.e2e: true`) passed the
  296. same run: the `auth:test-user` step seeded a real test account, that address could not sign in
  297. before confirming, and the `auth-signup`/`auth-session` checks proved the signup email, the enforced
  298. confirmation, the confirmed login and the session token — **live-validated for Supabase across
  299. disposable projects, where the confirmation came through the Auth admin API instead of the seeded
  300. email click, inbox delivery stayed human-confirmed, and a later run proved a declared protected
  301. path (an anonymous 401) and a signed-in read of an RLS-protected table, reported as a count rather
  302. than a table name**. Password recovery is **live-validated on the same provider** (`auth.recovery:
  303. true` adds the `auth:recovery` step and the `auth-recovery` check, which proved no account
  304. enumeration, a one-time token and the replaced password on a disposable project; the confirmation
  305. came through the Auth admin API, the inbox click stays human-confirmed, and two output defects that
  306. run found — a false "created by golive" ownership claim and a handoff evidence text contradicting
  307. the recorded step — are fixed with mocked regressions). Account isolation — the other half, and the
  308. one earlier runs could not exercise — is
  309. implemented and mock-covered the same way: `auth.isolation: true` with `auth.identityPath` and
  310. `auth.isolationPath` adds the `auth:isolation` step (a second real test account, confirmed through
  311. the provider's admin API and recorded by id and address) and the `auth-isolation` check, which
  312. signs in as both accounts and proves on the app's own routes that neither can read the other's
  313. identity or rows (a cross-account read fails critically; an undeclared or 404 route skips with the
  314. app-code task). Its live run comes separately too. Other auth providers stay guided.
  315. - [ ] 🗺️ **OAuth / social login / SSO:** client registration, consent screens, scopes, callback
  316. URLs and provider reviews. Current auth-provider setup is guided.
  317. - [x] ✅ **Payments and subscriptions:** ~~Prove test-mode checkout and webhook acceptance with Stripe.~~
  318. A real test-card payment delivered a signature-verified `checkout.session.completed` event. A new
  319. read-only `stripe-live-payment` check reads the most recent succeeded live PaymentIntent, the live
  320. webhook endpoint that would receive it and the matching delivery event, and reports any refund; it
  321. is implemented and mock-covered but not live-validated yet. Live-mode readiness, entitlements,
  322. refunds and subscription events still need validation.
  323. - [x] ✅ **Transactional email:** ~~Prove sending-domain setup, verification and real delivery with Resend.~~
  324. A send through the app's own environment key was delivered (to spam on a fresh subdomain, no DMARC yet).
  325. With `auth.smtp: resend` the `auth:smtp` step also writes the auth project's custom SMTP — Resend's
  326. host/port/user, the sender the app already uses, and an SMTP password taken from a sending key golive
  327. issued (the email journey's key, or one it issues for SMTP alone) — and raises the project's own auth
  328. email rate limit (`rate_limit_email_sent`) to 30 per hour (or `auth.emailRateLimitPerHour`) in the
  329. same write, because the provider keeps that limit with custom SMTP. `auth-policy` then reports
  330. `custom SMTP via Resend` instead of warning about the built-in mailer. The password is write-only (the
  331. provider answers a hash), so the read-back confirms the settings and a real auth email is the only full
  332. proof. **Live-validated on a disposable project (2026-09-24)**: the same run wrote the custom SMTP and
  333. read it back (`smtp.resend.com`, port 465, user `resend`, sender `auth@mail.trytofu.xyz`) together with
  334. `auth email rate limit: 2 → 30 per hour`, issued the SMTP key by itself and revoked it in teardown, and
  335. `auth-policy` then read `custom SMTP via Resend` with 30 auth emails/hour — settings and rate limit
  336. only, since the password itself can never be read back. Bounce handling, richer message content and
  337. actual inbox delivery (human-confirmed by design, and doubtful on that run's domain — see
  338. [issue #52](https://github.com/mikehasa/golive-skill/issues/52)) still need validation.
  339. - [x] ✅ **Domains / DNS / HTTPS:** ~~Prove domain attachment, DNS wiring and HTTPS serving on host+DNS pairs.~~
  340. Tested: Vercel attachment with Porkbun and GoDaddy record writes under `--confirm-dns`, ownership
  341. verification and HTTPS 200 on disposable subdomains. The Cloudflare DNS adapter, redirects and
  342. further host pairings still need live validation.
  343. - [ ] 🗺️ **SMS and push notifications:** sender registration, credentials, permissions and delivery checks.
  344. - [ ] 🗺️ **Third-party and AI services:** API access, scopes, callbacks, quotas and functional tests.
  345. Missing environment variables are detected today; service-specific workflows are planned.
  346. - [ ] 🗺️ **Background work:** cron schedules, queues, workers, retries and failed-job recovery.
  347. - [ ] 🗺️ **Cache, search and realtime:** caches, search/vector indexes and realtime services when needed.
  348. ### Launch with confidence, then keep it running
  349. - [ ] 🗺️ **Security and abuse controls:** access policies, exposed credentials, security headers,
  350. rate limits and bot protection. Scoped RLS/advisor and credential-pattern checks exist today.
  351. - [ ] 🗺️ **Monitoring and alerts:** error tracking, logs, uptime and actionable alerts.
  352. Provider suggestions are guided today; verified setup is planned. On-demand drift checks exist
  353. (`golive status`, below) — continuous monitoring and alerting do not. Sentry is implemented as an
  354. automated monitoring provider — adapter, host env wiring and the `sentry-ingest` check,
  355. mock-covered with no live run yet. UptimeRobot's uptime monitor is implemented too —
  356. `uptimerobot:monitor` and the read-only `uptime-monitor` check, mock-covered with no live run yet.
  357. - [ ] 🚧 **Product analytics:** event validation and consent/data settings, beyond today's guided
  358. provider suggestions. PostHog analytics is wired through an approved plan — the app's analytics
  359. project is adopted or selected (a create is planned when nothing matches), and the `posthog-ingest`
  360. check proves ingest by sending one synthetic event and reading it back through PostHog's own query
  361. API — live-validated on a disposable project (2026-09-30). Host env writing, consent settings and
  362. the app's own event flows stay open; the create/delete path of a golive-created project is
  363. mock-covered only.
  364. - [ ] 🚧 **CI/CD and safe releases:** previews, release checks, promotion, rollback and drift
  365. detection, building on today's approved CLI deployments. **Deployment identity — implemented, not
  366. live-validated:** each successful deploy records the provider's own identity for the deployment it
  367. made (`deployed:<target>:id` = `<provider>|<deployment id>|<url>|<time>` in `.golive/state.json`,
  368. mock-covered; a provider that reports no identity records none), so a later capability can name one
  369. exact deployment. **Opt-in preview deploy and release check — implemented, not live-validated:**
  370. with `release.preview: true` in `golive.yaml` (and `preview` in `targets`), `plan` adds
  371. `preview:deploy` — a create that deploys the current working tree to the host's preview target,
  372. names the provider, project, env target and the source project the preview shares with production,
  373. needs `--confirm-live` when a live-mode value fills a preview env name, and records the provider's
  374. own identity as `deployed:preview:id` — and `release:check`, which writes nothing, declares
  375. `preview:deploy` as its prerequisite, and fails the plan when the provider's read of that deployment
  376. or a credential scan of its bundle fails. In a plan that builds a release candidate, that check is
  377. the last step, so what it gates is the promotion (whose own plan re-runs the check before production
  378. changes), not the production deploy the same plan already emitted before it. **Promotion
  379. and rollback — implemented, not live-validated:** with `release.promote: true` (on top of the
  380. preview opt-in) a plan asks for a release by promotion, and with `release.rollback: true` it asks to
  381. re-point production at an earlier deployment golive itself created and recorded. `promote:production`
  382. names the exact deployment id it would make production — the provider reports a deployment's id only
  383. once the deployment exists, so building the candidate and promoting it are two plans, and the plan
  384. you approve names which one it is — is gated by `release:check` re-reading that deployment in the
  385. same plan, and
  386. needs **no extra confirmation flag**: the plan id, the named deployment and the fresh gate are the
  387. approval. Both steps re-read the target deployment and what production serves before writing and
  388. prove what production serves afterwards; both keep the cross-release stop (neither is `replayable`
  389. nor a deletion), and neither is automatic — no failed check triggers a rollback, and a deployment
  390. built by a dashboard, a Git push or a pull request is never a promotion or rollback target (it is a
  391. handoff, named as such). What each host supports differs, and golive refuses rather than guessing:
  392. Netlify re-reads its published deployment and can restore an earlier one, so both steps work there;
  393. Vercel exposes no read of what production serves and no promote/rollback call golive has exercised,
  394. so on Vercel nothing is promoted or rolled back and a warning says why. `production-release` proves
  395. what production serves, names what it served before, and reports a deployment golive never recorded
  396. as a handoff. Adding these step ids changes a plan's id, so an approval that was not applied must be
  397. re-planned. The preview checks (and therefore promotion) skip on a host that exposes no
  398. per-deployment read (Vercel), reporting that instead of guessing. Drift detection
  399. exists as the read-only `golive status` command below (it ran read-only in the auth validation and
  400. had nothing actionable once that journey passed, but the DNS, environment, webhook and deployment
  401. baselines it compares still lack live evidence), and preview deployments are not yet among the
  402. subjects it compares.
  403. - [ ] 🗺️ **Backups and recovery:** retention, restore drills, incident steps and approved cleanup.
  404. Approved `teardown` removes what golive created; backups and any restore remain manual, supervised work.
  405. - [x] ✅ **Uninstall / teardown:** ~~an approved inventory of golive-created resources and their removal.~~
  406. `golive teardown` plans the removal, deletes only what golive provably created (ownership proofs and
  407. `--confirm-destroy`), and re-reads the DNS zone's golive-owned record list and the host's own
  408. project read after deleting. Nothing it cannot remove is dropped silently: a leftover — an
  409. unreadable zone, an unremovable host project, a provider that is not signed in — becomes a handoff
  410. naming what remains and the exact fix, and Supabase/Neon projects and the Resend sending domain
  411. remain manual handoffs
  412. ([#9](https://github.com/mikehasa/golive-skill/issues/9)). A removal forgets the baseline golive
  413. recorded for that resource, so `golive status` does not report golive's own teardown as drift, and
  414. a sending key golive revoked is reported as a warning instead of a pass, because the provider
  415. offers no read to confirm it.
  416. - [ ] 🗺️ **Costs and quotas:** plan choices, budgets, alerts and capacity checks.
  417. Scoped Free-plan guards exist today; ongoing cost management is planned.
  418. - [ ] 🚧 **Launch essentials:** metadata, share previews, indexing, accessibility, support links
  419. and owner-reviewed policy pages. The read-only `site-metadata` check reads the production page's
  420. own `<head>` once and reports its title, description, canonical link and Open Graph/Twitter share
  421. tags (a missing title, description or share tag — or an `og:image`/`og:url` that is not absolute —
  422. warns, never fails; golive does not edit app code, so the fix is a change in your repo). It is
  423. mock-covered with no live run yet; share previews, indexing, accessibility, support links and
  424. policy pages stay planned.
  425. - [ ] 🚧 **Ownership and handover:** accounts, resources, access, renewal responsibilities and
  426. maintenance instructions. `golive handoff --write` records the login route, ownership proofs,
  427. recurring jobs and removal gates in `GOLIVE_HANDOVER.md`, tagging every row as verified, recorded,
  428. not verifiable or unknown, and `golive status` re-reads those subjects on demand: it compares the
  429. baselines golive recorded with the providers as they are now, and names what it could not read.
  430. Drift re-baselining stays manual and approved — the command is implemented and ran read-only in the
  431. auth validation, but a live validation of every drift subject is still pending.
  432. Some steps will always need a person: accepting terms, identity verification, purchases, billing
  433. choices and reviews that a provider requires. “Guided” should still mean a clear next action,
  434. the right page, the right permissions, a check afterward, and a return to the same workflow.
  435. When the app itself needs code changes, GoLive should give the coding agent a concrete task and
  436. recheck the result. It should not make you coordinate a dozen disconnected setup conversations.
  437. **Next up:** complete and live-test the remaining launch journeys—the live run for account isolation
  438. (implemented and mock-covered on Supabase, not yet exercised against a real project), live-mode
  439. payment flows and the Cloudflare DNS adapter—then expand app architectures and
  440. ongoing operations.
  441. These are directions, not release dates. A capability should graduate from experimental only after
  442. its account setup, connection, verification and recovery have been exercised. Contributions toward
  443. any part of this checklist are welcome, especially evidence of where a real launch gets stuck.
  444. <details>
  445. <summary>Production checklists informing this roadmap</summary>
  446. The scope draws on [Vercel's launch checklist](https://vercel.com/docs/production-checklist),
  447. [Supabase's production checklist](https://supabase.com/docs/guides/deployment/going-into-prod),
  448. [Stripe's go-live checklist](https://docs.stripe.com/get-started/checklist/go-live),
  449. [Google's OAuth production guidance](https://developers.google.com/identity/protocols/oauth2/production-readiness/policy-compliance)
  450. and [Next.js production guidance](https://nextjs.org/docs/pages/guides/production-checklist).
  451. These inform the goals above; they are not GoLive features or blanket requirements for every app.
  452. </details>
  453. ## Verification you can inspect
  454. The report records **pass, fail, warning and skipped** results, along with remaining human steps.
  455. Checks include account access, environment-variable names, provider-confirmed deployment URLs, public
  456. JavaScript secret patterns, database access, supported auth/webhook/DNS settings, and (where the host
  457. can answer it) the deployment the provider says production serves.
  458. A ready deployment is not proof that the app works. An environment-variable name can exist with
  459. a wrong value. A verified email domain does not prove inbox delivery. Signed payment events,
  460. signup and the app's business flows need functional tests. **Skipped is not passed.**
  461. Your app gets `golive.yaml`, `.golive/state.json`, `.golive/report.json` and `GOLIVE_REPORT.md`.
  462. State preserves resource IDs and step evidence for recovery; it is not a credential store.
  463. `golive teardown` removes what golive created after its own approval and `--confirm-destroy`;
  464. there is no cross-provider rollback, restore or general reconciliation command for those resources —
  465. `release:rollback` (opt-in) only re-points production at an earlier deployment golive itself recorded,
  466. and touches no data, DNS, payment or email resource.
  467. `golive handoff --write` adds the ownership document: `GOLIVE_HANDOVER.md` at the repo root and its
  468. JSON source in `.golive/handover.json`. It names the accounts and login route, every resource golive
  469. created and the proof it is golive's, what is still manual, what recurs, how removal works, and which
  470. commands re-check each subject. Each row says whether it was verified in that run, recorded earlier,
  471. not verifiable by golive or unknown; golive read no billing data, so no cost figure is stated. The
  472. files contain no secret values, but secret-free metadata can still identify private resources —
  473. review them before sharing. `--write` never overwrites a file golive did not generate unless
  474. `--force` is passed.
  475. `golive status` asks the follow-up question: has anything changed behind golive's back since it
  476. recorded what it did? It compares recorded baselines — the DNS records golive wrote, the environment
  477. variable **names** it delivered, the registered webhook endpoint, the domain attachment, the database
  478. project and its connection selectors, the sending domain, the payment account behind the app's keys,
  479. the host project — with reads taken now, and labels both sides: `expected (recorded by golive <time>)`
  480. against `observed (read now)`. Each item says who can act: re-run a check, re-plan and apply an
  481. approved change, or a decision only a human can make. It is read-only: no report file, no provider
  482. write, no state change, and it exits with `2` when something needs acting on. A provider it cannot read
  483. is reported as unverifiable — never as clean, and never as a failure — and it never re-baselines
  484. anything by itself. Drift is deliberately not a gate: `plan`, `apply` and `verify` never consult it.
  485. `status` is **implemented**, and it ran read-only during the Supabase auth validation (a failed step
  486. surfaced as actionable, then an empty list once it completed), but a live validation of the remaining
  487. drift subjects is still pending.
  488. ## Credentials and control
  489. - **Approve before account changes.** Plans name the destinations and intended writes, and `apply`
  490. refuses without the approved plan id and `--yes`. Changing the installed release invalidates old
  491. approvals. DNS, live-payment and deletion steps have extra gates (`--confirm-dns`,
  492. `--confirm-live`, `--confirm-destroy`), and a project's first production deploy needs
  493. `--confirm-live` as well, because approving a plan alone used to be enough to write production for
  494. the first time. [Trust, access and control](docs/TRUST.md#what-golive-may-write-and-what-comes-first)
  495. walks through each gate.
  496. - **Keep secrets out of chat.** Supported vendor logins are reused. On macOS, a native hidden-input
  497. dialog can save a needed API key; your own editor is the fallback. Keys live in
  498. `~/.config/golive/credentials`, a local plaintext file at mode 0600 outside your app repo — not an
  499. OS keychain, so anything running as your user can read it. The execution code keeps values out of
  500. argv, plans, state, reports and command output, storing fingerprints instead of values.
  501. `golive credentials --remove NAME --yes` deletes one stored entry, irreversibly; revoking the
  502. token at the provider is what actually ends access. Mac login passwords stay with macOS/vendor
  503. authentication prompts; GoLive never asks you to enter one in its key dialog. The full boundary is
  504. in [trust, access and control](docs/TRUST.md#the-credential-boundary).
  505. - **Updates have an owner.** Skills CLI manages its installs. The optional own installer supports
  506. whole-bundle updates and local rollback; automatic replacement is off by default. Update between
  507. deployment runs, never between a plan and its apply. Cloud resources are unaffected by rollback.
  508. - **Your accounts remain yours.** GoLive does not buy services or create billing accounts.
  509. Your coding agent, providers and installer have their own data practices.
  510. ## Contribute
  511. 🤝 **We're early, and we'd love your help shaping GoLive.** Bug reports, feature ideas, docs fixes
  512. and pull requests are all welcome. You don't need to build an adapter to contribute: an unclear
  513. login instruction or a real launch that got stuck is useful feedback too.
  514. Open an issue to report a problem or discuss an idea, or send a focused PR. For a larger provider
  515. or workflow addition, consider starting an issue so we can agree on the scope together. Never include secrets
  516. or raw authentication responses in a report.
  517. See **[CONTRIBUTING.md](CONTRIBUTING.md)** for local setup, tests and your first contribution.
  518. The [architecture](docs/ARCHITECTURE.md), [trust, access and control](docs/TRUST.md),
  519. [recovery](docs/RECOVERY.md), [provider scope](docs/PROVIDERS.md) and
  520. [validation record](docs/VALIDATION.md) explain what exists and where help is needed.
  521. [MIT licensed](LICENSE). Bundled third-party notices are included in
  522. [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.