@solcreek/cli 0.4.21 → 0.4.23

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @solcreek/cli
 
+## 0.4.23
+
+### Fixes / DX
+
+- **`creek init` help now lists what it creates** — creek.toml (project
+  name, build command/output, detected framework) plus a worker/index.ts
+  example when you add a database — so first-timers know what to expect.
+
+- **`creek doctor --json` prints a one-line summary to stderr** when a human
+  is watching, instead of only a wall of JSON. stdout stays pure JSON for
+  agents and pipes; CI / redirected runs stay silent.
+
+- **The two SQLite doctor findings cross-reference each other.** A project
+  with both better-sqlite3 and Prisma no longer reads as two unrelated
+  problems — each notes it's the same Cloudflare-Workers SQLite migration.
+
+- **`creek db/storage/cache attach --to` shows a value placeholder** in its
+  usage (`--to=<project>`) instead of a bare `--to`.
+
+## 0.4.22
+
+### Fixes / DX
+
+- **Next.js deploys now set up the Creek adapter automatically.** Deploying
+  a Next.js (≥ 16.2.3) project no longer requires installing or configuring
+  anything — `creek deploy` fetches and runs the adapter on first use.
+  Projects outside the Creek repo previously fell back to an older build
+  path without it.
+
+- **`creek deploy` no longer publishes from a non-interactive shell without
+  `--yes`.** In CI, an AI coding agent, or a pipe there is no prompt to
+  confirm, so a bare `creek deploy` now refuses and points you at
+  `--dry-run` (preview the plan) or `--yes` (confirm and deploy) instead of
+  shipping on its own. Interactive (terminal) use is unchanged.
+
+- **Clearer Next.js diagnostics.** `creek doctor` and `creek deploy
+  --dry-run` no longer tell you to run `next build` to produce output that
+  Creek generates itself at deploy time, and the reported build-output path
+  now matches what actually ships.
+
 ## 0.4.6
 
 ### Features

package/dist/commands/dashboard.d.ts

@@ -0,0 +1,21 @@
+export declare const dashboardCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    server: {
+        type: "string";
+        description: string;
+    };
+    token: {
+        type: "string";
+        description: string;
+    };
+}>;
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/commands/dashboard.js

@@ -0,0 +1,72 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { execSync } from "node:child_process";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+import { CreekdClient, CreekdApiError, getCreekdUrl } from "../utils/creekd-client.js";
+export const dashboardCommand = defineCommand({
+    meta: {
+        name: "dashboard",
+        description: "Open the creekd web dashboard in your browser",
+    },
+    args: {
+        server: {
+            type: "string",
+            description: "creekd admin API URL (or $CREEKD_URL)",
+        },
+        token: {
+            type: "string",
+            description: "Bearer token (or $CREEKD_TOKEN)",
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const url = args.server || getCreekdUrl();
+        const client = new CreekdClient(url, args.token || process.env.CREEKD_TOKEN || process.env.CREEKCTL_TOKEN || "");
+        // Verify creekd is reachable
+        try {
+            await client.listApps();
+        }
+        catch (err) {
+            if (err instanceof CreekdApiError && err.status === 401) {
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "unauthorized", message: "Authentication required" }, 1);
+                consola.error("Authentication failed. Set CREEKD_TOKEN or use --token.");
+                process.exit(1);
+            }
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "unreachable", message: `Cannot reach creekd at ${url}` }, 1, [
+                    { command: "creek top --server <url>", description: "Check connection" },
+                ]);
+            consola.error(`Cannot reach creekd at ${url}`);
+            consola.info("Is creekd running? Start it with: creekd");
+            process.exit(1);
+        }
+        // In production, dashboard is served at the same URL as creekd (via Caddy).
+        // In dev, it's typically at localhost:3000 (Vite).
+        const dashboardUrl = url.includes(":9080")
+            ? url.replace(":9080", ":3000")
+            : url;
+        if (jsonMode) {
+            jsonOutput({ ok: true, url: dashboardUrl }, 0, [
+                { command: "creek top", description: "CLI monitoring alternative" },
+            ]);
+        }
+        consola.success(`Opening dashboard: ${dashboardUrl}`);
+        openBrowser(dashboardUrl);
+    },
+});
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === "darwin"
+            ? `open "${url}"`
+            : process.platform === "win32"
+                ? `start "" "${url}"`
+                : `xdg-open "${url}"`;
+        execSync(cmd, { stdio: "ignore" });
+    }
+    catch {
+        consola.info(`Open manually: ${url}`);
+    }
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/commands/deploy.d.ts

