@lizard-build/cli 0.1.0 → 0.3.29

package/src/commands/logs.ts

@@ -1,28 +1,93 @@
 import chalk from "chalk";
+import * as p from "@clack/prompts";
 import { Command } from "commander";
-import { streamSSE, api } from "../lib/api.js";
-import { resolveProjectId } from "../lib/config.js";
-import { info, error } from "../lib/format.js";
+import { streamSSE, api, withScope, withQuery, type ResourceScope } from "../lib/api.js";
+import { resolveProjectScope, resolveService, getActiveService } from "../lib/resolve.js";
+import { info, error, isTTY, isJSONMode, printJSON, table, statusColor, timeAgo } from "../lib/format.js";
 
 export function registerLogs(program: Command) {
   program
     .command("logs")
     .description("Stream runtime logs")
     .option("--build", "Show build logs instead of runtime")
-    .option("--service <id>", "Only show logs for a specific service")
+    .option("-s, --service <id>", "Only show logs for a specific service")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("--tail <n>", "Print last N log lines and exit (no follow)")
+    .option("--restarts [n]", "List last N restart events (default 20) and exit")
+    .option("--restart <id>", "Print log tail of a specific restart event (or 'latest')")
     .action(async (opts) => {
-      const projectId = resolveProjectId(program.opts().project);
+      if (opts.restarts !== undefined && opts.restart !== undefined) {
+        error("Use --restarts (list) or --restart <id> (detail), not both");
+        process.exit(1);
+      }
+
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+
+      if (opts.restarts !== undefined) {
+        await showRestartList(opts.service, projectId, parseRestartsN(opts.restarts));
+        return;
+      }
+      if (opts.restart !== undefined) {
+        await showRestartLogTail(opts.service, projectId, String(opts.restart));
+        return;
+      }
+
+      const tailN = opts.tail !== undefined ? parseTail(opts.tail) : undefined;
 
       if (opts.build) {
-        // Show build logs for the latest build
-        await showBuildLogs(opts.service, projectId);
+        await showBuildLogs(opts.service, projectId, scope, tailN);
         return;
       }
 
+      // Resolve -s flag (may be name, slug, or ID) once up front so every
+      // branch below talks to the API with a real service ID.
+      let serviceId: string | undefined;
       if (opts.service) {
+        const svc = await resolveService(projectId, opts.service);
+        serviceId = svc.id;
+      }
+
+      // --tail: fetch historical logs and exit
+      if (tailN !== undefined) {
+        const entries = await api.get<any[]>(
+          withScope(
+            withQuery(`/api/projects/${projectId}/logs`, {
+              limit: tailN,
+              service: serviceId,
+            }),
+            scope,
+          ),
+        );
+        for (const e of entries) printLogEntry(e);
+        return;
+      }
+
+      if (!serviceId && isTTY() && !isJSONMode()) {
+        // Offer to pick a specific service or stream all
+        const data = await api.get<{ apps: any[] }>(
+          withScope(`/api/projects/${projectId}/services`, scope),
+        );
+        const apps = data.apps || [];
+
+        if (apps.length > 1) {
+          const choices = [
+            { value: "all", label: "All services", hint: "stream combined logs" },
+            ...apps.map((a: any) => ({
+              value: a.id,
+              label: a.name || a.id,
+              hint: a.status,
+            })),
+          ];
+          const selected = await p.select({ message: "Show logs for", options: choices });
+          if (p.isCancel(selected)) process.exit(5);
+          if (selected !== "all") serviceId = selected as string;
+        }
+      }
+
+      if (serviceId) {
         // Stream logs for a specific app
         info(chalk.dim("Streaming logs... (Ctrl+C to stop)\n"));
-        await streamSSE(`/api/apps/${opts.service}/logs`, (event, data) => {
+        await streamSSE(`/api/apps/${serviceId}/logs`, (event, data) => {
           if (event === "error") {
             error(data);
             return false;
@@ -36,7 +101,7 @@ export function registerLogs(program: Command) {
       // Stream all project logs
       info(chalk.dim("Streaming project logs... (Ctrl+C to stop)\n"));
       await streamSSE(
-        `/api/projects/${projectId}/logs/stream`,
+        withScope(`/api/projects/${projectId}/logs/stream`, scope),
         (event, data) => {
           if (event === "error") {
             error(data);
@@ -49,36 +114,214 @@ export function registerLogs(program: Command) {
     });
 }
 
+function parseTail(raw: string): number {
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n < 1) {
+    error("--tail must be a positive integer");
+    process.exit(1);
+  }
+  if (n > 1000) {
+    info(chalk.yellow("--tail capped at 1000 (server limit)"));
+    return 1000;
+  }
+  return n;
+}
+
+function parseRestartsN(raw: unknown): number {
+  if (raw === true || raw === "" || raw === undefined) return 20;
+  const n = parseInt(String(raw), 10);
+  if (isNaN(n) || n < 1) {
+    error("--restarts must be a positive integer");
+    process.exit(1);
+  }
+  return n;
+}
+
+// Shape returned by /api/apps/:id/deploy-events
+interface DeployEvent {
+  buildId: string;
+  trigger: string | null;
+  status: string;
+  commitSha: string | null;
+  createdAt: number;
+  events: Array<{
+    id: string;
+    source: string;
+    status: string;
+    exitInfo: string | null;
+    logsTail: string | null;
+    crashedAt: number;
+    nextRetryAt?: number | null;
+    triggeredBy?: string;
+  }>;
+}
+
+type FlatEvent = DeployEvent["events"][number] & {
+  buildId: string;
+  commitSha: string | null;
+};
+
+async function fetchFlatRestarts(appId: string): Promise<FlatEvent[]> {
+  const builds = await api.get<DeployEvent[]>(`/api/apps/${appId}/deploy-events`);
+  const flat: FlatEvent[] = [];
+  for (const b of builds) {
+    for (const e of b.events) {
+      flat.push({ ...e, buildId: b.buildId, commitSha: b.commitSha });
+    }
+  }
+  flat.sort((a, b) => b.crashedAt - a.crashedAt);
+  return flat;
+}
+
+function replicaPrefix(e: any): string {
+  if (!e.replica) return "";
+  return chalk.magenta(`[${e.replica}]`) + " ";
+}
+
+function printLogEntry(e: any) {
+  if (isJSONMode()) {
+    process.stdout.write(JSON.stringify(e) + "\n");
+    return;
+  }
+  const rep = replicaPrefix(e);
+  if (e.service && e.message) {
+    const prefix = chalk.cyan(`[${e.service}]`);
+    process.stdout.write(`${prefix} ${rep}${e.message}\n`);
+  } else if (e.message) {
+    process.stdout.write(`${rep}${e.message}\n`);
+  }
+}
+
 function printLogLine(data: string) {
+  let parsed: any;
   try {
-    const parsed = JSON.parse(data);
-    if (parsed.service && parsed.line) {
-      const prefix = chalk.cyan(`[${parsed.service}]`);
-      process.stdout.write(`${prefix} ${parsed.line}\n`);
-    } else if (parsed.line) {
-      process.stdout.write(parsed.line + "\n");
-    } else if (parsed.message) {
-      process.stdout.write(parsed.message + "\n");
-    } else if (typeof parsed === "string") {
-      process.stdout.write(parsed + "\n");
-    } else {
-      process.stdout.write(data + "\n");
-    }
+    parsed = JSON.parse(data);
   } catch {
+    parsed = { message: data };
+  }
+  if (typeof parsed === "string") parsed = { message: parsed };
+
+  if (isJSONMode()) {
+    process.stdout.write(JSON.stringify(parsed) + "\n");
+    return;
+  }
+
+  const rep = replicaPrefix(parsed);
+  if (parsed.service && parsed.message) {
+    const prefix = chalk.cyan(`[${parsed.service}]`);
+    process.stdout.write(`${prefix} ${rep}${parsed.message}\n`);
+  } else if (parsed.message) {
+    process.stdout.write(`${rep}${parsed.message}\n`);
+  } else {
     process.stdout.write(data + "\n");
   }
 }
 
-async function showBuildLogs(serviceId: string | undefined, projectId: string) {
-  let appId = serviceId;
+async function showRestartList(
+  serviceRef: string | undefined,
+  projectId: string,
+  n: number,
+) {
+  const svc = await getActiveService(serviceRef, projectId);
+  const events = await fetchFlatRestarts(svc.id);
+  const slice = events.slice(0, n);
+
+  if (isJSONMode()) {
+    for (const e of slice) {
+      process.stdout.write(JSON.stringify(e) + "\n");
+    }
+    return;
+  }
+
+  if (slice.length === 0) {
+    info(chalk.dim(`No restart events for ${svc.name}.`));
+    return;
+  }
+
+  table(
+    ["When", "Source", "Status", "Exit", "By", "ID"],
+    slice.map((e) => [
+      timeAgo(e.crashedAt),
+      e.source,
+      statusColor(e.status),
+      (e.exitInfo ?? "").slice(0, 60),
+      e.triggeredBy ?? chalk.dim("—"),
+      chalk.dim(e.id),
+    ]),
+  );
+
+  if (events.length > slice.length) {
+    info(chalk.dim(`\n(${events.length - slice.length} more — re-run with --restarts ${events.length})`));
+  }
+  info(chalk.dim("\nInspect: lizard logs --restart <id>   (or 'latest')"));
+}
+
+async function showRestartLogTail(
+  serviceRef: string | undefined,
+  projectId: string,
+  ref: string,
+) {
+  const svc = await getActiveService(serviceRef, projectId);
+  const events = await fetchFlatRestarts(svc.id);
+
+  let evt: FlatEvent | undefined;
+  if (ref === "latest") {
+    evt = events[0];
+    if (!evt) {
+      error(`No restart events for ${svc.name}.`);
+      process.exit(1);
+    }
+  } else {
+    evt = events.find((e) => e.id === ref);
+    if (!evt) {
+      error(`Restart event "${ref}" not found for ${svc.name}.`);
+      process.exit(1);
+    }
+  }
+
+  if (isJSONMode()) {
+    printJSON(evt);
+    return;
+  }
+
+  console.log(chalk.dim("Event:    ") + evt.id);
+  console.log(chalk.dim("When:     ") + timeAgo(evt.crashedAt));
+  console.log(chalk.dim("Source:   ") + evt.source);
+  console.log(chalk.dim("Status:   ") + statusColor(evt.status));
+  if (evt.exitInfo) console.log(chalk.dim("Exit:     ") + evt.exitInfo);
+  if (evt.triggeredBy) console.log(chalk.dim("By:       ") + evt.triggeredBy);
+  if (evt.buildId) console.log(chalk.dim("Build:    ") + evt.buildId);
+  console.log();
+
+  if (evt.logsTail) {
+    process.stdout.write(evt.logsTail);
+    if (!evt.logsTail.endsWith("\n")) process.stdout.write("\n");
+  } else {
+    info(chalk.dim(`<no log tail captured — source=${evt.source} (manual restarts don't capture logs)>`));
+  }
+}
+
+async function showBuildLogs(
+  serviceRef: string | undefined,
+  projectId: string,
+  scope: ResourceScope,
+  tailN?: number,
+) {
+  let appId: string | undefined;
+  if (serviceRef) {
+    const svc = await resolveService(projectId, serviceRef);
+    appId = svc.id;
+  }
 
   if (!appId) {
     // Get first app in project
     const data = await api.get<{ apps: Array<{ id: string; name: string }> }>(
-      `/api/projects/${projectId}/services`,
+      withScope(`/api/projects/${projectId}/services`, scope),
     );
     if (!data.apps?.length) {
-      throw new Error("No apps in project");
+      throw new Error(
+        "No apps in project. Create one with `lizard up` or `lizard add`.",
+      );
     }
     appId = data.apps[0].id;
   }
@@ -88,12 +331,25 @@ async function showBuildLogs(serviceId: string | undefined, projectId: string) {
     builds?: Array<{ id: string; status: string }>;
   }>(`/api/apps/${appId}`);
   if (!app.builds?.length) {
-    throw new Error("No builds found");
+    throw new Error(
+      "No builds for this app yet. Trigger one with `lizard up` or `lizard redeploy`.",
+    );
   }
 
   const buildId = app.builds[0].id;
   info(chalk.dim(`Build ${buildId}\n`));
 
+  if (tailN !== undefined) {
+    const lines: string[] = [];
+    await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
+      if (event === "done" || event === "error") return false;
+      lines.push(data);
+      return true;
+    });
+    for (const line of lines.slice(-tailN)) printLogLine(line);
+    return;
+  }
+
   await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
     if (event === "done" || event === "error") {
       return false;

package/src/commands/open.ts

@@ -8,8 +8,9 @@ export function registerOpen(program: Command) {
   program
     .command("open")
     .description("Open project in browser")
-    .action(async () => {
-      const projectId = resolveProjectId(program.opts().project);
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (opts) => {
+      const projectId = await resolveProjectId(opts.project);
       const url = `${getBaseURL()}/projects/${projectId}`;
       await open(url);
       success("Opened in browser");

package/src/commands/port.ts

@@ -0,0 +1,57 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api, withScope } from "../lib/api.js";
+import { getActiveServiceWithKind, resolveProjectScope } from "../lib/resolve.js";
+import { success, info, isJSONMode, printJSON } from "../lib/format.js";
+
+/**
+ * `lizard port [number]`
+ *   bare     → show current container port
+ *   <number> → update container port (takes effect on next deploy)
+ */
+export function registerPort(program: Command) {
+  program
+    .command("port")
+    .argument("[port]", "Port number to set")
+    .description("Show or change the container port for a service")
+    .option("-s, --service <name>", "Service name or ID")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (portArg: string | undefined, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const service = await getActiveServiceWithKind(opts.service, projectId);
+      if (service.kind === "addon") {
+        throw new Error("Addons don't have a container port.");
+      }
+
+      if (portArg === undefined) {
+        const app = await api.get<{ containerPort?: number }>(`/api/apps/${service.id}`);
+        const port = app.containerPort ?? 3000;
+        if (isJSONMode()) {
+          printJSON({ port });
+        } else {
+          info(`${chalk.bold(service.name)} container port: ${chalk.cyan(port)}`);
+        }
+        return;
+      }
+
+      const newPort = parseInt(portArg, 10);
+      if (isNaN(newPort) || newPort < 1 || newPort > 65535) {
+        throw new Error(`Invalid port: ${portArg}. Must be 1–65535.`);
+      }
+
+      // PATCH /api/apps/:id is 410-Gone server-side; writes go through
+      // POST /api/projects/:id/config:apply.
+      await api.post(
+        withScope(`/api/projects/${projectId}/config:apply`, scope),
+        { services: [{ id: service.id, name: service.name, containerPort: newPort }] },
+      );
+
+      if (isJSONMode()) {
+        printJSON({ ok: true, port: newPort });
+      } else {
+        success(
+          `${chalk.bold(service.name)} container port set to ${chalk.cyan(newPort)} — takes effect on next deploy`,
+        );
+      }
+    });
+}

package/src/commands/projects.ts

@@ -1,6 +1,8 @@
+import chalk from "chalk";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
-import { isJSONMode, printJSON, table } from "../lib/format.js";
+import { api, withQuery } from "../lib/api.js";
+import { success, isJSONMode, printJSON, table } from "../lib/format.js";
+import { pickWorkspace, resolveWorkspace } from "../lib/picker.js";
 
 interface Project {
   id: string;
@@ -8,6 +10,8 @@ interface Project {
   slug: string;
   role: string;
   memberCount: number;
+  workspaceId?: string | null;
+  workspaceName?: string | null;
   createdAt: number;
 }
 
@@ -19,8 +23,15 @@ export function registerProjects(program: Command) {
   proj
     .command("list")
     .description("List all projects")
-    .action(async () => {
-      const projects = await api.get<Project[]>("/api/projects");
+    .option("-w, --workspace <ws>", "Filter by workspace id, slug, or name")
+    .action(async (opts) => {
+      let workspaceId: string | undefined;
+      if (opts.workspace) {
+        workspaceId = (await resolveWorkspace(opts.workspace)).id;
+      }
+      const projects = await api.get<Project[]>(
+        withQuery("/api/projects", { workspaceId }),
+      );
 
       if (isJSONMode()) {
         printJSON(projects);
@@ -33,13 +44,39 @@ export function registerProjects(program: Command) {
       }
 
       table(
-        ["Name", "ID", "Role", "Members"],
+        ["Name", "Workspace", "Slug", "Role", "Members"],
         projects.map((p) => [
           p.name,
-          p.id,
+          p.workspaceName || chalk.dim("—"),
+          p.slug,
           p.role || "owner",
           String(p.memberCount || 1),
         ]),
       );
     });
+
+  proj
+    .command("create")
+    .argument("<name>", "Project name")
+    .description("Create a new project without linking it to this directory")
+    .option("-w, --workspace <ws>", "Workspace to create the project in")
+    .action(async (name: string, opts) => {
+      const workspace = await pickWorkspace({ flag: opts.workspace });
+      const project = await api.post<Project>("/api/projects", {
+        name,
+        workspaceId: workspace.id,
+      });
+
+      if (isJSONMode()) {
+        printJSON({
+          ...project,
+          workspaceId: project.workspaceId ?? workspace.id,
+          workspaceName: project.workspaceName ?? workspace.name,
+        });
+      } else {
+        success(
+          `Project ${chalk.bold(project.name)} created in ${chalk.bold(workspace.name)}`,
+        );
+      }
+    });
 }

package/src/commands/ps.ts

@@ -1,80 +1,59 @@
 import chalk from "chalk";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
-import { resolveProjectId } from "../lib/config.js";
-import {
-  isJSONMode,
-  printJSON,
-  table,
-  statusColor,
-} from "../lib/format.js";
-
-interface Service {
-  id: string;
-  name: string;
-  type: "app" | "addon";
-  addonType?: string;
-  status: string;
-  domain?: string;
-  hostname?: string;
-  createdAt?: number;
-}
+import { api, withScope } from "../lib/api.js";
+import { getProjectLink } from "../lib/config.js";
+import { resolveProjectScope } from "../lib/resolve.js";
+import { isJSONMode, printJSON, table, statusColor } from "../lib/format.js";
 
 export function registerPs(program: Command) {
   program
     .command("ps")
     .description("List all services in the project")
-    .action(async () => {
-      const projectId = resolveProjectId(program.opts().project);
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
       const data = await api.get<{ apps: any[]; addons: any[] }>(
-        `/api/projects/${projectId}/services`,
+        withScope(`/api/projects/${projectId}/services`, scope),
       );
 
-      const services: Service[] = [];
-
-      for (const app of data.apps || []) {
-        services.push({
-          id: app.id,
-          name: app.name,
-          type: "app",
-          status: app.status,
-          domain: app.domain,
-          createdAt: app.createdAt,
-        });
+      if (isJSONMode()) {
+        printJSON(data);
+        return;
       }
 
-      for (const addon of data.addons || []) {
-        services.push({
-          id: addon.id,
-          name: addon.name || addon.addonType,
-          type: "addon",
-          addonType: addon.addonType,
-          status: addon.status,
-          hostname: addon.hostname,
-          createdAt: addon.createdAt,
-        });
-      }
+      const apps = data.apps || [];
+      const addons = data.addons || [];
 
-      if (isJSONMode()) {
-        printJSON(services);
+      if (apps.length === 0 && addons.length === 0) {
+        console.log("No services. Use `lizard add` or `lizard up`.");
         return;
       }
 
-      if (services.length === 0) {
-        console.log("No services. Use `lizard add` or `lizard deploy`.");
-        return;
+      const linkedId = getProjectLink()?.serviceId;
+
+      if (apps.length > 0) {
+        table(
+          ["App", "Status", "URL", "Linked"],
+          apps.map((a: any) => [
+            a.name || a.id,
+            statusColor(a.status),
+            a.domain ? chalk.cyan(`https://${a.domain}`) : chalk.dim("—"),
+            a.id === linkedId ? chalk.green("✓") : "",
+          ]),
+        );
       }
 
-      table(
-        ["Name", "Type", "Status", "URL/Host"],
-        services.map((s) => [
-          s.name,
-          s.addonType || s.type,
-          statusColor(s.status),
-          s.domain
-            ? `https://${s.domain}`
-            : s.hostname || chalk.dim("—"),
-        ]),
-      );
+      if (addons.length > 0) {
+        if (apps.length > 0) console.log();
+        table(
+          ["Addon", "Type", "Status", "Host"],
+          addons.map((a: any) => [
+            a.name || a.type,
+            a.type,
+            statusColor(a.status),
+            a.hostname ? chalk.dim(a.hostname) : chalk.dim("—"),
+          ]),
+        );
+      }
     });
 }