@solcreek/cli 0.4.10 → 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.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `creek logs` — read structured tenant logs from R2 archive.
+ *
+ * Auth: requires `creek login`. Server is responsible for tenant
+ * isolation — the CLI simply targets the project slug, the
+ * authenticated session decides which team's logs are visible.
+ *
+ * Project resolution: --project flag wins; otherwise resolve from
+ * cwd creek.toml / wrangler.*. If neither, error with hint.
+ *
+ * `--follow` is reserved for Step 7 (WebSocket subscribe). For now
+ * the command is one-shot historical query.
+ *
+ * Output:
+ *   default → human-friendly multi-line per entry, colored by
+ *             outcome (ok=dim, exception=red, etc.)
+ *   --json  → newline-delimited LogEntry JSON, suitable for `| jq`
+ */
+export declare const logsCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    project: {
+        type: "string";
+        description: string;
+    };
+    since: {
+        type: "string";
+        description: string;
+    };
+    until: {
+        type: "string";
+        description: string;
+    };
+    outcome: {
+        type: "string";
+        description: string;
+    };
+    "script-type": {
+        type: "string";
+        description: string;
+    };
+    deployment: {
+        type: "string";
+        description: string;
+    };
+    branch: {
+        type: "string";
+        description: string;
+    };
+    level: {
+        type: "string";
+        description: string;
+    };
+    search: {
+        type: "string";
+        description: string;
+    };
+    limit: {
+        type: "string";
+        description: string;
+    };
+    follow: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/commands/logs.js

