@beechcms/cli 0.4.0-preview.9 → 0.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/commands/seed-load.ts
-import pc from "picocolors";
+import pc2 from "picocolors";
 import {
-  SEED_REGISTRY,
+  SEED_REGISTRY as SEED_REGISTRY2,
   generateCreateTable,
   generateDraftTable,
   generateIndexes,
@@ -27,9 +27,7 @@ function executeD1File(sql, options) {
     writeFileSync(tmpFile, sql, "utf-8");
     const args = ["d1", "execute", options.db, "--file", tmpFile, ...buildArgs(options)];
     const result = spawnSync("npx", ["wrangler", ...args], { stdio: "inherit", cwd: process.cwd(), shell: true });
-    if (result.status !== 0) {
-      process.exit(result.status ?? 1);
-    }
+    return result.status === 0;
   } finally {
     try {
       rmSync(tmpFile);
@@ -126,6 +124,68 @@ async function diffSeed(seed, options) {
   return { slug: seed.slug, tableExists: true, columns };
 }
 
+// src/commands/validate.ts
+import pc from "picocolors";
+import { SEED_REGISTRY } from "@beechcms/core";
+function validateSeeds(registry) {
+  const result = [];
+  const slugsSeen = /* @__PURE__ */ new Set();
+  for (const seed of Object.values(registry)) {
+    const messages = [];
+    if (slugsSeen.has(seed.slug)) {
+      messages.push(`duplicate slug "${seed.slug}" \u2014 each seed must have a unique slug`);
+    }
+    slugsSeen.add(seed.slug);
+    const aliasesSeen = /* @__PURE__ */ new Set();
+    for (const branch of seed.branches) {
+      if (aliasesSeen.has(branch.alias)) {
+        messages.push(`duplicate branch alias "${branch.alias}"`);
+      }
+      aliasesSeen.add(branch.alias);
+    }
+    const allAliases = new Set(seed.branches.map((b) => b.alias));
+    if (!allAliases.has(seed.displayNameAlias)) {
+      messages.push(`displayNameAlias "${seed.displayNameAlias}" not found in branches`);
+    }
+    if (messages.length > 0) {
+      result.push({ slug: seed.slug, messages });
+    }
+  }
+  return result;
+}
+async function validate(args) {
+  const registry = args.registry ?? SEED_REGISTRY;
+  if (Object.keys(registry).length === 0) {
+    console.warn(pc.yellow("\n  Warning: SEED_REGISTRY is empty. Create a seeds.ts in your project root.\n"));
+    return;
+  }
+  console.log(pc.cyan("\n  beech validate \u2014 checking seeds\n"));
+  const errors = validateSeeds(registry);
+  const errorMap = new Map(errors.map((e) => [e.slug, e.messages]));
+  let totalIssues = 0;
+  for (const seed of Object.values(registry)) {
+    const msgs = errorMap.get(seed.slug);
+    if (!msgs) {
+      console.log(pc.green(`  \u2713 ${seed.slug}`));
+    } else {
+      totalIssues += msgs.length;
+      console.log(pc.red(`  \u2717 ${seed.slug}`));
+      for (const msg of msgs) {
+        console.log(pc.red(`      \u2192 ${msg}`));
+      }
+    }
+  }
+  console.log("");
+  if (totalIssues > 0) {
+    const s = totalIssues !== 1 ? "s" : "";
+    console.log(pc.red(`  Found ${totalIssues} issue${s}. Fix the seeds above before loading.
+`));
+    process.exit(1);
+  } else {
+    console.log(pc.green("  All seeds valid.\n"));
+  }
+}
+
 // src/commands/seed-load.ts
 function buildStatements(seed) {
   const stmts = [generateCreateTable(seed), ...generateIndexes(seed)];
@@ -139,71 +199,100 @@ function buildStatements(seed) {
 }
 async function runDiff(options, registry) {
   const seeds = Object.values(registry);
-  console.log(pc.cyan("\n  Diffing schema\u2026\n"));
+  console.log(pc2.cyan("\n  Diffing schema\u2026\n"));
   let allOk = true;
   for (const seed of seeds) {
     const result = await diffSeed(seed, options);
     const tableName = `content_${seed.slug}`;
     if (!result.tableExists) {
-      console.log(pc.red(`  \u2717 ${tableName} \u2014 table missing`));
+      console.log(pc2.red(`  \u2717 ${tableName} \u2014 table missing`));
       allOk = false;
       continue;
     }
     const problems = result.columns.filter((c) => c.status !== "ok");
     if (problems.length === 0) {
-      console.log(pc.green(`  \u2713 ${tableName}`));
+      console.log(pc2.green(`  \u2713 ${tableName}`));
       continue;
     }
     allOk = false;
-    console.log(pc.yellow(`  \u26A0 ${tableName}`));
+    console.log(pc2.yellow(`  \u26A0 ${tableName}`));
     for (const col of problems) {
       if (col.status === "missing") {
-        console.log(pc.red(`    + missing column: ${col.name} ${col.expectedType}`));
+        console.log(pc2.red(`    + missing column: ${col.name} ${col.expectedType}`));
       } else if (col.status === "extra") {
-        console.log(pc.dim(`    ~ extra column:   ${col.name} ${col.actualType}`));
+        console.log(pc2.dim(`    ~ orphaned column: "${col.name}" (${col.actualType}) \u2014 exists in DB but not in seeds.ts`));
       } else if (col.status === "type_mismatch") {
-        console.log(pc.red(`    \u2260 type mismatch:  ${col.name} (expected ${col.expectedType}, got ${col.actualType})`));
+        console.log(pc2.red(`    \u2260 type mismatch:  ${col.name} (expected ${col.expectedType}, got ${col.actualType})`));
       }
     }
   }
   console.log("");
   if (allOk) {
-    console.log(pc.green("  Schema matches seeds. No action needed.\n"));
+    console.log(pc2.green("  Schema matches seeds. No action needed.\n"));
   } else {
-    console.log(pc.yellow("  Run `beech seed:load` to apply missing tables/columns.\n"));
+    console.log(pc2.yellow("  Run `beech seed:load` to apply missing tables/columns.\n"));
   }
 }
 async function runLoad(options, dryRun, registry) {
   const seeds = Object.values(registry);
   if (dryRun) {
-    console.log(pc.cyan("\n  -- dry-run: SQL that would be executed\n"));
+    console.log(pc2.cyan("\n  -- dry-run: SQL that would be executed\n"));
     for (const seed of seeds) {
       const stmts = buildStatements(seed);
-      console.log(pc.dim(`  -- content_${seed.slug}`));
+      console.log(pc2.dim(`  -- content_${seed.slug}`));
       for (const stmt of stmts) {
         console.log(stmt + "\n");
       }
     }
     return;
   }
-  console.log(pc.cyan(`
+  console.log(pc2.cyan(`
   Loading seeds into ${options.local ? "local" : "remote"} D1 (${options.db})\u2026
 `));
   for (const seed of seeds) {
     const stmts = buildStatements(seed);
     const sql = stmts.join("\n\n") + "\n";
-    process.stdout.write(`  ${pc.dim("\u2192")} content_${seed.slug}\u2026 `);
-    executeD1File(sql, options);
-    console.log(pc.green("done"));
+    process.stdout.write(`  ${pc2.dim("\u2192")} content_${seed.slug}\u2026 `);
+    const ok = executeD1File(sql, options);
+    if (!ok) {
+      console.log(pc2.red("failed"));
+      console.log(pc2.red(`
+  \u2717 Failed to apply schema for content_${seed.slug}
+`));
+      console.log(pc2.dim("  wrangler reported an error above."));
+      console.log(pc2.dim(`  Most likely causes:`));
+      console.log(pc2.dim(`    - Database "${options.db}" not found or wrong database_id`));
+      if (!options.local) {
+        console.log(pc2.dim("    - Not logged in to Cloudflare"));
+        console.log(pc2.cyan("\n  \u2192 Run:  npx wrangler login"));
+        console.log(pc2.cyan("  \u2192 Then: npx beech seed:load\n"));
+      } else {
+        console.log(pc2.cyan("\n  \u2192 Run:  npx beech init --db --local   # re-initialise local DB"));
+        console.log(pc2.cyan("  \u2192 Then: npx beech seed:load --local\n"));
+      }
+      process.exit(1);
+    }
+    console.log(pc2.green("done"));
   }
-  console.log(pc.green("\n  All seeds loaded.\n"));
+  console.log(pc2.green("\n  All seeds loaded.\n"));
 }
 async function seedLoad(args) {
-  const registry = args.registry ?? SEED_REGISTRY;
+  const registry = args.registry ?? SEED_REGISTRY2;
   if (Object.keys(registry).length === 0) {
-    console.warn(pc.yellow("\n  Warning: SEED_REGISTRY is empty. Create a seeds.ts in your project root.\n"));
+    console.log(pc2.yellow("\n  \u2717 No seeds found\n"));
+    console.log(pc2.dim("  Create a seeds.ts file in your project root with at least one content type."));
+    console.log(pc2.cyan("\n  \u2192 Run: npx beech seed:create\n"));
     return;
   }
+  const validationErrors = validateSeeds(registry);
+  if (validationErrors.length > 0) {
+    const total = validationErrors.reduce((n, e) => n + e.messages.length, 0);
+    const s = total !== 1 ? "s" : "";
+    console.log(pc2.yellow(`
+  \u26A0 Seed validation found ${total} issue${s}. Schema changes will still be applied.
+`));
+    console.log(pc2.dim('  Run "npx beech validate" for details.\n'));
+  }
   const configPath = findWranglerConfig();
   const db = args.db ?? resolveDbName(configPath);
   const options = {
@@ -217,6 +306,769 @@ async function seedLoad(args) {
     await runLoad(options, args.dryRun, registry);
   }
 }
+
+// src/commands/init.ts
+import pc3 from "picocolors";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { resolve as resolve2, basename } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var SYSTEM_TABLES = [
+  "users",
+  "refresh_tokens",
+  "password_reset_tokens",
+  "public_idempotency_keys",
+  "analytics",
+  "system_stats",
+  "activity_logs",
+  "notifications",
+  "media_objects",
+  "content_event_log"
+];
+var BASE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS users (
+    id                  TEXT    NOT NULL PRIMARY KEY,
+    email               TEXT    NOT NULL UNIQUE,
+    password_hash       TEXT    NOT NULL,
+    role                TEXT    NOT NULL DEFAULT 'editor' CHECK (role IN ('admin', 'editor')),
+    name                TEXT,
+    avatar_url          TEXT,
+    notification_prefs  TEXT    NOT NULL DEFAULT '{}',
+    created_at          INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE TABLE IF NOT EXISTS refresh_tokens (
+    id          TEXT    NOT NULL PRIMARY KEY,
+    user_id     TEXT    NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    token_hash  TEXT    NOT NULL,
+    expires_at  INTEGER NOT NULL,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    revoked_at  INTEGER DEFAULT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_refresh_user    ON refresh_tokens(user_id);
+CREATE INDEX IF NOT EXISTS idx_refresh_hash    ON refresh_tokens(token_hash);
+CREATE INDEX IF NOT EXISTS idx_refresh_expires ON refresh_tokens(expires_at);
+
+CREATE TABLE IF NOT EXISTS password_reset_tokens (
+    id          TEXT    NOT NULL PRIMARY KEY,
+    user_id     TEXT    NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    token_hash  TEXT    NOT NULL,
+    expires_at  INTEGER NOT NULL,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    used_at     INTEGER DEFAULT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_prt_hash ON password_reset_tokens(token_hash);
+CREATE INDEX IF NOT EXISTS idx_prt_user ON password_reset_tokens(user_id);
+
+CREATE TABLE IF NOT EXISTS public_idempotency_keys (
+    idempotency_key     TEXT    NOT NULL PRIMARY KEY,
+    request_fingerprint TEXT    NOT NULL,
+    response_status     INTEGER NOT NULL,
+    response_body       TEXT    NOT NULL,
+    created_at          INTEGER NOT NULL,
+    expires_at          INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_idempotency_expires ON public_idempotency_keys(expires_at);
+
+CREATE TABLE IF NOT EXISTS analytics (
+    id      INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    day_ts  INTEGER NOT NULL,
+    metric  TEXT    NOT NULL,
+    seed    TEXT    NOT NULL DEFAULT '',
+    value   INTEGER NOT NULL DEFAULT 0,
+    UNIQUE(day_ts, metric, seed)
+);
+
+CREATE INDEX IF NOT EXISTS idx_analytics_day  ON analytics(day_ts);
+CREATE INDEX IF NOT EXISTS idx_analytics_seed ON analytics(seed, day_ts);
+
+CREATE TABLE IF NOT EXISTS system_stats (
+    id    TEXT NOT NULL PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+INSERT OR IGNORE INTO system_stats (id, value) VALUES ('total_storage_bytes', '0');
+
+CREATE TABLE IF NOT EXISTS activity_logs (
+    id          TEXT    NOT NULL PRIMARY KEY,
+    user_id     TEXT    NOT NULL,
+    user_email  TEXT    NOT NULL,
+    user_name   TEXT,
+    action      TEXT    NOT NULL,
+    entity_type TEXT    NOT NULL,
+    entity_id   TEXT    NOT NULL,
+    entity_slug TEXT,
+    details     TEXT,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_activity_user    ON activity_logs(user_id);
+CREATE INDEX IF NOT EXISTS idx_activity_created ON activity_logs(created_at);
+
+CREATE TABLE IF NOT EXISTS notifications (
+    id         TEXT    NOT NULL PRIMARY KEY,
+    title      TEXT    NOT NULL,
+    message    TEXT    NOT NULL,
+    type       TEXT    NOT NULL DEFAULT 'info' CHECK (type IN ('info', 'warning', 'error')),
+    is_read    INTEGER NOT NULL DEFAULT 0 CHECK (is_read IN (0, 1)),
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_notifications_created ON notifications(created_at);
+CREATE INDEX IF NOT EXISTS idx_notifications_unread  ON notifications(is_read);
+
+CREATE TABLE IF NOT EXISTS media_objects (
+    key         TEXT    NOT NULL PRIMARY KEY,
+    filename    TEXT    NOT NULL,
+    mime_type   TEXT    NOT NULL,
+    size_bytes  INTEGER NOT NULL,
+    uploaded_by TEXT    NOT NULL DEFAULT '',
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_media_user    ON media_objects(uploaded_by);
+CREATE INDEX IF NOT EXISTS idx_media_created ON media_objects(created_at DESC);
+
+CREATE TABLE IF NOT EXISTS content_event_log (
+    id          TEXT    NOT NULL PRIMARY KEY,
+    schema_slug TEXT    NOT NULL,
+    entry_id    TEXT    NOT NULL,
+    action      TEXT    NOT NULL CHECK (action IN ('create', 'update', 'delete')),
+    user_id     TEXT,
+    details     TEXT,
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_event_log_schema_slug ON content_event_log(schema_slug);
+CREATE INDEX IF NOT EXISTS idx_event_log_created_at  ON content_event_log(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_event_log_entry_id    ON content_event_log(entry_id);
+`.trim();
+var PLACEHOLDER_DB_IDS = [
+  "INCOLLA_QUI_IL_TUO_ID_D1",
+  "FILL_IN_YOUR_D1_DATABASE_ID",
+  "YOUR_D1_DATABASE_ID"
+];
+function checkWranglerAuth() {
+  const result = spawnSync2("npx", ["wrangler", "whoami", "--json"], {
+    encoding: "utf-8",
+    cwd: process.cwd(),
+    shell: true
+  });
+  return result.status === 0;
+}
+function checkWranglerPlaceholders(configPath) {
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(stripped);
+    const bindings = parsed?.d1_databases ?? [];
+    const issues = [];
+    for (const b of bindings) {
+      const id = b.database_id ?? "";
+      if (!id || PLACEHOLDER_DB_IDS.includes(id)) {
+        issues.push(`d1_databases[0].database_id is "${id || "(empty)"}"`);
+      }
+    }
+    return issues;
+  } catch {
+    return [];
+  }
+}
+function readProjectName(configPath) {
+  if (!configPath) return basename(process.cwd());
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(stripped);
+    return parsed?.name || basename(process.cwd());
+  } catch {
+    return basename(process.cwd());
+  }
+}
+function readBucketName(configPath) {
+  if (!configPath) return null;
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(stripped);
+    const buckets = parsed?.r2_buckets ?? [];
+    return buckets[0]?.bucket_name ?? null;
+  } catch {
+    return null;
+  }
+}
+function createD1Database(dbName) {
+  const result = spawnSync2("npx", ["wrangler", "d1", "create", dbName, "--json"], {
+    encoding: "utf-8",
+    cwd: process.cwd(),
+    shell: true,
+    stdio: ["inherit", "pipe", "pipe"]
+  });
+  if (result.status !== 0) return null;
+  try {
+    const parsed = JSON.parse(result.stdout);
+    return parsed?.uuid ?? parsed?.database_id ?? null;
+  } catch {
+    return null;
+  }
+}
+function createR2Bucket(bucketName) {
+  const result = spawnSync2("npx", ["wrangler", "r2", "bucket", "create", bucketName], {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    shell: true
+  });
+  return result.status === 0;
+}
+function patchWranglerConfig(configPath, dbId) {
+  try {
+    let raw = readFileSync2(configPath, "utf-8");
+    for (const placeholder of PLACEHOLDER_DB_IDS) {
+      raw = raw.split(placeholder).join(dbId);
+    }
+    raw = raw.replace(/"database_id"\s*:\s*""/g, `"database_id": "${dbId}"`);
+    writeFileSync2(configPath, raw, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function printManualDbInstructions() {
+  console.log(pc3.dim("\n  Update your D1 database_id in wrangler.jsonc,"));
+  console.log(pc3.dim("  or create a new database with:"));
+  console.log(pc3.cyan("\n  \u2192 Run:  npx wrangler d1 create my-project-db"));
+  console.log(pc3.cyan("  \u2192 Then: npx beech init --db\n"));
+}
+function echoApiKeys(configPath) {
+  if (!configPath) return;
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(stripped);
+    const vars = parsed?.vars ?? {};
+    const readKey = vars["PUBLIC_READ_API_KEY"];
+    const writeKey = vars["PUBLIC_WRITE_API_KEY"];
+    if (!readKey && !writeKey) return;
+    console.log(pc3.dim("  API keys detected in wrangler.jsonc:\n"));
+    if (readKey) {
+      const masked = readKey.length > 8 ? readKey.slice(0, 4) + "****" + readKey.slice(-4) : "****";
+      console.log(pc3.dim(`    PUBLIC_READ_API_KEY  = ${masked}`));
+    }
+    if (writeKey) {
+      const masked = writeKey.length > 8 ? writeKey.slice(0, 4) + "****" + writeKey.slice(-4) : "****";
+      console.log(pc3.dim(`    PUBLIC_WRITE_API_KEY = ${masked}`));
+    }
+    console.log(pc3.dim("\n  Use these in your frontend as the X-API-Key header.\n"));
+  } catch {
+  }
+}
+function checkFiles(cwd, checkDevVars) {
+  let ok = true;
+  const workerExists = existsSync2(resolve2(cwd, "worker.ts")) || existsSync2(resolve2(cwd, "worker.js"));
+  if (!workerExists) {
+    console.log(pc3.red("  \u2717 worker.ts        \u2014 missing (required)"));
+    ok = false;
+  } else {
+    console.log(pc3.green("  \u2713 worker.ts"));
+  }
+  const configPath = findWranglerConfig();
+  const configInCwd = configPath && (configPath === resolve2(cwd, "wrangler.jsonc") || configPath === resolve2(cwd, "wrangler.json") || configPath === resolve2(cwd, "wrangler.toml"));
+  if (!configInCwd) {
+    console.log(pc3.red("  \u2717 wrangler.jsonc   \u2014 missing (required)"));
+    ok = false;
+  } else {
+    console.log(pc3.green(`  \u2713 ${basename(configPath)}`));
+  }
+  const seedsExists = existsSync2(resolve2(cwd, "seeds.ts")) || existsSync2(resolve2(cwd, "seeds.js")) || existsSync2(resolve2(cwd, "seed.ts")) || existsSync2(resolve2(cwd, "seed.js"));
+  if (!seedsExists) {
+    console.log(pc3.yellow("  \u26A0 seeds.ts         \u2014 missing (create it, then run beech seed:load)"));
+  } else {
+    console.log(pc3.green("  \u2713 seeds.ts"));
+  }
+  if (checkDevVars) {
+    if (!existsSync2(resolve2(cwd, ".dev.vars"))) {
+      console.log(pc3.dim("  \u25CB .dev.vars        \u2014 not found (optional: only needed for production R2 credentials)"));
+    } else {
+      console.log(pc3.green("  \u2713 .dev.vars"));
+    }
+  }
+  return ok;
+}
+function printNextSteps(local) {
+  const localFlag = local ? " --local" : "";
+  console.log(pc3.dim("  Next steps:"));
+  console.log(pc3.cyan(`  1. npx beech seed:load${localFlag}`));
+  console.log(pc3.dim("      \u2192 create content tables from seeds.ts"));
+  console.log(pc3.cyan("  2. npx wrangler dev"));
+  console.log(pc3.dim("      \u2192 start API + dashboard"));
+  console.log(pc3.dim("  3. Open http://localhost:8789/admin\n"));
+}
+function getExistingTables(options) {
+  try {
+    const rows = queryD1(
+      `SELECT name FROM sqlite_master WHERE type='table'`,
+      options
+    );
+    return rows.map((r) => r.name);
+  } catch {
+    return null;
+  }
+}
+async function init(args) {
+  const cwd = process.cwd();
+  console.log(pc3.cyan("\n  beech init \u2014 project check\n"));
+  const filesOk = checkFiles(cwd, args.local);
+  if (!filesOk) {
+    console.log(pc3.red("\n  \u2717 Required files missing\n"));
+    console.log(pc3.dim("  Fix the errors above before initialising the database."));
+    console.log(pc3.cyan("\n  \u2192 See: https://beechcms.dev/docs/getting-started\n"));
+    process.exit(1);
+  }
+  console.log(pc3.green("\n  All required files present.\n"));
+  if (!args.initDb) {
+    echoApiKeys(findWranglerConfig());
+    const localFlag = args.local ? " --local" : "";
+    console.log(pc3.dim("  Next steps:"));
+    console.log(pc3.dim(`  1. npx beech init --db${localFlag}     # initialise D1 database`));
+    console.log(pc3.dim(`  2. npx beech seed:load${localFlag}     # create content tables`));
+    console.log(pc3.dim("  3. npx wrangler dev                 # start API + dashboard"));
+    console.log(pc3.dim("  4. Open http://localhost:8789/admin\n"));
+    return;
+  }
+  const configPath = findWranglerConfig();
+  if (configPath) {
+    const placeholders = checkWranglerPlaceholders(configPath);
+    if (placeholders.length > 0) {
+      console.log(pc3.yellow("  \u26A0 wrangler.jsonc contains placeholder values:\n"));
+      for (const issue of placeholders) {
+        console.log(pc3.yellow(`    - ${issue}`));
+      }
+      if (process.stdin.isTTY) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        let autoCreate = false;
+        try {
+          const answer = (await rl.question(
+            pc3.cyan("\n  \u2192 Create a new D1 database (and R2 bucket) on Cloudflare automatically? (Y/n): ")
+          )).trim().toLowerCase();
+          autoCreate = !answer || answer === "y" || answer === "yes";
+        } finally {
+          rl.close();
+        }
+        if (autoCreate) {
+          const authed = checkWranglerAuth();
+          if (!authed) {
+            console.log(pc3.red("\n  \u2717 Not logged in to Cloudflare\n"));
+            console.log(pc3.dim("  BeechCMS needs access to your Cloudflare account to create the database."));
+            console.log(pc3.cyan("\n  \u2192 Run:  npx wrangler login"));
+            console.log(pc3.cyan("  \u2192 Then: npx beech init --db\n"));
+            process.exit(1);
+          }
+          const projectName = readProjectName(configPath);
+          const dbName = `${projectName}-db`;
+          const bucketName = readBucketName(configPath) || `${projectName}-media`;
+          console.log(pc3.dim(`
+  Creating D1 database "${dbName}"\u2026`));
+          const dbId = createD1Database(dbName);
+          if (!dbId) {
+            console.log(pc3.red("\n  \u2717 Failed to create D1 database\n"));
+            console.log(pc3.dim("  Create it manually and retry:"));
+            console.log(pc3.cyan(`
+  \u2192 Run:  npx wrangler d1 create ${dbName}`));
+            console.log(pc3.cyan("  \u2192 Then: npx beech init --db\n"));
+            process.exit(1);
+          }
+          console.log(pc3.green(`  \u2713 D1 database created (id: ${dbId})`));
+          console.log(pc3.dim(`
+  Creating R2 bucket "${bucketName}"\u2026`));
+          const r2Ok = createR2Bucket(bucketName);
+          if (r2Ok) {
+            console.log(pc3.green(`  \u2713 R2 bucket "${bucketName}" created`));
+          } else {
+            console.log(pc3.yellow(`  \u26A0 R2 bucket creation failed (may already exist \u2014 continuing)`));
+          }
+          console.log(pc3.dim("\n  Updating wrangler.jsonc\u2026"));
+          const patched = patchWranglerConfig(configPath, dbId);
+          if (patched) {
+            console.log(pc3.green("  \u2713 wrangler.jsonc updated\n"));
+          } else {
+            console.log(pc3.yellow(`  \u26A0 Could not update wrangler.jsonc automatically
+`));
+            console.log(pc3.dim(`  Set database_id = "${dbId}" in wrangler.jsonc manually, then retry:`));
+            console.log(pc3.cyan("  \u2192 Run: npx beech init --db\n"));
+            process.exit(1);
+          }
+        } else {
+          printManualDbInstructions();
+          process.exit(1);
+        }
+      } else {
+        printManualDbInstructions();
+        process.exit(1);
+      }
+    }
+  }
+  if (!args.local) {
+    const authed = checkWranglerAuth();
+    if (!authed) {
+      console.log(pc3.red("  \u2717 Not logged in to Cloudflare\n"));
+      console.log(pc3.dim("  BeechCMS needs access to your Cloudflare account to manage the D1 database."));
+      console.log(pc3.cyan("\n  \u2192 Run:  npx wrangler login"));
+      console.log(pc3.cyan("  \u2192 Then: npx beech init --db\n"));
+      process.exit(1);
+    }
+  }
+  const db = args.db ?? resolveDbName(configPath);
+  const options = { db, local: args.local, configPath };
+  console.log(pc3.cyan(`  Checking database "${db}" (${args.local ? "local" : "remote"})\u2026
+`));
+  const existingTables = getExistingTables(options);
+  const missingTables = SYSTEM_TABLES.filter((t) => !existingTables?.includes(t));
+  if (!args.local) {
+    if (existingTables === null) {
+      console.log(pc3.red("  \u2717 Remote database unreachable\n"));
+      console.log(pc3.dim("  Most likely causes:"));
+      console.log(pc3.dim("    - Wrong database_id in wrangler.jsonc"));
+      console.log(pc3.dim("    - Worker not yet deployed"));
+      console.log(pc3.cyan("\n  \u2192 Fix:  Update d1_databases.database_id in wrangler.jsonc"));
+      console.log(pc3.cyan("  \u2192 Then: npm run deploy\n"));
+      process.exit(1);
+    }
+    if (missingTables.length > 0) {
+      console.log(pc3.yellow(`  \u26A0 Missing system tables: ${missingTables.join(", ")}
+`));
+      console.log(pc3.dim("  Most likely causes:"));
+      console.log(pc3.dim("    - Wrong database_id in wrangler.jsonc"));
+      console.log(pc3.dim("    - Migrations did not run during deploy"));
+      console.log(pc3.cyan("\n  \u2192 Fix:  Update d1_databases.database_id in wrangler.jsonc"));
+      console.log(pc3.cyan("  \u2192 Then: npm run deploy\n"));
+      process.exit(1);
+    }
+    for (const table of SYSTEM_TABLES) {
+      console.log(pc3.green(`  \u2713 ${table}`));
+    }
+    console.log(pc3.green("\n  All system tables present. Remote database is initialized.\n"));
+    return;
+  }
+  if (existingTables === null) {
+    console.log(pc3.yellow("  Database unreachable or not yet created \u2014 applying base schema\u2026\n"));
+  } else if (missingTables.length === 0) {
+    console.log(pc3.green("  \u2713 All system tables present. Database already initialised.\n"));
+    printNextSteps(args.local);
+    return;
+  } else {
+    console.log(pc3.yellow(`  Missing system tables: ${missingTables.join(", ")}`));
+    console.log(pc3.cyan("\n  Applying base schema\u2026\n"));
+  }
+  const ok = executeD1File(BASE_SCHEMA_SQL, options);
+  if (!ok) {
+    console.log(pc3.red("\n  \u2717 Database initialisation failed\n"));
+    console.log(pc3.dim("  wrangler reported an error above."));
+    console.log(pc3.cyan("\n  \u2192 Run: npx beech init --db --local\n"));
+    process.exit(1);
+  }
+  console.log(pc3.green("\n  \u2713 worker.ts"));
+  console.log(pc3.green(`  \u2713 ${configPath ? basename(configPath) : "wrangler.jsonc"}`));
+  console.log(pc3.green("  \u2713 seeds.ts"));
+  console.log(pc3.green("  \u2713 Local D1 system tables ready\n"));
+  echoApiKeys(configPath);
+  printNextSteps(args.local);
+}
+
+// src/commands/seed-create.ts
+import pc4 from "picocolors";
+import { createInterface as createInterface2 } from "node:readline/promises";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+var BRANCH_TYPES = ["text", "number", "boolean", "date", "richtext", "file", "tags"];
+function slugify(str) {
+  return str.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function toConstName(slug) {
+  return slug.replace(/-/g, "_").toUpperCase() + "_SEED";
+}
+function toLabel(alias) {
+  return alias.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+}
+function generateSeedBlock(slug, label, labelPlural, branches) {
+  const displayAlias = branches.find((b) => b.type === "text")?.alias ?? branches[0]?.alias ?? "name";
+  const cName = toConstName(slug);
+  const branchLines = branches.map((b) => {
+    const parts = [
+      `alias: '${b.alias}'`,
+      `label: '${b.label}'`,
+      `type: '${b.type}'`
+    ];
+    if (b.required) parts.push("requiredOnCreate: true");
+    return `    { ${parts.join(", ")} },`;
+  });
+  return [
+    "",
+    `export const ${cName} = defineSeed({`,
+    `  slug: '${slug}',`,
+    `  label: '${label}',`,
+    `  labelPlural: '${labelPlural}',`,
+    `  displayNameAlias: '${displayAlias}',`,
+    "  branches: [",
+    ...branchLines,
+    "  ],",
+    "  dashboard: {",
+    "    icon: 'Folder',",
+    "    group: 'Content',",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function ensureDefineSeedImport(content) {
+  if (content.includes("defineSeed")) return content;
+  return `import { defineSeed } from '@beechcms/core'
+` + content;
+}
+function tryInsertRegistryEntry(content, slug, cName) {
+  const match = content.match(/(SEED_REGISTRY[^{]*\{)([\s\S]*?)(\n\})/m);
+  if (!match) return null;
+  const [full, open, inner, close] = match;
+  const newEntry = `
+  ${slug}: ${cName},`;
+  return content.replace(full, open + inner + newEntry + close);
+}
+function findSeedsFile() {
+  const cwd = process.cwd();
+  const searchDirs = [cwd, resolve3(cwd, "apps", "api")];
+  for (const dir of searchDirs) {
+    for (const name of ["seeds.ts", "seed.ts"]) {
+      const p = resolve3(dir, name);
+      if (existsSync3(p)) return p;
+    }
+  }
+  return null;
+}
+async function seedCreate(_args) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const ask = async (q, fallback = "") => {
+    const hint = fallback ? pc4.dim(` [${fallback}]`) : "";
+    const answer = await rl.question(`  ${q}${hint}: `);
+    return answer.trim() || fallback;
+  };
+  const askYN = async (q, defaultYes = true) => {
+    const hint = defaultYes ? pc4.dim(" (Y/n)") : pc4.dim(" (y/N)");
+    const answer = (await rl.question(`  ${q}${hint}: `)).trim().toLowerCase();
+    if (!answer) return defaultYes;
+    return answer === "y" || answer === "yes";
+  };
+  console.log(pc4.cyan("\n  beech seed:create \u2014 new content type wizard\n"));
+  try {
+    const label = await ask('Content type name (singular, e.g. "Article")');
+    if (!label) {
+      rl.close();
+      console.log(pc4.red("\n  \u2717 Name required.\n"));
+      process.exit(1);
+    }
+    const defaultSlug = slugify(label) + "s";
+    const slug = slugify(await ask("Slug (plural, used in URL + table name)", defaultSlug)) || defaultSlug;
+    const labelPlural = await ask("Plural label", label + "s") || label + "s";
+    const branches = [];
+    console.log(pc4.dim("\n  Now define the fields. Press Enter to accept defaults.\n"));
+    let addMore = true;
+    while (addMore) {
+      console.log(pc4.dim(`  \u2500\u2500\u2500 Field ${branches.length + 1} \u2500\u2500\u2500`));
+      const alias = await ask('  Alias (camelCase, e.g. "title", "publishedAt")');
+      if (!alias) {
+        console.log(pc4.yellow("  Alias required \u2014 skipping."));
+        addMore = await askYN("\n  Add a field?");
+        continue;
+      }
+      const fieldLabel = await ask("  Label", toLabel(alias)) || toLabel(alias);
+      const typeList = BRANCH_TYPES.join(" | ");
+      const rawType = (await ask(`  Type (${typeList})`, "text")).toLowerCase();
+      const type = BRANCH_TYPES.includes(rawType) ? rawType : "text";
+      const required = await askYN("  Required on create?", false);
+      branches.push({ alias, label: fieldLabel, type, required });
+      addMore = await askYN("\n  Add another field?");
+    }
+    rl.close();
+    if (branches.length === 0) {
+      console.log(pc4.yellow("\n  No fields defined \u2014 seed not created.\n"));
+      process.exit(0);
+    }
+    const seedBlock = generateSeedBlock(slug, label, labelPlural, branches);
+    const cName = toConstName(slug);
+    const seedsPath = findSeedsFile();
+    if (!seedsPath) {
+      console.log(pc4.yellow("\n  Could not find seeds.ts. Add this to your seeds file manually:\n"));
+      console.log(seedBlock);
+      process.exit(0);
+    }
+    let content = readFileSync3(seedsPath, "utf-8");
+    content = ensureDefineSeedImport(content);
+    const withSeed = content + seedBlock;
+    const withRegistry = tryInsertRegistryEntry(withSeed, slug, cName);
+    writeFileSync3(seedsPath, withRegistry ?? withSeed, "utf-8");
+    console.log(pc4.green(`
+  \u2713 Seed "${slug}" appended to ${seedsPath}
+`));
+    if (!withRegistry) {
+      console.log(pc4.yellow(`  \u26A0 Could not auto-update SEED_REGISTRY \u2014 add this entry manually:
+`));
+      console.log(pc4.cyan(`    ${slug}: ${cName},
+`));
+    }
+    console.log(pc4.dim("  Next steps:"));
+    console.log(pc4.cyan("  npx beech seed:load --local"));
+    console.log(pc4.dim("  \u2192 create the new content table in your local D1 database\n"));
+  } catch (err) {
+    rl.close();
+    throw err;
+  }
+}
+
+// src/commands/deploy.ts
+import pc5 from "picocolors";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { readFileSync as readFileSync4 } from "node:fs";
+function readWorkerName(configPath) {
+  if (!configPath) return null;
+  try {
+    const raw = readFileSync4(configPath, "utf-8");
+    const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(stripped);
+    return parsed?.name ?? null;
+  } catch {
+    return null;
+  }
+}
+function extractWorkerUrl(output) {
+  const match = output.match(/https:\/\/[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+\.workers\.dev\b/);
+  return match?.[0] ?? null;
+}
+async function checkAdmin(url) {
+  try {
+    const res = await fetch(`${url}/admin`, {
+      method: "HEAD",
+      redirect: "follow",
+      signal: AbortSignal.timeout(12e3)
+    });
+    return { ok: res.status < 500, status: res.status };
+  } catch {
+    return { ok: false, status: null };
+  }
+}
+async function deploy(args) {
+  console.log(pc5.cyan("\n  beech deploy\n"));
+  console.log(pc5.dim("  [1/3] Deploying Worker\u2026\n"));
+  const deployResult = spawnSync3("npm", ["run", "deploy"], {
+    stdio: ["inherit", "pipe", "inherit"],
+    encoding: "utf-8",
+    cwd: process.cwd(),
+    shell: true
+  });
+  const deployStdout = deployResult.stdout ?? "";
+  if (deployStdout) process.stdout.write(deployStdout);
+  if (deployResult.status !== 0) {
+    console.log(pc5.red("\n  \u2717 Worker deploy failed\n"));
+    console.log(pc5.dim("  Check the wrangler output above for details."));
+    console.log(pc5.cyan("\n  \u2192 Run:  npx wrangler login           # if not authenticated"));
+    console.log(pc5.cyan("  \u2192 Or:   Update wrangler.jsonc        # if database_id is wrong\n"));
+    process.exit(1);
+  }
+  const deployedUrl = extractWorkerUrl(deployStdout);
+  console.log(pc5.green("\n  \u2713 Worker deployed"));
+  if (args.skipSeed) {
+    console.log(pc5.dim("\n  [2/3] Skipping seed:load (--skip-seed)"));
+  } else {
+    console.log(pc5.dim("\n  [2/3] Syncing content schema to remote D1\u2026\n"));
+    const seedResult = spawnSync3("npx", ["beech", "seed:load"], {
+      stdio: "inherit",
+      cwd: process.cwd(),
+      shell: true
+    });
+    if (seedResult.status !== 0) {
+      console.log(pc5.yellow("\n  \u26A0 seed:load failed\n"));
+      console.log(pc5.dim("  Sync the remote content schema manually:"));
+      console.log(pc5.cyan("  \u2192 Run: npx beech seed:load\n"));
+    } else {
+      console.log(pc5.green("\n  \u2713 Content schema synced"));
+    }
+  }
+  if (args.skipCheck) {
+    console.log(pc5.dim("\n  [3/3] Skipping admin check (--skip-check)\n"));
+    return;
+  }
+  const adminBase = deployedUrl ?? (() => {
+    const workerName = readWorkerName(findWranglerConfig());
+    return workerName ? `https://${workerName}.workers.dev` : null;
+  })();
+  if (!adminBase) {
+    console.log(pc5.dim("\n  [3/3] Could not determine worker URL \u2014 skipping admin check\n"));
+    console.log(pc5.dim("  The deployed URL is printed by wrangler above. Open <url>/admin to verify.\n"));
+    return;
+  }
+  console.log(pc5.dim(`
+  [3/3] Checking ${adminBase}/admin\u2026
+`));
+  const { ok, status } = await checkAdmin(adminBase);
+  if (ok) {
+    console.log(pc5.green(`  \u2713 Admin reachable at: ${adminBase}/admin
+`));
+  } else {
+    const statusStr = status != null ? ` (HTTP ${status})` : "";
+    console.log(pc5.yellow(`  \u26A0 Admin returned an error${statusStr} at: ${adminBase}/admin
+`));
+    console.log(pc5.dim("  The database may not be fully initialized."));
+    console.log(pc5.cyan("  \u2192 Run: npx beech init --db --remote\n"));
+  }
+}
+
+// src/commands/update.ts
+import pc6 from "picocolors";
+import { spawnSync as spawnSync4 } from "node:child_process";
+async function update(_args) {
+  console.log(pc6.cyan("\n  beech update\n"));
+  console.log(pc6.dim("  [1/2] Installing latest BeechCMS packages\u2026\n"));
+  const installResult = spawnSync4(
+    "npm",
+    ["install", "@beechcms/api@latest", "@beechcms/core@latest"],
+    { stdio: "inherit", cwd: process.cwd(), shell: true }
+  );
+  if (installResult.status !== 0) {
+    console.log(pc6.red("\n  \u2717 npm install failed\n"));
+    console.log(pc6.dim("  Check the output above for details."));
+    console.log(pc6.dim("  You may need to resolve version conflicts manually."));
+    console.log(pc6.cyan("\n  \u2192 Try: npm install --legacy-peer-deps\n"));
+    process.exit(1);
+  }
+  console.log(pc6.green("\n  \u2713 Packages updated"));
+  console.log(pc6.dim("\n  [2/2] Applying system migrations to local database\u2026\n"));
+  const initResult = spawnSync4(
+    "npx",
+    ["beech", "init", "--db", "--local"],
+    { stdio: "inherit", cwd: process.cwd(), shell: true }
+  );
+  if (initResult.status !== 0) {
+    console.log(pc6.yellow("\n  \u26A0 Local DB update failed\n"));
+    console.log(pc6.dim("  Apply system migrations manually:"));
+    console.log(pc6.cyan("  \u2192 Run: npx beech init --db --local\n"));
+  } else {
+    console.log(pc6.green("\n  \u2713 Local database updated"));
+  }
+  console.log(pc6.dim("\n  Local update complete.\n"));
+  console.log(pc6.dim("  Next steps:"));
+  console.log(pc6.cyan("  1. npx beech seed:load --local"));
+  console.log(pc6.dim("      \u2192 sync content schema to local DB"));
+  console.log(pc6.cyan("  2. npm run deploy"));
+  console.log(pc6.dim("      \u2192 deploy updated API + dashboard"));
+  console.log(pc6.cyan("  3. npx beech seed:load"));
+  console.log(pc6.dim("      \u2192 sync remote schema\n"));
+}
 export {
-  seedLoad
+  deploy,
+  init,
+  seedCreate,
+  seedLoad,
+  update,
+  validate,
+  validateSeeds
 };