@lizard-build/cli 0.1.0

package/src/commands/regions.ts

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { isJSONMode, printJSON, table } from "../lib/format.js";
+
+interface Region {
+  id: string;
+  name: string;
+  code: string;
+  endpoint?: string;
+}
+
+export function registerRegions(program: Command) {
+  const region = program
+    .command("region")
+    .description("Region management");
+
+  region
+    .command("list")
+    .description("List available regions")
+    .action(async () => {
+      const regions = await api.get<Region[]>("/api/regions");
+
+      if (isJSONMode()) {
+        printJSON(regions);
+        return;
+      }
+
+      if (regions.length === 0) {
+        console.log("No regions available.");
+        return;
+      }
+
+      table(
+        ["Code", "Name"],
+        regions.map((r) => [r.code || r.id, r.name]),
+      );
+    });
+}

package/src/commands/restart.ts

@@ -0,0 +1,24 @@
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { success, isJSONMode, printJSON } from "../lib/format.js";
+
+export function registerRestart(program: Command) {
+  program
+    .command("restart")
+    .argument("<id>", "Service ID to restart")
+    .description("Restart a service")
+    .action(async (id: string) => {
+      const spinner = ora("Restarting...").start();
+
+      await api.post(`/api/apps/${id}/restart`);
+
+      spinner.stop();
+      if (isJSONMode()) {
+        printJSON({ id, status: "restarting" });
+      } else {
+        success(`Service ${id} restarting`);
+      }
+    });
+}

package/src/commands/run.ts

@@ -0,0 +1,43 @@
+import { execSync } from "node:child_process";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+
+interface Secret {
+  key: string;
+  value: string;
+}
+
+export function registerRun(program: Command) {
+  program
+    .command("run")
+    .argument("<command...>", "Command to run with project env vars")
+    .description("Run a command with project secrets as env vars")
+    .allowUnknownOption()
+    .action(async (args: string[]) => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // Fetch secrets
+      const secrets = await api.get<Secret[]>(
+        `/api/projects/${projectId}/secrets`,
+      );
+
+      // Build env
+      const env: Record<string, string> = { ...process.env as Record<string, string> };
+      for (const s of secrets) {
+        env[s.key] = s.value;
+      }
+
+      // Run command
+      const cmd = args.join(" ");
+      try {
+        execSync(cmd, {
+          env,
+          stdio: "inherit",
+          shell: process.env.SHELL || "/bin/sh",
+        });
+      } catch (err: any) {
+        process.exit(err.status || 1);
+      }
+    });
+}

package/src/commands/secrets.ts