@@ -0,0 +1,355 @@
+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.
+ *
+ * Auth: requires `creek login`. Server is responsible for tenant
+ * isolation — the CLI simply targets the project slug, the
+ * authenticated session decides which team's logs are visible.
+ *
+ * Project resolution: --project flag wins; otherwise resolve from
+ * cwd creek.toml / wrangler.*. If neither, error with hint.
+ *
+ * `--follow` is reserved for Step 7 (WebSocket subscribe). For now
+ * the command is one-shot historical query.
+ *
+ * Output:
+ *   default → human-friendly multi-line per entry, colored by
+ *             outcome (ok=dim, exception=red, etc.)
+ *   --json  → newline-delimited LogEntry JSON, suitable for `| jq`
+ */
+export const logsCommand = defineCommand({
+    meta: {
+        name: "logs",
+        description: "Read recent log entries for a project",
+    },
+    args: {
+        project: {
+            type: "string",
+            description: "Project slug. Defaults to creek.toml in cwd.",
+        },
+        since: {
+            type: "string",
+            description: "Time window start. Relative (1h, 30m, 2d) or ISO. Default: 1h",
+        },
+        until: {
+            type: "string",
+            description: 'Time window end. "now" or ISO. Default: now',
+        },
+        outcome: {
+            type: "string",
+            description: "Filter by tail outcome. Repeatable via comma (ok,exception).",
+        },
+        "script-type": {
+            type: "string",
+            description: "Filter by production/branch/deployment. Repeatable via comma.",
+        },
+        deployment: {
+            type: "string",
+            description: "8-hex deploy id — scopes to that single deployment preview.",
+        },
+        branch: {
+            type: "string",
+            description: "Branch name — scopes to that branch preview.",
+        },
+        level: {
+            type: "string",
+            description: "Filter by console level (error,warn,...). Entry needs at least one matching log line.",
+        },
+        search: {
+            type: "string",
+            description: "Substring match against console messages, exceptions, and request URLs.",
+        },
+        limit: {
+            type: "string",
+            description: "Max entries to print. Default 100, max 1000.",
+        },
+        follow: {
+            type: "boolean",
+            description: "Live tail via WebSocket. Prints recent context first, then streams new entries until Ctrl+C.",
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const token = getToken();
+        if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated" }, 1, AUTH_BREADCRUMBS);
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        const projectSlug = await resolveProjectSlug(args.project, jsonMode);
+        const client = new CreekClient(getApiUrl(), token);
+        const filters = {
+            ...(args.since ? { since: args.since } : {}),
+            ...(args.until ? { until: args.until } : {}),
+            ...(args.deployment ? { deployment: args.deployment } : {}),
+            ...(args.branch ? { branch: args.branch } : {}),
+            ...(args.search ? { search: args.search } : {}),
+            ...(args.limit ? { limit: Number(args.limit) } : {}),
+            ...(args.outcome
+                ? { outcomes: parseList(args.outcome) }
+                : {}),
+            ...(args["script-type"]
+                ? {
+                    scriptTypes: parseList(args["script-type"]),
+                }
+                : {}),
+            ...(args.level
+                ? { levels: parseList(args.level) }
+                : {}),
+        };
+        let response;
+        try {
+            response = await client.getLogs(projectSlug, filters);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "logs_failed", message: msg }, 1, []);
+            consola.error(`Failed to read logs: ${msg}`);
+            process.exit(1);
+        }
+        if (jsonMode) {
+            // ndjson — easy to pipe to jq
+            for (const entry of response.entries) {
+                process.stdout.write(JSON.stringify(entry) + "\n");
+            }
+            if (response.truncated) {
+                process.stderr.write(`# truncated — more entries match. Refine --since/--limit to narrow.\n`);
+            }
+            return;
+        }
+        if (response.entries.length === 0 && !args.follow) {
+            consola.info("No log entries match the query.");
+            return;
+        }
+        // Human output: oldest at top so the latest entry is closest to the prompt.
+        const ordered = [...response.entries].reverse();
+        for (const entry of ordered) {
+            printEntry(entry);
+        }
+        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;
+    let resolved;
+    try {
+        resolved = resolveConfig(process.cwd());
+    }
+    catch (err) {
+        if (err instanceof ConfigNotFoundError) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "no_project", message: "No project config in cwd" }, 1, NO_PROJECT_BREADCRUMBS);
+            consola.error("No project config in cwd. Pass --project <slug>.");
+            process.exit(1);
+        }
+        throw err;
+    }
+    return resolved.projectName;
+}
+function parseList(input) {
+    return input
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+const COLOR = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+};
+function color(s, c) {
+    return process.stdout.isTTY ? `${COLOR[c]}${s}${COLOR.reset}` : s;
+}
+function printEntry(entry) {
+    const ts = new Date(entry.timestamp).toISOString().replace("T", " ").slice(0, 19);
+    const outcomeColor = entry.outcome === "ok"
+        ? "gray"
+        : entry.outcome === "exception"
+            ? "red"
+            : "yellow";
+    const status = entry.request?.status;
+    const statusStr = status === undefined
+        ? ""
+        : status >= 500
+            ? color(String(status), "red")
+            : status >= 400
+                ? color(String(status), "yellow")
+                : color(String(status), "green");
+    const variant = entry.scriptType === "production"
+        ? ""
+        : entry.scriptType === "branch"
+            ? ` [branch ${entry.branch}]`
+            : ` [deploy ${entry.deployId}]`;
+    const headline = [
+        color(ts, "dim"),
+        color(entry.outcome, outcomeColor),
+        entry.request?.method ?? "—",
+        entry.request?.url
+            ? new URL(entry.request.url).pathname + new URL(entry.request.url).search
+            : "—",
+        statusStr,
+        color(variant, "dim"),
+    ]
+        .filter(Boolean)
+        .join(" ");
+    process.stdout.write(headline + "\n");
+    for (const log of entry.logs) {
+        const levelColor = log.level === "error" ? "red" : log.level === "warn" ? "yellow" : "cyan";
+        const msg = log.message
+            .map((m) => (typeof m === "string" ? m : safeStringify(m)))
+            .join(" ");
+        process.stdout.write(`  ${color(log.level.padEnd(5), levelColor)} ${msg}\n`);
+    }
+    for (const ex of entry.exceptions) {
+        process.stdout.write(`  ${color("exc", "red")} ${color(ex.name, "red")}: ${ex.message}\n`);
+    }
+}
+// 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/dist/index.js

@@ -18,6 +18,7 @@ import { devCommand } from "./commands/dev.js";
 import { rollbackCommand } from "./commands/rollback.js";
 import { opsCommand } from "./commands/ops.js";
 import { queueCommand } from "./commands/queue.js";
+import { logsCommand } from "./commands/logs.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const cliPkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 // Read version from the "creek" facade package (what users install),
@@ -43,6 +44,7 @@ const main = defineCommand({
         status: statusCommand,
         projects: projectsCommand,
         deployments: deploymentsCommand,
+        logs: logsCommand,
         login: loginCommand,
         whoami: whoamiCommand,
         init: initCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +33,7 @@
     "esbuild": "^0.25.0",
     "smol-toml": "^1.3.1",
     "ws": "^8.20.0",
-    "@solcreek/sdk": "0.4.4"
+    "@solcreek/sdk": "0.4.5"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",