@link-assistant/hive-mind 1.50.6 → 1.50.7

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @link-assistant/hive-mind
 
+## 1.50.7
+
+### Patch Changes
+
+- 84b9853: fix: make all long sleeps interruptible so CTRL+C responds immediately (#1574)
+  - Replace raw `setTimeout` sleeps with an interruptible sleep utility that listens for SIGINT
+  - Ensure CTRL+C during CI polling, auto-merge waits, and auto-continue delays terminates the process immediately
+  - Add `interruptible-sleep.lib.mjs` with full test coverage
+
 ## 1.50.6
 
 ### Patch Changes

package/package.json

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

package/src/interruptible-sleep.lib.mjs

@@ -0,0 +1,42 @@
+/**
+ * Interruptible sleep utility for long-running wait loops.
+ *
+ * Replaces raw `await new Promise(r => setTimeout(r, ms))` with a sleep
+ * that resolves immediately on SIGINT, so the process exit handler chain
+ * is not blocked by a lingering timer.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1574
+ */
+
+/**
+ * Sleep for `ms` milliseconds, but resolve early if SIGINT is received.
+ *
+ * When SIGINT fires during the sleep, the timer is cleared and the promise
+ * resolves with `{ interrupted: true }`. The existing SIGINT handler (from
+ * exit-handler.lib.mjs) continues to run normally — this function does NOT
+ * consume or re-emit the signal, it only ensures its own timer doesn't
+ * block the event loop.
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {Promise<{interrupted: boolean}>}
+ */
+export function interruptibleSleep(ms) {
+  return new Promise(resolve => {
+    let timer;
+
+    const onInterrupt = () => {
+      clearTimeout(timer);
+      process.removeListener('SIGINT', onInterrupt);
+      resolve({ interrupted: true });
+    };
+
+    timer = setTimeout(() => {
+      process.removeListener('SIGINT', onInterrupt);
+      resolve({ interrupted: false });
+    }, ms);
+
+    process.on('SIGINT', onInterrupt);
+  });
+}
+
+export default { interruptibleSleep };

package/src/solve.auto-continue.lib.mjs

@@ -49,6 +49,9 @@ const { extractLinkedIssueNumber } = githubLinking;
 // Import configuration
 import { autoContinue, limitReset } from './config.lib.mjs';
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 const { calculateWaitTime } = validation;
 
 /**
@@ -116,7 +119,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     }, countdownInterval);
 
     // Wait until reset time
-    await new Promise(resolve => setTimeout(resolve, waitMs));
+    await interruptibleSleep(waitMs);
     clearInterval(countdownTimer);
 
     const actionType = isRestart ? 'Restarting' : 'Resuming';

package/src/solve.auto-merge.lib.mjs

@@ -54,6 +54,9 @@ import { limitReset } from './config.lib.mjs';
 const autoMergeHelpers = await import('./solve.auto-merge-helpers.lib.mjs');
 const { checkForExistingComment, checkForNonBotComments, getMergeBlockers } = autoMergeHelpers;
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 /**
  * Main function: Watch and restart until PR becomes mergeable
  * This implements --auto-restart-until-mergeable functionality
@@ -104,7 +107,7 @@ export const watchUntilMergeable = async params => {
   // Issue #1567: Wait for initial cooldown before first check.
   // This gives CI/CD time to start and solution logs time to be posted.
   await log(formatAligned('⏳', 'Initial cooldown:', `Waiting ${INITIAL_COOLDOWN_SECONDS}s before first check...`));
-  await new Promise(resolve => setTimeout(resolve, INITIAL_COOLDOWN_SECONDS * 1000));
+  await interruptibleSleep(INITIAL_COOLDOWN_SECONDS * 1000);
   await log(formatAligned('✅', 'Cooldown complete:', 'Starting monitoring loop'));
   await log('');
 
@@ -200,7 +203,7 @@ export const watchUntilMergeable = async params => {
         if (!noCiConfigured) {
           const DOUBLE_CHECK_DELAY_MS = 10000; // 10 seconds
           await log(formatAligned('🔍', 'Multi-mechanism CI consensus check:', `Waiting ${DOUBLE_CHECK_DELAY_MS / 1000}s then verifying...`, 2));
-          await new Promise(resolve => setTimeout(resolve, DOUBLE_CHECK_DELAY_MS));
+          await interruptibleSleep(DOUBLE_CHECK_DELAY_MS);
 
           // Run multi-mechanism consensus: Check Runs API + Workflow Runs API + Repo-wide actions
           const consensus = await checkCIConsensus({
@@ -223,7 +226,7 @@ export const watchUntilMergeable = async params => {
             const actualWaitSeconds = currentBackoffSeconds;
             await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
             await log('');
-            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            await interruptibleSleep(actualWaitSeconds * 1000);
             continue;
           }
           await log(formatAligned('✅', 'All CI mechanisms agree:', `CheckRuns=${consensus.mechanisms.checkRunsAPI.status}, WorkflowRuns=complete(${consensus.mechanisms.workflowRunsAPI.total}), RepoActions=${consensus.mechanisms.repoActions.skipped ? 'skipped' : 'clear'}`, 2));
@@ -236,7 +239,7 @@ export const watchUntilMergeable = async params => {
             const actualWaitSeconds = currentBackoffSeconds;
             await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
             await log('');
-            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            await interruptibleSleep(actualWaitSeconds * 1000);
             continue;
           }
         }
@@ -606,7 +609,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
             }
 
             // Wait until the limit resets
-            await new Promise(resolve => setTimeout(resolve, waitMs));
+            await interruptibleSleep(waitMs);
 
             await log(formatAligned('✅', 'Usage limit wait complete', 'Resuming session...'));
             await log('');
@@ -841,7 +844,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
     const actualWaitSeconds = currentBackoffSeconds;
     await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
     await log('');
-    await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+    await interruptibleSleep(actualWaitSeconds * 1000);
   }
 };
 

package/src/solve.watch.lib.mjs

@@ -37,6 +37,9 @@ const { detectAndCountFeedback } = feedbackLib;
 const restartShared = await import('./solve.restart-shared.lib.mjs');
 const { checkPRMerged, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildUncommittedChangesFeedback, isApiError } = restartShared;
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 /**
  * Monitor for feedback in a loop and trigger restart when detected
  */
@@ -446,7 +449,7 @@ export const watchForFeedback = async params => {
       const actualWaitMs = actualWaitSeconds * 1000;
       await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
       await log(''); // Blank line for readability
-      await new Promise(resolve => setTimeout(resolve, actualWaitMs));
+      await interruptibleSleep(actualWaitMs);
     } else if (isTemporaryWatch && !firstIterationInTemporaryMode) {
       // In auto-restart mode, check immediately without waiting
       await log(formatAligned('', 'Checking immediately for uncommitted changes...', '', 2));