gzero-cli 0.1.0-preview.2 → 0.2.0

package/README.md

@@ -11,7 +11,7 @@
 
 **Deploy UIs and APIs, manage env vars, domains, and billing, straight from your terminal or an AI agent.**
 
-[![npm](https://img.shields.io/npm/v/gzero-cli/preview?color=7C6FF0&label=npm&logo=npm&logoColor=white)](https://www.npmjs.com/package/gzero-cli)
+[![npm](https://img.shields.io/npm/v/gzero-cli?color=7C6FF0&label=npm&logo=npm&logoColor=white)](https://www.npmjs.com/package/gzero-cli)
 [![node](https://img.shields.io/badge/node-%E2%89%A520-7C6FF0?logo=node.js&logoColor=white)](https://nodejs.org)
 [![platforms](https://img.shields.io/badge/platform-linux%20%C2%B7%20macos%20%C2%B7%20windows-A594FF)](#install)
 [![MCP ready](https://img.shields.io/badge/AI%20agents-MCP%20ready-5B4BE0)](#connect-an-ai-agent-mcp)
@@ -37,33 +37,45 @@ Works on Linux, macOS, and Windows.
 
 ## Quick start
 
-Push your code to GitHub, then go from zero to live in two commands:
+One command gets you live. Run it in your project directory:
 
 ```bash
-gzero login            # device-code sign in via your browser
-gzero init             # pick a repo, auto-detect the build, create + deploy
+gzero login            # device-code sign in via your browser (one time)
+cd my-app
+gzero deploy           # publish to GitHub if needed, scan, create, and ship
 ```
 
-`gzero init` walks you through it: choose a GitHub repo, pick web app or API,
-attach it to a product (existing or new), and it scans the repo to detect the
-framework, build command, and output folder for you. At the end it offers to
-deploy.
+`gzero deploy` (short alias: `g0 deploy`) is context-aware and does the right
+thing for where you are:
 
-Already have projects? Day-to-day it's just:
+- **Linked directory** (a `.gzero/project.json` file exists): redeploys that project.
+- **Git repo with a GitHub remote:** scans, creates the project, and deploys.
+- **Local repo, not on GitHub yet:** offers to create a GitHub repo on your
+  account and push your code there first, then continues.
+- **Not a git repo:** falls back to picking one of your GitHub repositories.
+
+`init` vs `deploy`, in one line: **init sets up and links, deploy ships.** Use
+`gzero init` to create and link a project without deploying yet.
 
 ```bash
 gzero deploy           # deploy a project and watch it go live
-gzero status           # check readiness, URL, and env vars
+gzero status           # check hosting mode, readiness, URL, and env vars
 ```
 
-`gzero deploy` on a brand-new account with no projects drops straight into the
-`init` flow, then deploys. Run `gzero` with no arguments (or `gzero --help`) to
-see the full command list.
+Run `gzero` with no arguments (or `gzero --help`) to see the full command list.
 
 > **Note**
-> GroundZero builds and deploys from GitHub, so your code needs to be pushed to
-> a GitHub repo first (the same as the dashboard). The CLI does not upload local
-> files.
+> GroundZero builds from GitHub, so your code has to live in a GitHub repo. The
+> CLI can create that repo and push for you (reusing your GitHub sign-in, no
+> extra tokens), so a purely local project can go live without leaving the
+> terminal.
+
+### Static vs server-rendered (SSR)
+
+When a scan detects a server-rendered app (Next, Nuxt, SvelteKit, ...), the CLI
+asks how to host it: a **static site** (free preview, cheap to go live) or a
+**server-rendered app** running a Node server (the all-in $9/mo plan: server,
+custom domain, SSL). Switch anytime with `gzero ssr enable` / `gzero ssr disable`.
 
 ## Sign in
 
@@ -98,14 +110,16 @@ in the browser itself.
 | `gzero login` | Device-code sign in; saves an API token |
 | `gzero logout` | Revoke the current token and clear local config |
 | `gzero whoami` | Show the signed-in account |
-| `gzero init [repo]` | Create a project from a GitHub repo (interactive), then optionally deploy |
+| `gzero deploy [project]` | Get the current project live: publish to GitHub if needed, scan, create, and deploy (or redeploy the linked/named project) |
+| `gzero init [repo]` | Set up and link a project (from local code or a GitHub repo) without deploying |
 | `gzero projects` *(alias `ls`)* | List your projects |
-| `gzero deploy [project]` | Trigger a deploy and follow it to completion (bootstraps `init` on an empty account) |
-| `gzero status [project]` | Active deploy, readiness, and env status |
+| `gzero status [project]` | Active deploy, hosting mode, readiness, and env status |
 | `gzero logs [project]` | Print the latest deploy's build log |
 | `gzero open [project]` | Open the project's live URL in your browser |
 | `gzero rollback [project]` | Roll back to a previous successful deploy |
-| `gzero promote [project]` | Promote a deploy to production |
+| `gzero promote [project]` | Promote a live deploy to production |
+| `gzero ssr enable [project]` | Switch a web project to server-rendered hosting (paid) |
+| `gzero ssr disable [project]` | Switch a server-rendered project back to static |
 | `gzero env list [project]` | List env var keys |
 | `gzero env set <project> <key> <value>` | Set an env var |
 | `gzero env rm <project> <key>` | Delete an env var |
@@ -167,9 +181,16 @@ for details.
 ## Examples
 
 ```bash
-# Create a project from a specific repo and deploy it
+# Take a purely local project live: creates a GitHub repo, pushes, then deploys
+cd my-app && gzero deploy
+
+# Create and link a project from a specific repo without deploying
 gzero init acme/my-app
 
+# Host a server-rendered app on the Node runtime, then deploy it
+gzero ssr enable my-app
+gzero deploy my-app
+
 # Deploy a specific branch to production and wait for it to go live
 gzero deploy my-app --branch main --env production
 

package/dist/index.js

@@ -31,9 +31,29 @@ var require_deploy_readiness = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.evaluateDeployReadiness = evaluateDeployReadiness;
+    function staticSwitchHint(framework) {
+      switch (framework) {
+        case "next-static":
+          return "add `output: 'export'` to next.config (no SSR, ISR, or API routes)";
+        case "nuxt-static":
+          return "build with `nuxt generate` (or set `nitro: { preset: 'static' }`)";
+        case "astro-static":
+          return "set `output: 'static'` and remove the SSR adapter";
+        case "sveltekit-static":
+          return "use `@sveltejs/adapter-static` (no SSR or server endpoints)";
+        case "vite-react":
+        case "vite-vue":
+        case "vite-svelte":
+          return "ship a client-only or prerendered build (no Nitro server routes)";
+        default:
+          return "configure a static build for your framework";
+      }
+    }
     function evaluateDeployReadiness(input) {
       const blockers = [];
       const warnings = [];
+      const detectedRenderMode = input.checks?.some((c) => c.id === "render-mode") ? "ssr" : "static";
+      const renderMode = input.renderModeOverride ?? detectedRenderMode;
       if (!input.framework || input.framework === "unknown") {
         blockers.push({
           id: "framework",
@@ -50,7 +70,7 @@ var require_deploy_readiness = __commonJS({
           recommendation: 'Add a "build" script to package.json or run scan again.'
         });
       }
-      if (!input.outputDir && input.framework !== "plain-html") {
+      if (!input.outputDir && input.framework !== "plain-html" && renderMode !== "ssr") {
         blockers.push({
           id: "output",
           level: "error",
@@ -58,6 +78,14 @@ var require_deploy_readiness = __commonJS({
           recommendation: "Run scan again to detect the build output folder."
         });
       }
+      if (renderMode === "ssr" && input.serviceType !== void 0 && input.serviceType !== "ssr_web") {
+        blockers.push({
+          id: "ssr-hosting",
+          level: "error",
+          message: "This app renders on a server (SSR). Choose Server-rendered (SSR) hosting to deploy it.",
+          recommendation: `Pick Server-rendered (SSR) in Hosting mode to continue ($9/mo all-in: server, domain, and SSL). To host as a static site instead, ${staticSwitchHint(input.framework)}, then re-scan.`
+        });
+      }
       if (input.secretsFound) {
         warnings.push({
           id: "secrets",
@@ -81,6 +109,8 @@ var require_deploy_readiness = __commonJS({
           if (check.id.startsWith("env-"))
             continue;
           const isFrameworkConfigError = check.id === "framework-config" && check.level === "error";
+          if (isFrameworkConfigError && renderMode === "ssr")
+            continue;
           if (check.level !== "warning" && !isFrameworkConfigError)
             continue;
           warnings.push({
@@ -95,7 +125,8 @@ var require_deploy_readiness = __commonJS({
         canDeploy: blockers.length === 0,
         blockers,
         warnings,
-        technicalNotes: input.technicalNotes ?? []
+        technicalNotes: input.technicalNotes ?? [],
+        renderMode
       };
     }
   }
@@ -283,6 +314,15 @@ var require_dist2 = __commonJS({
         me: () => request("/auth/me"),
         // --- Repos ---
         listRepos: (opts) => request(`/github/repos${opts?.refresh ? "?refresh=true" : ""}`),
+        /**
+         * Create a new GitHub repository on the signed-in user's account (using their
+         * linked OAuth token, server-side). Returns a short-lived tokenized `pushUrl`
+         * so a client can push local commits once; callers must not persist it.
+         */
+        createRepo: (input) => request("/github/repos", {
+          method: "POST",
+          body: JSON.stringify(input)
+        }),
         // --- Scanner ---
         scanRepo: (input) => request("/scanner/scan", {
           method: "POST",
@@ -327,6 +367,22 @@ var require_dist2 = __commonJS({
           method: "POST",
           body: JSON.stringify({ deployId })
         }),
+        /** Switch a web project to server-rendered mode (consumes SSR capacity). */
+        enableSsr: (projectId, startCommand) => request(`/projects/${projectId}/ssr`, {
+          method: "POST",
+          body: JSON.stringify({ startCommand: startCommand ?? null })
+        }),
+        /** Switch a server-rendered project back to static hosting. */
+        disableSsr: (projectId) => request(`/projects/${projectId}/ssr`, { method: "DELETE" }),
+        /**
+         * Re-point a project to a different GitHub repo. Clears artifacts, cache, and
+         * deploy history from the old repo and resets the build config; a rescan and
+         * redeploy are required afterwards.
+         */
+        changeRepo: (projectId, repoFullName, defaultBranch) => request(`/projects/${projectId}/repo`, {
+          method: "POST",
+          body: JSON.stringify({ repoFullName, defaultBranch: defaultBranch ?? null })
+        }),
         // --- Env vars ---
         listEnvVars: (projectId) => request(`/projects/${projectId}/env-vars`),
         upsertEnvVar: (projectId, key, value) => request(`/projects/${projectId}/env-vars`, {
@@ -353,9 +409,9 @@ var require_dist2 = __commonJS({
         // --- Billing ---
         getBillingStatus: () => request("/billing/status"),
         createCheckout: () => request("/billing/checkout", { method: "POST" }),
-        createAddonCheckout: (addonId, productId) => request("/billing/addons/checkout", {
+        createAddonCheckout: (addonId, productId, returnPath) => request("/billing/addons/checkout", {
           method: "POST",
-          body: JSON.stringify({ addonId, productId })
+          body: JSON.stringify({ addonId, productId, returnPath })
         }),
         createBillingPortal: () => request("/billing/portal", { method: "POST" }),
         listInvoices: () => request("/billing/invoices")
@@ -409,6 +465,23 @@ async function clearConfig() {
   } catch {
   }
 }
+function projectLinkPath(dir) {
+  return join(dir, ".gzero", "project.json");
+}
+async function loadProjectLink(dir) {
+  try {
+    const raw = await readFile(projectLinkPath(dir), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.projectId ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function saveProjectLink(dir, link) {
+  await mkdir(join(dir, ".gzero"), { recursive: true });
+  await writeFile(projectLinkPath(dir), `${JSON.stringify(link, null, 2)}
+`);
+}
 async function resolveSettings(flags2) {
   const file = await loadConfig();
   return {
@@ -558,6 +631,84 @@ async function resolveProject(c, ref) {
 var import_sdk2 = __toESM(require_dist2(), 1);
 import * as p2 from "@clack/prompts";
 import pc3 from "picocolors";
+
+// src/git.ts
+import { spawn as spawn2 } from "child_process";
+import { basename } from "path";
+function runGit(args, cwd) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let child;
+    try {
+      child = spawn2("git", args, { cwd });
+    } catch {
+      resolve({ code: 127, stdout: "", stderr: "git not found" });
+      return;
+    }
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("error", () => resolve({ code: 127, stdout, stderr: "git not found" }));
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+  });
+}
+async function gitAvailable() {
+  const res = await runGit(["--version"], process.cwd());
+  return res.code === 0;
+}
+function parseGithubRemote(url) {
+  if (!url) return null;
+  const trimmed = url.trim();
+  const ssh = /^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/.exec(trimmed);
+  if (ssh) return `${ssh[1]}/${ssh[2]}`;
+  const https = /^https?:\/\/(?:[^@]+@)?github\.com\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (https) return `${https[1]}/${https[2]}`;
+  return null;
+}
+async function inspectGit(cwd) {
+  const inside = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside.code !== 0 || inside.stdout.trim() !== "true") {
+    return {
+      isRepo: false,
+      root: null,
+      branch: null,
+      hasCommits: false,
+      originUrl: null,
+      githubRepo: null,
+      dirty: false
+    };
+  }
+  const [root, branch, head, origin, status] = await Promise.all([
+    runGit(["rev-parse", "--show-toplevel"], cwd),
+    runGit(["symbolic-ref", "--short", "HEAD"], cwd),
+    runGit(["rev-parse", "HEAD"], cwd),
+    runGit(["remote", "get-url", "origin"], cwd),
+    runGit(["status", "--porcelain"], cwd)
+  ]);
+  const originUrl = origin.code === 0 ? origin.stdout.trim() || null : null;
+  return {
+    isRepo: true,
+    root: root.code === 0 ? root.stdout.trim() : null,
+    branch: branch.code === 0 ? branch.stdout.trim() || null : null,
+    hasCommits: head.code === 0,
+    originUrl,
+    githubRepo: parseGithubRemote(originUrl),
+    dirty: status.code === 0 && status.stdout.trim().length > 0
+  };
+}
+function suggestRepoName(cwd, root) {
+  const dir = basename(root ?? cwd) || "app";
+  return dir.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+}
+async function hasGitIdentity(cwd) {
+  const [name, email] = await Promise.all([
+    runGit(["config", "user.name"], cwd),
+    runGit(["config", "user.email"], cwd)
+  ]);
+  return name.code === 0 && name.stdout.trim() !== "" && email.code === 0 && email.stdout.trim() !== "";
+}
+
+// src/create.ts
 var MANUAL = "__manual__";
 var CREATE_PRODUCT = "__create__";
 var REPO_ROOT = ".";
@@ -565,6 +716,21 @@ function guard(value) {
   if (p2.isCancel(value)) die("Cancelled.");
   return value;
 }
+function redactSecret(text2, pushUrl) {
+  let out = text2;
+  if (pushUrl) out = out.split(pushUrl).join("https://github.com");
+  const token = /x-access-token:([^@/\s]+)@/.exec(pushUrl)?.[1];
+  if (token) out = out.split(token).join("***");
+  return out.replace(/(https?:\/\/)[^@/\s]+:[^@/\s]+@/g, "$1");
+}
+async function lookupDefaultBranch(c, repoFullName) {
+  try {
+    const { repos } = await c.listRepos();
+    return repos.find((r) => r.fullName === repoFullName)?.defaultBranch ?? null;
+  } catch {
+    return null;
+  }
+}
 async function pickRepo(c) {
   const s = p2.spinner();
   s.start("Loading your GitHub repositories");
@@ -680,19 +846,36 @@ function scanSummary(scan, repoFullName, branch) {
     `${pc3.dim("branch")}     ${branch}`,
     `${pc3.dim("framework")}  ${scan.framework}`
   ];
+  if (scan.renderMode) lines.push(`${pc3.dim("render")}     ${scan.renderMode === "ssr" ? "server-rendered (SSR)" : "static"}`);
   if (scan.scanPath && scan.scanPath !== REPO_ROOT) lines.push(`${pc3.dim("path")}       ${scan.scanPath}`);
   if (scan.buildCommand) lines.push(`${pc3.dim("build")}      ${scan.buildCommand}`);
   if (scan.outputDir) lines.push(`${pc3.dim("output")}     ${scan.outputDir}`);
+  if (scan.renderMode === "ssr" && scan.startCommand)
+    lines.push(`${pc3.dim("start")}      ${scan.startCommand}`);
   if (scan.requiredEnvVars.length > 0)
     lines.push(`${pc3.dim("env vars")}   ${scan.requiredEnvVars.join(", ")}`);
   return lines.join("\n");
 }
+function staticExportHint(framework) {
+  switch (framework) {
+    case "next-static":
+      return "Add `output: 'export'` to next.config.js (static export), then re-scan.";
+    case "nuxt-static":
+      return "Use `nuxt generate` (or nitro preset 'static') to prerender, then re-scan.";
+    case "astro-static":
+      return "Set `output: 'static'` in astro.config, then re-scan.";
+    case "sveltekit-static":
+      return "Switch to @sveltejs/adapter-static, then re-scan.";
+    default:
+      return "Configure a static export for this framework, then re-scan.";
+  }
+}
 async function interactiveCreate(c, opts = {}) {
   let repoFullName;
   let defaultBranch;
   if (opts.repo) {
     repoFullName = opts.repo;
-    defaultBranch = "main";
+    defaultBranch = opts.defaultBranch ?? await lookupDefaultBranch(c, opts.repo) ?? "main";
   } else {
     ({ repoFullName, defaultBranch } = await pickRepo(c));
   }
@@ -700,7 +883,7 @@ async function interactiveCreate(c, opts = {}) {
     await p2.select({
       message: "What are you deploying?",
       options: [
-        { value: "web", label: "Web app", hint: "static site (React, Vue, Astro, Svelte, ...)" },
+        { value: "web", label: "Web app", hint: "React, Vue, Astro, Svelte, Next, Nuxt, ..." },
         { value: "api", label: "API", hint: "ExpressoTS backend" }
       ]
     })
@@ -721,6 +904,37 @@ async function interactiveCreate(c, opts = {}) {
     }
   }
   p2.note(scanSummary(scan, repoFullName, defaultBranch), "Detected configuration");
+  let hostingMode = null;
+  let buildCommand = scan.buildCommand;
+  let outputDir = scan.outputDir;
+  let configOverrides = {};
+  if (kind === "web" && scan.renderMode === "ssr") {
+    hostingMode = guard(
+      await p2.select({
+        message: "This app renders on a server. How do you want to host it?",
+        options: [
+          { value: "ssr", label: "Server-rendered (SSR)", hint: "$9/mo all-in: server, domain, SSL" },
+          {
+            value: "static",
+            label: "Static site",
+            hint: scan.staticAlternative ? "build a static export" : "needs a static export config"
+          }
+        ],
+        initialValue: "ssr"
+      })
+    );
+    if (hostingMode === "static") {
+      configOverrides = { renderMode: "static" };
+      if (scan.staticAlternative) {
+        buildCommand = scan.staticAlternative.buildCommand;
+        outputDir = scan.staticAlternative.outputDir;
+      } else {
+        p2.note(staticExportHint(scan.framework), "Static export needed");
+      }
+    } else {
+      configOverrides = { renderMode: "ssr" };
+    }
+  }
   const s = p2.spinner();
   s.start(kind === "api" ? "Creating API service" : "Creating project");
   let project;
@@ -735,17 +949,31 @@ async function interactiveCreate(c, opts = {}) {
         defaultBranch
       });
     } else {
+      const detectedConfig = {
+        framework: scan.framework,
+        buildCommand: scan.buildCommand,
+        outputDir: scan.outputDir,
+        scanPath: scan.scanPath ?? REPO_ROOT,
+        startCommand: scan.startCommand ?? null,
+        installCommand: scan.installCommand ?? "npm install",
+        renderMode: scan.renderMode,
+        staticAlternative: scan.staticAlternative ?? null
+      };
       project = await c.createProject({
         repoFullName,
         productId,
         defaultBranch,
         framework: scan.framework,
         scanPath: scan.scanPath ?? REPO_ROOT,
-        buildCommand: scan.buildCommand,
-        outputDir: scan.outputDir,
+        buildCommand,
+        outputDir,
         spaFallback: scan.spaFallback,
         requiredEnvVars: scan.requiredEnvVars,
-        secretsFound: scan.secretsFound
+        secretsFound: scan.secretsFound,
+        lastScanChecks: scan.checks,
+        startCommand: scan.startCommand ?? null,
+        detectedConfig,
+        configOverrides
       });
     }
   } catch (err) {
@@ -753,7 +981,143 @@ async function interactiveCreate(c, opts = {}) {
     fail(err);
   }
   s.stop(`${symbol.ok} Created ${brand.violet(project.name)} ${pc3.dim(`(${project.slug})`)}`);
-  return { project, scan };
+  let ssrPending = false;
+  if (hostingMode === "ssr") {
+    const outcome = await upgradeToSsr(c, project, scan.startCommand ?? null);
+    ssrPending = outcome === "checkout";
+  }
+  return { project, scan, ssrPending };
+}
+async function upgradeToSsr(c, project, startCommand) {
+  let billing2;
+  try {
+    billing2 = await c.getBillingStatus();
+  } catch (err) {
+    fail(err);
+  }
+  const hasSpareCapacity = billing2.ssrRuntime.capacity > billing2.ssrRuntime.used;
+  if (hasSpareCapacity) {
+    const s = p2.spinner();
+    s.start("Enabling server-rendered hosting");
+    try {
+      await c.enableSsr(project.id, startCommand);
+      s.stop(`${symbol.ok} Server-rendered hosting enabled.`);
+    } catch (err) {
+      s.stop("Could not enable server rendering");
+      fail(err);
+    }
+    return "enabled";
+  }
+  const addonId = billing2.availableAddons.find((a) => a.type === "ssr")?.id;
+  if (!addonId) {
+    p2.note("Server rendering isn't available on your account yet.", "Server rendering");
+    return "unavailable";
+  }
+  try {
+    const { url } = await c.createAddonCheckout(addonId);
+    p2.note(
+      `${pc3.underline(url)}
+
+${pc3.dim("This is the all-in $9/mo plan (server, domain, SSL).")}`,
+      "Complete payment to enable server rendering"
+    );
+    openBrowser(url);
+  } catch (err) {
+    fail(err);
+  }
+  return "checkout";
+}
+async function createRepoAndPush(c, cwd, git) {
+  if (!await gitAvailable()) die("git is required to create and push a repository.");
+  const suggested = suggestRepoName(cwd, git.root);
+  p2.note(
+    `This project isn't on GitHub yet. GroundZero deploys from GitHub, so we'll
+create a repo on your account and push your code there.`,
+    "Publish to GitHub"
+  );
+  const name = guard(
+    await p2.text({
+      message: "New GitHub repository name",
+      defaultValue: suggested,
+      placeholder: suggested,
+      validate: (v) => /^[A-Za-z0-9._-]+$/.test(v.trim()) ? void 0 : "Use letters, numbers, '.', '-', '_' only."
+    })
+  );
+  const repoName = name.trim() || suggested;
+  const isPrivate = guard(
+    await p2.confirm({ message: "Make the repository private?", initialValue: true })
+  );
+  const create = p2.spinner();
+  create.start(`Creating ${repoName} on GitHub`);
+  let repo;
+  try {
+    repo = await c.createRepo({ name: repoName, private: isPrivate });
+  } catch (err) {
+    create.stop("Could not create repository");
+    fail(err);
+  }
+  create.stop(`${symbol.ok} Created ${brand.violet(repo.fullName)}`);
+  const root = git.root ?? cwd;
+  const branch = git.branch ?? "main";
+  if (!git.hasCommits) {
+    await runGit(["add", "-A"], root);
+    const identityArgs = await hasGitIdentity(root) ? [] : ["-c", "user.name=GroundZero", "-c", "user.email=cli@gzer0.app"];
+    const commit = await runGit([...identityArgs, "commit", "-m", "Initial commit"], root);
+    if (commit.code !== 0) {
+      die(`Could not create an initial commit: ${commit.stderr.trim() || "commit failed"}`);
+    }
+  }
+  const push = p2.spinner();
+  push.start(`Pushing ${branch} to ${repo.fullName}`);
+  const cleanUrl = `https://github.com/${repo.fullName}.git`;
+  const remoteName = git.originUrl ? "gzero" : "origin";
+  await runGit(["remote", "remove", remoteName], root);
+  await runGit(["remote", "add", remoteName, cleanUrl], root);
+  const pushed = await runGit(["push", repo.pushUrl, `HEAD:refs/heads/${branch}`], root);
+  if (pushed.code !== 0) {
+    push.stop("Push failed");
+    const detail = redactSecret(pushed.stderr, repo.pushUrl).trim();
+    die(`git push failed: ${detail || "unknown error"}`);
+  }
+  push.stop(
+    `${symbol.ok} Pushed ${branch} to ${brand.violet(repo.fullName)}${remoteName === "gzero" ? pc3.dim(" (remote 'gzero')") : ""}`
+  );
+  return { repoFullName: repo.fullName, branch };
+}
+async function onboardProject(c, opts) {
+  if (opts.repo) {
+    return interactiveCreate(c, { repo: opts.repo });
+  }
+  const git = await inspectGit(opts.cwd);
+  if (!git.isRepo) {
+    let projects;
+    try {
+      projects = await c.listProjects();
+    } catch (err) {
+      fail(err);
+    }
+    if (projects.length > 0) {
+      const project = await resolveProject(c);
+      return { project, existing: true };
+    }
+    return interactiveCreate(c);
+  }
+  if (git.githubRepo) {
+    let projects;
+    try {
+      projects = await c.listProjects();
+    } catch (err) {
+      fail(err);
+    }
+    const match = projects.find((proj) => proj.repoFullName === git.githubRepo);
+    if (match) {
+      p2.note(`Using the existing project for ${git.githubRepo}.`, "Linked");
+      return { project: match, existing: true };
+    }
+    return interactiveCreate(c, { repo: git.githubRepo, defaultBranch: git.branch ?? void 0 });
+  }
+  const pushed = await createRepoAndPush(c, opts.cwd, git);
+  return interactiveCreate(c, { repo: pushed.repoFullName, defaultBranch: pushed.branch });
 }
 async function deployProject(c, project, opts = {}) {
   const s = p2.spinner();
@@ -798,7 +1162,7 @@ ${pc3.dim("Re-run with --yes to acknowledge warnings.")}`);
     s.stop(`${symbol.warn} Deploy status: ${current.status}`);
   }
 }
-async function offerDeploy(c, project, opts) {
+async function reportReadiness(c, project) {
   let hardBlockers = [];
   try {
     const readiness = await c.getReadiness(project.id);
@@ -816,6 +1180,10 @@ ${pc3.dim("Set them with")} gzero env set ${project.slug} KEY value`,
     }
   } catch {
   }
+  return { hardBlockers };
+}
+async function offerDeploy(c, project, opts) {
+  const { hardBlockers } = await reportReadiness(c, project);
   if (hardBlockers.length > 0) {
     p2.note(hardBlockers.map((b) => `${symbol.err} ${b.message}`).join("\n"), "Fix before deploying");
     p2.outro(`Resolve the blockers above, then run ${brand.violet(`gzero deploy ${project.slug}`)}.`);
@@ -829,12 +1197,25 @@ ${pc3.dim("Set them with")} gzero env set ${project.slug} KEY value`,
     p2.outro(`Run ${brand.violet(`gzero deploy ${project.slug}`)} when you're ready.`);
     return;
   }
-  await deployProject(c, project, { yes: true });
+  await deployProject(c, project, { yes: true, ...opts.deploy });
   p2.outro("Done.");
 }
+async function finishSetup(c, project, opts = {}) {
+  if (opts.ssrPending) {
+    p2.outro(
+      `Finish the server-rendering upgrade in your browser, then run ${brand.violet(`gzero deploy ${project.slug}`)}.`
+    );
+    return;
+  }
+  const { hardBlockers } = await reportReadiness(c, project);
+  if (hardBlockers.length > 0) {
+    p2.note(hardBlockers.map((b) => `${symbol.err} ${b.message}`).join("\n"), "Fix before deploying");
+  }
+  p2.outro(`Setup complete. Run ${brand.violet(`gzero deploy ${project.slug}`)} to ship.`);
+}
 
 // src/index.ts
-var VERSION = "0.1.0-preview.2";
+var VERSION = true ? "0.2.0" : "0.0.0-dev";
 var program = new Command();
 program.name("gzero").description("GroundZero: deploy UIs and APIs from the terminal or an AI agent.").version(VERSION, "-v, --version", "Print the CLI version.").option("--api-url <url>", "API base URL (default: config or GZERO_API_URL)").option("--token <token>", "API token (default: config or GZERO_TOKEN)").configureHelp({
   styleTitle: (s) => pc4.bold(s),
@@ -955,36 +1336,52 @@ program.command("projects").alias("ls").description("List your projects.").actio
     fail(err);
   }
 });
-program.command("init").argument("[repo]", "GitHub repository (owner/repo) to skip the picker").description("Create a project from a GitHub repo (interactive) and optionally deploy.").action(async (repo, _opts, command) => {
+program.command("init").argument("[repo]", "GitHub repository (owner/repo) to skip detection").description("Set up a project (from local code or a GitHub repo) and link this directory. Does not deploy.").action(async (repo, _opts, command) => {
   const c = await client(flags(command));
   p3.intro(lockup("init"));
-  const { project } = await interactiveCreate(c, { repo });
-  await offerDeploy(c, project, { prompt: true });
+  const cwd = process.cwd();
+  const { project, ssrPending } = await onboardProject(c, { cwd, repo });
+  await saveProjectLink(cwd, { projectId: project.id, repoFullName: project.repoFullName });
+  await finishSetup(c, project, { ssrPending });
 });
-program.command("deploy").argument("[project]", "project id, slug, or name").option("-b, --branch <branch>", "branch to deploy").option("-e, --env <environment>", "environment (production or preview)").option("-y, --yes", "acknowledge readiness warnings and deploy anyway").option("--no-follow", "return immediately instead of streaming status").description("Trigger a deploy and follow it to completion.").action(async (projectRef, opts, command) => {
+program.command("deploy").argument("[project]", "project id, slug, or name").option("-b, --branch <branch>", "branch to deploy").option("-e, --env <environment>", "environment (production or preview)").option("-y, --yes", "acknowledge readiness warnings and deploy anyway").option("--no-follow", "return immediately instead of streaming status").description("Ship the current project to a live URL (sets it up first if needed).").action(async (projectRef, opts, command) => {
   const c = await client(flags(command));
-  if (!projectRef) {
+  const cwd = process.cwd();
+  const deployOpts = {
+    yes: Boolean(opts.yes),
+    branch: opts.branch,
+    env: opts.env,
+    follow: opts.follow
+  };
+  if (projectRef) {
+    const project2 = await resolveProject(c, projectRef);
+    await deployProject(c, project2, deployOpts);
+    return;
+  }
+  const link = await loadProjectLink(cwd);
+  if (link) {
     let projects;
     try {
       projects = await c.listProjects();
     } catch (err) {
       fail(err);
     }
-    if (projects.length === 0) {
-      p3.intro(lockup("deploy"));
-      p3.note("You don't have any projects yet. Let's create one.", "Setup");
-      const { project: project2 } = await interactiveCreate(c);
-      await offerDeploy(c, project2, { prompt: false });
+    const linked = projects.find((proj) => proj.id === link.projectId);
+    if (linked) {
+      await deployProject(c, linked, deployOpts);
       return;
     }
   }
-  const project = await resolveProject(c, projectRef);
-  await deployProject(c, project, {
-    yes: Boolean(opts.yes),
-    branch: opts.branch,
-    env: opts.env,
-    follow: opts.follow
-  });
+  p3.intro(lockup("deploy"));
+  const { project, ssrPending } = await onboardProject(c, { cwd });
+  await saveProjectLink(cwd, { projectId: project.id, repoFullName: project.repoFullName });
+  if (ssrPending) {
+    p3.outro(
+      `Finish the server-rendering upgrade in your browser, then run ${brand.violet(`gzero deploy ${project.slug}`)}.`
+    );
+    return;
+  }
+  await offerDeploy(c, project, { prompt: false, deploy: deployOpts });
 });
 program.command("status").argument("[project]", "project id, slug, or name").description("Show the active deploy and readiness for a project.").action(async (projectRef, _opts, command) => {
   const c = await client(flags(command));
@@ -992,11 +1389,21 @@ program.command("status").argument("[project]", "project id, slug, or name").des
   try {
     const status = await c.getProjectStatus(project.id);
     const active = status.activeDeploy;
+    const hosting = project.serviceType === "ssr_web" ? "server-rendered" : "static";
     console.log(`${symbol.bullet} ${pc4.bold(project.name)}${pc4.dim(` (${project.slug})`)}`);
     console.log(`  status:   ${active ? statusColor(active.status) : pc4.dim("no deploys")}`);
     if (active?.url) console.log(`  url:      ${pc4.cyan(active.url)}`);
+    console.log(`  hosting:  ${hosting}`);
     console.log(`  env vars: ${status.envConfigured ? pc4.green("configured") : pc4.yellow("missing")}`);
     console.log(`  ready:    ${status.readiness.canDeploy ? pc4.green("yes") : pc4.red("no")}`);
+    const ssrBlocker = status.readiness.blockers.find((b) => b.id === "ssr-hosting");
+    if (ssrBlocker) {
+      console.log(
+        `
+${symbol.warn} ${ssrBlocker.message}
+  ${pc4.dim(`Run`)} gzero ssr enable ${project.slug} ${pc4.dim("to host it as a server-rendered app.")}`
+      );
+    }
   } catch (err) {
     fail(err);
   }
@@ -1077,6 +1484,33 @@ program.command("promote").argument("[project]", "project id, slug, or name").de
     fail(err);
   }
 });
+var ssr = program.command("ssr").description("Manage server-rendered (SSR) hosting.");
+ssr.command("enable").argument("[project]", "project id, slug, or name").option("--start-command <cmd>", 'Node start command for the server (e.g. "next start")').description("Switch a web project to server-rendered hosting (paid).").action(async (projectRef, opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  p3.intro(lockup("ssr"));
+  const outcome = await upgradeToSsr(c, project, opts.startCommand ?? null);
+  if (outcome === "enabled") {
+    p3.outro(`Server rendering is on. Run ${brand.violet(`gzero deploy ${project.slug}`)} to build it.`);
+  } else if (outcome === "checkout") {
+    p3.outro(`Complete payment in your browser, then run ${brand.violet(`gzero deploy ${project.slug}`)}.`);
+  } else {
+    p3.outro("Server rendering is not available on your account.");
+  }
+});
+ssr.command("disable").argument("[project]", "project id, slug, or name").description("Switch a server-rendered project back to static hosting.").action(async (projectRef, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  const s = p3.spinner();
+  s.start("Switching to static hosting");
+  try {
+    await c.disableSsr(project.id);
+    s.stop(`${symbol.ok} ${brand.violet(project.name)} is now a static site.`);
+  } catch (err) {
+    s.stop("Could not disable server rendering");
+    fail(err);
+  }
+});
 var env = program.command("env").description("Manage project environment variables.");
 env.command("list").argument("[project]", "project id, slug, or name").description("List env var keys for a project.").action(async (projectRef, _opts, command) => {
   const c = await client(flags(command));

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "gzero-cli",
-  "version": "0.1.0-preview.2",
+  "version": "0.2.0",
   "description": "GroundZero command-line interface: deploy UIs and APIs, manage env, domains, and billing.",
-  "license": "SEE LICENSE IN LICENSE",
+  "license": "LICENSE.md",
   "homepage": "https://gzer0.app/docs",
   "type": "module",
   "bin": {
-    "gzero": "dist/index.js"
+    "gzero": "dist/index.js",
+    "g0": "dist/index.js"
   },
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE.md"
   ],
   "publishConfig": {
-    "tag": "preview"
+    "tag": "latest"
   },
   "scripts": {
     "build": "tsup && chmod +x dist/index.js",