@link-assistant/hive-mind 1.46.5 → 1.46.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.46.7
+
+### Patch Changes
+
+- 249cf93: Fix --isolation option not working in /solve and /hive Telegram commands (#1534): extract --isolation from user args before validation, so it's used for execution isolation (via $ CLI from start-command) instead of being forwarded to solve/hive as an unknown argument. Per-command --isolation takes precedence over bot-level ISOLATION_BACKEND setting.
+
+## 1.46.6
+
+### Patch Changes
+
+- 6ab718a: Fix --interactive-mode completely broken (#1532): replace promisify(execFile) with spawn-based execFileAsync that correctly pipes stdin to child processes. The Node.js promisify(execFile) silently ignores the `input` option, causing `gh api --input -` to hang forever waiting for stdin data that never arrives, which blocks the entire stream processing loop.
+
 ## 1.46.5
 
 ### Patch Changes

package/package.json

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

package/src/interactive-mode.lib.mjs

@@ -52,12 +52,67 @@ const CONFIG = {
 // See: https://github.com/link-assistant/hive-mind/issues/1324
 import { sanitizeUnicode } from './unicode-sanitization.lib.mjs';
 
-// Use child_process for stdin-based API calls to avoid shell quoting issues
-// with large/complex comment bodies containing backticks, quotes, etc.
+// Use child_process.spawn for stdin-based API calls to avoid shell quoting
+// issues with large/complex comment bodies containing backticks, quotes, etc.
+// IMPORTANT: We use spawn (not execFile) because promisify(execFile) silently
+// ignores the `input` option — only the sync variants (execFileSync, execSync,
+// spawnSync) support `input`. Using execFile with `input` causes `gh api --input -`
+// to hang forever waiting for stdin, which blocks the stream processing loop and
+// prevents interactive mode from working at all.
 // See: https://github.com/link-assistant/hive-mind/issues/1458
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
+// See: https://github.com/link-assistant/hive-mind/issues/1532
+import { spawn } from 'node:child_process';
+
+/**
+ * Spawn a child process with stdin piping support.
+ * Unlike promisify(execFile), this correctly writes `input` to the child's
+ * stdin before closing it, so commands like `gh api --input -` work.
+ *
+ * @param {string} command - The command to run
+ * @param {string[]} args - Command arguments
+ * @param {Object} [options] - Options
+ * @param {string} [options.input] - Data to write to stdin
+ * @param {number} [options.maxBuffer=1048576] - Max stdout/stderr buffer size
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+const execFileAsync = (command, args, options = {}) => {
+  return new Promise((resolve, reject) => {
+    const { input, maxBuffer = 1024 * 1024, ...spawnOpts } = options;
+    const child = spawn(command, args, { ...spawnOpts, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    let stdoutLen = 0;
+    let stderrLen = 0;
+    child.stdout.on('data', chunk => {
+      const str = chunk.toString();
+      stdoutLen += str.length;
+      if (stdoutLen <= maxBuffer) stdout += str;
+    });
+    child.stderr.on('data', chunk => {
+      const str = chunk.toString();
+      stderrLen += str.length;
+      if (stderrLen <= maxBuffer) stderr += str;
+    });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code !== 0) {
+        const err = new Error(`Command failed: ${command} ${args.join(' ')}\n${stderr}`);
+        err.code = code;
+        err.stdout = stdout;
+        err.stderr = stderr;
+        reject(err);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+    if (input != null) {
+      child.stdin.write(input);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+  });
+};
 
 /**
  * Truncate content in the middle, keeping start and end
@@ -1302,6 +1357,7 @@ export const utils = {
   formatCost,
   escapeMarkdown,
   getToolIcon,
+  execFileAsync,
   CONFIG,
 };
 

package/src/telegram-bot.mjs

@@ -40,6 +40,7 @@ const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config
 const { parseGitHubUrl } = await import('./github.lib.mjs');
 const { validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
 const { validateBranchInArgs } = await import('./solve.branch.lib.mjs');
+const { extractIsolationFromArgs, isValidPerCommandIsolation, resolveIsolation, createIsolationAwareQueueCallback } = await import('./telegram-isolation.lib.mjs');
 const { formatUsageMessage, getAllCachedLimits } = await import('./limits.lib.mjs');
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
@@ -586,8 +587,7 @@ async function safeReply(ctx, text, options = {}) {
   }
 }
 
-// Execute a command via isolation mode ($ from start-command) or start-screen, then update message
-async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock) {
+async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null) {
   const { chat, message_id: msgId } = startingMessage;
   const safeEdit = async text => {
     try {
@@ -596,16 +596,16 @@ async function executeAndUpdateMessage(ctx, startingMessage, commandName, args,
       console.error(`[telegram-bot] Failed to update message for ${commandName}: ${e.message}`);
     }
   };
+  const iso = await resolveIsolation(perCommandIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE);
   let result,
     session,
     extraInfo = '';
-  if (ISOLATION_BACKEND && isolationRunner) {
-    const sid = isolationRunner.generateSessionId();
-    VERBOSE && console.log(`[VERBOSE] Using isolation (${ISOLATION_BACKEND}), session: ${sid}`);
-    result = await isolationRunner.executeWithIsolation(commandName, args, { backend: ISOLATION_BACKEND, sessionId: sid, verbose: VERBOSE });
-    session = sid;
-    extraInfo = `\n🔒 Isolation: \`${ISOLATION_BACKEND}\``;
-    if (result.success) trackSession(sid, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: ISOLATION_BACKEND, sessionId: sid }, VERBOSE);
+  if (iso) {
+    session = iso.runner.generateSessionId();
+    VERBOSE && console.log(`[VERBOSE] Using isolation (${iso.backend}), session: ${session}`);
+    result = await iso.runner.executeWithIsolation(commandName, args, { backend: iso.backend, sessionId: session, verbose: VERBOSE });
+    extraInfo = `\n🔒 Isolation: \`${iso.backend}\``;
+    if (result.success) trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: iso.backend, sessionId: session }, VERBOSE);
   } else {
     result = await executeStartScreen(commandName, args);
     const match = result.success && (result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -R\s+(\S+)/));
@@ -934,9 +934,12 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
-
-  // Merge user args with overrides
-  const args = mergeArgsWithOverrides(userArgs, solveOverrides);
+  const { backend: solvePerCommandIsolation, filteredArgs: userArgsWithoutIsolation } = extractIsolationFromArgs(userArgs); // issue #1534
+  if (solvePerCommandIsolation && !isValidPerCommandIsolation(solvePerCommandIsolation)) {
+    await safeReply(ctx, `❌ Invalid --isolation value '${escapeMarkdown(solvePerCommandIsolation)}'. Must be: screen, tmux, or docker`, { reply_to_message_id: ctx.message.message_id });
+    return;
+  }
+  const args = mergeArgsWithOverrides(userArgsWithoutIsolation, solveOverrides);
 
   // Determine tool from args (default: claude)
   let solveTool = 'claude';
@@ -1024,23 +1027,16 @@ async function handleSolveCommand(ctx) {
 
   if (check.canStart && queueStats.queued === 0) {
     const startingMessage = await safeReply(ctx, `🚀 Starting solve command...\n\n${infoBlock}`, { reply_to_message_id: ctx.message.message_id });
-    await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock);
+    await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock, solvePerCommandIsolation);
   } else {
-    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool });
+    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: solvePerCommandIsolation });
     let queueMessage = `📋 Solve command queued (position #${queueStats.queued + 1})\n\n${infoBlock}`;
     if (check.reason) queueMessage += `\n\n⏳ Waiting: ${escapeMarkdown(check.reason)}`;
     const queuedMessage = await safeReply(ctx, queueMessage, { reply_to_message_id: ctx.message.message_id });
     queueItem.messageInfo = { chatId: queuedMessage.chat.id, messageId: queuedMessage.message_id };
     if (!solveQueue.executeCallback) {
-      solveQueue.executeCallback =
-        ISOLATION_BACKEND && isolationRunner
-          ? async item => {
-              const sid = isolationRunner.generateSessionId();
-              const r = await isolationRunner.executeWithIsolation('solve', item.args, { backend: ISOLATION_BACKEND, sessionId: sid, verbose: VERBOSE });
-              if (r.success) trackSession(sid, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: 'solve', isolationBackend: ISOLATION_BACKEND, sessionId: sid }, VERBOSE);
-              return { ...r, output: r.output || `session: ${sid}` };
-            }
-          : createQueueExecuteCallback(executeStartScreen, (session, info) => trackSession(session, info, VERBOSE));
+      const _t = (s, i) => trackSession(s, i, VERBOSE);
+      solveQueue.executeCallback = createIsolationAwareQueueCallback(ISOLATION_BACKEND, isolationRunner, _t, createQueueExecuteCallback(executeStartScreen, _t), VERBOSE);
     }
   }
 }
@@ -1135,8 +1131,12 @@ async function handleHiveCommand(ctx) {
     if (VERBOSE) console.log(`[VERBOSE] /hive: Normalized ${p.type} URL to repo URL: ${normalizedArgs[0]}`);
   } else if (validation.normalizedUrl && validation.normalizedUrl !== userArgs[0]) normalizedArgs[0] = validation.normalizedUrl;
 
-  // Merge user args with overrides
-  const args = mergeArgsWithOverrides(normalizedArgs, hiveOverrides);
+  const { backend: hivePerCommandIsolation, filteredArgs: normalizedArgsWithoutIsolation } = extractIsolationFromArgs(normalizedArgs); // issue #1534
+  if (hivePerCommandIsolation && !isValidPerCommandIsolation(hivePerCommandIsolation)) {
+    await safeReply(ctx, `❌ Invalid --isolation value '${escapeMarkdown(hivePerCommandIsolation)}'. Must be: screen, tmux, or docker`, { reply_to_message_id: ctx.message.message_id });
+    return;
+  }
+  const args = mergeArgsWithOverrides(normalizedArgsWithoutIsolation, hiveOverrides);
 
   // Determine tool from args (default: claude)
   let hiveTool = 'claude';
@@ -1195,7 +1195,7 @@ async function handleHiveCommand(ctx) {
   }
 
   const startingMessage = await safeReply(ctx, `🚀 Starting hive command...\n\n${infoBlock}`, { reply_to_message_id: ctx.message.message_id });
-  await executeAndUpdateMessage(ctx, startingMessage, 'hive', args, infoBlock);
+  await executeAndUpdateMessage(ctx, startingMessage, 'hive', args, infoBlock, hivePerCommandIsolation);
 }
 
 bot.command(/^hive$/i, handleHiveCommand);

package/src/telegram-isolation.lib.mjs

@@ -0,0 +1,88 @@
+/**
+ * Per-command isolation support for Telegram bot commands.
+ *
+ * Extracts --isolation <backend> from user args in /solve and /hive commands,
+ * so it can be used for execution isolation (via $ CLI from start-command)
+ * instead of being forwarded to solve/hive as an unknown argument.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1534
+ * @see https://github.com/link-assistant/hive-mind/pull/390
+ */
+
+const VALID_ISOLATION_BACKENDS = ['screen', 'tmux', 'docker'];
+
+/**
+ * Extract --isolation <backend> from args array.
+ * Returns { backend: string|null, filteredArgs: string[] }.
+ * The --isolation flag is a per-command execution option (not a solve/hive option),
+ * so it must be stripped before passing args to solve/hive validation and execution.
+ */
+export function extractIsolationFromArgs(args) {
+  const filteredArgs = [];
+  let backend = null;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--isolation' && i + 1 < args.length) {
+      backend = args[i + 1].trim().toLowerCase();
+      i++; // Skip the value
+    } else if (args[i].startsWith('--isolation=')) {
+      backend = args[i].substring('--isolation='.length).trim().toLowerCase();
+    } else {
+      filteredArgs.push(args[i]);
+    }
+  }
+  return { backend, filteredArgs };
+}
+
+/**
+ * Validate an isolation backend value.
+ * @param {string} backend
+ * @returns {boolean}
+ */
+export function isValidPerCommandIsolation(backend) {
+  return VALID_ISOLATION_BACKENDS.includes(backend);
+}
+
+/**
+ * Get the effective isolation backend and runner for a command execution.
+ * Per-command isolation takes precedence over bot-level ISOLATION_BACKEND.
+ *
+ * @param {string|null} perCommandIsolation - Per-command --isolation value from user args
+ * @param {string} botIsolationBackend - Bot-level ISOLATION_BACKEND
+ * @param {object|null} botIsolationRunner - Bot-level isolation runner module
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {Promise<{backend: string, runner: object}|null>}
+ */
+export async function resolveIsolation(perCommandIsolation, botIsolationBackend, botIsolationRunner, verbose = false) {
+  const effectiveBackend = perCommandIsolation || botIsolationBackend;
+  if (!effectiveBackend) return null;
+
+  let runner = botIsolationRunner;
+  if (!runner) {
+    try {
+      runner = await import('./isolation-runner.lib.mjs');
+      if (verbose) console.log('[VERBOSE] Dynamically imported isolation-runner for per-command isolation');
+    } catch (e) {
+      console.error(`[telegram-bot] Failed to import isolation-runner: ${e.message}`);
+      return null;
+    }
+  }
+
+  return { backend: effectiveBackend, runner };
+}
+
+/**
+ * Create a queue execute callback that supports per-command isolation.
+ * Falls back to the provided fallback callback when no isolation is active.
+ */
+export function createIsolationAwareQueueCallback(botIsolationBackend, botIsolationRunner, trackSession, fallbackCallback, verbose) {
+  return async item => {
+    const iso = await resolveIsolation(item.perCommandIsolation, botIsolationBackend, botIsolationRunner, verbose);
+    if (iso) {
+      const sid = iso.runner.generateSessionId();
+      const r = await iso.runner.executeWithIsolation(item.command || 'solve', item.args, { backend: iso.backend, sessionId: sid, verbose });
+      if (r.success) trackSession(sid, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: item.command || 'solve', isolationBackend: iso.backend, sessionId: sid }, verbose);
+      return { ...r, output: r.output || `session: ${sid}` };
+    }
+    return fallbackCallback(item);
+  };
+}