koguma 0.6.6 → 2.0.0

package/cli/dev-sync.ts

@@ -0,0 +1,305 @@
+/**
+ * cli/dev-sync.ts — Bidirectional sync between content/ files and local D1.
+ *
+ * Two event-driven sync paths:
+ *   1. File watcher:  content/ file changes → parse → INSERT OR REPLACE into D1
+ *   2. Sync server:   router webhook (POST /sync) → write content/ file
+ *
+ * Loop prevention: a shared cooldown map tracks recent writes by entry ID.
+ * When either side writes, it records the ID. The other side skips that ID
+ * for a short cooldown window to prevent infinite loops.
+ */
+
+import { watch, existsSync, statSync } from 'fs';
+import { resolve, relative, join, extname, sep } from 'path';
+import { log, ok, warn, ANSI } from './log.ts';
+import { d1InsertRow, applySchema, type D1Target } from './wrangler.ts';
+import { buildInsertSql } from '../src/db/sql.ts';
+import {
+  parseContentFile,
+  contentEntryToDbRow,
+  dbRowToContentFile,
+  writeContentDir,
+  type ContentTypeInfo
+} from './content.ts';
+import { CONTENT_DIR, SITE_CONFIG_FILE } from './constants.ts';
+
+// ── Constants ──────────────────────────────────────────────────────
+
+/** Port for the dev sync HTTP server */
+export const DEV_SYNC_PORT = 4319;
+
+/** Env var the router checks to decide whether to fire webhooks */
+export const DEV_SYNC_ENV_VAR = 'KOGUMA_DEV_SYNC';
+
+/** Cooldown window (ms) to prevent sync loops */
+const COOLDOWN_MS = 3000;
+
+// ── Loop prevention ────────────────────────────────────────────────
+
+/** Tracks recent writes to prevent infinite loops between watchers */
+const recentWrites = new Map<string, number>();
+
+function markRecentWrite(entryId: string): void {
+  recentWrites.set(entryId, Date.now());
+}
+
+function isRecentWrite(entryId: string): boolean {
+  const ts = recentWrites.get(entryId);
+  if (!ts) return false;
+  if (Date.now() - ts > COOLDOWN_MS) {
+    recentWrites.delete(entryId);
+    return false;
+  }
+  return true;
+}
+
+// ── File watcher: content/ → D1 ───────────────────────────────────
+
+interface FileWatcherOptions {
+  root: string;
+  dbName: string;
+  contentTypes: ContentTypeInfo[];
+}
+
+function startFileWatcher(opts: FileWatcherOptions): { stop: () => void } {
+  const { root, dbName, contentTypes } = opts;
+  const contentDir = resolve(root, CONTENT_DIR);
+
+  if (!existsSync(contentDir)) return { stop: () => {} };
+
+  const ctMap = new Map(contentTypes.map(ct => [ct.id, ct]));
+
+  // Debounce to avoid processing the same file multiple times
+  const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  const watcher = watch(contentDir, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    const filePath = resolve(contentDir, filename);
+
+    // Skip non-content files
+    const ext = extname(filename);
+    if (ext !== '.md' && ext !== '.yml' && ext !== '.yaml') return;
+
+    // Skip media/ subdirectory
+    if (filename.startsWith('media' + sep) || filename.startsWith('media/'))
+      return;
+
+    // Determine content type from directory structure
+    const parts = filename.split(sep);
+    if (parts.length < 2) return; // Need at least contentType/file.md
+    const contentTypeId = parts[0]!;
+
+    // Debounce — editors often trigger multiple events per save
+    const existing = debounceTimers.get(filename);
+    if (existing) clearTimeout(existing);
+
+    debounceTimers.set(
+      filename,
+      setTimeout(() => {
+        debounceTimers.delete(filename);
+
+        if (!existsSync(filePath)) return; // File was deleted
+
+        const ctInfo = ctMap.get(contentTypeId);
+        if (!ctInfo) return;
+
+        try {
+          const entry = parseContentFile(filePath, contentTypeId);
+
+          // Derive entry ID for loop prevention
+          const slug = entry.slug || (entry.fields.slug as string) || '';
+          const entryId = ctInfo.singleton
+            ? `${contentTypeId}-singleton`
+            : `${contentTypeId}-${slug}`;
+
+          if (isRecentWrite(entryId)) return;
+
+          // Pack into v2 format: entries(id, content_type, slug, data, status)
+          const rowData = contentEntryToDbRow(entry, ctInfo);
+          const {
+            id, slug: rowSlug, status, publish_at, publishAt,
+            created_at: _ca, updated_at: _ua, content_type: _ct,
+            ...fields
+          } = rowData;
+          d1InsertRow(root, dbName, '--local', 'entries', {
+            id: id as string,
+            content_type: contentTypeId,
+            slug: (rowSlug as string | undefined) ?? null,
+            data: JSON.stringify(fields),
+            status: (status as string | undefined) ?? 'published',
+            ...(publish_at !== undefined ? { publish_at } : {}),
+            ...(publishAt !== undefined ? { publish_at: publishAt } : {})
+          });
+          markRecentWrite(entryId);
+
+          ok(
+            `${ANSI.DIM}sync:${ANSI.RESET} ${contentTypeId}/${parts.slice(1).join('/')} → D1`
+          );
+        } catch (e) {
+          warn(`File sync failed for ${filename}: ${e}`);
+        }
+      }, 300) // 300ms debounce
+    );
+  });
+
+  return {
+    stop: () => {
+      watcher.close();
+      for (const timer of debounceTimers.values()) clearTimeout(timer);
+      debounceTimers.clear();
+    }
+  };
+}
+
+// ── Sync server: router webhook → content/ files ───────────────────
+
+interface SyncServerOptions {
+  root: string;
+  contentTypes: ContentTypeInfo[];
+}
+
+export function killStalePortHolder(port: number): void {
+  try {
+    const { execSync } = require('child_process');
+    const out = execSync(`lsof -ti :${port}`, { encoding: 'utf-8' }).trim();
+    if (out) {
+      for (const pid of out.split('\n')) {
+        const n = parseInt(pid, 10);
+        if (n > 0 && n !== process.pid) {
+          try { process.kill(n, 'SIGTERM'); } catch { /* already gone */ }
+        }
+      }
+      // Brief pause to let the OS release the socket
+      execSync('sleep 0.2');
+    }
+  } catch { /* lsof not found or no process — fine */ }
+}
+
+function startSyncServer(opts: SyncServerOptions): {
+  stop: () => void;
+  port: number;
+} {
+  const { root, contentTypes } = opts;
+  const contentDir = resolve(root, CONTENT_DIR);
+  const ctMap = new Map(contentTypes.map(ct => [ct.id, ct]));
+
+  killStalePortHolder(DEV_SYNC_PORT);
+
+  const server = Bun.serve({
+    port: DEV_SYNC_PORT,
+    reusePort: true,
+    fetch: async (req: Request) => {
+      const url = new URL(req.url);
+
+      if (req.method === 'POST' && url.pathname === '/sync') {
+        try {
+          const payload = (await req.json()) as {
+            action: 'create' | 'update' | 'delete';
+            contentType: string;
+            entry?: Record<string, unknown>;
+            entryId?: string;
+          };
+
+          const ctInfo = ctMap.get(payload.contentType);
+          if (!ctInfo) {
+            return new Response('Unknown content type', { status: 400 });
+          }
+
+          if (payload.action === 'delete') {
+            // For delete, we'd need to remove the file — for now, just log
+            ok(
+              `${ANSI.DIM}sync:${ANSI.RESET} D1 → deleted ${payload.contentType}/${payload.entryId}`
+            );
+            return new Response('ok');
+          }
+
+          if (!payload.entry) {
+            return new Response('Missing entry data', { status: 400 });
+          }
+
+          // Derive entry ID for loop prevention
+          const slug =
+            (payload.entry.slug as string) ||
+            (payload.entry.id as string) ||
+            '';
+          const entryId = ctInfo.singleton
+            ? `${payload.contentType}-singleton`
+            : `${payload.contentType}-${slug}`;
+
+          if (isRecentWrite(entryId)) {
+            return new Response('ok (cooldown)');
+          }
+
+          // Write the entry to a content/ file
+          const count = writeContentDir(contentDir, [payload.entry], [ctInfo]);
+
+          if (count > 0) {
+            markRecentWrite(entryId);
+            ok(
+              `${ANSI.DIM}sync:${ANSI.RESET} D1 → ${payload.contentType}/${slug || 'index'}`
+            );
+          }
+
+          return new Response('ok');
+        } catch (e) {
+          warn(`Sync server error: ${e}`);
+          return new Response('error', { status: 500 });
+        }
+      }
+
+      return new Response('not found', { status: 404 });
+    }
+  });
+
+  return {
+    port: server.port,
+    stop: () => server.stop()
+  };
+}
+
+// ── Public API ─────────────────────────────────────────────────────
+
+export interface DevSyncHandle {
+  stop: () => void;
+  syncUrl: string;
+}
+
+/**
+ * Start bidirectional dev sync.
+ *
+ * Returns a handle with:
+ * - `stop()` to clean up watchers and server
+ * - `syncUrl` to pass as KOGUMA_DEV_SYNC env var to wrangler dev
+ */
+export function startDevSync(
+  root: string,
+  dbName: string,
+  contentTypes: ContentTypeInfo[],
+  opts?: { silent?: boolean }
+): DevSyncHandle {
+  const contentDir = resolve(root, CONTENT_DIR);
+
+  // Ensure content/ directory exists
+  if (!existsSync(contentDir)) {
+    const { mkdirSync } = require('fs');
+    mkdirSync(contentDir, { recursive: true });
+  }
+
+  // Start both sync paths
+  const fileWatcher = startFileWatcher({ root, dbName, contentTypes });
+  const syncServer = startSyncServer({ root, contentTypes });
+
+  if (!opts?.silent) {
+    ok(`Dev sync active — file watcher + sync server on :${syncServer.port}`);
+  }
+
+  return {
+    syncUrl: `http://localhost:${syncServer.port}`,
+    stop: () => {
+      fileWatcher.stop();
+      syncServer.stop();
+      recentWrites.clear();
+    }
+  };
+}

