koguma 0.6.4 → 0.6.5

package/cli/index.ts

@@ -17,6 +17,13 @@ import { execSync } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { resolve, dirname, basename } from 'path';
 import { generateSchema } from '../src/db/schema.ts';
+import {
+  buildInsertSql,
+  wrapForShell,
+  buildAssetIndex,
+  processSeedEntry,
+  buildImportSql
+} from '../src/db/sql.ts';
 
 // ── Helpers ─────────────────────────────────────────────────────────
 
@@ -472,13 +479,9 @@ async function cmdBuild() {
 async function cmdSeed() {
   header('koguma seed');
   const root = findProjectRoot();
+  const seedTs = resolve(root, 'db/seed.ts');
   const seedSql = resolve(root, 'db/seed.sql');
 
-  if (!existsSync(seedSql)) {
-    fail('db/seed.sql not found. Generate it first with your seed script.');
-    process.exit(1);
-  }
-
   // Parse database name from wrangler.toml
   const toml = readFileSync(resolve(root, 'wrangler.toml'), 'utf-8');
   const dbNameMatch = toml.match(/database_name\s*=\s*"([^"]+)"/);
@@ -487,14 +490,94 @@ async function cmdSeed() {
   const isRemote = process.argv.includes('--remote');
   const target = isRemote ? '--remote' : '--local';
 
-  log(
-    `Seeding ${isRemote ? 'REMOTE' : 'local'} database: ${CYAN}${dbName}${RESET}`
-  );
-  run(`bunx wrangler d1 execute ${dbName} ${target} --file=${seedSql}`, {
-    cwd: root
-  });
+  if (existsSync(seedTs)) {
+    // ── seed.ts path — structured seeding with smart field resolution ──
+    log(`Using ${CYAN}db/seed.ts${RESET} (structured seed)`);
+    const seedModule = await import(seedTs);
+    const seedData = seedModule.default as Record<
+      string,
+      Record<string, unknown>[]
+    >;
+
+    // Import config for field metadata
+    const configPath = resolve(root, 'site.config.ts');
+    const configModule = await import(configPath);
+    const config = configModule.default as {
+      contentTypes: {
+        id: string;
+        fieldMeta: Record<string, { fieldType: string; required: boolean }>;
+      }[];
+    };
+    const ctMap = new Map(config.contentTypes.map(ct => [ct.id, ct]));
+
+    // Build asset title→id lookup
+    log('Loading asset index...');
+    let assetIndex = buildAssetIndex([]);
+    try {
+      const output = runCapture(
+        `bunx wrangler d1 execute ${dbName} ${target} --command "SELECT id, title FROM _assets" --json`,
+        root
+      );
+      const parsed = JSON.parse(output);
+      const assets = parsed?.[0]?.results ?? [];
+      assetIndex = buildAssetIndex(assets);
+      ok(`Loaded ${assetIndex.titleMap.size} asset mappings`);
+    } catch {
+      warn('No _assets table found — image title resolution disabled');
+    }
+
+    // Lazy-load markdown converter
+    const { markdownToKoguma } =
+      await import('../src/rich-text/markdown-to-koguma.ts');
+
+    let totalEntries = 0;
+
+    for (const [typeId, entries] of Object.entries(seedData)) {
+      const ct = ctMap.get(typeId);
+      if (!ct) {
+        warn(`Content type '${typeId}' not found in site.config.ts — skipping`);
+        continue;
+      }
+
+      log(`Seeding ${CYAN}${typeId}${RESET} (${entries.length} entries)...`);
 
-  ok(`Database seeded (${isRemote ? 'remote' : 'local'})!`);
+      for (const entry of entries) {
+        const { processed, resolutions } = processSeedEntry(
+          entry,
+          ct.fieldMeta,
+          assetIndex,
+          markdownToKoguma
+        );
+
+        for (const r of resolutions) {
+          ok(`  ${r}`);
+        }
+
+        const sql = buildInsertSql(typeId, processed);
+        run(
+          `bunx wrangler d1 execute ${dbName} ${target} --command "${wrapForShell(sql)}"`,
+          { cwd: root, silent: true }
+        );
+        totalEntries++;
+      }
+    }
+
+    ok(`Seeded ${totalEntries} entries (${isRemote ? 'remote' : 'local'})!`);
+  } else if (existsSync(seedSql)) {
+    // ── seed.sql path — legacy SQL seeding ──
+    log(
+      `Seeding ${isRemote ? 'REMOTE' : 'local'} database: ${CYAN}${dbName}${RESET}`
+    );
+    run(`bunx wrangler d1 execute ${dbName} ${target} --file=${seedSql}`, {
+      cwd: root
+    });
+    ok(`Database seeded (${isRemote ? 'remote' : 'local'})!`);
+  } else {
+    fail(
+      'No seed file found. Create db/seed.ts (structured) or db/seed.sql (raw SQL).'
+    );
+    process.exit(1);
+  }
 }
 
 async function cmdDeploy() {
@@ -672,9 +755,9 @@ function fieldTypeToTs(
     case 'date':
       return 'string';
     case 'richText':
-      return 'Record<string, unknown>';
+      return 'KogumaDocument';
     case 'image':
-      return '{ id: string; url: string; title?: string; width?: number; height?: number }';
+      return 'KogumaAsset';
     case 'boolean':
       return 'boolean';
     case 'number':
@@ -689,6 +772,14 @@ function fieldTypeToTs(
       return meta.refContentType
         ? `${capitalize(meta.refContentType)}Entry[]`
         : 'Record<string, unknown>[]';
+    case 'youtube':
+    case 'instagram':
+    case 'email':
+    case 'phone':
+    case 'color':
+      return 'string';
+    case 'images':
+      return 'string[]';
     default:
       return 'unknown';
   }
@@ -739,6 +830,8 @@ async function cmdTypegen() {
     ' * Do not edit manually.',
     ' */',
     '',
+    'import type { KogumaDocument, KogumaAsset } from "koguma/types";',
+    '',
     '// ── System fields ── common to all entries',
     'interface KogumaSystemFields {',
     '  id: string;',
@@ -856,7 +949,8 @@ async function cmdMigrate() {
       const results = parsed?.[0]?.results ?? [];
       existingColumns[ct.id] = results;
     } catch {
-      warn(`Table '${ct.id}' does not exist yet.`);
+      warn(`Table '${ct.id}' does not exist yet — will create it.`);
+      existingColumns[ct.id] = [];
     }
   }
 
@@ -1119,16 +1213,9 @@ async function cmdImport() {
     );
 
     for (const entry of data.entries) {
-      const cols = Object.keys(entry);
-      const vals = Object.values(entry).map(v => {
-        if (v === null) return 'NULL';
-        if (typeof v === 'number') return String(v);
-        return `'${String(v).replace(/'/g, "''")}'`;
-      });
-
-      const sql = `INSERT OR REPLACE INTO ${typeId} (${cols.join(', ')}) VALUES (${vals.join(', ')})`;
+      const sql = buildInsertSql(typeId, entry);
       run(
-        `bunx wrangler d1 execute ${dbName} ${target} --command "${sql.replace(/"/g, '\\"')}"`,
+        `bunx wrangler d1 execute ${dbName} ${target} --command "${wrapForShell(sql)}"`,
         { cwd: root, silent: true }
       );
       totalEntries++;
@@ -1137,16 +1224,9 @@ async function cmdImport() {
     // Import join tables
     for (const [jtName, rows] of Object.entries(data.joinTables)) {
       for (const row of rows) {
-        const cols = Object.keys(row);
-        const vals = Object.values(row).map(v => {
-          if (v === null) return 'NULL';
-          if (typeof v === 'number') return String(v);
-          return `'${String(v).replace(/'/g, "''")}'`;
-        });
-
-        const sql = `INSERT OR REPLACE INTO ${jtName} (${cols.join(', ')}) VALUES (${vals.join(', ')})`;
+        const sql = buildInsertSql(jtName, row);
         run(
-          `bunx wrangler d1 execute ${dbName} ${target} --command "${sql.replace(/"/g, '\\"')}"`,
+          `bunx wrangler d1 execute ${dbName} ${target} --command "${wrapForShell(sql)}"`,
           { cwd: root, silent: true }
         );
       }
@@ -1158,37 +1238,469 @@ async function cmdImport() {
   );
 }
 
+// ── Shared auth helper ──────────────────────────────────────────────
+
+async function authenticate(targetUrl: string, root: string): Promise<string> {
+  const devVarsPath = resolve(root, '.dev.vars');
+  let password = '';
+  if (existsSync(devVarsPath)) {
+    const content = readFileSync(devVarsPath, 'utf-8');
+    const match = content.match(/KOGUMA_SECRET=(.+)/);
+    if (match?.[1]) password = match[1].trim();
+  }
+  if (!password) {
+    fail('KOGUMA_SECRET not found in .dev.vars');
+    process.exit(1);
+  }
+
+  const loginRes = await fetch(`${targetUrl}/api/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ password }),
+    redirect: 'manual'
+  });
+  const setCookie = loginRes.headers.get('set-cookie') ?? '';
+  const cookieMatch = setCookie.match(/koguma_session=[^;]+/);
+  if (!cookieMatch) {
+    fail('Login failed — check your KOGUMA_SECRET');
+    process.exit(1);
+  }
+  return cookieMatch[0];
+}
+
+function getRemoteUrl(): string {
+  const idx = process.argv.indexOf('--remote');
+  const url = idx >= 0 ? process.argv[idx + 1] : undefined;
+  if (!url || url.startsWith('-')) {
+    fail('Usage: koguma <command> --remote https://your-site.workers.dev');
+    process.exit(1);
+  }
+  return url.replace(/\/$/, '');
+}
+
+function getDbName(root: string): string {
+  const toml = readFileSync(resolve(root, 'wrangler.toml'), 'utf-8');
+  const match = toml.match(/database_name\s*=\s*"([^"]+)"/);
+  return match?.[1] ?? 'my-db';
+}
+
+// ── Pull ────────────────────────────────────────────────────────────
+
+async function cmdPull() {
+  header('koguma pull');
+  const root = findProjectRoot();
+  const remoteUrl = getRemoteUrl();
+  const dbName = getDbName(root);
+
+  // 1. Migrate local schema
+  log('Step 1: Migrating local schema...');
+  // Re-use migrate logic inline (avoid process.argv mutation)
+  const configPath = resolve(root, 'site.config.ts');
+  const configModule = await import(configPath);
+  const config = configModule.default as {
+    contentTypes: {
+      id: string;
+      name: string;
+      fieldMeta: Record<
+        string,
+        { fieldType: string; required: boolean; refContentType?: string }
+      >;
+    }[];
+  };
+
+  // 2. Export remote content
+  log('\nStep 2: Exporting remote content...');
+  const exportData: Record<
+    string,
+    { entries: unknown[]; joinTables: Record<string, unknown[]> }
+  > = {};
+
+  for (const ct of config.contentTypes) {
+    try {
+      const output = runCapture(
+        `bunx wrangler d1 execute ${dbName} --remote --command "SELECT * FROM ${ct.id}" --json`,
+        root
+      );
+      const parsed = JSON.parse(output);
+      const entries = parsed?.[0]?.results ?? [];
+
+      const joinTables: Record<string, unknown[]> = {};
+      for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
+        if (meta.fieldType === 'references') {
+          const joinTable = `${ct.id}__${fieldId}`;
+          try {
+            const jtOutput = runCapture(
+              `bunx wrangler d1 execute ${dbName} --remote --command "SELECT * FROM ${joinTable}" --json`,
+              root
+            );
+            const jtParsed = JSON.parse(jtOutput);
+            joinTables[joinTable] = jtParsed?.[0]?.results ?? [];
+          } catch {
+            // Join table may not exist
+          }
+        }
+      }
+
+      exportData[ct.id] = { entries, joinTables };
+      ok(`${ct.id}: ${entries.length} entries`);
+    } catch {
+      warn(`Could not export ${ct.id} from remote`);
+    }
+  }
+
+  // Also export _assets
+  let remoteAssets: Record<string, unknown>[] = [];
+  try {
+    const output = runCapture(
+      `bunx wrangler d1 execute ${dbName} --remote --command "SELECT * FROM _assets" --json`,
+      root
+    );
+    const parsed = JSON.parse(output);
+    remoteAssets = parsed?.[0]?.results ?? [];
+    ok(`_assets: ${remoteAssets.length} assets`);
+  } catch {
+    warn('Could not export _assets from remote');
+  }
+
+  // 3. Import content into local
+  log('\nStep 3: Importing content to local...');
+
+  // Import _assets first
+  for (const asset of remoteAssets) {
+    const sql = buildInsertSql('_assets', asset);
+    run(
+      `bunx wrangler d1 execute ${dbName} --local --command "${wrapForShell(sql)}"`,
+      { cwd: root, silent: true }
+    );
+  }
+
+  // Import content types
+  for (const [typeId, data] of Object.entries(exportData)) {
+    for (const entry of data.entries as Record<string, unknown>[]) {
+      const sql = buildInsertSql(typeId, entry);
+      run(
+        `bunx wrangler d1 execute ${dbName} --local --command "${wrapForShell(sql)}"`,
+        { cwd: root, silent: true }
+      );
+    }
+    for (const [jtName, rows] of Object.entries(data.joinTables)) {
+      for (const row of rows as Record<string, unknown>[]) {
+        const sql = buildInsertSql(jtName, row);
+        run(
+          `bunx wrangler d1 execute ${dbName} --local --command "${wrapForShell(sql)}"`,
+          { cwd: root, silent: true }
+        );
+      }
+    }
+  }
+
+  // 4. Download R2 media
+  log('\nStep 4: Downloading remote media...');
+  const cookie = await authenticate(remoteUrl, root);
+
+  const mediaRes = await fetch(`${remoteUrl}/api/admin/media`, {
+    headers: { Cookie: cookie }
+  });
+  if (!mediaRes.ok) {
+    warn('Could not list remote media');
+  } else {
+    const { assets } = (await mediaRes.json()) as {
+      assets: { id: string; url: string; title: string }[];
+    };
+    log(`Found ${assets.length} remote assets`);
+
+    const bucketMatch = readFileSync(
+      resolve(root, 'wrangler.toml'),
+      'utf-8'
+    ).match(/bucket_name\s*=\s*"([^"]+)"/);
+    const bucketName = bucketMatch?.[1] ?? 'media';
+
+    for (const asset of assets) {
+      const key = asset.url.replace('/api/media/', '');
+      log(`⬇ ${asset.title}`);
+      try {
+        const dlRes = await fetch(`${remoteUrl}${asset.url}`);
+        if (!dlRes.ok) {
+          warn(`  Download failed: ${dlRes.status}`);
+          continue;
+        }
+        const buf = Buffer.from(await dlRes.arrayBuffer());
+        const tmpPath = resolve(root, `db/.media-tmp-${key}`);
+        writeFileSync(tmpPath, buf);
+        run(
+          `bunx wrangler r2 object put ${bucketName}/${key} --file=${tmpPath} --local`,
+          { cwd: root, silent: true }
+        );
+        // Clean up temp file
+        try {
+          const { unlinkSync } = await import('fs');
+          unlinkSync(tmpPath);
+        } catch {
+          /* ignore */
+        }
+        ok(`  → local R2`);
+      } catch (e) {
+        warn(`  Error: ${e}`);
+      }
+    }
+  }
+
+  ok('Pull complete! Local now mirrors remote.');
+}
+
+// ── Push ────────────────────────────────────────────────────────────
+
+async function cmdPush() {
+  header('koguma push');
+  const root = findProjectRoot();
+  const remoteUrl = getRemoteUrl();
+  const dbName = getDbName(root);
+
+  // 1. Migrate remote schema
+  log('Step 1: Migrating remote schema...');
+  const configPath = resolve(root, 'site.config.ts');
+  const configModule = await import(configPath);
+  const config = configModule.default as {
+    contentTypes: {
+      id: string;
+      name: string;
+      fieldMeta: Record<
+        string,
+        { fieldType: string; required: boolean; refContentType?: string }
+      >;
+    }[];
+  };
+
+  // Run migrate --remote
+  const existingColumns: Record<string, { name: string; type: string }[]> = {};
+  for (const ct of config.contentTypes) {
+    try {
+      const output = runCapture(
+        `bunx wrangler d1 execute ${dbName} --remote --command "SELECT name, type FROM pragma_table_info('${ct.id}')" --json`,
+        root
+      );
+      const parsed = JSON.parse(output);
+      existingColumns[ct.id] = parsed?.[0]?.results ?? [];
+    } catch {
+      warn(`Table '${ct.id}' does not exist on remote — will create it.`);
+      existingColumns[ct.id] = [];
+    }
+  }
+
+  const { detectDrift } = await import('../src/db/migrate.ts');
+  const driftResult = detectDrift(config.contentTypes as any, existingColumns);
+
+  if (driftResult.sql.length > 0) {
+    const sqlFile = resolve(root, 'db/migration.sql');
+    writeFileSync(sqlFile, driftResult.sql.join('\n'));
+    run(`bunx wrangler d1 execute ${dbName} --remote --file=${sqlFile}`, {
+      cwd: root
+    });
+    ok('Remote schema migrated');
+  } else {
+    ok('Remote schema is up to date');
+  }
+
+  // 2. Export local content
+  log('\nStep 2: Exporting local content...');
+  const exportData: Record<
+    string,
+    { entries: unknown[]; joinTables: Record<string, unknown[]> }
+  > = {};
+
+  for (const ct of config.contentTypes) {
+    try {
+      const output = runCapture(
+        `bunx wrangler d1 execute ${dbName} --local --command "SELECT * FROM ${ct.id}" --json`,
+        root
+      );
+      const parsed = JSON.parse(output);
+      const entries = parsed?.[0]?.results ?? [];
+
+      const joinTables: Record<string, unknown[]> = {};
+      for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
+        if (meta.fieldType === 'references') {
+          const joinTable = `${ct.id}__${fieldId}`;
+          try {
+            const jtOutput = runCapture(
+              `bunx wrangler d1 execute ${dbName} --local --command "SELECT * FROM ${joinTable}" --json`,
+              root
+            );
+            const jtParsed = JSON.parse(jtOutput);
+            joinTables[joinTable] = jtParsed?.[0]?.results ?? [];
+          } catch {
+            /* */
+          }
+        }
+      }
+
+      exportData[ct.id] = { entries, joinTables };
+      ok(`${ct.id}: ${entries.length} entries`);
+    } catch {
+      warn(`Could not export ${ct.id} from local`);
+    }
+  }
+
+  // Also export _assets
+  let localAssets: Record<string, unknown>[] = [];
+  try {
+    const output = runCapture(
+      `bunx wrangler d1 execute ${dbName} --local --command "SELECT * FROM _assets" --json`,
+      root
+    );
+    const parsed = JSON.parse(output);
+    localAssets = parsed?.[0]?.results ?? [];
+    ok(`_assets: ${localAssets.length} assets`);
+  } catch {
+    warn('Could not export _assets from local');
+  }
+
+  // 3. Import content to remote
+  log('\nStep 3: Importing content to remote...');
+
+  // Import _assets first
+  for (const asset of localAssets) {
+    const sql = buildInsertSql('_assets', asset);
+    run(
+      `bunx wrangler d1 execute ${dbName} --remote --command "${wrapForShell(sql)}"`,
+      { cwd: root, silent: true }
+    );
+  }
+
+  // Import content types
+  for (const [typeId, data] of Object.entries(exportData)) {
+    for (const entry of data.entries as Record<string, unknown>[]) {
+      const sql = buildInsertSql(typeId, entry);
+      run(
+        `bunx wrangler d1 execute ${dbName} --remote --command "${wrapForShell(sql)}"`,
+        { cwd: root, silent: true }
+      );
+    }
+    for (const [jtName, rows] of Object.entries(data.joinTables)) {
+      for (const row of rows as Record<string, unknown>[]) {
+        const sql = buildInsertSql(jtName, row);
+        run(
+          `bunx wrangler d1 execute ${dbName} --remote --command "${wrapForShell(sql)}"`,
+          { cwd: root, silent: true }
+        );
+      }
+    }
+  }
+
+  // 4. Upload local media to remote
+  log('\nStep 4: Uploading local media to remote...');
+  const cookie = await authenticate(remoteUrl, root);
+
+  for (const asset of localAssets as {
+    id: string;
+    url: string;
+    title: string;
+    content_type: string;
+  }[]) {
+    const key = (asset.url as string).replace('/api/media/', '');
+    log(`⬆ ${asset.title}`);
+    try {
+      // Download from local wrangler dev
+      const dlRes = await fetch(`http://localhost:8787${asset.url}`);
+      if (!dlRes.ok) {
+        warn(`  Local download failed: ${dlRes.status}`);
+        continue;
+      }
+
+      const blob = await dlRes.blob();
+      const fileName = key;
+      const formData = new FormData();
+      formData.append(
+        'file',
+        new File([blob], fileName, {
+          type: asset.content_type ?? 'application/octet-stream'
+        })
+      );
+      formData.append('title', asset.title ?? fileName);
+
+      const upRes = await fetch(`${remoteUrl}/api/admin/media`, {
+        method: 'POST',
+        headers: { Cookie: cookie },
+        body: formData
+      });
+
+      if (!upRes.ok) {
+        warn(`  Upload failed: ${await upRes.text()}`);
+        continue;
+      }
+      ok(`  → remote R2`);
+    } catch (e) {
+      warn(`  Error: ${e}`);
+    }
+  }
+
+  // 5. Deploy
+  log('\nStep 5: Deploying...');
+  await cmdDeploy();
+
+  ok('Push complete! Remote now mirrors local.');
+}
+
+// ── Wrangler wrappers ───────────────────────────────────────────────
+
+function cmdDev() {
+  const root = findProjectRoot();
+  const extra = process.argv.slice(3).join(' ');
+  run(`bunx wrangler dev ${extra}`.trim(), { cwd: root });
+}
+
+function cmdLogin() {
+  run('bunx wrangler login');
+}
+
+function cmdTail() {
+  const root = findProjectRoot();
+  const extra = process.argv.slice(3).join(' ');
+  run(`bunx wrangler tail ${extra}`.trim(), { cwd: root });
+}
+
+// ── Help ────────────────────────────────────────────────────────────
+
 function cmdHelp() {
   console.log(`
-${BOLD}🐻 Koguma CLI${RESET} ${DIM}v0.5.0${RESET}
+${BOLD}🐻 Koguma CLI${RESET} ${DIM}v0.6.0${RESET}
 
 ${BOLD}Usage:${RESET} koguma <command>
 
-${BOLD}Commands:${RESET}
-  ${CYAN}init${RESET}            Create D1 database and R2 bucket, patch wrangler.toml
-  ${CYAN}secret${RESET}          Set the admin password on Cloudflare
-  ${CYAN}build${RESET}           Build the admin dashboard bundle
-  ${CYAN}seed${RESET}            Seed the database from db/seed.sql
-  ${CYAN}schema${RESET}          Generate correct DDL from site.config.ts → db/schema.sql
+${BOLD}Development:${RESET}
+  ${CYAN}dev${RESET}             Start local dev server (wrangler dev)
+  ${CYAN}login${RESET}           Authenticate with Cloudflare
+  ${CYAN}tail${RESET}            Stream live logs from production
+
+${BOLD}Schema & Types:${RESET}
+  ${CYAN}schema${RESET}          Generate DDL from site.config.ts → db/schema.sql
   ${CYAN}typegen${RESET}         Generate koguma.d.ts typed interfaces
-  ${CYAN}migrate${RESET}         Detect schema drift and apply ALTER TABLE changes
+  ${CYAN}migrate${RESET}         Detect schema drift, apply CREATE/ALTER TABLE
+
+${BOLD}Content:${RESET}
+  ${CYAN}seed${RESET}            Seed database from db/seed.ts or db/seed.sql
   ${CYAN}export${RESET}          Export all content to JSON
   ${CYAN}import${RESET}          Import content from JSON file
-  ${CYAN}migrate-media${RESET}   Download images and upload to R2
+
+${BOLD}Media:${RESET}
+  ${CYAN}migrate-media${RESET}   Download external images and upload to R2
+
+${BOLD}Sync:${RESET}
+  ${CYAN}pull${RESET}            Download remote content + media → local
+  ${CYAN}push${RESET}            Upload local content + media → remote + deploy
+
+${BOLD}Deploy:${RESET}
+  ${CYAN}init${RESET}            Create D1 database and R2 bucket, patch wrangler.toml
+  ${CYAN}secret${RESET}          Set the admin password on Cloudflare
+  ${CYAN}build${RESET}           Build the admin dashboard bundle
   ${CYAN}deploy${RESET}          Build admin + frontend, then deploy via wrangler
 
-${BOLD}Options:${RESET}
-  ${DIM}koguma seed --remote${RESET}                           Seed the production database
-  ${DIM}koguma migrate --remote${RESET}                        Migrate the production database
-  ${DIM}koguma export --remote${RESET}                         Export from production
-  ${DIM}koguma import data.json --remote${RESET}               Import to production
-  ${DIM}koguma migrate-media --remote https://...${RESET}      Migrate to production R2
-
-${BOLD}First deploy:${RESET}
-  ${DIM}$${RESET} koguma init                       ${DIM}# Create D1 + R2${RESET}
-  ${DIM}$${RESET} koguma secret                     ${DIM}# Set admin password${RESET}
-  ${DIM}$${RESET} koguma seed --remote              ${DIM}# Seed production DB${RESET}
-  ${DIM}$${RESET} koguma deploy                     ${DIM}# Build + deploy${RESET}
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} koguma dev                                    ${DIM}# Local dev server${RESET}
+  ${DIM}$${RESET} koguma migrate --remote                       ${DIM}# Migrate production DB${RESET}
+  ${DIM}$${RESET} koguma pull --remote https://my-site.dev       ${DIM}# Sync remote → local${RESET}
+  ${DIM}$${RESET} koguma push --remote https://my-site.dev       ${DIM}# Sync local → remote${RESET}
+  ${DIM}$${RESET} koguma seed --remote                           ${DIM}# Seed production DB${RESET}
 `);
 }
 
@@ -1230,6 +1742,21 @@ switch (command) {
   case 'deploy':
     await cmdDeploy();
     break;
+  case 'pull':
+    await cmdPull();
+    break;
+  case 'push':
+    await cmdPush();
+    break;
+  case 'dev':
+    cmdDev();
+    break;
+  case 'login':
+    cmdLogin();
+    break;
+  case 'tail':
+    cmdTail();
+    break;
   case 'help':
   case '--help':
   case '-h':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koguma",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "🐻 A little CMS with big heart — schema-driven, runs on Cloudflare's free tier",
   "type": "module",
   "license": "MIT",

package/src/config/define.ts

@@ -82,7 +82,7 @@ export function contentType<
   displayField: string;
   singleton?: boolean;
   fields: F;
-}): ContentTypeConfig {
+}) {
   // Collect all field builders (from groups or flat)
   const allFields: Record<string, FieldBuilder> = {};
   const groups: GroupConfig[] = [];
@@ -116,11 +116,11 @@ export function contentType<
     name: opts.name,
     displayField: opts.displayField,
     singleton: opts.singleton,
-    schema: schema as z.ZodType,
+    schema,
     fieldMeta,
     groups,
     flatFields
-  };
+  } satisfies ContentTypeConfig;
 }
 
 // ── defineConfig ─────────────────────────────────────────────────────

