@korajs/cli 0.4.0 → 0.6.0

package/dist/bin.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   createCommand
-} from "./chunk-MVP5PDT4.js";
+} from "./chunk-EEZNRI5W.js";
 import {
   deployCommand,
   generateTypes
-} from "./chunk-YGVO4POI.js";
+} from "./chunk-Q2FBCOQD.js";
 import {
   DevServerError,
   InvalidProjectError,
@@ -16,21 +16,187 @@ import {
   hasTsxInstalled,
   promptConfirm,
   resolveProjectBinaryEntryPoint
-} from "./chunk-CMSX76KM.js";
+} from "./chunk-VLTPEATY.js";
 
 // src/bin.ts
-import { defineCommand as defineCommand4, runMain } from "citty";
+import { defineCommand as defineCommand9, runMain } from "citty";
 
-// src/commands/dev/dev-command.ts
-import { access as access2 } from "fs/promises";
-import { join as join3 } from "path";
-import { resolve } from "path";
+// src/commands/backup/backup-command.ts
+import { readFile, writeFile } from "fs/promises";
+import "path";
 import { defineCommand } from "citty";
+var DEFAULT_SYNC_PORT = 3001;
+var backupCommand = defineCommand({
+  meta: {
+    name: "backup",
+    description: "Backup and restore Kora sync server data"
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: {
+        name: "create",
+        description: "Create a backup of the sync server"
+      },
+      args: {
+        url: {
+          type: "string",
+          description: "Sync server URL (default: http://localhost:3001)",
+          default: `http://localhost:${DEFAULT_SYNC_PORT}`
+        },
+        out: {
+          type: "string",
+          description: "Output file path (default: kora-backup-<timestamp>.kora)"
+        },
+        token: {
+          type: "string",
+          description: "Backup token (defaults to KORA_BACKUP_TOKEN or KORA_ADMIN_TOKEN)"
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT}`;
+        const outFile = typeof args.out === "string" ? args.out : `kora-backup-${Date.now()}.kora`;
+        const token = typeof args.token === "string" ? args.token : process.env.KORA_BACKUP_TOKEN ?? process.env.KORA_ADMIN_TOKEN;
+        logger.banner();
+        logger.info(`Exporting backup from ${url}...`);
+        try {
+          const backupUrl = `${url.replace(/\/$/, "")}/__kora/backup/export`;
+          const response = await fetch(backupUrl, {
+            method: "POST",
+            headers: token ? { Authorization: `Bearer ${token}` } : void 0
+          });
+          if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(
+              `Backup failed: ${error.message ?? response.statusText}`
+            );
+          }
+          const buffer = await response.arrayBuffer();
+          await writeFile(outFile, new Uint8Array(buffer));
+          const size = (buffer.byteLength / 1024).toFixed(1);
+          logger.success(`Backup saved to ${outFile} (${size} KB)`);
+        } catch (error) {
+          logger.error("Backup failed");
+          if (error instanceof Error) logger.error(error.message);
+          logger.blank();
+          logger.step("Make sure the Kora sync server is running.");
+          process.exit(1);
+        }
+      }
+    }),
+    restore: defineCommand({
+      meta: {
+        name: "restore",
+        description: "Restore a backup to the sync server"
+      },
+      args: {
+        file: {
+          type: "string",
+          description: "Backup file path",
+          required: true
+        },
+        url: {
+          type: "string",
+          description: "Sync server URL (default: http://localhost:3001)",
+          default: `http://localhost:${DEFAULT_SYNC_PORT}`
+        },
+        merge: {
+          type: "boolean",
+          description: "Merge with existing data instead of replacing",
+          default: false
+        },
+        token: {
+          type: "string",
+          description: "Backup token (defaults to KORA_BACKUP_TOKEN or KORA_ADMIN_TOKEN)"
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const filePath = typeof args.file === "string" ? args.file : "";
+        const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT}`;
+        const merge = args.merge === true;
+        const token = typeof args.token === "string" ? args.token : process.env.KORA_BACKUP_TOKEN ?? process.env.KORA_ADMIN_TOKEN;
+        logger.banner();
+        logger.info(`Restoring backup from ${filePath} to ${url}...`);
+        try {
+          const data = await readFile(filePath);
+          const restoreUrl = `${url.replace(/\/$/, "")}/__kora/backup/import?merge=${merge}`;
+          const response = await fetch(restoreUrl, {
+            method: "POST",
+            headers: token ? { Authorization: `Bearer ${token}` } : void 0,
+            body: data
+          });
+          if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(
+              `Restore failed: ${error.message ?? response.statusText}`
+            );
+          }
+          const result = await response.json();
+          if (result.success) {
+            logger.success(
+              `Restored ${result.operationsRestored} operations${result.duration ? ` in ${result.duration}ms` : ""}`
+            );
+          } else {
+            logger.error("Restore completed with errors");
+          }
+        } catch (error) {
+          logger.error("Restore failed");
+          if (error instanceof Error) logger.error(error.message);
+          process.exit(1);
+        }
+      }
+    }),
+    info: defineCommand({
+      meta: {
+        name: "info",
+        description: "Show backup file information"
+      },
+      args: {
+        file: {
+          type: "string",
+          description: "Backup file path",
+          required: true
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const filePath = typeof args.file === "string" ? args.file : "";
+        try {
+          const data = await readFile(filePath);
+          const { readBackupManifest } = await import("@korajs/store");
+          const manifest = readBackupManifest(
+            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+          );
+          logger.banner();
+          logger.info(`Backup: ${filePath}`);
+          logger.blank();
+          logger.step(`Created:     ${new Date(manifest.createdAt).toISOString()}`);
+          logger.step(`Node ID:     ${manifest.nodeId}`);
+          logger.step(`Schema:      v${manifest.schemaVersion}`);
+          logger.step(`Operations:  ${manifest.operationCount.toLocaleString()}`);
+          logger.step(`Collections: ${manifest.collections.join(", ") || "(none)"}`);
+          logger.step(`Checksum:    ${manifest.checksum.slice(0, 16)}...`);
+          logger.blank();
+          logger.step(`Format version: ${manifest.version}`);
+        } catch (error) {
+          logger.error("Failed to read backup file");
+          if (error instanceof Error) logger.error(error.message);
+          process.exit(1);
+        }
+      }
+    })
+  }
+});
+
+// src/commands/compact/compact-command.ts
+import { resolve } from "path";
+import { defineCommand as defineCommand2 } from "citty";
 
 // src/commands/dev/kora-config.ts
 import { spawn } from "child_process";
 import { access } from "fs/promises";
-import { extname, join } from "path";
+import { extname, join as join2 } from "path";
 import { pathToFileURL } from "url";
 var CONFIG_CANDIDATES = [
   "kora.config.ts",
@@ -53,7 +219,7 @@ async function loadKoraConfig(projectRoot) {
 }
 async function findKoraConfigFile(projectRoot) {
   for (const file of CONFIG_CANDIDATES) {
-    const candidate = join(projectRoot, file);
+    const candidate = join2(projectRoot, file);
     try {
       await access(candidate);
       return candidate;
@@ -81,7 +247,7 @@ async function loadTypeScriptConfig(configPath, projectRoot) {
   }
 }
 async function runCommand(command, args, cwd) {
-  return await new Promise((resolve4, reject) => {
+  return await new Promise((resolve6, reject) => {
     const child = spawn(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -100,7 +266,7 @@ async function runCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve4(stdout.trim());
+        resolve6(stdout.trim());
         return;
       }
       reject(new Error(`Failed to load kora config (exit ${code ?? "unknown"}): ${stderr.trim()}`));
@@ -118,6 +284,156 @@ function toConfigObject(mod) {
   return value;
 }
 
+// src/commands/migrate/schema-loader.ts
+import { spawn as spawn2 } from "child_process";
+import { extname as extname2 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function loadSchemaDefinition(schemaPath, projectRoot) {
+  const ext = extname2(schemaPath);
+  const moduleValue = ext === ".ts" || ext === ".mts" || ext === ".cts" ? await loadTypeScriptModule(schemaPath, projectRoot) : await import(`${pathToFileURL2(schemaPath).href}?t=${Date.now()}-${Math.random()}`);
+  return extractSchema(moduleValue);
+}
+function extractSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error("Schema module must export an object.");
+  }
+  const moduleRecord = value;
+  const candidate = moduleRecord.default ?? moduleRecord;
+  if (!isSchemaDefinition(candidate)) {
+    throw new Error("Schema module must export a valid SchemaDefinition as default export.");
+  }
+  return candidate;
+}
+function isSchemaDefinition(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const object = value;
+  return typeof object.version === "number" && typeof object.collections === "object" && object.collections !== null && typeof object.relations === "object" && object.relations !== null;
+}
+async function loadTypeScriptModule(schemaPath, projectRoot) {
+  if (!await hasTsxInstalled(projectRoot)) {
+    throw new Error(
+      `Schema file is TypeScript (${schemaPath}) but local "tsx" was not found. Install tsx in the project.`
+    );
+  }
+  const script = "const modulePath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(modulePath).href)).then(mod => { const v = mod.default ?? mod; process.stdout.write(JSON.stringify(v)) }).catch(e => { process.stderr.write(String(e)); process.exit(1) })";
+  const output = await runCommand2(
+    process.execPath,
+    ["--import", "tsx", "--eval", script, schemaPath],
+    projectRoot
+  );
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Failed to parse schema module output for ${schemaPath}`);
+  }
+}
+async function runCommand2(command, args, cwd) {
+  return await new Promise((resolve6, reject) => {
+    const child = spawn2(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve6(stdout.trim());
+        return;
+      }
+      reject(
+        new Error(`Failed to load TypeScript schema (exit ${code ?? "unknown"}): ${stderr.trim()}`)
+      );
+    });
+  });
+}
+
+// src/commands/compact/compact-command.ts
+var compactCommand = defineCommand2({
+  meta: {
+    name: "compact",
+    description: "Compact the local Kora operation log after server ack"
+  },
+  args: {
+    db: {
+      type: "string",
+      description: "Path to the local SQLite database (required)"
+    },
+    schema: {
+      type: "string",
+      description: "Path to schema file"
+    },
+    strategy: {
+      type: "string",
+      description: "Compaction strategy: after-ack | after-days | never",
+      default: "after-ack"
+    },
+    days: {
+      type: "string",
+      description: "Age threshold when strategy is after-days",
+      default: "30"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      throw new InvalidProjectError(process.cwd());
+    }
+    const dbPath = typeof args.db === "string" ? resolve(projectRoot, args.db) : void 0;
+    if (!dbPath) {
+      throw new Error("Missing --db <path> to the local SQLite database file.");
+    }
+    const config = await loadKoraConfig(projectRoot);
+    const schemaPath = typeof args.schema === "string" ? resolve(projectRoot, args.schema) : typeof config?.schema === "string" ? resolve(projectRoot, config.schema) : void 0;
+    if (!schemaPath) {
+      throw new Error("Could not resolve schema path. Pass --schema <path>.");
+    }
+    const schema = await loadSchemaDefinition(schemaPath, projectRoot);
+    const { BetterSqlite3Adapter } = await import("@korajs/store/better-sqlite3");
+    const { Store } = await import("@korajs/store");
+    const strategyName = typeof args.strategy === "string" ? args.strategy : "after-ack";
+    const days = Number.parseInt(typeof args.days === "string" ? args.days : "30", 10);
+    const store = new Store({
+      schema,
+      adapter: new BetterSqlite3Adapter(dbPath)
+    });
+    await store.open();
+    let result;
+    if (strategyName === "never") {
+      result = await store.compact({ mode: "never" });
+    } else if (strategyName === "after-days") {
+      result = await store.compact({ mode: "after-days", days });
+    } else if (strategyName === "after-ack") {
+      result = await store.compact({ mode: "after-ack" });
+    } else {
+      await store.close();
+      throw new Error(`Unknown strategy "${strategyName}". Use after-ack, after-days, or never.`);
+    }
+    await store.close();
+    logger.banner();
+    logger.success(`Compacted ${result.deletedCount} operation log entries.`);
+    for (const [nodeId, seq] of result.watermark) {
+      logger.step(`  ${nodeId}: seq <= ${seq}`);
+    }
+  }
+});
+
+// src/commands/dev/dev-command.ts
+import { access as access2 } from "fs/promises";
+import { join as join4 } from "path";
+import { resolve as resolve2 } from "path";
+import { defineCommand as defineCommand3 } from "citty";
+
 // src/commands/dev/process-manager.ts
 import { spawn as spawnChild } from "child_process";
 var ProcessManager = class {
@@ -132,8 +448,8 @@ var ProcessManager = class {
     let resolveExit;
     const runningProcess = {
       child,
-      exitPromise: new Promise((resolve4) => {
-        resolveExit = resolve4;
+      exitPromise: new Promise((resolve6) => {
+        resolveExit = resolve6;
       }),
       stdoutBuffer: "",
       stderrBuffer: ""
@@ -200,15 +516,15 @@ var ProcessManager = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve4) => {
-    setTimeout(resolve4, ms);
+  return new Promise((resolve6) => {
+    setTimeout(resolve6, ms);
   });
 }
 
 // src/commands/dev/schema-watcher.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { watch } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var SchemaWatcher = class {
   constructor(config) {
     this.config = config;
@@ -236,7 +552,7 @@ var SchemaWatcher = class {
     this.watcher = null;
   }
   async regenerate() {
-    const koraBinJs = join2(
+    const koraBinJs = join3(
       this.config.projectRoot,
       "node_modules",
       "@korajs",
@@ -263,8 +579,8 @@ var SchemaWatcher = class {
   }
 };
 async function spawnCommand(command, args, cwd) {
-  await new Promise((resolve4, reject) => {
-    const child = spawn2(command, args, {
+  await new Promise((resolve6, reject) => {
+    const child = spawn3(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -280,7 +596,7 @@ async function spawnCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve4();
+        resolve6();
         return;
       }
       reject(new Error(`Type generation exited with code ${code ?? "unknown"}.`));
@@ -302,7 +618,7 @@ function toError(error) {
 }
 
 // src/commands/dev/dev-command.ts
-var devCommand = defineCommand({
+var devCommand = defineCommand3({
   meta: {
     name: "dev",
     description: "Start the Kora development environment"
@@ -342,7 +658,7 @@ var devCommand = defineCommand({
     const watchDebounceMs = typeof config?.dev?.watch === "object" && typeof config.dev.watch.debounceMs === "number" ? config.dev.watch.debounceMs : 300;
     const viteEntryPoint = await resolveProjectBinaryEntryPoint(projectRoot, "vite", "vite");
     if (!viteEntryPoint) {
-      throw new DevServerError("vite", join3(projectRoot, "node_modules", ".bin", "vite"));
+      throw new DevServerError("vite", join4(projectRoot, "node_modules", ".bin", "vite"));
     }
     const syncServerFile = await findSyncServerFile(projectRoot);
     let managedSyncStore = normalizeManagedSyncStore(config, projectRoot);
@@ -358,7 +674,7 @@ var devCommand = defineCommand({
     }
     if (shouldStartSync && syncServerFile === null && managedSyncStore) {
       const hasServerPackage = await fileExists(
-        join3(projectRoot, "node_modules", "@korajs", "server", "package.json")
+        join4(projectRoot, "node_modules", "@korajs", "server", "package.json")
       );
       if (!hasServerPackage) {
         logger.warn(
@@ -375,7 +691,7 @@ var devCommand = defineCommand({
     }
     let configuredSchemaPath = null;
     if (typeof config?.schema === "string") {
-      const candidate = resolve(projectRoot, config.schema);
+      const candidate = resolve2(projectRoot, config.schema);
       if (await fileExists(candidate)) {
         configuredSchemaPath = candidate;
       } else {
@@ -390,8 +706,8 @@ var devCommand = defineCommand({
     let schemaWatcher = null;
     let shuttingDown = false;
     let resolveFinished;
-    const finished = new Promise((resolve4) => {
-      resolveFinished = resolve4;
+    const finished = new Promise((resolve6) => {
+      resolveFinished = resolve6;
     });
     const onManagedProcessExit = () => {
       if (!processManager.hasRunning() && !shuttingDown) {
@@ -434,11 +750,15 @@ var devCommand = defineCommand({
       logger.step("  Schema watcher disabled (schema.ts not found)");
     }
     logger.blank();
+    logger.step("  Kora DevTools overlay: Ctrl+Shift+K (Cmd+Shift+K on macOS) when devtools: true");
     processManager.spawn({
       label: "vite",
       command: process.execPath,
       args: [viteEntryPoint, "--port", String(vitePort)],
       cwd: projectRoot,
+      env: {
+        KORA_DEV: "1"
+      },
       onExit: onManagedProcessExit
     });
     if (shouldStartSync && hasTsx && syncServerFile) {
@@ -489,7 +809,7 @@ var devCommand = defineCommand({
   }
 });
 async function findSyncServerFile(projectRoot) {
-  const candidates = [join3(projectRoot, "server.ts"), join3(projectRoot, "server.js")];
+  const candidates = [join4(projectRoot, "server.ts"), join4(projectRoot, "server.js")];
   for (const candidate of candidates) {
     try {
       await access2(candidate);
@@ -513,7 +833,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   const store = sync.store;
   if (store === void 0) return { type: "memory" };
   if (store === "memory") return { type: "memory" };
-  if (store === "sqlite") return { type: "sqlite", filename: join3(projectRoot, "kora-sync.db") };
+  if (store === "sqlite") return { type: "sqlite", filename: join4(projectRoot, "kora-sync.db") };
   if (store === "postgres") {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) return null;
@@ -522,7 +842,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   if (typeof store === "object" && store !== null) {
     if (store.type === "memory") return { type: "memory" };
     if (store.type === "sqlite") {
-      const filename = typeof store.filename === "string" && store.filename.length > 0 ? resolve(projectRoot, store.filename) : join3(projectRoot, "kora-sync.db");
+      const filename = typeof store.filename === "string" && store.filename.length > 0 ? resolve2(projectRoot, store.filename) : join4(projectRoot, "kora-sync.db");
       return { type: "sqlite", filename };
     }
     if (store.type === "postgres" && typeof store.connectionString === "string") {
@@ -585,17 +905,387 @@ process.stdout.write('Managed sync server running on ws://localhost:' + String(c
 await new Promise(() => {});
 `;
 
+// src/commands/doctor/doctor-command.ts
+import { defineCommand as defineCommand4 } from "citty";
+
+// src/commands/doctor/doctor-checks.ts
+import { access as access3, readFile as readFile2 } from "fs/promises";
+import { join as join5, resolve as resolve3 } from "path";
+var STATUS_ENDPOINT = "/__kora/status";
+async function runDoctorChecks(options) {
+  const { projectRoot } = options;
+  const results = [];
+  results.push({
+    id: "project-root",
+    title: "Project root",
+    status: "pass",
+    message: projectRoot
+  });
+  const config = await loadKoraConfig(projectRoot);
+  if (!config) {
+    results.push({
+      id: "kora-config",
+      title: "kora.config",
+      status: "warn",
+      message: "No kora.config.* file found.",
+      fix: "Add kora.config.ts with schema path and dev settings (see create-kora-app templates)."
+    });
+  } else {
+    results.push({
+      id: "kora-config",
+      title: "kora.config",
+      status: "pass",
+      message: "Configuration file loaded."
+    });
+  }
+  const schemaPath = await resolveSchemaPath(projectRoot, config?.schema);
+  if (!schemaPath) {
+    results.push({
+      id: "schema",
+      title: "Schema",
+      status: "fail",
+      message: "Could not find schema.ts in src/ or project root.",
+      fix: "Add src/schema.ts or set schema in kora.config.ts."
+    });
+  } else {
+    try {
+      const schema = await loadSchemaDefinition(schemaPath, projectRoot);
+      results.push({
+        id: "schema",
+        title: "Schema",
+        status: "pass",
+        message: `Loaded schema v${schema.version} (${Object.keys(schema.collections).length} collection(s)).`
+      });
+      const workerCheck = await checkWorkerFile(projectRoot);
+      results.push(workerCheck);
+      const depsCheck = await checkDependencies(projectRoot);
+      results.push(depsCheck);
+      results.push(opfsBrowserNote());
+      if (!options.skipNetwork) {
+        const syncUrl = options.syncHttpUrl ?? await resolveSyncHttpUrl(projectRoot, config);
+        const syncChecks = await checkSyncServer(syncUrl, schema);
+        results.push(...syncChecks);
+      } else {
+        results.push({
+          id: "sync-server",
+          title: "Sync server",
+          status: "skip",
+          message: "Network checks skipped."
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        id: "schema",
+        title: "Schema",
+        status: "fail",
+        message: `Failed to load schema: ${message}`,
+        fix: "Ensure the schema exports defineSchema() as default and TypeScript can be evaluated (install tsx)."
+      });
+    }
+  }
+  return results;
+}
+async function resolveSchemaPath(projectRoot, configSchema) {
+  if (typeof configSchema === "string") {
+    const resolved = resolve3(projectRoot, configSchema);
+    try {
+      await access3(resolved);
+      return resolved;
+    } catch {
+    }
+  }
+  return findSchemaFile(projectRoot);
+}
+async function checkWorkerFile(projectRoot) {
+  const candidates = [
+    join5(projectRoot, "src", "kora-worker.ts"),
+    join5(projectRoot, "src", "kora-worker.js")
+  ];
+  for (const path of candidates) {
+    try {
+      await access3(path);
+      return {
+        id: "worker",
+        title: "SQLite WASM worker",
+        status: "pass",
+        message: `Found ${path.replace(projectRoot, ".")}.`
+      };
+    } catch {
+    }
+  }
+  return {
+    id: "worker",
+    title: "SQLite WASM worker",
+    status: "warn",
+    message: "No src/kora-worker.ts found.",
+    fix: "Add kora-worker.ts and pass store.workerUrl from Vite (?worker&url) in createApp()."
+  };
+}
+async function checkDependencies(projectRoot) {
+  try {
+    const raw = await readFile2(join5(projectRoot, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const hasKora = Boolean(deps.korajs || deps.kora);
+    const hasStore = Boolean(deps["@korajs/store"]);
+    if (hasKora || hasStore) {
+      return {
+        id: "dependencies",
+        title: "Dependencies",
+        status: "pass",
+        message: hasKora ? "korajs is listed in package.json." : "@korajs/store is listed in package.json."
+      };
+    }
+    return {
+      id: "dependencies",
+      title: "Dependencies",
+      status: "fail",
+      message: "No korajs or @korajs/store dependency found.",
+      fix: "Run pnpm add korajs @korajs/react (or your package manager equivalent)."
+    };
+  } catch {
+    return {
+      id: "dependencies",
+      title: "Dependencies",
+      status: "fail",
+      message: "Could not read package.json.",
+      fix: "Run this command from a Kora app directory with a valid package.json."
+    };
+  }
+}
+function opfsBrowserNote() {
+  return {
+    id: "opfs",
+    title: "OPFS persistence",
+    status: "skip",
+    message: "OPFS availability is checked in the browser at runtime. Open the app and confirm no IndexedDB fallback warning in the console.",
+    fix: "Use a Chromium-based browser with storage access; avoid private mode if persistence fails."
+  };
+}
+async function resolveSyncHttpUrl(projectRoot, config) {
+  const envUrl = await readEnvSyncUrl(projectRoot);
+  if (envUrl) {
+    return toSyncStatusHttpBase(envUrl);
+  }
+  const syncPort = typeof config?.dev?.sync === "object" && typeof config.dev.sync.port === "number" ? config.dev.sync.port : 3001;
+  return `http://localhost:${syncPort}`;
+}
+async function readEnvSyncUrl(projectRoot) {
+  for (const file of [".env", ".env.local"]) {
+    const path = join5(projectRoot, file);
+    try {
+      const content = await readFile2(path, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const match = trimmed.match(/^VITE_SYNC_URL=(.+)$/);
+        if (match?.[1]) {
+          return match[1].trim().replace(/^["']|["']$/g, "");
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function toSyncStatusHttpBase(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "ws:") {
+      parsed.protocol = "http:";
+    } else if (parsed.protocol === "wss:") {
+      parsed.protocol = "https:";
+    }
+    parsed.pathname = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString().replace(/\/$/, "");
+  } catch {
+    return "http://localhost:3001";
+  }
+}
+async function checkSyncServer(httpBase, schema) {
+  const statusUrl = `${httpBase.replace(/\/$/, "")}${STATUS_ENDPOINT}`;
+  try {
+    const response = await fetch(statusUrl, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      return [
+        {
+          id: "sync-server",
+          title: "Sync server",
+          status: "fail",
+          message: `GET ${statusUrl} returned ${response.status}.`,
+          fix: "Start the sync server with `kora dev` or `pnpm run dev` in a sync template."
+        }
+      ];
+    }
+    const body = await response.json();
+    const results = [
+      {
+        id: "sync-server",
+        title: "Sync server",
+        status: "pass",
+        message: `Reachable at ${statusUrl} (server v${body.version ?? "unknown"}).`
+      }
+    ];
+    if (typeof body.schemaVersion === "number" && body.schemaVersion !== schema.version) {
+      results.push({
+        id: "schema-version",
+        title: "Schema version",
+        status: "warn",
+        message: `Client schema v${schema.version} differs from server schema v${body.schemaVersion}.`,
+        fix: "Run migrations on the server and client, or align schema.version before syncing."
+      });
+    } else {
+      results.push({
+        id: "schema-version",
+        title: "Schema version",
+        status: "pass",
+        message: `Client and server both use schema v${schema.version}.`
+      });
+    }
+    return results;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return [
+      {
+        id: "sync-server",
+        title: "Sync server",
+        status: "warn",
+        message: `Could not reach ${statusUrl}: ${detail}`,
+        fix: "Start the sync server, or pass --skip-network for local-only checks."
+      }
+    ];
+  }
+}
+function doctorHasFailures(results) {
+  return results.some((r) => r.status === "fail");
+}
+
+// src/commands/doctor/doctor-command.ts
+var doctorCommand = defineCommand4({
+  meta: {
+    name: "doctor",
+    description: "Check Kora project setup (schema, worker, sync server, versions)"
+  },
+  args: {
+    url: {
+      type: "string",
+      description: "Sync server HTTP base URL for status probe (default: from .env or localhost:3001)"
+    },
+    "skip-network": {
+      type: "boolean",
+      description: "Skip sync server and schema version network checks",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      throw new InvalidProjectError(process.cwd());
+    }
+    const syncHttpUrl = typeof args.url === "string" ? args.url : void 0;
+    const skipNetwork = args["skip-network"] === true;
+    logger.banner();
+    logger.info(`Checking project at ${projectRoot}`);
+    logger.blank();
+    const results = await runDoctorChecks({
+      projectRoot,
+      syncHttpUrl,
+      skipNetwork
+    });
+    for (const check of results) {
+      const prefix = check.status === "pass" ? "success" : check.status === "warn" ? "warn" : check.status === "fail" ? "error" : "step";
+      logger[prefix](`${check.title}: ${check.message}`);
+      if (check.fix && check.status !== "pass" && check.status !== "skip") {
+        logger.step(`  Fix: ${check.fix}`);
+      }
+    }
+    logger.blank();
+    if (doctorHasFailures(results)) {
+      logger.error("Doctor found blocking issues.");
+      process.exitCode = 1;
+      return;
+    }
+    const warnings = results.filter((r) => r.status === "warn").length;
+    if (warnings > 0) {
+      logger.warn(`Doctor finished with ${warnings} warning(s).`);
+    } else {
+      logger.success("All checks passed.");
+    }
+  }
+});
+
 // src/commands/generate/generate-command.ts
-import { mkdir, writeFile } from "fs/promises";
-import { dirname, resolve as resolve2 } from "path";
-import { defineCommand as defineCommand2 } from "citty";
-var generateCommand = defineCommand2({
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { dirname, resolve as resolve4 } from "path";
+import { defineCommand as defineCommand5 } from "citty";
+
+// src/commands/generate/hook-generator.ts
+function generateCollectionHooks(schema) {
+  const files = /* @__PURE__ */ new Map();
+  for (const collectionName of Object.keys(schema.collections)) {
+    const pascal = toPascalCase(collectionName);
+    const hookName = `use${pascal}`;
+    const content = [
+      "// Auto-generated by `kora generate hooks` \u2014 safe to edit",
+      `// Schema v${String(schema.version)}`,
+      "",
+      "import { useCollection, useMutation, useQuery } from '@korajs/react'",
+      `import type { ${pascal}InsertInput, ${pascal}Record, ${pascal}UpdateInput } from '../types'`,
+      "",
+      "/**",
+      ` * Collection hook for \`${collectionName}\`.`,
+      " * Add useQuery(...) calls with your QueryBuilder factories.",
+      " */",
+      `export function ${hookName}() {`,
+      `	const ${collectionName} = useCollection('${collectionName}')`,
+      "",
+      `	const insert = useMutation((data: ${pascal}InsertInput) => ${collectionName}.insert(data))`,
+      `	const update = useMutation((id: string, data: ${pascal}UpdateInput) =>`,
+      `		${collectionName}.update(id, data),`,
+      "	)",
+      `	const remove = useMutation((id: string) => ${collectionName}.delete(id))`,
+      "",
+      "	return {",
+      `		${collectionName},`,
+      "		insert,",
+      "		update,",
+      "		remove,",
+      "	}",
+      "}",
+      ""
+    ].join("\n");
+    files.set(`${collectionName}.ts`, content);
+  }
+  const indexLines = [
+    "// Auto-generated by `kora generate hooks`",
+    "",
+    ...Object.keys(schema.collections).map((name) => {
+      const pascal = toPascalCase(name);
+      return `export { use${pascal} } from './${name}'`;
+    }),
+    ""
+  ];
+  files.set("index.ts", indexLines.join("\n"));
+  return files;
+}
+function toPascalCase(value) {
+  return value.split(/[-_]/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+// src/commands/generate/generate-command.ts
+var generateCommand = defineCommand5({
   meta: {
     name: "generate",
     description: "Generate code from your Kora schema"
   },
   subCommands: {
-    types: defineCommand2({
+    types: defineCommand5({
       meta: {
         name: "types",
         description: "Generate TypeScript types from your schema"
@@ -619,7 +1309,7 @@ var generateCommand = defineCommand2({
         }
         let schemaPath;
         if (args.schema && typeof args.schema === "string") {
-          schemaPath = resolve2(args.schema);
+          schemaPath = resolve4(args.schema);
         } else {
           const found = await findSchemaFile(projectRoot);
           if (!found) {
@@ -634,7 +1324,7 @@ var generateCommand = defineCommand2({
         }
         logger.step(`Reading schema from ${schemaPath}...`);
         const schemaModule = await import(schemaPath);
-        const schema = extractSchema(schemaModule);
+        const schema = extractSchema2(schemaModule);
         if (!schema) {
           logger.error("Schema file must export a SchemaDefinition as the default export.");
           process.exitCode = 1;
@@ -642,31 +1332,193 @@ var generateCommand = defineCommand2({
         }
         const output = generateTypes(schema);
         const outputFile = typeof args.output === "string" ? args.output : "kora/generated/types.ts";
-        const outputPath = resolve2(projectRoot, outputFile);
+        const outputPath = resolve4(projectRoot, outputFile);
         await mkdir(dirname(outputPath), { recursive: true });
-        await writeFile(outputPath, output, "utf-8");
+        await writeFile2(outputPath, output, "utf-8");
         logger.success(`Generated types at ${outputPath}`);
       }
+    }),
+    hooks: defineCommand5({
+      meta: {
+        name: "hooks",
+        description: "Generate per-collection React hook stubs"
+      },
+      args: {
+        schema: {
+          type: "string",
+          description: "Path to schema file"
+        },
+        output: {
+          type: "string",
+          description: "Output directory for hooks",
+          default: "kora/generated/hooks"
+        },
+        types: {
+          type: "string",
+          description: "Relative import path to generated types from hook files",
+          default: "../types"
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const projectRoot = await findProjectRoot();
+        if (!projectRoot) {
+          throw new InvalidProjectError(process.cwd());
+        }
+        let schemaPath;
+        if (args.schema && typeof args.schema === "string") {
+          schemaPath = resolve4(projectRoot, args.schema);
+        } else {
+          const found = await findSchemaFile(projectRoot);
+          if (!found) {
+            throw new SchemaNotFoundError([
+              "src/schema.ts",
+              "schema.ts",
+              "src/schema.js",
+              "schema.js"
+            ]);
+          }
+          schemaPath = found;
+        }
+        const schema = await loadSchemaDefinition(schemaPath, projectRoot);
+        const outputDir = typeof args.output === "string" ? resolve4(projectRoot, args.output) : resolve4(projectRoot, "kora/generated/hooks");
+        const files = generateCollectionHooks(schema);
+        for (const [name, content] of files) {
+          const adjusted = typeof args.types === "string" && args.types !== "../types" ? content.replace("from '../types'", `from '${args.types}'`) : content;
+          const filePath = resolve4(outputDir, name);
+          await mkdir(dirname(filePath), { recursive: true });
+          await writeFile2(filePath, adjusted, "utf-8");
+        }
+        logger.success(`Generated ${String(files.size)} hook file(s) at ${outputDir}`);
+        logger.step("Run `kora generate types` first if ../types is missing.");
+      }
     })
   }
 });
-function extractSchema(mod) {
+function extractSchema2(mod) {
   if (typeof mod !== "object" || mod === null) return null;
   const record = mod;
   const candidate = record.default ?? record;
-  if (isSchemaDefinition(candidate)) return candidate;
+  if (isSchemaDefinition2(candidate)) return candidate;
   return null;
 }
-function isSchemaDefinition(value) {
+function isSchemaDefinition2(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
   return typeof obj.version === "number" && typeof obj.collections === "object" && obj.collections !== null;
 }
 
+// src/commands/logs/logs-command.ts
+import { defineCommand as defineCommand6 } from "citty";
+var DEFAULT_SYNC_PORT2 = 3001;
+var EVENTS_ENDPOINT = "/__kora/events";
+var logsCommand = defineCommand6({
+  meta: {
+    name: "logs",
+    description: "Stream real-time events from a Kora sync server"
+  },
+  args: {
+    url: {
+      type: "string",
+      description: "Sync server URL (default: http://localhost:3001)",
+      default: `http://localhost:${DEFAULT_SYNC_PORT2}`
+    },
+    follow: {
+      type: "boolean",
+      description: "Follow log output (like tail -f)",
+      default: true,
+      alias: "f"
+    },
+    level: {
+      type: "string",
+      description: "Filter by log level (info, warn, error)"
+    },
+    token: {
+      type: "string",
+      description: "Admin token (defaults to KORA_ADMIN_TOKEN)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT2}`;
+    const follow = args.follow !== false;
+    const levelFilter = typeof args.level === "string" ? args.level : null;
+    const token = typeof args.token === "string" ? args.token : process.env.KORA_ADMIN_TOKEN ?? void 0;
+    const eventsUrl = `${url.replace(/\/$/, "")}${EVENTS_ENDPOINT}`;
+    logger.banner();
+    logger.info(`Connecting to ${eventsUrl}...`);
+    logger.blank();
+    try {
+      const response = await fetch(eventsUrl, {
+        headers: token ? { Authorization: `Bearer ${token}` } : void 0
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to connect to ${eventsUrl}: ${response.status} ${response.statusText}`
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const processLine = (line) => {
+        if (line.startsWith("event: ")) {
+          return;
+        }
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          try {
+            const parsed = JSON.parse(data);
+            const level = String(parsed.level ?? "info");
+            if (levelFilter && level !== levelFilter) return;
+            const timestamp = parsed.timestamp ? new Date(parsed.timestamp).toISOString() : "";
+            const event = String(parsed.event ?? "unknown");
+            const nodeId = parsed.nodeId ? ` [${parsed.nodeId}]` : "";
+            const session = parsed.sessionId ? ` <${parsed.sessionId}>` : "";
+            const count = parsed.count ? ` (${parsed.count})` : "";
+            const error = parsed.error ? ` \u2014 ${parsed.error}` : "";
+            const prefix = level === "error" ? "\u2717" : level === "warn" ? "\u26A0" : "\u25CF";
+            const color = level === "error" ? "\x1B[31m" : level === "warn" ? "\x1B[33m" : "\x1B[36m";
+            console.log(
+              `${color}${prefix}${"\x1B[0m"} ${timestamp.slice(11, 23)} ${event}${nodeId}${session}${count}${error}`
+            );
+          } catch {
+          }
+        }
+      };
+      const read = async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            processLine(line.trim());
+          }
+          if (!follow) break;
+        }
+      };
+      await read();
+    } catch (error) {
+      logger.error(`Failed to connect to ${eventsUrl}`);
+      if (error instanceof Error) {
+        logger.error(error.message);
+      }
+      logger.blank();
+      logger.step("Make sure the Kora sync server is running.");
+      logger.step("Start it with: kora dev");
+      process.exit(1);
+    }
+  }
+});
+
 // src/commands/migrate/migrate-command.ts
-import { mkdir as mkdir2, readFile, readdir, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
-import { defineCommand as defineCommand3 } from "citty";
+import { mkdir as mkdir2, readFile as readFile3, readdir, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join6, resolve as resolve5 } from "path";
+import { defineCommand as defineCommand7 } from "citty";
 
 // src/commands/migrate/migration-generator.ts
 import { generateSQL } from "@korajs/core";
@@ -1231,83 +2083,34 @@ async function loadPostgresModule() {
   }
 }
 
-// src/commands/migrate/schema-loader.ts
-import { spawn as spawn3 } from "child_process";
-import { extname as extname2 } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-async function loadSchemaDefinition(schemaPath, projectRoot) {
-  const ext = extname2(schemaPath);
-  const moduleValue = ext === ".ts" || ext === ".mts" || ext === ".cts" ? await loadTypeScriptModule(schemaPath, projectRoot) : await import(`${pathToFileURL2(schemaPath).href}?t=${Date.now()}-${Math.random()}`);
-  return extractSchema2(moduleValue);
-}
-function extractSchema2(value) {
-  if (typeof value !== "object" || value === null) {
-    throw new Error("Schema module must export an object.");
-  }
-  const moduleRecord = value;
-  const candidate = moduleRecord.default ?? moduleRecord;
-  if (!isSchemaDefinition2(candidate)) {
-    throw new Error("Schema module must export a valid SchemaDefinition as default export.");
-  }
-  return candidate;
-}
-function isSchemaDefinition2(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const object = value;
-  return typeof object.version === "number" && typeof object.collections === "object" && object.collections !== null && typeof object.relations === "object" && object.relations !== null;
-}
-async function loadTypeScriptModule(schemaPath, projectRoot) {
-  if (!await hasTsxInstalled(projectRoot)) {
-    throw new Error(
-      `Schema file is TypeScript (${schemaPath}) but local "tsx" was not found. Install tsx in the project.`
-    );
-  }
-  const script = "const modulePath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(modulePath).href)).then(mod => { const v = mod.default ?? mod; process.stdout.write(JSON.stringify(v)) }).catch(e => { process.stderr.write(String(e)); process.exit(1) })";
-  const output = await runCommand2(
-    process.execPath,
-    ["--import", "tsx", "--eval", script, schemaPath],
-    projectRoot
-  );
-  try {
-    return JSON.parse(output);
-  } catch {
-    throw new Error(`Failed to parse schema module output for ${schemaPath}`);
-  }
-}
-async function runCommand2(command, args, cwd) {
-  return await new Promise((resolve4, reject) => {
-    const child = spawn3(command, args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: process.env
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString("utf-8");
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString("utf-8");
-    });
-    child.on("error", (error) => {
-      reject(error);
-    });
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve4(stdout.trim());
-        return;
-      }
-      reject(
-        new Error(`Failed to load TypeScript schema (exit ${code ?? "unknown"}): ${stderr.trim()}`)
-      );
-    });
-  });
+// src/commands/migrate/operation-transform-generator.ts
+function generateOperationTransformModule(fromVersion, toVersion) {
+  return [
+    "import type { Operation, OperationTransform } from '@korajs/core'",
+    "",
+    "/**",
+    ` * Operation transforms for schema v${fromVersion} \u2192 v${toVersion}.`,
+    " * Implement `transform` to rewrite or drop legacy operations during sync.",
+    " * @see https://korajs.dev/docs/migrations",
+    " */",
+    "export const operationTransforms: OperationTransform[] = [",
+    "  {",
+    `    fromVersion: ${fromVersion},`,
+    `    toVersion: ${toVersion},`,
+    "    transform(operation: Operation): Operation | null {",
+    "      // Return null to drop unmigratable operations.",
+    "      return operation",
+    "    },",
+    "  },",
+    "]",
+    ""
+  ].join("\n");
 }
 
 // src/commands/migrate/migrate-command.ts
 var SNAPSHOT_PATH = "kora/schema.snapshot.json";
 var MIGRATIONS_DIR = "kora/migrations";
-var migrateCommand = defineCommand3({
+var migrateCommand = defineCommand7({
   meta: {
     name: "migrate",
     description: "Detect schema changes and generate/apply migrations"
@@ -1349,12 +2152,12 @@ var migrateCommand = defineCommand3({
       throw new InvalidProjectError(process.cwd());
     }
     const config = await loadKoraConfig(projectRoot);
-    const resolvedSchemaPath = typeof args.schema === "string" ? resolve3(projectRoot, args.schema) : typeof config?.schema === "string" ? resolve3(projectRoot, config.schema) : await findSchemaFile(projectRoot);
+    const resolvedSchemaPath = typeof args.schema === "string" ? resolve5(projectRoot, args.schema) : typeof config?.schema === "string" ? resolve5(projectRoot, config.schema) : await findSchemaFile(projectRoot);
     if (!resolvedSchemaPath) {
       throw new SchemaNotFoundError(["src/schema.ts", "schema.ts", "src/schema.js", "schema.js"]);
     }
     const currentSchema = await loadSchemaDefinition(resolvedSchemaPath, projectRoot);
-    const snapshotFile = join4(projectRoot, SNAPSHOT_PATH);
+    const snapshotFile = join6(projectRoot, SNAPSHOT_PATH);
     const previousSchema = await readSchemaSnapshot(snapshotFile);
     if (!previousSchema) {
       if (args["dry-run"] === true) {
@@ -1367,7 +2170,7 @@ var migrateCommand = defineCommand3({
       return;
     }
     const diff = diffSchemas(previousSchema, currentSchema);
-    const outputDir = typeof args["output-dir"] === "string" ? resolve3(projectRoot, args["output-dir"]) : resolve3(projectRoot, MIGRATIONS_DIR);
+    const outputDir = typeof args["output-dir"] === "string" ? resolve5(projectRoot, args["output-dir"]) : resolve5(projectRoot, MIGRATIONS_DIR);
     if (!diff.hasChanges) {
       logger.success("No schema changes detected.");
       if (args.apply === true) {
@@ -1455,7 +2258,7 @@ var migrateCommand = defineCommand3({
 });
 async function readSchemaSnapshot(path) {
   try {
-    const content = await readFile(path, "utf-8");
+    const content = await readFile3(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1477,14 +2280,14 @@ function isInteractiveTerminal() {
 }
 async function writeSchemaSnapshot(path, schema) {
   await mkdir2(dirname2(path), { recursive: true });
-  await writeFile2(path, `${JSON.stringify(schema, null, 2)}
+  await writeFile3(path, `${JSON.stringify(schema, null, 2)}
 `, "utf-8");
 }
 async function writeMigrationFile(outputDir, fromVersion, toVersion, generated) {
   const existing = await readdir(outputDir).catch(() => []);
   const sequence = existing.filter((file) => /^\d{3}-/.test(file)).length + 1;
   const filename = `${String(sequence).padStart(3, "0")}-v${fromVersion}-to-v${toVersion}.ts`;
-  const path = join4(outputDir, filename);
+  const path = join6(outputDir, filename);
   const migrationId = filename.replace(/\.ts$/, "");
   const fileContent = [
     `export const up = ${JSON.stringify(generated.up, null, 2)} as const`,
@@ -1496,8 +2299,10 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
     `export const containsBreakingChanges = ${generated.containsBreakingChanges}`,
     ""
   ].join("\n");
-  await writeFile2(path, fileContent, "utf-8");
-  await writeMigrationManifest(join4(outputDir, `${migrationId}.json`), {
+  await writeFile3(path, fileContent, "utf-8");
+  const transformsPath = join6(outputDir, `${migrationId}.transforms.ts`);
+  await writeFile3(transformsPath, generateOperationTransformModule(fromVersion, toVersion), "utf-8");
+  await writeMigrationManifest(join6(outputDir, `${migrationId}.json`), {
     id: migrationId,
     fromVersion,
     toVersion,
@@ -1509,7 +2314,7 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
   return path;
 }
 async function writeMigrationManifest(path, manifest) {
-  await writeFile2(path, `${JSON.stringify(manifest, null, 2)}
+  await writeFile3(path, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 async function listMigrationManifests(outputDir) {
@@ -1518,13 +2323,13 @@ async function listMigrationManifests(outputDir) {
   const manifests = [];
   for (const file of migrationFiles) {
     const id = file.replace(/\.ts$/, "");
-    const manifestPath = join4(outputDir, `${id}.json`);
+    const manifestPath = join6(outputDir, `${id}.json`);
     const jsonManifest = await readMigrationManifest(manifestPath);
     if (jsonManifest) {
       manifests.push({ ...jsonManifest, id });
       continue;
     }
-    const migrationPath = join4(outputDir, file);
+    const migrationPath = join6(outputDir, file);
     const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
     manifests.push(sourceManifest);
   }
@@ -1532,7 +2337,7 @@ async function listMigrationManifests(outputDir) {
 }
 async function readMigrationManifest(path) {
   try {
-    const content = await readFile(path, "utf-8");
+    const content = await readFile3(path, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     const code = error.code;
@@ -1543,7 +2348,7 @@ async function readMigrationManifest(path) {
   }
 }
 async function readMigrationManifestFromSource(path, id) {
-  const content = await readFile(path, "utf-8");
+  const content = await readFile3(path, "utf-8");
   const versions = parseVersionsFromMigrationId(id);
   return {
     id,
@@ -1560,9 +2365,14 @@ function parseVersionsFromMigrationId(id) {
   if (!match) {
     throw new Error(`Migration id "${id}" does not include a vX-to-vY version suffix.`);
   }
+  const fromVersionText = match[1];
+  const toVersionText = match[2];
+  if (fromVersionText === void 0 || toVersionText === void 0) {
+    throw new Error(`Migration id "${id}" does not include a vX-to-vY version suffix.`);
+  }
   return {
-    fromVersion: Number.parseInt(match[1], 10),
-    toVersion: Number.parseInt(match[2], 10)
+    fromVersion: Number.parseInt(fromVersionText, 10),
+    toVersion: Number.parseInt(toVersionText, 10)
   };
 }
 function parseStringArrayExport(source, exportName) {
@@ -1600,18 +2410,18 @@ function parseLiteralExport(source, exportName) {
 }
 function resolveSqliteApplyPath(dbArg, projectRoot, config) {
   if (typeof dbArg === "string") {
-    return resolve3(projectRoot, dbArg);
+    return resolve5(projectRoot, dbArg);
   }
   const sync = config?.dev?.sync;
   if (typeof sync === "object" && sync !== null) {
     if (sync.store === "sqlite") {
-      return join4(projectRoot, "kora-sync.db");
+      return join6(projectRoot, "kora-sync.db");
     }
     if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "sqlite") {
       if (typeof sync.store.filename === "string" && sync.store.filename.length > 0) {
-        return resolve3(projectRoot, sync.store.filename);
+        return resolve5(projectRoot, sync.store.filename);
       }
-      return join4(projectRoot, "kora-sync.db");
+      return join6(projectRoot, "kora-sync.db");
     }
   }
   return void 0;
@@ -1628,18 +2438,155 @@ function resolvePostgresConnectionString(config) {
   return void 0;
 }
 
+// src/commands/status/status-command.ts
+import { defineCommand as defineCommand8 } from "citty";
+var DEFAULT_SYNC_PORT3 = 3001;
+var STATUS_ENDPOINT2 = "/__kora/status";
+async function fetchServerStatus(url, token) {
+  const statusUrl = `${url.replace(/\/$/, "")}${STATUS_ENDPOINT2}`;
+  const response = await fetch(statusUrl, {
+    headers: token ? { Authorization: `Bearer ${token}` } : void 0
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch status from ${statusUrl}: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours % 24 > 0) parts.push(`${hours % 24}h`);
+  if (minutes % 60 > 0) parts.push(`${minutes % 60}m`);
+  parts.push(`${seconds % 60}s`);
+  return parts.join(" ");
+}
+var statusCommand = defineCommand8({
+  meta: {
+    name: "status",
+    description: "Show Kora sync server status"
+  },
+  args: {
+    url: {
+      type: "string",
+      description: "Sync server URL (default: http://localhost:3001)",
+      default: `http://localhost:${DEFAULT_SYNC_PORT3}`
+    },
+    watch: {
+      type: "boolean",
+      description: "Live-updating status (like htop)",
+      default: false,
+      alias: "w"
+    },
+    token: {
+      type: "string",
+      description: "Admin token (defaults to KORA_ADMIN_TOKEN)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT3}`;
+    const watch2 = args.watch === true;
+    const token = typeof args.token === "string" ? args.token : process.env.KORA_ADMIN_TOKEN ?? void 0;
+    try {
+      if (watch2) {
+        console.clear();
+        logger.banner();
+        logger.info(`Connecting to ${url}...`);
+        const interval = setInterval(async () => {
+          try {
+            const status = await fetchServerStatus(url, token);
+            printStatus(status, url, logger);
+          } catch {
+          }
+        }, 2e3);
+        try {
+          const status = await fetchServerStatus(url, token);
+          printStatus(status, url, logger);
+        } catch {
+        }
+        await new Promise(() => {
+          process.on("SIGINT", () => {
+            clearInterval(interval);
+            process.exit(0);
+          });
+          process.on("SIGTERM", () => {
+            clearInterval(interval);
+            process.exit(0);
+          });
+        });
+      } else {
+        const status = await fetchServerStatus(url, token);
+        printStatus(status, url, logger);
+      }
+    } catch (error) {
+      logger.error(`Failed to connect to ${url}`);
+      if (error instanceof Error) {
+        logger.error(error.message);
+      }
+      logger.blank();
+      logger.step("Make sure the Kora sync server is running.");
+      logger.step("Start it with: kora dev");
+      process.exit(1);
+    }
+  }
+});
+function printStatus(status, url, logger) {
+  console.clear();
+  logger.banner();
+  logger.info(`Kora Sync Server \u2014 ${url}`);
+  logger.blank();
+  if (!status.running) {
+    logger.error("Server is not running");
+    return;
+  }
+  logger.step(`Status:     Running (uptime: ${formatUptime(status.uptime)}) \u2014 v${status.version}`);
+  logger.step(`Schema:     v${status.schemaVersion}`);
+  logger.blank();
+  logger.step(`Connections: ${status.connectedClients} connected`);
+  logger.step(`  Peak:      ${status.peakConnections}`);
+  logger.step(`  Total:     ${status.connectionsTotal}`);
+  if (status.connectedNodeIds.length > 0) {
+    logger.step("  Active nodes:");
+    for (const nodeId of status.connectedNodeIds) {
+      logger.step(`    \u2022 ${nodeId}`);
+    }
+  }
+  logger.blank();
+  logger.step("Operations:");
+  logger.step(`  Received:  ${status.operationsReceived.toLocaleString()}`);
+  logger.step(`  Sent:      ${status.operationsSent.toLocaleString()}`);
+  logger.step(`  Total:     ${status.totalOperations.toLocaleString()}`);
+  logger.blank();
+  if (status.errorCount > 0) {
+    logger.warn(`Errors: ${status.errorCount}`);
+  } else {
+    logger.step("Errors:     0");
+  }
+}
+
 // src/bin.ts
-var main = defineCommand4({
+var main = defineCommand9({
   meta: {
     name: "kora",
     description: "Kora.js \u2014 Offline-first application framework"
   },
   subCommands: {
+    backup: backupCommand,
+    compact: compactCommand,
     create: createCommand,
     dev: devCommand,
+    doctor: doctorCommand,
     deploy: deployCommand,
     generate: generateCommand,
-    migrate: migrateCommand
+    logs: logsCommand,
+    migrate: migrateCommand,
+    status: statusCommand
   }
 });
 runMain(main);