@lizard-build/cli 0.1.0 → 0.3.30

package/src/commands/domain.ts

@@ -0,0 +1,248 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import { getActiveService } from "../lib/resolve.js";
+import { success, isJSONMode, printJSON, table, isTTY } from "../lib/format.js";
+
+interface DomainResponse {
+  ok?: boolean;
+  hostname: string;
+  generated?: boolean;
+  verified?: boolean;
+  txtRecord?: string;
+  txtValue?: string;
+  cnameTarget?: string;
+}
+
+interface AppLite {
+  id: string;
+  name: string;
+  domain?: string | null;
+  containerPort?: number | null;
+}
+
+/**
+ * `lizard domain` — domain management.
+ *   bare         → if no domain, auto-generate one; otherwise show current
+ *   <hostname>   → attach a custom domain
+ *   delete <h>   → remove a domain
+ *   generate     → force-generate a fresh *.onlizard.com subdomain
+ */
+export function registerDomain(program: Command) {
+  const dom = program
+    .command("domain")
+    .alias("domains")
+    .argument("[hostname]", "Custom domain to attach (e.g. app.example.com)")
+    .description("Manage service domains")
+    .option("-s, --service <name>", "Service name or ID")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("--port <n>", "Port to expose", parseIntOption)
+    .action(async (hostname: string | undefined, opts, _cmd) => {
+      const projectId = await resolveProjectId(opts.project);
+      const service = await getActiveService(opts.service, projectId);
+
+      if (!hostname) {
+        // Bare `lizard domain` — show or auto-generate.
+        const appRow = await api
+          .get<AppLite>(`/api/apps/${service.id}`)
+          .catch(() => null);
+        const existing = appRow?.domain;
+
+        if (existing) {
+          if (isJSONMode()) {
+            printJSON({ hostname: existing, generated: false });
+          } else {
+            console.log(chalk.cyan(`https://${existing}`));
+            console.log(
+              chalk.dim(
+                `  Reference from other services: ${chalk.cyan(`\${{${service.name}.LIZARD_PUBLIC_DOMAIN}}`)}`,
+              ),
+            );
+          }
+          return;
+        }
+
+        const result = await api
+          .post<DomainResponse>(`/api/apps/${service.id}/domains`, { generate: true })
+          .catch((err: any) => {
+            if (err?.status === 404) {
+              throw new Error(
+                "Domain endpoint not yet implemented. The API needs " +
+                  "`POST /api/apps/{id}/domains` with body { generate: true }.",
+              );
+            }
+            throw err;
+          });
+
+        if (isJSONMode()) {
+          printJSON(result);
+        } else {
+          success(`Domain generated: ${chalk.cyan(`https://${result.hostname}`)}`);
+          console.log(
+            chalk.dim(
+              `  Reference from other services: ${chalk.cyan(`\${{${service.name}.LIZARD_PUBLIC_DOMAIN}}`)}`,
+            ),
+          );
+        }
+        return;
+      }
+
+      // Attach custom hostname
+      const result = await api
+        .post<DomainResponse>(`/api/apps/${service.id}/domains`, {
+          hostname,
+          port: opts.port,
+        })
+        .catch((err: any) => {
+          if (err?.status === 404) {
+            throw new Error(
+              "Domain endpoint not yet implemented. The API needs " +
+                "`POST /api/apps/{id}/domains` with body { hostname }.",
+            );
+          }
+          throw err;
+        });
+
+      if (isJSONMode()) {
+        printJSON(result);
+        return;
+      }
+
+      // Custom domain — print verification + DNS instructions
+      success(`Custom domain ${chalk.cyan(hostname)} registered (pending verification)`);
+      console.log();
+      console.log(chalk.bold("1) Verify ownership — add this TXT record at your DNS provider:"));
+      console.log(`     ${chalk.dim("Name: ")}${chalk.cyan(result.txtRecord || `_lizard-verify.${hostname}`)}`);
+      console.log(`     ${chalk.dim("Value:")} ${chalk.cyan(result.txtValue || "")}`);
+      console.log();
+      if (result.cnameTarget) {
+        console.log(chalk.bold("2) Point traffic — add this CNAME record:"));
+        console.log(`     ${chalk.dim("Name: ")}${chalk.cyan(hostname)}`);
+        console.log(`     ${chalk.dim("Value:")} ${chalk.cyan(result.cnameTarget)}`);
+        console.log(chalk.dim(`     (${result.cnameTarget} is a multi-A record across all load balancers — no IP to track.)`));
+        console.log();
+      }
+      console.log(chalk.bold("3) Once both records propagate, run:"));
+      console.log(`     ${chalk.cyan(`lizard domain verify ${hostname}`)}`);
+      console.log();
+      console.log(chalk.dim("HTTPS certificate will be issued automatically by Let's Encrypt on first request."));
+    });
+
+  // Subcommands intentionally don't redeclare -s/-p: Commander 14 binds a
+  // duplicate short flag to the parent, leaving the subcommand action with
+  // `opts.service === undefined`. Read parent values via optsWithGlobals().
+  dom
+    .command("generate")
+    .description("Generate a fresh *.onlizard.com subdomain")
+    .action(async (_opts, sub) => {
+      const opts = sub.optsWithGlobals();
+      const projectId = await resolveProjectId(opts.project);
+      const service = await getActiveService(opts.service, projectId);
+
+      const result = await api
+        .post<DomainResponse>(`/api/apps/${service.id}/domains`, { generate: true })
+        .catch((err: any) => {
+          if (err?.status === 404) {
+            throw new Error(
+              "Domain endpoint not yet implemented. The API needs " +
+                "`POST /api/apps/{id}/domains` with body { generate: true }.",
+            );
+          }
+          throw err;
+        });
+
+      if (isJSONMode()) {
+        printJSON(result);
+      } else {
+        success(`Domain generated: ${chalk.cyan(`https://${result.hostname}`)}`);
+        console.log(
+          chalk.dim(
+            `  Reference from other services: ${chalk.cyan(`\${{${service.name}.LIZARD_PUBLIC_DOMAIN}}`)}`,
+          ),
+        );
+      }
+    });
+
+  dom
+    .command("verify")
+    .argument("<hostname>", "Custom domain to verify")
+    .description("Check the TXT record and activate the domain")
+    .action(async (hostname: string, _opts, sub) => {
+      const opts = sub.optsWithGlobals();
+      const projectId = await resolveProjectId(opts.project);
+      const service = await getActiveService(opts.service, projectId);
+
+      const result = await api
+        .post<{ ok: boolean; verified: boolean; hostname?: string; message?: string }>(
+          `/api/apps/${service.id}/domains/verify`,
+          { hostname },
+        )
+        .catch((err: any) => {
+          if (err?.status === 404) {
+            throw new Error(
+              `No pending verification for ${hostname}. Run \`lizard domain ${hostname}\` first.`,
+            );
+          }
+          throw err;
+        });
+
+      if (isJSONMode()) {
+        printJSON(result);
+        return;
+      }
+
+      if (result.verified) {
+        success(`Domain ${chalk.cyan(hostname)} verified and active`);
+        console.log(chalk.dim(`https://${hostname} — TLS issues on first HTTPS request.`));
+      } else {
+        console.log(chalk.yellow(`Not verified yet.`));
+        if (result.message) console.log(chalk.dim(`  ${result.message}`));
+      }
+    });
+
+  dom
+    .command("delete")
+    .alias("rm")
+    .argument("<hostname>", "Domain to remove")
+    .description("Remove a domain")
+    .option("-y, --yes", "Skip confirmation")
+    .action(async (hostname: string, _opts, sub) => {
+      const opts = sub.optsWithGlobals();
+      const projectId = await resolveProjectId(opts.project);
+      const service = await getActiveService(opts.service, projectId);
+
+      if (!opts.yes) {
+        if (!isTTY()) throw new Error("Use -y to confirm in non-interactive mode");
+        const confirm = await p.confirm({
+          message: `Remove domain ${chalk.bold(hostname)} from ${chalk.bold(service.name)}?`,
+        });
+        if (p.isCancel(confirm) || !confirm) process.exit(5);
+      }
+
+      await api
+        .delete(`/api/apps/${service.id}/domains/${encodeURIComponent(hostname)}`)
+        .catch((err: any) => {
+          if (err?.status === 404) {
+            throw new Error(
+              "Domain delete endpoint not yet implemented. The API needs " +
+                "`DELETE /api/apps/{id}/domains/{hostname}`.",
+            );
+          }
+          throw err;
+        });
+
+      if (isJSONMode()) {
+        printJSON({ domain: hostname, status: "deleted" });
+      } else {
+        success(`Domain ${chalk.cyan(hostname)} removed`);
+      }
+    });
+}
+
+function parseIntOption(v: string): number {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n)) throw new Error(`Invalid number: ${v}`);
+  return n;
+}

