@link-assistant/hive-mind 1.30.3 → 1.30.4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/hive-mind
 
+## 1.30.4
+
+### Patch Changes
+
+- 65eefd9: fix: prevent solve command from hanging after PR is merged (Issue #1346)
+
+  Previously, after the solve command detected a merged PR and printed "PR MERGED! Stopping auto-restart-until-mergeable mode", the process would hang indefinitely instead of exiting.
+
+  Root cause: The `finally` block in `src/solve.mjs` completed all async work but never called `process.exit(0)`. Active handles on the Node.js event loop (from libraries like `command-stream` and network connections) prevent natural process exit. When Sentry is enabled (`--sentry`), `@sentry/profiling-node` native handles also contribute.
+
+  The fix:
+  1. Restores explicit `📁 Complete log file:` display in the `finally` block (matching original behavior)
+  2. Calls `closeSentry()` from `sentry.lib.mjs` to properly flush Sentry events and release profiling handles when Sentry is enabled (no-op when disabled)
+  3. Calls `process.exit(0)` as a required safety net to prevent hanging from any remaining active handles
+  4. Adds a hard `Promise.race` timeout (3s) around `sentry.close()` in `exit-handler.lib.mjs` to prevent it from hanging if Sentry's transport stalls
+
 ## 1.30.3
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -944,7 +944,9 @@ export const executeClaudeCommand = async params => {
           if (execCommand.kill) {
             await log(`   Sending SIGTERM to process...`, { verbose: true });
             execCommand.kill('SIGTERM');
-            setTimeout(() => {
+            // Issue #1346: Capture timer handle so it can be cleared after use to avoid
+            // leaking an active event loop reference when the process exits before 2s
+            const sigkillTimerId = setTimeout(() => {
               try {
                 if (!execCommand.result?.code) {
                   log(`   Process still alive after 2s, sending SIGKILL`, { verbose: true });
@@ -954,6 +956,7 @@ export const executeClaudeCommand = async params => {
                 /* process may have exited */
               }
             }, 2000);
+            sigkillTimerId.unref();
           }
         } catch (e) {
           await log(`   Warning: Could not kill process: ${e.message}`, { verbose: true });

package/src/exit-handler.lib.mjs

@@ -67,11 +67,17 @@ const showExitMessage = async (reason = 'Process exiting', code = 0) => {
 export const safeExit = async (code = 0, reason = 'Process completed') => {
   await showExitMessage(reason, code);
 
-  // Close Sentry to flush any pending events and allow the process to exit cleanly
+  // 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
+  // flush logic, but the outer Promise itself has no built-in deadline, so we enforce one.
   try {
     const sentry = await getSentry();
     if (sentry && sentry.close) {
-      await sentry.close(2000); // Wait up to 2 seconds for pending events to be sent
+      await Promise.race([
+        sentry.close(2000),
+        new Promise(resolve => setTimeout(resolve, 3000)), // hard 3s deadline
+      ]);
     }
   } catch {
     // Ignore Sentry.close() errors - exit anyway
@@ -119,7 +125,7 @@ export const installGlobalExitHandlers = () => {
     try {
       const sentry = await getSentry();
       if (sentry && sentry.close) {
-        await sentry.close(2000);
+        await Promise.race([sentry.close(2000), new Promise(resolve => setTimeout(resolve, 3000))]);
       }
     } catch {
       // Ignore Sentry.close() errors
@@ -140,7 +146,7 @@ export const installGlobalExitHandlers = () => {
     try {
       const sentry = await getSentry();
       if (sentry && sentry.close) {
-        await sentry.close(2000);
+        await Promise.race([sentry.close(2000), new Promise(resolve => setTimeout(resolve, 3000))]);
       }
     } catch {
       // Ignore Sentry.close() errors
@@ -164,7 +170,7 @@ export const installGlobalExitHandlers = () => {
     try {
       const sentry = await getSentry();
       if (sentry && sentry.close) {
-        await sentry.close(2000);
+        await Promise.race([sentry.close(2000), new Promise(resolve => setTimeout(resolve, 3000))]);
       }
     } catch {
       // Ignore Sentry.close() errors
@@ -188,7 +194,7 @@ export const installGlobalExitHandlers = () => {
     try {
       const sentry = await getSentry();
       if (sentry && sentry.close) {
-        await sentry.close(2000);
+        await Promise.race([sentry.close(2000), new Promise(resolve => setTimeout(resolve, 3000))]);
       }
     } catch {
       // Ignore Sentry.close() errors

package/src/github-merge.lib.mjs

@@ -769,9 +769,15 @@ export async function waitForCI(owner, repo, prNumber, options = {}, verbose = f
     }
 
     if (onStatusUpdate) {
-      // Issue #1269: Wrap callback with timeout to prevent infinite blocking
+      // Issue #1269: Wrap callback with timeout to prevent infinite blocking; #1346: capture and clear timeout handle to prevent dangling timer
       try {
-        await Promise.race([onStatusUpdate(ciStatus), new Promise((_, reject) => setTimeout(() => reject(new Error(`Callback timeout after ${callbackTimeout}ms`)), callbackTimeout))]);
+        let callbackTimeoutId;
+        await Promise.race([
+          onStatusUpdate(ciStatus),
+          new Promise((_, reject) => {
+            callbackTimeoutId = setTimeout(() => reject(new Error(`Callback timeout after ${callbackTimeout}ms`)), callbackTimeout);
+          }),
+        ]).finally(() => clearTimeout(callbackTimeoutId));
       } catch (callbackError) {
         // Issue #1269: Log callback errors but continue processing
         console.error(`[ERROR] /merge: Status update callback failed for PR #${prNumber}: ${callbackError.message}`);

package/src/hive.mjs

@@ -52,7 +52,13 @@ if (isDirectExecution) {
     console.log('   Loading dependencies (this may take a moment)...');
     // Helper function to add timeout to async operations
     const withTimeout = (promise, timeoutMs, operation) => {
-      return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation '${operation}' timed out after ${timeoutMs}ms. This might be due to slow network or npm configuration issues.`)), timeoutMs))]);
+      let timeoutId;
+      return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => reject(new Error(`Operation '${operation}' timed out after ${timeoutMs}ms. This might be due to slow network or npm configuration issues.`)), timeoutMs);
+        }),
+      ]).finally(() => clearTimeout(timeoutId));
     };
     // Use use-m to dynamically import modules for cross-runtime compatibility
     if (typeof use === 'undefined') {

package/src/sentry.lib.mjs

@@ -273,8 +273,16 @@ export const closeSentry = async (timeout = 2000) => {
     return;
   }
 
+  // Issue #1346: Use Promise.race with a hard deadline so a hung sentry.close()
+  // (e.g. from @sentry/profiling-node native thread) cannot block the caller forever.
   try {
-    await sentry.close(timeout);
+    let hardDeadlineId;
+    await Promise.race([
+      sentry.close(timeout),
+      new Promise(resolve => {
+        hardDeadlineId = setTimeout(resolve, timeout + 1000);
+      }),
+    ]).finally(() => clearTimeout(hardDeadlineId));
   } catch (error) {
     // Silently fail if close fails
     if (process.env.DEBUG === 'true') {

package/src/solve.mjs

@@ -41,7 +41,7 @@ const config = await import('./solve.config.lib.mjs');
 const { initializeConfig, parseArguments } = config;
 // Import Sentry integration
 const sentryLib = await import('./sentry.lib.mjs');
-const { initializeSentry, addBreadcrumb, reportError } = sentryLib;
+const { initializeSentry, addBreadcrumb, reportError, closeSentry } = sentryLib;
 const { yargs, hideBin } = await initializeConfig(use);
 const path = (await use('path')).default;
 const fs = (await use('fs')).promises;
@@ -1485,14 +1485,15 @@ try {
     $,
   });
 } finally {
-  // Clean up temporary directory using repository module
   await cleanupTempDirectory(tempDir, argv, limitReached);
 
-  // Show final log file reference (similar to Claude and other agents)
-  // This ensures users always know where to find the complete log file
+  // Show final log file reference so users always know where to find the complete log
   if (getLogFile()) {
-    const path = await use('path');
-    const absoluteLogPath = path.resolve(getLogFile());
-    await log(`\n📁 Complete log file: ${absoluteLogPath}`);
+    const finalLogPath = path.resolve(getLogFile());
+    await log(`\n📁 Complete log file: ${finalLogPath}`);
   }
+
+  // Issue #1346: Flush Sentry events before exit.
+  // closeSentry() uses a hard Promise.race deadline so it cannot block indefinitely.
+  await closeSentry();
 }