@korajs/cli 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/bin.js

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 import {
   createCommand
-} from "./chunk-BWTKRKNJ.js";
+} from "./chunk-Z7GCXMGW.js";
 import {
+  agentsCommand,
   deployCommand,
   generateTypes
-} from "./chunk-EOWLAAIV.js";
+} from "./chunk-4IKCHRJ6.js";
 import {
   DevServerError,
   InvalidProjectError,
   SchemaNotFoundError,
   createLogger,
   promptConfirm
-} from "./chunk-B5YS4STN.js";
+} from "./chunk-G2PBYMMA.js";
 import {
   loadSchemaDefinition
 } from "./chunk-6C4BHSRA.js";
@@ -361,6 +362,7 @@ var compactCommand = defineCommand2({
 });
 
 // src/commands/dev/dev-command.ts
+import { existsSync, readFileSync } from "fs";
 import { access as access2 } from "fs/promises";
 import { join as join4 } from "path";
 import { resolve as resolve2 } from "path";
@@ -371,6 +373,7 @@ import { spawn as spawnChild } from "child_process";
 var ProcessManager = class {
   processes = /* @__PURE__ */ new Map();
   spawn(config) {
+    this.processes.get(config.label)?.child.kill("SIGTERM");
     const options = {
       cwd: config.cwd,
       env: { ...process.env, ...config.env },
@@ -414,6 +417,20 @@ var ProcessManager = class {
   hasRunning() {
     return this.processes.size > 0;
   }
+  async restart(config) {
+    await this.stop(config.label);
+    this.spawn(config);
+  }
+  async stop(label) {
+    const running = this.processes.get(label);
+    if (!running) return;
+    running.child.kill("SIGTERM");
+    await Promise.race([running.exitPromise, delay(5e3)]);
+    const remaining = this.processes.get(label);
+    if (!remaining) return;
+    remaining.child.kill("SIGKILL");
+    await remaining.exitPromise;
+  }
   async shutdownAll() {
     const running = Array.from(this.processes.values());
     if (running.length === 0) return;
@@ -466,6 +483,7 @@ var SchemaWatcher = class {
   debounceMs;
   watcher = null;
   debounceTimer = null;
+  schemaVersion = null;
   start() {
     if (this.watcher) return;
     this.watcher = watch(this.config.schemaPath, () => {
@@ -474,6 +492,9 @@ var SchemaWatcher = class {
     this.watcher.on("error", (error) => {
       this.config.onError?.(toError(error));
     });
+    void this.refreshSchemaVersion().catch((error) => {
+      this.config.onError?.(toError(error));
+    });
   }
   stop() {
     if (this.debounceTimer) {
@@ -497,6 +518,15 @@ var SchemaWatcher = class {
     const args = hasTsx ? ["--import", "tsx", koraBinJs, "generate", "types", "--schema", this.config.schemaPath] : [koraBinJs, "generate", "types", "--schema", this.config.schemaPath];
     await spawnCommand(command, args, this.config.projectRoot);
     this.config.onRegenerate?.();
+    await this.refreshSchemaVersion();
+  }
+  async refreshSchemaVersion() {
+    const schema = await loadSchemaDefinition(this.config.schemaPath, this.config.projectRoot);
+    const previous = this.schemaVersion;
+    this.schemaVersion = schema.version;
+    if (previous !== null && previous !== schema.version) {
+      this.config.onSchemaVersionChange?.({ previous, next: schema.version });
+    }
   }
   scheduleRegeneration() {
     if (this.debounceTimer) {
@@ -581,6 +611,7 @@ var devCommand = defineCommand3({
     if (!projectRoot) {
       throw new InvalidProjectError(process.cwd());
     }
+    loadProjectEnv(projectRoot);
     const config = await loadKoraConfig(projectRoot);
     const vitePort = typeof args.port === "string" ? args.port : String(config?.dev?.port ?? 5173);
     const syncPortFromConfig = typeof config?.dev?.sync === "object" && typeof config.dev.sync.port === "number" ? config.dev.sync.port : 3001;
@@ -682,7 +713,9 @@ var devCommand = defineCommand3({
       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");
+    logger.step(
+      "  Kora DevTools overlay: Ctrl+Shift+K (Cmd+Shift+K on macOS) when devtools is enabled"
+    );
     processManager.spawn({
       label: "vite",
       command: process.execPath,
@@ -693,33 +726,31 @@ var devCommand = defineCommand3({
       },
       onExit: onManagedProcessExit
     });
-    if (shouldStartSync && hasTsx && syncServerFile) {
-      processManager.spawn({
-        label: "sync",
-        command: process.execPath,
-        args: ["--import", "tsx", syncServerFile],
-        cwd: projectRoot,
-        env: {
-          PORT: String(syncPort),
-          KORA_SYNC_PORT: String(syncPort)
-        },
-        onExit: onManagedProcessExit
-      });
-    }
-    if (shouldStartSync && syncServerFile === null && managedSyncStore !== null) {
-      processManager.spawn({
-        label: "sync",
-        command: process.execPath,
-        args: ["--input-type=module", "--eval", MANAGED_SYNC_BOOTSTRAP_SCRIPT],
-        cwd: projectRoot,
-        env: {
-          KORA_DEV_SYNC_CONFIG: JSON.stringify({
-            port: Number(syncPort),
-            store: managedSyncStore
-          })
-        },
-        onExit: onManagedProcessExit
-      });
+    const syncProcessConfig = shouldStartSync && hasTsx && syncServerFile ? {
+      label: "sync",
+      command: process.execPath,
+      args: ["--import", "tsx", syncServerFile],
+      cwd: projectRoot,
+      env: {
+        PORT: String(syncPort),
+        KORA_SYNC_PORT: String(syncPort)
+      },
+      onExit: onManagedProcessExit
+    } : shouldStartSync && syncServerFile === null && managedSyncStore !== null ? {
+      label: "sync",
+      command: process.execPath,
+      args: ["--input-type=module", "--eval", MANAGED_SYNC_BOOTSTRAP_SCRIPT],
+      cwd: projectRoot,
+      env: {
+        KORA_DEV_SYNC_CONFIG: JSON.stringify({
+          port: Number(syncPort),
+          store: managedSyncStore
+        })
+      },
+      onExit: onManagedProcessExit
+    } : null;
+    if (syncProcessConfig) {
+      processManager.spawn(syncProcessConfig);
     }
     if (watchEnabled && schemaPath) {
       schemaWatcher = new SchemaWatcher({
@@ -729,6 +760,16 @@ var devCommand = defineCommand3({
         onRegenerate: () => {
           logger.success("Regenerated types from schema changes");
         },
+        onSchemaVersionChange: ({ previous, next }) => {
+          if (!syncProcessConfig) {
+            logger.warn(
+              `Schema version changed from ${previous} to ${next}; restart your sync server before clients can sync.`
+            );
+            return;
+          }
+          logger.warn(`Schema version changed from ${previous} to ${next}; restarting sync server.`);
+          void processManager.restart(syncProcessConfig);
+        },
         onError: (error) => {
           logger.error(`Schema watcher error: ${error.message}`);
         }
@@ -759,6 +800,43 @@ async function fileExists(path) {
     return false;
   }
 }
+function loadProjectEnv(projectRoot, mode = "development") {
+  const files = [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`];
+  const existingKeys = new Set(Object.keys(process.env));
+  for (const file of files) {
+    const path = join4(projectRoot, file);
+    if (!existsSync(path)) continue;
+    const parsed = parseEnvFile(readFileSync(path, "utf8"));
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!existingKeys.has(key)) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+function parseEnvFile(contents) {
+  const env = {};
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const normalized = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const equalsIndex = normalized.indexOf("=");
+    if (equalsIndex <= 0) continue;
+    const key = normalized.slice(0, equalsIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    env[key] = parseEnvValue(normalized.slice(equalsIndex + 1).trim());
+  }
+  return env;
+}
+function parseEnvValue(value) {
+  const quote = value[0];
+  if ((quote === '"' || quote === "'") && value[value.length - 1] === quote) {
+    const inner = value.slice(1, -1);
+    return quote === '"' ? inner.replace(/\\n/g, "\n").replace(/\\r/g, "\r") : inner;
+  }
+  const commentIndex = value.search(/\s#/);
+  return (commentIndex >= 0 ? value.slice(0, commentIndex) : value).trim();
+}
 function normalizeManagedSyncStore(config, projectRoot) {
   const sync = config?.dev?.sync;
   if (typeof sync !== "object" || sync === null) return null;
@@ -1793,6 +1871,14 @@ function mapFieldType(descriptor) {
       return "INTEGER";
     case "array":
       return "TEXT";
+    case "object":
+      return "TEXT";
+    case "json":
+      return "TEXT";
+    case "blob":
+      return "TEXT";
+    case "secret":
+      return "TEXT";
     case "richtext":
       return "BLOB";
   }
@@ -1808,7 +1894,7 @@ function quoteIdentifier(identifier) {
   if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
     throw new Error(`Invalid SQL identifier: ${identifier}`);
   }
-  return identifier;
+  return `"${identifier}"`;
 }
 function formatChange(change) {
   switch (change.type) {
@@ -2503,7 +2589,7 @@ function printStatus(status, url, logger) {
 }
 
 // src/commands/studio/studio-command.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { resolve as resolve6 } from "path";
 import { defineCommand as defineCommand9 } from "citty";
 var studioCommand = defineCommand9({
@@ -2556,7 +2642,7 @@ var studioCommand = defineCommand9({
       }
       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 { SpectatorManager } = await import("./spectator-manager-FTH2NFSE.js");
       const spectator = new SpectatorManager({
         url: args.connect,
         schema,
@@ -2608,7 +2694,7 @@ var studioCommand = defineCommand9({
       );
     }
     const dbPath = resolve6(process.cwd(), args.db);
-    if (!existsSync(dbPath)) {
+    if (!existsSync2(dbPath)) {
       throw new Error(`Database file not found: ${dbPath}`);
     }
     const server = await startStudioServer({ port, dbPath });
@@ -2629,9 +2715,10 @@ var studioCommand = defineCommand9({
 var main = defineCommand10({
   meta: {
     name: "kora",
-    description: "Kora.js \u2014 Offline-first application framework"
+    description: "Kora.js, the offline-first application framework"
   },
   subCommands: {
+    "agents-md": agentsCommand,
     backup: backupCommand,
     compact: compactCommand,
     create: createCommand,