@open-mercato/cli 0.6.4-canary.3993.1.739a4e21a9 → 0.6.4-develop.3926.1.c83e4d3395

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
-[build:cli] found 74 entry points
+[build:cli] found 73 entry points
 Copied create-app/agentic/ → dist/agentic/
 Discovered 16 standalone guides → dist/agentic/guides/
 [build:cli] built successfully

package/dist/mercato.js

@@ -25,7 +25,7 @@ import {
 import { parseModuleInstallArgs } from "./lib/module-install-args.js";
 import { resolveNextBuildIdCandidate } from "./lib/next-build-id.js";
 import { acquireServerStartLock } from "./lib/server-start-lock.js";
-import { createDevEnvReloader, watchDevEnvFiles } from "./lib/dev-env-reload.js";
+import { createDevEnvReloader, watchDevEnvFiles, watchDevRuntimeFiles } from "./lib/dev-env-reload.js";
 const lazyIntegration = () => import("./lib/testing/integration.js");
 import path from "node:path";
 import fs from "node:fs";
@@ -246,102 +246,6 @@ function buildServerProcessEnvironment(environment) {
   }
   return runtimeEnv;
 }
-function resolveDevRuntimeBaseUrl(environment = process.env) {
-  const configured = environment.APP_URL ?? environment.NEXT_PUBLIC_APP_URL ?? environment.NEXTAUTH_URL;
-  if (configured?.trim()) {
-    return configured.trim().replace(/\/+$/, "");
-  }
-  return `http://localhost:${environment.PORT?.trim() || "3000"}`;
-}
-function writeDevSplashChildState(state) {
-  if (process.env.OM_DEV_SPLASH_RUNTIME_WRAPPER === "1") return;
-  const stateFile = process.env.OM_DEV_SPLASH_CHILD_STATE_FILE;
-  if (!stateFile?.trim()) return;
-  try {
-    fs.mkdirSync(path.dirname(stateFile), { recursive: true });
-    fs.writeFileSync(stateFile, `${JSON.stringify({
-      mode: process.env.OM_DEV_SPLASH_MODE || "dev",
-      failed: false,
-      failureLines: [],
-      failureCommand: null,
-      ...state
-    }, null, 2)}
-`);
-  } catch {
-  }
-}
-function writeDevSplashRuntimeStarting(detail = "Starting Next.js dev server") {
-  writeDevSplashChildState({
-    phase: "Preparing app runtime",
-    detail,
-    ready: false,
-    readyUrl: null,
-    loginUrl: null,
-    progressLabel: "Launching app runtime",
-    activity: detail
-  });
-}
-function resolveSplashProgressFallback() {
-  const current = Number.parseInt(process.env.OM_DEV_SPLASH_STAGE_CURRENT ?? "", 10);
-  const total = Number.parseInt(process.env.OM_DEV_SPLASH_STAGE_TOTAL ?? "", 10);
-  if (Number.isFinite(current) && Number.isFinite(total) && total > 0) {
-    return { current, total };
-  }
-  if (process.env.OM_DEV_SPLASH_MODE === "greenfield" || process.env.OM_DEV_SPLASH_MODE === "setup") {
-    return { current: 5, total: 5 };
-  }
-  return { current: 3, total: 3 };
-}
-function writeDevSplashRuntimeRestarting(reason) {
-  const progress = resolveSplashProgressFallback();
-  writeDevSplashChildState({
-    phase: "App runtime is restarting",
-    detail: `Reason: ${reason}`,
-    ready: false,
-    readyUrl: null,
-    loginUrl: null,
-    progressCurrent: progress.current,
-    progressTotal: progress.total,
-    progressLabel: "Restarting app runtime",
-    activity: `App runtime restart: ${reason}`
-  });
-}
-function writeDevSplashRuntimeReady(reason) {
-  const readyUrl = resolveDevRuntimeBaseUrl();
-  const progress = resolveSplashProgressFallback();
-  writeDevSplashChildState({
-    phase: "App is ready",
-    detail: reason ? `Restart completed after ${reason}` : "Next.js dev server is ready",
-    ready: true,
-    readyUrl,
-    loginUrl: `${readyUrl}/login`,
-    progressCurrent: progress.current,
-    progressTotal: progress.total,
-    progressPercent: 100,
-    progressLabel: "App is ready",
-    activity: reason ? `Restart completed after ${reason}` : "App runtime is ready"
-  });
-}
-function resolveDevWarmupReadyTimeoutMs(environment = process.env) {
-  const parsed = Number.parseInt(environment.OM_DEV_WARMUP_READY_TIMEOUT_MS ?? "", 10);
-  if (Number.isFinite(parsed) && parsed >= 0) return parsed;
-  return 3e5;
-}
-async function waitForDevWarmupReadyFile(filePath, options = {}) {
-  const normalized = filePath?.trim();
-  if (!normalized) return "ready";
-  const timeoutMs = options.timeoutMs ?? resolveDevWarmupReadyTimeoutMs();
-  const startedAt = Date.now();
-  while (true) {
-    if (options.signal?.aborted) return "aborted";
-    try {
-      if (fs.existsSync(normalized)) return "ready";
-    } catch {
-    }
-    if (timeoutMs >= 0 && Date.now() - startedAt >= timeoutMs) return "timeout";
-    await new Promise((resolve) => setTimeout(resolve, 250));
-  }
-}
 function waitForManagedProcessExit(proc, label) {
   return new Promise((resolve) => {
     proc.on("exit", (code, signal) => {
@@ -541,17 +445,18 @@ async function runGeneratorSuite(quiet) {
 function createGenerateWatchChecksumFn() {
   return async () => {
     const { createResolver } = await import("./lib/resolver.js");
-    const { calculateGenerateWatchStructureChecksum } = await import("./lib/generate-watch-structure.js");
+    const { calculateStructureChecksum } = await import("./lib/utils.js");
     const resolver = createResolver();
-    const moduleRoots = [];
+    const tracked = /* @__PURE__ */ new Set([
+      path.join(resolver.getAppDir(), "src", "modules.ts"),
+      path.join(resolver.getAppDir(), "src", "modules")
+    ]);
     for (const entry of resolver.loadEnabledModules()) {
       const roots = resolver.getModulePaths(entry);
-      moduleRoots.push({ appBase: roots.appBase, pkgBase: roots.pkgBase });
+      tracked.add(roots.appBase);
+      tracked.add(roots.pkgBase);
     }
-    return calculateGenerateWatchStructureChecksum({
-      modulesFile: path.join(resolver.getAppDir(), "src", "modules.ts"),
-      moduleRoots
-    });
+    return calculateStructureChecksum(Array.from(tracked));
   };
 }
 async function buildAllModules() {
@@ -1489,7 +1394,6 @@ async function run(argv = process.argv) {
           let activeLazySupervisor = null;
           let activeLazySchedulerSupervisor = null;
           let activeGenerateWatcher = null;
-          let lastRestartReason = null;
           const generateWatcherMode = resolveGenerateWatcherMode(process.env);
           const envReloader = createDevEnvReloader(appDir, process.env, initialProcessEnvironmentEntries);
           function cleanup() {
@@ -1568,68 +1472,54 @@ async function run(argv = process.argv) {
               filePath
             });
           });
+          const stopRuntimeWatcher = watchDevRuntimeFiles(appDir, (filePath) => {
+            devRestartPromiseResolve?.({
+              label: "Runtime graph change",
+              restart: true,
+              filePath
+            });
+          });
           const waitForDevRestart = () => new Promise((resolve) => {
             devRestartPromiseResolve = resolve;
           });
-          const startNextDev = (runtimeEnv) => {
-            let readyResolve = () => void 0;
-            const readyPromise = new Promise((resolve) => {
-              readyResolve = resolve;
+          const startNextDev = (runtimeEnv) => new Promise((resolve) => {
+            const nextProcess = spawn("node", [nextBin, "dev", "--turbopack"], {
+              stdio: ["inherit", "pipe", "pipe"],
+              env: runtimeEnv,
+              cwd: appDir
             });
-            const exitPromise = new Promise((resolve) => {
-              writeDevSplashRuntimeStarting(
-                lastRestartReason ? `Restarting Next.js dev server. Reason: ${lastRestartReason}` : "Starting Next.js dev server"
-              );
-              const nextProcess = spawn("node", [nextBin, "dev", "--turbopack"], {
-                stdio: ["inherit", "pipe", "pipe"],
-                env: runtimeEnv,
-                cwd: appDir
-              });
-              processes.push(nextProcess);
-              let combinedOutput = "";
-              let reportedReady = false;
-              const appendOutput = (chunk) => {
-                combinedOutput += chunk;
-                if (combinedOutput.length > 32768) {
-                  combinedOutput = combinedOutput.slice(-32768);
-                }
-                if (!reportedReady && /\bready in\b/i.test(chunk)) {
-                  reportedReady = true;
-                  writeDevSplashRuntimeReady(lastRestartReason ?? void 0);
-                  lastRestartReason = null;
-                  readyResolve();
-                }
-              };
-              nextProcess.stdout?.on("data", (chunk) => {
-                const text = typeof chunk === "string" ? chunk : chunk.toString();
-                process.stdout.write(text);
-                appendOutput(text);
-              });
-              nextProcess.stderr?.on("data", (chunk) => {
-                const text = typeof chunk === "string" ? chunk : chunk.toString();
-                process.stderr.write(text);
-                appendOutput(text);
-              });
-              nextProcess.on("exit", async (code, signal) => {
-                if (!didRetryCorruptedTurbopackCache && isTurbopackCacheCorruption(combinedOutput)) {
-                  didRetryCorruptedTurbopackCache = true;
-                  lastRestartReason = "corrupted Turbopack dev cache";
-                  writeDevSplashRuntimeRestarting(lastRestartReason);
-                  console.log("[server] Detected corrupted Turbopack dev cache. Clearing .mercato/next/dev and restarting Next.js once...");
-                  removeTurbopackDevCache(appDir);
-                  const restarted = startNextDev(runtimeEnv);
-                  restarted.readyPromise.then(readyResolve);
-                  return resolve(await restarted.exitPromise);
-                }
-                resolve({
-                  label: "Next.js dev server",
-                  code,
-                  signal
-                });
+            processes.push(nextProcess);
+            let combinedOutput = "";
+            const appendOutput = (chunk) => {
+              combinedOutput += chunk;
+              if (combinedOutput.length > 32768) {
+                combinedOutput = combinedOutput.slice(-32768);
+              }
+            };
+            nextProcess.stdout?.on("data", (chunk) => {
+              const text = typeof chunk === "string" ? chunk : chunk.toString();
+              process.stdout.write(text);
+              appendOutput(text);
+            });
+            nextProcess.stderr?.on("data", (chunk) => {
+              const text = typeof chunk === "string" ? chunk : chunk.toString();
+              process.stderr.write(text);
+              appendOutput(text);
+            });
+            nextProcess.on("exit", async (code, signal) => {
+              if (!didRetryCorruptedTurbopackCache && isTurbopackCacheCorruption(combinedOutput)) {
+                didRetryCorruptedTurbopackCache = true;
+                console.log("[server] Detected corrupted Turbopack dev cache. Clearing .mercato/next/dev and restarting Next.js once...");
+                removeTurbopackDevCache(appDir);
+                return resolve(await startNextDev(runtimeEnv));
+              }
+              resolve({
+                label: "Next.js dev server",
+                code,
+                signal
               });
             });
-            return { exitPromise, readyPromise };
-          };
+          });
           try {
             while (!stopping) {
               envReloader.reload();
@@ -1638,84 +1528,59 @@ async function run(argv = process.argv) {
               const autoSpawnSchedulerMode = resolveAutoSpawnSchedulerMode(process.env);
               const queueStrategy = process.env.QUEUE_STRATEGY || "local";
               const schedulerCommand = lookupModuleCommand(getCliModules(), "scheduler", "start");
-              const nextRuntime = startNextDev(runtimeEnv);
-              const restartPromise = waitForDevRestart();
-              const backgroundStartAbort = new AbortController();
-              const cancelBackgroundStart = () => backgroundStartAbort.abort();
-              nextRuntime.exitPromise.finally(cancelBackgroundStart);
-              restartPromise.then(cancelBackgroundStart);
-              let backgroundExitResolve = () => void 0;
-              const backgroundExitPromise = new Promise((resolve) => {
-                backgroundExitResolve = resolve;
-              });
               const managedExitPromises = [
-                nextRuntime.exitPromise,
-                restartPromise,
-                backgroundExitPromise
+                startNextDev(runtimeEnv),
+                waitForDevRestart()
               ];
-              const startBackgroundServices = async () => {
-                if (stopping || backgroundStartAbort.signal.aborted) return;
-                const warmupReady = await waitForDevWarmupReadyFile(process.env.OM_DEV_WARMUP_READY_FILE, {
-                  timeoutMs: resolveDevWarmupReadyTimeoutMs(process.env),
-                  signal: backgroundStartAbort.signal
-                });
-                if (warmupReady === "aborted" || stopping || backgroundStartAbort.signal.aborted) return;
-                if (warmupReady === "timeout") {
-                  console.warn("[server] Timed out waiting for dev warmup marker; starting background services anyway.");
-                }
-                if (autoSpawnWorkersMode !== "off") {
-                  const discoveredWorkers = getRegisteredCliWorkers();
-                  const discoveredWorkerQueues = [...new Set(discoveredWorkers.map((worker) => worker.queue))];
-                  if (discoveredWorkerQueues.length === 0) {
-                    console.error("[server] AUTO_SPAWN_WORKERS is enabled, but no queues were discovered from CLI modules. Run `yarn generate` and verify `.mercato/generated/modules.cli.generated.ts` contains worker entries. Continuing without auto-spawned workers.");
-                  } else if (autoSpawnWorkersMode === "lazy") {
-                    console.log(`[server] Lazy worker auto-spawn enabled \u2014 workers will start on first job (${discoveredWorkerQueues.length} queue(s) watched).`);
-                    activeLazySupervisor = startLazyWorkerSupervisor({
-                      mercatoBin,
-                      appDir,
-                      runtimeEnv,
-                      workers: discoveredWorkers,
-                      pollMs: resolveLazyPollMs(process.env),
-                      restartOnUnexpectedExit: resolveLazyRestart(process.env)
-                    });
-                  } else {
-                    console.log("[server] Eager worker auto-spawn enabled - starting workers for all queues...");
-                    const workerProcess = spawn("node", [mercatoBin, "queue", "worker", "--all"], {
-                      stdio: "inherit",
-                      env: runtimeEnv,
-                      cwd: appDir
-                    });
-                    processes.push(workerProcess);
-                    waitForManagedProcessExit(workerProcess, formatQueueWorkerLabel(discoveredWorkerQueues)).then(backgroundExitResolve);
-                  }
+              if (autoSpawnWorkersMode !== "off") {
+                const discoveredWorkers = getRegisteredCliWorkers();
+                const discoveredWorkerQueues = [...new Set(discoveredWorkers.map((worker) => worker.queue))];
+                if (discoveredWorkerQueues.length === 0) {
+                  console.error("[server] AUTO_SPAWN_WORKERS is enabled, but no queues were discovered from CLI modules. Run `yarn generate` and verify `.mercato/generated/modules.cli.generated.ts` contains worker entries. Continuing without auto-spawned workers.");
+                } else if (autoSpawnWorkersMode === "lazy") {
+                  console.log(`[server] Lazy worker auto-spawn enabled \u2014 workers will start on first job (${discoveredWorkerQueues.length} queue(s) watched).`);
+                  activeLazySupervisor = startLazyWorkerSupervisor({
+                    mercatoBin,
+                    appDir,
+                    runtimeEnv,
+                    workers: discoveredWorkers,
+                    pollMs: resolveLazyPollMs(process.env),
+                    restartOnUnexpectedExit: resolveLazyRestart(process.env)
+                  });
+                } else {
+                  console.log("[server] Eager worker auto-spawn enabled - starting workers for all queues...");
+                  const workerProcess = spawn("node", [mercatoBin, "queue", "worker", "--all"], {
+                    stdio: "inherit",
+                    env: runtimeEnv,
+                    cwd: appDir
+                  });
+                  processes.push(workerProcess);
+                  managedExitPromises.push(waitForManagedProcessExit(workerProcess, formatQueueWorkerLabel(discoveredWorkerQueues)));
                 }
-                if (autoSpawnSchedulerMode !== "off" && queueStrategy === "local") {
-                  if (schedulerCommand.status !== "ok") {
-                    console.log(`[server] Skipping scheduler auto-start \u2014 ${describeMissingModuleCommand(schedulerCommand)}`);
-                  } else if (autoSpawnSchedulerMode === "lazy") {
-                    console.log("[server] Lazy scheduler auto-spawn enabled - scheduler will start when an enabled schedule exists.");
-                    activeLazySchedulerSupervisor = startLazySchedulerSupervisor({
-                      mercatoBin,
-                      appDir,
-                      runtimeEnv,
-                      pollMs: resolveLazySchedulerPollMs(process.env),
-                      restartOnUnexpectedExit: resolveLazySchedulerRestart(process.env)
-                    });
-                  } else {
-                    console.log("[server] Eager scheduler auto-spawn enabled - starting scheduler polling engine...");
-                    const schedulerProcess = spawn("node", [mercatoBin, "scheduler", "start"], {
-                      stdio: "inherit",
-                      env: runtimeEnv,
-                      cwd: appDir
-                    });
-                    processes.push(schedulerProcess);
-                    waitForManagedProcessExit(schedulerProcess, "Scheduler polling engine").then(backgroundExitResolve);
-                  }
+              }
+              if (autoSpawnSchedulerMode !== "off" && queueStrategy === "local") {
+                if (schedulerCommand.status !== "ok") {
+                  console.log(`[server] Skipping scheduler auto-start \u2014 ${describeMissingModuleCommand(schedulerCommand)}`);
+                } else if (autoSpawnSchedulerMode === "lazy") {
+                  console.log("[server] Lazy scheduler auto-spawn enabled - scheduler will start when an enabled schedule exists.");
+                  activeLazySchedulerSupervisor = startLazySchedulerSupervisor({
+                    mercatoBin,
+                    appDir,
+                    runtimeEnv,
+                    pollMs: resolveLazySchedulerPollMs(process.env),
+                    restartOnUnexpectedExit: resolveLazySchedulerRestart(process.env)
+                  });
+                } else {
+                  console.log("[server] Eager scheduler auto-spawn enabled - starting scheduler polling engine...");
+                  const schedulerProcess = spawn("node", [mercatoBin, "scheduler", "start"], {
+                    stdio: "inherit",
+                    env: runtimeEnv,
+                    cwd: appDir
+                  });
+                  processes.push(schedulerProcess);
+                  managedExitPromises.push(waitForManagedProcessExit(schedulerProcess, "Scheduler polling engine"));
                 }
-              };
-              nextRuntime.readyPromise.then(() => {
-                void startBackgroundServices();
-              });
+              }
               if (generateWatcherMode === "in-process") {
                 console.log("[server] In-process generate watcher enabled \u2014 structural changes will regenerate without a sidecar process.");
                 activeGenerateWatcher = startInProcessGenerateWatcher({
@@ -1736,10 +1601,6 @@ async function run(argv = process.argv) {
                 console.log("[server] Legacy out-of-process generate watcher selected via OM_DEV_GENERATE_WATCH_MODE=legacy \u2014 expect the dev orchestrator to spawn `mercato generate watch --skip-initial`.");
               }
               const firstExit = await Promise.race(managedExitPromises);
-              if (isDevServerRestartResult(firstExit)) {
-                lastRestartReason = `${firstExit.label.toLowerCase()} (${path.basename(firstExit.filePath)})`;
-                writeDevSplashRuntimeRestarting(lastRestartReason);
-              }
               await cleanupAndWait();
               devRestartPromiseResolve = null;
               if (isDevServerRestartResult(firstExit)) {
@@ -1753,6 +1614,7 @@ async function run(argv = process.argv) {
             }
           } finally {
             stopEnvWatcher();
+            stopRuntimeWatcher();
           }
         }
       },