@nmakarov/cli-toolkit 0.53.0 → 0.57.0

package/dist/deploy.cjs

@@ -38,6 +38,8 @@ __export(deploy_exports, {
   initServiceStructure: () => initServiceStructure,
   installDeps: () => installDeps,
   installOperatorShell: () => installOperatorShell,
+  isFreshOnline: () => isFreshOnline,
+  isPidAlive: () => isPidAlive,
   listReleases: () => listReleases,
   loadServices: () => loadServices,
   npmEnv: () => npmEnv,
@@ -129,6 +131,8 @@ function servicePaths(service) {
     current: (0, import_node_path.join)(root, "current"),
     sharedEnv: (0, import_node_path.join)(root, "shared", ".env"),
     ecosystem: (0, import_node_path.join)(root, "shared", "ecosystem.config.cjs"),
+    /** Preloaded by pm2 `node_args --require` so ENV survives flaky restarts. */
+    ensureEnv: (0, import_node_path.join)(root, "shared", "ensure-env.cjs"),
     deployLog: (0, import_node_path.join)(root, "logs", "deploy.log"),
     lockHashFile: (0, import_node_path.join)(root, "shared", ".package-lock.sha256")
   };
@@ -447,6 +451,16 @@ async function pruneReleases(service, paths, options = {}) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function isPidAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 0) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function getPm2Process(appName, options = {}) {
   const { logger } = options;
   const { stdout } = await runCapture("bash", ["-lc", "pm2 jlist"], { logger });
@@ -483,21 +497,44 @@ async function waitPm2(appName, predicate, options = {}) {
     `pm2 wait timed out after ${timeoutMs}ms for ${appName} (${label}); last status=${lastStatus}`
   );
 }
+function isFreshOnline(proc, oldPid) {
+  if (proc?.pm2_env?.status !== "online") return false;
+  const pid = Number(proc.pid);
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  if (oldPid != null) {
+    if (pid === oldPid) return false;
+    if (isPidAlive(oldPid)) return false;
+  }
+  return true;
+}
 async function reloadPm2(paths, options = {}) {
   const { dryRun = false, logger = console, appName = null, waitTimeoutMs = 65e3 } = options;
   if (dryRun) {
     logger.info(`[dryRun] would pm2 startOrReload ${paths.ecosystem} --update-env`);
     return;
   }
+  let oldPid = null;
+  if (appName) {
+    const before = await getPm2Process(appName, { logger });
+    const n = Number(before?.pid);
+    if (Number.isFinite(n) && n > 0 && before?.pm2_env?.status === "online") {
+      oldPid = n;
+      logger.info(`pm2 ${appName}: reloading (old pid=${oldPid})`);
+    }
+  }
   await runShell(`pm2 startOrReload "${paths.ecosystem}" --update-env`, { logger });
   logger.info("pm2 reloaded");
   if (appName) {
-    await waitPm2(
+    const proc = await waitPm2(
       appName,
-      (proc) => proc?.pm2_env?.status === "online",
-      { timeoutMs: waitTimeoutMs, logger, label: "online after reload" }
+      (p) => isFreshOnline(p, oldPid),
+      {
+        timeoutMs: waitTimeoutMs,
+        logger,
+        label: oldPid ? `online on new pid (old ${oldPid} gone)` : "online after reload"
+      }
     );
-    logger.info(`pm2 ${appName} online`);
+    logger.info(`pm2 ${appName} online pid=${proc?.pid ?? "?"}`);
   }
 }
 async function stopPm2(appName, options = {}) {
@@ -515,10 +552,15 @@ async function stopPm2(appName, options = {}) {
     logger.info(`pm2 ${appName}: already stopped`);
     return;
   }
+  const oldPid = Number(before.pid);
   await runShell(`pm2 stop "${appName}"`, { logger });
   await waitPm2(
     appName,
-    (proc) => !proc || proc.pm2_env?.status === "stopped",
+    (proc) => {
+      if (proc && proc.pm2_env?.status !== "stopped") return false;
+      if (Number.isFinite(oldPid) && oldPid > 0 && isPidAlive(oldPid)) return false;
+      return true;
+    },
     { timeoutMs: waitTimeoutMs, logger, label: "stopped" }
   );
   logger.info(`pm2 ${appName} stopped`);
@@ -532,12 +574,12 @@ async function startPm2(paths, options = {}) {
   await runShell(`pm2 start "${paths.ecosystem}" --update-env`, { logger });
   logger.info("pm2 started");
   if (appName) {
-    await waitPm2(
+    const proc = await waitPm2(
       appName,
-      (proc) => proc?.pm2_env?.status === "online",
+      (p) => isFreshOnline(p, null),
       { timeoutMs: waitTimeoutMs, logger, label: "online after start" }
     );
-    logger.info(`pm2 ${appName} online`);
+    logger.info(`pm2 ${appName} online pid=${proc?.pid ?? "?"}`);
   }
 }
 
@@ -781,12 +823,23 @@ function resolvePm2Args(pm2) {
   if (/(?:^|\s)--stopAllowance=/.test(base)) return base;
   return `${base}${base ? " " : ""}--stopAllowance=${Math.floor(stopSec)}`.trim();
 }
+function buildEnsureEnvScript() {
+  return `/**
+ * Written by cli-toolkit deploy (init-structure). Do not hand-edit.
+ * Preloaded via pm2 node_args --require so Args sees ENV=production even when
+ * a post-SIGKILL restart briefly omits ecosystem env (otherwise Db \u2192 local:6032).
+ */
+if (!process.env.ENV) process.env.ENV = "production";
+if (!process.env.NODE_ENV) process.env.NODE_ENV = "production";
+`;
+}
 function buildEcosystemConfig(service, paths) {
   const { pm2 } = service;
   const outLog = (0, import_node_path8.join)(paths.logs, `${pm2.appName}.out.log`);
   const errLog = (0, import_node_path8.join)(paths.logs, `${pm2.appName}.err.log`);
   const killTimeoutMs = resolveKillTimeoutMs(pm2);
   const args = resolvePm2Args(pm2);
+  const ensureEnv = paths.ensureEnv;
   return `/**
  * pm2 ecosystem for ${service.name} \u2014 written by cli-toolkit deploy from the
  * service manifest (init/deploy). Do not hand-edit; change pm2.* in the
@@ -799,6 +852,8 @@ module.exports = {
             script: "${pm2.script}",
             cwd: "${paths.current}",
             args: ${JSON.stringify(args)},
+            // Absolute --require so ENV is set before Args constructs (see shared/ensure-env.cjs).
+            node_args: ${JSON.stringify(`--require ${ensureEnv}`)},
             instances: 1,
             exec_mode: "fork",
             autorestart: true,
@@ -840,9 +895,17 @@ async function initServiceStructure(service, options = {}) {
     created.push(dir);
   }
   const ecosystemExisted = await pathExists4(paths.ecosystem);
+  const ensureEnvExisted = await pathExists4(paths.ensureEnv);
   if (!dryRun) {
+    await (0, import_promises11.writeFile)(paths.ensureEnv, buildEnsureEnvScript(), { mode: 420 });
     await (0, import_promises11.writeFile)(paths.ecosystem, buildEcosystemConfig(service, paths), { mode: 420 });
   }
+  if (ensureEnvExisted) {
+    logger.info(`synced ${paths.ensureEnv}`);
+  } else {
+    created.push(paths.ensureEnv);
+    logger.info(`seeded ${paths.ensureEnv}`);
+  }
   if (ecosystemExisted) {
     logger.info(`synced ${paths.ecosystem} from manifest`);
   } else {
@@ -1352,6 +1415,8 @@ function resolveServiceFrom(serviceMap, name, { appsRoot } = {}) {
   initServiceStructure,
   installDeps,
   installOperatorShell,
+  isFreshOnline,
+  isPidAlive,
   listReleases,
   loadServices,
   npmEnv,