koguma 2.0.0 → 2.2.0

package/cli/index.ts

@@ -13,7 +13,13 @@
  * All commands auto-detect the project root by looking for koguma.toml.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync
+} from 'fs';
 import { resolve, dirname, extname } from 'path';
 
 import { ANSI, log, ok, warn, fail, header } from './log.ts';
@@ -47,6 +53,7 @@ import {
   d1ExecuteBatchSqlAsync,
   r2PutLocal,
   r2PutLocalAsync,
+  r2PutRemoteAsync,
   wranglerDev,
   wranglerDeploy,
   createD1Database,
@@ -59,7 +66,11 @@ import {
   validateContent,
   type ContentTypeInfo
 } from './content.ts';
-import { startDevSync, DEV_SYNC_ENV_VAR, killStalePortHolder } from './dev-sync.ts';
+import {
+  startDevSync,
+  DEV_SYNC_ENV_VAR,
+  killStalePortHolder
+} from './dev-sync.ts';
 import { buildInsertSql, wrapForShell } from '../src/db/sql.ts';
 import { intro, outro, handleCancel, p, BRAND } from './ui.ts';
 
@@ -156,8 +167,12 @@ async function syncContentToLocalD1(
         f => !f.startsWith('.') && !f.startsWith('_')
       );
       const mimeTypes: Record<string, string> = {
-        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-        '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml'
       };
 
       for (const file of mediaFiles) {
@@ -167,15 +182,19 @@ async function syncContentToLocalD1(
 
         assetIdMap.set(file, id);
         mediaUploads.push({ filePath: resolve(mediaDir, file), key });
-        assetSql.push(buildInsertSql('assets', {
-          id,
-          data: JSON.stringify({
-            title: file,
-            url: `/api/media/${key}`,
-            content_type: mimeTypes[ext] ?? 'application/octet-stream',
-            width: null, height: null, file_size: null
+        assetSql.push(
+          buildInsertSql('assets', {
+            id,
+            data: JSON.stringify({
+              title: file,
+              url: `/api/media/${key}`,
+              content_type: mimeTypes[ext] ?? 'application/octet-stream',
+              width: null,
+              height: null,
+              file_size: null
+            })
           })
-        }));
+        );
       }
     }
 
@@ -184,8 +203,14 @@ async function syncContentToLocalD1(
     const entrySql: string[] = [];
     for (const { contentType, rowData } of prepared) {
       const {
-        id, slug, status, publish_at, publishAt,
-        created_at: _ca, updated_at: _ua, content_type: _ct,
+        id,
+        slug,
+        status,
+        publish_at,
+        publishAt,
+        created_at: _ca,
+        updated_at: _ua,
+        content_type: _ct,
         ...fields
       } = rowData;
 
@@ -193,9 +218,16 @@ async function syncContentToLocalD1(
       const ct = config.contentTypes.find(c => c.id === contentType);
       if (ct && assetIdMap.size > 0) {
         for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
-          if (meta.fieldType === 'image' && typeof fields[fieldId] === 'string') {
-            fields[fieldId] = assetIdMap.get(fields[fieldId] as string) ?? fields[fieldId];
-          } else if (meta.fieldType === 'images' && Array.isArray(fields[fieldId])) {
+          if (
+            meta.fieldType === 'image' &&
+            typeof fields[fieldId] === 'string'
+          ) {
+            fields[fieldId] =
+              assetIdMap.get(fields[fieldId] as string) ?? fields[fieldId];
+          } else if (
+            meta.fieldType === 'images' &&
+            Array.isArray(fields[fieldId])
+          ) {
             fields[fieldId] = (fields[fieldId] as string[]).map(
               v => assetIdMap.get(v) ?? v
             );
@@ -203,21 +235,26 @@ async function syncContentToLocalD1(
         }
       }
 
-      entrySql.push(buildInsertSql('entries', {
-        id: id as string,
-        content_type: contentType,
-        slug: (slug as string | undefined) ?? null,
-        data: JSON.stringify(fields),
-        status: (status as string | undefined) ?? 'draft',
-        ...(publish_at !== undefined ? { publish_at } : {}),
-        ...(publishAt !== undefined ? { publish_at: publishAt } : {})
-      }));
+      entrySql.push(
+        buildInsertSql('entries', {
+          id: id as string,
+          content_type: contentType,
+          slug: (slug as string | undefined) ?? null,
+          data: JSON.stringify(fields),
+          status: (status as string | undefined) ?? 'draft',
+          ...(publish_at !== undefined ? { publish_at } : {}),
+          ...(publishAt !== undefined ? { publish_at: publishAt } : {})
+        })
+      );
     }
 
     // Single batch: assets + entries written to one SQL file
     const allStatements = [...assetSql, ...entrySql];
     if (allStatements.length > 0) {
-      if (s) s.message(`Syncing ${entrySql.length} entries + ${assetSql.length} assets...`);
+      if (s)
+        s.message(
+          `Syncing ${entrySql.length} entries + ${assetSql.length} assets...`
+        );
       await d1ExecuteBatchSqlAsync(root, dbName, '--local', allStatements);
     }
 
@@ -542,7 +579,10 @@ async function cmdDev(): Promise<void> {
 /**
  * koguma push — Ship to production.
  *
- * Content sync → build admin → deploy → sync data + media to remote.
+ * Reads content/ directly as the source of truth:
+ *   - Entries + media metadata → remote D1  (no local D1 roundtrip)
+ *   - content/media/ files → remote R2  (no localhost dependency)
+ *   - Then builds and deploys the worker.
  */
 async function cmdPush(): Promise<void> {
   intro('push');
@@ -557,127 +597,178 @@ async function cmdPush(): Promise<void> {
 
   const { dbName, bucketName } = getProjectNames(root);
 
-  // ── Confirmation ──
-  const confirmed = await p.confirm({
-    message: `Push local content to ${BRAND.ACCENT}${remoteUrl}${BRAND.RESET}?`,
-    initialValue: true
-  });
-  if (handleCancel(confirmed)) return;
-  if (!confirmed) {
-    outro('Push cancelled.');
-    return;
+  // ── Confirmation (Enter = yes, n = cancel, --yes to skip) ──
+  const skipConfirm =
+    process.argv.includes('--yes') || process.argv.includes('-y');
+  if (!skipConfirm) {
+    const answer = await p.text({
+      message: `Push to ${BRAND.ACCENT}${remoteUrl}${BRAND.RESET}? (Y/n)`,
+      defaultValue: 'y',
+      placeholder: 'y'
+    });
+    if (handleCancel(answer)) return;
+    if ((answer as string).toLowerCase().startsWith('n')) {
+      outro('Push cancelled.');
+      return;
+    }
+  } else {
+    p.log.info(`Pushing to ${BRAND.ACCENT}${remoteUrl}${BRAND.RESET} (--yes)`);
   }
 
-  // ── Step 1: Apply schema to remote ──
+  // ── Step 1/4: Apply schema to remote ──
   const s1 = p.spinner();
   s1.start('Applying schema to remote...');
   applySchema(root, dbName, '--remote');
   s1.stop('Remote schema applied');
 
-  // ── Step 2: Sync content/ → local D1 ──
+  // ── Step 2/4: content/ → remote D1 (direct, no local roundtrip) ──
   const s2 = p.spinner();
-  s2.start('Syncing content/ to local D1...');
-  await syncContentToLocalD1(root, dbName, s2);
-  s2.stop('Local content synced');
-
-  // ── Step 3: Export local content ──
-  const s3 = p.spinner();
-  s3.start('Exporting local content...');
-
-  let localEntries: Record<string, unknown>[] = [];
-  try {
-    localEntries = d1Query(root, dbName, '--local', 'SELECT * FROM entries');
-  } catch {
-    p.log.warn('Could not export entries from local');
-  }
+  s2.start('Reading content/ and syncing to remote D1...');
+  const contentDir = resolve(root, CONTENT_DIR);
+  const mediaDir = resolve(contentDir, 'media');
+  let syncedEntries = 0;
+  let syncedAssets = 0;
 
-  let localAssets: Record<string, unknown>[] = [];
   try {
-    localAssets = d1Query(root, dbName, '--local', 'SELECT * FROM assets');
-  } catch {
-    p.log.warn('Could not export assets from local');
-  }
-  s3.stop(
-    `Exported ${localEntries.length} entries + ${localAssets.length} assets`
-  );
+    const config = await loadSiteConfig(root);
 
-  // ── Step 4: Import to remote ──
-  const total = localEntries.length + localAssets.length;
-  if (total > 0) {
-    const prog = p.progress({ max: total });
-    prog.start('Importing content to remote...');
+    // Build asset rows from content/media/ filenames
+    const mimeTypes: Record<string, string> = {
+      '.png': 'image/png',
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.gif': 'image/gif',
+      '.webp': 'image/webp',
+      '.svg': 'image/svg+xml',
+      '.avif': 'image/avif',
+      '.ico': 'image/x-icon'
+    };
+    const assetIdMap = new Map<string, string>();
+    const allStatements: string[] = [];
 
-    let done = 0;
-    for (const asset of localAssets) {
-      d1InsertRow(root, dbName, '--remote', 'assets', asset);
-      done++;
-      prog.advance(done, `Importing... (${done}/${total})`);
-    }
-    for (const entry of localEntries) {
-      d1InsertRow(root, dbName, '--remote', 'entries', entry);
-      done++;
-      prog.advance(done, `Importing... (${done}/${total})`);
+    if (existsSync(mediaDir)) {
+      const mediaFiles = readdirSync(mediaDir).filter(
+        f => !f.startsWith('.') && !f.startsWith('_')
+      );
+      for (const file of mediaFiles) {
+        const ext = extname(file).toLowerCase();
+        const id = `media-${file.replace(/\.\w+$/, '')}`;
+        const key = `${id}${ext}`;
+        assetIdMap.set(file, id);
+        allStatements.push(
+          buildInsertSql('assets', {
+            id,
+            data: JSON.stringify({
+              title: file,
+              url: `/api/media/${key}`,
+              content_type: mimeTypes[ext] ?? 'application/octet-stream',
+              width: null,
+              height: null,
+              file_size: null
+            })
+          })
+        );
+      }
+      syncedAssets = assetIdMap.size;
     }
-    prog.stop(
-      `Synced ${localEntries.length} entries + ${localAssets.length} assets to remote`
-    );
-  }
 
-  // ── Step 5: Upload media to remote ──
-  if (localAssets.length > 0) {
-    const cookie = await authenticate(remoteUrl, root);
-    const sProg = p.progress({ max: localAssets.length });
-    sProg.start('Uploading media to remote...');
-
-    let uploaded = 0;
-    for (const asset of localAssets) {
-      const assetData =
-        typeof asset.data === 'string'
-          ? JSON.parse(asset.data)
-          : (asset.data as Record<string, string>);
-      const assetUrl = assetData.url ?? '';
-      const assetTitle = assetData.title ?? '';
-      const contentType = assetData.content_type ?? 'application/octet-stream';
-      const key = assetUrl.replace('/api/media/', '');
+    // Read content/ entries → build SQL
+    const prepared = prepareContentForSync(contentDir, config.contentTypes);
+    for (const { contentType, rowData } of prepared) {
+      const {
+        id,
+        slug,
+        status,
+        publish_at,
+        publishAt,
+        created_at: _ca,
+        updated_at: _ua,
+        content_type: _ct,
+        ...fields
+      } = rowData;
 
-      try {
-        const dlRes = await fetch(`http://localhost:8787${assetUrl}`);
-        if (!dlRes.ok) {
-          uploaded++;
-          sProg.advance(uploaded);
-          continue;
+      // Resolve media filenames → asset IDs
+      const ct = config.contentTypes.find(c => c.id === contentType);
+      if (ct && assetIdMap.size > 0) {
+        for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
+          if (
+            meta.fieldType === 'image' &&
+            typeof fields[fieldId] === 'string'
+          ) {
+            fields[fieldId] =
+              assetIdMap.get(fields[fieldId] as string) ?? fields[fieldId];
+          } else if (
+            meta.fieldType === 'images' &&
+            Array.isArray(fields[fieldId])
+          ) {
+            fields[fieldId] = (fields[fieldId] as string[]).map(
+              v => assetIdMap.get(v) ?? v
+            );
+          }
         }
+      }
 
-        const blob = await dlRes.blob();
-        const formData = new FormData();
-        formData.append('file', new File([blob], key, { type: contentType }));
-        formData.append('title', assetTitle || key);
+      allStatements.push(
+        buildInsertSql('entries', {
+          id: id as string,
+          content_type: contentType,
+          slug: (slug as string | undefined) ?? null,
+          data: JSON.stringify(fields),
+          status: (status as string | undefined) ?? 'published',
+          ...(publish_at !== undefined ? { publish_at } : {}),
+          ...(publishAt !== undefined ? { publish_at: publishAt } : {})
+        })
+      );
+    }
+    syncedEntries = prepared.length;
 
-        const upRes = await fetch(`${remoteUrl}/api/admin/media`, {
-          method: 'POST',
-          headers: { Cookie: cookie },
-          body: formData
-        });
+    if (allStatements.length > 0) {
+      await d1ExecuteBatchSqlAsync(root, dbName, '--remote', allStatements);
+    }
+    s2.stop(
+      `Synced ${syncedEntries} entries + ${syncedAssets} assets to remote D1`
+    );
+  } catch (e) {
+    s2.stop('Content sync failed');
+    warn(`${e}`);
+  }
 
-        if (!upRes.ok) {
-          warn(`Upload failed for ${assetTitle}: ${await upRes.text()}`);
+  // ── Step 3/4: content/media/ → remote R2 (direct file upload) ──
+  if (existsSync(mediaDir)) {
+    const mediaFiles = readdirSync(mediaDir).filter(
+      f => !f.startsWith('.') && !f.startsWith('_')
+    );
+    if (mediaFiles.length > 0) {
+      const sProg = p.progress({ max: mediaFiles.length });
+      sProg.start('Uploading media files to remote R2...');
+      let uploaded = 0;
+      for (const file of mediaFiles) {
+        const ext = extname(file).toLowerCase();
+        const id = `media-${file.replace(/\.\w+$/, '')}`;
+        const key = `${id}${ext}`;
+        try {
+          await r2PutRemoteAsync(
+            root,
+            bucketName,
+            key,
+            resolve(mediaDir, file)
+          );
+        } catch (e) {
+          warn(`Failed to upload ${file}: ${e}`);
         }
-      } catch (e) {
-        warn(`Error uploading ${assetTitle}: ${e}`);
+        uploaded++;
+        sProg.advance(
+          uploaded,
+          `Uploading... (${uploaded}/${mediaFiles.length})`
+        );
       }
-      uploaded++;
-      sProg.advance(
-        uploaded,
-        `Uploading media... (${uploaded}/${localAssets.length})`
-      );
+      sProg.stop(`Uploaded ${uploaded} media files to remote R2`);
     }
-    sProg.stop(`Uploaded ${uploaded} media assets`);
   }
 
-  // ── Step 6: Build + Deploy ──
+  // ── Step 4/4: Build + Deploy ──
   const sBuild = p.spinner();
   sBuild.start('Building admin dashboard...');
-
   const kogumaRoot = findKogumaRoot();
   const adminDir = resolve(kogumaRoot, 'admin');
   if (existsSync(adminDir)) {
@@ -949,7 +1040,7 @@ function cmdHelp(): void {
     [
       `${BRAND.ACCENT}init${BRAND.RESET}            Set up a new project ${BRAND.DIM}(scaffold, login, D1, R2, secret)${BRAND.RESET}`,
       `${BRAND.ACCENT}dev${BRAND.RESET}             Start local dev server ${BRAND.DIM}with auto-sync + typegen${BRAND.RESET}`,
-      `${BRAND.ACCENT}push${BRAND.RESET}            Build, deploy, and sync content to remote`,
+      `${BRAND.ACCENT}push${BRAND.RESET}            Build, deploy, and sync content to remote ${BRAND.DIM}(--yes to skip confirm)${BRAND.RESET}`,
       `${BRAND.ACCENT}pull${BRAND.RESET}            Download remote content + media to local`,
       `${BRAND.ACCENT}gen-types${BRAND.RESET}       Generate ${BRAND.DIM}koguma.d.ts${BRAND.RESET} typed interfaces`,
       `${BRAND.ACCENT}tidy${BRAND.RESET}            Sync content/ dirs with config + validate`,
@@ -962,7 +1053,7 @@ function cmdHelp(): void {
     [
       `${BRAND.DIM}$${BRAND.RESET} koguma init`,
       `${BRAND.DIM}$${BRAND.RESET} koguma dev`,
-      `${BRAND.DIM}$${BRAND.RESET} koguma push --remote https://my-site.dev`,
+      `${BRAND.DIM}$${BRAND.RESET} koguma push --remote https://my-site.dev${BRAND.DIM} --yes${BRAND.RESET}`,
       `${BRAND.DIM}$${BRAND.RESET} koguma pull --remote https://my-site.dev`,
       `${BRAND.DIM}$${BRAND.RESET} koguma gen-types`,
       `${BRAND.DIM}$${BRAND.RESET} koguma tidy --dry`

package/cli/scaffold.ts

@@ -337,7 +337,7 @@ export function generateExampleFile(
   }
 
   const fm = matter.stringify('', frontmatter).trim();
-  return { content: fm + '\n', extension: '.yml' };
+  return { content: fm + '\n', extension: '.md' };
 }
 
 /**

package/cli/wrangler.ts

@@ -207,7 +207,10 @@ export async function d1ExecuteBatchSqlAsync(
   if (!existsSync(dbDir)) mkdirSync(dbDir, { recursive: true });
 
   const sqlFile = resolve(dbDir, 'batch-sync.sql');
-  writeFileSync(sqlFile, statements.map(s => s.endsWith(';') ? s : s + ';').join('\n'));
+  writeFileSync(
+    sqlFile,
+    statements.map(s => (s.endsWith(';') ? s : s + ';')).join('\n')
+  );
   await runAsync(
     `bunx wrangler d1 execute ${dbName} ${target} ${configFlag(root)} --file=${sqlFile}`,
     { cwd: root, silent: true }
@@ -244,6 +247,36 @@ export async function r2PutLocalAsync(
   );
 }
 
+/**
+ * Put an object into the remote (production) Cloudflare R2 bucket.
+ */
+export function r2PutRemote(
+  root: string,
+  bucketName: string,
+  key: string,
+  filePath: string
+): void {
+  run(
+    `bunx wrangler r2 object put ${bucketName}/${key} ${configFlag(root)} --file=${filePath}`,
+    { cwd: root, silent: true }
+  );
+}
+
+/**
+ * Put an object into the remote (production) Cloudflare R2 bucket (async).
+ */
+export async function r2PutRemoteAsync(
+  root: string,
+  bucketName: string,
+  key: string,
+  filePath: string
+): Promise<void> {
+  await runAsync(
+    `bunx wrangler r2 object put ${bucketName}/${key} ${configFlag(root)} --file=${filePath}`,
+    { cwd: root, silent: true }
+  );
+}
+
 // ── Wrangler dev / deploy ──────────────────────────────────────────
 
 /**
@@ -280,6 +313,13 @@ export function wranglerDev(
       /│.*\[b\].*\[c\].*\[x\]/, // keyboard shortcuts content
       /╰.*╯/, // keyboard shortcuts box bottom
       /\[wrangler:/, // [wrangler:inf] prefixed messages (handled separately below)
+      /Resolving dependencies/, // npm dep install noise
+      /Resolved, downloaded/, // npm dep install noise
+      /Saved lockfile/, // npm dep install noise
+      /^✓\s+/, // npm dep install success lines
+      /^✘\s+/, // npm dep install error lines (let warn() handle these)
+      /^▲\s+/, // npm dep install warning lines
+      /^>\s+/, // npm progress lines
       /^\s*$/ // blank lines
     ];
 

package/package.json

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