@solcreek/cli 0.4.14 → 0.4.16

package/dist/commands/cache.d.ts

@@ -0,0 +1,2 @@
+export declare const cacheCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=cache.d.ts.map

package/dist/commands/cache.js

@@ -0,0 +1,7 @@
+import { createResourceCommand } from "./resource-cmd.js";
+export const cacheCommand = createResourceCommand({
+    kind: "cache",
+    label: "cache namespace",
+    defaultBinding: "KV",
+});
+//# sourceMappingURL=cache.js.map

package/dist/commands/db.d.ts

@@ -0,0 +1,2 @@
+export declare const dbCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=db.d.ts.map

package/dist/commands/db.js

@@ -0,0 +1,442 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { resolve } from "node:path";
+import { CreekClient } from "@solcreek/sdk";
+import { createResourceCommand } from "./resource-cmd.js";
+import { detectMigrationDir, parseMigrationFiles, splitStatements, computePending } from "./migrate.js";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS } from "../utils/output.js";
+const base = createResourceCommand({
+    kind: "database",
+    label: "database",
+    defaultBinding: "DB",
+});
+const shellCommand = defineCommand({
+    meta: {
+        name: "shell",
+        description: "Execute SQL against a team database. Interactive REPL or single query with --sql.",
+    },
+    args: {
+        name: {
+            type: "positional",
+            description: "Database name (as shown by `creek db ls`)",
+            required: true,
+        },
+        sql: {
+            type: "string",
+            description: "SQL query to execute (non-interactive mode). Omit for interactive REPL.",
+            required: 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 client = new CreekClient(getApiUrl(), token);
+        // Resolve name → resource ID
+        const { resources } = await client.listResources();
+        const db = resources.find((r) => r.name === args.name && r.kind === "database");
+        if (!db) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_found", message: `No database named "${args.name}"` }, 1);
+            consola.error(`No database named "${args.name}"`);
+            process.exit(1);
+        }
+        // Single query mode
+        if (args.sql) {
+            await executeAndPrint(client, db.id, args.sql, jsonMode);
+            return;
+        }
+        // Interactive REPL
+        consola.info(`Connected to ${args.name} (${db.id.slice(0, 8)})`);
+        consola.info("Type SQL and press Enter. Use .exit to quit.\n");
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: "sql> ",
+        });
+        rl.prompt();
+        let buffer = "";
+        rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (trimmed === ".exit" || trimmed === ".quit") {
+                rl.close();
+                return;
+            }
+            if (trimmed === ".tables") {
+                buffer = "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name";
+            }
+            else if (trimmed === ".schema") {
+                buffer = "SELECT sql FROM sqlite_master WHERE sql IS NOT NULL ORDER BY name";
+            }
+            else {
+                buffer += (buffer ? "\n" : "") + line;
+            }
+            // Execute when line ends with semicolon or is a dot-command
+            if (!buffer.endsWith(";") && !trimmed.startsWith(".")) {
+                rl.setPrompt("...> ");
+                rl.prompt();
+                return;
+            }
+            await executeAndPrint(client, db.id, buffer, false);
+            buffer = "";
+            rl.setPrompt("sql> ");
+            rl.prompt();
+        });
+        rl.on("close", () => {
+            consola.info("Bye.");
+            process.exit(0);
+        });
+    },
+});
+async function executeAndPrint(client, resourceId, sql, jsonMode) {
+    try {
+        const result = await client.queryDatabase(resourceId, sql);
+        if (jsonMode) {
+            jsonOutput({ ok: true, ...result }, 0);
+            return;
+        }
+        if (result.rows.length === 0) {
+            if (result.meta.changes > 0) {
+                consola.info(`${result.meta.changes} row(s) changed (${result.meta.duration.toFixed(1)}ms)`);
+            }
+            else {
+                consola.info("No results.");
+            }
+            return;
+        }
+        // Print table
+        const cols = result.columns;
+        const widths = cols.map((c) => c.length);
+        for (const row of result.rows) {
+            for (let i = 0; i < cols.length; i++) {
+                const val = String(row[cols[i]] ?? "NULL");
+                widths[i] = Math.max(widths[i], val.length);
+            }
+        }
+        // Cap column widths
+        const maxWidth = 40;
+        const cappedWidths = widths.map((w) => Math.min(w, maxWidth));
+        const header = cols.map((c, i) => c.padEnd(cappedWidths[i])).join("  ");
+        const separator = cappedWidths.map((w) => "─".repeat(w)).join("──");
+        console.log(header);
+        console.log(separator);
+        for (const row of result.rows) {
+            const line = cols
+                .map((c, i) => {
+                const val = String(row[c] ?? "NULL");
+                return val.length > maxWidth ? val.slice(0, maxWidth - 1) + "…" : val.padEnd(cappedWidths[i]);
+            })
+                .join("  ");
+            console.log(line);
+        }
+        consola.info(`\n${result.rows.length} row(s) · ${result.meta.duration.toFixed(1)}ms`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (jsonMode) {
+            jsonOutput({ ok: false, error: "query_failed", message: msg }, 1);
+        }
+        else {
+            consola.error(msg);
+        }
+    }
+}
+const migrateCommand = defineCommand({
+    meta: {
+        name: "migrate",
+        description: "Apply pending SQL migrations to a team database. Reads .sql files from a migration directory, tracks applied state, executes in order.",
+    },
+    args: {
+        name: {
+            type: "positional",
+            description: "Database name (as shown by `creek db ls`)",
+            required: true,
+        },
+        dir: {
+            type: "string",
+            description: "Migration directory path. Default: auto-detect drizzle/, drizzle/migrations/, migrations/, sql/",
+            required: false,
+        },
+        "dry-run": {
+            type: "boolean",
+            description: "Show pending migrations without executing them.",
+            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 client = new CreekClient(getApiUrl(), token);
+        // 1. Resolve database name → resource ID
+        const { resources } = await client.listResources();
+        const db = resources.find((r) => r.name === args.name && r.kind === "database");
+        if (!db) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_found", message: `No database named "${args.name}"` }, 1);
+            consola.error(`No database named "${args.name}"`);
+            process.exit(1);
+        }
+        // 2. Find migration directory
+        const cwd = process.cwd();
+        const migrationDir = args.dir ? resolve(cwd, args.dir) : detectMigrationDir(cwd);
+        if (!migrationDir) {
+            const msg = args.dir
+                ? `Migration directory not found: ${args.dir}`
+                : "No migration directory found. Looked for: drizzle/, drizzle/migrations/, migrations/, sql/. Use --dir to specify.";
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "no_migration_dir", message: msg }, 1);
+            consola.error(msg);
+            process.exit(1);
+        }
+        // 3. Read migration files
+        const files = parseMigrationFiles(migrationDir);
+        if (files.length === 0) {
+            if (jsonMode)
+                jsonOutput({ ok: true, message: "No .sql files found", applied: 0, pending: 0 }, 0);
+            consola.info(`No .sql files found in ${migrationDir}`);
+            return;
+        }
+        // 4. Create tracking table + query applied migrations
+        try {
+            await client.queryDatabase(db.id, `CREATE TABLE IF NOT EXISTS _creek_migrations (
+          name TEXT PRIMARY KEY,
+          applied_at INTEGER NOT NULL
+        );`);
+        }
+        catch (err) {
+            const msg = `Failed to create migration tracking table: ${err instanceof Error ? err.message : String(err)}`;
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "tracking_table_failed", message: msg }, 1);
+            consola.error(msg);
+            process.exit(1);
+        }
+        let appliedRows;
+        try {
+            const result = await client.queryDatabase(db.id, "SELECT name FROM _creek_migrations ORDER BY name;");
+            appliedRows = result.rows;
+        }
+        catch (err) {
+            const msg = `Failed to query applied migrations: ${err instanceof Error ? err.message : String(err)}`;
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "query_failed", message: msg }, 1);
+            consola.error(msg);
+            process.exit(1);
+        }
+        const appliedSet = new Set(appliedRows.map((r) => r.name));
+        const pending = computePending(files, appliedSet);
+        // 5. Dry-run
+        if (args["dry-run"]) {
+            if (jsonMode) {
+                jsonOutput({
+                    ok: true,
+                    dryRun: true,
+                    total: files.length,
+                    applied: appliedSet.size,
+                    pending: pending.map((f) => f.name),
+                }, 0);
+            }
+            else if (pending.length === 0) {
+                consola.success(`Database "${args.name}" is up to date (${appliedSet.size} applied)`);
+            }
+            else {
+                consola.info(`${pending.length} pending migration(s):\n`);
+                for (const f of pending) {
+                    consola.log(`  ${f.name}`);
+                }
+                consola.info(`\nRun without --dry-run to apply.`);
+            }
+            return;
+        }
+        // 6. Apply pending
+        if (pending.length === 0) {
+            if (jsonMode)
+                jsonOutput({ ok: true, message: "up to date", applied: appliedSet.size, migrated: 0 }, 0);
+            consola.success(`Database "${args.name}" is up to date (${appliedSet.size} applied)`);
+            return;
+        }
+        consola.info(`Migrating "${args.name}": ${pending.length} pending of ${files.length} total\n`);
+        let migrated = 0;
+        for (const file of pending) {
+            const sql = readFileSync(file.path, "utf-8");
+            const statements = splitStatements(sql);
+            if (statements.length === 0) {
+                consola.warn(`  ${file.name} — empty, skipping`);
+                continue;
+            }
+            consola.start(`  ${file.name} (${statements.length} statement${statements.length > 1 ? "s" : ""})`);
+            let failed = false;
+            for (let i = 0; i < statements.length; i++) {
+                try {
+                    await client.queryDatabase(db.id, statements[i]);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    consola.error(`  ${file.name} — statement ${i + 1}/${statements.length} failed: ${msg}`);
+                    if (jsonMode) {
+                        jsonOutput({
+                            ok: false,
+                            error: "migration_failed",
+                            file: file.name,
+                            statement: i + 1,
+                            totalStatements: statements.length,
+                            message: msg,
+                            migrated,
+                            remaining: pending.length - migrated,
+                        }, 1);
+                    }
+                    consola.error(`\n${migrated} migration(s) applied before failure. Fix the SQL and re-run.`);
+                    process.exit(1);
+                }
+            }
+            // Record success
+            try {
+                await client.queryDatabase(db.id, "INSERT INTO _creek_migrations (name, applied_at) VALUES (?, ?);", [file.name, Date.now()]);
+            }
+            catch {
+                // Non-fatal — migration ran but tracking failed. It won't re-run
+                // because the schema changes already happened. Warn and continue.
+                consola.warn(`  ${file.name} — applied but failed to record in tracking table`);
+            }
+            migrated++;
+            consola.success(`  ${file.name}`);
+        }
+        if (jsonMode) {
+            jsonOutput({ ok: true, migrated, total: files.length, applied: appliedSet.size + migrated }, 0);
+        }
+        consola.success(`\n${migrated} migration(s) applied successfully`);
+    },
+});
+const SEED_CANDIDATES = [
+    "drizzle/seed.sql",
+    "drizzle/migrations/seed.sql",
+    "migrations/seed.sql",
+    "sql/seed.sql",
+    "seed.sql",
+];
+const seedCommand = defineCommand({
+    meta: {
+        name: "seed",
+        description: "Execute a seed SQL file against a team database. Looks for seed.sql in common locations or use --file to specify.",
+    },
+    args: {
+        name: {
+            type: "positional",
+            description: "Database name (as shown by `creek db ls`)",
+            required: true,
+        },
+        file: {
+            type: "string",
+            description: "Path to seed SQL file. Default: auto-detect seed.sql in drizzle/, migrations/, sql/, or project root.",
+            required: 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 client = new CreekClient(getApiUrl(), token);
+        // Resolve database
+        const { resources } = await client.listResources();
+        const db = resources.find((r) => r.name === args.name && r.kind === "database");
+        if (!db) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_found", message: `No database named "${args.name}"` }, 1);
+            consola.error(`No database named "${args.name}"`);
+            process.exit(1);
+        }
+        // Find seed file
+        const cwd = process.cwd();
+        let seedPath = null;
+        if (args.file) {
+            seedPath = resolve(cwd, args.file);
+            if (!existsSync(seedPath)) {
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "file_not_found", message: `Seed file not found: ${args.file}` }, 1);
+                consola.error(`Seed file not found: ${args.file}`);
+                process.exit(1);
+            }
+        }
+        else {
+            for (const candidate of SEED_CANDIDATES) {
+                const abs = resolve(cwd, candidate);
+                if (existsSync(abs)) {
+                    seedPath = abs;
+                    break;
+                }
+            }
+            if (!seedPath) {
+                const msg = "No seed file found. Looked for: " + SEED_CANDIDATES.join(", ") + ". Use --file to specify.";
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "no_seed_file", message: msg }, 1);
+                consola.error(msg);
+                process.exit(1);
+            }
+        }
+        // Read and execute
+        const sql = readFileSync(seedPath, "utf-8");
+        const statements = splitStatements(sql);
+        if (statements.length === 0) {
+            if (jsonMode)
+                jsonOutput({ ok: true, message: "Seed file is empty", executed: 0 }, 0);
+            consola.info("Seed file is empty — nothing to execute.");
+            return;
+        }
+        consola.info(`Seeding "${args.name}" from ${seedPath.replace(cwd + "/", "")}`);
+        consola.info(`${statements.length} statement(s)\n`);
+        for (let i = 0; i < statements.length; i++) {
+            try {
+                await client.queryDatabase(db.id, statements[i]);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (jsonMode) {
+                    jsonOutput({
+                        ok: false,
+                        error: "seed_failed",
+                        statement: i + 1,
+                        totalStatements: statements.length,
+                        message: msg,
+                    }, 1);
+                }
+                consola.error(`Statement ${i + 1}/${statements.length} failed: ${msg}`);
+                process.exit(1);
+            }
+        }
+        if (jsonMode)
+            jsonOutput({ ok: true, executed: statements.length }, 0);
+        consola.success(`Seed complete (${statements.length} statement${statements.length > 1 ? "s" : ""})`);
+    },
+});
+// Merge subcommands into the base resource command
+export const dbCommand = defineCommand({
+    meta: base.meta,
+    subCommands: {
+        ...base.subCommands,
+        shell: shellCommand,
+        migrate: migrateCommand,
+        seed: seedCommand,
+    },
+});
+//# sourceMappingURL=db.js.map

