@nmakarov/cli-toolkit 0.51.0 → 0.55.0

package/dist/deploy.js

@@ -11,8 +11,13 @@ function defineService(service) {
   const pm2 = {
     appName: service.name,
     args: "",
+    stopAllowance: 60,
     ...service.pm2
   };
+  if (pm2.killTimeout == null) {
+    const stopSec = Number(pm2.stopAllowance);
+    pm2.killTimeout = Number.isFinite(stopSec) && stopSec > 0 ? Math.floor(stopSec * 1e3) + 5e3 : 65e3;
+  }
   const nginx = service.nginx ? { siteName: service.name, ...service.nginx } : null;
   return {
     repoDirName: deriveRepoDirName(service.repoUrl),
@@ -93,6 +98,30 @@ function run(cmd, args, options = {}) {
 function runShell(command, options = {}) {
   return run("bash", ["-lc", command], options);
 }
+function runCapture(cmd, args, options = {}) {
+  const { cwd, env, logger, allowFail = false } = options;
+  return new Promise((resolve2, reject) => {
+    logger?.info?.(`$ ${cmd} ${args.join(" ")}${cwd ? `  (cwd=${cwd})` : ""}`);
+    const child = spawn(cmd, args, {
+      cwd,
+      env: env ?? process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0 || allowFail) resolve2({ stdout, stderr, code });
+      else reject(new Error(`${cmd} exited with code ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}
 
 // src/deploy/log.js
 import { appendFile, mkdir } from "fs/promises";
@@ -310,7 +339,7 @@ async function runReleaseTests(service, releasePath, paths, options = {}) {
 // src/deploy/prune.js
 import { rm as rm2, readlink as readlink2 } from "fs/promises";
 async function pruneReleases(service, paths, options = {}) {
-  const { dryRun = false, logger = console } = options;
+  const { dryRun = false, logger = console, protect = [] } = options;
   const keep = service.keepReleases ?? 3;
   const releases = await listReleases(paths);
   let activeName = null;
@@ -324,6 +353,9 @@ async function pruneReleases(service, paths, options = {}) {
     if (keepSet.size < keep) keepSet.add(rel.name);
   }
   if (activeName) keepSet.add(activeName);
+  for (const name of protect) {
+    if (name) keepSet.add(name);
+  }
   const toRemove = releases.filter((rel) => !keepSet.has(rel.name));
   for (const rel of toRemove) {
     if (dryRun) {
@@ -337,14 +369,139 @@ async function pruneReleases(service, paths, options = {}) {
 }
 
 // src/deploy/pm2.js
+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 });
+  let list;
+  try {
+    list = JSON.parse(stdout || "[]");
+  } catch (err) {
+    throw new Error(`pm2 jlist: invalid JSON (${err?.message ?? err})`);
+  }
+  if (!Array.isArray(list)) return null;
+  return list.find((p) => p?.name === appName) ?? null;
+}
+async function waitPm2(appName, predicate, options = {}) {
+  const {
+    timeoutMs = 65e3,
+    pollMs = 500,
+    dryRun = false,
+    logger = console,
+    label = "condition"
+  } = options;
+  if (dryRun) {
+    logger.info?.(`[dryRun] would wait pm2 ${appName} for ${label}`);
+    return null;
+  }
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "(unknown)";
+  while (Date.now() < deadline) {
+    const proc = await getPm2Process(appName, { logger });
+    lastStatus = proc?.pm2_env?.status ?? "(missing)";
+    if (predicate(proc)) return proc;
+    await sleep(pollMs);
+  }
+  throw new Error(
+    `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 } = 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) {
+    const proc = await waitPm2(
+      appName,
+      (p) => isFreshOnline(p, oldPid),
+      {
+        timeoutMs: waitTimeoutMs,
+        logger,
+        label: oldPid ? `online on new pid (old ${oldPid} gone)` : "online after reload"
+      }
+    );
+    logger.info(`pm2 ${appName} online pid=${proc?.pid ?? "?"}`);
+  }
+}
+async function stopPm2(appName, options = {}) {
+  const { dryRun = false, logger = console, waitTimeoutMs = 65e3 } = options;
+  if (dryRun) {
+    logger.info(`[dryRun] would pm2 stop ${appName}`);
+    return;
+  }
+  const before = await getPm2Process(appName, { logger });
+  if (!before) {
+    logger.info(`pm2 ${appName}: not present (already stopped)`);
+    return;
+  }
+  if (before.pm2_env?.status === "stopped") {
+    logger.info(`pm2 ${appName}: already stopped`);
+    return;
+  }
+  const oldPid = Number(before.pid);
+  await runShell(`pm2 stop "${appName}"`, { logger });
+  await waitPm2(
+    appName,
+    (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`);
+}
+async function startPm2(paths, options = {}) {
+  const { dryRun = false, logger = console, appName = null, waitTimeoutMs = 65e3 } = options;
+  if (dryRun) {
+    logger.info(`[dryRun] would pm2 start ${paths.ecosystem} --update-env`);
+    return;
+  }
+  await runShell(`pm2 start "${paths.ecosystem}" --update-env`, { logger });
+  logger.info("pm2 started");
+  if (appName) {
+    const proc = await waitPm2(
+      appName,
+      (p) => isFreshOnline(p, null),
+      { timeoutMs: waitTimeoutMs, logger, label: "online after start" }
+    );
+    logger.info(`pm2 ${appName} online pid=${proc?.pid ?? "?"}`);
+  }
 }
 
 // src/deploy/nginx.js
@@ -573,10 +730,26 @@ async function requireDeployRoot(parentDir, serviceRoot) {
 This is meant to run on the target host (where ${parentDir} exists). For a local dry run use --appsRoot=/tmp/<service>.`
   );
 }
+function resolveKillTimeoutMs(pm2) {
+  const explicit = Number(pm2?.killTimeout);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+  const stopSec = Number(pm2?.stopAllowance);
+  if (Number.isFinite(stopSec) && stopSec > 0) return Math.floor(stopSec * 1e3) + 5e3;
+  return 65e3;
+}
+function resolvePm2Args(pm2) {
+  const base = String(pm2?.args ?? "").trim();
+  const stopSec = Number(pm2?.stopAllowance);
+  if (!Number.isFinite(stopSec) || stopSec <= 0) return base;
+  if (/(?:^|\s)--stopAllowance=/.test(base)) return base;
+  return `${base}${base ? " " : ""}--stopAllowance=${Math.floor(stopSec)}`.trim();
+}
 function buildEcosystemConfig(service, paths) {
   const { pm2 } = service;
   const outLog = join8(paths.logs, `${pm2.appName}.out.log`);
   const errLog = join8(paths.logs, `${pm2.appName}.err.log`);
+  const killTimeoutMs = resolveKillTimeoutMs(pm2);
+  const args = resolvePm2Args(pm2);
   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
@@ -588,7 +761,7 @@ module.exports = {
             name: "${pm2.appName}",
             script: "${pm2.script}",
             cwd: "${paths.current}",
-            args: "${pm2.args ?? ""}",
+            args: ${JSON.stringify(args)},
             instances: 1,
             exec_mode: "fork",
             autorestart: true,
@@ -596,6 +769,8 @@ module.exports = {
             max_restarts: 10,
             restart_delay: 2000,
             max_memory_restart: "1500M",
+            // Grace window after SIGINT/SIGTERM before SIGKILL (ms). Align with --stopAllowance.
+            kill_timeout: ${killTimeoutMs},
             out_file: "${outLog}",
             error_file: "${errLog}",
             merge_logs: true,
@@ -796,15 +971,27 @@ async function bootstrapHost(service, options = {}) {
 }
 
 // src/deploy/deploy-service.js
+import { readlink as readlink3 } from "fs/promises";
+function resolveKillTimeoutMs2(service) {
+  const explicit = Number(service.pm2?.killTimeout);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+  const stopSec = Number(service.pm2?.stopAllowance);
+  if (Number.isFinite(stopSec) && stopSec > 0) return Math.floor(stopSec * 1e3) + 5e3;
+  return 65e3;
+}
 async function deployService(service, options = {}) {
   const {
     dryRun = false,
     skipPull = false,
     skipTests = false,
     skipNginx = false,
+    stopFirst = false,
     logger = console
   } = options;
   const paths = servicePaths(service);
+  const appName = service.pm2.appName;
+  const killTimeoutMs = resolveKillTimeoutMs2(service);
+  const waitTimeoutMs = killTimeoutMs + 1e4;
   await initServiceStructure(service, { dryRun, logger });
   if (!skipPull) await pullRepo(service, { dryRun, logger });
   await syncEnv(service, { dryRun, logger });
@@ -812,14 +999,31 @@ async function deployService(service, options = {}) {
   await writeReleaseBuildInfo(service, releasePath, { stamp, dryRun, logger });
   await installDeps(service, releasePath, paths, { dryRun, logger });
   if (!skipTests) await runReleaseTests(service, releasePath, paths, { dryRun, logger });
-  await activateRelease(releasePath, paths, { dryRun, logger });
-  await pruneReleases(service, paths, { dryRun, logger });
-  await reloadPm2(paths, { dryRun, logger });
+  let previousReleaseName = null;
+  try {
+    const prev = await readlink3(paths.current);
+    previousReleaseName = prev.split("/").pop() || null;
+  } catch {
+  }
+  if (stopFirst) {
+    logger.info(`deploy mode=stopFirst app=${appName} killTimeoutMs=${killTimeoutMs}`);
+    await stopPm2(appName, { dryRun, logger, waitTimeoutMs });
+    await activateRelease(releasePath, paths, { dryRun, logger });
+    await pruneReleases(service, paths, { dryRun, logger });
+    await startPm2(paths, { dryRun, logger, appName, waitTimeoutMs });
+  } else {
+    logger.info(
+      `deploy mode=rolling app=${appName} killTimeoutMs=${killTimeoutMs}` + (previousReleaseName ? ` previous=${previousReleaseName}` : "")
+    );
+    await activateRelease(releasePath, paths, { dryRun, logger });
+    await reloadPm2(paths, { dryRun, logger, appName, waitTimeoutMs });
+    await pruneReleases(service, paths, { dryRun, logger });
+  }
   if (!skipNginx) await enableNginxUpstream(service, { dryRun, logger });
-  const summary = `deploy complete stamp=${stamp} dryRun=${dryRun}`;
+  const summary = `deploy complete stamp=${stamp} mode=${stopFirst ? "stopFirst" : "rolling"} dryRun=${dryRun}`;
   logger.info(summary);
   if (!dryRun) await appendDeployLog(paths.deployLog, summary);
-  return { stamp, releasePath };
+  return { stamp, releasePath, mode: stopFirst ? "stopFirst" : "rolling" };
 }
 
 // src/deploy/provision-service.js
@@ -860,7 +1064,7 @@ async function provisionService(service, options = {}) {
 }
 
 // src/deploy/rollback-service.js
-import { readlink as readlink3 } from "fs/promises";
+import { readlink as readlink4 } from "fs/promises";
 async function rollbackService(service, options = {}) {
   const { release: targetName, dryRun = false, logger = console } = options;
   const paths = servicePaths(service);
@@ -868,7 +1072,7 @@ async function rollbackService(service, options = {}) {
   if (releases.length === 0) throw new Error("No releases to roll back to");
   let activeName = null;
   try {
-    const target = await readlink3(paths.current);
+    const target = await readlink4(paths.current);
     activeName = target.split("/").pop();
   } catch {
     throw new Error("No active release (current symlink missing)");
@@ -1106,9 +1310,12 @@ export {
   ensureEnvOnRemote,
   ensureRemoteRepo,
   ensureRepoDependencies,
+  getPm2Process,
   initServiceStructure,
   installDeps,
   installOperatorShell,
+  isFreshOnline,
+  isPidAlive,
   listReleases,
   loadServices,
   npmEnv,
@@ -1127,6 +1334,7 @@ export {
   resolveServiceFrom,
   rollbackService,
   run,
+  runCapture,
   runReleaseTests,
   runRemoteCli,
   runRemoteStatus,
@@ -1135,7 +1343,10 @@ export {
   servicePaths,
   shellQuote,
   sshRun,
+  startPm2,
+  stopPm2,
   syncEnv,
+  waitPm2,
   writeReleaseBuildInfo
 };
 //# sourceMappingURL=deploy.js.map