@open-mercato/cli 0.7.1-develop.7185.1.0f280ef1f1 → 0.7.1-develop.7186.1.6e080a5017

package/dist/lib/module-runtimes.js

@@ -0,0 +1,99 @@
+import {
+  moduleRuntimeAppliesTo
+} from "@open-mercato/shared/modules/runtime";
+const DEFAULT_START_TIMEOUT_MS = 3e4;
+const DEFAULT_STOP_TIMEOUT_MS = 3e4;
+const START_TIMEOUT_ENV_VAR = "OM_MODULE_RUNTIME_START_TIMEOUT_MS";
+const STOP_TIMEOUT_ENV_VAR = "OM_MODULE_RUNTIME_STOP_TIMEOUT_MS";
+class ModuleRuntimeTimeoutError extends Error {
+  constructor(moduleId, phase, timeoutMs) {
+    super(`Module "${moduleId}" did not ${phase} within ${timeoutMs}ms.`);
+    this.name = "ModuleRuntimeTimeoutError";
+  }
+}
+function resolveTimeoutMs(env, name, fallbackMs, log) {
+  const raw = env[name];
+  if (raw == null || raw.trim() === "") return fallbackMs;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    log(`[runtime] ignoring ${name}="${raw}": expected a positive number of milliseconds, using ${fallbackMs}ms`);
+    return fallbackMs;
+  }
+  return parsed;
+}
+async function withTimeout(work, timeoutMs, onTimeout) {
+  let timer;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(onTimeout()), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function startModuleRuntimes(options) {
+  const log = options.log ?? ((message) => console.log(message));
+  const env = options.env ?? process.env;
+  const startTimeoutMs = options.startTimeoutMs ?? resolveTimeoutMs(env, START_TIMEOUT_ENV_VAR, DEFAULT_START_TIMEOUT_MS, log);
+  const stopTimeoutMs = options.stopTimeoutMs ?? resolveTimeoutMs(env, STOP_TIMEOUT_ENV_VAR, DEFAULT_STOP_TIMEOUT_MS, log);
+  const controller = new AbortController();
+  const started = [];
+  const applicable = options.modules.filter((m) => Boolean(m.runtime) && moduleRuntimeAppliesTo(m.runtime, options.role)).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const stopStarted = async () => {
+    controller.abort();
+    for (const entry of [...started].reverse()) {
+      if (!entry.handle) continue;
+      try {
+        await withTimeout(
+          Promise.resolve(entry.handle.stop()),
+          stopTimeoutMs,
+          () => new ModuleRuntimeTimeoutError(entry.id, "stop", stopTimeoutMs)
+        );
+        log(`[runtime] stopped "${entry.id}"`);
+      } catch (error) {
+        log(`[runtime] "${entry.id}" failed to stop: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    started.length = 0;
+  };
+  for (const module of applicable) {
+    const startedAt = Date.now();
+    const starting = (async () => module.runtime.start({ container: options.container, role: options.role, signal: controller.signal }))();
+    try {
+      const handle = await withTimeout(
+        starting,
+        startTimeoutMs,
+        () => new ModuleRuntimeTimeoutError(module.id, "start", startTimeoutMs)
+      );
+      started.push({ id: module.id, handle });
+      log(`[runtime] started "${module.id}" (${options.role}, ${Date.now() - startedAt}ms)`);
+    } catch (error) {
+      if (error instanceof ModuleRuntimeTimeoutError) {
+        void starting.then((handle) => handle?.stop()).catch(() => {
+        });
+      }
+      await stopStarted();
+      throw error;
+    }
+  }
+  let stopping = null;
+  return {
+    started: started.map((entry) => entry.id),
+    stop: () => stopping ??= stopStarted()
+  };
+}
+function isProductionBuildPhase(env = process.env) {
+  return env.NEXT_PHASE === "phase-production-build";
+}
+export {
+  DEFAULT_START_TIMEOUT_MS,
+  DEFAULT_STOP_TIMEOUT_MS,
+  START_TIMEOUT_ENV_VAR,
+  STOP_TIMEOUT_ENV_VAR,
+  isProductionBuildPhase,
+  startModuleRuntimes
+};
+//# sourceMappingURL=module-runtimes.js.map

package/dist/lib/module-runtimes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/module-runtimes.ts"],
+  "sourcesContent": ["// Starting and stopping the module runtimes declared by `runtime.ts` (SPEC-072).\n//\n// Kept out of mercato.ts so the contract can be tested directly: the ordering, the failure\n// semantics, the shutdown and both timeouts are the whole substance of this hook, and none of\n// them are reachable through a CLI command in a test.\n\nimport type { AppContainer } from '@open-mercato/shared/lib/di/container'\nimport {\n  moduleRuntimeAppliesTo,\n  type ModuleRuntime,\n  type ModuleRuntimeHandle,\n  type ModuleRuntimeRole,\n} from '@open-mercato/shared/modules/runtime'\n\nexport const DEFAULT_START_TIMEOUT_MS = 30_000\nexport const DEFAULT_STOP_TIMEOUT_MS = 30_000\n\nexport const START_TIMEOUT_ENV_VAR = 'OM_MODULE_RUNTIME_START_TIMEOUT_MS'\nexport const STOP_TIMEOUT_ENV_VAR = 'OM_MODULE_RUNTIME_STOP_TIMEOUT_MS'\n\nexport type ModuleRuntimeCarrier = { id: string; runtime?: ModuleRuntime }\n\nexport type StartModuleRuntimesOptions = {\n  modules: ModuleRuntimeCarrier[]\n  container: AppContainer\n  role: ModuleRuntimeRole\n  /** One line per start and stop. Defaults to console. */\n  log?: (message: string) => void\n  /** Defaults to `OM_MODULE_RUNTIME_START_TIMEOUT_MS`, then 30s. */\n  startTimeoutMs?: number\n  /** Defaults to `OM_MODULE_RUNTIME_STOP_TIMEOUT_MS`, then 30s. */\n  stopTimeoutMs?: number\n  /** Where the timeout overrides are read from. Defaults to `process.env`. */\n  env?: NodeJS.ProcessEnv\n}\n\nexport type StartedModuleRuntimes = {\n  /** Module ids whose runtime is running, in start order. */\n  started: string[]\n  /** Aborts the shared signal, then stops each runtime in reverse start order. Idempotent. */\n  stop(): Promise<void>\n}\n\nclass ModuleRuntimeTimeoutError extends Error {\n  constructor(moduleId: string, phase: 'start' | 'stop', timeoutMs: number) {\n    super(`Module \"${moduleId}\" did not ${phase} within ${timeoutMs}ms.`)\n    this.name = 'ModuleRuntimeTimeoutError'\n  }\n}\n\n/**\n * Reads a timeout override, falling back to `fallbackMs` when it is unset or not a usable number.\n *\n * A start timeout is fatal by design (contract \u00A73), so an operator whose runtime legitimately needs\n * longer than the default \u2014 acquiring a lease, waiting on a broker \u2014 needs a supported way to say\n * so rather than a worker that exits non-zero on every boot. A malformed value falls back loudly:\n * refusing to start over a typo in a tuning knob would be worse than the default it replaces.\n */\nfunction resolveTimeoutMs(\n  env: NodeJS.ProcessEnv,\n  name: string,\n  fallbackMs: number,\n  log: (message: string) => void,\n): number {\n  const raw = env[name]\n  if (raw == null || raw.trim() === '') return fallbackMs\n  const parsed = Number(raw)\n  if (!Number.isFinite(parsed) || parsed <= 0) {\n    log(`[runtime] ignoring ${name}=\"${raw}\": expected a positive number of milliseconds, using ${fallbackMs}ms`)\n    return fallbackMs\n  }\n  return parsed\n}\n\n/**\n * Rejects if `work` outlives `timeoutMs`.\n *\n * The timer is always cleared, including on the winning path: an uncleared timer keeps the event\n * loop alive, so a CLI command that finished its work would hang until the timeout elapsed \u2014 the\n * kind of bug that only shows up as \"the process takes 30 seconds to exit\".\n */\nasync function withTimeout<T>(work: Promise<T>, timeoutMs: number, onTimeout: () => Error): Promise<T> {\n  let timer: NodeJS.Timeout | undefined\n  try {\n    return await Promise.race([\n      work,\n      new Promise<never>((_resolve, reject) => {\n        timer = setTimeout(() => reject(onTimeout()), timeoutMs)\n      }),\n    ])\n  } finally {\n    if (timer) clearTimeout(timer)\n  }\n}\n\n/**\n * Starts every module runtime that applies to this role, once.\n *\n * A throwing or timing-out `start` is fatal: the runtimes already started are stopped, and the\n * error is rethrown for the caller to exit on. A process that came up without a runtime it was\n * supposed to have looks healthy while doing nothing, which is worse than not coming up.\n */\nexport async function startModuleRuntimes(options: StartModuleRuntimesOptions): Promise<StartedModuleRuntimes> {\n  const log = options.log ?? ((message: string) => console.log(message))\n  const env = options.env ?? process.env\n  const startTimeoutMs = options.startTimeoutMs\n    ?? resolveTimeoutMs(env, START_TIMEOUT_ENV_VAR, DEFAULT_START_TIMEOUT_MS, log)\n  const stopTimeoutMs = options.stopTimeoutMs\n    ?? resolveTimeoutMs(env, STOP_TIMEOUT_ENV_VAR, DEFAULT_STOP_TIMEOUT_MS, log)\n\n  const controller = new AbortController()\n  const started: Array<{ id: string; handle: ModuleRuntimeHandle | void }> = []\n\n  // Sorted by module id so a failure is reproducible rather than dependent on registry order.\n  // Compared by code point rather than `localeCompare`, which depends on the host's default locale\n  // and ICU build \u2014 \"reproducible\" must not mean \"on machines with the same locale\".\n  //\n  // No dependency graph on purpose: a module that needs another module's runtime should depend on\n  // its service through DI, which already expresses that and already detects cycles.\n  const applicable = options.modules\n    .filter((m): m is ModuleRuntimeCarrier & { runtime: ModuleRuntime } =>\n      Boolean(m.runtime) && moduleRuntimeAppliesTo(m.runtime as ModuleRuntime, options.role))\n    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))\n\n  const stopStarted = async (): Promise<void> => {\n    controller.abort()\n    for (const entry of [...started].reverse()) {\n      if (!entry.handle) continue\n      try {\n        await withTimeout(\n          Promise.resolve(entry.handle.stop()),\n          stopTimeoutMs,\n          () => new ModuleRuntimeTimeoutError(entry.id, 'stop', stopTimeoutMs),\n        )\n        log(`[runtime] stopped \"${entry.id}\"`)\n      } catch (error) {\n        // A shutdown that cannot finish must not become a shutdown that never finishes: report and\n        // carry on to the next runtime, so one stuck module cannot hold the process open.\n        log(`[runtime] \"${entry.id}\" failed to stop: ${error instanceof Error ? error.message : String(error)}`)\n      }\n    }\n    started.length = 0\n  }\n\n  for (const module of applicable) {\n    const startedAt = Date.now()\n    // Called through an async wrapper so a `start` that throws synchronously rejects rather than\n    // escaping the try below, which would skip stopping the runtimes already started.\n    const starting = (async () =>\n      module.runtime.start({ container: options.container, role: options.role, signal: controller.signal }))()\n    try {\n      const handle = await withTimeout(\n        starting,\n        startTimeoutMs,\n        () => new ModuleRuntimeTimeoutError(module.id, 'start', startTimeoutMs),\n      )\n      started.push({ id: module.id, handle })\n      log(`[runtime] started \"${module.id}\" (${options.role}, ${Date.now() - startedAt}ms)`)\n    } catch (error) {\n      // A timed-out `start` keeps running: its handle was never pushed to `started`, so shutdown\n      // would not reach it. Trail the promise and release whatever it eventually hands back \u2014 and\n      // swallow a late rejection, which would otherwise surface as an unhandled rejection long\n      // after the error below has already been reported.\n      if (error instanceof ModuleRuntimeTimeoutError) {\n        void starting\n          .then((handle) => handle?.stop())\n          .catch(() => {})\n      }\n      await stopStarted()\n      throw error\n    }\n  }\n\n  let stopping: Promise<void> | null = null\n  return {\n    started: started.map((entry) => entry.id),\n    stop: () => (stopping ??= stopStarted()),\n  }\n}\n\n/**\n * True when this process is a Next production build.\n *\n * A build evaluates application code and must not acquire brokers, sockets or leases \u2014 and must\n * certainly not briefly own work it cannot finish. Hosts have been carrying this check by hand;\n * it belongs with the runner.\n *\n * At its only call site today \u2014 `mercato queue worker --all` \u2014 it is always false: `NEXT_PHASE` is\n * set by Next, not by a worker process. It guards the entry that matters once the `server` role\n * lands, where module code really is evaluated during `next build`; it is here so that entry\n * inherits the check rather than reinventing it.\n */\nexport function isProductionBuildPhase(env: NodeJS.ProcessEnv = process.env): boolean {\n  return env.NEXT_PHASE === 'phase-production-build'\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mercato.js

@@ -1,4 +1,5 @@
 import { registerWorkerShutdownHook, runWorker } from "@open-mercato/queue/worker";
+import { isProductionBuildPhase, startModuleRuntimes } from "./lib/module-runtimes.js";
 import { getCliModules, hasCliModules, registerCliModules } from "./registry.js";
 import { parseBooleanToken } from "@open-mercato/shared/lib/boolean";
 import { getSslConfig } from "@open-mercato/shared/lib/db/ssl";
@@ -1382,6 +1383,14 @@ async function run(argv = process.argv) {
               });
               console.log("[worker] Local scheduler started in the shared worker process.");
             }
+            if (!isProductionBuildPhase()) {
+              const runtimes = await startModuleRuntimes({
+                modules: getCliModules(),
+                container: await createRequestContainer(),
+                role: "worker"
+              });
+              if (runtimes.started.length > 0) registerWorkerShutdownHook(() => runtimes.stop());
+            }
             console.log("[worker] All workers started. Press Ctrl+C to stop");
             await new Promise(() => {
             });