@lizard-build/cli 0.1.0 → 0.3.29

package/src/commands/up.ts

@@ -0,0 +1,461 @@
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import { execSync, spawn } from "child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { api, streamSSE, getBaseURL, type ResourceScope } from "../lib/api.js";
+import { updateProjectLink, DEFAULT_REGION } from "../lib/config.js";
+import { resolveContext, getScope } from "../lib/resolve.js";
+import { ensureLinked } from "./init.js";
+import {
+  success,
+  info,
+  error,
+  isJSONMode,
+  isTTY,
+  printJSON,
+  statusColor,
+} from "../lib/format.js";
+
+interface App {
+  id: string;
+  name: string;
+  status: string;
+  domain?: string;
+  repoUrl?: string;
+  branch?: string;
+  sourceType?: string;
+  builds?: Array<{ id: string; status: string }>;
+}
+
+/**
+ * Builds the `up` command:
+ *   - upload local code (or `[path]`) as a tarball
+ *   - target a service via --service / linked / first-in-project
+ *   - --ci streams build logs only and exits when build finishes
+ *   - --detach returns immediately after upload
+ */
+export function registerUp(program: Command) {
+  const up = program
+    .command("up")
+    .description("Upload and deploy code to Lizard")
+    .argument("[path]", "Path to deploy (default: current directory)")
+    .option("-d, --detach", "Don't attach to the log stream")
+    .option("-c, --ci", "Stream build logs only, exit on completion")
+    .option("-s, --service <name>", "Service to deploy to (defaults to linked)")
+    .option("--no-gitignore", "Don't ignore paths from .gitignore")
+    .option("--region <code>", "Region to create the service in (new services only)")
+    .option("--build-command <cmd>", "Build command to run (e.g. 'npm run build')")
+    .option("--start-command <cmd>", "Start command to run (e.g. 'node dist/index.js')")
+    .option("--pre-deploy-command <cmd>", "Pre-deploy command (e.g. 'node dist/migrate.js')")
+    .option("--port <number>", "Container port (default: 3000)")
+    .action(async (pathArg: string | undefined, opts, cmd) => {
+      const merged = cmd.optsWithGlobals();
+      const serviceFlag = merged.service ?? opts.service;
+      const projectFlag = merged.project;
+      const region: string | undefined = opts.region;
+
+      // Run init flow if cwd isn't linked yet
+      await ensureLinked({ projectName: projectFlag });
+
+      // Resolve target service: --service flag → linked → first-in-project → prompt-or-fail
+      const ctx = await resolveContext({
+        projectFlag,
+        serviceFlag,
+      });
+      const projectId = ctx.projectId;
+      const scope = getScope(ctx);
+
+      const targetPath = pathArg ? path.resolve(pathArg) : process.cwd();
+
+      // `up` always uploads a local tarball. For redeploy of an existing
+      // build without re-uploading, use `lizard redeploy`.
+      await deployFromLocal({
+        projectId,
+        scope,
+        targetPath,
+        useGitignore: opts.gitignore !== false,
+        serviceFlag,
+        existingServiceId: ctx.service?.id,
+        region,
+        buildCommand: opts.buildCommand,
+        startCommand: opts.startCommand,
+        preDeployCommand: opts.preDeployCommand,
+        port: opts.port ? parseInt(opts.port, 10) : undefined,
+        opts,
+      });
+    });
+
+  // `lizard up status <id>` — show build/deploy status
+  up
+    .command("status")
+    .argument("<id>", "App or deploy ID")
+    .description("Show deployment status")
+    .action(async (id: string) => {
+      const app = await api.get<App>(`/api/apps/${id}`);
+      if (isJSONMode()) {
+        printJSON(app);
+        return;
+      }
+      console.log(`${chalk.bold(app.name)}  ${statusColor(app.status)}`);
+      if (app.domain) console.log(`  URL: ${chalk.cyan(`https://${app.domain}`)}`);
+      if (app.builds?.length)
+        console.log(`  Latest build: ${statusColor(app.builds[0].status)}`);
+    });
+}
+
+// ── deploy strategies ────────────────────────────────────────────────────────
+
+async function deployFromLocal(args: {
+  projectId: string;
+  scope: ResourceScope;
+  targetPath: string;
+  buildCommand?: string;
+  startCommand?: string;
+  preDeployCommand?: string;
+  port?: number;
+  useGitignore: boolean;
+  serviceFlag: string | undefined;
+  existingServiceId: string | undefined;
+  region: string | undefined;
+  opts: any;
+}) {
+  const defaultName = args.serviceFlag || getDefaultAppName(args.targetPath);
+  info(
+    `${args.existingServiceId ? "Uploading" : "Creating service from"} ${chalk.dim(args.targetPath)}`,
+  );
+
+  let appName = args.serviceFlag || defaultName;
+  if (!args.existingServiceId && !args.serviceFlag && isTTY()) {
+    const nameInput = await prompt(`Service name [${defaultName}]: `);
+    appName = nameInput || defaultName;
+  }
+
+  const files = getUploadFiles(args.targetPath, args.useGitignore);
+  if (files.length === 0) {
+    throw new Error(
+      "No files to upload. Run from a directory with files, or pass a path: `lizard up <path>`.",
+    );
+  }
+  info(chalk.dim(`  ${files.length} files selected`));
+
+  const detectedPort = args.port === undefined ? detectLocalPort(args.targetPath) : undefined;
+  if (detectedPort) info(`Detected port ${chalk.bold(detectedPort)} from Dockerfile`);
+
+  const tarball = await createTarball(files, args.targetPath);
+  info(chalk.dim(`  Tarball: ${(tarball.length / 1024 / 1024).toFixed(1)} MB`));
+
+  const spinner = ora("Uploading...").start();
+  let newApp: App & { buildId?: string };
+  try {
+    const resolvedPort = args.port ?? detectedPort;
+    const qs = new URLSearchParams();
+    // Only send port when explicitly given or detected — lets server keep the stored
+    // containerPort on redeploy instead of overwriting it with the 3000 default.
+    if (resolvedPort !== undefined) qs.set("port", String(resolvedPort));
+    if (!args.existingServiceId) {
+      qs.set("name", appName);
+      if (args.region) qs.set("region", args.region);
+      // New services with no detected port default to 3000
+      if (resolvedPort === undefined) qs.set("port", "3000");
+    }
+    if (args.existingServiceId) qs.set("appId", args.existingServiceId);
+    if (args.buildCommand) qs.set("buildCommand", args.buildCommand);
+    if (args.startCommand) qs.set("startCommand", args.startCommand);
+    if (args.preDeployCommand) qs.set("preDeployCommand", args.preDeployCommand);
+    if (args.scope.workspaceId) qs.set("workspaceId", args.scope.workspaceId);
+
+    const url = `${getBaseURL()}/api/projects/${args.projectId}/apps/upload?${qs.toString()}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        Authorization: `Bearer ${(await import("../lib/auth.js")).getToken()}`,
+      },
+      body: tarball.buffer as ArrayBuffer,
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(
+        `Upload failed (${res.status}): ${text || res.statusText}`,
+      );
+    }
+    newApp = (await res.json()) as App & { buildId?: string };
+    spinner.succeed(`Service ${chalk.bold(newApp.name)} ${args.existingServiceId ? "updated" : "created"}`);
+  } catch (err: any) {
+    spinner.fail("Upload failed");
+    throw err;
+  }
+
+  saveServiceToConfig(args.projectId, newApp.id, newApp.name);
+
+  if (args.opts.detach) {
+    isJSONMode()
+      ? printJSON({ appId: newApp.id, version: 1, status: "deploying" })
+      : success(`Deploy started  ${chalk.dim(`lizard up status ${newApp.id}`)}`);
+    return;
+  }
+  await streamBuildLogs(newApp.id, args.opts.ci);
+}
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function saveServiceToConfig(_projectId: string, serviceId: string, serviceName: string) {
+  try {
+    updateProjectLink({ serviceId, serviceName });
+  } catch {}
+}
+
+function getDefaultAppName(cwd: string = process.cwd()): string {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+    if (pkg.name) return pkg.name.replace(/^@[^/]+\//, "");
+  } catch {}
+  return path.basename(cwd);
+}
+
+function getUploadFiles(cwd: string, useGitignore: boolean): string[] {
+  if (useGitignore) {
+    try {
+      // `-z` outputs NUL-separated paths and disables git's default behaviour
+      // of double-quoting names with unusual characters. Without it, a file
+      // called `weird\nname.txt` would either get quoted (and never matched
+      // by tar) or split the listing across newlines.
+      const tracked = execSync("git ls-files -z", {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+      })
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean);
+      const untracked = execSync("git ls-files --others --exclude-standard -z", {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+      })
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean);
+      return [...new Set([...tracked, ...untracked])];
+    } catch {
+      // fall through to manual collection
+    }
+  }
+  return collectFilesManually(cwd, cwd);
+}
+
+const EXCLUDE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  "build",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".cache",
+  "coverage",
+  ".turbo",
+  ".vercel",
+]);
+const EXCLUDE_EXT = new Set([".pyc", ".pyo", ".log", ".DS_Store"]);
+
+function collectFilesManually(root: string, dir: string): string[] {
+  const results: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (EXCLUDE_DIRS.has(entry.name)) continue;
+    if (EXCLUDE_EXT.has(path.extname(entry.name))) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) results.push(...collectFilesManually(root, full));
+    else results.push(path.relative(root, full));
+  }
+  return results;
+}
+
+function createTarball(files: string[], cwd: string): Promise<Uint8Array> {
+  return new Promise((resolve, reject) => {
+    const chunks: Uint8Array[] = [];
+    // `--null` makes tar read NUL-separated paths from stdin, matching what
+    // `git ls-files -z` writes. Newline-separated input would split filenames
+    // containing `\n` across multiple entries. Both bsdtar (macOS) and GNU
+    // tar accept `--null` before `-T -`.
+    const tar = spawn("tar", ["--null", "-czf", "-", "-T", "-"], { cwd });
+    tar.stdout.on("data", (c: Buffer) => chunks.push(c));
+    tar.stderr.on("data", () => {});
+    tar.on("close", (code: number) => {
+      if (code === 0) {
+        const total = chunks.reduce((n, c) => n + c.length, 0);
+        const out = new Uint8Array(total);
+        let off = 0;
+        for (const c of chunks) {
+          out.set(c, off);
+          off += c.length;
+        }
+        resolve(out);
+      } else {
+        reject(new Error(`tar exited ${code}`));
+      }
+    });
+    if (files.length > 0) tar.stdin.write(files.join("\0") + "\0");
+    tar.stdin.end();
+  });
+}
+
+function detectLocalPort(dir: string): number | undefined {
+  for (const name of ["Dockerfile", "dockerfile", "Dockerfile.production"]) {
+    try {
+      const text = fs.readFileSync(path.join(dir, name), "utf8");
+      const match = text.match(/^EXPOSE\s+(\d+)/m);
+      if (match) return parseInt(match[1], 10);
+    } catch {}
+  }
+  return undefined;
+}
+
+function prompt(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function streamBuildLogs(appId: string, ciMode: boolean = false) {
+  const spinner = ora("Waiting for build...").start();
+  let buildId: string | null = null;
+  for (let i = 0; i < 30; i++) {
+    await sleep(2000);
+    try {
+      const app = await api.get<App>(`/api/apps/${appId}`);
+      if (app.builds?.length) {
+        const latest = app.builds[0];
+        if (["building", "deploying", "running", "failed"].includes(latest.status)) {
+          buildId = latest.id;
+          break;
+        }
+      }
+    } catch {}
+  }
+  spinner.stop();
+  if (!buildId) {
+    info(chalk.dim("No build found. Check `lizard up status <id>`."));
+    return;
+  }
+  info(chalk.dim("Streaming build logs...\n"));
+
+  // Stream with auto-reconnect — connections can drop mid-build (Cloudflare
+  // idle timeout, network blips). Reconnect until the build itself reports
+  // a terminal status, with a hard cap so we don't loop forever.
+  const deadline = Date.now() + 15 * 60 * 1000; // 15 min max
+  while (Date.now() < deadline) {
+    let dropped = false;
+    try {
+      await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
+        if (event === "done" || event === "error") {
+          if (event === "error") emitBuildError(data);
+          else emitBuildDone();
+          return false;
+        }
+        emitBuildLine(data);
+        return true;
+      });
+    } catch {
+      dropped = true;
+    }
+
+    // Whether we got a clean SSE end or a dropped connection, check the
+    // build state — terminal status means we stop reconnecting.
+    try {
+      const build = await api.get<{ status: string }>(`/api/builds/${buildId}`);
+      if (build.status === "done" || build.status === "failed") break;
+    } catch {}
+
+    if (!dropped) break; // clean SSE end — don't reconnect
+    await sleep(2000);
+  }
+
+  if (ciMode) return;
+
+  const app = await api.get<App>(`/api/apps/${appId}`);
+  if (app.status === "running") {
+    if (isJSONMode()) {
+      process.stdout.write(
+        JSON.stringify({
+          event: "deployed",
+          status: "running",
+          url: app.domain ? `https://${app.domain}` : null,
+        }) + "\n",
+      );
+    } else {
+      success(`Deployed! ${app.domain ? chalk.cyan(`https://${app.domain}`) : ""}`);
+    }
+  } else if (app.status === "failed") {
+    if (isJSONMode()) {
+      process.stdout.write(
+        JSON.stringify({ event: "failed", status: "failed" }) + "\n",
+      );
+    } else {
+      error("Deploy failed. Check logs with `lizard logs --build`");
+    }
+  } else if (app.status === "deploying") {
+    if (isJSONMode()) {
+      process.stdout.write(
+        JSON.stringify({ event: "deploying", status: "deploying" }) + "\n",
+      );
+    } else {
+      info(chalk.dim("Still deploying... check status with `lizard ps`"));
+    }
+  }
+}
+
+// ── build stream emitters ────────────────────────────────────────────────────
+
+function emitBuildLine(data: string) {
+  let parsed: any;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    parsed = { line: data };
+  }
+  if (typeof parsed === "string") parsed = { line: parsed };
+  const line = parsed.line ?? parsed.message ?? "";
+
+  if (isJSONMode()) {
+    process.stdout.write(
+      JSON.stringify({ event: "log", line, ...stripLine(parsed) }) + "\n",
+    );
+    return;
+  }
+  if (line) process.stdout.write(line + "\n");
+  else process.stdout.write(data + "\n");
+}
+
+function stripLine(obj: any): Record<string, unknown> {
+  const { line: _l, message: _m, ...rest } = obj;
+  return rest;
+}
+
+function emitBuildDone() {
+  if (isJSONMode()) {
+    process.stdout.write(JSON.stringify({ event: "done" }) + "\n");
+  } else {
+    success("Build complete");
+  }
+}
+
+function emitBuildError(data: string) {
+  if (isJSONMode()) {
+    process.stdout.write(
+      JSON.stringify({ event: "error", message: data }) + "\n",
+    );
+  } else {
+    error(`Build failed: ${data}`);
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,87 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { info, success, isJSONMode, printJSON } from "../lib/format.js";
+import { CURRENT_VERSION, getLatestVersion, selfUpdate } from "../lib/updater.js";
+
+export function registerUpgrade(program: Command) {
+  program
+    .command("upgrade")
+    .description("Upgrade Lizard CLI to latest version")
+    .option("--check", "Only check for updates without installing")
+    .action(async (opts) => {
+      const result = await getLatestVersion();
+
+      if (result.kind === "rate-limited") {
+        if (isJSONMode()) {
+          printJSON({
+            currentVersion: CURRENT_VERSION,
+            error: { code: "rate_limited", resetAt: result.resetAt },
+          });
+          return;
+        }
+        const eta =
+          result.resetAt > 0
+            ? ` Try again in ~${Math.max(1, Math.ceil((result.resetAt * 1000 - Date.now()) / 60_000))} min.`
+            : "";
+        info(`GitHub API rate-limited (60 req/h per IP).${eta}`);
+        return;
+      }
+
+      if (result.kind === "error") {
+        if (isJSONMode()) {
+          printJSON({
+            currentVersion: CURRENT_VERSION,
+            error: { code: "check_failed" },
+          });
+          return;
+        }
+        info("Could not check for updates. Check your internet connection.");
+        return;
+      }
+
+      const latest = result.version;
+      const updateAvailable = latest !== CURRENT_VERSION;
+
+      if (isJSONMode() && opts.check) {
+        printJSON({ currentVersion: CURRENT_VERSION, latestVersion: latest, updateAvailable });
+        return;
+      }
+
+      if (!updateAvailable) {
+        if (isJSONMode()) {
+          printJSON({
+            currentVersion: CURRENT_VERSION,
+            latestVersion: latest,
+            updateAvailable: false,
+            upgraded: false,
+          });
+          return;
+        }
+        info(`Already up to date (v${CURRENT_VERSION})`);
+        return;
+      }
+
+      if (opts.check) {
+        info(`Update available: v${CURRENT_VERSION} → ${chalk.green("v" + latest)}`);
+        info(chalk.dim(`Run \`lizard upgrade\` to install`));
+        return;
+      }
+
+      info(`Upgrading v${CURRENT_VERSION} → ${chalk.green("v" + latest)}...`);
+
+      try {
+        await selfUpdate((msg) => info(chalk.dim(msg)));
+        if (isJSONMode()) {
+          printJSON({
+            previousVersion: CURRENT_VERSION,
+            latestVersion: latest,
+            upgraded: true,
+          });
+        } else {
+          success(`Upgraded to v${latest}`);
+        }
+      } catch (e: any) {
+        throw new Error(`Upgrade failed: ${e.message}`);
+      }
+    });
+}

package/src/commands/whoami.ts

@@ -1,27 +1,55 @@
 import chalk from "chalk";
 import { Command } from "commander";
 import { api } from "../lib/api.js";
+import { getProjectLink } from "../lib/config.js";
 import { isJSONMode, printJSON } from "../lib/format.js";
 
 export function registerWhoami(program: Command) {
   program
     .command("whoami")
-    .description("Show current user")
+    .description("Show current user, active workspace, and linked project")
     .action(async () => {
       const user = await api.get<{
         id: string;
         username: string;
         avatarUrl?: string;
         hasGithubApp?: boolean;
+        activeWorkspaceId?: string | null;
+        activeWorkspaceName?: string | null;
+        defaultWorkspaceId?: string | null;
       }>("/api/auth/me");
 
+      const link = getProjectLink();
+      const project = link
+        ? {
+            id: link.projectId,
+            name: link.projectName,
+            workspaceId: link.workspaceId ?? null,
+            workspaceName: link.workspaceName ?? null,
+          }
+        : null;
+
       if (isJSONMode()) {
-        printJSON(user);
+        printJSON({ ...user, project });
+        return;
+      }
+
+      console.log(chalk.bold(user.username));
+      if (user.hasGithubApp) {
+        console.log(chalk.dim("GitHub App: connected"));
+      }
+      if (user.activeWorkspaceName) {
+        console.log(chalk.dim("Workspace: ") + user.activeWorkspaceName);
+      }
+
+      if (project) {
+        const label = project.name || project.id;
+        const wsTag = project.workspaceName ? chalk.dim(` (${project.workspaceName})`) : "";
+        console.log(chalk.dim("Project: ") + label + wsTag + chalk.dim(" (linked here)"));
       } else {
-        console.log(chalk.bold(user.username));
-        if (user.hasGithubApp) {
-          console.log(chalk.dim("GitHub App: connected"));
-        }
+        console.log(
+          chalk.dim("Project: none — run `lizard init` in a project directory"),
+        );
       }
     });
 }

package/src/commands/workspace.ts

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { fetchWorkspaces } from "../lib/picker.js";
+import { isJSONMode, printJSON, table } from "../lib/format.js";
+
+/**
+ * `lizard workspace` — workspace info.
+ *
+ * Member management (invite/remove/rename) intentionally lives in the
+ * dashboard, not here, to keep CLI surface narrow (Railway model).
+ */
+export function registerWorkspace(program: Command) {
+  const ws = program
+    .command("workspace")
+    .description("Workspace info");
+
+  ws.command("list")
+    .alias("ls")
+    .description("List workspaces you belong to")
+    .action(async () => {
+      const list = await fetchWorkspaces();
+
+      if (isJSONMode()) {
+        printJSON(list);
+        return;
+      }
+
+      if (list.length === 0) {
+        console.log("No workspaces. The backend should always return a personal workspace.");
+        return;
+      }
+
+      table(
+        ["Name", "Slug", "Role", "Projects", "Personal"],
+        list.map((w) => [
+          w.name,
+          w.slug,
+          w.role,
+          String(w.projectCount ?? 0),
+          w.isPersonal ? chalk.green("✓") : "",
+        ]),
+      );
+    });
+}