@solcreek/cli 0.4.14 → 0.4.15

package/dist/commands/deployments.js

@@ -6,10 +6,28 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseConfig } from "@solcreek/sdk";
 import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS } from "../utils/output.js";
-export const deploymentsCommand = defineCommand({
+function resolveSlug(argSlug, jsonMode) {
+    if (argSlug)
+        return argSlug;
+    const configPath = join(process.cwd(), "creek.toml");
+    if (!existsSync(configPath)) {
+        if (jsonMode) {
+            jsonOutput({
+                ok: false,
+                error: "no_project",
+                message: "No creek.toml found. Use --project <slug> or run from a project directory.",
+            }, 1, NO_PROJECT_BREADCRUMBS);
+        }
+        consola.error("No creek.toml found. Use --project <slug> or run from a project directory.");
+        process.exit(1);
+    }
+    return parseConfig(readFileSync(configPath, "utf-8")).project.name;
+}
+// --- List (default behaviour) ---
+const deploymentsList = defineCommand({
     meta: {
-        name: "deployments",
-        description: "List recent deployments for the current project",
+        name: "list",
+        description: "List recent deployments",
     },
     args: {
         project: {
@@ -28,18 +46,7 @@ export const deploymentsCommand = defineCommand({
             consola.error("Not authenticated. Run `creek login` first.");
             process.exit(1);
         }
-        // Resolve project slug
-        let slug = args.project;
-        if (!slug) {
-            const configPath = join(process.cwd(), "creek.toml");
-            if (!existsSync(configPath)) {
-                if (jsonMode)
-                    jsonOutput({ ok: false, error: "no_project", message: "No creek.toml found. Use --project <slug> or run from a project directory." }, 1, NO_PROJECT_BREADCRUMBS);
-                consola.error("No creek.toml found. Use --project <slug> or run from a project directory.");
-                process.exit(1);
-            }
-            slug = parseConfig(readFileSync(configPath, "utf-8")).project.name;
-        }
+        const slug = resolveSlug(args.project, jsonMode);
         const client = new CreekClient(getApiUrl(), token);
         let deployments;
         try {
@@ -74,6 +81,194 @@ export const deploymentsCommand = defineCommand({
         }
     },
 });
+// --- Logs subcommand ---
+const deploymentsLogs = defineCommand({
+    meta: {
+        name: "logs",
+        description: "Read the build log for a deployment (production + branch + preview). Use --project to target a different project; --raw to print ndjson for piping. Designed so AI coding agents can diagnose failed deploys without a human relay.",
+    },
+    args: {
+        id: {
+            type: "positional",
+            description: "Deployment id (8-char short id or full uuid)",
+            required: true,
+        },
+        project: {
+            type: "string",
+            description: "Project slug (default: from creek.toml)",
+            required: false,
+        },
+        raw: {
+            type: "boolean",
+            description: "Print raw ndjson lines instead of step-grouped output",
+            default: false,
+        },
+        ...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 slug = resolveSlug(args.project, jsonMode);
+        const client = new CreekClient(getApiUrl(), token);
+        // If the user passed a short id, look up the full uuid. GET endpoint
+        // requires the full id.
+        let fullId = args.id;
+        if (fullId.length < 36) {
+            try {
+                const list = await client.listDeployments(slug);
+                const match = list.find((d) => d.id.startsWith(fullId));
+                if (!match) {
+                    if (jsonMode)
+                        jsonOutput({ ok: false, error: "not_found", message: `No deployment matches id prefix '${fullId}'` }, 1);
+                    consola.error(`No deployment matches id prefix '${fullId}'`);
+                    process.exit(1);
+                }
+                fullId = match.id;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : "Failed to resolve deployment id";
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+                consola.error(msg);
+                process.exit(1);
+            }
+        }
+        let log;
+        try {
+            log = await client.getBuildLog(slug, fullId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to read build log";
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+            consola.error(msg);
+            process.exit(1);
+        }
+        if (jsonMode) {
+            jsonOutput({ ok: true, deploymentId: fullId, ...log }, 0);
+        }
+        if (!log.metadata) {
+            consola.info(log.message ?? "No build log available for this deployment.");
+            return;
+        }
+        if (args.raw) {
+            for (const e of log.entries)
+                consola.log(JSON.stringify(e));
+            return;
+        }
+        // Grouped printout: step ▸ lines. Headers carry status + duration + CK-code.
+        const grouped = groupByStep(log.entries);
+        const headerLabels = {
+            clone: "Clone",
+            detect: "Detect",
+            install: "Install",
+            build: "Build",
+            bundle: "Bundle",
+            upload: "Upload",
+            provision: "Provision",
+            activate: "Activate",
+            cleanup: "Cleanup",
+        };
+        const order = [
+            "clone",
+            "detect",
+            "install",
+            "build",
+            "bundle",
+            "upload",
+            "provision",
+            "activate",
+            "cleanup",
+        ];
+        const meta = log.metadata;
+        const statusColour = meta.status === "success" ? "\x1b[32m" :
+            meta.status === "failed" ? "\x1b[31m" :
+                "\x1b[33m";
+        consola.log(`\n  deployment ${fullId.slice(0, 8)}  ${statusColour}${meta.status}\x1b[0m`);
+        if (meta.errorCode)
+            consola.log(`  error code: ${meta.errorCode}`);
+        if (meta.errorStep)
+            consola.log(`  failed at: ${meta.errorStep}`);
+        consola.log("");
+        for (const step of order) {
+            const lines = grouped.get(step);
+            if (!lines)
+                continue;
+            const header = headerLabels[step] ?? step;
+            const duration = stepDuration(lines);
+            const failed = meta.status === "failed" && meta.errorStep === step;
+            const icon = failed ? "\x1b[31m✗\x1b[0m" : "\x1b[32m✓\x1b[0m";
+            const label = failed ? `\x1b[31m${header}\x1b[0m` : header;
+            consola.log(`  ${icon}  ${label}${duration ? ` (${duration})` : ""}`);
+            for (const l of lines) {
+                const lineColour = l.level === "error" || l.level === "fatal" ? "\x1b[31m" :
+                    l.level === "warn" ? "\x1b[33m" :
+                        "\x1b[90m";
+                consola.log(`       ${lineColour}${l.msg}\x1b[0m`);
+            }
+        }
+        if (meta.truncated) {
+            consola.warn("  (log was truncated at 5MB / 200k lines)");
+        }
+    },
+});
+function groupByStep(entries) {
+    const map = new Map();
+    for (const e of entries) {
+        let bucket = map.get(e.step);
+        if (!bucket) {
+            bucket = [];
+            map.set(e.step, bucket);
+        }
+        bucket.push(e);
+    }
+    return map;
+}
+function stepDuration(lines) {
+    if (lines.length < 2)
+        return null;
+    const sorted = [...lines].sort((a, b) => a.ts - b.ts);
+    const ms = sorted[sorted.length - 1].ts - sorted[0].ts;
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60_000)}m ${Math.floor((ms % 60_000) / 1000)}s`;
+}
+// --- Public export ---
+export const deploymentsCommand = defineCommand({
+    meta: {
+        name: "deployments",
+        description: "List deployments and read build logs",
+    },
+    args: {
+        project: {
+            type: "string",
+            description: "Project slug (default: from creek.toml)",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    subCommands: {
+        list: deploymentsList,
+        logs: deploymentsLogs,
+    },
+    // Default behaviour (no subcommand) = list. Citty resolves
+    // subcommands first, so this only fires when the user types
+    // `creek deployments` with no trailing verb.
+    async run(ctx) {
+        const run = deploymentsList.run;
+        if (!run)
+            return;
+        return run(ctx);
+    },
+});
 function timeAgo(dateStr) {
     const diff = Date.now() - new Date(dateStr).getTime();
     const mins = Math.floor(diff / 60_000);

package/dist/commands/doctor.d.ts

@@ -25,5 +25,15 @@ export declare const doctorCommand: import("citty").CommandDef<{
         description: string;
         required: false;
     };
+    last: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    project: {
+        type: "string";
+        description: string;
+        required: false;
+    };
 }>;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -3,7 +3,9 @@ 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";
+import { CreekClient } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, } from "../utils/output.js";
 /**
  * `creek doctor` — pre-deploy sanity check.
  *
@@ -26,11 +28,29 @@ export const doctorCommand = defineCommand({
             description: "Project directory to analyze. Defaults to cwd.",
             required: false,
         },
+        last: {
+            type: "boolean",
+            description: "Diagnose the most recent FAILED deployment instead of running pre-deploy checks. Fetches the build log and matches errorCode against the CK-* fix table.",
+            default: false,
+        },
+        project: {
+            type: "string",
+            description: "Project slug for --last (default: read from creek.toml in cwd)",
+            required: false,
+        },
         ...globalArgs,
     },
     async run({ args }) {
-        const cwd = resolve(args.path ?? process.cwd());
         const jsonMode = resolveJsonMode(args);
+        if (args.last) {
+            await runLastFailureDiagnosis({
+                project: args.project,
+                cwd: resolve(args.path ?? process.cwd()),
+                jsonMode,
+            });
+            return;
+        }
+        const cwd = resolve(args.path ?? process.cwd());
         const ctx = buildContext(cwd);
         const report = runDoctor(ctx);
         if (jsonMode) {
@@ -171,4 +191,154 @@ function groupBy(arr, key) {
 function s(n) {
     return n === 1 ? "" : "s";
 }
+// ─── `--last` failure diagnosis ─────────────────────────────────────────
+//
+// CK-code → one-line fix hint. Source of truth in product terms is
+// skills/creek/references/diagnosis.md; the MCP server's get_build_log
+// tool carries the same mapping (packages/mcp-server/src/tools.ts
+// CK_FIX_HINTS). Keep all three in sync when adding a new CK-* rule.
+const CK_FIX_HINTS = {
+    "CK-NO-CONFIG": "Run `creek init` to scaffold a creek.toml, or cd to a directory that contains creek.toml / wrangler.* / package.json / index.html.",
+    "CK-NOTHING-TO-DEPLOY": "Run the project's build command so there's output in [build].output, or set [build].command in creek.toml if the project needs one.",
+    "CK-DB-DUAL-DRIVER-SPLIT": "Consolidate the split db.local.ts + db.prod.ts files. Share schema.ts and routes.ts; keep only thin boot files (server/local.ts for dev, server/worker.ts for prod) that differ in driver setup. See examples/vite-react-drizzle.",
+    "CK-SYNC-SQLITE": "better-sqlite3 is synchronous and won't run on Workers. Migrate to an async ORM with a D1 adapter — Drizzle or Kysely are the drop-in paths.",
+    "CK-PRISMA-SQLITE": "Prisma's SQLite datasource isn't supported on Cloudflare Workers. Switch to Drizzle or Kysely with a D1 adapter.",
+    "CK-RUNTIME-LOCKIN": "The project imports from @solcreek/* runtime packages. For a portable build that can deploy outside Creek, replace those with driver-level imports (e.g. drizzle-orm/d1 instead of creek's db re-export).",
+    "CK-CONFIG-OVERLAP": "Both creek.toml and wrangler.* are present. Pick one as the source of truth — creek.toml is preferred; remove wrangler.* or update any shared fields to match.",
+};
+function suggestFix(code) {
+    if (!code)
+        return null;
+    return CK_FIX_HINTS[code] ?? null;
+}
+async function runLastFailureDiagnosis(opts) {
+    const token = getToken();
+    if (!token) {
+        if (opts.jsonMode) {
+            jsonOutput({ ok: false, error: "not_authenticated" }, 1, AUTH_BREADCRUMBS);
+        }
+        consola.error("Not authenticated. Run `creek login` first.");
+        process.exit(1);
+    }
+    // Resolve project slug — prefer --project, fall back to creek.toml
+    let slug = opts.project;
+    if (!slug) {
+        const creekToml = join(opts.cwd, "creek.toml");
+        if (existsSync(creekToml)) {
+            const raw = safeRead(creekToml);
+            const match = raw?.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+            if (match)
+                slug = match[1];
+        }
+    }
+    if (!slug) {
+        const msg = "No project slug. Pass --project <slug> or run from a directory with creek.toml.";
+        if (opts.jsonMode)
+            jsonOutput({ ok: false, error: "no_project", message: msg }, 1);
+        consola.error(msg);
+        process.exit(1);
+    }
+    const client = new CreekClient(getApiUrl(), token);
+    // Find the most recent failed deployment.
+    let deployments;
+    try {
+        deployments = await client.listDeployments(slug);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to list deployments";
+        if (opts.jsonMode)
+            jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+        consola.error(msg);
+        process.exit(1);
+    }
+    const failed = deployments.find((d) => d.status === "failed");
+    if (!failed) {
+        const msg = `No failed deployments for ${slug}. Last ${deployments.length} deploys succeeded.`;
+        if (opts.jsonMode)
+            jsonOutput({ ok: true, project: slug, failed: null, message: msg }, 0);
+        consola.log("");
+        consola.log(`  ${c("⬡ creek doctor --last", "bold")}  ${c(slug, "dim")}`);
+        consola.log(`  ${c("✓", "green")} ${msg}`);
+        consola.log("");
+        return;
+    }
+    // Pull the build log.
+    let log;
+    try {
+        log = await client.getBuildLog(slug, failed.id);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to read build log";
+        if (opts.jsonMode)
+            jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+        consola.error(msg);
+        process.exit(1);
+    }
+    const meta = log.metadata;
+    const errorCode = meta?.errorCode ?? null;
+    const errorStep = meta?.errorStep ?? null;
+    const fix = suggestFix(errorCode);
+    if (opts.jsonMode) {
+        jsonOutput({
+            ok: true,
+            project: slug,
+            failed: {
+                id: failed.id,
+                version: failed.version,
+                branch: failed.branch,
+                commitSha: failed.commit_sha,
+                errorCode,
+                errorStep,
+                suggestedFix: fix,
+                failedStep: failed.failed_step,
+                errorMessage: failed.error_message,
+            },
+        }, 0, [
+            {
+                command: `creek deployments logs ${failed.id.slice(0, 8)} --json`,
+                description: "Read the full build log",
+            },
+            { command: `creek deploy --json`, description: "Redeploy after fixing" },
+        ]);
+        return;
+    }
+    // Human output.
+    consola.log("");
+    consola.log(`  ${c("⬡ creek doctor --last", "bold")}  ${c(slug, "dim")}`);
+    consola.log(`  ${c("failed deploy:", "dim")} ${failed.id.slice(0, 8)}${failed.branch ? ` (${failed.branch})` : ""}`);
+    consola.log("");
+    if (errorCode) {
+        consola.log(`  ${c("✗", "red")} ${c(errorCode, "bold")}  ${c(`at step: ${errorStep ?? "unknown"}`, "gray")}`);
+    }
+    else if (errorStep) {
+        consola.log(`  ${c("✗", "red")} Failed at step: ${c(errorStep, "bold")}`);
+    }
+    else {
+        consola.log(`  ${c("✗", "red")} Deploy failed — no structured errorCode available.`);
+    }
+    consola.log("");
+    if (fix) {
+        consola.log(`  ${c("→ fix:", "cyan")}`);
+        for (const line of fix.split("\n"))
+            consola.log(`    ${line}`);
+        consola.log("");
+    }
+    else if (errorCode) {
+        consola.log(`  ${c("→ no mapped fix for", "dim")} ${c(errorCode, "bold")}${c(". Inspect the full log:", "dim")}`);
+        consola.log(`    creek deployments logs ${failed.id.slice(0, 8)}`);
+        consola.log("");
+    }
+    else {
+        consola.log(`  ${c("→ inspect the full log:", "cyan")}`);
+        consola.log(`    creek deployments logs ${failed.id.slice(0, 8)}`);
+        consola.log("");
+    }
+    if (failed.error_message) {
+        consola.log(`  ${c("error message:", "dim")}`);
+        for (const line of failed.error_message.split("\n").slice(0, 8)) {
+            consola.log(`    ${c(line, "gray")}`);
+        }
+        consola.log("");
+    }
+}
 //# sourceMappingURL=doctor.js.map

package/dist/commands/migrate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Migration logic for `creek db migrate`.
+ *
+ * Pure functions are exported for testing. The CLI command wires
+ * them together with the SDK client in db.ts.
+ */
+/**
+ * Find the migration directory relative to cwd.
+ * Returns the absolute path of the first candidate that exists and
+ * contains at least one .sql file, or null if none found.
+ */
+export declare function detectMigrationDir(cwd: string): string | null;
+export interface MigrationFile {
+    /** File name without directory (e.g. "0001_init.sql") */
+    name: string;
+    /** Absolute path */
+    path: string;
+}
+/**
+ * Read .sql files from a directory, sorted lexicographically.
+ * Non-.sql files and empty .sql files are skipped.
+ */
+export declare function parseMigrationFiles(dir: string): MigrationFile[];
+/**
+ * Split a migration file's SQL content into individual statements.
+ *
+ * If the content contains Drizzle's `--> statement-breakpoint` marker,
+ * split on those. Otherwise split on semicolons. Empty statements are
+ * filtered out.
+ */
+export declare function splitStatements(sql: string): string[];
+/**
+ * Given files on disk and names already applied, return the pending
+ * migrations in order.
+ */
+export declare function computePending(files: MigrationFile[], applied: Set<string>): MigrationFile[];
+//# sourceMappingURL=migrate.d.ts.map

package/dist/commands/migrate.js

@@ -0,0 +1,99 @@
+/**
+ * Migration logic for `creek db migrate`.
+ *
+ * Pure functions are exported for testing. The CLI command wires
+ * them together with the SDK client in db.ts.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+// --- Auto-detect migration directory ---
+const CANDIDATE_DIRS = [
+    "drizzle",
+    "drizzle/migrations",
+    "migrations",
+    "sql",
+];
+/**
+ * Find the migration directory relative to cwd.
+ * Returns the absolute path of the first candidate that exists and
+ * contains at least one .sql file, or null if none found.
+ */
+export function detectMigrationDir(cwd) {
+    for (const dir of CANDIDATE_DIRS) {
+        const abs = resolve(cwd, dir);
+        if (existsSync(abs)) {
+            try {
+                const files = readdirSync(abs);
+                if (files.some((f) => f.endsWith(".sql")))
+                    return abs;
+            }
+            catch {
+                // Permission error or not a directory — skip
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Read .sql files from a directory, sorted lexicographically.
+ * Non-.sql files and empty .sql files are skipped.
+ */
+export function parseMigrationFiles(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((f) => f.endsWith(".sql"))
+        .sort()
+        .map((name) => ({ name, path: join(dir, name) }))
+        .filter((f) => {
+        try {
+            const content = readFileSync(f.path, "utf-8").trim();
+            return content.length > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+// --- Split SQL statements ---
+const DRIZZLE_BREAKPOINT = "--> statement-breakpoint";
+/**
+ * Split a migration file's SQL content into individual statements.
+ *
+ * If the content contains Drizzle's `--> statement-breakpoint` marker,
+ * split on those. Otherwise split on semicolons. Empty statements are
+ * filtered out.
+ */
+export function splitStatements(sql) {
+    const trimmed = sql.trim();
+    if (!trimmed)
+        return [];
+    let parts;
+    if (trimmed.includes(DRIZZLE_BREAKPOINT)) {
+        parts = trimmed.split(DRIZZLE_BREAKPOINT);
+    }
+    else {
+        // Split on semicolons but preserve them — each statement should
+        // include its trailing semicolon for D1 execution.
+        parts = trimmed
+            .split(/;(?=\s|$)/)
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0)
+            .map((s) => (s.endsWith(";") ? s : s + ";"));
+    }
+    return parts.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+// --- Compute pending migrations ---
+/**
+ * Given files on disk and names already applied, return the pending
+ * migrations in order.
+ */
+export function computePending(files, applied) {
+    return files.filter((f) => !applied.has(f.name));
+}
+//# sourceMappingURL=migrate.js.map

package/dist/commands/resource-cmd.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Factory for resource subcommands (creek db, creek storage, creek cache).
+ *
+ * All resource kinds share the same CRUD shape:
+ *   ls, create, attach, detach, rename, delete
+ *
+ * Only the `kind` value and display labels differ.
+ */
+interface ResourceCmdOptions {
+    kind: "database" | "storage" | "cache" | "ai";
+    /** Singular label for display, e.g. "database", "storage bucket", "cache namespace" */
+    label: string;
+    /** Default binding name, e.g. "DB", "STORAGE", "KV" */
+    defaultBinding: string;
+}
+export declare function createResourceCommand(opts: ResourceCmdOptions): import("citty").CommandDef<import("citty").ArgsDef>;
+export {};
+//# sourceMappingURL=resource-cmd.d.ts.map