@@ -29,6 +29,16 @@ export declare const deployCommand: import("citty").CommandDef<{
         description: string;
         required: false;
     };
+    watch: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "watch-timeout-ms": {
+        type: "string";
+        description: string;
+        required: false;
+    };
     json: {
         type: "boolean";
         description: string;

package/dist/commands/deploy.js

@@ -16,6 +16,8 @@ import { ensureTosAccepted } from "../utils/tos.js";
 import { hasAdapterOutput } from "../utils/nextjs.js";
 import { isRepoUrl, parseRepoUrl, validateRepoUrl, validateSubpath, RepoUrlError } from "../utils/repo-url.js";
 import { checkGitInstalled, cloneRepo, detectPackageManager, installDependencies, cleanupDir as cleanupCloneDir, GitCloneError } from "../utils/git-clone.js";
+import { CreekdClient, getCreekdUrl } from "../utils/creekd-client.js";
+import { watchDeploy } from "../utils/watch.js";
 function section(name) {
     consola.log(`\n  \x1b[2m[${name}]\x1b[0m`);
 }
@@ -243,6 +245,16 @@ export const deployCommand = defineCommand({
             description: "Target project slug or UUID. Required with --from-github when not run inside a project directory.",
             required: false,
         },
+        watch: {
+            type: "boolean",
+            description: "After deploy lands, poll status.conditions[] until Ready=True or Degraded reason=DeployTimeout (self-host creekd target only). Default poll = 1s, default budget = 5min.",
+            default: false,
+        },
+        "watch-timeout-ms": {
+            type: "string",
+            description: "Client-side watch budget in milliseconds (default 300000 = 5min). Independent of the daemon's progressing_timeout.",
+            required: false,
+        },
     },
     async run({ args }) {
         const jsonMode = resolveJsonMode(args);
@@ -256,6 +268,27 @@ export const deployCommand = defineCommand({
                 : process.cwd();
             return await dryRunPlan(dryCwd, args, jsonMode);
         }
+        // --- Safety gate: no silent deploys in non-interactive environments ---
+        // Deploying publishes to a public URL — irreversible enough that we
+        // don't want it to happen by accident. In a TTY a human is present to
+        // see and abort; in a non-TTY (AI agent, CI, pipe) there is no prompt,
+        // so a bare `creek deploy` would otherwise just ship. Require an
+        // explicit --yes there instead. This is what makes the "safe to run
+        // from an AI coding agent" promise true: a bare call refuses and points
+        // at --dry-run / --yes rather than publishing on its own. Documented CI
+        // already passes --yes, so this doesn't regress automated deploys.
+        if (!isTTY && !args.yes) {
+            const breadcrumbs = [
+                { command: "creek deploy --dry-run", description: "Preview the plan without executing (no network, no uploads)" },
+                { command: "creek deploy --yes", description: "Confirm and deploy without an interactive prompt" },
+            ];
+            const message = "Refusing to deploy from a non-interactive environment without confirmation. Re-run with --dry-run to preview the plan, or --yes to deploy.";
+            if (jsonMode) {
+                jsonOutput({ ok: false, error: "confirmation_required", message }, 1, breadcrumbs);
+            }
+            consola.error(message);
+            process.exit(1);
+        }
         // --- Ensure ToS accepted ---
         const autoConfirm = shouldAutoConfirm(args);
         const tos = await ensureTosAccepted(autoConfirm);
@@ -318,6 +351,13 @@ export const deployCommand = defineCommand({
                     consola.warn(`  Binding '${ub.name}' (${ub.type}) is not yet supported — will be skipped`);
                 }
             }
+            // creekd target → deploy to local creekd via admin API
+            if (resolved.target === "creekd") {
+                return await deployCreekd(cwd, resolved, args["skip-build"], jsonMode, {
+                    watch: args.watch === true,
+                    watchTimeoutMs: parseWatchTimeoutMs(args["watch-timeout-ms"]),
+                });
+            }
             if (token) {
                 return await deployAuthenticated(cwd, resolved, token, args["skip-build"], jsonMode, args["no-cache"]);
             }
@@ -344,6 +384,203 @@ export const deployCommand = defineCommand({
         process.exit(1);
     },
 });
+async function deployCreekd(cwd, resolved, skipBuild, jsonMode, watchOpts = { watch: false }) {
+    const client = new CreekdClient();
+    // 1. Verify creekd is reachable
+    try {
+        await client.listApps();
+    }
+    catch {
+        const msg = `Cannot reach creekd at ${getCreekdUrl()}. Is it running?`;
+        if (jsonMode)
+            jsonOutput({ error: "creekd_unreachable", message: msg }, 1, [
+                { command: "creekd", description: "Start the daemon" },
+            ]);
+        consola.error(msg);
+        process.exit(1);
+    }
+    if (!jsonMode) {
+        section("Detect");
+        consola.info(`  Target: creekd (local)`);
+        consola.info(`  Project: ${resolved.projectName}`);
+        if (resolved.framework)
+            consola.info(`  Framework: ${resolved.framework}`);
+    }
+    // 2. Build (unless skipped)
+    if (!skipBuild && resolved.buildCommand) {
+        if (!jsonMode) {
+            section("Build");
+            consola.start(`  ${resolved.buildCommand}`);
+        }
+        try {
+            execSync(resolved.buildCommand, { cwd, stdio: jsonMode ? "pipe" : "inherit" });
+            if (!jsonMode)
+                consola.success("  Build complete");
+        }
+        catch (e) {
+            const msg = `Build failed: ${resolved.buildCommand}`;
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "build_failed", message: msg }, 1, []);
+            consola.error(msg);
+            process.exit(1);
+        }
+    }
+    // 3. Detect entry point + runtime
+    const entryPoint = resolved.workerEntry ?? resolved.buildOutput + "/index.js";
+    const runtime = "bun"; // default; could read from creek.toml [app].runtime
+    const port = 3000; // TODO: auto-assign or read from config
+    // 4. Deploy via CreekdClient (idempotent: spawn if absent, deploy if running)
+    if (!jsonMode) {
+        section("Deploy");
+        consola.start("  Deploying to creekd...");
+    }
+    const startTime = Date.now();
+    try {
+        const spawnReq = { id: resolved.projectName, runtime, entry: entryPoint, port };
+        let app;
+        try {
+            app = await client.spawnApp(spawnReq);
+        }
+        catch (e) {
+            if (e.code === "already_running") {
+                app = await client.deployApp(resolved.projectName, { runtime, entry: entryPoint, port });
+            }
+            else {
+                throw e;
+            }
+        }
+        // Release phase (pre-traffic command, e.g. migrations)
+        if (resolved.releaseCommand) {
+            if (!jsonMode) {
+                section("Release");
+                consola.start(`  ${resolved.releaseCommand}`);
+            }
+            try {
+                execSync(resolved.releaseCommand, {
+                    cwd,
+                    stdio: jsonMode ? "pipe" : "inherit",
+                    timeout: (resolved.releaseTimeout ?? 300) * 1000,
+                });
+                if (!jsonMode)
+                    consola.success("  Release complete");
+            }
+            catch (e) {
+                const msg = e.killed
+                    ? `Release command timed out after ${resolved.releaseTimeout ?? 300}s`
+                    : `Release command failed: ${e.stderr?.toString() || e.message}`;
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "release_failed", message: msg }, 1);
+                consola.error(msg);
+                try {
+                    await client.stopApp(resolved.projectName);
+                }
+                catch { }
+                process.exit(1);
+            }
+        }
+        const elapsedS = ((Date.now() - startTime) / 1000).toFixed(1);
+        // --watch — poll status.conditions[] until Ready or
+        // deploy_stuck. Runs AFTER `creekctl ensure` returns success
+        // so the daemon already has the spec; we're observing the
+        // supervisor's convergence. Skipped when --watch is off.
+        let watchSummary;
+        if (watchOpts.watch) {
+            if (!jsonMode) {
+                section("Watch");
+                consola.start("  Polling status.conditions[]...");
+            }
+            watchSummary = await watchDeploy(new CreekdClient(), resolved.projectName, {
+                timeoutMs: watchOpts.watchTimeoutMs,
+                onPoll: jsonMode
+                    ? undefined
+                    : (envelope) => {
+                        const conds = envelope.status?.conditions ?? [];
+                        const summary = conds.map((c) => `${c.type}=${c.status}`).join(" ");
+                        consola.info(`  ${summary}`);
+                    },
+            });
+        }
+        if (jsonMode) {
+            jsonOutput({
+                ok: watchSummary ? watchSummary.ok : true,
+                url: `http://localhost:${port}`,
+                appId: resolved.projectName,
+                port,
+                runtime,
+                target: "creekd",
+                buildTimeS: parseFloat(elapsedS),
+                mode: "creekd-local",
+                ...(watchSummary ? { watch: watchSummaryWire(watchSummary) } : {}),
+            }, watchSummary && !watchSummary.ok ? 1 : 0, [
+                { command: `creek top ${resolved.projectName}`, description: "Check app status" },
+                { command: `creek logs --server ${resolved.projectName}`, description: "View app logs" },
+                { command: `creek exec -- bun run seed.ts`, description: "Run one-off command" },
+            ]);
+        }
+        else {
+            if (watchSummary && !watchSummary.ok) {
+                consola.error(`  Watch failed: ${watchSummary.reason}`);
+                if (watchSummary.reason === "deploy_stuck") {
+                    consola.info("  The daemon flipped Degraded reason=DeployTimeout — supervisor did not converge.");
+                    consola.info(`    creek logs --server ${resolved.projectName}     Inspect why`);
+                }
+                else if (watchSummary.reason === "watch_timeout") {
+                    consola.info(`  Client gave up after ${watchSummary.elapsedMs}ms. The daemon may still converge.`);
+                }
+                else if (watchSummary.reason === "fetch_failed") {
+                    consola.info(`  Polling failed: ${watchSummary.error.message}`);
+                }
+                process.exit(1);
+            }
+            consola.success(`  Deployed to creekd (${elapsedS}s)`);
+            consola.info(`  http://localhost:${port}`);
+            console.log("");
+            consola.info("  Next steps:");
+            consola.info(`    creek top ${resolved.projectName}      Check status`);
+            consola.info(`    creek logs --server ${resolved.projectName}     View logs`);
+            consola.info(`    creekctl events ${resolved.projectName}   Stream events`);
+        }
+    }
+    catch (e) {
+        const output = e.stdout?.toString() || e.stderr?.toString() || e.message;
+        const msg = `creekctl deploy failed: ${output}`;
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "creekd_deploy_failed", message: msg }, 1, []);
+        consola.error(msg);
+        process.exit(1);
+    }
+}
+/** Parse the --watch-timeout-ms flag. Empty / unset → undefined
+ *  so watchDeploy applies its own default. Non-numeric → exits. */
+function parseWatchTimeoutMs(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    const s = String(raw);
+    if (!/^\d+$/.test(s)) {
+        consola.error(`--watch-timeout-ms must be a positive integer (got "${raw}")`);
+        process.exit(1);
+    }
+    const n = Number.parseInt(s, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+        consola.error(`--watch-timeout-ms must be a positive integer (got "${raw}")`);
+        process.exit(1);
+    }
+    return n;
+}
+/** Pluck the JSON-friendly fields out of a WatchResult — strips
+ *  the AppEnvelope which is too noisy for the deploy summary. */
+function watchSummaryWire(r) {
+    if (r.ok)
+        return { ok: true, reason: r.reason };
+    if (r.reason === "deploy_stuck") {
+        const conds = r.envelope.status?.conditions ?? [];
+        return { ok: false, reason: r.reason, conditions: conds };
+    }
+    if (r.reason === "watch_timeout") {
+        return { ok: false, reason: r.reason, elapsedMs: r.elapsedMs };
+    }
+    return { ok: false, reason: r.reason, error: r.error.message };
+}
 export const CLI_TERMINAL_STATUSES = new Set(["active", "failed", "cancelled"]);
 export const CLI_IN_FLIGHT_STATUSES = new Set([
     "queued",
@@ -514,12 +751,18 @@ async function deployFromGithub(options) {
     // Report the outcome
     if (targetDeployment.status === "active") {
         if (jsonMode) {
+            const elapsedS = ((Date.now() - startedAt) / 1000).toFixed(1);
             jsonOutput({
                 ok: true,
                 deploymentId: targetDeployment.id,
                 version: targetDeployment.version,
                 status: "active",
                 url: targetDeployment.url,
+                branch: targetDeployment.branch,
+                buildTimeS: parseFloat(elapsedS),
+                mode: "production",
+                source: "github",
+                rollbackCommand: `creek rollback --project ${projectSlug}`,
             }, 0, NO_PROJECT_BREADCRUMBS);
         }
         else {
@@ -777,9 +1020,11 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
                 sandboxId: result.sandboxId,
                 url: status.previewUrl,
                 deployDurationMs: status.deployDurationMs,
+                buildTimeS: status.deployDurationMs ? parseFloat((status.deployDurationMs / 1000).toFixed(1)) : null,
                 expiresAt: result.expiresAt,
                 expiresInMinutes: expiresInMinutes(result.expiresAt),
                 framework: framework ?? null,
+                renderMode: effectiveRenderMode,
                 assetCount: fileList.length,
                 mode: "sandbox",
             }, 0, [
@@ -1062,13 +1307,20 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
                     // Silent — build log is best-effort for now.
                 });
                 if (jsonMode) {
+                    const elapsedS = ((Date.now() - start) / 1000).toFixed(1);
                     jsonOutput({
                         ok: true,
                         url: res.url ?? res.previewUrl,
                         previewUrl: res.previewUrl,
                         deploymentId: deployment.id,
+                        version: res.deployment?.version ?? null,
                         project: project.slug,
+                        framework: framework ?? null,
+                        renderMode: effectiveRenderMode,
+                        assetCount: fileList.length,
+                        buildTimeS: parseFloat(elapsedS),
                         mode: "production",
+                        rollbackCommand: `creek rollback --project ${project.slug}`,
                         ...(resolved.cron.length > 0 ? { cron: resolved.cron } : {}),
                     }, 0, [
                         { command: `creek status`, description: "Check deployment status" },

package/dist/commands/dev.d.ts

@@ -4,10 +4,23 @@ export declare const devCommand: import("citty").CommandDef<{
         description: string;
         default: string;
     };
+    target: {
+        type: "string";
+        description: string;
+        required: false;
+    };
     reset: {
         type: "boolean";
         description: string;
     };
+    dashboard: {
+        type: "boolean";
+        description: string;
+    };
+    top: {
+        type: "boolean";
+        description: string;
+    };
     json: {
         type: "boolean";
         description: string;

package/dist/commands/dev.js

@@ -1,12 +1,13 @@
 import { defineCommand } from "citty";
 import { consola } from "consola";
-import { resolveConfig, formatDetectionSummary } from "@solcreek/sdk";
+import { execSync } from "node:child_process";
+import { resolveConfig, formatDetectionSummary, DEPLOY_TARGETS } from "@solcreek/sdk";
 import { globalArgs } from "../utils/output.js";
 import { DevServer } from "../dev/server.js";
 export const devCommand = defineCommand({
     meta: {
         name: "dev",
-        description: "Start local development server",
+        description: "Start local development server. Auto-detects target from creek.toml (cf = Miniflare, creekd = sandbox VM with real Postgres/Redis).",
     },
     args: {
         ...globalArgs,
@@ -15,10 +16,23 @@ export const devCommand = defineCommand({
             description: "Port number (default: 3000)",
             default: "3000",
         },
+        target: {
+            type: "string",
+            description: "Deploy target override: cf (Miniflare) or creekd (sandbox VM)",
+            required: false,
+        },
         reset: {
             type: "boolean",
             description: "Clear local data before starting",
         },
+        dashboard: {
+            type: "boolean",
+            description: "Open the web dashboard after server starts",
+        },
+        top: {
+            type: "boolean",
+            description: "Show creek top alongside the dev server",
+        },
     },
     async run({ args }) {
         const cwd = process.cwd();
@@ -35,7 +49,36 @@ export const devCommand = defineCommand({
             consola.error(`Invalid port: ${args.port}`);
             process.exit(1);
         }
+        // Target: CLI flag > creek.toml > auto-detect (already resolved)
+        const target = args.target ?? config.target;
+        if (args.target && !DEPLOY_TARGETS.includes(args.target)) {
+            consola.error(`Invalid target "${args.target}". Valid: ${DEPLOY_TARGETS.join(", ")}`);
+            process.exit(1);
+        }
         consola.info(`Detected: ${formatDetectionSummary(config)}`);
+        consola.info(`Target: ${target}${args.target ? " (--target override)" : " (from config)"}`);
+        if (target === "creekd") {
+            const { CreekdDevServer } = await import("../dev/creekd-runner.js");
+            const server = new CreekdDevServer({ cwd, port, config, reset: !!args.reset });
+            const shutdown = async () => {
+                consola.info("Shutting down...");
+                await server.stop();
+                process.exit(0);
+            };
+            process.on("SIGINT", shutdown);
+            process.on("SIGTERM", shutdown);
+            try {
+                await server.start();
+            }
+            catch (e) {
+                consola.error(`Failed to start creekd dev server: ${e.message}`);
+                await server.stop();
+                process.exit(1);
+            }
+            afterStart(args, port);
+            return;
+        }
+        // CF Workers path (existing)
         const server = new DevServer({
             cwd,
             port,
@@ -58,6 +101,7 @@ export const devCommand = defineCommand({
             await server.stop();
             process.exit(1);
         }
+        afterStart(args, port);
         // Interactive trigger commands (only if cron/queue configured)
         if (config.cron.length > 0 || config.queue) {
             const { createInterface } = await import("node:readline");
@@ -99,4 +143,35 @@ export const devCommand = defineCommand({
         }
     },
 });
+function afterStart(args, port) {
+    if (args.dashboard) {
+        const url = `http://localhost:${port}`;
+        consola.info(`Opening dashboard: ${url}`);
+        openBrowser(url);
+    }
+    if (args.top) {
+        import("../utils/creekd-client.js").then(({ getCreekdUrl }) => {
+            const topUrl = getCreekdUrl();
+            consola.info(`Starting creek top (${topUrl})...`);
+            import("node:child_process").then(({ spawn }) => {
+                spawn(process.execPath, [process.argv[1], "top", "--server", topUrl], {
+                    stdio: "inherit",
+                });
+            });
+        });
+    }
+}
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === "darwin"
+            ? `open "${url}"`
+            : process.platform === "win32"
+                ? `start "" "${url}"`
+                : `xdg-open "${url}"`;
+        execSync(cmd, { stdio: "ignore" });
+    }
+    catch {
+        consola.info(`Open manually: ${url}`);
+    }
+}
 //# sourceMappingURL=dev.js.map

package/dist/commands/doctor.js

@@ -55,6 +55,15 @@ export const doctorCommand = defineCommand({
         const ctx = buildDoctorContext(cwd);
         const report = runDoctor(ctx);
         if (jsonMode) {
+            // A one-line human summary on stderr so stdout stays pure JSON for
+            // agents/pipes, while a person who pipes this in a terminal isn't
+            // staring at a wall of JSON. Only when stderr is a TTY (a human is
+            // watching) — fully-redirected/CI runs stay silent.
+            if (process.stderr.isTTY) {
+                const { error, warn, info } = report.summary;
+                const counts = `${error} error${s(error)}, ${warn} warning${s(warn)}, ${info} info`;
+                process.stderr.write(`creek doctor: ${report.ok ? "ok" : "issues found"} — ${counts}\n`);
+            }
             jsonOutput({
                 ok: report.ok,
                 cwd,

package/dist/commands/init.d.ts

@@ -14,5 +14,15 @@ export declare const initCommand: import("citty").CommandDef<{
         description: string;
         required: false;
     };
+    adopt: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+    "hostkey-fingerprint": {
+        type: "string";
+        description: string;
+        required: false;
+    };
 }>;
 //# sourceMappingURL=init.d.ts.map