@lizard-build/cli 0.1.0 → 0.3.30

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("✓") : "",
+        ]),
+      );
+    });
+}

package/src/index.ts

@@ -1,126 +1,252 @@
 #!/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 { registerSkill } from "./commands/skill.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.
+    //
+    // Walk up to the top-level ancestor so subcommands inherit (`skill list`
+    // matches via `skill`). Leaf names like `git status` don't false-positive
+    // because we check the ancestor's name, not the action's.
+    const noAuth = new Set(["login", "logout", "upgrade", "help", "docs", "status", "skill"]);
+    let topLevel: Command = actionCommand;
+    while (topLevel.parent && topLevel.parent !== thisCommand) {
+      topLevel = topLevel.parent;
+    }
+    if (noAuth.has(topLevel.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);
+registerSkill(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 +259,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 +282,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);
   }
 }