package/dist/commands/deploy.js

@@ -4,11 +4,13 @@ import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 // ajv is lazy-imported only when --template --data is used (avoid top-level crash if deps missing)
 import { join, resolve } from "node:path";
 import { execSync, execFileSync } from "node:child_process";
-import { CreekClient, CreekAuthError, detectFramework, resolveConfig, formatDetectionSummary, resolvedConfigToResources, resolvedConfigToBindingRequirements, ConfigNotFoundError, detectNextjsMode, detectMonorepo, } from "@solcreek/sdk";
+import { CreekClient, CreekAuthError, detectFramework, resolveConfig, formatDetectionSummary, resolvedConfigToBindingRequirements, ConfigNotFoundError, detectNextjsMode, detectMonorepo, runDoctor, } from "@solcreek/sdk";
+import { buildDoctorContext } from "../utils/doctor-context.js";
 import { getToken, getApiUrl } from "../utils/config.js";
 import { collectAssets } from "../utils/bundle.js";
 import { sandboxDeploy, pollSandboxStatus, printSandboxSuccess } from "../utils/sandbox.js";
 import { prepareDeployBundle } from "../utils/prepare-bundle.js";
+import { BuildLogEmitter } from "../utils/build-log.js";
 import { isTTY, jsonOutput, resolveJsonMode, globalArgs, shouldAutoConfirm, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS } from "../utils/output.js";
 import { ensureTosAccepted } from "../utils/tos.js";
 import { hasAdapterOutput } from "../utils/nextjs.js";
