@lizard-build/cli 0.1.0 → 0.3.30

package/src/commands/service-show.ts

@@ -0,0 +1,52 @@
+import { Command } from "commander";
+import { api, withScope } from "../lib/api.js";
+import { resolveProjectScope, resolveService } from "../lib/resolve.js";
+import { printJSON } from "../lib/format.js";
+
+/**
+ * `lizard service show` — print the current service configuration as JSON.
+ *
+ * Works for both apps and addons. Without `-s` shows the whole project
+ * (`{ apps, addons }`). With `-s <name>` shows just that service.
+ *
+ * Useful for diff-ing against a `lizard.config.json`, seeding a new file,
+ * or feeding into `lizard service set` to roll back.
+ */
+export function registerServiceShow(svc: Command) {
+  svc
+    .command("show")
+    .description("Show the current service configuration as JSON")
+    .argument("[service]", "Service name or ID (omit for whole project)")
+    .option("-s, --service <name>", "Limit output to one service")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (serviceArg: string | undefined, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+
+      const ref = serviceArg || opts.service;
+      if (ref) {
+        const svcInfo = await resolveService(projectId, ref);
+        if (svcInfo.kind === "app") {
+          const detail = await api.get<unknown>(
+            withScope(`/api/apps/${svcInfo.id}`, scope),
+          );
+          printJSON(detail);
+          return;
+        }
+        // Addons: pluck from the project /services endpoint, which already
+        // returns rich addon objects (connection, config, volume, region).
+        // There is no per-addon GET route on the backend.
+        const data = await api.get<{ addons?: any[] }>(
+          withScope(`/api/projects/${projectId}/services`, scope),
+        );
+        const addon = (data.addons || []).find((a: any) => a.id === svcInfo.id);
+        if (!addon) throw new Error(`Addon ${svcInfo.name} not found`);
+        printJSON(addon);
+        return;
+      }
+
+      const data = await api.get<unknown>(
+        withScope(`/api/projects/${projectId}/services`, scope),
+      );
+      printJSON(data);
+    });
+}

package/src/commands/service.ts

