@lizard-build/cli 0.3.41 → 0.3.43

package/src/commands/logs.ts

@@ -2,8 +2,9 @@ import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { Command } from "commander";
 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";
+import { resolveProjectScope, resolveService, getActiveServiceWithKind } from "../lib/resolve.js";
+import { getProjectLink } from "../lib/config.js";
+import { info, error, warn, isTTY, isJSONMode, printJSON, table, statusColor, timeAgo } from "../lib/format.js";
 
 export function registerLogs(program: Command) {
   program
@@ -20,6 +21,10 @@ export function registerLogs(program: Command) {
         error("Use --restarts (list) or --restart <id> (detail), not both");
         process.exit(1);
       }
+      if (opts.tail !== undefined && (opts.restarts !== undefined || opts.restart !== undefined)) {
+        error("--tail cannot be combined with --restarts/--restart");
+        process.exit(1);
+      }
 
       const { projectId, scope } = await resolveProjectScope(opts.project);
 
@@ -50,14 +55,22 @@ export function registerLogs(program: Command) {
       // branch below talks to the API with a real service ID.
       let serviceId: string | undefined;
       let serviceName: string | undefined;
+      let serviceKind: "app" | "addon" | undefined;
       if (opts.service) {
         const svc = await resolveService(projectId, opts.service);
         serviceId = svc.id;
         serviceName = svc.name;
+        serviceKind = svc.kind;
       }
 
       // --tail: fetch historical logs and exit
       if (tailN !== undefined) {
+        if (opts.service && !serviceName) {
+          // An empty name would be dropped from the query string and the
+          // filter would silently match every service.
+          error(`Service "${opts.service}" has no name to filter logs by`);
+          process.exit(1);
+        }
         // The project log stream tags entries with the service *name*
         // (not ID), so the historical filter must use the name too.
         const entries = await api.get<any[]>(
@@ -75,12 +88,13 @@ export function registerLogs(program: Command) {
 
       if (!serviceId && isTTY() && !isJSONMode()) {
         // Offer to pick a specific service or stream all
-        const data = await api.get<{ apps: any[] }>(
+        const data = await api.get<{ apps: any[]; addons?: any[] }>(
           withScope(`/api/projects/${projectId}/services`, scope),
         );
         const apps = data.apps || [];
+        const addons = data.addons || [];
 
-        if (apps.length > 1) {
+        if (apps.length + addons.length > 1) {
           const choices = [
             { value: "all", label: "All services", hint: "stream combined logs" },
             ...apps.map((a: any) => ({
@@ -88,24 +102,42 @@ export function registerLogs(program: Command) {
               label: a.name || a.id,
               hint: a.status,
             })),
+            ...addons.map((a: any) => ({
+              value: a.id,
+              label: a.name || a.addonType || 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 (selected !== "all") {
+            serviceId = selected as string;
+            serviceKind = addons.some((a: any) => a.id === selected) ? "addon" : "app";
+          }
         }
       }
 
+      const onReconnect = (attempt: number) =>
+        warn(`log stream lost — reconnecting (attempt ${attempt}/5)`);
+      const streamHandler = (event: string, data: string) => {
+        if (event === "error") {
+          error(data);
+          process.exitCode = 1;
+          return false;
+        }
+        printLogLine(data);
+        return true;
+      };
+
       if (serviceId) {
-        // Stream logs for a specific app
+        // Stream logs for a specific service. Addons live on a different
+        // endpoint — the app one 404s for them.
+        const streamPath =
+          serviceKind === "addon"
+            ? withScope(`/api/projects/${projectId}/addons/${serviceId}/logs`, scope)
+            : `/api/apps/${serviceId}/logs`;
         info(chalk.dim("Streaming logs... (Ctrl+C to stop)\n"));
-        await streamSSE(`/api/apps/${serviceId}/logs`, (event, data) => {
-          if (event === "error") {
-            error(data);
-            return false;
-          }
-          printLogLine(data);
-          return true;
-        });
+        await streamSSE(streamPath, streamHandler, { reconnect: true, onReconnect });
         return;
       }
 
@@ -113,14 +145,8 @@ export function registerLogs(program: Command) {
       info(chalk.dim("Streaming project logs... (Ctrl+C to stop)\n"));
       await streamSSE(
         withScope(`/api/projects/${projectId}/logs/stream`, scope),
-        (event, data) => {
-          if (event === "error") {
-            error(data);
-            return false;
-          }
-          printLogLine(data);
-          return true;
-        },
+        streamHandler,
+        { reconnect: true, onReconnect },
       );
     });
 }
@@ -174,6 +200,19 @@ type FlatEvent = DeployEvent["events"][number] & {
 
 async function fetchFlatRestarts(appId: string): Promise<FlatEvent[]> {
   const builds = await api.get<DeployEvent[]>(`/api/apps/${appId}/deploy-events`);
+  // The plain listing is DB-only; crash events still held by vm-agent are
+  // merged in by the server only when a buildId is given. Refetch the newest
+  // build so `--restart latest` sees crashes that haven't been persisted yet.
+  if (builds.length > 0) {
+    try {
+      const [withLive] = await api.get<DeployEvent[]>(
+        withQuery(`/api/apps/${appId}/deploy-events`, { buildId: builds[0].buildId }),
+      );
+      if (withLive && withLive.buildId === builds[0].buildId) builds[0] = withLive;
+    } catch {
+      // node unreachable — the DB-only list is still useful
+    }
+  }
   const flat: FlatEvent[] = [];
   for (const b of builds) {
     for (const e of b.events) {
@@ -228,12 +267,27 @@ function printLogLine(data: string) {
   }
 }
 
+/** Resolve the target for app-only subcommands; addons have no builds or
+ *  restart events, so fail with a clear message instead of a server 404. */
+async function getActiveApp(
+  serviceRef: string | undefined,
+  projectId: string,
+  what: string,
+): Promise<{ id: string; name: string }> {
+  const svc = await getActiveServiceWithKind(serviceRef, projectId);
+  if (svc.kind === "addon") {
+    error(`${what} are only available for apps — "${svc.name}" is an addon`);
+    process.exit(1);
+  }
+  return { id: svc.id, name: svc.name };
+}
+
 async function showRestartList(
   serviceRef: string | undefined,
   projectId: string,
   n: number,
 ) {
-  const svc = await getActiveService(serviceRef, projectId);
+  const svc = await getActiveApp(serviceRef, projectId, "Restart events");
   const events = await fetchFlatRestarts(svc.id);
   const slice = events.slice(0, n);
 
@@ -272,7 +326,7 @@ async function showRestartLogTail(
   projectId: string,
   ref: string,
 ) {
-  const svc = await getActiveService(serviceRef, projectId);
+  const svc = await getActiveApp(serviceRef, projectId, "Restart events");
   const events = await fetchFlatRestarts(svc.id);
 
   let evt: FlatEvent | undefined;
@@ -319,13 +373,11 @@ async function showBuildLogs(
   tailN?: number,
 ) {
   let appId: string | undefined;
-  if (serviceRef) {
-    const svc = await resolveService(projectId, serviceRef);
+  if (serviceRef || getProjectLink()?.serviceId) {
+    // Explicit -s flag, or the service linked to this cwd.
+    const svc = await getActiveApp(serviceRef, projectId, "Build logs");
     appId = svc.id;
-  }
-
-  if (!appId) {
-    // Get first app in project
+  } else {
     const data = await api.get<{ apps: Array<{ id: string; name: string }> }>(
       withScope(`/api/projects/${projectId}/services`, scope),
     );
@@ -335,6 +387,9 @@ async function showBuildLogs(
       );
     }
     appId = data.apps[0].id;
+    if (data.apps.length > 1) {
+      info(chalk.dim(`Multiple apps — showing ${data.apps[0].name}. Use -s to pick another.`));
+    }
   }
 
   // Get latest build
@@ -354,24 +409,45 @@ async function showBuildLogs(
     // Snapshot semantics: the server replays history immediately; if the
     // build is still running the stream would otherwise follow it forever.
     // Stop after 3s without new events and print what we have.
-    const lines: string[] = [];
+    //
+    // Each SSE event carries a multi-line *chunk* (a logSnippet delta), not a
+    // single line — for a finished build the whole log arrives as one event.
+    // Reassemble the text first, then tail by line.
+    const chunks: string[] = [];
     await streamSSE(
       `/api/builds/${buildId}/logs`,
       (event, data) => {
         if (event === "done" || event === "error") return false;
-        lines.push(data);
+        try {
+          const parsed = JSON.parse(data);
+          chunks.push(typeof parsed === "string" ? parsed : data);
+        } catch {
+          chunks.push(data);
+        }
         return true;
       },
       { idleTimeoutMs: 3000 },
     );
-    for (const line of lines.slice(-tailN)) printLogLine(line);
+    const lines = chunks.join("").split("\n");
+    while (lines.length && lines[lines.length - 1] === "") lines.pop();
+    for (const line of lines.slice(-tailN)) {
+      if (isJSONMode()) {
+        process.stdout.write(JSON.stringify({ message: line }) + "\n");
+      } else {
+        process.stdout.write(line + "\n");
+      }
+    }
     return;
   }
 
   await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
-    if (event === "done" || event === "error") {
+    if (event === "error") {
+      // The human-readable "--- Build failed ---" line already arrived as a
+      // data event; just make the failure visible to scripts.
+      process.exitCode = 1;
       return false;
     }
+    if (event === "done") return false;
     printLogLine(data);
     return true;
   });

package/src/lib/api.ts

@@ -129,90 +129,178 @@ export const api = {
   delete: <T = any>(path: string) => request<T>("DELETE", path),
 };
 
-/** Stream SSE and call handler for each data line. Return false to stop.
+/** Compare two Redis-stream-style event ids (`<ms>-<seq>`). Returns true when
+ *  `id` is at or before `last` — i.e. a replayed event we've already shown.
+ *  Ids in any other format never count as replays. */
+function isReplayedId(id: string, last: string): boolean {
+  const a = id.split("-").map(Number);
+  const b = last.split("-").map(Number);
+  if (a.length !== 2 || b.length !== 2 || a.some(Number.isNaN) || b.some(Number.isNaN)) {
+    return false;
+  }
+  return a[0] < b[0] || (a[0] === b[0] && a[1] <= b[1]);
+}
+
+const MAX_RECONNECT_ATTEMPTS = 5;
+
+/** Stream SSE and call handler for each event. Return false to stop.
  *
  *  `opts.idleTimeoutMs` — stop (resolve) when no *event* arrives for that
  *  long. Heartbeat comments don't reset the timer. Used by `--tail`-style
- *  snapshot reads that must not follow a live stream forever. */
+ *  snapshot reads that must not follow a live stream forever.
+ *
+ *  `opts.reconnect` — re-establish the connection when the server drops it
+ *  (API deploys, proxy idle timeouts). Resumes via `Last-Event-ID` and
+ *  suppresses events the server replays from before the drop. Rejects after
+ *  MAX_RECONNECT_ATTEMPTS consecutive failures so callers exit non-zero
+ *  instead of pretending the stream ended cleanly. `opts.onReconnect` fires
+ *  before each attempt. */
 export function streamSSE(
   path: string,
   handler: (event: string, data: string) => boolean | void,
-  opts: { idleTimeoutMs?: number } = {},
+  opts: {
+    idleTimeoutMs?: number;
+    reconnect?: boolean;
+    onReconnect?: (attempt: number) => void;
+    /** Base backoff between reconnect attempts; scaled by attempt number. */
+    reconnectBaseDelayMs?: number;
+  } = {},
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     const url = new URL(baseURL + path);
     const token = _accessToken || getToken();
-    const reqHeaders: Record<string, string> = {
-      "User-Agent": USER_AGENT,
-      Accept: "text/event-stream",
+    const transport = url.protocol === "https:" ? https : http;
+
+    let finished = false;
+    let attempts = 0;
+    let lastEventId: string | undefined;
+    // Id of the last event handed to the handler — replay marker across reconnects.
+    let lastDispatchedId: string | undefined;
+
+    const settle = (err?: unknown) => {
+      if (finished) return;
+      finished = true;
+      if (err) reject(err);
+      else resolve();
     };
-    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 + url.search, method: "GET", headers: reqHeaders },
-      (res) => {
-        if (res.statusCode && res.statusCode >= 400) {
-          let body = "";
-          res.on("data", (c: Buffer) => body += c.toString());
-          res.on("end", () => reject(new APIError(res.statusCode!, `SSE failed: ${body}`)));
-          return;
-        }
-
-        let idleTimer: NodeJS.Timeout | undefined;
-        const finish = () => {
-          if (idleTimer) clearTimeout(idleTimer);
-          req.destroy();
-          resolve();
-        };
-        const armIdleTimer = () => {
-          if (!opts.idleTimeoutMs) return;
-          if (idleTimer) clearTimeout(idleTimer);
-          idleTimer = setTimeout(finish, opts.idleTimeoutMs);
-        };
-        armIdleTimer();
-
-        let buffer = "";
-        let currentEvent = "";
-        let currentData = "";
-
-        res.setEncoding("utf8");
-        res.on("data", (chunk: string) => {
-          buffer += chunk;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-
-          for (const line of lines) {
-            const trimmed = line.replace(/\r$/, "");
-            if (trimmed === "") {
-              if (currentData) {
-                armIdleTimer();
-                const cont = handler(currentEvent, currentData);
-                if (cont === false) {
-                  finish();
-                  return;
+    // Connection dropped without the handler asking to stop.
+    const dropped = (err?: unknown) => {
+      if (finished) return;
+      if (!opts.reconnect) {
+        settle(err);
+        return;
+      }
+      attempts++;
+      if (attempts > MAX_RECONNECT_ATTEMPTS) {
+        settle(
+          err instanceof Error
+            ? err
+            : new Error("SSE stream disconnected and reconnect attempts failed"),
+        );
+        return;
+      }
+      opts.onReconnect?.(attempts);
+      const base = opts.reconnectBaseDelayMs ?? 1000;
+      setTimeout(connect, Math.min(base * attempts, base * 5));
+    };
+
+    const connect = () => {
+      if (finished) return;
+      const reqHeaders: Record<string, string> = {
+        "User-Agent": USER_AGENT,
+        Accept: "text/event-stream",
+      };
+      if (token) reqHeaders["Authorization"] = `Bearer ${token}`;
+      if (lastEventId) reqHeaders["Last-Event-ID"] = lastEventId;
+
+      const req = transport.request(
+        { hostname: url.hostname, port: url.port || (url.protocol === "https:" ? 443 : 80),
+          path: url.pathname + url.search, method: "GET", headers: reqHeaders },
+        (res) => {
+          if (res.statusCode && res.statusCode >= 400) {
+            let body = "";
+            res.on("data", (c: Buffer) => body += c.toString());
+            res.on("end", () => settle(new APIError(res.statusCode!, `SSE failed: ${body}`)));
+            return;
+          }
+
+          let idleTimer: NodeJS.Timeout | undefined;
+          const finish = () => {
+            if (idleTimer) clearTimeout(idleTimer);
+            finished = true;
+            req.destroy();
+            resolve();
+          };
+          const armIdleTimer = () => {
+            if (!opts.idleTimeoutMs) return;
+            if (idleTimer) clearTimeout(idleTimer);
+            idleTimer = setTimeout(finish, opts.idleTimeoutMs);
+          };
+          armIdleTimer();
+
+          let buffer = "";
+          let currentEvent = "";
+          let currentId: string | undefined;
+          let dataLines: string[] = [];
+
+          res.setEncoding("utf8");
+          res.on("data", (chunk: string) => {
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+
+            for (const line of lines) {
+              const trimmed = line.replace(/\r$/, "");
+              if (trimmed === "") {
+                const data = dataLines.join("\n");
+                if (data) {
+                  attempts = 0; // stream is healthy — reset the reconnect budget
+                  armIdleTimer();
+                  // After a reconnect the app-log endpoint replays recent
+                  // history; skip entries we already printed.
+                  const replay =
+                    opts.reconnect && currentId && lastDispatchedId
+                      ? isReplayedId(currentId, lastDispatchedId)
+                      : false;
+                  if (!replay) {
+                    if (currentId) lastDispatchedId = currentId;
+                    const cont = handler(currentEvent, data);
+                    if (cont === false) {
+                      finish();
+                      return;
+                    }
+                  }
                 }
+                currentEvent = "";
+                currentId = undefined;
+                dataLines = [];
+              } else if (trimmed.startsWith("event:")) {
+                currentEvent = trimmed.slice(6).trim();
+              } else if (trimmed.startsWith("data:")) {
+                dataLines.push(trimmed.slice(5).trimStart());
+              } else if (trimmed.startsWith("id:")) {
+                currentId = trimmed.slice(3).trim();
+                lastEventId = currentId;
               }
-              currentEvent = "";
-              currentData = "";
-            } else if (trimmed.startsWith("event:")) {
-              currentEvent = trimmed.slice(6).trim();
-            } else if (trimmed.startsWith("data:")) {
-              currentData = trimmed.slice(5).trimStart();
             }
-          }
-        });
-
-        res.on("end", () => {
-          if (idleTimer) clearTimeout(idleTimer);
-          resolve();
-        });
-        res.on("error", reject);
-      },
-    );
-
-    req.on("error", reject);
-    req.end();
+          });
+
+          res.on("end", () => {
+            if (idleTimer) clearTimeout(idleTimer);
+            dropped();
+          });
+          res.on("error", (err) => {
+            if (idleTimer) clearTimeout(idleTimer);
+            dropped(err);
+          });
+        },
+      );
+
+      req.on("error", dropped);
+      req.end();
+    };
+
+    connect();
   });
 }

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "0.3.41";
+export const CURRENT_VERSION = "0.3.43";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";