@@ -0,0 +1,175 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import { success, isJSONMode, printJSON, table } from "../lib/format.js";
+
+interface Secret {
+  key: string;
+  value: string;
+}
+
+export function registerSecrets(program: Command) {
+  const secret = program
+    .command("secret")
+    .description("Manage project secrets");
+
+  secret
+    .command("list")
+    .description("List project secrets")
+    .option("--show", "Reveal secret values")
+    .action(async (opts) => {
+      const projectId = resolveProjectId(program.opts().project);
+      const secrets = await api.get<Secret[]>(
+        `/api/projects/${projectId}/secrets`,
+      );
+
+      if (isJSONMode()) {
+        printJSON(
+          opts.show
+            ? secrets
+            : secrets.map((s) => ({ key: s.key, value: "***" })),
+        );
+        return;
+      }
+
+      if (secrets.length === 0) {
+        console.log("No secrets. Use `lizard secret set KEY=value`.");
+        return;
+      }
+
+      table(
+        ["Key", "Value"],
+        secrets.map((s) => [
+          s.key,
+          opts.show ? s.value : chalk.dim("•".repeat(Math.min(s.value.length, 20))),
+        ]),
+      );
+    });
+
+  secret
+    .command("set")
+    .argument("<pairs...>", "KEY=value pairs")
+    .description("Set one or more secrets")
+    .option("--no-redeploy", "Don't trigger redeploy")
+    .action(async (pairs: string[], opts) => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // Parse KEY=value pairs
+      const newSecrets: Record<string, string> = {};
+      for (const pair of pairs) {
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx < 1) {
+          throw new Error(`Invalid format: "${pair}". Use KEY=value`);
+        }
+        newSecrets[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+      }
+
+      // Get existing secrets, merge, update
+      const existing = await api.get<Secret[]>(
+        `/api/projects/${projectId}/secrets`,
+      );
+      const merged: Secret[] = [];
+      const existingKeys = new Set<string>();
+
+      for (const s of existing) {
+        if (newSecrets[s.key] !== undefined) {
+          merged.push({ key: s.key, value: newSecrets[s.key] });
+          existingKeys.add(s.key);
+        } else {
+          merged.push(s);
+        }
+      }
+      // Add new keys
+      for (const [key, value] of Object.entries(newSecrets)) {
+        if (!existingKeys.has(key)) {
+          merged.push({ key, value });
+        }
+      }
+
+      await api.put(`/api/projects/${projectId}/secrets`, merged);
+
+      if (isJSONMode()) {
+        printJSON({ updated: Object.keys(newSecrets) });
+      } else {
+        success(
+          `${Object.keys(newSecrets).length} secret(s) updated`,
+        );
+      }
+    });
+
+  secret
+    .command("delete")
+    .argument("<keys...>", "Secret keys to delete")
+    .description("Delete one or more secrets")
+    .action(async (keys: string[]) => {
+      const projectId = resolveProjectId(program.opts().project);
+      const existing = await api.get<Secret[]>(
+        `/api/projects/${projectId}/secrets`,
+      );
+
+      const keysSet = new Set(keys);
+      const filtered = existing.filter((s) => !keysSet.has(s.key));
+
+      if (filtered.length === existing.length) {
+        throw new Error(`Secret(s) not found: ${keys.join(", ")}`);
+      }
+
+      await api.put(`/api/projects/${projectId}/secrets`, filtered);
+
+      if (isJSONMode()) {
+        printJSON({ deleted: keys });
+      } else {
+        success(`${keys.length} secret(s) deleted`);
+      }
+    });
+
+  secret
+    .command("import")
+    .description("Import secrets from stdin (KEY=value format, one per line)")
+    .option("--no-redeploy", "Don't trigger redeploy")
+    .action(async () => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // Read stdin
+      const chunks: Buffer[] = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk as Buffer);
+      }
+      const input = Buffer.concat(chunks).toString("utf-8");
+
+      const newSecrets: Record<string, string> = {};
+      for (const line of input.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx < 1) continue;
+        newSecrets[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+      }
+
+      if (Object.keys(newSecrets).length === 0) {
+        throw new Error("No valid KEY=value pairs found in input");
+      }
+
+      // Merge with existing
+      const existing = await api.get<Secret[]>(
+        `/api/projects/${projectId}/secrets`,
+      );
+      const existingMap = new Map(existing.map((s) => [s.key, s.value]));
+      for (const [k, v] of Object.entries(newSecrets)) {
+        existingMap.set(k, v);
+      }
+      const merged = Array.from(existingMap.entries()).map(([key, value]) => ({
+        key,
+        value,
+      }));
+
+      await api.put(`/api/projects/${projectId}/secrets`, merged);
+
+      if (isJSONMode()) {
+        printJSON({ imported: Object.keys(newSecrets) });
+      } else {
+        success(`${Object.keys(newSecrets).length} secret(s) imported`);
+      }
+    });
+}

package/src/commands/status.ts

@@ -0,0 +1,65 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId, findProjectConfig } from "../lib/config.js";
+import { isJSONMode, printJSON, statusColor, table } from "../lib/format.js";
+
+export function registerStatus(program: Command) {
+  program
+    .command("status")
+    .description("Show project status")
+    .action(async () => {
+      const projectId = resolveProjectId(program.opts().project);
+      const config = findProjectConfig();
+
+      const [project, services] = await Promise.all([
+        api.get<{ id: string; name: string; slug: string }>(
+          `/api/projects/${projectId}`,
+        ),
+        api.get<{ apps: any[]; addons: any[] }>(
+          `/api/projects/${projectId}/services`,
+        ),
+      ]);
+
+      if (isJSONMode()) {
+        printJSON({ project, services, environment: config?.environment || "production" });
+        return;
+      }
+
+      console.log(chalk.bold(project.name) + chalk.dim(` (${project.id})`));
+      if (config?.environment) {
+        console.log(chalk.dim(`Environment: ${config.environment}`));
+      }
+      console.log();
+
+      const allServices = [
+        ...(services.apps || []).map((a: any) => ({
+          name: a.name,
+          type: "app",
+          status: a.status,
+          url: a.domain ? `https://${a.domain}` : "",
+        })),
+        ...(services.addons || []).map((a: any) => ({
+          name: a.name || a.addonType,
+          type: a.addonType || "addon",
+          status: a.status,
+          url: a.hostname || "",
+        })),
+      ];
+
+      if (allServices.length === 0) {
+        console.log(chalk.dim("No services"));
+        return;
+      }
+
+      table(
+        ["Name", "Type", "Status", "URL"],
+        allServices.map((s) => [
+          s.name,
+          s.type,
+          statusColor(s.status),
+          s.url || chalk.dim("—"),
+        ]),
+      );
+    });
+}

