@open-mercato/cli 0.5.1-develop.2996.ce62fd491c → 0.5.1-develop.3036.f02c281f23

package/dist/mercato.js

@@ -248,6 +248,40 @@ function formatManagedProcessExitStatus(result) {
 function createManagedProcessExitError(result) {
   return new Error(`[server] ${result.label} exited unexpectedly with ${formatManagedProcessExitStatus(result)}.`);
 }
+function formatQueueWorkerLabel(queueNames) {
+  if (queueNames.length === 0) return "Queue worker";
+  const sorted = [...queueNames].sort((a, b) => a.localeCompare(b));
+  const preview = sorted.length > 4 ? `${sorted.slice(0, 4).join(", ")}, +${sorted.length - 4} more` : sorted.join(", ");
+  return `Queue worker (${preview})`;
+}
+function lookupModuleCommand(allModules, moduleName, commandName) {
+  const mod = allModules.find((entry) => entry.id === moduleName);
+  if (!mod) {
+    return { status: "missing-module" };
+  }
+  if (!mod.cli || mod.cli.length === 0) {
+    return { status: "missing-cli" };
+  }
+  const command = mod.cli.find((entry) => entry.command === commandName);
+  if (!command) {
+    return { status: "missing-command" };
+  }
+  return {
+    status: "ok",
+    module: mod,
+    command
+  };
+}
+function describeMissingModuleCommand(result) {
+  switch (result.status) {
+    case "missing-module":
+      return "module not enabled";
+    case "missing-cli":
+      return "module has no CLI commands";
+    case "missing-command":
+      return "command not found";
+  }
+}
 function ensureNextBuildIdInConfiguredDistDir(appDir) {
   const configuredDistDir = path.join(appDir, ".mercato", "next");
   const configuredBuildIdPath = path.join(configuredDistDir, "BUILD_ID");
@@ -304,36 +338,24 @@ async function handleDirectEjectCommand(args) {
   return 0;
 }
 async function runModuleCommand(allModules, moduleName, commandName, args = [], options = {}) {
-  const mod = allModules.find((m) => m.id === moduleName);
-  if (!mod) {
-    if (options.optional) {
-      if (!options.silentOptional) {
-        console.log(`\u23ED\uFE0F  Skipping "${moduleName}:${commandName}" \u2014 module not enabled`);
-      }
-      return false;
-    }
-    throw new Error(`Module not found: "${moduleName}"`);
-  }
-  if (!mod.cli || mod.cli.length === 0) {
+  const resolved = lookupModuleCommand(allModules, moduleName, commandName);
+  if (resolved.status !== "ok") {
     if (options.optional) {
       if (!options.silentOptional) {
-        console.log(`\u23ED\uFE0F  Skipping "${moduleName}:${commandName}" \u2014 module has no CLI commands`);
+        console.log(`\u23ED\uFE0F  Skipping "${moduleName}:${commandName}" \u2014 ${describeMissingModuleCommand(resolved)}`);
       }
       return false;
     }
-    throw new Error(`Module "${moduleName}" has no CLI commands`);
-  }
-  const cmd = mod.cli.find((c) => c.command === commandName);
-  if (!cmd) {
-    if (options.optional) {
-      if (!options.silentOptional) {
-        console.log(`\u23ED\uFE0F  Skipping "${moduleName}:${commandName}" \u2014 command not found`);
-      }
-      return false;
+    switch (resolved.status) {
+      case "missing-module":
+        throw new Error(`Module not found: "${moduleName}"`);
+      case "missing-cli":
+        throw new Error(`Module "${moduleName}" has no CLI commands`);
+      case "missing-command":
+        throw new Error(`Command "${commandName}" not found in module "${moduleName}"`);
     }
-    throw new Error(`Command "${commandName}" not found in module "${moduleName}"`);
   }
-  await cmd.run(args);
+  await resolved.command.run(args);
   return true;
 }
 async function runPostGenerateStructuralCachePurge(quiet) {
@@ -1355,8 +1377,8 @@ async function run(argv = process.argv) {
           const autoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS !== "false";
           const autoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER !== "false";
           const queueStrategy = process.env.QUEUE_STRATEGY || "local";
-          const runtimeEnv = buildServerProcessEnvironment(process.env);
           let didRetryCorruptedTurbopackCache = false;
+          const schedulerCommand = lookupModuleCommand(getCliModules(), "scheduler", "start");
           function cleanup() {
             console.log("[server] Shutting down...");
             for (const proc of processes) {
@@ -1370,7 +1392,7 @@ async function run(argv = process.argv) {
             await Promise.all(
               processes.map(
                 (proc) => new Promise((resolve) => {
-                  if (proc.exitCode !== null) return resolve();
+                  if (proc.exitCode !== null || proc.signalCode !== null) return resolve();
                   proc.on("exit", () => resolve());
                 })
               )
@@ -1392,7 +1414,7 @@ async function run(argv = process.argv) {
           const startNextDev = () => new Promise((resolve) => {
             const nextProcess = spawn("node", [nextBin, "dev", "--turbopack"], {
               stdio: ["inherit", "pipe", "pipe"],
-              env: runtimeEnv,
+              env: process.env,
               cwd: appDir
             });
             processes.push(nextProcess);
@@ -1437,22 +1459,26 @@ async function run(argv = process.argv) {
               console.log("[server] Starting workers for all queues...");
               const workerProcess = spawn("node", [mercatoBin, "queue", "worker", "--all"], {
                 stdio: "inherit",
-                env: runtimeEnv,
+                env: process.env,
                 cwd: appDir
               });
               processes.push(workerProcess);
-              managedExitPromises.push(waitForManagedProcessExit(workerProcess, "Queue worker"));
+              managedExitPromises.push(waitForManagedProcessExit(workerProcess, formatQueueWorkerLabel(discoveredWorkerQueues)));
             }
           }
           if (autoSpawnScheduler && queueStrategy === "local") {
-            console.log("[server] 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 (schedulerCommand.status !== "ok") {
+              console.log(`[server] Skipping scheduler auto-start \u2014 ${describeMissingModuleCommand(schedulerCommand)}`);
+            } else {
+              console.log("[server] Starting scheduler polling engine...");
+              const schedulerProcess = spawn("node", [mercatoBin, "scheduler", "start"], {
+                stdio: "inherit",
+                env: process.env,
+                cwd: appDir
+              });
+              processes.push(schedulerProcess);
+              managedExitPromises.push(waitForManagedProcessExit(schedulerProcess, "Scheduler polling engine"));
+            }
           }
           const firstExit = await Promise.race(managedExitPromises);
           await cleanupAndWait();
@@ -1474,13 +1500,14 @@ async function run(argv = process.argv) {
           const autoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER !== "false";
           const queueStrategy = process.env.QUEUE_STRATEGY || "local";
           const runtimeEnv = buildServerProcessEnvironment(process.env);
+          const schedulerCommand = lookupModuleCommand(getCliModules(), "scheduler", "start");
           const serverStartLock = acquireServerStartLock(appDir, {
             port: runtimeEnv.PORT ?? process.env.PORT ?? null
           });
           function cleanup() {
             console.log("[server] Shutting down...");
             for (const proc of processes) {
-              if (!proc.killed) {
+              if (!proc.killed && proc.exitCode === null && proc.signalCode === null) {
                 proc.kill("SIGTERM");
               }
             }
@@ -1490,7 +1517,7 @@ async function run(argv = process.argv) {
             await Promise.all(
               processes.map(
                 (proc) => new Promise((resolve) => {
-                  if (proc.exitCode !== null) return resolve();
+                  if (proc.exitCode !== null || proc.signalCode !== null) return resolve();
                   proc.on("exit", () => resolve());
                 })
               )
@@ -1509,6 +1536,9 @@ async function run(argv = process.argv) {
               cwd: appDir
             });
             processes.push(nextProcess);
+            const managedExitPromises = [
+              waitForManagedProcessExit(nextProcess, "Next.js production server")
+            ];
             if (autoSpawnWorkers) {
               const discoveredWorkerQueues = [...new Set(getRegisteredCliWorkers().map((worker) => worker.queue))];
               if (discoveredWorkerQueues.length === 0) {
@@ -1521,25 +1551,28 @@ async function run(argv = process.argv) {
                   cwd: appDir
                 });
                 processes.push(workerProcess);
+                managedExitPromises.push(waitForManagedProcessExit(workerProcess, formatQueueWorkerLabel(discoveredWorkerQueues)));
               }
             }
             if (autoSpawnScheduler && queueStrategy === "local") {
-              console.log("[server] Starting scheduler polling engine...");
-              const schedulerProcess = spawn("node", [mercatoBin, "scheduler", "start"], {
-                stdio: "inherit",
-                env: runtimeEnv,
-                cwd: appDir
-              });
-              processes.push(schedulerProcess);
+              if (schedulerCommand.status !== "ok") {
+                console.log(`[server] Skipping scheduler auto-start \u2014 ${describeMissingModuleCommand(schedulerCommand)}`);
+              } else {
+                console.log("[server] 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"));
+              }
             }
-            await Promise.race(
-              processes.map(
-                (proc) => new Promise((resolve) => {
-                  proc.on("exit", () => resolve());
-                })
-              )
-            );
+            const firstExit = await Promise.race(managedExitPromises);
             await cleanupAndWait();
+            if (!isExpectedManagedExitSignal(firstExit.signal)) {
+              throw createManagedProcessExitError(firstExit);
+            }
           } finally {
             serverStartLock.release();
           }