@link-assistant/hive-mind 1.69.6 → 1.69.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.69.7
+
+### Patch Changes
+
+- 2ea2bb7: Extend Telegram `/stop` to accept a GitHub issue or pull-request URL (passed as the argument or contained in the replied-to message). The bot looks the URL up in the in-memory solve queue and either cancels the queued item or forwards CTRL+C via `$ --stop <UUID>` to the running isolated session. The UUID flow from #524 and the chat-level pause flow from #1081 are preserved.
+
 ## 1.69.6
 
 ### Patch Changes

package/package.json

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

package/src/telegram-bot.mjs

@@ -1057,7 +1057,7 @@ const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
 const { registerStartStopCommands } = await import('./telegram-start-stop-command.lib.mjs');
 const { registerLogCommand } = await import('./telegram-log-command.lib.mjs');
 registerTopCommand(bot, sharedCommandOpts);
-registerStartStopCommands(bot, sharedCommandOpts);
+registerStartStopCommands(bot, { ...sharedCommandOpts, getSolveQueue });
 await registerLogCommand(bot, sharedCommandOpts);
 await registerTerminalWatchCommand(bot, sharedCommandOpts);
 

package/src/telegram-start-stop-command.lib.mjs

@@ -13,13 +13,21 @@
  * - `/stop <UUID>` or reply-to-message-with-UUID forwards CTRL+C to the
  *   matching isolated solve/hive session via `$ --stop <UUID>` from
  *   link-foundation/start (issue #524).
+ * - `/stop <issue-or-pr-url>` (or reply to a message that contains one) looks
+ *   the URL up in the in-memory solve queue and either cancels the queued
+ *   item or forwards CTRL+C to the running isolated session (issue #1780).
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1081
  * @see https://github.com/link-assistant/hive-mind/issues/524
+ * @see https://github.com/link-assistant/hive-mind/issues/1780
  * @see https://github.com/link-foundation/start/issues/112
  */
 
 import { extractSessionIdFromText } from './telegram-log-command.lib.mjs';
+import { parseGitHubUrl } from './github.lib.mjs';
+import { cleanNonPrintableChars } from './telegram-markdown.lib.mjs';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 // Store stopped chats: Map<chatId, { stoppedAt: Date, stoppedBy: { id, username, firstName }, reason?: string }>
 const stoppedChats = new Map();
@@ -117,6 +125,66 @@ export function extractStopSessionId(text, repliedTo) {
   return { sessionId: null, source: null };
 }
 
+/**
+ * Walk arbitrary text and return the first GitHub issue or pull-request URL
+ * found, or null. Tolerates multiple URLs (returns the first issue/pull URL
+ * in source order). Uses the same `parseGitHubUrl` validator as the rest of
+ * the bot so the result is always a normalized URL string.
+ *
+ * @param {string} text
+ * @returns {string|null}
+ */
+function findFirstIssueOrPullUrl(text) {
+  if (!text || typeof text !== 'string') return null;
+  const cleaned = cleanNonPrintableChars(text);
+  for (const word of cleaned.split(/\s+/)) {
+    if (!word) continue;
+    const parsed = parseGitHubUrl(word);
+    if (parsed.valid && (parsed.type === 'issue' || parsed.type === 'pull')) {
+      return parsed.normalized;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract the target of a `/stop` invocation. Returns the most specific
+ * target found among the four possible sources, in this priority order:
+ *
+ *   1. UUID in the `/stop` argument        (kind='uuid', source='argument')
+ *   2. UUID in the replied-to message      (kind='uuid', source='reply')
+ *   3. Issue/PR URL in the `/stop` argument (kind='url',  source='argument')
+ *   4. Issue/PR URL in the replied-to text  (kind='url',  source='reply')
+ *
+ * UUIDs win over URLs because UUIDs are globally unique whereas a single
+ * issue URL can map to several in-flight requests if the user enqueued the
+ * same issue twice. Argument wins over reply because the argument is the
+ * more deliberate signal (the user explicitly typed it).
+ *
+ * @param {string} text - Raw `/stop ...` command text
+ * @param {Object|null|undefined} repliedTo - Telegram message object being replied to
+ * @returns {{ kind: 'uuid'|'url'|null, value: string|null, source: 'argument'|'reply'|null }}
+ * @see https://github.com/link-assistant/hive-mind/issues/1780
+ */
+export function extractStopTarget(text, repliedTo) {
+  const argText = String(text || '').replace(/^\/stop(?:@\w+)?\s*/i, '');
+  const replyText = repliedTo ? `${repliedTo.text || ''}\n${repliedTo.caption || ''}` : '';
+
+  const argUuid = extractSessionIdFromText(argText);
+  if (argUuid) return { kind: 'uuid', value: argUuid, source: 'argument' };
+
+  const replyUuid = extractSessionIdFromText(replyText);
+  if (replyUuid) return { kind: 'uuid', value: replyUuid, source: 'reply' };
+
+  const argUrl = findFirstIssueOrPullUrl(argText);
+  if (argUrl) return { kind: 'url', value: argUrl, source: 'argument' };
+
+  const replyUrl = findFirstIssueOrPullUrl(replyText);
+  if (replyUrl) return { kind: 'url', value: replyUrl, source: 'reply' };
+
+  return { kind: null, value: null, source: null };
+}
+
 /**
  * Registers the /start and /stop command handlers with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -129,9 +197,13 @@ export function extractStopSessionId(text, repliedTo) {
  * @param {Function} [options.isTopicAuthorized] - Topic-level authorization fallback
  * @param {Function} [options.buildAuthErrorMessage] - Builds the chat-not-authorized message
  * @param {Function} [options.stopIsolatedSession] - Override for tests; calls `$ --stop <uuid>`
+ * @param {Function} [options.getSolveQueue] - Returns the in-memory SolveQueue (for `/stop <url>`).
+ *   When omitted, the URL flow degrades gracefully to a "no queue available"
+ *   message so unit tests for non-URL paths don't need to construct a queue.
+ *   See https://github.com/link-assistant/hive-mind/issues/1780.
  */
 export function registerStartStopCommands(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, getSolveQueue } = options;
   const stopIsolatedSessionImpl = options.stopIsolatedSession || (async (...args) => (await import('./isolation-runner.lib.mjs')).stopIsolatedSession(...args));
 
   /**
@@ -180,12 +252,146 @@ export function registerStartStopCommands(bot, options) {
     return { valid: true, chatId };
   }
 
-  // /stop command. Two modes:
-  //   1. `/stop <UUID>` or reply-to-message-with-UUID — forward CTRL+C to the
-  //      matching isolated session via `$ --stop <UUID>` (issue #524).
-  //   2. bare `/stop` (optionally with a free-text reason) — pause new task
+  /**
+   * Owner-only auth check for the /stop UUID and /stop URL flows. Mirrors the
+   * /log auth model: in private DMs the user is implicitly the owner; in
+   * groups they must be the chat creator. Replies with the appropriate error
+   * directly when auth fails.
+   *
+   * @param {Object} ctx - Telegraf context
+   * @param {string} label - Short human-readable label for the variant ('UUID', 'URL')
+   * @returns {Promise<boolean>} true when authorized
+   */
+  async function authorizeTargetedStop(ctx, label) {
+    const message = ctx.message;
+    const chatId = ctx.chat?.id;
+    const chatType = ctx.chat?.type;
+    if (chatType === 'private') return true;
+    if (!isGroupChat(ctx)) {
+      await ctx.reply('❌ The /stop command only works in group chats or private chats with the bot.', { reply_to_message_id: message.message_id });
+      return false;
+    }
+    if (!isChatAuthorized(chatId)) {
+      if (!isTopicAuthorized || !isTopicAuthorized(ctx)) {
+        const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${chatId}) is not authorized to use this bot.`;
+        await ctx.reply(errMsg, { reply_to_message_id: message.message_id });
+        return false;
+      }
+    }
+    try {
+      const member = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (!member || member.status !== 'creator') {
+        VERBOSE && console.log(`[VERBOSE] /stop <${label}> ignored: user is not chat owner`);
+        await ctx.reply(`❌ /stop <${label}> is only available to the chat owner.`, { reply_to_message_id: message.message_id });
+        return false;
+      }
+    } catch (error) {
+      console.error(`[ERROR] /stop <${label}>: getChatMember failed:`, error);
+      await ctx.reply('❌ Failed to verify permissions for /stop.', { reply_to_message_id: message.message_id });
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Forward CTRL+C to a running isolated session via `$ --stop <uuid>`.
+   * Posts an ack reply, edits it with the result. Used by both the
+   * `/stop <UUID>` path (issue #524) and the `/stop <url>` path when the
+   * matched queue item is already executing in an isolated session
+   * (issue #1780).
+   *
+   * @param {Object} ctx - Telegraf context
+   * @param {string} sessionId - UUID of the session to stop
+   */
+  async function runStopIsolatedSessionFlow(ctx, sessionId) {
+    const message = ctx.message;
+    const ack = await ctx.reply(`⏹️ Asking session \`${sessionId}\` to stop (sending CTRL+C via \`$ --stop\`)…`, {
+      parse_mode: 'Markdown',
+      reply_to_message_id: message.message_id,
+    });
+
+    let result;
+    try {
+      result = await stopIsolatedSessionImpl(sessionId, VERBOSE);
+    } catch (error) {
+      console.error('[ERROR] /stop: stopIsolatedSession threw:', error);
+      result = { success: false, output: '', error: error?.message || String(error) };
+    }
+
+    const trimmedOutput = (result.output || '').toString().trim();
+    const trimmedError = (result.error || '').toString().trim();
+    const lines = [];
+    if (result.success) {
+      lines.push(`✅ Stop request sent to session \`${sessionId}\`.`);
+      lines.push('');
+      lines.push('The session should terminate shortly.');
+      if (trimmedOutput) {
+        lines.push('');
+        lines.push('```');
+        lines.push(trimmedOutput.slice(0, 1000));
+        lines.push('```');
+      }
+    } else {
+      lines.push(`❌ Failed to stop session \`${sessionId}\`.`);
+      if (trimmedError) {
+        lines.push('');
+        lines.push('```');
+        lines.push(trimmedError.slice(0, 1000));
+        lines.push('```');
+      }
+    }
+
+    try {
+      await ctx.telegram.editMessageText(ack.chat.id, ack.message_id, undefined, lines.join('\n'), { parse_mode: 'Markdown' });
+    } catch (error) {
+      console.error('[ERROR] /stop: editMessageText failed, falling back to reply:', error);
+      await ctx.reply(lines.join('\n'), { parse_mode: 'Markdown', reply_to_message_id: message.message_id });
+    }
+  }
+
+  /**
+   * Resolve a `/stop <url>` request against the in-memory solve queue.
+   * Returns an action descriptor that the dispatcher executes.
+   *
+   * @param {string} url - Normalized GitHub issue or PR URL
+   * @returns {{ action: 'no-queue'|'not-found'|'cancel-queued'|'stop-running'|'running-not-isolated', item?: Object, sessionId?: string|null, tool?: string|null }}
+   */
+  function resolveQueueLookupForUrl(url) {
+    if (typeof getSolveQueue !== 'function') {
+      return { action: 'no-queue' };
+    }
+    const queue = getSolveQueue({ verbose: VERBOSE });
+    const item = queue?.findByUrl?.(url);
+    if (!item) return { action: 'not-found' };
+
+    // Queued items have a defined .id and live in one of the per-tool queues.
+    // The cancel(id) call walks every per-tool queue and returns true on hit.
+    const cancelled = queue.cancel(item.id);
+    if (cancelled) {
+      return { action: 'cancel-queued', item, tool: item.tool || null };
+    }
+
+    // Not in a per-tool queue → must be in `processing`. If it was started
+    // via an isolation backend, item.sessionName is the start-command UUID
+    // and we can forward CTRL+C to it. Non-isolated runs have a screen name
+    // that is not UUID-shaped — we can't safely interrupt those from here.
+    const sessionId = item.sessionName && UUID_RE.test(item.sessionName) ? item.sessionName : null;
+    if (sessionId) {
+      return { action: 'stop-running', item, sessionId, tool: item.tool || null };
+    }
+    return { action: 'running-not-isolated', item, tool: item.tool || null };
+  }
+
+  // /stop command. Three modes (checked in this order, before any reply
+  // rejection so the queue-card-reply ergonomics from issue #1780 work):
+  //   1. `/stop <UUID>` or reply with UUID — forward CTRL+C via
+  //      `$ --stop <UUID>` (issue #524).
+  //   2. `/stop <issue-or-pr-url>` or reply containing that URL — look up
+  //      the matching solve queue item; cancel it if queued, forward
+  //      CTRL+C if running with isolation (issue #1780).
+  //   3. bare `/stop` (optionally with a free-text reason) — pause new task
   //      acceptance for the chat (issue #1081).
-  // Only accessible by chat owner (creator) in both modes.
+  // Only accessible by chat owner (creator) in modes 1, 2 (in groups).
   bot.command('stop', async ctx => {
     VERBOSE && console.log('[VERBOSE] /stop command received');
     if (isOldMessage(ctx)) {
@@ -193,92 +399,76 @@ export function registerStartStopCommands(bot, options) {
       return;
     }
 
-    // Detect UUID modes BEFORE the forwarded/reply rejection used by the
-    // chat-level stop, because the UUID-from-reply mode is intentionally a
-    // reply (issue #524).
+    // Detect UUID/URL targets BEFORE the forwarded/reply rejection used by
+    // the chat-level stop, because both targeted modes are intentionally
+    // delivered as replies (issues #524, #1780).
     const message = ctx.message;
     const repliedTo = message?.reply_to_message || null;
-    const { sessionId, source } = extractStopSessionId(message?.text || '', repliedTo);
+    const target = extractStopTarget(message?.text || '', repliedTo);
+
+    if (target.kind === 'uuid') {
+      const sessionId = target.value;
+      VERBOSE && console.log(`[VERBOSE] /stop: detected UUID ${sessionId} (source=${target.source})`);
+      const ok = await authorizeTargetedStop(ctx, 'UUID');
+      if (!ok) return;
+      await runStopIsolatedSessionFlow(ctx, sessionId);
+      return;
+    }
 
-    if (sessionId) {
-      VERBOSE && console.log(`[VERBOSE] /stop: detected UUID ${sessionId} (source=${source})`);
-      // Reuse the same auth model as /log: must be chat owner in groups; in
-      // private DMs the user is implicitly the owner of their own chat.
-      const chatId = ctx.chat?.id;
-      const chatType = ctx.chat?.type;
-      if (chatType !== 'private') {
-        if (!isGroupChat(ctx)) {
-          await ctx.reply('❌ The /stop command only works in group chats or private chats with the bot.', { reply_to_message_id: message.message_id });
-          return;
-        }
-        if (!isChatAuthorized(chatId)) {
-          if (!isTopicAuthorized || !isTopicAuthorized(ctx)) {
-            const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${chatId}) is not authorized to use this bot.`;
-            await ctx.reply(errMsg, { reply_to_message_id: message.message_id });
-            return;
-          }
-        }
-        try {
-          const member = await ctx.telegram.getChatMember(chatId, ctx.from.id);
-          if (!member || member.status !== 'creator') {
-            VERBOSE && console.log('[VERBOSE] /stop <UUID> ignored: user is not chat owner');
-            await ctx.reply('❌ /stop <UUID> is only available to the chat owner.', { reply_to_message_id: message.message_id });
-            return;
-          }
-        } catch (error) {
-          console.error('[ERROR] /stop <UUID>: getChatMember failed:', error);
-          await ctx.reply('❌ Failed to verify permissions for /stop.', { reply_to_message_id: message.message_id });
-          return;
-        }
+    if (target.kind === 'url') {
+      const url = target.value;
+      VERBOSE && console.log(`[VERBOSE] /stop: detected URL ${url} (source=${target.source})`);
+      const ok = await authorizeTargetedStop(ctx, 'URL');
+      if (!ok) return;
+
+      const lookup = resolveQueueLookupForUrl(url);
+      VERBOSE && console.log(`[VERBOSE] /stop: queue lookup for ${url} → ${lookup.action}`);
+
+      if (lookup.action === 'no-queue') {
+        await ctx.reply(`ℹ️ Cannot look up tasks by URL right now (the bot has no solve queue available in this context).\n\nIf you have the session UUID, you can use \`/stop <UUID>\` instead.`, {
+          parse_mode: 'Markdown',
+          reply_to_message_id: message.message_id,
+        });
+        return;
       }
 
-      const ack = await ctx.reply(`⏹️ Asking session \`${sessionId}\` to stop (sending CTRL+C via \`$ --stop\`)…`, {
-        parse_mode: 'Markdown',
-        reply_to_message_id: message.message_id,
-      });
-
-      let result;
-      try {
-        result = await stopIsolatedSessionImpl(sessionId, VERBOSE);
-      } catch (error) {
-        console.error('[ERROR] /stop <UUID>: stopIsolatedSession threw:', error);
-        result = { success: false, output: '', error: error?.message || String(error) };
+      if (lookup.action === 'not-found') {
+        await ctx.reply(`ℹ️ No queued or running task found for ${url}.\n\nIf the task is running with \`--isolation screen\`, try \`/stop <UUID>\` (the UUID is shown in the bot's session-id message).`, {
+          parse_mode: 'Markdown',
+          reply_to_message_id: message.message_id,
+        });
+        return;
       }
 
-      const trimmedOutput = (result.output || '').toString().trim();
-      const trimmedError = (result.error || '').toString().trim();
-      const lines = [];
-      if (result.success) {
-        lines.push(`✅ Stop request sent to session \`${sessionId}\`.`);
-        lines.push('');
-        lines.push('The session should terminate shortly.');
-        if (trimmedOutput) {
-          lines.push('');
-          lines.push('```');
-          lines.push(trimmedOutput.slice(0, 1000));
-          lines.push('```');
-        }
-      } else {
-        lines.push(`❌ Failed to stop session \`${sessionId}\`.`);
-        if (trimmedError) {
-          lines.push('');
-          lines.push('```');
-          lines.push(trimmedError.slice(0, 1000));
-          lines.push('```');
-        }
+      if (lookup.action === 'cancel-queued') {
+        VERBOSE && console.log(`[VERBOSE] /stop: cancelled queued item ${lookup.item?.id} for ${url}`);
+        const toolLabel = lookup.tool ? ` from \`${lookup.tool}\` queue` : '';
+        await ctx.reply(`🗑 Removed queued task for ${url}${toolLabel}.`, {
+          parse_mode: 'Markdown',
+          reply_to_message_id: message.message_id,
+        });
+        return;
       }
 
-      try {
-        await ctx.telegram.editMessageText(ack.chat.id, ack.message_id, undefined, lines.join('\n'), { parse_mode: 'Markdown' });
-      } catch (error) {
-        console.error('[ERROR] /stop <UUID>: editMessageText failed, falling back to reply:', error);
-        await ctx.reply(lines.join('\n'), { parse_mode: 'Markdown', reply_to_message_id: message.message_id });
+      if (lookup.action === 'stop-running') {
+        VERBOSE && console.log(`[VERBOSE] /stop: forwarding CTRL+C to running session ${lookup.sessionId} for ${url}`);
+        await runStopIsolatedSessionFlow(ctx, lookup.sessionId);
+        return;
       }
+
+      // running-not-isolated: a started, non-isolated screen session. We
+      // could shell out to `screen -X -S <name> stuff $'\003'`, but that's
+      // brittle and out of scope for #1780. Tell the user how to recover.
+      await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+        parse_mode: 'Markdown',
+        reply_to_message_id: message.message_id,
+      });
       return;
     }
 
-    // No UUID — fall through to the chat-level pause flow. That flow rejects
-    // forwards/replies on purpose (#1081) so a stray reply doesn't pause the chat.
+    // No UUID or URL — fall through to the chat-level pause flow. That flow
+    // rejects forwards/replies on purpose (#1081) so a stray reply doesn't
+    // pause the chat.
     if (isForwardedOrReply(ctx)) {
       VERBOSE && console.log('[VERBOSE] /stop ignored: forwarded or reply');
       return;