@@ -88,6 +90,13 @@ async function dryRunPlan(cwd, args, jsonMode) {
             type: b.type,
         }))
         : [];
+    // Run the same rule engine as `creek doctor` so dry-run surfaces
+    // config errors (e.g. CK-RESOURCES-KEYS) that would otherwise only
+    // reveal themselves at runtime when the missing binding crashes the
+    // worker. Agents following the SKILL.md "dry-run first" rule need
+    // these findings here, not after a 500.
+    const doctorReport = runDoctor(buildDoctorContext(cwd));
+    const blockingFindings = doctorReport.findings.filter((f) => f.severity === "error");
     const plan = {
         mode: "dry-run",
         supported: true,
@@ -112,6 +121,7 @@ async function dryRunPlan(cwd, args, jsonMode) {
             : null,
         buildOutputFallback,
         bindings,
+        findings: doctorReport.findings,
         wouldDeploy,
         sideEffects: {
             networkCalls: false,
@@ -119,9 +129,11 @@ async function dryRunPlan(cwd, args, jsonMode) {
             buildExecuted: false,
             tosPromptShown: false,
         },
-        nextStep: wouldDeploy
-            ? "Run without --dry-run to execute: npx creek deploy"
-            : "No project config or build output found. Run `creek init` or `npm create vite@latest` first.",
+        nextStep: blockingFindings.length > 0
+            ? `Fix ${blockingFindings.length} blocking issue${blockingFindings.length === 1 ? "" : "s"} first (see findings), then re-run. For details: creek doctor --json`
+            : wouldDeploy
+                ? "Run without --dry-run to execute: npx creek deploy"
+                : "No project config or build output found. Run `creek init` or `npm create vite@latest` first.",
     };
     if (jsonMode) {
         jsonOutput(plan, 0, []);
@@ -154,6 +166,22 @@ async function dryRunPlan(cwd, args, jsonMode) {
                 .map((b) => `${b.name} (${b.type})`)
                 .join(", ")} — would be skipped`);
         }
+        if (doctorReport.findings.length > 0) {
+            const errCount = doctorReport.summary.error;
+            const warnCount = doctorReport.summary.warn;
+            const infoCount = doctorReport.summary.info;
+            const parts = [];
+            if (errCount)
+                parts.push(`${errCount} error${errCount === 1 ? "" : "s"}`);
+            if (warnCount)
+                parts.push(`${warnCount} warning${warnCount === 1 ? "" : "s"}`);
+            if (infoCount)
+                parts.push(`${infoCount} info`);
+            consola.log(`  Doctor findings:  ${parts.join(", ")} — run \`creek doctor\` for details`);
+            for (const f of doctorReport.findings.filter((f) => f.severity === "error")) {
+                consola.log(`    \x1b[31m✗\x1b[0m [${f.code}] ${f.title}`);
+            }
+        }
     }
     else if (buildOutputFallback) {
         consola.log(`  Detected:         prebuilt assets in ${buildOutputFallback}/ (no creek.toml, no wrangler config)`);
@@ -917,11 +945,30 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
         const prepared = await prepareDeployBundle({ cwd, resolved, skipBuild });
         const { plan, framework: detectedFramework, effectiveRenderMode, effectiveEntrypoint, fileList, assets: clientAssets, serverFiles, } = prepared;
         void detectedFramework; // framework var above is the source of truth here
+        // Resource / runtime anchors — inline lines that pre-empt the most
+        // common wrong assumptions an AI agent reads from Creek running on
+        // Cloudflare. Cheap to print, and they parse them directly.
+        const dbDeps = !!resolved.bindings.find((b) => b.type === "d1") ||
+            fileList.some((f) => /\.(db|sqlite)$/i.test(f));
+        if (!jsonMode && dbDeps) {
+            consola.info("  ℹ Database: Creek uses the portable driver — better-sqlite3 locally, D1 remotely. Your code reads env.DB in both. Do NOT rewrite for D1 manually; `creek db attach` wires the binding.");
+        }
         section("Upload");
         consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
         section("Deploy");
         consola.start("  Creating deployment...");
         const { deployment } = await client.createDeployment(project.id);
+        // Collect a minimal structured build log for the dashboard. We emit
+        // one line per high-level phase — verbose stdout capture is a
+        // Phase 2 concern. The log is POSTed once we reach a terminal
+        // status (success / failed), so the dashboard panel shows something
+        // useful for every authenticated deploy.
+        const buildLog = new BuildLogEmitter();
+        buildLog.info("detect", `framework=${framework ?? "none"} renderMode=${effectiveRenderMode} entrypoint=${effectiveEntrypoint ?? "none"}`);
+        if (resolved.buildCommand) {
+            buildLog.info("build", `ran: ${resolved.buildCommand}`);
+        }
+        buildLog.info("bundle", `${fileList.length} assets (${assetSummary(fileList)})`);
         consola.start("  Uploading bundle...");
         const effectiveHasWorker = serverFiles !== undefined;
         const bundle = {
@@ -935,9 +982,7 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
             workerScript: null,
             assets: clientAssets,
             serverFiles,
-            // Backward compat: boolean flags
-            resources: resolvedConfigToResources(resolved),
-            // New: binding declarations with user-defined names
+            // Binding declarations with user-defined names
             bindings: resolvedConfigToBindingRequirements(resolved),
             // Pass through wrangler vars and compat settings
             ...(Object.keys(resolved.vars).length > 0 ? { vars: resolved.vars } : {}),
@@ -966,6 +1011,7 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
         };
         let lastStatus = "";
         const start = Date.now();
+        buildLog.info("upload", `bundle uploaded (${fileList.length} files)`);
         while (Date.now() - start < POLL_TIMEOUT) {
             const res = await client.getDeploymentStatus(project.id, deployment.id);
             const { status, failed_step, error_message } = res.deployment;
@@ -976,9 +1022,27 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
                 if (!TERMINAL.has(status) && STEP_LABELS[status]) {
                     consola.start(STEP_LABELS[status]);
                 }
+                // Map server-side phase transitions into build-log steps so
+                // the dashboard timeline shows what happened after upload.
+                if (status === "provisioning")
+                    buildLog.info("provision", "provisioning resources");
+                if (status === "deploying")
+                    buildLog.info("activate", "activating at edge");
                 lastStatus = status;
             }
             if (status === "active") {
+                buildLog.info("activate", `deployed: ${res.url ?? res.previewUrl}`);
+                // Fire-and-forget the build log upload — don't block the user
+                // on it or make a slow/failing log API take down a successful
+                // deploy.
+                void client
+                    .uploadBuildLog(deployment.id, buildLog.toNdjson(), {
+                    status: "success",
+                    startedAt: buildLog.startedAt,
+                })
+                    .catch(() => {
+                    // Silent — build log is best-effort for now.
+                });
                 if (jsonMode) {
                     jsonOutput({
                         ok: true,
@@ -1013,6 +1077,16 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
             if (status === "failed") {
                 const step = failed_step ? ` at ${failed_step}` : "";
                 const msg = error_message ?? "Unknown error";
+                buildLog.error(failed_step ?? "activate", msg);
+                void client
+                    .uploadBuildLog(deployment.id, buildLog.toNdjson(), {
+                    status: "failed",
+                    startedAt: buildLog.startedAt,
+                    errorStep: failed_step ?? null,
+                })
+                    .catch(() => {
+                    // Silent — build log is best-effort for now.
+                });
                 if (jsonMode)
                     jsonOutput({ ok: false, error: "deploy_failed", message: msg, failedStep: failed_step }, 1, [
                         { command: `creek deployments --project ${project.slug}`, description: "Check previous deployments" },