@lizard-build/cli 0.1.0 → 0.3.29

package/src/index.ts

@@ -1,126 +1,247 @@
 #!/usr/bin/env node
 
 import { Command } from "commander";
+import chalk from "chalk";
 import { setJSONMode, isJSONMode, error } from "./lib/format.js";
-import { setTokenOverride, requireAuth, isLoggedIn } from "./lib/auth.js";
-import { setBaseURL, setAccessToken } from "./lib/api.js";
+import { requireAuth, isLoggedIn } from "./lib/auth.js";
+import { setBaseURL, setAccessToken, APIError } from "./lib/api.js";
+import { checkForUpdateInBackground, CURRENT_VERSION } from "./lib/updater.js";
 
-// Commands
-import { registerLogin } from "./commands/login.js";
-import { registerLogout } from "./commands/logout.js";
-import { registerWhoami } from "./commands/whoami.js";
+const BANNER = chalk.rgb(16, 185, 129)(
+  [
+    "╔═══════════════════════════════════════════════════╗",
+    "║                                                   ║",
+    "║    ██╗     ██╗███████╗ █████╗ ██████╗ ██████╗     ║",
+    "║    ██║     ██║╚══███╔╝██╔══██╗██╔══██╗██╔══██╗    ║",
+    "║    ██║     ██║  ███╔╝ ███████║██████╔╝██║  ██║    ║",
+    "║    ██║     ██║ ███╔╝  ██╔══██║██╔══██╗██║  ██║    ║",
+    "║    ███████╗██║███████╗██║  ██║██║  ██║██████╔╝    ║",
+    "║    ╚══════╝╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═════╝     ║",
+    "║                                                   ║",
+    "╚═══════════════════════════════════════════════════╝",
+  ].join("\n"),
+);
+
+// Commands (alphabetical by command name)
+import { registerAdd } from "./commands/add.js";
+import { registerConfig } from "./commands/config.js";
+import { registerDocs } from "./commands/docs.js";
+import { registerDomain } from "./commands/domain.js";
+import { registerGit } from "./commands/git.js";
 import { registerInit } from "./commands/init.js";
 import { registerLink } from "./commands/link.js";
+import { registerLogin } from "./commands/login.js";
+import { registerLogout } from "./commands/logout.js";
+import { registerLogs } from "./commands/logs.js";
+import { registerOpen } from "./commands/open.js";
+import { registerPort } from "./commands/port.js";
 import { registerProjects } from "./commands/projects.js";
-import { registerDeploy } from "./commands/deploy.js";
 import { registerPs } from "./commands/ps.js";
-import { registerAdd } from "./commands/add.js";
-import { registerDestroy } from "./commands/destroy.js";
-import { registerRestart } from "./commands/restart.js";
 import { registerRedeploy } from "./commands/redeploy.js";
-import { registerLogs } from "./commands/logs.js";
-import { registerSecrets } from "./commands/secrets.js";
 import { registerRegions } from "./commands/regions.js";
-import { registerStatus } from "./commands/status.js";
-import { registerOpen } from "./commands/open.js";
+import { registerRestart } from "./commands/restart.js";
 import { registerRun } from "./commands/run.js";
-import { registerConnect } from "./commands/connect.js";
-import { registerContext } from "./commands/context.js";
-import { registerGit } from "./commands/git.js";
-import { registerVersion } from "./commands/version.js";
-import { registerUpdate } from "./commands/update.js";
+import { registerScale } from "./commands/scale.js";
+import { registerSecrets } from "./commands/secrets.js";
+import { registerService } from "./commands/service.js";
+import { registerSSH } from "./commands/ssh.js";
+import { registerStatus } from "./commands/status.js";
+import { registerUnlink } from "./commands/unlink.js";
+import { registerUp } from "./commands/up.js";
+import { registerUpgrade } from "./commands/upgrade.js";
+import { registerWhoami } from "./commands/whoami.js";
+import { registerWorkspace } from "./commands/workspace.js";
 
 const program = new Command();
 
 program
   .name("lizard")
   .description("Lizard CLI — deploy and manage apps on Lizard")