@@ -0,0 +1,298 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api, withScope, withQuery } from "../lib/api.js";
+import { updateProjectLink, getProjectLink } from "../lib/config.js";
+import { resolveProjectScope, resolveService } from "../lib/resolve.js";
+import { validateName } from "../lib/name.js";
+import { registerServiceSet } from "./service-set.js";
+import { registerServiceShow } from "./service-show.js";
+import {
+  success,
+  info,
+  isJSONMode,
+  printJSON,
+  isTTY,
+} from "../lib/format.js";
+
+interface ServicesResponse {
+  apps?: any[];
+  addons?: any[];
+}
+
+/**
+ * `lizard service` — service group:
+ *   - bare: link a service to cwd
+ *   - list / link / status / delete / rename / set / show / logs
+ *   (scale / redeploy / restart live on the top-level commands of the same name)
+ */
+export function registerService(program: Command) {
+  const svc = program
+    .command("service")
+    .argument(
+      "[name]",
+      "Service name to link (legacy form for `service link <name>`)",
+    )
+    .description("Manage services")
+    .action(async (name: string | undefined, _opts, cmd) => {
+      // No subcommand → behave like `service link`
+      if (!name && cmd.args.length === 0) {
+        await linkInteractive(cmd);
+        return;
+      }
+      if (name) {
+        await linkByName(cmd, name);
+      }
+    });
+
+  // `service set` and `service show` — per-service configuration patches.
+  // Live in their own files because the apply logic is substantial.
+  registerServiceSet(svc);
+  registerServiceShow(svc);
+
+  svc
+    .command("link")
+    .argument("[name]", "Service name or ID")
+    .description("Link a service to the current directory")
+    .action(async (name: string | undefined, _opts, sub) => {
+      if (name) {
+        await linkByName(sub, name);
+      } else {
+        await linkInteractive(sub);
+      }
+    });
+
+  svc
+    .command("delete")
+    .alias("rm")
+    .description("Delete a service")
+    .argument("[service]", "Service name or ID (defaults to linked)")
+    .option("-s, --service <name>", "Service name or ID")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("-y, --yes", "Skip confirmation")
+    .action(async (serviceArg: string | undefined, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const target = serviceArg || opts.service || getProjectLink()?.serviceId;
+      if (!target) throw new Error("No service specified or linked.");
+      const svcInfo = await resolveService(projectId, target);
+
+      const yes = opts.yes;
+      if (!yes) {
+        if (!isTTY()) throw new Error("Use -y to confirm in non-interactive mode");
+        const confirm = await p.confirm({
+          message: `Delete ${chalk.bold(svcInfo.name)}? This is irreversible.`,
+        });
+        if (p.isCancel(confirm) || !confirm) process.exit(5);
+      }
+
+      if (svcInfo.kind === "app") {
+        await api.delete(withScope(`/api/apps/${svcInfo.id}`, scope));
+      } else {
+        await api.delete(withScope(`/api/projects/${projectId}/addons/${svcInfo.id}`, scope));
+      }
+
+      // Clear link if we just deleted the linked service
+      const link = getProjectLink();
+      if (link?.serviceId === svcInfo.id) {
+        updateProjectLink({ serviceId: undefined, serviceName: undefined });
+      }
+
+      if (isJSONMode()) {
+        printJSON({ id: svcInfo.id, name: svcInfo.name, status: "deleted" });
+      } else {
+        success(`Service ${chalk.bold(svcInfo.name)} deleted`);
+      }
+    });
+
+  svc
+    .command("rename")
+    .argument("<new-name>", "New name for the service")
+    .description("Rename a service (apps and addons)")
+    .option("-s, --service <name>", "Service name or ID (defaults to linked service)")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (newName: string, opts) => {
+      const nameErr = validateName(newName);
+      if (nameErr) throw new Error(`Invalid name: ${nameErr}`);
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const target = opts.service || getProjectLink()?.serviceId;
+      if (!target) throw new Error("No service specified or linked.");
+      const svcInfo = await resolveService(projectId, target);
+
+      if (svcInfo.kind === "app") {
+        // PATCH /api/apps/:id is 410-Gone; renames go through config:apply.
+        // Backend treats name as a rename only when id is also in the patch
+        // (otherwise name is a lookup key).
+        await api.post(
+          withScope(`/api/projects/${projectId}/config:apply`, scope),
+          { services: [{ id: svcInfo.id, name: newName }] },
+        );
+      } else {
+        await api.patch(
+          withScope(`/api/projects/${projectId}/addons/${svcInfo.id}`, scope),
+          { name: newName },
+        );
+      }
+
+      // Keep the cwd link's cached name in sync when we just renamed the linked one.
+      const link = getProjectLink();
+      if (link?.serviceId === svcInfo.id) {
+        updateProjectLink({ serviceId: svcInfo.id, serviceName: newName });
+      }
+
+      if (isJSONMode()) {
+        printJSON({ id: svcInfo.id, oldName: svcInfo.name, name: newName });
+      } else {
+        success(`Renamed ${chalk.bold(svcInfo.name)} → ${chalk.bold(newName)}`);
+      }
+    });
+
+  svc
+    .command("logs")
+    .description("Stream logs of a service")
+    .argument("[service]", "Service name or ID (defaults to linked)")
+    .option("-s, --service <name>", "Service name or ID")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("--build", "Show build logs instead of runtime")
+    .option("-n, --tail <n>", "Print last N lines and exit (no follow); use --tail all for full history")
+    .option("--page <n>", "Page of historical logs (1=most recent, 2=older, …); implies --tail 200")
+    .action(async (serviceArg: string | undefined, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const target = serviceArg || opts.service || getProjectLink()?.serviceId;
+      if (!target) throw new Error("No service specified or linked.");
+      const svcInfo = await resolveService(projectId, target);
+
+      const { streamSSE } = await import("../lib/api.js");
+
+      if (opts.build) {
+        const app = await api.get<{ builds?: Array<{ id: string }> }>(
+          withScope(`/api/apps/${svcInfo.id}`, scope),
+        );
+        if (!app.builds?.length) throw new Error("No builds found");
+        info(chalk.dim(`Streaming build logs for ${svcInfo.name}...\n`));
+        await streamSSE(`/api/builds/${app.builds[0].id}/logs`, (event, data) => {
+          if (event === "done" || event === "error") return false;
+          process.stdout.write(safeLogLine(data) + "\n");
+          return true;
+        });
+        return;
+      }
+
+      // --page: paginate through historical logs without streaming
+      if (opts.page !== undefined) {
+        const pageSize = 200;
+        const pageNum = Math.max(1, parseInt(opts.page, 10) || 1);
+        // Fetch pages iteratively: page 1 = most recent, page 2 = one step older, etc.
+        let before: string | undefined;
+        for (let p = 1; p <= pageNum; p++) {
+          const result = await api.get<{ entries: any[]; oldest: string | null }>(
+            withScope(
+              withQuery(`/api/apps/${svcInfo.id}/logs/history`, {
+                limit: pageSize,
+                before,
+              }),
+              scope,
+            ),
+          );
+          if (p === pageNum) {
+            if (!result.entries.length) {
+              info(chalk.dim("No more logs."));
+            } else {
+              info(chalk.dim(`Page ${pageNum} (${result.entries.length} lines):\n`));
+              for (const e of result.entries) process.stdout.write(safeLogLine(JSON.stringify(e)) + "\n");
+              if (result.oldest) info(chalk.dim(`\n  --page ${pageNum + 1}  for older logs`));
+            }
+          } else {
+            if (!result.entries.length || !result.entries[0]) break;
+            before = result.entries[0].id; // oldest entry of this page → upper bound for next
+          }
+        }
+        return;
+      }
+
+      // --tail N: fetch N historical lines and exit (no follow)
+      if (opts.tail !== undefined) {
+        const rawTail = String(opts.tail);
+        const limit = rawTail === "all" ? 2000 : Math.min(Math.max(1, parseInt(rawTail, 10) || 200), 2000);
+        const result = await api.get<{ entries: any[]; oldest: string | null }>(
+          withScope(
+            withQuery(`/api/apps/${svcInfo.id}/logs/history`, { limit }),
+            scope,
+          ),
+        );
+        for (const e of result.entries) process.stdout.write(safeLogLine(JSON.stringify(e)) + "\n");
+        if (result.oldest && result.entries.length === limit) {
+          info(chalk.dim(`\n  Showing last ${limit} lines. Use --tail all or --page 2 to see older logs.`));
+        }
+        return;
+      }
+
+      info(chalk.dim(`Streaming logs for ${svcInfo.name}... (Ctrl+C to stop)\n`));
+      await streamSSE(
+        withScope(
+          withQuery(`/api/apps/${svcInfo.id}/logs`, { limit: 500 }),
+          scope,
+        ),
+        (event, data) => {
+          if (event === "error") return false;
+          process.stdout.write(safeLogLine(data) + "\n");
+          return true;
+        },
+      );
+    });
+
+  // Helpers in scope of registerService
+  async function linkByName(_cmd: Command, name: string) {
+    const { projectId } = await resolveProjectScope(undefined);
+    const svcInfo = await resolveService(projectId, name);
+    updateProjectLink({ serviceId: svcInfo.id, serviceName: svcInfo.name });
+    if (isJSONMode()) {
+      printJSON({ serviceId: svcInfo.id, serviceName: svcInfo.name });
+    } else {
+      success(`Linked service ${chalk.bold(svcInfo.name)}`);
+    }
+  }
+
+  async function linkInteractive(_cmd: Command) {
+    const { projectId, scope } = await resolveProjectScope(undefined);
+    const data = await api.get<ServicesResponse>(
+      withScope(`/api/projects/${projectId}/services`, scope),
+    );
+    const services = [...(data.apps || []), ...(data.addons || [])];
+    if (services.length === 0) {
+      throw new Error("No services in project. Use `lizard add` first.");
+    }
+    if (!isTTY()) {
+      throw new Error(
+        "Service name required in non-interactive mode. Usage: `lizard service link <name>`",
+      );
+    }
+    const sel = await p.select({
+      message: "Select a service",
+      options: services.map((s: any) => ({
+        value: s.id,
+        label: s.name || s.addonType,
+        hint: s.status,
+      })),
+    });
+    if (p.isCancel(sel)) process.exit(5);
+    const svcInfo = services.find((s: any) => s.id === sel)!;
+    updateProjectLink({ serviceId: svcInfo.id, serviceName: svcInfo.name });
+    if (isJSONMode()) {
+      printJSON({ serviceId: svcInfo.id, serviceName: svcInfo.name });
+    } else {
+      success(`Linked service ${chalk.bold(svcInfo.name)}`);
+    }
+  }
+}
+
+function safeLogLine(data: string): string {
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.line) return parsed.line;
+    if (parsed.message) return parsed.message;
+    if (typeof parsed === "string") return parsed;
+    return data;
+  } catch {
+    return data;
+  }
+}

