@nmakarov/cli-toolkit 0.79.0 → 0.81.0

package/dist/cli-runner.js

@@ -1002,6 +1002,30 @@ var init_ui_elements = __esm({
   }
 });
 
+// src/screen/follow-scroll.js
+function clampScroll(scrollTop, maxScroll) {
+  const max = Math.max(0, Number(maxScroll) || 0);
+  const top = Number(scrollTop) || 0;
+  return Math.min(Math.max(0, top), max);
+}
+function isScrolledToBottom(scrollTop, maxScroll) {
+  return clampScroll(scrollTop, maxScroll) >= Math.max(0, Number(maxScroll) || 0);
+}
+function nextScrollAfterUserMove(scrollTop, maxScroll, delta) {
+  const next = clampScroll((Number(scrollTop) || 0) + (Number(delta) || 0), maxScroll);
+  return { scrollTop: next, following: isScrolledToBottom(next, maxScroll) };
+}
+function nextScrollAfterContentChange({ following, scrollTop, maxScroll }) {
+  const max = Math.max(0, Number(maxScroll) || 0);
+  if (following) return { scrollTop: max, following: true };
+  const next = clampScroll(scrollTop, max);
+  return { scrollTop: next, following: isScrolledToBottom(next, max) };
+}
+var init_follow_scroll = __esm({
+  "src/screen/follow-scroll.js"() {
+  }
+});
+
 // src/screen/scrollable-text.js
 import { useState as useState3, useEffect as useEffect2, useMemo, useRef as useRef2, createElement as createElement2 } from "react";
 import { Box as Box4, Text as Text5 } from "ink";
