@open-mercato/cli 0.6.3-develop.3894.1.352abf4240 → 0.6.3

package/dist/mercato.js

@@ -246,6 +246,102 @@ 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) => {
@@ -445,18 +541,17 @@ async function runGeneratorSuite(quiet) {
 function createGenerateWatchChecksumFn() {
   return async () => {
     const { createResolver } = await import("./lib/resolver.js");
-    const { calculateStructureChecksum } = await import("./lib/utils.js");
+    const { calculateGenerateWatchStructureChecksum } = await import("./lib/generate-watch-structure.js");
     const resolver = createResolver();
-    const tracked = /* @__PURE__ */ new Set([
-      path.join(resolver.getAppDir(), "src", "modules.ts"),
-      path.join(resolver.getAppDir(), "src", "modules")
-    ]);
+    const moduleRoots = [];
     for (const entry of resolver.loadEnabledModules()) {
       const roots = resolver.getModulePaths(entry);
-      tracked.add(roots.appBase);
-      tracked.add(roots.pkgBase);
+      moduleRoots.push({ appBase: roots.appBase, pkgBase: roots.pkgBase });
     }
-    return calculateStructureChecksum(Array.from(tracked));
+    return calculateGenerateWatchStructureChecksum({
+      modulesFile: path.join(resolver.getAppDir(), "src", "modules.ts"),
+      moduleRoots
+    });
   };
 }
 async function buildAllModules() {
@@ -1390,10 +1485,11 @@ async function run(argv = process.argv) {
           let processes = [];
           let didRetryCorruptedTurbopackCache = false;
           let stopping = false;
-          let envChangePromiseResolve = null;
+          let devRestartPromiseResolve = null;
           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() {
@@ -1466,53 +1562,74 @@ async function run(argv = process.argv) {
           const nextBin = resolveInstalledBinary(nodeModulesBases, "next/dist/bin/next");
           const mercatoBin = resolveInstalledBinary(nodeModulesBases, "@open-mercato/cli/bin/mercato");
           const stopEnvWatcher = watchDevEnvFiles(appDir, (filePath) => {
-            envChangePromiseResolve?.({
+            devRestartPromiseResolve?.({
               label: "Environment file change",
               restart: true,
               filePath
             });
           });
-          const waitForEnvChange = () => new Promise((resolve) => {
-            envChangePromiseResolve = resolve;
+          const waitForDevRestart = () => new Promise((resolve) => {
+            devRestartPromiseResolve = resolve;
           });
-          const startNextDev = (runtimeEnv) => new Promise((resolve) => {
-            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 = "";
-            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
+            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();
@@ -1521,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),
-                waitForEnvChange()
+                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({
@@ -1594,10 +1736,14 @@ 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();
-              envChangePromiseResolve = null;
+              devRestartPromiseResolve = null;
               if (isDevServerRestartResult(firstExit)) {
-                console.log(`[server] Detected environment file change (${path.basename(firstExit.filePath)}). Restarting app runtime...`);
+                console.log(`[server] Detected ${firstExit.label.toLowerCase()} (${path.basename(firstExit.filePath)}). Restarting app runtime...`);
                 continue;
               }
               if (!isExpectedManagedExit(firstExit, { stopping })) {