package/src/commands/update.ts

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { info, isJSONMode, printJSON } from "../lib/format.js";
+
+export function registerUpdate(program: Command) {
+  program
+    .command("update")
+    .description("Update Lizard CLI to latest version")
+    .option("--check", "Only check for updates without installing")
+    .action(async (opts) => {
+      // Check npm for latest version
+      try {
+        const res = await fetch("https://registry.npmjs.org/@lizard/cli/latest");
+        if (!res.ok) throw new Error("Failed to check for updates");
+        const data = (await res.json()) as { version: string };
+
+        if (isJSONMode()) {
+          printJSON({
+            currentVersion: "0.1.0",
+            latestVersion: data.version,
+            updateAvailable: data.version !== "0.1.0",
+          });
+          return;
+        }
+
+        if (data.version === "0.1.0") {
+          info("Already up to date (v0.1.0)");
+          return;
+        }
+
+        if (opts.check) {
+          info(`Update available: v0.1.0 → v${data.version}`);
+          info(chalk.dim(`Run \`lizard update\` to install`));
+          return;
+        }
+
+        info(`Updating to v${data.version}...`);
+        const { execSync } = await import("node:child_process");
+        execSync("npm install -g @lizard/cli@latest", { stdio: "inherit" });
+      } catch {
+        info("Could not check for updates. Run `npm update -g @lizard/cli` manually.");
+      }
+    });
+}

package/src/commands/version.ts

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import { isJSONMode, printJSON } from "../lib/format.js";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function getVersion(): string {
+  try {
+    // Try to read from package.json
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version || "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+
+export function registerVersion(program: Command) {
+  program
+    .command("version")
+    .description("Show CLI version")
+    .action(() => {
+      const version = getVersion();
+      if (isJSONMode()) {
+        printJSON({
+          version,
+          platform: process.platform,
+          arch: process.arch,
+          node: process.version,
+        });
+      } else {
+        console.log(`lizard v${version}`);
+        console.log(`${process.platform}/${process.arch} node/${process.version}`);
+      }
+    });
+}

package/src/commands/whoami.ts

@@ -0,0 +1,27 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { isJSONMode, printJSON } from "../lib/format.js";
+
+export function registerWhoami(program: Command) {
+  program
+    .command("whoami")
+    .description("Show current user")
+    .action(async () => {
+      const user = await api.get<{
+        id: string;
+        username: string;
+        avatarUrl?: string;
+        hasGithubApp?: boolean;
+      }>("/api/auth/me");
+
+      if (isJSONMode()) {
+        printJSON(user);
+      } else {
+        console.log(chalk.bold(user.username));
+        if (user.hasGithubApp) {
+          console.log(chalk.dim("GitHub App: connected"));
+        }
+      }
+    });
+}

package/src/index.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { setJSONMode, isJSONMode, error } from "./lib/format.js";
+import { setTokenOverride, requireAuth, isLoggedIn } from "./lib/auth.js";
+import { setBaseURL, setAccessToken } from "./lib/api.js";
+
+// Commands
+import { registerLogin } from "./commands/login.js";
+import { registerLogout } from "./commands/logout.js";
+import { registerWhoami } from "./commands/whoami.js";
+import { registerInit } from "./commands/init.js";
+import { registerLink } from "./commands/link.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 { 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";
+
+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")
+  .hook("preAction", async (thisCommand, actionCommand) => {
+    const opts = thisCommand.opts();
+
+    // 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;
+
+    // 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);
+registerInit(program);
+registerLink(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);
+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`);
+    }
+  });
+
+// Error handling
+program.exitOverride();
+
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err: any) {
+    // Commander throws for --help, --version, etc. — ignore those
+    if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+      process.exit(0);
+    }
+    if (err.code === "commander.help") {
+      process.exit(0);
+    }
+
+    const msg = err.message || String(err);
+
+    if (isJSONMode()) {
+      console.log(
+        JSON.stringify(
+          {
+            error: {
+              code: err.code || "ERROR",
+              message: msg,
+            },
+          },
+          null,
+          2,
+        ),
+      );
+    } else {
+      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);
+    }
+    process.exit(1);
+  }
+}
+
+main();