@nmakarov/cli-toolkit 0.78.0 → 0.80.0

package/dist/cli-runner.js

@@ -2654,13 +2654,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 ?? "";
@@ -2677,7 +2678,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;
@@ -2686,12 +2687,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();
@@ -2850,6 +2851,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;
@@ -2860,6 +2863,9 @@ function setup(opts = {}) {
       }
     }
   };
+  context.requestExit = (code = 0) => {
+    context._requestExitCode = code;
+  };
   logger.debug("[setup] completed successfully");
   return context;
 }
@@ -2895,9 +2901,25 @@ async function init(flow2, opts = {}) {
     if (cleanupRan) return;
     cleanupRan = true;
     const fns = [...ctx.cleanupFunctions].reverse();
+    const budgetMs = 5e3;
+    const started = Date.now();
     for (const fn of fns) {
+      const left = budgetMs - (Date.now() - started);
+      if (left <= 0) {
+        ctx.logger.warn("[cleanup] budget exhausted \u2014 skipping remaining cleanup");
+        break;
+      }
       try {
-        await fn(ctx);
+        await Promise.race([
+          Promise.resolve(fn(ctx)),
+          new Promise((_, reject) => {
+            const t = setTimeout(
+              () => reject(new Error(`cleanup timed out after ${left}ms`)),
+              left
+            );
+            t.unref?.();
+          })
+        ]);
       } catch (error) {
         ctx.logger.warn("[cleanup] error in cleanup function:", error);
       }
@@ -2993,6 +3015,8 @@ async function init(flow2, opts = {}) {
       process.exit(process.exitCode);
     } else if (stop || kill) {
       process.exit(0);
+    } else if (context._requestExitCode != null) {
+      process.exit(context._requestExitCode);
     }
   }
 }
@@ -3116,7 +3140,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 () => {
@@ -3384,6 +3408,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,
@@ -3468,6 +3496,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;
@@ -3483,22 +3514,46 @@ var Db = class _Db {
         connectionString: this.config.connectionString,
         family: 4
       };
+      const acquireTimeout = this._reconnectAcquireTimeoutMs ?? this.config.acquireConnectionTimeout;
       this.knexInstance = knex({
         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;
       }
@@ -3506,20 +3561,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));
     }
   }
   /**
@@ -3542,27 +3619,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;
@@ -3571,10 +3660,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`.
@@ -3587,10 +3685,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;
@@ -3614,10 +3715,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;