@solcreek/cli 0.4.11 → 0.4.12

package/dist/commands/logs-filter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pure filter logic for `creek logs --follow`.
+ *
+ * Historical mode (`creek logs --since`) gets server-side filtering;
+ * live mode (`--follow`) receives ALL log events for the project's
+ * realtime room and must filter client-side. This module is the
+ * mirror of control-plane/src/modules/logs/query.ts:matchesQuery —
+ * if those drift, --follow shows different entries than --since
+ * for the same flags.
+ */
+import type { LogEntry, LogQueryFilters } from "@solcreek/sdk";
+export declare function matchesClientSide(entry: LogEntry, filters: LogQueryFilters): boolean;
+export declare function describeFilters(filters: LogQueryFilters): string;
+export declare function safeStringify(v: unknown): string;
+//# sourceMappingURL=logs-filter.d.ts.map

package/dist/commands/logs-filter.js

@@ -0,0 +1,66 @@
+/**
+ * Pure filter logic for `creek logs --follow`.
+ *
+ * Historical mode (`creek logs --since`) gets server-side filtering;
+ * live mode (`--follow`) receives ALL log events for the project's
+ * realtime room and must filter client-side. This module is the
+ * mirror of control-plane/src/modules/logs/query.ts:matchesQuery —
+ * if those drift, --follow shows different entries than --since
+ * for the same flags.
+ */
+export function matchesClientSide(entry, filters) {
+    if (filters.outcomes?.length && !filters.outcomes.includes(entry.outcome))
+        return false;
+    if (filters.scriptTypes?.length && !filters.scriptTypes.includes(entry.scriptType))
+        return false;
+    if (filters.deployment && entry.deployId !== filters.deployment)
+        return false;
+    if (filters.branch && entry.branch !== filters.branch)
+        return false;
+    if (filters.levels?.length) {
+        const hit = entry.logs.some((l) => filters.levels.includes(l.level));
+        if (!hit)
+            return false;
+    }
+    if (filters.search) {
+        if (!searchMatches(entry, filters.search))
+            return false;
+    }
+    return true;
+}
+function searchMatches(entry, needle) {
+    const n = needle.toLowerCase();
+    const haystack = entry.logs
+        .flatMap((l) => l.message.map((m) => (typeof m === "string" ? m : safeStringify(m))))
+        .join(" ") +
+        " " +
+        entry.exceptions.map((e) => `${e.name} ${e.message}`).join(" ") +
+        " " +
+        (entry.request?.url ?? "");
+    return haystack.toLowerCase().includes(n);
+}
+export function describeFilters(filters) {
+    const bits = [];
+    if (filters.outcomes?.length)
+        bits.push(`outcome=${filters.outcomes.join(",")}`);
+    if (filters.scriptTypes?.length)
+        bits.push(`scriptType=${filters.scriptTypes.join(",")}`);
+    if (filters.deployment)
+        bits.push(`deployment=${filters.deployment}`);
+    if (filters.branch)
+        bits.push(`branch=${filters.branch}`);
+    if (filters.levels?.length)
+        bits.push(`level=${filters.levels.join(",")}`);
+    if (filters.search)
+        bits.push(`search="${filters.search}"`);
+    return bits.length === 0 ? "(none)" : bits.join(" ");
+}
+export function safeStringify(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+//# sourceMappingURL=logs-filter.js.map

package/dist/commands/logs.js

@@ -1,8 +1,10 @@
 import { defineCommand } from "citty";
 import consola from "consola";
+import WebSocket from "ws";
 import { CreekClient, resolveConfig, ConfigNotFoundError, } from "@solcreek/sdk";
 import { getToken, getApiUrl } from "../utils/config.js";
 import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS, } from "../utils/output.js";
