@open-mercato/cli 0.5.1-develop.3032.01699048cb → 0.5.1-develop.3043.1a796c3920

package/dist/mercato.js

@@ -7,10 +7,12 @@ import { resolveInitDerivedSecrets } from "./lib/init-secrets.js";
 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";
 const lazyIntegration = () => import("./lib/testing/integration.js");
 import path from "node:path";
 import fs from "node:fs";
 let envLoaded = false;
+const initialProcessEnvironmentEntries = Object.entries(process.env);
 async function runWithCapturedExitCode(action) {
   const previousExitCode = process.exitCode;
   process.exitCode = void 0;
@@ -248,6 +250,43 @@ function formatManagedProcessExitStatus(result) {
 function createManagedProcessExitError(result) {
   return new Error(`[server] ${result.label} exited unexpectedly with ${formatManagedProcessExitStatus(result)}.`);
 }
+function isDevServerRestartResult(result) {
+  return "restart" in result && result.restart === true;
+}
+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 +343,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) {
@@ -1351,12 +1378,11 @@ async function run(argv = process.argv) {
           const env = resolveEnvironment();
           const appDir = env.appDir;
           const nodeModulesBases = Array.from(/* @__PURE__ */ new Set([env.rootDir, appDir]));
-          const processes = [];
-          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 processes = [];
           let didRetryCorruptedTurbopackCache = false;
+          let stopping = false;
+          let envChangePromiseResolve = null;
+          const envReloader = createDevEnvReloader(appDir, process.env, initialProcessEnvironmentEntries);
           function cleanup() {
             console.log("[server] Shutting down...");
             for (const proc of processes) {
@@ -1370,7 +1396,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());
                 })
               )
@@ -1380,16 +1406,33 @@ async function run(argv = process.argv) {
               fs.unlinkSync(lockFile);
             } catch {
             }
+            processes = [];
           }
-          process.on("SIGTERM", cleanup);
-          process.on("SIGINT", cleanup);
+          process.on("SIGTERM", () => {
+            stopping = true;
+            cleanup();
+          });
+          process.on("SIGINT", () => {
+            stopping = true;
+            cleanup();
+          });
           console.log("[server] Starting Open Mercato in dev mode...");
           const { createResolver: createResolverForSources } = await import("./lib/resolver.js");
           const { generateModulePackageSources } = await import("./lib/generators/index.js");
           await generateModulePackageSources({ resolver: createResolverForSources(), quiet: true });
           const nextBin = resolveInstalledBinary(nodeModulesBases, "next/dist/bin/next");
           const mercatoBin = resolveInstalledBinary(nodeModulesBases, "@open-mercato/cli/bin/mercato");
-          const startNextDev = () => new Promise((resolve) => {
+          const stopEnvWatcher = watchDevEnvFiles(appDir, (filePath) => {
+            envChangePromiseResolve?.({
+              label: "Environment file change",
+              restart: true,
+              filePath
+            });
+          });
+          const waitForEnvChange = () => new Promise((resolve) => {
+            envChangePromiseResolve = resolve;
+          });
+          const startNextDev = (runtimeEnv) => new Promise((resolve) => {
             const nextProcess = spawn("node", [nextBin, "dev", "--turbopack"], {
               stdio: ["inherit", "pipe", "pipe"],
               env: runtimeEnv,
@@ -1418,7 +1461,7 @@ async function run(argv = process.argv) {
                 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());
+                return resolve(await startNextDev(runtimeEnv));
               }
               resolve({
                 label: "Next.js dev server",
@@ -1427,37 +1470,61 @@ async function run(argv = process.argv) {
               });
             });
           });
-          const nextExitPromise = startNextDev();
-          const managedExitPromises = [nextExitPromise];
-          if (autoSpawnWorkers) {
-            const discoveredWorkerQueues = [...new Set(getRegisteredCliWorkers().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 {
-              console.log("[server] 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, "Queue worker"));
+          try {
+            while (!stopping) {
+              envReloader.reload();
+              const runtimeEnv = buildServerProcessEnvironment(process.env);
+              const autoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS !== "false";
+              const autoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER !== "false";
+              const queueStrategy = process.env.QUEUE_STRATEGY || "local";
+              const schedulerCommand = lookupModuleCommand(getCliModules(), "scheduler", "start");
+              const managedExitPromises = [
+                startNextDev(runtimeEnv),
+                waitForEnvChange()
+              ];
+              if (autoSpawnWorkers) {
+                const discoveredWorkerQueues = [...new Set(getRegisteredCliWorkers().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 {
+                  console.log("[server] 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 (autoSpawnScheduler && queueStrategy === "local") {
+                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"));
+                }
+              }
+              const firstExit = await Promise.race(managedExitPromises);
+              await cleanupAndWait();
+              envChangePromiseResolve = null;
+              if (isDevServerRestartResult(firstExit)) {
+                console.log(`[server] Detected environment file change (${path.basename(firstExit.filePath)}). Restarting app runtime...`);
+                continue;
+              }
+              if (!isExpectedManagedExitSignal(firstExit.signal)) {
+                throw createManagedProcessExitError(firstExit);
+              }
+              stopping = true;
             }
-          }
-          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"));
-          }
-          const firstExit = await Promise.race(managedExitPromises);
-          await cleanupAndWait();
-          if (!isExpectedManagedExitSignal(firstExit.signal)) {
-            throw createManagedProcessExitError(firstExit);
+          } finally {
+            stopEnvWatcher();
           }
         }
       },
@@ -1474,13 +1541,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 +1558,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 +1577,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 +1592,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();
           }