-  .version("0.1.0")
-  .option("--json", "Output in JSON format")
-  .option("-y, --yes", "Skip confirmation prompts")
-  .option("--workspace <id>", "Workspace name or ID")
-  .option("--project <id>", "Project ID")
-  .option("--environment <name>", "Environment name")
-  .option("--region <region>", "Region for creating services")
-  .option("--token <token>", "API token")
-  .option("--no-color", "Disable colors")
-  .option("--verbose", "Verbose output")
+  .version(CURRENT_VERSION)
+  .addHelpText("before", BANNER + "\n")
+  .configureHelp({
+    subcommandTerm: (cmd) => {
+      const alias = cmd.aliases()[0];
+      return alias ? `${cmd.name()}|${alias}` : cmd.name();
+    },
+  })
+  .option("--json", "Output in JSON format (combine with --help to dump machine-readable command schema for agents)")
   .hook("preAction", async (thisCommand, actionCommand) => {
     const opts = thisCommand.opts();
 
+    // Check for updates silently in background (shows notice after command)
+    if (actionCommand.name() !== "upgrade") {
+      checkForUpdateInBackground();
+    }
+
     // JSON mode: explicit flag or non-TTY stdout
     if (opts.json || !process.stdout.isTTY) {
       setJSONMode(true);
     }
 
-    // Token override
-    if (opts.token) {
-      setTokenOverride(opts.token);
-    }
-
     // API URL override
     if (process.env.LIZARD_API_URL) {
       setBaseURL(process.env.LIZARD_API_URL);
     }
 
-    // Commands that don't need auth
-    const noAuth = new Set(["login", "logout", "version", "completion", "update", "help"]);
-    if (noAuth.has(actionCommand.name())) return;
+    // Top-level commands that don't need auth. `status` prints the local link;
+    // the optional workspace backfill silently no-ops when not authed.
+    //
+    // Match by name AND parent — otherwise leaf subcommands sharing a name
+    // (e.g. `git status`, `up status`) skip the auto-login flow and would
+    // 401 instead of prompting the user to log in.
+    const noAuth = new Set(["login", "logout", "upgrade", "help", "docs", "status"]);
+    const isTopLevel = actionCommand.parent === thisCommand;
+    if (isTopLevel && noAuth.has(actionCommand.name())) return;
 
     // Require auth — auto-triggers login flow if not logged in
     const creds = await requireAuth();
     setAccessToken(creds.accessToken);
   });
 
-// Register all commands
-registerLogin(program);
-registerLogout(program);
-registerWhoami(program);
+// Register all commands (alphabetical)
+registerAdd(program);
+registerConfig(program);
+registerDocs(program);
+registerDomain(program);
+registerGit(program);
 registerInit(program);
 registerLink(program);
+registerLogin(program);
+registerLogout(program);
+registerLogs(program);
+registerOpen(program);
+registerPort(program);
 registerProjects(program);
-registerDeploy(program);
 registerPs(program);
-registerAdd(program);
-registerDestroy(program);
-registerRestart(program);
 registerRedeploy(program);
-registerLogs(program);
-registerSecrets(program);
 registerRegions(program);
-registerStatus(program);
-registerOpen(program);
+registerRestart(program);
 registerRun(program);
-registerConnect(program);
-registerContext(program);
-registerGit(program);
-registerVersion(program);
-registerUpdate(program);
-
-// Shell completion
-program
-  .command("completion")
-  .argument("<shell>", "Shell type (bash, zsh, fish)")
-  .description("Generate shell completion script")
-  .action((shell: string) => {
-    // Commander doesn't have built-in completion like Cobra
-    // Point users to manual setup
-    console.log(`# Add to your .${shell}rc:`);
-    if (shell === "bash") {
-      console.log(`eval "$(lizard completion bash)"`);
-    } else if (shell === "zsh") {
-      console.log(`# lizard completion is not yet available for zsh`);
-      console.log(`# Coming soon`);
-    } else if (shell === "fish") {
-      console.log(`# lizard completion is not yet available for fish`);
-      console.log(`# Coming soon`);
-    }
-  });
+registerScale(program);
+registerSecrets(program);
+registerService(program);
+registerSSH(program);
+registerStatus(program);
+registerUnlink(program);
+registerUp(program);
+registerUpgrade(program);
+registerWhoami(program);
+registerWorkspace(program);
 
 // Error handling
 program.exitOverride();
 