@@ -1036,9 +1060,11 @@ function ScrollableText({
   showScrollbar = true,
   showStatus = true,
   bindKeys = true,
-  header = null
+  header = null,
+  followBottom = false
 }) {
   const [scrollTop, setScrollTop] = useState3(0);
+  const [following, setFollowing] = useState3(() => !!followBottom);
   const [, bump] = useState3(0);
   const termRows = process.stdout.rows || 24;
   const viewportRows = Math.max(
@@ -1057,39 +1083,40 @@ function ScrollableText({
   const clamped = Math.min(Math.max(0, scrollTop), maxScroll);
   const visible = allLines.slice(clamped, clamped + viewportRows);
   const bar = needsBar ? scrollbarGlyphs(viewportRows, allLines.length, clamped) : null;
-  useEffect2(() => {
-    setScrollTop((s) => Math.min(s, maxScroll));
-  }, [maxScroll]);
   const maxScrollRef = useRef2(maxScroll);
   const pageSizeRef = useRef2(viewportRows);
+  const scrollTopRef = useRef2(scrollTop);
+  const followingRef = useRef2(following);
   maxScrollRef.current = maxScroll;
   pageSizeRef.current = viewportRows;
+  scrollTopRef.current = scrollTop;
+  followingRef.current = following;
+  useEffect2(() => {
+    const next = nextScrollAfterContentChange({
+      following: followBottom && followingRef.current,
+      scrollTop: scrollTopRef.current,
+      maxScroll
+    });
+    if (next.scrollTop !== scrollTopRef.current) setScrollTop(next.scrollTop);
+    if (followBottom && next.following !== followingRef.current) setFollowing(next.following);
+  }, [maxScroll, followBottom]);
+  const applyUserScroll = (delta) => {
+    const next = nextScrollAfterUserMove(scrollTopRef.current, maxScrollRef.current, delta);
+    setScrollTop(next.scrollTop);
+    if (followBottom) setFollowing(next.following);
+    bump((n) => n + 1);
+    ctx?.update?.();
+  };
   useEffect2(() => {
     if (!ctx || !bindKeys) return void 0;
     ctx.setKeyBinding(SCROLL_KEYS);
-    ctx.setAction("scrollUp", () => {
-      setScrollTop((s) => Math.max(0, s - 1));
-      bump((n) => n + 1);
-      ctx.update?.();
-    });
-    ctx.setAction("scrollDown", () => {
-      setScrollTop((s) => Math.min(maxScrollRef.current, s + 1));
-      bump((n) => n + 1);
-      ctx.update?.();
-    });
-    ctx.setAction("pageUp", () => {
-      setScrollTop((s) => Math.max(0, s - pageSizeRef.current));
-      bump((n) => n + 1);
-      ctx.update?.();
-    });
-    ctx.setAction("pageDown", () => {
-      setScrollTop((s) => Math.min(maxScrollRef.current, s + pageSizeRef.current));
-      bump((n) => n + 1);
-      ctx.update?.();
-    });
+    ctx.setAction("scrollUp", () => applyUserScroll(-1));
+    ctx.setAction("scrollDown", () => applyUserScroll(1));
+    ctx.setAction("pageUp", () => applyUserScroll(-pageSizeRef.current));
+    ctx.setAction("pageDown", () => applyUserScroll(pageSizeRef.current));
     return void 0;
-  }, [ctx, bindKeys]);
-  const status = allLines.length === 0 ? "empty" : `lines ${clamped + 1}-${Math.min(clamped + visible.length, allLines.length)} of ${allLines.length}` + (needsBar ? " \xB7 \u2325\u2191/\u2193 or PgUp/Dn page" : "");
+  }, [ctx, bindKeys, followBottom]);
+  const status = allLines.length === 0 ? "empty" : `lines ${clamped + 1}-${Math.min(clamped + visible.length, allLines.length)} of ${allLines.length}` + (needsBar ? " \xB7 \u2325\u2191/\u2193 or PgUp/Dn page" : "") + (followBottom && following ? " \xB7 follow" : followBottom ? " \xB7 follow off" : "");
   const rowNodes = visible.map((line, i) => {
     const body = padEndVisible(line, textWidth);
     const glyph = bar ? bar[i] ?? BAR_TRACK : showScrollbar ? " " : "";
@@ -1127,6 +1154,7 @@ var init_scrollable_text = __esm({
   "src/screen/scrollable-text.js"() {
     init_components();
     init_scrollbar();
+    init_follow_scroll();
     init_scrollbar();
     h5 = createElement2;
     SCROLL_KEYS = [
@@ -1295,10 +1323,14 @@ __export(screen_exports, {
   buildBreadcrumb: () => buildBreadcrumb,
   buildDetailBreadcrumb: () => buildDetailBreadcrumb,
   buildFooter: () => buildFooter,
+  clampScroll: () => clampScroll,
   formatBindingKey: () => formatBindingKey,
   h: () => createElement3,
+  isScrolledToBottom: () => isScrolledToBottom,
   load: () => load,
   memo: () => memo,
+  nextScrollAfterContentChange: () => nextScrollAfterContentChange,
+  nextScrollAfterUserMove: () => nextScrollAfterUserMove,
   organizeFooterMessages: () => organizeFooterMessages,
   scrollbarGlyphs: () => scrollbarGlyphs,
   showListScreen: () => showListScreen,
@@ -1335,6 +1367,7 @@ var init_screen = __esm({
     init_components();
     init_ui_elements();
     init_scrollable_text();
+    init_follow_scroll();
     init_scrollbar();
     init_key_bindings();
     init_utils();
@@ -2654,13 +2687,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 +2711,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 +2720,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 +2884,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 +2896,9 @@ function setup(opts = {}) {
       }
     }
   };
+  context.requestExit = (code = 0) => {
+    context._requestExitCode = code;
+  };
   logger.debug("[setup] completed successfully");
   return context;
 }
@@ -2895,9 +2934,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 +3048,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 +3173,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 +3441,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 +3529,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 +3547,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 +3594,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 +3652,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 +3693,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 +3718,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 +3748,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;