@open-mercato/cli 0.6.4-develop.3949.1.adc3d0b3b1 → 0.6.4-develop.3962.1.70f30e284c

package/dist/mercato.js

@@ -322,6 +322,26 @@ function writeDevSplashRuntimeReady(reason) {
     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) => {
@@ -1551,55 +1571,65 @@ async function run(argv = process.argv) {
           const waitForDevRestart = () => new Promise((resolve) => {
             devRestartPromiseResolve = resolve;
           });
-          const startNextDev = (runtimeEnv) => 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
+          const startNextDev = (runtimeEnv) => {
+            let readyResolve = () => void 0;
+            const readyPromise = new Promise((resolve) => {
+              readyResolve = resolve;
             });
-            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;
-              }
-            };
-            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);
-                return resolve(await startNextDev(runtimeEnv));
-              }
-              resolve({
-                label: "Next.js dev server",
-                code,
-                signal
+            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
+                });
               });
             });
-          });
+            return { exitPromise, readyPromise };
+          };
           try {
             while (!stopping) {
               envReloader.reload();
@@ -1608,59 +1638,84 @@ 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 = [
-                startNextDev(runtimeEnv),
-                waitForDevRestart()
+                nextRuntime.exitPromise,
+                restartPromise,
+                backgroundExitPromise
               ];
-              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)));
+              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 (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"));
+                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 (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);
+                  }
+                }
+              };
+              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({