+const EXIT_CODES: Record<string, string> = {
+  "0": "success",
+  "1": "generic error",
+  "2": "auth (401/403)",
+  "3": "not found (404)",
+  "4": "timeout (408/504)",
+  "5": "cancelled by user",
+};
+
+function isHelpJsonRequest(argv: string[]): boolean {
+  const hasHelp = argv.some((a) => a === "--help" || a === "-h");
+  const hasJson = argv.some((a) => a === "--json");
+  return hasHelp && hasJson;
+}
+
+function collectValueFlags(cmd: Command, acc: Set<string>) {
+  for (const opt of cmd.options as any[]) {
+    if (opt.required || opt.optional) {
+      if (opt.short) acc.add(opt.short);
+      if (opt.long) acc.add(opt.long);
+    }
+  }
+  for (const sub of cmd.commands) collectValueFlags(sub, acc);
+}
+
+function findTargetCommand(argv: string[], root: Command): Command {
+  const valueFlags = new Set<string>();
+  collectValueFlags(root, valueFlags);
+
+  let cur: Command = root;
+  for (let i = 2; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "--help" || tok === "-h" || tok === "--json") continue;
+    if (tok.startsWith("-")) {
+      if (tok.includes("=")) continue;
+      if (valueFlags.has(tok) && i + 1 < argv.length) i++;
+      continue;
+    }
+    const sub = cur.commands.find(
+      (c) => c.name() === tok || c.aliases().includes(tok),
+    );
+    if (!sub) break;
+    cur = sub;
+  }
+  return cur;
+}
+
+function dumpOption(o: any) {
+  return {
+    flags: o.flags,
+    long: o.long ?? null,
+    short: o.short ?? null,
+    description: o.description ?? "",
+    takesValue: Boolean(o.required || o.optional),
+    valueRequired: Boolean(o.required),
+    defaultValue: o.defaultValue ?? null,
+    choices: o.argChoices ?? null,
+    negate: Boolean(o.negate),
+  };
+}
+
+function dumpCommand(cmd: Command): any {
+  const args = ((cmd as any).registeredArguments ?? []).map((a: any) => ({
+    name: a.name(),
+    description: a.description ?? "",
+    required: Boolean(a.required),
+    variadic: Boolean(a.variadic),
+    defaultValue: a.defaultValue ?? null,
+    choices: a.argChoices ?? null,
+  }));
+  return {
+    name: cmd.name(),
+    aliases: cmd.aliases(),
+    description: cmd.description(),
+    usage: cmd.usage(),
+    arguments: args,
+    options: (cmd.options as any[])
+      .filter((o) => !o.hidden)
+      .map(dumpOption),
+    subcommands: cmd.commands
+      .filter((c: any) => !c._hidden)
+      .map(dumpCommand),
+  };
+}
+
 async function main() {
+  // Set JSON mode from argv *before* parseAsync so the catch block below
+  // honors --json even when commander rejects before our preAction hook
+  // fires (e.g. unknown command, malformed global flag). Non-TTY auto-mode
+  // stays in preAction — `lizard --help | less` shouldn't suddenly emit JSON.
+  if (process.argv.includes("--json")) {
+    setJSONMode(true);
+  }
+
+  if (isHelpJsonRequest(process.argv)) {
+    const target = findTargetCommand(process.argv, program);
+    const isRoot = target === program;
+    const out = {
+      cli: "lizard",
+      version: CURRENT_VERSION,
+      command: dumpCommand(target),
+      globalOptions: isRoot
+        ? []
+        : (program.options as any[]).filter((o) => !o.hidden).map(dumpOption),
+      exitCodes: EXIT_CODES,
+    };
+    process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+    process.exit(0);
+  }
+
   try {
     await program.parseAsync(process.argv);
   } catch (err: any) {
@@ -133,14 +254,19 @@ async function main() {
     }
 
     const msg = err.message || String(err);
+    const apiErr = err instanceof APIError ? err : undefined;
+    const status = apiErr?.status;
+    const code = apiErr?.code || err.code || "ERROR";
 
     if (isJSONMode()) {
       console.log(
         JSON.stringify(
           {
             error: {
-              code: err.code || "ERROR",
+              code,
+              status: status ?? null,
               message: msg,
+              body: apiErr?.body ?? null,
             },
           },
           null,
@@ -151,16 +277,19 @@ async function main() {
       error(msg);
     }
 
-    // Exit codes per spec
-    if (msg.includes("Not authenticated") || msg.includes("Invalid token")) {
-      process.exit(2);
-    }
-    if (msg.includes("not found") || msg.includes("Not found")) {
-      process.exit(3);
-    }
-    if (msg.includes("timeout") || msg.includes("Timeout")) {
-      process.exit(4);
-    }
+    // Exit codes derived from APIError.status (or tagged error codes), not message text
+    const isAuth = status === 401 || status === 403 || code === "NOT_AUTHENTICATED";
+    const isNotFound = status === 404;
+    const isTimeout =
+      status === 408 ||
+      status === 504 ||
+      err.name === "AbortError" ||
+      err.code === "ETIMEDOUT" ||
+      err.code === "UND_ERR_CONNECT_TIMEOUT";
+
+    if (isAuth) process.exit(2);
+    if (isNotFound) process.exit(3);
+    if (isTimeout) process.exit(4);
     process.exit(1);
   }
 }

package/src/lib/api.ts

@@ -1,7 +1,10 @@
 import { getToken } from "./auth.js";
+import { CURRENT_VERSION } from "./updater.js";
+import * as https from "node:https";
+import * as http from "node:http";
 
 const DEFAULT_BASE_URL = "https://lizard.build";
-const USER_AGENT = "lizard-cli/0.1";
+const USER_AGENT = `lizard-cli/${CURRENT_VERSION}`;
 
 let baseURL = process.env.LIZARD_API_URL || DEFAULT_BASE_URL;
 let _accessToken: string | null = null;
@@ -10,13 +13,56 @@ export function setBaseURL(url: string) { baseURL = url; }
 export function getBaseURL() { return baseURL; }
 export function setAccessToken(token: string) { _accessToken = token; }
 
+// ── Scoping ───────────────────────────────────────────────────────────
+//
+// Every project-scoped endpoint takes `?workspaceId=…` — mirrors
+// lizard-client's `withScope` so server-side state is shared across
+// CLI and browser. Build URLs through these helpers, never by hand.
+
+export interface ResourceScope {
+  workspaceId?: string | null;
+}
+
+export interface Workspace {
+  id: string;
+  name: string;
+  slug: string;
+  role: "owner" | "member";
+  isPersonal?: boolean;
+  projectCount?: number;
+  createdAt?: number;
+}
+
+export function withQuery(
+  path: string,
+  params: Record<string, string | number | boolean | null | undefined>,
+): string {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === undefined || value === "") continue;
+    search.set(key, String(value));
+  }
+  const query = search.toString();
+  if (!query) return path;
+  return `${path}${path.includes("?") ? "&" : "?"}${query}`;
+}
+
+export function withScope(path: string, scope?: ResourceScope): string {
+  if (!scope) return path;
+  return withQuery(path, {
+    workspaceId: scope.workspaceId,
+  });
+}
+
 export class APIError extends Error {
   status: number;
   code: string;
-  constructor(status: number, message: string, code = "") {
+  body: unknown;
+  constructor(status: number, message: string, code = "", body: unknown = null) {
     super(message);
     this.status = status;
     this.code = code;
+    this.body = body;
   }
 }
 
@@ -32,12 +78,14 @@ async function request<T = any>(
   method: string,
   path: string,
   body?: unknown,
+  extraHeaders: Record<string, string> = {},
 ): Promise<T> {
   const url = baseURL + path;
   const token = _accessToken || getToken();
 
   const headers: Record<string, string> = {
     "User-Agent": USER_AGENT,
+    ...extraHeaders,
   };
   if (token) {
     headers["Authorization"] = `Bearer ${token}`;
@@ -55,12 +103,14 @@ async function request<T = any>(
   if (!res.ok) {
     let msg = res.statusText;
     let code = "";
+    let body: unknown = null;
     try {
       const j = (await res.json()) as any;
+      body = j;
       msg = j.error || j.message || msg;
       code = j.code || "";
     } catch {}
-    throw new APIError(res.status, msg, code);
+    throw new APIError(res.status, msg, code, body);
   }
 
   const text = await res.text();
@@ -70,8 +120,8 @@ async function request<T = any>(
 
 export const api = {
   get: <T = any>(path: string) => request<T>("GET", path),
-  post: <T = any>(path: string, body?: unknown) =>
-    request<T>("POST", path, body),
+  post: <T = any>(path: string, body?: unknown, headers?: Record<string, string>) =>
+    request<T>("POST", path, body, headers),
   put: <T = any>(path: string, body?: unknown) =>
     request<T>("PUT", path, body),
   patch: <T = any>(path: string, body?: unknown) =>
@@ -80,55 +130,68 @@ export const api = {
 };
 
 /** Stream SSE and call handler for each data line. Return false to stop. */
-export async function streamSSE(
+export function streamSSE(
   path: string,
   handler: (event: string, data: string) => boolean | void,
 ): Promise<void> {
-  const url = baseURL + path;
-  const token = _accessToken || getToken();
-  const headers: Record<string, string> = {
-    "User-Agent": USER_AGENT,
-    Accept: "text/event-stream",
-  };
-  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return new Promise((resolve, reject) => {
+    const url = new URL(baseURL + path);
+    const token = _accessToken || getToken();
+    const reqHeaders: Record<string, string> = {
+      "User-Agent": USER_AGENT,
+      Accept: "text/event-stream",
+    };
+    if (token) reqHeaders["Authorization"] = `Bearer ${token}`;
+
+    const transport = url.protocol === "https:" ? https : http;
+    const req = transport.request(
+      { hostname: url.hostname, port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: url.pathname + url.search, method: "GET", headers: reqHeaders },
+      (res) => {
+        if (res.statusCode && res.statusCode >= 400) {
+          let body = "";
+          res.on("data", (c: Buffer) => body += c.toString());
+          res.on("end", () => reject(new APIError(res.statusCode!, `SSE failed: ${body}`)));
+          return;
+        }
 
-  const res = await fetch(url, { headers });
-  if (!res.ok) {
-    throw new APIError(res.status, `SSE failed: ${res.statusText}`);
-  }
-  if (!res.body) return;
-
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let currentEvent = "";
-  let currentData = "";
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-
-    for (const line of lines) {
-      const trimmed = line.replace(/\r$/, "");
-      if (trimmed === "") {
-        if (currentData) {
-          const cont = handler(currentEvent, currentData);
-          if (cont === false) {
-            reader.cancel();
-            return;
+        let buffer = "";
+        let currentEvent = "";
+        let currentData = "";
+
+        res.setEncoding("utf8");
+        res.on("data", (chunk: string) => {
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+
+          for (const line of lines) {
+            const trimmed = line.replace(/\r$/, "");
+            if (trimmed === "") {
+              if (currentData) {
+                const cont = handler(currentEvent, currentData);
+                if (cont === false) {
+                  req.destroy();
+                  resolve();
+                  return;
+                }
+              }
+              currentEvent = "";
+              currentData = "";
+            } else if (trimmed.startsWith("event:")) {
+              currentEvent = trimmed.slice(6).trim();
+            } else if (trimmed.startsWith("data:")) {
+              currentData = trimmed.slice(5).trimStart();
+            }
           }
-        }
-        currentEvent = "";
-        currentData = "";
-      } else if (trimmed.startsWith("event:")) {
-        currentEvent = trimmed.slice(6).trim();
-      } else if (trimmed.startsWith("data:")) {
-        currentData = trimmed.slice(5).trimStart();
-      }
-    }
-  }
+        });
+
+        res.on("end", resolve);
+        res.on("error", reject);
+      },
+    );
+
+    req.on("error", reject);
+    req.end();
+  });
 }