@nmakarov/cli-toolkit 0.78.0 → 0.80.0

package/dist/index.cjs

@@ -3972,7 +3972,7 @@ var CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set([
   "57P02",
   "57P03"
 ]);
-var CONNECTION_ERROR_MESSAGE_RE = /connection (terminated|ended|closed|destroyed|reset|refused|not open)|Connection terminated unexpectedly|Client has encountered a connection error|server closed the connection|Cannot use a pool after calling end|This socket has been ended|connect ECONNRESET/i;
+var CONNECTION_ERROR_MESSAGE_RE = /connection (terminated|ended|closed|destroyed|reset|refused|not open)|Connection (terminated|ended) unexpectedly|Client has encountered a connection error|server closed the connection|Cannot use a pool after calling end|This socket has been ended|connect ECONNRESET/i;
 var Db = class _Db {
   static async init(context, options = {}) {
     const buildConfig = async () => {
@@ -4240,6 +4240,10 @@ var Db = class _Db {
     this.isConnected = false;
     this.queriesLog = [];
     this._reconnectPromise = null;
+    this._closed = false;
+    this._liveKnex = /* @__PURE__ */ new Set();
+    this._reconnectCooldownUntil = 0;
+    this._reconnectAcquireTimeoutMs = null;
     this.config = {
       testConnection: true,
       profile: false,
@@ -4324,6 +4328,9 @@ var Db = class _Db {
     return null;
   }
   async connect() {
+    if (this._closed) {
+      throw new ParamError("Db: Connection closed");
+    }
     if (this.isConnected && this.knexInstance) {
       this.logger.warn?.("[Db] Already connected");
       return;
@@ -4339,22 +4346,46 @@ var Db = class _Db {
         connectionString: this.config.connectionString,
         family: 4
       };
+      const acquireTimeout = this._reconnectAcquireTimeoutMs ?? this.config.acquireConnectionTimeout;
       this.knexInstance = (0, import_knex.default)({
         client,
         connection: connectionConfig,
         pool: this.config.pool,
-        acquireConnectionTimeout: this.config.acquireConnectionTimeout,
+        acquireConnectionTimeout: acquireTimeout,
         ...this.config.ssl && { ssl: this.config.ssl }
       });
+      this._liveKnex.add(this.knexInstance);
+      this.knexInstance.on?.("error", (err) => {
+        if (this._closed) return;
+        this.logger.warn?.(
+          `[Db] Connection error (${this.getErrorMessage(err)})`
+        );
+      });
+      if (this._closed) {
+        await this._destroyKnex(this.knexInstance, "connect aborted (closed)");
+        this.knexInstance = null;
+        throw new ParamError("Db: Connection closed");
+      }
       if (this.config.profile) {
         this.attachProfiler();
       }
       if (this.config.testConnection) {
         await this.testConnection();
       }
+      if (this._closed) {
+        await this._destroyKnex(this.knexInstance, "connect aborted (closed)");
+        this.knexInstance = null;
+        throw new ParamError("Db: Connection closed");
+      }
       this.isConnected = true;
       this.logger.debug?.(formatDbConnectMessage(this.config.name, this.config.connectionString));
     } catch (error) {
+      const failed = this.knexInstance;
+      this.knexInstance = null;
+      this.isConnected = false;
+      if (failed) {
+        await this._destroyKnex(failed, "connect failed");
+      }
       if (error instanceof ParamError) {
         throw error;
       }
@@ -4362,20 +4393,42 @@ var Db = class _Db {
       throw new ParamError(`Db: Connection failed - ${errorMsg}`);
     }
   }
-  async disconnect() {
-    if (!this.knexInstance) {
-      return;
-    }
+  /**
+   * Destroy a knex pool without hanging exit on stuck TCP sockets (ETIMEDOUT).
+   * @param {import("knex").Knex | null | undefined} knexInst
+   * @param {string} [reason]
+   * @param {number} [timeoutMs]
+   */
+  async _destroyKnex(knexInst, reason = "destroy", timeoutMs = 3e3) {
+    if (!knexInst || typeof knexInst.destroy !== "function") return;
+    this._liveKnex.delete(knexInst);
     try {
-      await this.knexInstance.destroy();
-      this.knexInstance = null;
-      this.isConnected = false;
-      this.queriesLog = [];
-      this.logger.debug?.(formatDbDisconnectMessage(this.config.name, this.config.connectionString));
+      await Promise.race([
+        knexInst.destroy(),
+        new Promise((_, reject) => {
+          const t = setTimeout(
+            () => reject(new Error(`Db: ${reason} timed out after ${timeoutMs}ms`)),
+            timeoutMs
+          );
+          t.unref?.();
+        })
+      ]);
     } catch (error) {
-      const errorMsg = this.getErrorMessage(error);
-      this.logger.error?.(`[Db] Error disconnecting: ${errorMsg}`);
-      throw error;
+      this.logger.debug?.(
+        `[Db] ${reason}: ${this.getErrorMessage(error)}`
+      );
+    }
+  }
+  async disconnect() {
+    this._closed = true;
+    this.isConnected = false;
+    this.knexInstance = null;
+    this.queriesLog = [];
+    const all = [...this._liveKnex];
+    this._liveKnex.clear();
+    await Promise.all(all.map((inst) => this._destroyKnex(inst, "disconnect")));
+    if (all.length > 0) {
+      this.logger.debug?.(formatDbDisconnectMessage(this.config.name, this.config.connectionString));
     }
   }
   /**
@@ -4398,27 +4451,39 @@ var Db = class _Db {
   }
   /**
    * Destroy the current knex pool and open a new one. Concurrent callers share one attempt.
+   * No-ops once disconnect() has closed the handle.
    */
   async reconnect() {
+    if (this._closed) {
+      return;
+    }
+    if (this._reconnectCooldownUntil && Date.now() < this._reconnectCooldownUntil) {
+      return;
+    }
     if (this._reconnectPromise) {
       await this._reconnectPromise;
       return;
     }
     this._reconnectPromise = (async () => {
+      if (this._closed) return;
       const old = this.knexInstance;
       this.isConnected = false;
       this.knexInstance = null;
       this.queriesLog = [];
       if (old) {
-        try {
-          await old.destroy();
-        } catch (error) {
-          this.logger.debug?.(
-            `[Db] destroy during reconnect: ${this.getErrorMessage(error)}`
-          );
-        }
+        await this._destroyKnex(old, "destroy during reconnect");
+      }
+      if (this._closed) return;
+      this._reconnectAcquireTimeoutMs = 3e3;
+      try {
+        await this.connect();
+        this._reconnectCooldownUntil = 0;
+      } catch (error) {
+        this._reconnectCooldownUntil = Date.now() + 5e3;
+        throw error;
+      } finally {
+        this._reconnectAcquireTimeoutMs = null;
       }
-      await this.connect();
     })();
     try {
       await this._reconnectPromise;
@@ -4427,10 +4492,19 @@ var Db = class _Db {
     }
   }
   async reconnectAfterConnectionError(error) {
+    if (this._closed) {
+      return;
+    }
+    if (this._reconnectCooldownUntil && Date.now() < this._reconnectCooldownUntil) {
+      return;
+    }
     this.logger.warn?.(
       `[Db] Connection lost (${this.getErrorMessage(error)}) \u2014 reconnecting\u2026`
     );
-    await this.reconnect();
+    try {
+      await this.reconnect();
+    } catch {
+    }
   }
   /**
    * Run `fn`; on a connection error, reconnect once (by default) and retry `fn`.
@@ -4443,10 +4517,13 @@ var Db = class _Db {
         return await fn();
       } catch (error) {
         lastError = error;
-        if (!this.isConnectionError(error) || attempt >= retries) {
+        if (this._closed || !this.isConnectionError(error) || attempt >= retries) {
           throw error;
         }
         await this.reconnectAfterConnectionError(error);
+        if (this._closed) {
+          throw error;
+        }
       }
     }
     throw lastError;
@@ -4470,10 +4547,13 @@ var Db = class _Db {
         try {
           return await protoThen.call(builder);
         } catch (error) {
-          if (!inst.isConnectionError(error)) {
+          if (inst._closed || !inst.isConnectionError(error)) {
             throw error;
           }
           await inst.reconnectAfterConnectionError(error);
+          if (inst._closed || !inst.knexInstance) {
+            throw error;
+          }
           if (typeof builder.clone === "function") {
             const retry = builder.clone();
             retry.client = inst.knexInstance.client;
@@ -5495,13 +5575,14 @@ var Logger = class _Logger {
    */
   progress(message, opts) {
     const { prefix, count, total } = opts;
-    const paddedTotal = String(total).length;
+    const displayTotal = Math.max(Number(total) || 0, Number(count) || 0);
+    const paddedTotal = String(displayTotal).length;
     const paddedCount = String(count).padStart(paddedTotal, " ");
     const payload = {
       level: "progress",
       message,
       count: paddedCount,
-      total,
+      total: displayTotal,
       prefix
     };
     const key = prefix ?? "";
@@ -5518,7 +5599,7 @@ var Logger = class _Logger {
       if (wantTimes) {
         let remaining = -1;
         if (itemsPerSec > 0) {
-          remaining = (total - count) / itemsPerSec;
+          remaining = Math.max(0, (displayTotal - count) / itemsPerSec);
         }
         payload.elapsed = this.round(elapsedSeconds, 2);
         payload.remaining = remaining >= 0 ? this.round(remaining, 2) : remaining;
@@ -5527,12 +5608,12 @@ var Logger = class _Logger {
         payload.rate = itemsPerSec >= 0 ? this.round(itemsPerSec, 2) : itemsPerSec;
       }
     }
-    if (count >= total) {
+    if (count === total) {
       delete this.startTimes[key];
       delete this.startCounts[key];
       delete this.lastProgressTimes[key];
     }
-    if (this.shouldOutputProgress(prefix ?? "", count, total)) {
+    if (this.shouldOutputProgress(prefix ?? "", count, displayTotal)) {
       this.out(payload);
       if (this.options.progressThrottle && prefix) {
         this.lastProgressTimes[prefix] = Date.now();
@@ -5691,6 +5772,8 @@ function setup(opts = {}) {
     // a quick "show me the figured params and quit" that skips the flow's
     // actual work. Like --stopAfter=init, this is a hard exit(0) (registered
     // cleanups are skipped); call it once components/params are resolved.
+    _requestExitCode: null,
+    requestExit: null,
     showUsedParamsIfNeeded: () => {
       const mode = params.getShowUsedParamsMode?.();
       if (mode !== "top" && mode !== "stop") return;
@@ -5701,6 +5784,9 @@ function setup(opts = {}) {
       }
     }
   };
+  context.requestExit = (code = 0) => {
+    context._requestExitCode = code;
+  };
   logger.debug("[setup] completed successfully");
   return context;
 }
@@ -6506,6 +6592,12 @@ function resolveKillTimeoutMs(pm2) {
   if (Number.isFinite(stopSec) && stopSec > 0) return Math.floor(stopSec * 1e3) + 5e3;
   return 65e3;
 }
+var DEFAULT_KILL_RETRY_TIME_MS = 1e4;
+function resolveKillRetryTimeMs(pm2) {
+  const explicit = Number(pm2?.killRetryTime);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
+  return DEFAULT_KILL_RETRY_TIME_MS;
+}
 function resolvePm2Args(pm2) {
   const base = String(pm2?.args ?? "").trim();
   const stopSec = Number(pm2?.stopAllowance);
@@ -6529,6 +6621,7 @@ function buildEcosystemConfig(service, paths) {
   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 killRetryTimeMs = resolveKillRetryTimeMs(pm2);
   const args = resolvePm2Args(pm2);
   const ensureEnv = paths.ensureEnv;
   return `/**
@@ -6554,6 +6647,9 @@ module.exports = {
             max_memory_restart: "1500M",
             // Grace window after SIGINT/SIGTERM before SIGKILL (ms). Align with --stopAllowance.
             kill_timeout: ${killTimeoutMs},
+            // How often pm2 re-checks / logs "failed to kill - retrying in \u2026"
+            // while waiting for graceful exit (pm2 default 100ms \u2192 noisy logs).
+            kill_retry_time: ${killRetryTimeMs},
             out_file: "${outLog}",
             error_file: "${errLog}",
             merge_logs: true,