@solcreek/cli 0.4.15 → 0.4.16

package/dist/commands/db.js

@@ -1,6 +1,6 @@
 import { defineCommand } from "citty";
 import consola from "consola";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { resolve } from "node:path";
 import { CreekClient } from "@solcreek/sdk";
@@ -322,6 +322,113 @@ const migrateCommand = defineCommand({
         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,
@@ -329,6 +436,7 @@ export const dbCommand = defineCommand({
         ...base.subCommands,
         shell: shellCommand,
         migrate: migrateCommand,
+        seed: seedCommand,
     },
 });
 //# sourceMappingURL=db.js.map

package/dist/commands/deploy.js

@@ -4,7 +4,8 @@ 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, 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";
@@ -89,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,
@@ -113,6 +121,7 @@ async function dryRunPlan(cwd, args, jsonMode) {
             : null,
         buildOutputFallback,
         bindings,
+        findings: doctorReport.findings,
         wouldDeploy,
         sideEffects: {
             networkCalls: false,
@@ -120,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, []);
@@ -155,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)`);

package/dist/commands/doctor.js

@@ -2,7 +2,8 @@ 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 { runDoctor, } from "@solcreek/sdk";
+import { buildDoctorContext } from "../utils/doctor-context.js";
 import { CreekClient } from "@solcreek/sdk";
 import { getToken, getApiUrl } from "../utils/config.js";
 import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, } from "../utils/output.js";
@@ -51,7 +52,7 @@ export const doctorCommand = defineCommand({
             return;
         }
         const cwd = resolve(args.path ?? process.cwd());
-        const ctx = buildContext(cwd);
+        const ctx = buildDoctorContext(cwd);
         const report = runDoctor(ctx);
         if (jsonMode) {
             jsonOutput({
@@ -68,35 +69,6 @@ export const doctorCommand = defineCommand({
             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");
@@ -105,17 +77,6 @@ function safeRead(path) {
         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",

package/dist/commands/init.js

@@ -59,11 +59,7 @@ export const initCommand = defineCommand({
                 output: "dist",
                 ...(useDb ? { worker: "worker/index.ts" } : {}),
             },
-            resources: {
-                d1: useDb,
-                kv: false,
-                r2: false,
-            },
+            ...(useDb ? { resources: { database: true } } : {}),
         };
         writeFileSync(configPath, stringify(config));
         // Scaffold worker + d1-schema example when database enabled

package/dist/utils/doctor-context.d.ts

@@ -0,0 +1,3 @@
+import { type DoctorContext } from "@solcreek/sdk";
+export declare function buildDoctorContext(cwd: string): DoctorContext;
+//# sourceMappingURL=doctor-context.d.ts.map

package/dist/utils/doctor-context.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveConfig, ConfigNotFoundError, } from "@solcreek/sdk";
+export function buildDoctorContext(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;
+        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;
+    }
+}
+//# sourceMappingURL=doctor-context.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",