@solcreek/cli 0.4.10 → 0.4.11

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,233 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+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";
+/**
+ * `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: "(Step 7 — not yet implemented) Live tail via WebSocket.",
+        },
+        ...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) {
+            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) {
+            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) {
+            consola.warn(`Truncated to ${response.entries.length} entries — refine --since/--limit to see more.`);
+        }
+    },
+});
+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`);
+    }
+}
+function safeStringify(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+//# 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.11",
   "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",