+import { matchesClientSide, describeFilters, safeStringify as ssExport } from "./logs-filter.js";
 /**
  * `creek logs` — read structured tenant logs from R2 archive.
  *
@@ -69,15 +71,11 @@ export const logsCommand = defineCommand({
         },
         follow: {
             type: "boolean",
-            description: "(Step 7 — not yet implemented) Live tail via WebSocket.",
+            description: "Live tail via WebSocket. Prints recent context first, then streams new entries until Ctrl+C.",
         },
         ...globalArgs,
     },
     async run({ args }) {
-        if (args.follow) {
-            consola.warn("--follow is not yet implemented (Phase 8 Step 7).");
-            consola.info("This command currently returns historical entries only.");
-        }
         const jsonMode = resolveJsonMode(args);
         const token = getToken();
         if (!token) {
@@ -128,7 +126,7 @@ export const logsCommand = defineCommand({
             }
             return;
         }
-        if (response.entries.length === 0) {
+        if (response.entries.length === 0 && !args.follow) {
             consola.info("No log entries match the query.");
             return;
         }
@@ -137,11 +135,140 @@ export const logsCommand = defineCommand({
         for (const entry of ordered) {
             printEntry(entry);
         }
-        if (response.truncated) {
+        if (response.truncated && !args.follow) {
             consola.warn(`Truncated to ${response.entries.length} entries — refine --since/--limit to see more.`);
         }
+        if (args.follow) {
+            // Track the newest historical timestamp so we can drop any
+            // duplicates that the WS would otherwise replay (R2 → realtime
+            // race window — the same event can appear on both within a
+            // ~second of being captured).
+            const seenAfter = response.entries.length > 0
+                ? Math.max(...response.entries.map((e) => e.timestamp))
+                : 0;
+            await follow(client, projectSlug, filters, seenAfter, jsonMode);
+        }
     },
 });
+/**
+ * Live tail via WebSocket. Mints a 5-min token via control-plane,
+ * connects to realtime-worker, and prints incoming `type: "log"`
+ * messages through the same printEntry path used for historical mode.
+ *
+ * Reconnect: realtime-worker drops the connection on any 5xx upstream
+ * (DO eviction, DO error, etc.). We retry with capped exponential
+ * backoff, re-mint the token (it could have expired during downtime).
+ *
+ * Token refresh: a single token is good for 5 min. For long-running
+ * tails we re-mint at 4 min — well before expiry — to avoid a
+ * mid-window 401 race with the WS handshake.
+ *
+ * Filter parity: the same client-side filter we'd apply to historical
+ * entries is applied to live entries too. Realtime push doesn't know
+ * about query filters; we filter here so `--outcome exception
+ * --follow` shows only exceptions.
+ */
+async function follow(client, projectSlug, filters, initialSeenAfter, jsonMode) {
+    if (!jsonMode) {
+        consola.info(`Live tail — Ctrl+C to exit. Filtering: ${describeFilters(filters)}`);
+    }
+    let seenAfter = initialSeenAfter;
+    let stopped = false;
+    process.on("SIGINT", () => {
+        stopped = true;
+        if (!jsonMode) {
+            process.stderr.write("\n");
+            consola.info("Stopped.");
+        }
+        process.exit(0);
+    });
+    const TOKEN_REFRESH_MS = 4 * 60 * 1000;
+    let backoffMs = 500;
+    const BACKOFF_MAX_MS = 15_000;
+    while (!stopped) {
+        let mintedAt;
+        let wsUrl;
+        try {
+            const minted = await client.getLogsWsToken(projectSlug);
+            mintedAt = Date.now();
+            wsUrl = minted.wsUrl;
+        }
+        catch (err) {
+            if (stopped)
+                return;
+            const msg = err instanceof Error ? err.message : String(err);
+            if (jsonMode)
+                process.stderr.write(`# ws-token failed: ${msg}\n`);
+            else
+                consola.warn(`Failed to mint subscribe token: ${msg}. Retrying in ${Math.round(backoffMs / 1000)}s.`);
+            await sleep(backoffMs);
+            backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX_MS);
+            continue;
+        }
+        const ws = new WebSocket(wsUrl);
+        let closed = false;
+        let refreshTimer = null;
+        await new Promise((resolve) => {
+            ws.on("open", () => {
+                backoffMs = 500; // reset on successful connect
+                // Force a clean reconnect just before token expiry.
+                const elapsed = Date.now() - mintedAt;
+                const remaining = Math.max(5_000, TOKEN_REFRESH_MS - elapsed);
+                refreshTimer = setTimeout(() => {
+                    if (!closed) {
+                        try {
+                            ws.close(1000, "token refresh");
+                        }
+                        catch { /* already closed */ }
+                    }
+                }, remaining);
+            });
+            ws.on("message", (data) => {
+                let parsed;
+                try {
+                    parsed = JSON.parse(data.toString());
+                }
+                catch {
+                    return;
+                }
+                if (parsed.type !== "log" || !parsed.entry)
+                    return;
+                const entry = parsed.entry;
+                // Skip duplicates the historical R2 read already showed.
+                if (entry.timestamp <= seenAfter)
+                    return;
+                // Apply client-side filters so flags work in --follow mode too.
+                if (!matchesClientSide(entry, filters))
+                    return;
+                seenAfter = Math.max(seenAfter, entry.timestamp);
+                if (jsonMode) {
+                    process.stdout.write(JSON.stringify(entry) + "\n");
+                }
+                else {
+                    printEntry(entry);
+                }
+            });
+            ws.on("close", () => {
+                closed = true;
+                if (refreshTimer)
+                    clearTimeout(refreshTimer);
+                resolve();
+            });
+            ws.on("error", () => {
+                // The "close" event will fire after this; resolve happens there.
+            });
+        });
+        if (stopped)
+            return;
+        // Brief backoff before reconnect — only meaningful if the close
+        // wasn't from our own token-refresh timer.
+        await sleep(backoffMs);
+        backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX_MS);
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
 async function resolveProjectSlug(override, jsonMode) {
     if (override)
         return override;
@@ -222,12 +349,7 @@ function printEntry(entry) {
         process.stdout.write(`  ${color("exc", "red")} ${color(ex.name, "red")}: ${ex.message}\n`);
     }
 }
-function safeStringify(v) {
-    try {
-        return JSON.stringify(v);
-    }
-    catch {
-        return String(v);
-    }
-}
+// safeStringify lives in logs-filter.js (re-exported for nested
+// console.log message rendering in printEntry below).
+const safeStringify = ssExport;
 //# sourceMappingURL=logs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",