@holo-js/cli 0.1.9 → 0.2.1

package/dist/{chunk-ASTSSSL2.mjs → chunk-5TEH2QPK.mjs}

@@ -1,20 +1,20 @@
 import {
   prepareProjectDiscovery
-} from "./chunk-7JR73TOH.mjs";
+} from "./chunk-VP2E62DF.mjs";
 import {
   syncManagedDriverDependencies
-} from "./chunk-WRZFATUT.mjs";
+} from "./chunk-4OHJC3GL.mjs";
 import {
   ensureGeneratedSchemaPlaceholder,
   ensureProjectConfig
-} from "./chunk-SRPGIWCF.mjs";
+} from "./chunk-YEFJBN56.mjs";
 import {
   renderFrameworkRunner
-} from "./chunk-IMOGEKB4.mjs";
+} from "./chunk-J76GH2DR.mjs";
 import {
   readTextFile,
   writeTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/dev.ts
 import { spawnSync, spawn } from "child_process";
@@ -88,6 +88,29 @@ async function runProjectLifecycleScript(io, projectRoot, scriptName, spawn2 = s
     throw new Error(result.stderr?.trim() || result.stdout?.trim() || `Project script "${scriptName}" failed.`);
   }
 }
+async function runProjectStartServer(io, projectRoot, spawnProcess = spawn) {
+  const runnerPath = join(projectRoot, ".holo-js/framework/run.mjs");
+  const child = spawnProcess(process.execPath, [runnerPath, "start"], {
+    cwd: projectRoot,
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdout?.on("data", (chunk) => io.stdout.write(chunk));
+  child.stderr?.on("data", (chunk) => io.stderr.write(chunk));
+  if (child.stdin) {
+    io.stdin.pipe(child.stdin);
+  }
+  const result = await new Promise((resolvePromise) => {
+    child.on("error", (error) => resolvePromise({ kind: "error", error }));
+    child.on("close", (code) => resolvePromise({ kind: "close", code }));
+  });
+  if (result.kind === "error") {
+    throw result.error;
+  }
+  if (result.code !== 0) {
+    throw new Error(`Project production server failed with exit code ${result.code ?? "unknown"}.`);
+  }
+}
 async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync) {
   const invocation = await resolvePackageManagerInstallInvocation(projectRoot);
   const result = spawn2(invocation.command, [...invocation.args], {
@@ -105,22 +128,52 @@ async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync)
     throw new Error(result.stderr?.trim() || result.stdout?.trim() || "Project dependency installation failed.");
   }
 }
-async function runProjectPrepare(projectRoot, io) {
+var FRAMEWORK_SYNC_DEFINITIONS = [
+  {
+    framework: "nuxt",
+    commands: {
+      bun: ["bun", "x", "nuxt", "prepare"],
+      npm: ["npm", "exec", "--", "nuxt", "prepare"],
+      pnpm: ["pnpm", "exec", "nuxt", "prepare"],
+      yarn: ["yarn", "run", "nuxt", "prepare"]
+    },
+    errorLabel: "nuxt prepare"
+  },
+  {
+    framework: "sveltekit",
+    commands: {
+      bun: ["bun", "x", "svelte-kit", "sync"],
+      npm: ["npm", "exec", "--", "svelte-kit", "sync"],
+      pnpm: ["pnpm", "exec", "svelte-kit", "sync"],
+      yarn: ["yarn", "run", "svelte-kit", "sync"]
+    },
+    errorLabel: "svelte-kit sync"
+  }
+];
+async function runProjectPrepare(projectRoot, io, options = {}) {
   const project = await ensureProjectConfig(projectRoot);
   await ensureGeneratedSchemaPlaceholder(projectRoot, project.config);
   await prepareProjectDiscovery(projectRoot, project.config);
   await refreshFrameworkRunner(projectRoot);
-  await runNuxtPrepare(projectRoot);
-  await runSvelteKitSync(projectRoot);
+  const syncFramework = options.syncFramework ?? true;
+  if (syncFramework) {
+    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
+    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+  }
   const updatedDependencies = await syncManagedDriverDependencies(projectRoot);
   if (updatedDependencies && io) {
     await runProjectDependencyInstall(io, projectRoot);
     await prepareProjectDiscovery(projectRoot, project.config);
     await refreshFrameworkRunner(projectRoot);
-    await runNuxtPrepare(projectRoot);
-    await runSvelteKitSync(projectRoot);
+    if (syncFramework) {
+      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
+      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+    }
   }
 }
+async function runProjectHotPrepare(projectRoot, io) {
+  await runProjectPrepare(projectRoot, io, { syncFramework: false });
+}
 async function refreshFrameworkRunner(projectRoot) {
   const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
   const frameworkRunnerPath = resolve(projectRoot, ".holo-js/framework/run.mjs");
@@ -137,91 +190,23 @@ async function refreshFrameworkRunner(projectRoot) {
   }
   await writeTextFile(frameworkRunnerPath, renderFrameworkRunner({ framework }));
 }
-async function runNuxtPrepare(projectRoot) {
-  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
-  try {
-    const content = await readFile(frameworkProjectPath, "utf8");
-    const manifest = JSON.parse(content);
-    if (manifest.framework !== "nuxt") {
-      return;
-    }
-  } catch {
-    return;
-  }
-  const manager = await resolveProjectPackageManager(projectRoot);
-  let command;
-  let args;
-  switch (manager) {
-    case "npm":
-      command = "npm";
-      args = ["exec", "--", "nuxt", "prepare"];
-      break;
-    case "pnpm":
-      command = "pnpm";
-      args = ["exec", "nuxt", "prepare"];
-      break;
-    case "yarn":
-      command = "yarn";
-      args = ["run", "nuxt", "prepare"];
-      break;
-    case "bun":
-    default:
-      command = "bun";
-      args = ["x", "nuxt", "prepare"];
-      break;
-  }
-  const { spawn: spawn2 } = await import("child_process");
-  await new Promise((resolve2, reject) => {
-    const child = spawn2(command, args, {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve2(void 0);
-      } else {
-        reject(new Error(`nuxt prepare exited with ${code}`));
-      }
-    });
-    child.on("error", reject);
-  });
-}
-async function runSvelteKitSync(projectRoot) {
+async function runFrameworkSync(projectRoot, definition) {
   const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
   try {
     const content = await readFile(frameworkProjectPath, "utf8");
     const manifest = JSON.parse(content);
-    if (manifest.framework !== "sveltekit") {
+    if (manifest.framework !== definition.framework) {
       return;
     }
   } catch {
     return;
   }
   const manager = await resolveProjectPackageManager(projectRoot);
-  let command;
-  let args;
-  switch (manager) {
-    case "npm":
-      command = "npm";
-      args = ["exec", "--", "svelte-kit", "sync"];
-      break;
-    case "pnpm":
-      command = "pnpm";
-      args = ["exec", "svelte-kit", "sync"];
-      break;
-    case "yarn":
-      command = "yarn";
-      args = ["run", "svelte-kit", "sync"];
-      break;
-    case "bun":
-    default:
-      command = "bun";
-      args = ["x", "svelte-kit", "sync"];
-      break;
-  }
-  const { spawn: spawn2 } = await import("child_process");
+  const invocation = definition.commands[manager];
+  const command = invocation[0];
+  const args = invocation.slice(1);
   await new Promise((resolve2, reject) => {
-    const child = spawn2(command, args, {
+    const child = spawn(command, args, {
       cwd: projectRoot,
       stdio: "inherit"
     });
@@ -229,7 +214,7 @@ async function runSvelteKitSync(projectRoot) {
       if (code === 0) {
         resolve2(void 0);
       } else {
-        reject(new Error(`svelte-kit sync exited with ${code}`));
+        reject(new Error(`${definition.errorLabel} exited with ${code}`));
       }
     });
     child.on("error", reject);
@@ -253,23 +238,14 @@ function resolveConfiguredChannelsPath(project) {
   const configuredPaths = project.config.paths;
   return configuredPaths.channels ?? "server/channels";
 }
-function isDiscoveryRelevantPath(filePath, project) {
-  const normalized = toPosixSlashes(filePath);
-  if (PACKAGE_MANIFEST_DISCOVERY_PATHS.has(normalized)) {
-    return true;
-  }
-  const generatedSchemaPath = toPosixSlashes(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts");
-  if (normalized === generatedSchemaPath) {
-    return true;
-  }
-  if (normalized === ".holo-js/generated" || normalized.startsWith(".holo-js/generated/")) {
-    return false;
-  }
+function resolveConfiguredRealtimePath(project) {
+  const configuredPaths = project.config.paths;
+  return configuredPaths.realtime ?? "server/realtime";
+}
+function resolveConfiguredDiscoveryRoots(project) {
   const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
   const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
-  const broadcastPath = resolveConfiguredBroadcastPath(project);
-  const channelsPath = resolveConfiguredChannelsPath(project);
-  const roots = [
+  return [
     project.config.paths.models,
     project.config.paths.migrations,
     project.config.paths.seeders,
@@ -279,14 +255,28 @@ function isDiscoveryRelevantPath(filePath, project) {
     project.config.paths.listeners,
     authorizationPoliciesPath,
     authorizationAbilitiesPath,
-    broadcastPath,
-    channelsPath,
+    resolveConfiguredBroadcastPath(project),
+    resolveConfiguredChannelsPath(project),
+    resolveConfiguredRealtimePath(project),
     "config"
   ];
+}
+function isDiscoveryRelevantPath(filePath, project) {
+  const normalized = toPosixSlashes(filePath);
+  if (PACKAGE_MANIFEST_DISCOVERY_PATHS.has(normalized)) {
+    return true;
+  }
+  const generatedSchemaPath = toPosixSlashes(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts");
+  if (normalized === generatedSchemaPath) {
+    return true;
+  }
+  if (normalized === ".holo-js/generated" || normalized.startsWith(".holo-js/generated/")) {
+    return false;
+  }
   if (normalized === ".env" || normalized.startsWith(".env.")) {
     return true;
   }
-  return roots.some((root) => normalized === root || normalized.startsWith(`${toPosixSlashes(root)}/`));
+  return resolveConfiguredDiscoveryRoots(project).some((root) => normalized === root || normalized.startsWith(`${toPosixSlashes(root)}/`));
 }
 function isRecursiveWatchUnsupported(error) {
   return error instanceof Error && (error.message.includes("recursive") || "code" in error && error.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM");
@@ -310,24 +300,9 @@ async function collectDirectoryTree(rootPath, directories) {
 }
 async function collectDiscoveryWatchRoots(projectRoot, project) {
   const directories = /* @__PURE__ */ new Set();
-  const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
-  const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
-  const broadcastPath = resolveConfiguredBroadcastPath(project);
-  const channelsPath = resolveConfiguredChannelsPath(project);
   const roots = [
     projectRoot,
-    resolve(projectRoot, "config"),
-    resolve(projectRoot, project.config.paths.models),
-    resolve(projectRoot, project.config.paths.migrations),
-    resolve(projectRoot, project.config.paths.seeders),
-    resolve(projectRoot, project.config.paths.commands),
-    resolve(projectRoot, project.config.paths.jobs),
-    resolve(projectRoot, project.config.paths.events),
-    resolve(projectRoot, project.config.paths.listeners),
-    resolve(projectRoot, authorizationPoliciesPath),
-    resolve(projectRoot, authorizationAbilitiesPath),
-    resolve(projectRoot, broadcastPath),
-    resolve(projectRoot, channelsPath),
+    ...resolveConfiguredDiscoveryRoots(project).map((root) => resolve(projectRoot, root)),
     resolve(projectRoot, dirname(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts"))
   ];
   for (const rootPath of roots) {
@@ -342,12 +317,13 @@ async function runProjectDevServer(io, projectRoot, spawnProcess = spawn, create
   let project = await ensureProjectConfig(projectRoot);
   let refreshNonRecursiveWatchers;
   let requestChildRestart;
-  const prepareDiscovery = async () => {
-    await prepare(projectRoot, io);
+  const hotPrepare = prepare === runProjectPrepare ? runProjectHotPrepare : prepare;
+  const prepareDiscovery = async (syncFramework = false) => {
+    await (syncFramework ? prepare : hotPrepare)(projectRoot, io);
     project = await ensureProjectConfig(projectRoot);
     await refreshNonRecursiveWatchers?.();
   };
-  await prepareDiscovery();
+  await prepareDiscovery(true);
   let pendingPrepare;
   let queued = false;
   let shuttingDown = false;
@@ -482,6 +458,7 @@ export {
   resolvePackageManagerCommand,
   resolvePackageManagerInstallInvocation,
   runProjectLifecycleScript,
+  runProjectStartServer,
   runProjectDependencyInstall,
   runProjectPrepare,
   toPosixSlashes,

package/dist/{chunk-F4MT6GBK.mjs → chunk-FGQ2I2YH.mjs}

@@ -1,6 +1,6 @@
 import {
   readTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/package-json.ts
 import { join } from "path";

package/dist/chunk-I7QBCEV7.mjs

@@ -0,0 +1,33 @@
+// src/io.ts
+import { spinner } from "@clack/prompts";
+function writeLine(stream, message = "") {
+  stream.write(`${message}
+`);
+}
+async function runWithSpinner(io, message, task, successMessage = message) {
+  if (!supportsSpinner(io)) {
+    return task();
+  }
+  const loading = spinner({
+    input: io.stdin,
+    output: io.stdout
+  });
+  loading.start(message);
+  try {
+    const result = await task();
+    loading.stop(successMessage);
+    return result;
+  } catch (error) {
+    loading.error("Command failed.");
+    throw error;
+  }
+}
+function supportsSpinner(io) {
+  return io.stdin.isTTY === true && io.stdout.isTTY === true && typeof io.stdin.setRawMode === "function";
+}
+
+export {
+  writeLine,
+  runWithSpinner,
+  supportsSpinner
+};

package/dist/{chunk-R6BWRY3E.mjs → chunk-ILU426CF.mjs}

@@ -145,6 +145,7 @@ var GENERATED_EVENTS_PATH = join(GENERATED_ROOT, "events.ts");
 var GENERATED_LISTENERS_PATH = join(GENERATED_ROOT, "listeners.ts");
 var GENERATED_BROADCAST_PATH = join(GENERATED_ROOT, "broadcast.ts");
 var GENERATED_CHANNELS_PATH = join(GENERATED_ROOT, "channels.ts");
+var GENERATED_CHANNEL_IMPORTER_PATH = join(GENERATED_ROOT, "channel-importer.ts");
 var GENERATED_BROADCAST_MANIFEST_PATH = join(GENERATED_ROOT, "broadcast-manifest.ts");
 var GENERATED_AUTHORIZATION_ROOT = join(GENERATED_ROOT, "authorization");
 var GENERATED_AUTHORIZATION_REGISTRY_PATH = join(GENERATED_AUTHORIZATION_ROOT, "registry.ts");
@@ -162,7 +163,7 @@ var GENERATED_SVELTE_HOOKS_PATH = join(GENERATED_ROOT, "hooks.ts");
 var GENERATED_SVELTE_SERVER_HOOKS_PATH = join(GENERATED_ROOT, "hooks.server.ts");
 var CONFIG_EXTENSION_PRIORITY = [".ts", ".mts", ".js", ".mjs", ".cts", ".cjs"];
 var SUPPORTED_CONFIG_EXTENSIONS = new Set(CONFIG_EXTENSION_PRIORITY);
-var SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES = ["storage", "events", "queue", "validation", "forms", "auth", "authorization", "notifications", "mail", "broadcast", "security", "cache"];
+var SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES = ["storage", "events", "queue", "validation", "forms", "auth", "authorization", "notifications", "mail", "broadcast", "realtime", "security", "cache"];
 var SUPPORTED_QUEUE_INSTALLER_DRIVERS = ["sync", "redis", "database"];
 var SUPPORTED_CACHE_INSTALLER_DRIVERS = ["file", "redis", "database"];
 var HOLO_EVENT_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.events.definition");
@@ -447,6 +448,7 @@ export {
   GENERATED_LISTENERS_PATH,
   GENERATED_BROADCAST_PATH,
   GENERATED_CHANNELS_PATH,
+  GENERATED_CHANNEL_IMPORTER_PATH,
   GENERATED_BROADCAST_MANIFEST_PATH,
   GENERATED_AUTHORIZATION_REGISTRY_PATH,
   GENERATED_AUTHORIZATION_TYPES_PATH,