@korajs/cli 0.6.0 → 1.0.0-beta.0

package/dist/bin.js

@@ -1,25 +1,30 @@
 #!/usr/bin/env node
 import {
   createCommand
-} from "./chunk-EEZNRI5W.js";
+} from "./chunk-BWTKRKNJ.js";
 import {
   deployCommand,
   generateTypes
-} from "./chunk-Q2FBCOQD.js";
+} from "./chunk-EOWLAAIV.js";
 import {
   DevServerError,
   InvalidProjectError,
   SchemaNotFoundError,
   createLogger,
+  promptConfirm
+} from "./chunk-B5YS4STN.js";
+import {
+  loadSchemaDefinition
+} from "./chunk-6C4BHSRA.js";
+import {
   findProjectRoot,
   findSchemaFile,
   hasTsxInstalled,
-  promptConfirm,
   resolveProjectBinaryEntryPoint
-} from "./chunk-VLTPEATY.js";
+} from "./chunk-5NI2FEQL.js";
 
 // src/bin.ts
-import { defineCommand as defineCommand9, runMain } from "citty";
+import { defineCommand as defineCommand10, runMain } from "citty";
 
 // src/commands/backup/backup-command.ts
 import { readFile, writeFile } from "fs/promises";
@@ -247,7 +252,7 @@ async function loadTypeScriptConfig(configPath, projectRoot) {
   }
 }
 async function runCommand(command, args, cwd) {
-  return await new Promise((resolve6, reject) => {
+  return await new Promise((resolve7, reject) => {
     const child = spawn(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -266,7 +271,7 @@ async function runCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve6(stdout.trim());
+        resolve7(stdout.trim());
         return;
       }
       reject(new Error(`Failed to load kora config (exit ${code ?? "unknown"}): ${stderr.trim()}`));
@@ -284,79 +289,6 @@ 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: {
@@ -448,8 +380,8 @@ var ProcessManager = class {
     let resolveExit;
     const runningProcess = {
       child,
-      exitPromise: new Promise((resolve6) => {
-        resolveExit = resolve6;
+      exitPromise: new Promise((resolve7) => {
+        resolveExit = resolve7;
       }),
       stdoutBuffer: "",
       stderrBuffer: ""
@@ -516,13 +448,13 @@ var ProcessManager = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve6) => {
-    setTimeout(resolve6, ms);
+  return new Promise((resolve7) => {
+    setTimeout(resolve7, ms);
   });
 }
 
 // src/commands/dev/schema-watcher.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { watch } from "fs";
 import { join as join3 } from "path";
 var SchemaWatcher = class {
@@ -579,8 +511,8 @@ var SchemaWatcher = class {
   }
 };
 async function spawnCommand(command, args, cwd) {
-  await new Promise((resolve6, reject) => {
-    const child = spawn3(command, args, {
+  await new Promise((resolve7, reject) => {
+    const child = spawn2(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -596,7 +528,7 @@ async function spawnCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve6();
+        resolve7();
         return;
       }
       reject(new Error(`Type generation exited with code ${code ?? "unknown"}.`));
@@ -706,8 +638,8 @@ var devCommand = defineCommand3({
     let schemaWatcher = null;
     let shuttingDown = false;
     let resolveFinished;
-    const finished = new Promise((resolve6) => {
-      resolveFinished = resolve6;
+    const finished = new Promise((resolve7) => {
+      resolveFinished = resolve7;
     });
     const onManagedProcessExit = () => {
       if (!processManager.hasRunning() && !shuttingDown) {
@@ -1324,7 +1256,7 @@ var generateCommand = defineCommand5({
         }
         logger.step(`Reading schema from ${schemaPath}...`);
         const schemaModule = await import(schemaPath);
-        const schema = extractSchema2(schemaModule);
+        const schema = extractSchema(schemaModule);
         if (!schema) {
           logger.error("Schema file must export a SchemaDefinition as the default export.");
           process.exitCode = 1;
@@ -1395,14 +1327,14 @@ var generateCommand = defineCommand5({
     })
   }
 });
-function extractSchema2(mod) {
+function extractSchema(mod) {
   if (typeof mod !== "object" || mod === null) return null;
   const record = mod;
   const candidate = record.default ?? record;
-  if (isSchemaDefinition2(candidate)) return candidate;
+  if (isSchemaDefinition(candidate)) return candidate;
   return null;
 }
-function isSchemaDefinition2(value) {
+function isSchemaDefinition(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
   return typeof obj.version === "number" && typeof obj.collections === "object" && obj.collections !== null;
@@ -2570,8 +2502,131 @@ function printStatus(status, url, logger) {
   }
 }
 
+// src/commands/studio/studio-command.ts
+import { existsSync } from "fs";
+import { resolve as resolve6 } from "path";
+import { defineCommand as defineCommand9 } from "citty";
+var studioCommand = defineCommand9({
+  meta: {
+    name: "studio",
+    description: "Kora Studio: visualize records, operations, and sync \u2014 or run the sync lab"
+  },
+  args: {
+    db: {
+      type: "string",
+      description: "Path to a Kora SQLite database file (file mode, read-only)"
+    },
+    lab: {
+      type: "boolean",
+      description: "Start the interactive multi-device sync laboratory"
+    },
+    connect: {
+      type: "string",
+      description: "Spectator mode: WebSocket URL of a live Kora sync server (read-only replica)"
+    },
+    token: {
+      type: "string",
+      description: "Spectator mode: bearer token for the sync auth handshake"
+    },
+    devices: {
+      type: "string",
+      description: "Lab mode: number of initial devices (default 2)"
+    },
+    schema: {
+      type: "string",
+      description: "Lab mode: path to a schema file (defaults to a built-in demo schema)"
+    },
+    port: {
+      type: "string",
+      description: "Port for the Studio UI (default 4321, 0 for a random free port)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const port = args.port !== void 0 ? Number.parseInt(args.port, 10) : 4321;
+    if (Number.isNaN(port) || port < 0 || port > 65535) {
+      throw new Error(`Invalid port "${args.port}"`);
+    }
+    const { startStudioServer } = await import("./studio-server-NIFKZI4F.js");
+    if (typeof args.connect === "string") {
+      if (typeof args.schema !== "string") {
+        throw new Error(
+          "Spectator mode needs your schema to materialize records: kora studio --connect wss://\u2026 --schema ./kora/schema.ts"
+        );
+      }
+      const { loadSchemaDefinition: loadSchemaDefinition2 } = await import("./schema-loader-GGHECMTM.js");
+      const schema = await loadSchemaDefinition2(resolve6(process.cwd(), args.schema), process.cwd());
+      const { SpectatorManager } = await import("./spectator-manager-E2LH2P54.js");
+      const spectator = new SpectatorManager({
+        url: args.connect,
+        schema,
+        ...typeof args.token === "string" ? { token: args.token } : {}
+      });
+      await spectator.start();
+      const server2 = await startStudioServer({ port, spectator });
+      logger.banner();
+      logger.success(`Kora Studio SPECTATOR running at ${server2.url}`);
+      logger.step(`Watching ${args.connect} (read-only replica \u2014 nothing is ever pushed)`);
+      logger.step("Press Ctrl+C to stop.");
+      const shutdown2 = async () => {
+        await server2.close();
+        await spectator.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => void shutdown2());
+      process.on("SIGTERM", () => void shutdown2());
+      return;
+    }
+    if (args.lab) {
+      const { LabManager, defaultLabSchema } = await import("./lab-manager-KUDII6BT.js");
+      let schema = defaultLabSchema();
+      if (typeof args.schema === "string") {
+        const { loadSchemaDefinition: loadSchemaDefinition2 } = await import("./schema-loader-GGHECMTM.js");
+        schema = await loadSchemaDefinition2(resolve6(process.cwd(), args.schema), process.cwd());
+      }
+      const initialDevices = args.devices !== void 0 ? Math.max(1, Number.parseInt(args.devices, 10) || 2) : 2;
+      const lab = new LabManager(schema);
+      await lab.start(initialDevices);
+      const server2 = await startStudioServer({ port, lab });
+      logger.banner();
+      logger.success(`Kora Studio LAB running at ${server2.url}`);
+      logger.step(`${initialDevices} device(s) started against an in-process sync server.`);
+      logger.step("Everything in the lab is throwaway \u2014 experiment freely.");
+      logger.step("Press Ctrl+C to stop.");
+      const shutdown2 = async () => {
+        await server2.close();
+        await lab.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => void shutdown2());
+      process.on("SIGTERM", () => void shutdown2());
+      return;
+    }
+    if (typeof args.db !== "string") {
+      throw new Error(
+        "Pass --db <path> to inspect a database, --lab for the sync laboratory, or --connect <wss url> for live spectator mode."
+      );
+    }
+    const dbPath = resolve6(process.cwd(), args.db);
+    if (!existsSync(dbPath)) {
+      throw new Error(`Database file not found: ${dbPath}`);
+    }
+    const server = await startStudioServer({ port, dbPath });
+    logger.banner();
+    logger.success(`Kora Studio running at ${server.url}`);
+    logger.step(`Database: ${dbPath} (read-only)`);
+    logger.step("Press Ctrl+C to stop.");
+    const shutdown = async () => {
+      await server.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+  }
+});
+
 // src/bin.ts
-var main = defineCommand9({
+var main = defineCommand10({
   meta: {
     name: "kora",
     description: "Kora.js \u2014 Offline-first application framework"
@@ -2586,7 +2641,8 @@ var main = defineCommand9({
     generate: generateCommand,
     logs: logsCommand,
     migrate: migrateCommand,
-    status: statusCommand
+    status: statusCommand,
+    studio: studioCommand
   }
 });
 runMain(main);