@nmakarov/cli-toolkit 0.50.0 → 0.53.0

package/dist/deploy.cjs

@@ -34,6 +34,7 @@ __export(deploy_exports, {
   ensureEnvOnRemote: () => ensureEnvOnRemote,
   ensureRemoteRepo: () => ensureRemoteRepo,
   ensureRepoDependencies: () => ensureRepoDependencies,
+  getPm2Process: () => getPm2Process,
   initServiceStructure: () => initServiceStructure,
   installDeps: () => installDeps,
   installOperatorShell: () => installOperatorShell,
@@ -55,6 +56,7 @@ __export(deploy_exports, {
   resolveServiceFrom: () => resolveServiceFrom,
   rollbackService: () => rollbackService,
   run: () => run,
+  runCapture: () => runCapture,
   runReleaseTests: () => runReleaseTests,
   runRemoteCli: () => runRemoteCli,
   runRemoteStatus: () => runRemoteStatus,
@@ -63,7 +65,10 @@ __export(deploy_exports, {
   servicePaths: () => servicePaths,
   shellQuote: () => shellQuote,
   sshRun: () => sshRun,
+  startPm2: () => startPm2,
+  stopPm2: () => stopPm2,
   syncEnv: () => syncEnv,
+  waitPm2: () => waitPm2,
   writeReleaseBuildInfo: () => writeReleaseBuildInfo
 });
 module.exports = __toCommonJS(deploy_exports);
@@ -81,8 +86,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),
@@ -163,6 +173,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 = (0, import_node_child_process.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
 var import_promises = require("fs/promises");
@@ -380,7 +414,7 @@ async function runReleaseTests(service, releasePath, paths, options = {}) {
 // src/deploy/prune.js
 var import_promises7 = require("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;
@@ -394,6 +428,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) {
@@ -407,14 +444,101 @@ async function pruneReleases(service, paths, options = {}) {
 }
 
 // src/deploy/pm2.js
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+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}`
+  );
+}
 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;
   }
   await runShell(`pm2 startOrReload "${paths.ecosystem}" --update-env`, { logger });
   logger.info("pm2 reloaded");
+  if (appName) {
+    await waitPm2(
+      appName,
+      (proc) => proc?.pm2_env?.status === "online",
+      { timeoutMs: waitTimeoutMs, logger, label: "online after reload" }
+    );
+    logger.info(`pm2 ${appName} online`);
+  }
+}
+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;
+  }
+  await runShell(`pm2 stop "${appName}"`, { logger });
+  await waitPm2(
+    appName,
+    (proc) => !proc || proc.pm2_env?.status === "stopped",
+    { 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) {
+    await waitPm2(
+      appName,
+      (proc) => proc?.pm2_env?.status === "online",
+      { timeoutMs: waitTimeoutMs, logger, label: "online after start" }
+    );
+    logger.info(`pm2 ${appName} online`);
+  }
 }
 
 // src/deploy/nginx.js
@@ -643,10 +767,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 = (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);
   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
@@ -658,7 +798,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,
@@ -666,6 +806,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,
@@ -866,15 +1008,27 @@ async function bootstrapHost(service, options = {}) {
 }
 
 // src/deploy/deploy-service.js
+var import_promises13 = require("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 });
@@ -882,21 +1036,38 @@ 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 (0, import_promises13.readlink)(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
-var import_promises13 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 async function pathExists6(path) {
   try {
-    await (0, import_promises13.access)(path);
+    await (0, import_promises14.access)(path);
     return true;
   } catch {
     return false;
@@ -930,7 +1101,7 @@ async function provisionService(service, options = {}) {
 }
 
 // src/deploy/rollback-service.js
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 async function rollbackService(service, options = {}) {
   const { release: targetName, dryRun = false, logger = console } = options;
   const paths = servicePaths(service);
@@ -938,7 +1109,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 (0, import_promises14.readlink)(paths.current);
+    const target = await (0, import_promises15.readlink)(paths.current);
     activeName = target.split("/").pop();
   } catch {
     throw new Error("No active release (current symlink missing)");
@@ -965,14 +1136,14 @@ async function rollbackService(service, options = {}) {
 }
 
 // src/deploy/ssh-remote.js
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_node_os3 = require("os");
 var import_node_path10 = require("path");
 var import_node_child_process4 = require("child_process");
 var REMOTE_CLI_REL = "node_modules/@nmakarov/cli-toolkit/scripts/deploy/cli.js";
 async function pathExists7(path) {
   try {
-    await (0, import_promises15.access)(path);
+    await (0, import_promises16.access)(path);
     return true;
   } catch {
     return false;
@@ -1064,9 +1235,9 @@ async function ensureEnvOnRemote(host, service, options = {}) {
   if (!await pathExists7(localPath)) return false;
   logger.info(`copying .env ${localPath} \u2192 ${host}:${paths.repoEnv}`);
   await sshRun(host, `mkdir -p ${shellQuote((0, import_node_path10.dirname)(paths.repoEnv))}`, { logger });
-  const scrubbed = scrubEnvContent(await (0, import_promises15.readFile)(localPath, "utf8"), service.envScrubPatterns ?? []);
+  const scrubbed = scrubEnvContent(await (0, import_promises16.readFile)(localPath, "utf8"), service.envScrubPatterns ?? []);
   const tmp = (0, import_node_path10.join)((0, import_node_os3.tmpdir)(), `deploy-env-${Date.now()}`);
-  await (0, import_promises15.writeFile)(tmp, scrubbed, { mode: 384 });
+  await (0, import_promises16.writeFile)(tmp, scrubbed, { mode: 384 });
   await scp(tmp, `${host}:${paths.repoEnv}`, { logger });
   await sshRun(host, `chmod 600 ${shellQuote(paths.repoEnv)}`, { logger });
   return true;
@@ -1177,6 +1348,7 @@ function resolveServiceFrom(serviceMap, name, { appsRoot } = {}) {
   ensureEnvOnRemote,
   ensureRemoteRepo,
   ensureRepoDependencies,
+  getPm2Process,
   initServiceStructure,
   installDeps,
   installOperatorShell,
@@ -1198,6 +1370,7 @@ function resolveServiceFrom(serviceMap, name, { appsRoot } = {}) {
   resolveServiceFrom,
   rollbackService,
   run,
+  runCapture,
   runReleaseTests,
   runRemoteCli,
   runRemoteStatus,
@@ -1206,7 +1379,10 @@ function resolveServiceFrom(serviceMap, name, { appsRoot } = {}) {
   servicePaths,
   shellQuote,
   sshRun,
+  startPm2,
+  stopPm2,
   syncEnv,
+  waitPm2,
   writeReleaseBuildInfo
 });
 //# sourceMappingURL=deploy.cjs.map