@link-assistant/hive-mind 2.7.3 → 2.8.0

package/src/telegram-fix-command.lib.mjs

@@ -0,0 +1,164 @@
+/**
+ * Telegram `/fix` command (issue #1733).
+ *
+ * Spawns the `fix` CLI in a work session, exactly like `/solve` and `/task` do
+ * for their own CLIs. `fix` creates the CI/CD remediation issue and then hands
+ * it off to `/solve --development-log --deep-analysis --auto-merge` itself, so
+ * this handler only has to validate the request and start the session.
+ */
+
+import { buildUserMention } from './buildUserMention.lib.mjs';
+import { validateModelName } from './models/index.mjs';
+import { parseFixRepository } from './fix.ci-cd.lib.mjs';
+import { escapeMarkdown } from './telegram-markdown.lib.mjs';
+import { extractIsolationFromArgs, isValidPerCommandIsolation } from './telegram-isolation.lib.mjs';
+import { moveArgumentToFront, parseCommandArgs } from './telegram-solve-command.lib.mjs';
+import { formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
+
+export const FIX_COMMAND_NAMES = Object.freeze(['fix']);
+
+export function getFixCommandNameFromText(text) {
+  if (!text || typeof text !== 'string') return null;
+  const firstLine = text.split('\n')[0].trim();
+  const match = firstLine.match(/^\/(\w+)(?:@\S+)?(?:\s|$)/);
+  const command = match ? match[1].toLowerCase() : null;
+  return FIX_COMMAND_NAMES.includes(command) ? command : null;
+}
+
+/**
+ * `--ci-cd` is the only mode `fix` supports today and it is required by the
+ * CLI, so the chat command implies it instead of making every user type it.
+ */
+export function applyFixCommandDefaults(args) {
+  const hasCiCd = args.includes('--ci-cd');
+  return hasCiCd ? args : [...args, '--ci-cd'];
+}
+
+export function findFixRepositoryArg(args) {
+  return args.find(arg => !arg.startsWith('-') && parseFixRepository(arg)) || null;
+}
+
+export function getFixToolFromArgs(args) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--tool' && i + 1 < args.length) return args[i + 1];
+    if (args[i].startsWith('--tool=')) return args[i].substring('--tool='.length);
+  }
+  return 'claude';
+}
+
+function getModelFromArgs(args) {
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--model' || args[i] === '-m') && i + 1 < args.length) return args[i + 1];
+    if (args[i].startsWith('--model=')) return args[i].substring('--model='.length);
+  }
+  return null;
+}
+
+function validateFixModel(args) {
+  const model = getModelFromArgs(args);
+  if (!model) return null;
+  const validation = validateModelName(model, getFixToolFromArgs(args));
+  return validation.valid ? null : validation.message;
+}
+
+export function buildFixCommandArgs(text) {
+  const args = applyFixCommandDefaults(parseCommandArgs(text));
+  const repositoryRaw = findFixRepositoryArg(args);
+  const repository = repositoryRaw ? parseFixRepository(repositoryRaw) : null;
+  return {
+    // `fix` reads the repository from the first bare argument, so normalize the
+    // shorthand (`owner/repo`) to a full URL and move it to the front.
+    args: repository ? moveArgumentToFront(args, repository.url, value => parseFixRepository(value)?.url || value) : args,
+    repositoryRaw,
+    repository,
+  };
+}
+
+// Issue #378: inject --language LOCALE into spawn args if no language flag is
+// already present, so spawned fix sessions inherit the user's effective locale.
+function injectLanguageIfMissing(args, locale) {
+  if (!locale || !args || !Array.isArray(args)) return args;
+  const langFlags = new Set(['--language', '--ui-language', '--work-language']);
+  for (const arg of args) {
+    const flag = arg.startsWith('--') ? arg.split('=')[0] : null;
+    if (flag && langFlags.has(flag)) return args;
+  }
+  return [...args, '--language', locale];
+}
+
+export function registerFixCommand(bot, options) {
+  const { VERBOSE, fixEnabled, addBreadcrumb, isOldMessage, isForwardedOrReply, isGroupChat, isTopicAuthorized, buildAuthErrorMessage, isChatStopped, getStoppedChatRejectMessage, safeReply, executeAndUpdateMessage, resolveLocale = null } = options;
+
+  async function handleFixCommand(ctx) {
+    const commandDisplay = '/fix';
+    VERBOSE && console.log(`[VERBOSE] ${commandDisplay} command received`);
+
+    await addBreadcrumb({
+      category: 'telegram.command',
+      message: `${commandDisplay} command received`,
+      level: 'info',
+      data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username },
+    });
+
+    if (!fixEnabled) {
+      await ctx.reply('❌ The fix command is disabled on this bot instance.');
+      return;
+    }
+    if (isOldMessage(ctx)) return;
+    // Issue #1922: a forwarded or replied-to /fix command must never be
+    // re-executed. Unlike /task, /fix takes no input from the replied message,
+    // so both cases are ignored.
+    if (isForwardedOrReply && isForwardedOrReply(ctx)) {
+      VERBOSE && console.log(`[VERBOSE] ${commandDisplay} ignored: forwarded or reply message`);
+      return;
+    }
+    if (!isGroupChat(ctx)) {
+      await ctx.reply(`❌ The ${commandDisplay} command only works in group chats. Please add this bot to a group and make it an admin.`, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+    if (!isTopicAuthorized(ctx)) {
+      await ctx.reply(buildAuthErrorMessage(ctx), { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+    if (isChatStopped(ctx.chat.id)) {
+      await safeReply(ctx, getStoppedChatRejectMessage(ctx.chat.id, 'Fix'), { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    const built = buildFixCommandArgs(ctx.message.text);
+    if (!built.repository) {
+      await safeReply(ctx, `❌ Missing GitHub repository URL. Usage: \`${commandDisplay} <github-repository-url> [options]\`\n\nExample: \`${commandDisplay} https://github.com/owner/repo\``, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    const { backend: perCommandIsolation, filteredArgs } = extractIsolationFromArgs(built.args);
+    if (perCommandIsolation && !isValidPerCommandIsolation(perCommandIsolation)) {
+      await safeReply(ctx, `❌ Invalid --isolation value '${escapeMarkdown(perCommandIsolation)}'. Must be: screen, tmux, or docker`, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    const modelError = validateFixModel(filteredArgs);
+    if (modelError) {
+      await safeReply(ctx, `❌ ${escapeMarkdown(modelError)}`, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
+    const userOptionsRaw = built.args.slice(1).join(' ');
+    let infoBlock = `Requested by: ${requester}\nRepository: ${escapeMarkdown(built.repository.url)}`;
+    if (userOptionsRaw) infoBlock += `\n\n🛠 Options: ${escapeMarkdown(userOptionsRaw)}`;
+
+    const fixUrlContext = { owner: built.repository.owner, repo: built.repository.repo, normalized: built.repository.url };
+    const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock }), { reply_to_message_id: ctx.message.message_id });
+    const fixLocale = resolveLocale ? resolveLocale(ctx) : null;
+    const argsForExec = injectLanguageIfMissing(filteredArgs, fixLocale);
+    await executeAndUpdateMessage(ctx, startingMessage, 'fix', argsForExec, infoBlock, perCommandIsolation || null, getFixToolFromArgs(argsForExec), fixUrlContext);
+  }
+
+  bot.command(
+    FIX_COMMAND_NAMES.map(command => new RegExp(`^${command}$`, 'i')),
+    handleFixCommand
+  );
+
+  return { handleFixCommand, FIX_COMMAND_NAMES };
+}

package/src/telegram-merge-queue.lib.mjs

@@ -21,6 +21,7 @@ import { resolveMergeTargetItems } from './github-merge-targets.lib.mjs';
 import { waitForPRReady as waitForPRReadyHelper } from './telegram-merge-wait.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
+import { cancellableSleep as cancellableSleepUntil } from './interruptible-sleep.lib.mjs';
 
 /**
  * Status enum for merge queue operations
@@ -495,7 +496,17 @@ export class MergeQueueProcessor {
     try {
       // Step 1: Check if PR is mergeable
       item.status = MergeItemStatus.CHECKING_CI;
-      const mergeableCheck = await this.checkPRMergeable(this.owner, this.repo, item.pr.number, this.verbose);
+      // Issue #2072: pass cancellation down so the UNKNOWN-mergeability retry delay aborts early
+      const mergeableCheck = await this.checkPRMergeable(this.owner, this.repo, item.pr.number, this.verbose, { isCancelled: () => this.isCancelled });
+
+      // Issue #2072: a cancel during the mergeability check must skip the PR, not fail it.
+      if (mergeableCheck.cancelled || this.isCancelled) {
+        item.status = MergeItemStatus.SKIPPED;
+        item.error = 'Cancelled';
+        this.stats.skipped++;
+        this.log(`Skipped PR #${item.pr.number}: cancelled during mergeability check`);
+        return;
+      }
 
       if (mergeableCheck.terminal) {
         item.status = MergeItemStatus.FAILED;
@@ -893,7 +904,7 @@ export class MergeQueueProcessor {
         if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
           return { outcome: 'error', error: error.message };
         }
-        await this.cancellableSleep(pollInterval);
+        await this.sleep(pollInterval);
         continue;
       }
 
@@ -912,27 +923,12 @@ export class MergeQueueProcessor {
         }
       }
 
-      await this.cancellableSleep(pollInterval);
+      await this.sleep(pollInterval);
     }
 
     return { outcome: 'timeout' };
   }
 
-  /**
-   * Issue #1807: Sleep helper that bails out as soon as cancellation is
-   * requested. Used by the auto-resolve poll loop so a `cancel()` call
-   * doesn't have to wait a full polling interval before taking effect.
-   */
-  async cancellableSleep(ms) {
-    const step = Math.min(ms, 1000);
-    const deadline = Date.now() + ms;
-    while (Date.now() < deadline) {
-      if (this.isCancelled) return;
-      const remaining = deadline - Date.now();
-      await this.sleep(Math.min(step, remaining));
-    }
-  }
-
   /**
    * Wait for any active CI runs on the target branch to complete
    * Issue #1307: Prevents merging while post-merge CI from previous merges is still running
@@ -1456,10 +1452,17 @@ export class MergeQueueProcessor {
   }
 
   /**
-   * Sleep helper
+   * Sleep helper.
+   *
+   * Issue #2072: this is the single sleep primitive for the queue, and it is
+   * cancellable — it returns as soon as `cancel()` is called (checked every
+   * 100ms) or SIGINT/SIGTERM arrives, instead of sleeping out the full delay.
+   * Every wait in the queue routes through here, so no stage of `/merge` can
+   * hold up a cancel by more than ~100ms. This supersedes the separate
+   * `cancellableSleep` helper added for #1807.
    */
   sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return cancellableSleepUntil(ms, () => this.isCancelled);
   }
 }
 

package/src/telegram-merge-wait.lib.mjs

@@ -65,8 +65,14 @@ export async function waitForPRReady(processor, item, initialCheck, options) {
       await processor.onProgress(processor.getProgressUpdate());
     }
 
+    // Issue #2072: `processor.sleep` returns early on cancel. The poll interval defaults
+    // to 5 minutes, which previously kept `/merge` running long after Cancel was pressed.
     await processor.sleep(pollIntervalMs);
-    latestCheck = await processor.checkPRMergeable(processor.owner, processor.repo, item.pr.number, processor.verbose);
+    if (processor.isCancelled) {
+      return { success: false, status: 'cancelled', error: 'Cancelled' };
+    }
+
+    latestCheck = await processor.checkPRMergeable(processor.owner, processor.repo, item.pr.number, processor.verbose, { isCancelled: () => processor.isCancelled });
   }
 }
 

package/src/telegram-ui-messages.lib.mjs

@@ -23,7 +23,7 @@ export function buildSolveQueuedMessage({ locale = null, tool = 'claude', positi
   return message;
 }
 
-export function buildTelegramHelpMessage({ locale = null, chatId, chatType = '', chatTitle = '', topicId = null, isStopped = false, stopInfo = null, stopReason = '', solveEnabled = true, taskEnabled = true, hiveEnabled = true, solveOverrides = [], hiveOverrides = [], showLimitsEnabled = false, isolationBackend = null, modelDescription = '', restrictedMode = false, authorized = null, allowTopicHint = '' } = {}) {
+export function buildTelegramHelpMessage({ locale = null, chatId, chatType = '', chatTitle = '', topicId = null, isStopped = false, stopInfo = null, stopReason = '', solveEnabled = true, taskEnabled = true, fixEnabled = true, hiveEnabled = true, solveOverrides = [], hiveOverrides = [], showLimitsEnabled = false, isolationBackend = null, modelDescription = '', restrictedMode = false, authorized = null, allowTopicHint = '' } = {}) {
   const message = [];
   addLine(message, 'telegram.help_title', {}, locale);
   message.push('');
@@ -71,6 +71,16 @@ export function buildTelegramHelpMessage({ locale = null, chatId, chatType = '',
     message.push('');
   }
 
+  if (fixEnabled) {
+    addLine(message, 'telegram.help_fix_enabled', {}, locale);
+    addLine(message, 'telegram.help_fix_usage', {}, locale);
+    addLine(message, 'telegram.help_fix_example', {}, locale);
+    message.push('');
+  } else {
+    addLine(message, 'telegram.help_fix_disabled', {}, locale);
+    message.push('');
+  }
+
   if (hiveEnabled) {
     addLine(message, 'telegram.help_hive_enabled', {}, locale);
     addLine(message, 'telegram.help_hive_usage', {}, locale);

package/src/telegram.config.lib.mjs

@@ -0,0 +1,96 @@
+// CLI configuration module for the telegram-bot command.
+// Extracted from telegram-bot.mjs so the option surface can be reviewed, tested
+// and reused without loading the bot itself.
+//
+// Defaults read the environment through getenv() when createYargsConfig() runs,
+// so callers must load .env/.lenv configuration before calling it.
+
+import { getenv } from './cli-arguments.lib.mjs';
+
+export const createYargsConfig = yargsInstance =>
+  yargsInstance
+    .usage('Usage: hive-telegram-bot [options]')
+    .option('configuration', {
+      type: 'string',
+      description: 'LINO configuration string for environment variables',
+      alias: 'c',
+      default: getenv('TELEGRAM_CONFIGURATION', ''),
+    })
+    .option('token', {
+      type: 'string',
+      description: 'Telegram bot token from @BotFather',
+      alias: 't',
+      default: getenv('TELEGRAM_BOT_TOKEN', ''),
+    })
+    .option('allowedChats', {
+      type: 'string',
+      description: 'Allowed chat IDs in lino notation, e.g., "(\n  123456789\n  987654321\n)"',
+      alias: 'allowed-chats',
+      default: getenv('TELEGRAM_ALLOWED_CHATS', ''),
+    })
+    .option('allowedTopics', {
+      type: 'string',
+      description: 'Allowed topic IDs in Links Notation format "chatId topicId" pairs',
+      alias: 'allowed-topics',
+      default: getenv('TELEGRAM_ALLOWED_TOPICS', ''),
+    })
+    .option('solveOverrides', {
+      type: 'string',
+      description: 'Override options for /solve command in lino notation, e.g., "(\n  --auto-continue\n  --attach-logs\n)"',
+      alias: 'solve-overrides',
+      default: getenv('TELEGRAM_SOLVE_OVERRIDES', ''),
+    })
+    .option('hiveOverrides', {
+      type: 'string',
+      description: 'Override options for /hive command in lino notation, e.g., "(\n  --verbose\n  --all-issues\n)"',
+      alias: 'hive-overrides',
+      default: getenv('TELEGRAM_HIVE_OVERRIDES', ''),
+    })
+    .option('solve', {
+      type: 'boolean',
+      description: 'Enable /solve command (use --no-solve to disable)',
+      default: getenv('TELEGRAM_SOLVE', 'true') !== 'false',
+    })
+    .option('hive', {
+      type: 'boolean',
+      description: 'Enable /hive command (use --no-hive to disable)',
+      default: getenv('TELEGRAM_HIVE', 'true') !== 'false',
+    })
+    .option('task', {
+      type: 'boolean',
+      description: 'Enable /task and /split commands (use --no-task to disable)',
+      default: getenv('TELEGRAM_TASK', 'true') !== 'false',
+    })
+    .option('fix', {
+      type: 'boolean',
+      description: 'Enable /fix command (use --no-fix to disable)',
+      default: getenv('TELEGRAM_FIX', 'true') !== 'false',
+    })
+    .option('auth', {
+      type: 'boolean',
+      description: 'Enable experimental private /auth command for allowlisted chat owners (use --no-auth to disable)',
+      default: getenv('TELEGRAM_AUTH', 'true') !== 'false',
+    })
+    .option('dryRun', {
+      type: 'boolean',
+      description: 'Validate configuration and options without starting the bot',
+      alias: 'dry-run',
+      default: false,
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description: 'Enable verbose logging for debugging',
+      alias: 'v',
+      default: getenv('TELEGRAM_BOT_VERBOSE', 'false') === 'true',
+    })
+    .option('autoStartScreenWatchMessage', { type: 'boolean', description: 'Experimental: auto-start separate /terminal_watch messages for public /solve sessions', alias: 'auto-start-screen-watch-message', default: getenv('TELEGRAM_AUTO_START_SCREEN_WATCH_MESSAGE', getenv('TELEGRAM_AUTO_WATCH_MESSAGE', 'false')) === 'true' })
+    // Issue #594: bot-owner toggle for --show-limits virtual option in /solve and /hive.
+    .option('showLimits', { type: 'boolean', description: 'Experimental: allow /solve and /hive callers to use --show-limits to embed Claude/Codex usage at start, end, and delta in the completion message', alias: 'show-limits', default: getenv('TELEGRAM_SHOW_LIMITS', 'true') !== 'false' })
+    .option('isolation', { type: 'string', description: "Isolation backend (screen/tmux/docker). Defaults to 'docker' so Telegram-bot work sessions run in Docker isolation; pass --isolation '' (or set TELEGRAM_ISOLATION='') to disable.", default: getenv('TELEGRAM_ISOLATION', 'docker') })
+    .help('h')
+    .alias('h', 'help')
+    .parserConfiguration({
+      'boolean-negation': true,
+      'strip-dashed': true, // Remove dashed keys from argv to simplify validation
+    })
+    .strict(); // Enable strict mode to reject unknown options (consistent with solve.mjs and hive.mjs)