package/src/commands/git.ts

@@ -1,80 +1,241 @@
 import chalk from "chalk";
+import ora from "ora";
+import * as readline from "node:readline";
+import * as p from "@clack/prompts";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
-import { resolveProjectId } from "../lib/config.js";
-import { success, info, isJSONMode, printJSON } from "../lib/format.js";
+import { api, getBaseURL, streamSSE, withScope } from "../lib/api.js";
+import { openURL } from "../lib/auth.js";
+import { resolveProjectScope, resolveService } from "../lib/resolve.js";
+import { success, error, info, isJSONMode, printJSON, isTTY, link } from "../lib/format.js";
+
+interface GitHubInstallation {
+  id: number;
+  account: { login: string; type: string };
+  htmlUrl: string;
+  repoCount: number | null;
+  privateCount: number | null;
+}
+
+interface GitHubStatus {
+  installed: boolean;
+  installationId: number | null;
+  installations?: GitHubInstallation[];
+  manageUrl?: string;
+  error?: string;
+}
 
 export function registerGit(program: Command) {
   const git = program
     .command("git")
-    .description("Git integration");
+    .description("Git and GitHub integration");
 
+  // lizard git connect — install GitHub App for private repo access
   git
     .command("connect")
-    .argument("<repo>", "GitHub repository (user/repo)")
-    .description("Connect Git repository for auto-deploy")
-    .option("--branch <name>", "Branch for auto-deploy", "main")
-    .action(async (repo: string, opts) => {
-      const projectId = resolveProjectId(program.opts().project);
-
-      // This requires a server endpoint for programmatic webhook setup
-      // For now, guide the user to use the dashboard
-      if (isJSONMode()) {
-        printJSON({
-          error: "not_implemented",
-          message: "Git connect via CLI requires server endpoint. Use the dashboard.",
-        });
+    .description("Connect GitHub App to access private repositories")
+    .action(async () => {
+      // Check current status
+      const status = await api.get<GitHubStatus>("/api/github/status");
+
+      if (status.installed) {
+        if (isJSONMode()) {
+          printJSON({
+            installed: true,
+            installationId: status.installationId,
+            alreadyConnected: true,
+          });
+          return;
+        }
+        success("GitHub App is already connected.");
+        info(chalk.dim("  Use `lizard git status` to see connected repositories."));
+        return;
+      }
+
+      const installUrl = `${getBaseURL()}/api/auth/github/install`;
+
+      // Non-interactive callers (--json, piped) can't press Enter; return
+      // the install URL so they can drive the flow themselves and re-run.
+      if (isJSONMode() || !isTTY()) {
+        if (isJSONMode()) {
+          printJSON({ installed: false, installUrl });
+          return;
+        }
+        info(`Open this URL to connect GitHub:\n  ${chalk.cyan(installUrl)}`);
+        return;
+      }
+
+      const opened = await openURL(installUrl);
+      if (opened) {
+        info("Opening GitHub to install the Lizard GitHub App...");
       } else {
-        info(`To connect ${chalk.cyan(repo)} for auto-deploy:`);
-        info(`  1. Open your project on lizard.build`);
-        info(`  2. Go to Settings → Git Integration`);
-        info(`  3. Connect ${repo} (branch: ${opts.branch})`);
-        info("");
-        info(chalk.dim("CLI git connect will be available in a future update."));
+        info(`Open this URL to connect GitHub:\n  ${chalk.cyan(installUrl)}`);
+      }
+
+      // Wait for user to complete installation in browser
+      await pressEnter(chalk.dim("\nPress Enter after completing GitHub installation..."));
+
+      // Verify
+      const spinner = ora("Verifying GitHub connection...").start();
+      const newStatus = await api.get<GitHubStatus>("/api/github/status");
+      spinner.stop();
+
+      if (newStatus.installed) {
+        success("GitHub connected! You can now deploy private repositories.");
+        info(chalk.dim("  Run `lizard deploy` to deploy your project."));
+      } else {
+        error("GitHub App not detected. Please try again or connect via the dashboard.");
+        process.exit(1);
       }
     });
 
+  // lizard git checkout <service> <branch> — switch branch and redeploy
   git
-    .command("disconnect")
-    .description("Disconnect Git auto-deploy")
-    .action(async () => {
-      info(chalk.dim("Git disconnect via CLI will be available in a future update."));
+    .command("checkout")
+    .description("Switch a service to a different branch and redeploy")
+    .argument("<service>", "Service name (as shown in the project)")
+    .argument("<branch>", "Branch name to switch to")
+    .option("--detach", "Start redeploy and exit without streaming logs")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (serviceArg: string, branch: string, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+
+      // Resolve service by name
+      const svc = await resolveService(projectId, serviceArg);
+      if (svc.kind !== "app") throw new Error(`"${serviceArg}" is not an app`);
+      const serviceId = svc.id;
+      const serviceName = svc.name ?? serviceArg;
+
+      // Patch the branch
+      const spinner = ora(`Switching ${chalk.bold(serviceName)} to branch ${chalk.cyan(branch)}...`).start();
+      await api.post(withScope(`/api/projects/${projectId}/config:apply`, scope), {
+        services: [{ name: serviceName, branch }],
+      });
+      spinner.succeed(`Branch set to ${chalk.cyan(branch)}`);
+
+      // Trigger redeploy
+      const deploySpinner = ora("Starting redeploy...").start();
+      await api.post(withScope(`/api/apps/${serviceId}/redeploy`, scope));
+      deploySpinner.stop();
+
+      if (opts.detach || isJSONMode()) {
+        if (isJSONMode()) printJSON({ id: serviceId, branch, status: "deploying" });
+        else success(`Redeploy started on branch ${chalk.cyan(branch)}`);
+        return;
+      }
+
+      info(`Redeploying ${chalk.bold(serviceName)} on ${chalk.cyan(branch)}...`);
+
+      // Wait for build to appear
+      let buildId: string | null = null;
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 2000));
+        try {
+          const app = await api.get<{ builds?: Array<{ id: string; status: string }> }>(`/api/apps/${serviceId}`);
+          const latest = app.builds?.[0];
+          if (latest && ["building", "deploying", "running", "failed"].includes(latest.status)) {
+            buildId = latest.id;
+            break;
+          }
+        } catch {}
+      }
+
+      if (buildId) {
+        await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
+          if (event === "done" || event === "error") {
+            if (event === "error") error(`Build failed: ${data}`);
+            return false;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            process.stdout.write((typeof parsed === "string" ? parsed : (parsed.line ?? data)) + "\n");
+          } catch {
+            process.stdout.write(data + "\n");
+          }
+          return true;
+        });
+      }
+
+      const app = await api.get<{ status: string; domain?: string }>(`/api/apps/${serviceId}`);
+      if (app.status === "running") {
+        success(`Deployed! ${app.domain ? chalk.cyan(`https://${app.domain}`) : ""}`);
+      } else {
+        error("Deploy failed");
+      }
     });
 
+  // lizard git status
   git
     .command("status")
-    .description("Show Git integration status")
-    .action(async () => {
-      const projectId = resolveProjectId(program.opts().project);
+    .description("Show GitHub connection and repository status")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
 
-      // Get apps to check for repo info
-      const services = await api.get<{ apps: any[] }>(
-        `/api/projects/${projectId}/services`,
-      );
+      const [githubStatus, services] = await Promise.all([
+        api.get<GitHubStatus>("/api/github/status"),
+        api.get<{ apps: any[] }>(withScope(`/api/projects/${projectId}/services`, scope)),
+      ]);
 
-      const appsWithRepo = (services.apps || []).filter((a: any) => a.repo);
+      const appsWithRepo = (services.apps || []).filter((a: any) => a.repo || a.repoUrl);
 
       if (isJSONMode()) {
         printJSON({
-          connected: appsWithRepo.length > 0,
+          github: {
+            installed: githubStatus.installed,
+            installationId: githubStatus.installationId,
+            installations: githubStatus.installations ?? [],
+            manageUrl: githubStatus.manageUrl,
+          },
           apps: appsWithRepo.map((a: any) => ({
             name: a.name,
-            repo: a.repo,
+            repo: a.repo || a.repoUrl,
             branch: a.branch,
           })),
         });
         return;
       }
 
+      // GitHub App status
+      if (githubStatus.installed) {
+        info(`GitHub App: ${chalk.green("connected")}`);
+        const installs = githubStatus.installations ?? [];
+        for (const inst of installs) {
+          const typeLabel = inst.account.type === "Organization" ? "org" : "user";
+          const repoLabel = inst.repoCount !== null
+            ? chalk.dim(`${inst.repoCount} repos${inst.privateCount ? `, ${inst.privateCount} private` : ""}`)
+            : "";
+          info(`  ${chalk.bold(inst.account.login)} ${chalk.dim(`(${typeLabel}, installation #${inst.id})`)}  ${repoLabel}`);
+        }
+        const manageUrl = githubStatus.manageUrl ?? `https://github.com/apps/lizard-app/installations/select_target`;
+        info(chalk.dim(`  Manage: ${link(manageUrl)}`));
+      } else {
+        info(`GitHub App: ${chalk.yellow("not connected")}  ${chalk.dim("→ run `lizard git connect`")}`);
+        if (githubStatus.error) {
+          info(chalk.dim(`  (${githubStatus.error})`));
+        }
+      }
+
+      // Connected repos
       if (appsWithRepo.length === 0) {
-        console.log("No Git repositories connected.");
+        info(chalk.dim("\nNo repositories connected to this project."));
         return;
       }
 
+      info("");
       for (const app of appsWithRepo) {
-        console.log(
-          `${chalk.bold(app.name)}: ${chalk.cyan(app.repo)} (${app.branch || "main"})`,
+        info(
+          `${chalk.bold(app.name)}: ${chalk.cyan(app.repo || app.repoUrl)} ${chalk.dim(`(${app.branch || "main"})`)}`,
         );
       }
     });
 }
+
+function pressEnter(question: string): Promise<void> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, () => {
+      rl.close();
+      resolve();
+    });
+  });
+}