package/src/commands/skill.ts

@@ -0,0 +1,157 @@
+import { Command } from "commander";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { error, info, isJSONMode, printJSON, table } from "../lib/format.js";
+
+const DEFAULT_SKILLS_DIR = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "skill-data",
+);
+
+function skillsDir(): string {
+  return process.env.LIZARD_SKILLS_DIR || DEFAULT_SKILLS_DIR;
+}
+
+function listSkills(): string[] {
+  const dir = skillsDir();
+  try {
+    return readdirSync(dir)
+      .filter((name) => {
+        const p = path.join(dir, name);
+        try {
+          return statSync(p).isDirectory();
+        } catch {
+          return false;
+        }
+      })
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function skillFile(name: string): string {
+  return path.join(skillsDir(), name, "SKILL.md");
+}
+
+// Minimal YAML-ish frontmatter parser. Pulls top-level scalar keys (name,
+// description, etc.) — enough to render `lizard skill list`. Full YAML parsing
+// would add a dependency for no real win.
+function parseFrontmatter(md: string): Record<string, string> {
+  if (!md.startsWith("---")) return {};
+  const end = md.indexOf("\n---", 3);
+  if (end === -1) return {};
+  const body = md.slice(3, end).replace(/^\r?\n/, "");
+  const out: Record<string, string> = {};
+  for (const raw of body.split(/\r?\n/)) {
+    const m = raw.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!m) continue;
+    let val = m[2].trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    out[m[1]] = val;
+  }
+  return out;
+}
+
+function readSkill(name: string): { md: string; meta: Record<string, string> } {
+  const file = skillFile(name);
+  let md: string;
+  try {
+    md = readFileSync(file, "utf8");
+  } catch {
+    throw new Error(
+      `Skill '${name}' not found. Run \`lizard skill list\` to see available skills.`,
+    );
+  }
+  return { md, meta: parseFrontmatter(md) };
+}
+
+function shortDesc(desc: string, max = 100): string {
+  const oneLine = desc.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "…" : oneLine;
+}
+
+export function registerSkill(program: Command) {
+  const skill = program
+    .command("skill")
+    .description("Read embedded agent skills shipped with this CLI version");
+
+  skill
+    .command("list")
+    .description("List available skills with descriptions")
+    .action(() => {
+      const names = listSkills();
+      if (isJSONMode()) {
+        printJSON({
+          dir: skillsDir(),
+          skills: names.map((n) => {
+            try {
+              const { meta } = readSkill(n);
+              return { name: n, description: meta.description || "" };
+            } catch {
+              return { name: n, description: "" };
+            }
+          }),
+        });
+        return;
+      }
+      if (names.length === 0) {
+        info("No skills found.");
+        return;
+      }
+      const rows = names.map((n) => {
+        try {
+          const { meta } = readSkill(n);
+          return [n, shortDesc(meta.description || "")];
+        } catch {
+          return [n, ""];
+        }
+      });
+      table(["name", "description"], rows);
+    });
+
+  skill
+    .command("get")
+    .description("Print a skill's full content (markdown)")
+    .argument("<name>", "skill name (e.g. core)")
+    .option("--full", "Include reference files (reserved; currently equivalent to default)")
+    .action((name: string, _opts: { full?: boolean }) => {
+      try {
+        const { md, meta } = readSkill(name);
+        if (isJSONMode()) {
+          printJSON({
+            name,
+            path: skillFile(name),
+            frontmatter: meta,
+            content: md,
+          });
+          return;
+        }
+        process.stdout.write(md.endsWith("\n") ? md : md + "\n");
+      } catch (e: any) {
+        error(e.message);
+        process.exit(3);
+      }
+    });
+
+  skill
+    .command("path")
+    .description("Print the filesystem path of a skill (or the skills root)")
+    .argument("[name]", "skill name; omit to print the skills directory")
+    .action((name?: string) => {
+      const target = name ? skillFile(name) : skillsDir();
+      if (isJSONMode()) {
+        printJSON({ path: target });
+        return;
+      }
+      console.log(target);
+    });
+}

package/src/commands/ssh.ts

@@ -0,0 +1,176 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api, getBaseURL, streamSSE, withScope } from "../lib/api.js";
+import { resolveProjectScope } from "../lib/resolve.js";
+import { error, isTTY } from "../lib/format.js";
+import { getToken } from "../lib/auth.js";
+import * as https from "node:https";
+import * as http from "node:http";
+
+export function registerSSH(program: Command) {
+  program
+    .command("ssh")
+    .description("Execute a command inside a running service VM")
+    .argument("[cmd...]", "Command and args to run inside the VM (required; pass after `--` to stop flag parsing, e.g. `-- ls -la /app`)")
+    .option("-s, --service <id>", "Service name or ID")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .addHelpText("after", `
+Examples:
+  lizard ssh -s my-app -- ls -la /app
+  lizard ssh -s my-app -- printenv
+  lizard ssh -s my-app -- bash -c "ps aux | head"`)
+    .action(async (cmdArgs: string[], opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      let serviceId = opts.service as string | undefined;
+
+      // Resolve service interactively if not given
+      if (!serviceId) {
+        const data = await api.get<{ apps: Array<{ id: string; name: string; status: string }> }>(
+          withScope(`/api/projects/${projectId}/services`, scope),
+        );
+        const running = (data.apps || []).filter((a) => a.status === "running");
+        if (running.length === 0) {
+          error("No running services in this project.");
+          process.exit(1);
+        }
+        if (running.length === 1) {
+          serviceId = running[0].id;
+        } else if (isTTY()) {
+          const selected = await p.select({
+            message: "Select a service",
+            options: running.map((a) => ({ value: a.id, label: a.name || a.id, hint: a.status })),
+          });
+          if (p.isCancel(selected)) process.exit(5);
+          serviceId = selected as string;
+        } else {
+          error("Multiple services — pass -s <service>");
+          process.exit(1);
+        }
+      }
+
+      // Resolve service ID if a name was given (lookup by name)
+      if (serviceId && !serviceId.match(/^[A-Za-z0-9_-]{20,}$/)) {
+        const data = await api.get<{ apps: Array<{ id: string; name: string; serviceName?: string }> }>(
+          withScope(`/api/projects/${projectId}/services`, scope),
+        );
+        const match = (data.apps || []).find(
+          (a) => a.name === serviceId || a.serviceName === serviceId || a.id === serviceId,
+        );
+        if (match) serviceId = match.id;
+      }
+
+      if (cmdArgs.length === 0) {
+        error("No command given. Usage: lizard ssh -s <service> -- <cmd> [args...]");
+        process.exit(1);
+      }
+
+      // The server executes `cmd` via shell on the VM, so each arg must be
+      // shell-quoted before being joined — otherwise `bash -c "ps | head"`
+      // collapses to `bash -c ps | head` (quotes lost, `|` becomes a real pipe).
+      const cmd = cmdArgs.map(shellQuote).join(" ");
+      process.stdout.write(chalk.dim(`$ ${cmd}\n`));
+
+      let exitCode = 0;
+
+      await execStream(serviceId!, cmd, (stream, line) => {
+        if (stream === "stderr") {
+          process.stderr.write(line + "\n");
+        } else {
+          process.stdout.write(line + "\n");
+        }
+      }, (code) => {
+        exitCode = code;
+      });
+
+      process.exit(exitCode);
+    });
+}
+
+function execStream(
+  appId: string,
+  cmd: string,
+  onLine: (stream: string, line: string) => void,
+  onExit: (code: number) => void,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const baseURL = getBaseURL();
+    const url = new URL(`${baseURL}/api/apps/${appId}/exec`);
+    const token = getToken();
+    const body = JSON.stringify({ cmd });
+
+    const reqHeaders: Record<string, string> = {
+      "Content-Type": "application/json",
+      "Content-Length": String(Buffer.byteLength(body)),
+      "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,
+        method: "POST",
+        headers: reqHeaders,
+      },
+      (res) => {
+        if (res.statusCode && res.statusCode >= 400) {
+          let body = "";
+          res.on("data", (c: Buffer) => (body += c.toString()));
+          res.on("end", () => reject(new Error(`exec failed ${res.statusCode}: ${body}`)));
+          return;
+        }
+
+        let buf = "";
+        let currentEvent = "";
+
+        res.setEncoding("utf8");
+        res.on("data", (chunk: string) => {
+          buf += chunk;
+          const lines = buf.split("\n");
+          buf = lines.pop() ?? "";
+
+          for (const line of lines) {
+            const trimmed = line.replace(/\r$/, "");
+            if (trimmed === "") {
+              currentEvent = "";
+            } else if (trimmed.startsWith("event:")) {
+              currentEvent = trimmed.slice(6).trim();
+            } else if (trimmed.startsWith("data:")) {
+              const data = trimmed.slice(5).trimStart();
+              if (currentEvent === "exit") {
+                try { onExit(JSON.parse(data).exitCode ?? 0); } catch {}
+              } else if (currentEvent === "error") {
+                error(data);
+              } else {
+                try {
+                  const parsed = JSON.parse(data);
+                  onLine(parsed.stream ?? "stdout", parsed.line ?? data);
+                } catch {
+                  onLine("stdout", data);
+                }
+              }
+            }
+          }
+        });
+
+        res.on("end", resolve);
+        res.on("error", reject);
+      },
+    );
+
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+/** POSIX single-quote escaping. Safe-token chars pass through verbatim;
+ *  anything else gets wrapped in '…' with embedded `'` rewritten as `'\''`. */
+function shellQuote(arg: string): string {
+  if (arg === "") return "''";
+  if (/^[A-Za-z0-9_./:=@%+,-]+$/.test(arg)) return arg;
+  return "'" + arg.replace(/'/g, "'\\''") + "'";
+}