@link-assistant/hive-mind 1.39.0 → 1.40.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.40.1
+
+### Patch Changes
+
+- 9df62ed: fix: increase activity timeout to 1hr, fix idle tracking, improve graceful kill (#1510)
+
+## 1.40.0
+
+### Minor Changes
+
+- 6b8465a: feat: add browsers, browser tools, and missing software to /version command
+
 ## 1.39.0
 
 ### Minor Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -853,21 +853,27 @@ export const executeClaudeCommand = async params => {
       let lastEventTime = null;
       let activityTimeoutId = null;
       let isActivityTimeout = false;
+      // Issue #1510: Separate SIGTERM (graceful) and SIGKILL (force) phases to allow
+      // capturing final output from the process during graceful shutdown
       const forceExitOnTimeout = async () => {
         if (forceExitTriggered) return;
         forceExitTriggered = true;
-        await log(`⚠️ Stream timeout — forcing exit (Issue #1280)`, { verbose: true });
+        await log(`⚠️ Stream timeout — sending SIGTERM for graceful shutdown (Issue #1280, #1510)`, { verbose: true });
         try {
           if (execCommand.kill) {
             execCommand.kill('SIGTERM');
-            // Issue #1346: Follow up with SIGKILL after 2s if still alive
+            // Issue #1346/#1510: Follow up with SIGKILL after 5s if still alive
+            // Increased from 2s to 5s to give more time for final output capture
             const t = setTimeout(() => {
               try {
-                if (!execCommand.result?.code) execCommand.kill('SIGKILL');
+                if (!execCommand.result?.code) {
+                  log(`⚠️ Process did not exit after SIGTERM, sending SIGKILL`, { verbose: true });
+                  execCommand.kill('SIGKILL');
+                }
               } catch {
                 /* exited */
               }
-            }, 2000);
+            }, 5000);
             t.unref();
           }
         } catch (e) {
@@ -892,8 +898,8 @@ export const executeClaudeCommand = async params => {
           activityTimeoutId = setTimeout(async () => {
             if (!forceExitTriggered && !resultEventReceived) {
               isActivityTimeout = true;
-              const idleSeconds = lastEventTime ? Math.round((Date.now() - lastEventTime) / 1000) : 'unknown';
-              await log(`\n⚠️ No stream output for ${timeouts.streamActivityMs / 1000}s after previous activity (idle: ${idleSeconds}s) — force-killing (Issue #1472)`, { level: 'warning' });
+              const idleSeconds = lastEventTime ? `${Math.round((Date.now() - lastEventTime) / 1000)}s` : 'unknown';
+              await log(`\n⚠️ No stream output for ${timeouts.streamActivityMs / 1000}s after previous activity (idle: ${idleSeconds}) — force-killing (Issue #1472)`, { level: 'warning' });
               await forceExitOnTimeout();
             }
           }, timeouts.streamActivityMs);
@@ -901,7 +907,8 @@ export const executeClaudeCommand = async params => {
         }
       };
       for await (const chunk of execCommand.stream()) {
-        if (forceExitTriggered) break;
+        // Issue #1510: Continue processing stream after SIGTERM to capture final output
+        // The stream will naturally end when the process exits (SIGTERM) or is force-killed (SIGKILL after 5s)
         if (!firstChunkReceived) {
           // Issue #1472/#1475: Clear startup timeout on first output
           firstChunkReceived = true;
@@ -922,12 +929,14 @@ export const executeClaudeCommand = async params => {
             if (!line.trim()) continue;
             try {
               const data = sanitizeObjectStrings(JSON.parse(line));
+              // Issue #1510: Track last event time for all modes (not just interactive)
+              // so activity timeout can report accurate idle duration
+              lastEventTime = Date.now();
               if (interactiveHandler) {
                 if (!interactiveHandler._firstEventLogged) {
                   interactiveHandler._firstEventLogged = true;
                   await log(`🔌 Interactive mode: First event received (type: ${data.type || 'unknown'}) — stream is active`, { verbose: true });
                 }
-                lastEventTime = Date.now();
                 try {
                   await interactiveHandler.processEvent(data);
                 } catch (interactiveError) {
@@ -1193,6 +1202,19 @@ export const executeClaudeCommand = async params => {
           const retryMode = isStartupTimeout ? ' (fresh start)' : ' (session preserved)';
           await log(`\n⚠️ ${errorLabel} detected. Retry ${retryCount + 1}/${maxRetries} in ${delayLabel}${retryMode}${notRetryableHint}...`, { level: 'warning' });
           await log(`   Error: ${isStartupTimeout ? `No output from Claude CLI within ${timeouts.streamStartupMs / 1000}s` : isActivityTimeout ? `No output for ${timeouts.streamActivityMs / 1000}s after previous activity` : lastMessage.substring(0, 200)}`, { verbose: true });
+          // Issue #1510: Post PR comment when force-killing and auto-resuming so reviewers can follow the session lifecycle
+          if ((isActivityTimeout || isStartupTimeout) && owner && repo && prNumber && $) {
+            try {
+              const timeoutType = isActivityTimeout ? 'activity' : 'startup';
+              const sessionInfo = sessionId ? `\nSession ID: \`${sessionId}\`` : '';
+              const resumeInfo = isStartupTimeout ? 'Session will be restarted (fresh start).' : `Session will be resumed with \`--resume\` (context preserved).`;
+              const commentBody = `## :warning: Session Force-Killed (${timeoutType} timeout)\n\nThe working session was force-killed due to ${timeoutType} timeout (no stream output for ${isActivityTimeout ? timeouts.streamActivityMs / 1000 : timeouts.streamStartupMs / 1000}s).\n\n**Auto-resuming**: Retry ${retryCount + 1}/${maxRetries} in ${delayLabel}. ${resumeInfo}${sessionInfo}\n\n*This is an automated notification — the session will continue automatically.*`;
+              await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+              await log(`   Posted force-kill notification to PR #${prNumber}`, { verbose: true });
+            } catch (commentError) {
+              await log(`   Warning: Could not post force-kill comment to PR: ${commentError.message}`, { verbose: true });
+            }
+          }
           // Activity timeout preserves session (work was started), startup timeout does not (no session created)
           if (!isStartupTimeout && sessionId && !argv.resume) argv.resume = sessionId;
           await waitWithCountdown(delay, log);

package/src/config.lib.mjs

@@ -63,8 +63,11 @@ export const timeouts = {
   // after at least one event was received, the process is considered hung mid-session.
   // This catches the case where Claude CLI starts producing output but then stops (e.g., the
   // original Issue #1472 where CLI was stuck for 4.5h with all output arriving only at CTRL+C).
-  // Default: 300000ms (5 minutes). Set to 0 to disable. Configurable via environment variable.
-  streamActivityMs: parseIntWithDefault('HIVE_MIND_STREAM_ACTIVITY_MS', 300000),
+  // Issue #1510: Increased from 300000ms (5 min) to 3600000ms (1 hour) because Claude Code can
+  // legitimately wait for long-running operations (docker builds, CI polls, large compilations).
+  // The 5-minute timeout was force-killing sessions during `sleep 300 && gh run view ...` commands.
+  // Default: 3600000ms (1 hour). Set to 0 to disable. Configurable via environment variable.
+  streamActivityMs: parseIntWithDefault('HIVE_MIND_STREAM_ACTIVITY_MS', 3600000),
 };
 
 // Auto-continue configurations

package/src/version-info.lib.mjs

@@ -50,7 +50,17 @@ const VERSION_COMMANDS = [
 
   // Browser Automation
   { key: 'playwright', command: 'playwright --version 2>&1' },
+  { key: 'playwrightTest', command: "npm list -g @playwright/test --depth=0 2>&1 | grep @playwright/test | awk '{print $2}'" },
   { key: 'playwrightMcp', command: "npm list -g @playwright/mcp --depth=0 2>&1 | grep @playwright/mcp | awk '{print $2}'" },
+  { key: 'playwrightMcpStatus', command: 'timeout 5 claude mcp list 2>&1 | grep -i playwright | head -1' },
+  { key: 'puppeteerBrowsers', command: "npm list -g @puppeteer/browsers --depth=0 2>&1 | grep @puppeteer/browsers | awk '{print $2}'" },
+
+  // Browsers (installed via Playwright)
+  { key: 'chrome', command: 'google-chrome --version 2>&1' },
+  { key: 'chromium', command: 'chromium --version 2>&1', fallbacks: ['chromium-browser --version 2>&1'] },
+  { key: 'firefox', command: 'firefox --version 2>&1' },
+  { key: 'msedge', command: 'microsoft-edge --version 2>&1', fallbacks: ['microsoft-edge-stable --version 2>&1'] },
+  { key: 'webkit', command: "ls ~/.cache/ms-playwright/ 2>/dev/null | grep -oE 'webkit-[0-9]+' | head -1" },
 
   // JavaScript/Node.js ecosystem
   { key: 'bun', command: 'bun --version 2>&1' },
@@ -103,10 +113,33 @@ const VERSION_COMMANDS = [
   { key: 'make', command: 'make --version 2>&1 | head -n1' },
   { key: 'cmake', command: 'cmake --version 2>&1 | head -n1' },
 
+  // Ruby ecosystem
+  { key: 'ruby', command: 'ruby --version 2>&1' },
+  { key: 'rbenv', command: 'rbenv --version 2>&1' },
+
+  // Kotlin
+  { key: 'kotlin', command: 'kotlin -version 2>&1' },
+
+  // Swift
+  { key: 'swift', command: 'swift --version 2>&1 | head -n1' },
+
+  // R
+  { key: 'r', command: 'R --version 2>&1 | head -n1' },
+
   // Development Tools
   { key: 'git', command: 'git --version 2>&1' },
   { key: 'gh', command: 'gh --version 2>&1 | head -n1' },
+  { key: 'glab', command: 'glab --version 2>&1 | head -n1' },
   { key: 'brew', command: 'brew --version 2>&1 | head -n1' },
+  { key: 'nasm', command: 'nasm --version 2>&1' },
+  { key: 'fasm', command: 'fasm 2>&1 | head -n1' },
+  { key: 'curl', command: 'curl --version 2>&1 | head -n1' },
+  { key: 'wget', command: 'wget --version 2>&1 | head -n1' },
+  { key: 'zip', command: 'zip --version 2>&1 | head -n2 | tail -n1' },
+  { key: 'unzip', command: 'unzip -v 2>&1 | head -n1' },
+  { key: 'expect', command: 'expect -version 2>&1' },
+  { key: 'screen', command: 'screen --version 2>&1' },
+  { key: 'xvfb', command: 'Xvfb -version 2>&1 | head -n1', fallbacks: ['dpkg -l xvfb 2>/dev/null | grep xvfb | head -1'] },
 ];
 
 /**
@@ -202,7 +235,17 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
 
         // Browser Automation
         playwright: versions.playwright,
+        playwrightTest: versions.playwrightTest,
         playwrightMcp: versions.playwrightMcp,
+        playwrightMcpStatus: versions.playwrightMcpStatus,
+        puppeteerBrowsers: versions.puppeteerBrowsers,
+
+        // Browsers
+        chrome: versions.chrome,
+        chromium: versions.chromium,
+        firefox: versions.firefox,
+        msedge: versions.msedge,
+        webkit: versions.webkit,
 
         // JavaScript/Node.js
         node: versions.node,
@@ -246,6 +289,19 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
         elan: versions.elan,
         lake: versions.lake,
 
+        // Ruby
+        ruby: versions.ruby,
+        rbenv: versions.rbenv,
+
+        // Kotlin
+        kotlin: versions.kotlin,
+
+        // Swift
+        swift: versions.swift,
+
+        // R
+        r: versions.r,
+
         // C/C++
         gcc: versions.gcc,
         gpp: versions.gpp,
@@ -258,7 +314,17 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
         // Development Tools
         git: versions.git,
         gh: versions.gh,
+        glab: versions.glab,
         brew: versions.brew,
+        nasm: versions.nasm,
+        fasm: versions.fasm,
+        curl: versions.curl,
+        wget: versions.wget,
+        zip: versions.zip,
+        unzip: versions.unzip,
+        expect: versions.expect,
+        screen: versions.screen,
+        xvfb: versions.xvfb,
 
         // Platform
         platform: versions.platform,
@@ -407,7 +473,7 @@ export function formatVersionMessage(versions) {
 
   if (perlLines.length > 0) {
     lines.push('');
-    lines.push('*💎 Perl*');
+    lines.push('*🐪 Perl*');
     lines.push(...perlLines);
   }
 
@@ -435,6 +501,38 @@ export function formatVersionMessage(versions) {
     lines.push(...leanLines);
   }
 
+  // === Ruby ===
+  const rubyLines = [];
+  addVersionLine(rubyLines, 'Ruby', versions.ruby);
+  addVersionLine(rubyLines, 'Rbenv', versions.rbenv);
+
+  if (rubyLines.length > 0) {
+    lines.push('');
+    lines.push('*💎 Ruby*');
+    lines.push(...rubyLines);
+  }
+
+  // === Kotlin ===
+  if (versions.kotlin) {
+    lines.push('');
+    lines.push('*🟣 Kotlin*');
+    addVersionLine(lines, 'Kotlin', versions.kotlin);
+  }
+
+  // === Swift ===
+  if (versions.swift) {
+    lines.push('');
+    lines.push('*🦅 Swift*');
+    addVersionLine(lines, 'Swift', versions.swift);
+  }
+
+  // === R ===
+  if (versions.r) {
+    lines.push('');
+    lines.push('*📊 R*');
+    addVersionLine(lines, 'R', versions.r);
+  }
+
   // === C/C++ ===
   const cppLines = [];
   addVersionLine(cppLines, 'GCC', versions.gcc);
@@ -444,20 +542,60 @@ export function formatVersionMessage(versions) {
   addVersionLine(cppLines, 'LLD', versions.lld);
   addVersionLine(cppLines, 'Make', versions.make);
   addVersionLine(cppLines, 'CMake', versions.cmake);
+  addVersionLine(cppLines, 'NASM', versions.nasm);
+  addVersionLine(cppLines, 'FASM', versions.fasm);
 
   if (cppLines.length > 0) {
     lines.push('');
-    lines.push('*🔨 C/C++*');
+    lines.push('*🔨 C/C++/Assembly*');
     lines.push(...cppLines);
   }
 
+  // === Browsers ===
+  const browserLines = [];
+  addVersionLine(browserLines, 'Google Chrome', versions.chrome);
+  addVersionLine(browserLines, 'Chromium', versions.chromium);
+  addVersionLine(browserLines, 'Firefox', versions.firefox);
+  addVersionLine(browserLines, 'Microsoft Edge', versions.msedge);
+  addVersionLine(browserLines, 'WebKit', versions.webkit);
+
+  if (browserLines.length > 0) {
+    lines.push('');
+    lines.push('*🌐 Browsers*');
+    lines.push(...browserLines);
+  }
+
+  // === Browser Automation ===
+  const browserAutoLines = [];
+  addVersionLine(browserAutoLines, 'Playwright', versions.playwright);
+  addVersionLine(browserAutoLines, 'Playwright Test', versions.playwrightTest);
+  addVersionLine(browserAutoLines, 'Playwright MCP', versions.playwrightMcp);
+  if (versions.playwrightMcpStatus) {
+    browserAutoLines.push(`• Playwright MCP in Claude Code: \`${versions.playwrightMcpStatus}\``);
+  } else if (versions.playwrightMcp) {
+    browserAutoLines.push('• Playwright MCP in Claude Code: `not configured`');
+  }
+  addVersionLine(browserAutoLines, 'Puppeteer Browsers', versions.puppeteerBrowsers);
+
+  if (browserAutoLines.length > 0) {
+    lines.push('');
+    lines.push('*🎭 Browser Automation*');
+    lines.push(...browserAutoLines);
+  }
+
   // === Development Tools ===
   const toolLines = [];
   addVersionLine(toolLines, 'Git', versions.git);
   addVersionLine(toolLines, 'GitHub CLI', versions.gh);
-  addVersionLine(toolLines, 'Playwright', versions.playwright);
-  addVersionLine(toolLines, 'Playwright MCP', versions.playwrightMcp);
+  addVersionLine(toolLines, 'GitLab CLI', versions.glab);
   addVersionLine(toolLines, 'Homebrew', versions.brew);
+  addVersionLine(toolLines, 'cURL', versions.curl);
+  addVersionLine(toolLines, 'Wget', versions.wget);
+  addVersionLine(toolLines, 'Zip', versions.zip);
+  addVersionLine(toolLines, 'Unzip', versions.unzip);
+  addVersionLine(toolLines, 'Expect', versions.expect);
+  addVersionLine(toolLines, 'Screen', versions.screen);
+  addVersionLine(toolLines, 'Xvfb', versions.xvfb);
 
   if (toolLines.length > 0) {
     lines.push('');