@lizard-build/cli 0.1.0 → 0.3.29

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/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, "'\\''") + "'";
+}

package/src/commands/status.ts

@@ -1,65 +1,70 @@
 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";
+import { getProjectLink, updateProjectLink } from "../lib/config.js";
+import { lookupProjectWorkspace } from "../lib/resolve.js";
+import { isJSONMode, printJSON, info } from "../lib/format.js";
 
+/**
+ * `lizard status` — print the linked workspace / project / service for
+ * the current working directory. Mirrors `railway status`.
+ *
+ * Lazy-fills workspaceId into the link when missing so legacy configs
+ * surface their workspace too.
+ */
 export function registerStatus(program: Command) {
   program
     .command("status")
-    .description("Show project status")
+    .description("Show linked workspace, project, and service")
     .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" });
+      const link = getProjectLink();
+      if (!link) {
+        if (isJSONMode()) {
+          printJSON({ cwd: process.cwd(), linked: false });
+        } else {
+          info("Not linked. Run `lizard init` to create or link a project.");
+        }
         return;
       }
 
-      console.log(chalk.bold(project.name) + chalk.dim(` (${project.id})`));
-      if (config?.environment) {
-        console.log(chalk.dim(`Environment: ${config.environment}`));
+      // Backfill workspace info for legacy links (saved before workspaces existed)
+      let workspaceName = link.workspaceName;
+      if (!link.workspaceId) {
+        const fetched = await lookupProjectWorkspace(link.projectId);
+        if (fetched?.workspaceId) {
+          workspaceName = fetched.workspaceName ?? undefined;
+          try {
+            updateProjectLink({
+              workspaceId: fetched.workspaceId,
+              workspaceName,
+            });
+          } catch {}
+        }
       }
-      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 || "",
-        })),
-      ];
+      const out = {
+        cwd: process.cwd(),
+        linked: true,
+        workspace: workspaceName ?? null,
+        workspaceId: link.workspaceId ?? null,
+        project: link.projectName ?? null,
+        projectId: link.projectId,
+        service: link.serviceName ?? null,
+        serviceId: link.serviceId ?? null,
+      };
 
-      if (allServices.length === 0) {
-        console.log(chalk.dim("No services"));
+      if (isJSONMode()) {
+        printJSON(out);
         return;
       }
 
-      table(
-        ["Name", "Type", "Status", "URL"],
-        allServices.map((s) => [
-          s.name,
-          s.type,
-          statusColor(s.status),
-          s.url || chalk.dim("—"),
-        ]),
+      const fmt = (v: string | null) => v ?? chalk.dim("—");
+
+      console.log(`  ${chalk.dim("Workspace:")}  ${fmt(out.workspace)}`);
+      console.log(`  ${chalk.dim("Project:")}    ${chalk.bold(out.project ?? link.projectId)}`);
+      console.log(
+        `  ${chalk.dim("Service:")}    ${
+          out.service ? chalk.bold(out.service) : chalk.dim("(none — `lizard service link`)")
+        }`,
       );
     });
 }

package/src/commands/unlink.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import { clearProjectLink } from "../lib/config.js";
+import { isJSONMode, printJSON, success } from "../lib/format.js";
+
+/**
+ * `lizard unlink` — drops the cwd↔project mapping.
+ */
+export function registerUnlink(program: Command) {
+  program
+    .command("unlink")
+    .description("Disassociate the current directory from any project")
+    .action(() => {
+      clearProjectLink();
+      if (isJSONMode()) printJSON({ status: "unlinked" });
+      else success("Directory unlinked");
+    });
+}