package/src/db/migrate.ts

@@ -48,7 +48,13 @@ function sqlType(fieldType: string): string {
     case 'longText':
     case 'richText':
     case 'url':
+    case 'email':
+    case 'phone':
+    case 'color':
+    case 'youtube':
+    case 'instagram':
     case 'image':
+    case 'images':
     case 'reference':
     case 'date':
     case 'select':
@@ -76,7 +82,7 @@ export function detectDrift(
 
   for (const ct of contentTypes) {
     const tableCols = existingColumns[ct.id];
-    if (!tableCols) {
+    if (!tableCols || tableCols.length === 0) {
       // Table doesn't exist — generate CREATE TABLE
       const columns: string[] = [
         'id TEXT PRIMARY KEY',

package/src/db/sql.ts

@@ -0,0 +1,166 @@
+/**
+ * sql.ts — Pure SQL generation utilities for D1 operations.
+ *
+ * These functions are used by seed, import, push, pull, and export commands.
+ * Extracted here to enable thorough unit testing without wrangler dependencies.
+ */
+
+// ── Value escaping ──────────────────────────────────────────────────
+
+/**
+ * Escape a JavaScript value for safe embedding in a SQL string.
+ * Returns a SQL-safe string (already quoted if needed).
+ */
+export function escapeValue(v: unknown): string {
+  if (v === null || v === undefined) return 'NULL';
+  if (typeof v === 'number') return String(v);
+  if (typeof v === 'boolean') return v ? '1' : '0';
+  return `'${String(v).replace(/'/g, "''")}'`;
+}
+
+// ── INSERT OR REPLACE generation ────────────────────────────────────
+
+/**
+ * Generate an INSERT OR REPLACE statement from a table name and row data.
+ */
+export function buildInsertSql(
+  table: string,
+  row: Record<string, unknown>
+): string {
+  const cols = Object.keys(row);
+  const vals = Object.values(row).map(escapeValue);
+  return `INSERT OR REPLACE INTO ${table} (${cols.join(', ')}) VALUES (${vals.join(', ')})`;
+}
+
+// ── Shell-safe SQL escaping ─────────────────────────────────────────
+
+/**
+ * Wrap a SQL statement for safe use in `wrangler d1 execute --command "..."`.
+ * Escapes inner double quotes.
+ */
+export function wrapForShell(sql: string): string {
+  return sql.replace(/"/g, '\\"');
+}
+
+// ── Asset title resolution ──────────────────────────────────────────
+
+export interface AssetIndex {
+  /** Map of lowercase title → asset ID */
+  titleMap: Map<string, string>;
+}
+
+/**
+ * Build an asset index from raw _assets rows.
+ * Maps both full title and title-without-extension to asset IDs.
+ */
+export function buildAssetIndex(
+  assets: { id: string; title: string }[]
+): AssetIndex {
+  const titleMap = new Map<string, string>();
+  for (const a of assets) {
+    titleMap.set(a.title.toLowerCase(), a.id);
+    const noExt = a.title.replace(/\.\w+$/, '').toLowerCase();
+    if (noExt !== a.title.toLowerCase()) titleMap.set(noExt, a.id);
+  }
+  return { titleMap };
+}
+
+/**
+ * Resolve a human-friendly asset reference (title or filename) to an asset ID.
+ * Returns the original value if not found.
+ */
+export function resolveAssetRef(
+  value: string,
+  index: AssetIndex
+): { id: string; resolved: boolean } {
+  const lower = value.toLowerCase();
+  const id = index.titleMap.get(lower);
+  if (id) return { id, resolved: true };
+  const noExt = value.replace(/\.\w+$/, '').toLowerCase();
+  const id2 = index.titleMap.get(noExt);
+  if (id2) return { id: id2, resolved: true };
+  return { id: value, resolved: false };
+}
+
+// ── Seed entry processing ───────────────────────────────────────────
+
+export interface FieldMeta {
+  fieldType: string;
+  required: boolean;
+}
+
+/**
+ * Process a seed entry by resolving image references and converting
+ * markdown strings in richText fields to KogumaDocument JSON.
+ *
+ * Returns a new processed entry (does not mutate the input).
+ */
+export function processSeedEntry(
+  entry: Record<string, unknown>,
+  fieldMeta: Record<string, FieldMeta>,
+  assetIndex: AssetIndex,
+  markdownToKoguma: (md: string) => { nodes: unknown[] }
+): { processed: Record<string, unknown>; resolutions: string[] } {
+  const processed: Record<string, unknown> = {
+    id: (entry.id as string) ?? crypto.randomUUID(),
+    status: (entry.status as string) ?? 'published',
+    ...entry
+  };
+
+  const resolutions: string[] = [];
+
+  for (const [fieldId, meta] of Object.entries(fieldMeta)) {
+    const value = processed[fieldId];
+    if (value === undefined || value === null) continue;
+
+    if (meta.fieldType === 'image' && typeof value === 'string') {
+      const result = resolveAssetRef(value, assetIndex);
+      if (result.resolved) {
+        processed[fieldId] = result.id;
+        resolutions.push(`${fieldId}: "${value}" → ${result.id}`);
+      }
+    } else if (meta.fieldType === 'richText' && typeof value === 'string') {
+      const doc = markdownToKoguma(value);
+      processed[fieldId] = JSON.stringify(doc);
+      resolutions.push(`${fieldId}: markdown → KogumaDocument`);
+    } else if (meta.fieldType === 'images' && Array.isArray(value)) {
+      const ids = value.map((v: unknown) => {
+        if (typeof v !== 'string') return v;
+        const result = resolveAssetRef(v, assetIndex);
+        if (result.resolved) {
+          resolutions.push(`${fieldId}: "${v}" → ${result.id}`);
+          return result.id;
+        }
+        return v;
+      });
+      processed[fieldId] = JSON.stringify(ids);
+    }
+  }
+
+  return { processed, resolutions };
+}
+
+// ── Batch SQL generation ────────────────────────────────────────────
+
+/**
+ * Generate all INSERT OR REPLACE statements for importing a set of entries
+ * into a table, including join table rows.
+ */
+export function buildImportSql(
+  typeId: string,
+  entries: Record<string, unknown>[],
+  joinTables?: Record<string, Record<string, unknown>[]>
+): string[] {
+  const statements: string[] = [];
+  for (const entry of entries) {
+    statements.push(buildInsertSql(typeId, entry));
+  }
+  if (joinTables) {
+    for (const [jtName, rows] of Object.entries(joinTables)) {
+      for (const row of rows) {
+        statements.push(buildInsertSql(jtName, row));
+      }
+    }
+  }
+  return statements;
+}

package/src/rich-text/markdown-to-koguma.ts

@@ -0,0 +1,164 @@
+/**
+ * markdown-to-koguma.ts — Lightweight markdown → KogumaDocument converter.
+ *
+ * Designed for seed content (author-controlled markdown), not arbitrary user input.
+ * Supports: headings, paragraphs, bold, italic, code, links, lists, code blocks, HR.
+ */
+import type {
+  KogumaDocument,
+  KogumaBlockNode,
+  KogumaInlineNode,
+  KogumaListItem
+} from '../config/types.ts';
+
+// ── Inline parsing ──────────────────────────────────────────────────
+
+function parseInline(text: string): KogumaInlineNode[] {
+  const nodes: KogumaInlineNode[] = [];
+  // Regex: links, bold, italic, inline code
+  const re =
+    /\[([^\]]+)\]\(([^)]+)\)|`([^`]+)`|\*\*(.+?)\*\*|\*(.+?)\*|([^[`*]+)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = re.exec(text)) !== null) {
+    if (match[1] !== undefined && match[2] !== undefined) {
+      // Link
+      nodes.push({
+        type: 'link',
+        url: match[2],
+        children: [{ type: 'text', text: match[1] }]
+      });
+    } else if (match[3] !== undefined) {
+      // Inline code
+      nodes.push({ type: 'text', text: match[3], code: true });
+    } else if (match[4] !== undefined) {
+      // Bold
+      nodes.push({ type: 'text', text: match[4], bold: true });
+    } else if (match[5] !== undefined) {
+      // Italic
+      nodes.push({ type: 'text', text: match[5], italic: true });
+    } else if (match[6] !== undefined && match[6].length > 0) {
+      // Plain text
+      nodes.push({ type: 'text', text: match[6] });
+    }
+  }
+
+  return nodes.length > 0 ? nodes : [{ type: 'text', text }];
+}
+
+// ── Block parsing ───────────────────────────────────────────────────
+
+export function markdownToKoguma(markdown: string): KogumaDocument {
+  const lines = markdown.split('\n');
+  const nodes: KogumaBlockNode[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i]!;
+
+    // Blank line — skip
+    if (line.trim() === '') {
+      i++;
+      continue;
+    }
+
+    // Fenced code block
+    const codeMatch = line.match(/^```(\w*)$/);
+    if (codeMatch) {
+      const language = codeMatch[1] || undefined;
+      const codeLines: string[] = [];
+      i++;
+      while (i < lines.length && !lines[i]!.startsWith('```')) {
+        codeLines.push(lines[i]!);
+        i++;
+      }
+      i++; // skip closing ```
+      nodes.push({ type: 'code', language, text: codeLines.join('\n') });
+      continue;
+    }
+
+    // Heading
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1]!.length as 1 | 2 | 3 | 4 | 5 | 6;
+      nodes.push({
+        type: 'heading',
+        level,
+        children: parseInline(headingMatch[2]!)
+      });
+      i++;
+      continue;
+    }
+
+    // Horizontal rule
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(line.trim())) {
+      nodes.push({ type: 'hr' });
+      i++;
+      continue;
+    }
+
+    // Unordered list
+    if (/^[-*+]\s/.test(line)) {
+      const items: KogumaListItem[] = [];
+      while (i < lines.length && /^[-*+]\s/.test(lines[i]!)) {
+        items.push({
+          children: parseInline(lines[i]!.replace(/^[-*+]\s/, ''))
+        });
+        i++;
+      }
+      nodes.push({ type: 'list', ordered: false, items });
+      continue;
+    }
+
+    // Ordered list
+    if (/^\d+\.\s/.test(line)) {
+      const items: KogumaListItem[] = [];
+      while (i < lines.length && /^\d+\.\s/.test(lines[i]!)) {
+        items.push({
+          children: parseInline(lines[i]!.replace(/^\d+\.\s/, ''))
+        });
+        i++;
+      }
+      nodes.push({ type: 'list', ordered: true, items });
+      continue;
+    }
+
+    // Blockquote
+    if (line.startsWith('> ')) {
+      const quoteLines: string[] = [];
+      while (i < lines.length && lines[i]!.startsWith('> ')) {
+        quoteLines.push(lines[i]!.slice(2));
+        i++;
+      }
+      nodes.push({
+        type: 'quote',
+        children: parseInline(quoteLines.join(' '))
+      });
+      continue;
+    }
+
+    // Paragraph (default)
+    const paraLines: string[] = [];
+    while (
+      i < lines.length &&
+      lines[i]!.trim() !== '' &&
+      !lines[i]!.startsWith('#') &&
+      !lines[i]!.startsWith('```') &&
+      !/^[-*+]\s/.test(lines[i]!) &&
+      !/^\d+\.\s/.test(lines[i]!) &&
+      !lines[i]!.startsWith('> ') &&
+      !/^(-{3,}|\*{3,}|_{3,})$/.test(lines[i]!.trim())
+    ) {
+      paraLines.push(lines[i]!);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      nodes.push({
+        type: 'paragraph',
+        children: parseInline(paraLines.join(' '))
+      });
+    }
+  }
+
+  return { nodes };
+}