@solcreek/cli 0.4.12 → 0.4.14

package/README.md

@@ -67,6 +67,9 @@ creek deploy https://github.com/user/repo/tree/main/packages/app
 | `creek deploy --dry-run` | Show the deploy plan without executing (agent-safe) |
 | `creek projects` | List your projects |
 | `creek deployments` | List deployments for a project |
+| `creek logs` | Read recent log entries (R2 archive) |
+| `creek logs --follow` | Live tail via WebSocket until Ctrl+C |
+| `creek logs --outcome exception` | Filter by tail outcome (or `--deployment`, `--branch`, `--level`, `--search`) |
 | `creek status` | Show current project status |
 | `creek login` | Authenticate with Creek |
 | `creek login --token <key>` | Authenticate in CI/CD (non-interactive) |

package/dist/commands/doctor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `creek doctor` — pre-deploy sanity check.
+ *
+ * Runs the SDK rule engine against the current project, reports
+ * findings. Exits 0 if ok, 1 if any error-severity finding fires.
+ *
+ * This is the one command designed for LLM agents to invoke before
+ * `creek deploy`. With `--json` the output is ndjson-adjacent (pretty
+ * JSON, but parseable), letting an agent look up fixes by stable
+ * CK-* codes and apply them without re-reading the source.
+ */
+export declare const doctorCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    path: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -0,0 +1,174 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { runDoctor, resolveConfig, ConfigNotFoundError, } from "@solcreek/sdk";
+import { globalArgs, resolveJsonMode, jsonOutput, } from "../utils/output.js";
+/**
+ * `creek doctor` — pre-deploy sanity check.
+ *
+ * Runs the SDK rule engine against the current project, reports
+ * findings. Exits 0 if ok, 1 if any error-severity finding fires.
+ *
+ * This is the one command designed for LLM agents to invoke before
+ * `creek deploy`. With `--json` the output is ndjson-adjacent (pretty
+ * JSON, but parseable), letting an agent look up fixes by stable
+ * CK-* codes and apply them without re-reading the source.
+ */
+export const doctorCommand = defineCommand({
+    meta: {
+        name: "doctor",
+        description: "Analyze the project for pre-deploy issues — missing build output, deprecated config keys, Workers-incompatible deps, portability leaks.",
+    },
+    args: {
+        path: {
+            type: "positional",
+            description: "Project directory to analyze. Defaults to cwd.",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const cwd = resolve(args.path ?? process.cwd());
+        const jsonMode = resolveJsonMode(args);
+        const ctx = buildContext(cwd);
+        const report = runDoctor(ctx);
+        if (jsonMode) {
+            jsonOutput({
+                ok: report.ok,
+                cwd,
+                archetype: report.archetype,
+                summary: report.summary,
+                findings: report.findings,
+            }, report.ok ? 0 : 1);
+            return;
+        }
+        printHuman(cwd, report);
+        if (!report.ok)
+            process.exit(1);
+    },
+});
+function buildContext(cwd) {
+    const fileExists = (relPath) => existsSync(join(cwd, relPath));
+    const creekTomlPath = join(cwd, "creek.toml");
+    const creekTomlRaw = existsSync(creekTomlPath)
+        ? safeRead(creekTomlPath)
+        : null;
+    const pkgPath = join(cwd, "package.json");
+    const packageJson = existsSync(pkgPath)
+        ? safeParseJson(pkgPath)
+        : null;
+    const resolved = resolveConfigSafely(cwd);
+    const allDeps = {
+        ...(packageJson?.dependencies ?? {}),
+        ...(packageJson?.devDependencies ?? {}),
+    };
+    return { cwd, resolved, packageJson, creekTomlRaw, fileExists, allDeps };
+}
+function resolveConfigSafely(cwd) {
+    try {
+        return resolveConfig(cwd);
+    }
+    catch (err) {
+        if (err instanceof ConfigNotFoundError)
+            return null;
+        // Other errors (parse failures) bubble as null — the rules will
+        // still pick up partial info from creekTomlRaw + packageJson.
+        return null;
+    }
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function safeParseJson(path) {
+    const raw = safeRead(path);
+    if (raw === null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Human output ───────────────────────────────────────────────────────
+const COLOR = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+};
+function tty() {
+    return process.stdout.isTTY ?? false;
+}
+function c(s, color) {
+    return tty() ? `${COLOR[color]}${s}${COLOR.reset}` : s;
+}
+function printHuman(cwd, report) {
+    consola.log("");
+    consola.log(`  ${c("⬡ creek doctor", "bold")}  ${c(cwd, "dim")}`);
+    consola.log(`  ${c("archetype:", "dim")} ${report.archetype ?? "unknown"}`);
+    consola.log("");
+    if (report.findings.length === 0) {
+        consola.log(`  ${c("✓", "green")} No issues detected. Deploy is good to go.`);
+        consola.log("");
+        return;
+    }
+    const order = ["error", "warn", "info"];
+    const grouped = groupBy(report.findings, (f) => f.severity);
+    for (const sev of order) {
+        const bucket = grouped.get(sev) ?? [];
+        for (const f of bucket) {
+            printFinding(f);
+        }
+    }
+    const parts = [];
+    if (report.summary.error)
+        parts.push(c(`${report.summary.error} error${s(report.summary.error)}`, "red"));
+    if (report.summary.warn)
+        parts.push(c(`${report.summary.warn} warning${s(report.summary.warn)}`, "yellow"));
+    if (report.summary.info)
+        parts.push(c(`${report.summary.info} info`, "cyan"));
+    consola.log(`  Summary: ${parts.join(", ")}`);
+    consola.log("");
+}
+function printFinding(f) {
+    const icon = f.severity === "error" ? c("✗", "red")
+        : f.severity === "warn" ? c("⚠", "yellow")
+            : c("ℹ", "cyan");
+    consola.log(`  ${icon} ${c(f.title, "bold")}  ${c(`[${f.code}]`, "gray")}`);
+    for (const line of f.detail.split("\n")) {
+        consola.log(`     ${c(line, "dim")}`);
+    }
+    consola.log(`     ${c("→ fix:", "cyan")}`);
+    for (const line of f.fix.split("\n")) {
+        consola.log(`       ${line}`);
+    }
+    if (f.references?.length) {
+        consola.log(`     ${c("→ refs:", "dim")} ${f.references.join(", ")}`);
+    }
+    consola.log("");
+}
+function groupBy(arr, key) {
+    const out = new Map();
+    for (const v of arr) {
+        const k = key(v);
+        const bucket = out.get(k) ?? [];
+        bucket.push(v);
+        out.set(k, bucket);
+    }
+    return out;
+}
+function s(n) {
+    return n === 1 ? "" : "s";
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/logs.js

@@ -116,38 +116,38 @@ export const logsCommand = defineCommand({
             consola.error(`Failed to read logs: ${msg}`);
             process.exit(1);
         }
+        // Print historical first, in both JSON and human mode. Ordering:
+        // oldest-at-top so the newest entry is closest to the prompt (and
+        // when --follow streams in below, it continues chronologically).
         if (jsonMode) {
-            // ndjson — easy to pipe to jq
             for (const entry of response.entries) {
                 process.stdout.write(JSON.stringify(entry) + "\n");
             }
-            if (response.truncated) {
+            if (response.truncated && !args.follow) {
                 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);
+        else {
+            if (response.entries.length === 0 && !args.follow) {
+                consola.info("No log entries match the query.");
+                return;
+            }
+            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.`);
+            }
         }
+        // No --follow → done.
+        if (!args.follow)
+            return;
+        // --follow → switch to WebSocket live tail.
+        const seenAfter = response.entries.length > 0
+            ? Math.max(...response.entries.map((e) => e.timestamp))
+            : 0;
+        await follow(client, projectSlug, filters, seenAfter, jsonMode);
     },
 });
 /**
@@ -254,8 +254,11 @@ async function follow(client, projectSlug, filters, initialSeenAfter, jsonMode)
                     clearTimeout(refreshTimer);
                 resolve();
             });
-            ws.on("error", () => {
+            ws.on("error", (err) => {
                 // The "close" event will fire after this; resolve happens there.
+                // Surface to stderr so reconnect storms aren't invisible.
+                if (!jsonMode)
+                    consola.warn(`ws error: ${err.message}`);
             });
         });
         if (stopped)

package/dist/index.js

@@ -19,6 +19,7 @@ import { rollbackCommand } from "./commands/rollback.js";
 import { opsCommand } from "./commands/ops.js";
 import { queueCommand } from "./commands/queue.js";
 import { logsCommand } from "./commands/logs.js";
+import { doctorCommand } from "./commands/doctor.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),
@@ -45,6 +46,7 @@ const main = defineCommand({
         projects: projectsCommand,
         deployments: deploymentsCommand,
         logs: logsCommand,
+        doctor: doctorCommand,
         login: loginCommand,
         whoami: whoamiCommand,
         init: initCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "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.5"
+    "@solcreek/sdk": "0.4.6"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",