package/cli/exec.ts

@@ -0,0 +1,61 @@
+/**
+ * cli/exec.ts — Shell execution helpers.
+ *
+ * Thin wrappers around child_process for CLI command execution.
+ */
+
+import { execSync, exec } from 'child_process';
+
+export interface ExecOptions {
+  cwd?: string;
+  silent?: boolean;
+}
+
+/**
+ * Run a shell command synchronously. Throws on failure unless `silent` is true.
+ * When silent, returns stdout even on non-zero exit.
+ */
+export function run(cmd: string, opts?: ExecOptions): string {
+  try {
+    return execSync(cmd, {
+      cwd: opts?.cwd,
+      encoding: 'utf-8',
+      stdio: opts?.silent ? 'pipe' : 'inherit'
+    }) as string;
+  } catch (e: unknown) {
+    const error = e as { stdout?: string; stderr?: string; status?: number };
+    if (opts?.silent) return error.stdout ?? '';
+    throw e;
+  }
+}
+
+/**
+ * Run a shell command silently and return trimmed stdout.
+ */
+export function runCapture(cmd: string, cwd?: string): string {
+  return run(cmd, { cwd, silent: true }).trim();
+}
+
+/**
+ * Run a shell command asynchronously (non-blocking).
+ * This keeps the event loop free so spinners can animate.
+ */
+export function runAsync(cmd: string, opts?: ExecOptions): Promise<string> {
+  return new Promise((resolve, reject) => {
+    exec(
+      cmd,
+      { cwd: opts?.cwd, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (opts?.silent) {
+            resolve(stdout ?? '');
+          } else {
+            reject(error);
+          }
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+  });
+}