@link-assistant/hive-mind 1.32.1 → 1.32.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/hive-mind
 
+## 1.32.3
+
+### Patch Changes
+
+- 04cf237: fix: properly drain active handles at exit to prevent indefinite process hang (Issue #1431)
+
+  Root causes identified and fixed: process.stdin (ReadStream) was never unreferenced; undici's global connection pool (Socket×2) was never closed; surviving command-stream child processes (ChildProcess) were never unreferenced; process.stdout/stderr (WriteStream×2) were not unreferenced on non-TTY descriptors.
+
+  Added drainHandles() in exit-handler.lib.mjs that unrefs/closes all four handle types before process.exit(). Added logActiveHandles() export with per-handle detail (fd, path, pid, remoteAddress) that always logs to the log file. Added no-leaked-streams ESLint rule to catch bare createReadStream/createWriteStream calls whose return value is discarded — the stream companion to the existing no-leaked-timers rule.
+
+## 1.32.2
+
+### Patch Changes
+
+- 695954c: Remove duplication of locked options in /solve and /hive command responses by showing only user-provided options in the Options line, adding emoji prefix for visual distinction, and adding empty line separator between URL and options
+
 ## 1.32.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.32.1",
+  "version": "1.32.3",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/exit-handler.lib.mjs

@@ -66,12 +66,127 @@ const showExitMessage = async (reason = 'Process exiting', code = 0) => {
   await logFunction(`📁 Full log file: ${currentLogPath}`);
 };
 
+/**
+ * Drain and unref active Node.js handles so the event loop can exit naturally.
+ *
+ * Issue #1431: After all work completes, several handle types keep the event loop
+ * alive and prevent the process from exiting on its own:
+ *
+ *   - ReadStream  — process.stdin is never unreferenced. Node keeps it open so the
+ *                   process can receive user input, but a CLI tool is done with input
+ *                   at this point.  Calling .unref() signals that this handle should
+ *                   not prevent exit.
+ *
+ *   - Socket (×2) — Node 18+ built-in fetch() uses undici internally. Each HTTP
+ *                   request leaves a keep-alive socket in undici's global connection
+ *                   pool. Calling getGlobalDispatcher().close() drains and destroys
+ *                   all pooled connections.
+ *
+ *   - ChildProcess — command-stream spawns child processes. The handle stays alive
+ *                    until the OS reclaims the process entry. Calling .unref() on
+ *                    each surviving child lets Node exit without waiting for them.
+ *
+ *   - WriteStream (×2) — process.stdout and process.stderr are always-open writable
+ *                        streams. On non-TTY file descriptors (e.g. pipes, redirects)
+ *                        they can keep the event loop alive. Calling .unref() is safe
+ *                        because we have already finished all output at this point.
+ *
+ * All of these are "unref" fixes — the handles are not forcibly destroyed, just
+ * marked as non-blocking so the event loop considers the process idle once all real
+ * async work is done. This is the idiomatic Node.js pattern for CLI tools.
+ */
+const drainHandles = async () => {
+  // 1. Unref process.stdin so a dangling ReadStream cannot block exit.
+  try {
+    if (process.stdin && !process.stdin.destroyed) {
+      process.stdin.unref();
+    }
+  } catch {
+    // Ignore — stdin may already be closed
+  }
+
+  // 2. Close undici's global dispatcher to drain keep-alive HTTP sockets (Socket handles).
+  //    Node 18+ built-in fetch uses undici; each fetch() call may leave a socket in the
+  //    pool. getGlobalDispatcher().close() is the documented way to drain them.
+  try {
+    const { getGlobalDispatcher } = await import('undici');
+    const dispatcher = getGlobalDispatcher();
+    if (dispatcher && typeof dispatcher.close === 'function') {
+      await Promise.race([
+        dispatcher.close(),
+        new Promise(resolve => setTimeout(resolve, 1000)), // hard 1s deadline
+      ]);
+    }
+  } catch {
+    // undici may not be available in all Node versions — safe to ignore
+  }
+
+  // 3. Unref surviving child processes from command-stream.
+  //    These are typically already-exited but their OS handle entry lingers.
+  try {
+    for (const handle of process._getActiveHandles()) {
+      if (handle?.constructor?.name === 'ChildProcess' && typeof handle.unref === 'function') {
+        handle.unref();
+      }
+    }
+  } catch {
+    // _getActiveHandles is a private V8 API — safe to ignore
+  }
+
+  // 4. Unref stdout/stderr on non-TTY descriptors.
+  //    On a TTY these are already non-blocking; on pipes/redirects they keep the loop alive.
+  try {
+    if (process.stdout && !process.stdout.isTTY && typeof process.stdout.unref === 'function') {
+      process.stdout.unref();
+    }
+    if (process.stderr && !process.stderr.isTTY && typeof process.stderr.unref === 'function') {
+      process.stderr.unref();
+    }
+  } catch {
+    // Ignore
+  }
+};
+
+/**
+ * Log active handles and requests for diagnostics.
+ * Always logs if there are unexpected handles (not just in verbose mode),
+ * treating lingering handles as a warning-level signal.
+ *
+ * @param {Function|null} log - Optional logging function; falls back to console.warn
+ */
+export const logActiveHandles = async (log = null) => {
+  try {
+    const handles = process._getActiveHandles();
+    const requests = process._getActiveRequests();
+    if (handles.length === 0 && requests.length === 0) return;
+
+    const emit = log || (msg => console.warn(msg));
+    await emit(`\n🔍 Active Node.js handles at exit (${handles.length} handles, ${requests.length} requests):`);
+    for (const h of handles) {
+      const name = h.constructor?.name || typeof h;
+      // Extra detail for streams: show fd and path/remoteAddress if available
+      const detail = [h.fd != null ? `fd=${h.fd}` : null, h.path ? `path=${h.path}` : null, h.remoteAddress ? `remote=${h.remoteAddress}:${h.remotePort}` : null, h.pid != null ? `pid=${h.pid}` : null, h.spawnfile ? `file=${h.spawnfile}` : null].filter(Boolean).join(', ');
+      await emit(`   Handle: ${name}${detail ? ` (${detail})` : ''}`);
+    }
+    for (const r of requests) {
+      await emit(`   Request: ${r.constructor?.name || typeof r}`);
+    }
+  } catch {
+    // _getActiveHandles is a private V8 API — safe to ignore if unavailable
+  }
+};
+
 /**
  * Safe exit function that ensures log path is shown
  */
 export const safeExit = async (code = 0, reason = 'Process completed') => {
   await showExitMessage(reason, code);
 
+  // Issue #1431: Drain/unref active handles so the event loop exits naturally.
+  // This resolves the root causes of dangling ReadStream (stdin), Socket (undici),
+  // ChildProcess (command-stream), and WriteStream (stdout/stderr) handles.
+  await drainHandles();
+
   // Close Sentry to flush any pending events and allow the process to exit cleanly.
   // Use Promise.race with a hard timeout to guarantee sentry.close() never hangs
   // indefinitely — the 2000ms hint passed to sentry.close() is forwarded to internal

package/src/solve.mjs

@@ -76,7 +76,7 @@ const { startWatchMode } = watchLib;
 const { startAutoRestartUntilMergeable } = await import('./solve.auto-merge.lib.mjs');
 const { runAutoEnsureRequirements } = await import('./solve.auto-ensure.lib.mjs');
 const exitHandler = await import('./exit-handler.lib.mjs');
-const { initializeExitHandler, installGlobalExitHandlers, safeExit } = exitHandler;
+const { initializeExitHandler, installGlobalExitHandlers, safeExit, logActiveHandles } = exitHandler;
 const { createInterruptWrapper } = await import('./solve.interrupt.lib.mjs');
 const getResourceSnapshot = memoryCheck.getResourceSnapshot;
 
@@ -1450,14 +1450,14 @@ try {
   // closeSentry() uses a hard Promise.race deadline so it cannot block indefinitely.
   await closeSentry();
 
-  // Issue #1335: Log active handles at exit to diagnose future process hang.
-  if (argv.verbose) {
-    const handles = process._getActiveHandles();
-    const requests = process._getActiveRequests();
-    if (handles.length > 0 || requests.length > 0) {
-      await log(`\n🔍 Active Node.js handles at exit (${handles.length} handles, ${requests.length} requests):`, { verbose: true });
-      for (const h of handles) await log(`   Handle: ${h.constructor?.name || typeof h}`, { verbose: true });
-      for (const r of requests) await log(`   Request: ${r.constructor?.name || typeof r}`, { verbose: true });
-    }
-  }
+  // Issue #1431: Log active handles before draining.
+  // Always logged to file and console so future hangs are immediately visible in logs.
+  // drainHandles() inside safeExit() will unref/close these before process.exit().
+  await logActiveHandles(msg => log(msg));
+
+  // Issue #1431: safeExit() calls drainHandles() to unref/close known handle types
+  // (process.stdin ReadStream, undici Socket pool, command-stream ChildProcess,
+  // process.stdout/stderr WriteStreams) so the event loop exits naturally, then
+  // calls process.exit(0) as a deterministic safety net.
+  await safeExit(0, 'Process completed');
 }

package/src/telegram-bot.mjs

@@ -991,8 +991,9 @@ async function handleSolveCommand(ctx) {
   const normalizedUrl = validation.parsed.normalized;
 
   const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
-  const optionsText = args.slice(1).join(' ') || 'none';
-  let infoBlock = `Requested by: ${requester}\nURL: ${escapeMarkdown(normalizedUrl)}\nOptions: ${optionsText}`;
+  // Issue #1228: Show only user-provided options (exclude locked overrides to avoid duplication)
+  const userOptionsText = userArgs.slice(1).join(' ') || 'none';
+  let infoBlock = `Requested by: ${requester}\nURL: ${escapeMarkdown(normalizedUrl)}\n\n🛠 Options: ${userOptionsText}`;
   if (solveOverrides.length > 0) infoBlock += `\n🔒 Locked options: ${solveOverrides.join(' ')}`;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
 
@@ -1160,8 +1161,9 @@ async function handleHiveCommand(ctx) {
 
   const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
   const escapedUrl = escapeMarkdown(args[0]);
-  const optionsText = args.slice(1).join(' ') || 'none';
-  let infoBlock = `Requested by: ${requester}\nURL: ${escapedUrl}\nOptions: ${optionsText}`;
+  // Issue #1228: Show only user-provided options (exclude locked overrides to avoid duplication)
+  const userOptionsText = normalizedArgs.slice(1).join(' ') || 'none';
+  let infoBlock = `Requested by: ${requester}\nURL: ${escapedUrl}\n\n🛠 Options: ${userOptionsText}`;
   if (hiveOverrides.length > 0) {
     infoBlock += `\n🔒 Locked options: ${hiveOverrides.join(' ')}`;
   }