gzero-cli 0.1.0-preview.1 → 0.1.0

package/dist/index.js

@@ -25,15 +25,185 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../sdk/dist/index.js
+// ../shared/dist/deploy-readiness.js
+var require_deploy_readiness = __commonJS({
+  "../shared/dist/deploy-readiness.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.evaluateDeployReadiness = evaluateDeployReadiness;
+    function evaluateDeployReadiness(input) {
+      const blockers = [];
+      const warnings = [];
+      if (!input.framework || input.framework === "unknown") {
+        blockers.push({
+          id: "framework",
+          level: "error",
+          message: "Could not detect a supported framework",
+          recommendation: "Use Vite, Astro (static), Next.js static export, or plain HTML."
+        });
+      }
+      if (!input.buildCommand && input.framework !== "plain-html") {
+        blockers.push({
+          id: "build",
+          level: "error",
+          message: "No build command configured",
+          recommendation: 'Add a "build" script to package.json or run scan again.'
+        });
+      }
+      if (!input.outputDir && input.framework !== "plain-html") {
+        blockers.push({
+          id: "output",
+          level: "error",
+          message: "No output directory configured",
+          recommendation: "Run scan again to detect the build output folder."
+        });
+      }
+      if (input.secretsFound) {
+        warnings.push({
+          id: "secrets",
+          level: "warning",
+          message: "An env file looks committed to your repo",
+          recommendation: "We never read it: app settings are injected at build time. For safety, remove it from the repo and add it to .gitignore."
+        });
+      }
+      for (const envVar of input.requiredEnvVars) {
+        if (!input.configuredEnvKeys.includes(envVar)) {
+          warnings.push({
+            id: `env-${envVar}`,
+            level: "warning",
+            message: `${envVar} is not set yet`,
+            recommendation: `Paste your .env to add ${envVar}, or deploy now and add it later.`
+          });
+        }
+      }
+      if (input.checks) {
+        for (const check of input.checks) {
+          if (check.id.startsWith("env-"))
+            continue;
+          const isFrameworkConfigError = check.id === "framework-config" && check.level === "error";
+          if (check.level !== "warning" && !isFrameworkConfigError)
+            continue;
+          warnings.push({
+            id: check.id,
+            level: "warning",
+            message: check.message,
+            recommendation: check.recommendation
+          });
+        }
+      }
+      return {
+        canDeploy: blockers.length === 0,
+        blockers,
+        warnings,
+        technicalNotes: input.technicalNotes ?? []
+      };
+    }
+  }
+});
+
+// ../shared/dist/index.js
 var require_dist = __commonJS({
+  "../shared/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PLAN_LIMITS = exports.PLAN_LIMITS_FALLBACK = exports.API_RUNTIME_UNAVAILABLE_MESSAGE = exports.API_RUNTIME_AVAILABLE = exports.evaluateDeployReadiness = void 0;
+    exports.parseDotEnv = parseDotEnv2;
+    function parseDotEnv2(raw) {
+      const entries = [];
+      const indexByKey = /* @__PURE__ */ new Map();
+      for (const rawLine of raw.split(/\r?\n/)) {
+        let line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+          continue;
+        if (line.startsWith("export "))
+          line = line.slice("export ".length).trim();
+        const eq = line.indexOf("=");
+        if (eq === -1)
+          continue;
+        const key = line.slice(0, eq).trim();
+        if (!key)
+          continue;
+        let value = line.slice(eq + 1).trim();
+        const quoted = value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"));
+        if (quoted) {
+          value = value.slice(1, -1);
+        } else {
+          const inlineComment = value.indexOf(" #");
+          if (inlineComment !== -1)
+            value = value.slice(0, inlineComment).trim();
+        }
+        const existing = indexByKey.get(key);
+        if (existing !== void 0) {
+          entries[existing] = { key, value };
+        } else {
+          indexByKey.set(key, entries.length);
+          entries.push({ key, value });
+        }
+      }
+      return entries;
+    }
+    var deploy_readiness_1 = require_deploy_readiness();
+    Object.defineProperty(exports, "evaluateDeployReadiness", { enumerable: true, get: function() {
+      return deploy_readiness_1.evaluateDeployReadiness;
+    } });
+    exports.API_RUNTIME_AVAILABLE = true;
+    exports.API_RUNTIME_UNAVAILABLE_MESSAGE = "API runtime is coming soon. ExpressoTS backend deploy is not available yet.";
+    exports.PLAN_LIMITS_FALLBACK = {
+      trial: {
+        maxStacks: 3,
+        maxBuilds: null,
+        buildsPeriod: "trial_lifetime",
+        maxBandwidthBytes: 5368709120,
+        maxCustomDomains: 0,
+        trialDurationDays: null,
+        stacksLabel: "3 preview sites",
+        buildsLabel: "Unlimited preview deploys",
+        trafficLabel: "About 2,500 visits per site",
+        domainsLabel: null,
+        planSummary: "3 free preview sites on a GroundZero URL. Go live with your own domain anytime."
+      },
+      solo: {
+        maxStacks: 3,
+        maxBuilds: null,
+        buildsPeriod: "billing_month",
+        maxBandwidthBytes: 53687091200,
+        maxCustomDomains: 1,
+        trialDurationDays: null,
+        stacksLabel: "Up to 3 products",
+        buildsLabel: "Unlimited deploys (fair use)",
+        trafficLabel: "About 25,000 visits per month",
+        domainsLabel: "Your own domain with SSL",
+        planSummary: "Go live with your own domain, SSL, and rollback. First product included; add more for $3/mo."
+      }
+    };
+    exports.PLAN_LIMITS = {
+      trial: {
+        apps: exports.PLAN_LIMITS_FALLBACK.trial.maxStacks,
+        buildsPerMonth: exports.PLAN_LIMITS_FALLBACK.trial.maxBuilds,
+        bandwidthGb: 5,
+        customDomains: 0,
+        previewExpiryDays: null
+      },
+      solo: {
+        apps: exports.PLAN_LIMITS_FALLBACK.solo.maxStacks,
+        buildsPerMonth: exports.PLAN_LIMITS_FALLBACK.solo.maxBuilds,
+        bandwidthGb: 50,
+        customDomains: 1,
+        previewExpiryDays: null
+      }
+    };
+  }
+});
+
+// ../sdk/dist/index.js
+var require_dist2 = __commonJS({
   "../sdk/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.GzeroApiError = exports.DEFAULT_BASE_URL = void 0;
-    exports.createClient = createClient2;
+    exports.parseDotEnv = exports.GzeroApiError = exports.DEFAULT_BASE_URL = void 0;
+    exports.createClient = createClient3;
     exports.DEFAULT_BASE_URL = "https://api.gzer0.app";
-    var GzeroApiError2 = class extends Error {
+    var GzeroApiError3 = class extends Error {
       status;
       code;
       constructor(message, status, code) {
@@ -43,12 +213,12 @@ var require_dist = __commonJS({
         this.name = "GzeroApiError";
       }
     };
-    exports.GzeroApiError = GzeroApiError2;
+    exports.GzeroApiError = GzeroApiError3;
     function normalizeBaseUrl(raw) {
       const value = (raw ?? exports.DEFAULT_BASE_URL).trim().replace(/\/+$/, "");
       return value.endsWith("/api") ? value.slice(0, -"/api".length) : value;
     }
-    function createClient2(options = {}) {
+    function createClient3(options = {}) {
       const baseUrl = normalizeBaseUrl(options.baseUrl);
       const doFetch = options.fetch ?? globalThis.fetch;
       let token = options.token;
@@ -66,7 +236,7 @@ var require_dist = __commonJS({
         if (!res.ok) {
           const body = await res.json().catch(() => ({}));
           const detail = body.blockers?.map((b) => b.message).join("; ");
-          throw new GzeroApiError2(detail ?? body.error ?? `API ${res.status}: ${path}`, res.status, body.error);
+          throw new GzeroApiError3(detail ?? body.error ?? `API ${res.status}: ${path}`, res.status, body.error);
         }
         if (res.status === 204)
           return void 0;
@@ -125,6 +295,11 @@ var require_dist = __commonJS({
           method: "POST",
           body: JSON.stringify({ name, description })
         }),
+        /** Attach an ExpressoTS API service to a product. Mirrors the web dashboard's API flow. */
+        addApiService: (productId, input) => request(`/products/${productId}/services/api`, {
+          method: "POST",
+          body: JSON.stringify(input)
+        }),
         // --- Projects ---
         listProjects: () => request("/projects"),
         getProjectStatus: (projectId) => request(`/projects/${projectId}/status`),
@@ -186,15 +361,19 @@ var require_dist = __commonJS({
         listInvoices: () => request("/billing/invoices")
       };
     }
+    var shared_1 = require_dist();
+    Object.defineProperty(exports, "parseDotEnv", { enumerable: true, get: function() {
+      return shared_1.parseDotEnv;
+    } });
   }
 });
 
 // src/index.ts
-var import_sdk = __toESM(require_dist(), 1);
-import { spawn } from "child_process";
+var import_sdk3 = __toESM(require_dist2(), 1);
+import { readFile as readFile2 } from "fs/promises";
 import { Command } from "commander";
-import * as p from "@clack/prompts";
-import pc from "picocolors";
+import * as p3 from "@clack/prompts";
+import pc4 from "picocolors";
 
 // src/config.ts
 import { homedir } from "os";
@@ -239,7 +418,82 @@ async function resolveSettings(flags2) {
   };
 }
 
-// src/index.ts
+// src/theme.ts
+import pc from "picocolors";
+var enabled = pc.isColorSupported;
+var DEEP = [91, 75, 224];
+var VIOLET = [124, 111, 240];
+var BRIGHT = [165, 148, 255];
+function fg([r, g, b]) {
+  if (!enabled) return (s) => s;
+  const prefix = `\x1B[38;2;${r};${g};${b}m`;
+  return (s) => `${prefix}${s}\x1B[39m`;
+}
+var deep = fg(DEEP);
+var violet = fg(VIOLET);
+var bright = fg(BRIGHT);
+function lerp(a, b, t) {
+  return Math.round(a + (b - a) * t);
+}
+function gradient(text2, from = VIOLET, to = BRIGHT) {
+  if (!enabled) return text2;
+  const chars = [...text2];
+  const last = Math.max(chars.length - 1, 1);
+  const painted = chars.map((ch, i) => {
+    const t = i / last;
+    const r = lerp(from[0], to[0], t);
+    const g = lerp(from[1], to[1], t);
+    const b = lerp(from[2], to[2], t);
+    return `\x1B[38;2;${r};${g};${b}m${ch}`;
+  }).join("");
+  return `${painted}\x1B[39m`;
+}
+var brand = {
+  deep,
+  violet,
+  bright,
+  /** The wordmark, always gradient + bold. */
+  word: () => pc.bold(gradient("GroundZero"))
+};
+var symbol = {
+  ok: pc.green("\u2713"),
+  err: pc.red("\u2717"),
+  warn: pc.yellow("\u25B2"),
+  info: violet("\u203A"),
+  dot: bright("\u2022"),
+  bullet: violet("\u25C6")
+};
+function markLines() {
+  return [
+    `     ${bright("\u257B")}`,
+    `  ${violet("\u256D\u2500\u256F \u2570\u2500\u256E")}`,
+    `  ${violet("\u2502     \u2502")}`,
+    `  ${violet("\u2570\u2500\u2500\u2500\u2500\u2500\u256F")}`
+  ];
+}
+function banner(version) {
+  const v = version ? pc.dim(`v${version}`) : "";
+  const rows = markLines();
+  const right = [
+    "",
+    `${brand.word()}  ${v}`,
+    pc.dim("Deploy UIs & APIs from your terminal or an AI agent."),
+    pc.dim("gzer0.app")
+  ];
+  const lines = rows.map((left, i) => `${left}   ${right[i] ?? ""}`.trimEnd());
+  return `
+${lines.join("\n")}
+`;
+}
+function lockup(label) {
+  return `${bright("\u23FB")} ${brand.word()} ${pc.dim(label)}`;
+}
+
+// src/util.ts
+var import_sdk = __toESM(require_dist2(), 1);
+import { spawn } from "child_process";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
 function openBrowser(url) {
   const platform = process.platform;
   const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
@@ -255,6 +509,10 @@ function die(message) {
   p.cancel(message);
   process.exit(1);
 }
+function fail(err) {
+  if (err instanceof import_sdk.GzeroApiError) die(err.message);
+  die(err instanceof Error ? err.message : String(err));
+}
 async function client(flags2, requireAuth = true) {
   const settings = await resolveSettings(flags2);
   if (requireAuth && !settings.token) {
@@ -262,9 +520,12 @@ async function client(flags2, requireAuth = true) {
   }
   return (0, import_sdk.createClient)({ baseUrl: settings.baseUrl, token: settings.token });
 }
-function fail(err) {
-  if (err instanceof import_sdk.GzeroApiError) die(err.message);
-  die(err instanceof Error ? err.message : String(err));
+function statusColor(status) {
+  if (status === "live") return pc2.green(status);
+  if (status === "failed") return pc2.red(status);
+  if (status === "building" || status === "deploying" || status === "pending")
+    return pc2.yellow(status);
+  return pc2.dim(status);
 }
 async function resolveProject(c, ref) {
   let projects;
@@ -273,7 +534,7 @@ async function resolveProject(c, ref) {
   } catch (err) {
     fail(err);
   }
-  if (projects.length === 0) die("No projects yet. Create one in the dashboard, then deploy.");
+  if (projects.length === 0) die("No projects yet. Run `gzero init` to create one.");
   if (ref) {
     const match = projects.find(
       (proj) => proj.id === ref || proj.slug === ref || proj.name === ref
@@ -286,24 +547,313 @@ async function resolveProject(c, ref) {
     message: "Select a project",
     options: projects.map((proj) => ({
       value: proj.id,
-      label: `${proj.name} ${pc.dim(`(${proj.slug})`)}`
+      label: `${proj.name} ${pc2.dim(`(${proj.slug})`)}`
     }))
   });
   if (p.isCancel(picked)) die("Cancelled.");
   return projects.find((proj) => proj.id === picked);
 }
+
+// src/create.ts
+var import_sdk2 = __toESM(require_dist2(), 1);
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+var MANUAL = "__manual__";
+var CREATE_PRODUCT = "__create__";
+var REPO_ROOT = ".";
+function guard(value) {
+  if (p2.isCancel(value)) die("Cancelled.");
+  return value;
+}
+async function pickRepo(c) {
+  const s = p2.spinner();
+  s.start("Loading your GitHub repositories");
+  let repos;
+  try {
+    ({ repos } = await c.listRepos());
+  } catch (err) {
+    s.stop("Failed to load repositories");
+    fail(err);
+  }
+  s.stop(`Found ${repos.length} repositor${repos.length === 1 ? "y" : "ies"}`);
+  let choice = MANUAL;
+  if (repos.length === 0) {
+    p2.note("No repositories found. Push your code to GitHub, then run this again.", "GitHub");
+  } else {
+    const options = repos.slice(0, 100).map((r) => ({ value: r.fullName, label: r.fullName, hint: r.private ? "private" : void 0 }));
+    options.push({ value: MANUAL, label: pc3.dim("Enter a repository manually") });
+    choice = guard(
+      await p2.select({ message: "Select a GitHub repository", options, maxItems: 12 })
+    );
+  }
+  if (choice === MANUAL) {
+    const entered = guard(
+      await p2.text({
+        message: "Repository (owner/repo)",
+        placeholder: "acme/my-app",
+        validate: (v) => /^[^/\s]+\/[^/\s]+$/.test(v.trim()) ? void 0 : "Use the owner/repo format."
+      })
+    );
+    const full = entered.trim();
+    return { repoFullName: full, defaultBranch: repos.find((r) => r.fullName === full)?.defaultBranch ?? "main" };
+  }
+  return { repoFullName: choice, defaultBranch: repos.find((r) => r.fullName === choice)?.defaultBranch ?? "main" };
+}
+async function pickProduct(c, defaultName) {
+  let products;
+  try {
+    products = await c.listProducts();
+  } catch (err) {
+    fail(err);
+  }
+  let productId = CREATE_PRODUCT;
+  if (products.length > 0) {
+    const options = [
+      { value: CREATE_PRODUCT, label: brand.violet("+ New product") },
+      ...products.map((prod) => ({ value: prod.id, label: `${prod.name} ${pc3.dim(`(${prod.slug})`)}` }))
+    ];
+    productId = guard(await p2.select({ message: "Attach to which product?", options }));
+  }
+  if (productId === CREATE_PRODUCT) {
+    const name = guard(
+      await p2.text({ message: "Product name", defaultValue: defaultName, placeholder: defaultName })
+    );
+    try {
+      const created = await c.createProduct((name || defaultName).trim());
+      return created.id;
+    } catch (err) {
+      fail(err);
+    }
+  }
+  return productId;
+}
+async function choosePath(scan, kind) {
+  const fallback = kind === "api" ? "apps/api" : "apps/web";
+  const candidates = scan.candidates ?? [];
+  if (candidates.length > 0) {
+    const options = candidates.map((cand) => ({
+      value: cand.scanPath,
+      label: `${cand.scanPath === REPO_ROOT ? "repo root" : cand.scanPath} ${pc3.dim(`(${cand.label})`)}`
+    }));
+    options.push({ value: REPO_ROOT, label: "Repo root (.)" });
+    options.push({ value: MANUAL, label: pc3.dim("Enter a path manually") });
+    const picked = guard(
+      await p2.select({
+        message: `Which folder holds your ${kind === "api" ? "API" : "app"}?`,
+        options
+      })
+    );
+    if (picked !== MANUAL) return picked;
+  }
+  const entered = guard(
+    await p2.text({
+      message: "Folder path (relative to repo root)",
+      placeholder: fallback,
+      defaultValue: scan.scanPath && scan.scanPath !== REPO_ROOT ? scan.scanPath : fallback
+    })
+  );
+  return entered.trim() || REPO_ROOT;
+}
+async function scanWithPath(c, repoFullName, branch, kind) {
+  let scanPath;
+  for (; ; ) {
+    const s = p2.spinner();
+    s.start(`Scanning ${repoFullName}${scanPath ? ` at ${scanPath}` : ""}`);
+    let result;
+    try {
+      result = await c.scanRepo({ repoFullName, branch, scanPath, scanKind: kind });
+    } catch (err) {
+      s.stop("Scan failed");
+      fail(err);
+    }
+    s.stop("Repository scanned");
+    if (result.needsPathSelection && !scanPath) {
+      scanPath = await choosePath(result, kind);
+      continue;
+    }
+    return result;
+  }
+}
+function scanSummary(scan, repoFullName, branch) {
+  const lines = [
+    `${pc3.dim("repo")}       ${repoFullName}`,
+    `${pc3.dim("branch")}     ${branch}`,
+    `${pc3.dim("framework")}  ${scan.framework}`
+  ];
+  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.requiredEnvVars.length > 0)
+    lines.push(`${pc3.dim("env vars")}   ${scan.requiredEnvVars.join(", ")}`);
+  return lines.join("\n");
+}
+async function interactiveCreate(c, opts = {}) {
+  let repoFullName;
+  let defaultBranch;
+  if (opts.repo) {
+    repoFullName = opts.repo;
+    defaultBranch = "main";
+  } else {
+    ({ repoFullName, defaultBranch } = await pickRepo(c));
+  }
+  let kind = guard(
+    await p2.select({
+      message: "What are you deploying?",
+      options: [
+        { value: "web", label: "Web app", hint: "static site (React, Vue, Astro, Svelte, ...)" },
+        { value: "api", label: "API", hint: "ExpressoTS backend" }
+      ]
+    })
+  );
+  const defaultName = repoFullName.split("/")[1] ?? repoFullName;
+  const productId = await pickProduct(c, defaultName);
+  let scan = await scanWithPath(c, repoFullName, defaultBranch, kind);
+  if (kind === "web" && scan.apiRepoDetected) {
+    const switchToApi = guard(
+      await p2.confirm({
+        message: "This looks like an API repo, not a web app. Deploy it as an API instead?",
+        initialValue: true
+      })
+    );
+    if (switchToApi) {
+      kind = "api";
+      scan = await scanWithPath(c, repoFullName, defaultBranch, "api");
+    }
+  }
+  p2.note(scanSummary(scan, repoFullName, defaultBranch), "Detected configuration");
+  const s = p2.spinner();
+  s.start(kind === "api" ? "Creating API service" : "Creating project");
+  let project;
+  try {
+    if (kind === "api") {
+      project = await c.addApiService(productId, {
+        repoFullName,
+        framework: scan.framework,
+        scanPath: scan.scanPath ?? REPO_ROOT,
+        buildCommand: scan.buildCommand,
+        outputDir: scan.outputDir,
+        defaultBranch
+      });
+    } else {
+      project = await c.createProject({
+        repoFullName,
+        productId,
+        defaultBranch,
+        framework: scan.framework,
+        scanPath: scan.scanPath ?? REPO_ROOT,
+        buildCommand: scan.buildCommand,
+        outputDir: scan.outputDir,
+        spaFallback: scan.spaFallback,
+        requiredEnvVars: scan.requiredEnvVars,
+        secretsFound: scan.secretsFound
+      });
+    }
+  } catch (err) {
+    s.stop("Create failed");
+    fail(err);
+  }
+  s.stop(`${symbol.ok} Created ${brand.violet(project.name)} ${pc3.dim(`(${project.slug})`)}`);
+  return { project, scan };
+}
+async function deployProject(c, project, opts = {}) {
+  const s = p2.spinner();
+  s.start(`Deploying ${project.name}`);
+  let deploy;
+  try {
+    deploy = await c.deploy(project.id, {
+      acknowledgeWarnings: Boolean(opts.yes),
+      branch: opts.branch,
+      environment: opts.env
+    });
+  } catch (err) {
+    s.stop("Deploy failed to start");
+    if (err instanceof import_sdk2.GzeroApiError) {
+      die(`${err.message}
+${pc3.dim("Re-run with --yes to acknowledge warnings.")}`);
+    }
+    fail(err);
+  }
+  if (opts.follow === false) {
+    s.stop(`Deploy queued (${deploy.id}).`);
+    return;
+  }
+  const terminal = /* @__PURE__ */ new Set(["live", "failed", "rolled_back"]);
+  const deadline = Date.now() + 15 * 60 * 1e3;
+  let current = deploy;
+  while (!terminal.has(current.status) && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 3e3));
+    try {
+      current = await c.getDeploy(deploy.id);
+    } catch {
+    }
+    s.message(`${project.name}: ${current.phase ?? current.status}`);
+  }
+  if (current.status === "live") {
+    s.stop(`${symbol.ok} ${pc3.green("Live")}  ${pc3.cyan(current.url ?? project.slug)}`);
+  } else if (current.status === "failed") {
+    s.stop(`${symbol.err} ${pc3.red("Deploy failed")}`);
+    if (current.buildLog) console.log(pc3.dim(current.buildLog.slice(-2e3)));
+    process.exit(1);
+  } else {
+    s.stop(`${symbol.warn} Deploy status: ${current.status}`);
+  }
+}
+async function offerDeploy(c, project, opts) {
+  let hardBlockers = [];
+  try {
+    const readiness = await c.getReadiness(project.id);
+    hardBlockers = readiness.blockers.filter((b) => !b.id.startsWith("env-"));
+    const envIssues = [...readiness.blockers, ...readiness.warnings].filter(
+      (i) => i.id.startsWith("env-")
+    );
+    if (envIssues.length > 0) {
+      p2.note(
+        envIssues.map((i) => `${symbol.warn} ${i.message}`).join("\n") + `
+
+${pc3.dim("Set them with")} gzero env set ${project.slug} KEY value`,
+        "Environment variables"
+      );
+    }
+  } catch {
+  }
+  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}`)}.`);
+    return;
+  }
+  let doDeploy = true;
+  if (opts.prompt) {
+    doDeploy = guard(await p2.confirm({ message: "Deploy now?", initialValue: true }));
+  }
+  if (!doDeploy) {
+    p2.outro(`Run ${brand.violet(`gzero deploy ${project.slug}`)} when you're ready.`);
+    return;
+  }
+  await deployProject(c, project, { yes: true });
+  p2.outro("Done.");
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
 var program = new Command();
-program.name("gzero").description("GroundZero: deploy UIs and APIs from the terminal or an AI agent.").version("0.1.0-preview.1").option("--api-url <url>", "API base URL (default: config or GZERO_API_URL)").option("--token <token>", "API token (default: config or GZERO_TOKEN)");
+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),
+  styleCommandText: (s) => brand.violet(s),
+  styleOptionTerm: (s) => pc4.cyan(s),
+  styleSubcommandTerm: (s) => brand.violet(s)
+}).addHelpText("beforeAll", () => banner(VERSION)).addHelpText("after", () => `
+${pc4.dim("Docs:")} ${pc4.underline("https://gzer0.app/docs")}
+`).showHelpAfterError(pc4.dim("(run `gzero --help` for usage)"));
 function flags(command) {
   return command.optsWithGlobals();
 }
 program.command("login").description("Sign in via the browser (device-code flow) and save an API token.").action(async (_opts, command) => {
   const gf = flags(command);
-  p.intro(pc.bgCyan(pc.black(" GroundZero login ")));
+  p3.intro(lockup("login"));
   const settings = await resolveSettings(gf);
-  const baseUrl = settings.baseUrl ?? import_sdk.DEFAULT_BASE_URL;
-  const c = (0, import_sdk.createClient)({ baseUrl });
-  const s = p.spinner();
+  const baseUrl = settings.baseUrl ?? import_sdk3.DEFAULT_BASE_URL;
+  const c = (0, import_sdk3.createClient)({ baseUrl });
+  const s = p3.spinner();
   s.start("Requesting device code");
   let start;
   try {
@@ -313,15 +863,15 @@ program.command("login").description("Sign in via the browser (device-code flow)
     fail(err);
   }
   s.stop("Device code ready");
-  p.note(
-    `${pc.bold("Your code:")} ${pc.cyan(start.user_code)}
+  p3.note(
+    `${pc4.bold("Your code:")} ${pc4.cyan(start.user_code)}
 
 Open this URL to authorize:
-${pc.underline(start.verification_uri_complete)}`,
+${pc4.underline(start.verification_uri_complete)}`,
     "Authorize this device"
   );
   openBrowser(start.verification_uri_complete);
-  const waiting = p.spinner();
+  const waiting = p3.spinner();
   waiting.start("Waiting for authorization in the browser");
   const deadline = Date.now() + start.expires_in * 1e3;
   let intervalMs = Math.max(start.interval, 1) * 1e3;
@@ -350,33 +900,35 @@ ${pc.underline(start.verification_uri_complete)}`,
   waiting.stop("Authorized");
   await saveConfig({ baseUrl, token });
   c.setToken(token);
-  p.note(pc.dim(configPath()), "Credentials saved to");
+  p3.note(pc4.dim(configPath()), "Credentials saved to");
   try {
     const me = await c.me();
-    p.outro(`Signed in as ${pc.green(me.githubLogin ?? me.name ?? "your account")}.`);
+    p3.outro(`${symbol.ok} Signed in as ${brand.violet(me.githubLogin ?? me.name ?? "your account")}.`);
   } catch {
-    p.outro("Signed in.");
+    p3.outro(`${symbol.ok} Signed in.`);
   }
 });
 program.command("logout").description("Revoke the current token and remove local credentials.").action(async (_opts, command) => {
   const gf = flags(command);
   const settings = await resolveSettings(gf);
   if (settings.token) {
-    const c = (0, import_sdk.createClient)({ baseUrl: settings.baseUrl, token: settings.token });
+    const c = (0, import_sdk3.createClient)({ baseUrl: settings.baseUrl, token: settings.token });
     try {
       await c.device.revoke();
     } catch {
     }
   }
   await clearConfig();
-  p.outro("Signed out.");
+  p3.outro(`${symbol.ok} Signed out.`);
 });
 program.command("whoami").description("Show the signed-in account.").action(async (_opts, command) => {
   const c = await client(flags(command));
   try {
     const me = await c.me();
-    console.log(`${pc.bold(me.githubLogin ?? me.name ?? me.id)}  ${pc.dim(me.email ?? "")}`);
-    console.log(pc.dim(`plan: ${me.plan}${me.isAdmin ? " (admin)" : ""}`));
+    console.log(
+      `${symbol.bullet} ${pc4.bold(me.githubLogin ?? me.name ?? me.id)}  ${pc4.dim(me.email ?? "")}`
+    );
+    console.log(`  ${pc4.dim(`plan: ${me.plan}${me.isAdmin ? " (admin)" : ""}`)}`);
   } catch (err) {
     fail(err);
   }
@@ -386,71 +938,53 @@ program.command("projects").alias("ls").description("List your projects.").actio
   try {
     const projects = await c.listProjects();
     if (projects.length === 0) {
-      console.log(pc.dim("No projects yet."));
+      console.log(pc4.dim("No projects yet. Run `gzero init` to create one."));
       return;
     }
+    const count = projects.length;
+    console.log(pc4.dim(`${count} project${count === 1 ? "" : "s"}
+`));
     for (const proj of projects) {
       const status = proj.activeDeployStatus ?? "-";
       const url = proj.activeDeployUrl ?? "";
       console.log(
-        `${pc.bold(proj.name)} ${pc.dim(`(${proj.slug})`)}  ${statusColor(status)}  ${pc.cyan(url)}`
+        `${symbol.bullet} ${pc4.bold(proj.name)} ${pc4.dim(`(${proj.slug})`)}  ${statusColor(status)}${url ? `  ${pc4.cyan(url)}` : ""}`
       );
     }
   } catch (err) {
     fail(err);
   }
 });
-function statusColor(status) {
-  if (status === "live") return pc.green(status);
-  if (status === "failed") return pc.red(status);
-  if (status === "building" || status === "deploying" || status === "pending")
-    return pc.yellow(status);
-  return pc.dim(status);
-}
+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) => {
+  const c = await client(flags(command));
+  p3.intro(lockup("init"));
+  const { project } = await interactiveCreate(c, { repo });
+  await offerDeploy(c, project, { prompt: true });
+});
 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) => {
   const c = await client(flags(command));
-  const project = await resolveProject(c, projectRef);
-  const s = p.spinner();
-  s.start(`Deploying ${project.name}`);
-  let deploy;
-  try {
-    deploy = await c.deploy(project.id, {
-      acknowledgeWarnings: Boolean(opts.yes),
-      branch: opts.branch,
-      environment: opts.env
-    });
-  } catch (err) {
-    s.stop("Deploy failed to start");
-    if (err instanceof import_sdk.GzeroApiError) {
-      die(`${err.message}
-${pc.dim("Re-run with --yes to acknowledge warnings.")}`);
-    }
-    fail(err);
-  }
-  if (opts.follow === false) {
-    s.stop(`Deploy queued (${deploy.id}).`);
-    return;
-  }
-  const terminal = /* @__PURE__ */ new Set(["live", "failed", "rolled_back"]);
-  const deadline = Date.now() + 15 * 60 * 1e3;
-  let current = deploy;
-  while (!terminal.has(current.status) && Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 3e3));
+  if (!projectRef) {
+    let projects;
     try {
-      current = await c.getDeploy(deploy.id);
-    } catch {
+      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 });
+      return;
     }
-    s.message(`${project.name}: ${current.phase ?? current.status}`);
-  }
-  if (current.status === "live") {
-    s.stop(pc.green(`Live: ${current.url ?? project.slug}`));
-  } else if (current.status === "failed") {
-    s.stop(pc.red("Deploy failed"));
-    if (current.buildLog) console.log(pc.dim(current.buildLog.slice(-2e3)));
-    process.exit(1);
-  } else {
-    s.stop(`Deploy status: ${current.status}`);
   }
+  const project = await resolveProject(c, projectRef);
+  await deployProject(c, project, {
+    yes: Boolean(opts.yes),
+    branch: opts.branch,
+    env: opts.env,
+    follow: opts.follow
+  });
 });
 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));
@@ -458,11 +992,11 @@ program.command("status").argument("[project]", "project id, slug, or name").des
   try {
     const status = await c.getProjectStatus(project.id);
     const active = status.activeDeploy;
-    console.log(pc.bold(project.name) + pc.dim(` (${project.slug})`));
-    console.log(`  status:   ${active ? statusColor(active.status) : pc.dim("no deploys")}`);
-    if (active?.url) console.log(`  url:      ${pc.cyan(active.url)}`);
-    console.log(`  env vars: ${status.envConfigured ? pc.green("configured") : pc.yellow("missing")}`);
-    console.log(`  ready:    ${status.readiness.canDeploy ? pc.green("yes") : pc.red("no")}`);
+    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(`  env vars: ${status.envConfigured ? pc4.green("configured") : pc4.yellow("missing")}`);
+    console.log(`  ready:    ${status.readiness.canDeploy ? pc4.green("yes") : pc4.red("no")}`);
   } catch (err) {
     fail(err);
   }
@@ -475,12 +1009,74 @@ program.command("logs").argument("[project]", "project id, slug, or name").descr
     const latest = deploys[0];
     if (!latest) die("No deploys yet.");
     const full = await c.getDeploy(latest.id);
-    console.log(pc.dim(`# ${project.name} deploy ${full.id} (${full.status})`));
-    console.log(full.buildLog ?? pc.dim("(no build log)"));
+    console.log(pc4.dim(`# ${project.name} deploy ${full.id} (${full.status})`));
+    console.log(full.buildLog ?? pc4.dim("(no build log)"));
   } catch (err) {
     fail(err);
   }
 });
+program.command("open").argument("[project]", "project id, slug, or name").description("Open the project's live URL in your browser.").action(async (projectRef, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  const url = project.activeDeployUrl;
+  if (!url) die("No live deploy to open. Run `gzero deploy` first.");
+  console.log(`${symbol.info} Opening ${pc4.cyan(url)}`);
+  openBrowser(url);
+});
+async function selectDeploy(c, projectId, opts) {
+  let deploys;
+  try {
+    deploys = await c.listDeploys(projectId);
+  } catch (err) {
+    fail(err);
+  }
+  const candidates = opts.filter ? deploys.filter(opts.filter) : deploys;
+  if (candidates.length === 0) die("No matching deploys.");
+  const picked = await p3.select({
+    message: opts.message,
+    options: candidates.slice(0, 20).map((d) => ({
+      value: d.id,
+      label: `${statusColor(d.status)} ${pc4.dim(d.environment)}  ${d.commitMessage?.split("\n")[0]?.slice(0, 48) ?? d.id}`,
+      hint: new Date(d.createdAt).toLocaleString()
+    }))
+  });
+  if (p3.isCancel(picked)) die("Cancelled.");
+  return picked;
+}
+program.command("rollback").argument("[project]", "project id, slug, or name").description("Roll back to a previous successful deploy.").action(async (projectRef, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  const deployId = await selectDeploy(c, project.id, {
+    message: "Roll back to which deploy?",
+    filter: (d) => d.status === "live" || d.status === "rolled_back"
+  });
+  const s = p3.spinner();
+  s.start("Rolling back");
+  try {
+    await c.rollback(project.id, deployId);
+    s.stop(`${symbol.ok} Rolled back ${brand.violet(project.name)}.`);
+  } catch (err) {
+    s.stop("Rollback failed");
+    fail(err);
+  }
+});
+program.command("promote").argument("[project]", "project id, slug, or name").description("Promote a deploy to production.").action(async (projectRef, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  const deployId = await selectDeploy(c, project.id, {
+    message: "Promote which deploy to production?",
+    filter: (d) => d.status === "live"
+  });
+  const s = p3.spinner();
+  s.start("Promoting");
+  try {
+    await c.promote(project.id, deployId);
+    s.stop(`${symbol.ok} Promoted ${brand.violet(project.name)} to production.`);
+  } catch (err) {
+    s.stop("Promote failed");
+    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));
@@ -488,11 +1084,11 @@ env.command("list").argument("[project]", "project id, slug, or name").descripti
   try {
     const vars = await c.listEnvVars(project.id);
     if (vars.length === 0) {
-      console.log(pc.dim("No env vars set."));
+      console.log(pc4.dim("No env vars set."));
       return;
     }
     for (const v of vars) {
-      console.log(`${v.key} ${v.configured ? pc.green("set") : pc.yellow("empty")}`);
+      console.log(`${v.key} ${v.configured ? pc4.green("set") : pc4.yellow("empty")}`);
     }
   } catch (err) {
     fail(err);
@@ -503,40 +1099,125 @@ env.command("set").argument("<project>", "project id, slug, or name").argument("
   const project = await resolveProject(c, projectRef);
   try {
     await c.upsertEnvVar(project.id, key, value);
-    p.outro(`Set ${pc.bold(key)} on ${project.name}.`);
+    p3.outro(`${symbol.ok} Set ${pc4.bold(key)} on ${brand.violet(project.name)}.`);
+  } catch (err) {
+    fail(err);
+  }
+});
+env.command("rm").alias("delete").argument("<project>", "project id, slug, or name").argument("<key>", "variable name").description("Delete an environment variable.").action(async (projectRef, key, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  try {
+    await c.deleteEnvVar(project.id, key);
+    p3.outro(`${symbol.ok} Removed ${pc4.bold(key)} from ${brand.violet(project.name)}.`);
+  } catch (err) {
+    fail(err);
+  }
+});
+env.command("import").argument("<project>", "project id, slug, or name").argument("<file>", "path to a .env file").description("Bulk-import environment variables from a .env file.").action(async (projectRef, file, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  let entries;
+  try {
+    entries = (0, import_sdk3.parseDotEnv)(await readFile2(file, "utf8"));
+  } catch (err) {
+    die(`Could not read ${file}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (entries.length === 0) die("No variables found in that file.");
+  try {
+    const result = await c.bulkUpsertEnvVars(project.id, entries);
+    const skipped = result.skipped.length > 0 ? ` ${pc4.dim(`(skipped ${result.skipped.length})`)}` : "";
+    p3.outro(`${symbol.ok} Imported ${pc4.bold(String(result.saved.length))} vars into ${brand.violet(project.name)}.${skipped}`);
   } catch (err) {
     fail(err);
   }
 });
 var domains = program.command("domains").description("Manage custom domains.");
+domains.command("list").argument("[project]", "project id, slug, or name").description("List custom domains for a project.").action(async (projectRef, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  try {
+    const list = await c.listDomains(project.id);
+    if (list.length === 0) {
+      console.log(pc4.dim("No custom domains."));
+      return;
+    }
+    for (const d of list) {
+      const state = d.verified ? pc4.green("verified") : pc4.yellow("pending");
+      console.log(`${symbol.bullet} ${pc4.bold(d.hostname)}  ${state}  ${pc4.dim(`ssl: ${d.sslStatus}`)}`);
+    }
+  } catch (err) {
+    fail(err);
+  }
+});
 domains.command("add").argument("<project>", "project id, slug, or name").argument("<hostname>", "custom domain, e.g. app.example.com").description("Attach a custom domain to a project.").action(async (projectRef, hostname, _opts, command) => {
   const c = await client(flags(command));
   const project = await resolveProject(c, projectRef);
   try {
     const domain = await c.addDomain(project.id, hostname);
-    p.outro(
-      `Added ${pc.bold(hostname)}. Point a CNAME to ${pc.cyan(domain.cnameTarget)}, then verify in the dashboard.`
+    p3.outro(
+      `${symbol.ok} Added ${pc4.bold(hostname)}. Point a CNAME to ${pc4.cyan(domain.cnameTarget)}, then run \`gzero domains verify\`.`
     );
   } catch (err) {
     fail(err);
   }
 });
+async function resolveDomainId(c, projectId, hostname) {
+  let list;
+  try {
+    list = await c.listDomains(projectId);
+  } catch (err) {
+    fail(err);
+  }
+  const match = list.find((d) => d.hostname === hostname);
+  if (!match) die(`No domain "${hostname}" on this project.`);
+  return match.id;
+}
+domains.command("verify").argument("<project>", "project id, slug, or name").argument("<hostname>", "custom domain to verify").description("Re-check DNS and verify a custom domain.").action(async (projectRef, hostname, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  const domainId = await resolveDomainId(c, project.id, hostname);
+  const s = p3.spinner();
+  s.start(`Verifying ${hostname}`);
+  try {
+    const domain = await c.verifyDomain(project.id, domainId);
+    if (domain.verified) {
+      s.stop(`${symbol.ok} ${pc4.bold(hostname)} verified ${pc4.dim(`(ssl: ${domain.sslStatus})`)}`);
+    } else {
+      s.stop(`${symbol.warn} ${pc4.bold(hostname)} not verified yet. Check the CNAME and try again.`);
+    }
+  } catch (err) {
+    s.stop("Verify failed");
+    fail(err);
+  }
+});
+domains.command("remove").alias("rm").argument("<project>", "project id, slug, or name").argument("<hostname>", "custom domain to remove").description("Remove a custom domain from a project.").action(async (projectRef, hostname, _opts, command) => {
+  const c = await client(flags(command));
+  const project = await resolveProject(c, projectRef);
+  const domainId = await resolveDomainId(c, project.id, hostname);
+  try {
+    await c.removeDomain(project.id, domainId);
+    p3.outro(`${symbol.ok} Removed ${pc4.bold(hostname)} from ${brand.violet(project.name)}.`);
+  } catch (err) {
+    fail(err);
+  }
+});
 var billing = program.command("billing").description("View plan and start payments.");
 billing.command("status", { isDefault: true }).description("Show current plan, usage, and available add-ons.").action(async (_opts, command) => {
   const c = await client(flags(command));
   try {
     const status = await c.getBillingStatus();
-    console.log(`${pc.bold("Plan:")} ${status.planDisplayName} ${pc.dim(`(${status.subscriptionStatus})`)}`);
-    console.log(`${pc.bold("Stacks:")} ${status.limits.stacksLabel}`);
-    console.log(`${pc.bold("Traffic:")} ${status.limits.trafficLabel}`);
+    console.log(`${symbol.bullet} ${pc4.bold("Plan:")} ${brand.violet(status.planDisplayName)} ${pc4.dim(`(${status.subscriptionStatus})`)}`);
+    console.log(`${pc4.bold("Stacks:")} ${status.limits.stacksLabel}`);
+    console.log(`${pc4.bold("Traffic:")} ${status.limits.trafficLabel}`);
     if (status.availableAddons.length > 0) {
-      console.log(pc.bold("\nAvailable add-ons:"));
+      console.log(pc4.bold("\nAvailable add-ons:"));
       for (const a of status.availableAddons) {
         console.log(
-          `  ${pc.cyan(a.id)}  ${a.displayName}  ${pc.dim(`$${(a.priceCents / 100).toFixed(2)}/mo`)}`
+          `  ${pc4.cyan(a.id)}  ${a.displayName}  ${pc4.dim(`$${(a.priceCents / 100).toFixed(2)}/mo`)}`
         );
       }
-      console.log(pc.dim("\nRun `gzero billing addon <id>` to purchase."));
+      console.log(pc4.dim("\nRun `gzero billing addon <id>` to purchase."));
     }
   } catch (err) {
     fail(err);
@@ -546,7 +1227,7 @@ billing.command("upgrade").description("Open Stripe checkout to subscribe to the
   const c = await client(flags(command));
   try {
     const { url } = await c.createCheckout();
-    p.note(pc.underline(url), "Complete payment in your browser");
+    p3.note(pc4.underline(url), "Complete payment in your browser");
     openBrowser(url);
   } catch (err) {
     fail(err);
@@ -556,7 +1237,7 @@ billing.command("addon").argument("<addonId>", "add-on id (see `gzero billing`)"
   const c = await client(flags(command));
   try {
     const { url } = await c.createAddonCheckout(addonId, opts.product);
-    p.note(pc.underline(url), "Complete payment in your browser");
+    p3.note(pc4.underline(url), "Complete payment in your browser");
     openBrowser(url);
   } catch (err) {
     fail(err);
@@ -566,7 +1247,7 @@ billing.command("portal").description("Open the Stripe billing portal to manage
   const c = await client(flags(command));
   try {
     const { url } = await c.createBillingPortal();
-    p.note(pc.underline(url), "Manage billing in your browser");
+    p3.note(pc4.underline(url), "Manage billing in your browser");
     openBrowser(url);
   } catch (err) {
     fail(err);
@@ -584,18 +1265,22 @@ function mcpEndpoint(baseUrl) {
 }
 program.command("mcp").description("Print config to connect an AI client to the hosted GroundZero MCP server.").action(async (_opts, command) => {
   const settings = await resolveSettings(flags(command));
-  const url = mcpEndpoint(settings.baseUrl ?? import_sdk.DEFAULT_BASE_URL);
+  const url = mcpEndpoint(settings.baseUrl ?? import_sdk3.DEFAULT_BASE_URL);
   const config = JSON.stringify({ mcpServers: { gzero: { url } } }, null, 2);
-  p.intro(pc.bgCyan(pc.black(" GroundZero MCP ")));
-  p.note(
-    `The MCP server is hosted at ${pc.cyan(url)}.
-Add it to your AI client (Cursor: ${pc.dim("~/.cursor/mcp.json")}) and it will
+  p3.intro(lockup("mcp"));
+  p3.note(
+    `The MCP server is hosted at ${pc4.cyan(url)}.
+Add it to your AI client (Cursor: ${pc4.dim("~/.cursor/mcp.json")}) and it will
 open a browser to sign in with GitHub the first time. Nothing to install.`,
     "Hosted MCP"
   );
-  p.note(config, "Client config");
-  p.outro("Paste the config above, then reload your AI client.");
+  p3.note(config, "Client config");
+  p3.outro("Paste the config above, then reload your AI client.");
 });
+if (process.argv.length <= 2) {
+  program.outputHelp();
+  process.exit(0);
+}
 program.parseAsync(process.argv).catch((err) => {
   fail(err);
 });