@link-assistant/hive-mind 1.40.2 → 1.42.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.42.0
+
+### Minor Changes
+
+- 5aa82f5: Add /stop and /start commands for telegram bot to control task acceptance per chat (Issue #1081)
+
+## 1.41.0
+
+### Minor Changes
+
+- 2c9396d: feat: simplify Dockerfile — bump sandbox 1.5.0→1.6.0, remove Playwright setup, eliminate USER root, remove silent fallbacks (#1505)
+
 ## 1.40.2
 
 ### Patch Changes

package/package.json

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

package/src/telegram-bot.mjs

@@ -53,6 +53,7 @@ const { formatUsageMessage, getAllCachedLimits } = await import('./limits.lib.mj
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
 const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
+const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
 // Import bot launcher with exponential backoff retry (issue #1240)
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
@@ -603,23 +604,17 @@ async function executeAndUpdateMessage(ctx, startingMessage, commandName, args,
 }
 
 bot.command('help', async ctx => {
-  if (VERBOSE) {
-    console.log('[VERBOSE] /help command received');
-  }
+  VERBOSE && console.log('[VERBOSE] /help command received');
 
   // Ignore messages sent before bot started
   if (isOldMessage(ctx)) {
-    if (VERBOSE) {
-      console.log('[VERBOSE] /help ignored: old message');
-    }
+    VERBOSE && console.log('[VERBOSE] /help ignored: old message');
     return;
   }
 
   // Ignore forwarded or reply messages
   if (isForwardedOrReply(ctx)) {
-    if (VERBOSE) {
-      console.log('[VERBOSE] /help ignored: forwarded or reply');
-    }
+    VERBOSE && console.log('[VERBOSE] /help ignored: forwarded or reply');
     return;
   }
 
@@ -628,6 +623,19 @@ bot.command('help', async ctx => {
   const chatTitle = ctx.chat.title || 'Private Chat';
 
   let message = '🤖 *SwarmMindBot Help*\n\n';
+
+  // Show stopped status if chat is stopped (issue #1081)
+  if (isChatStopped(chatId)) {
+    const stopInfo = getChatStopInfo(chatId);
+    const reason = stopInfo?.reason || DEFAULT_STOP_REASON;
+    message += '🛑 *Bot Status: STOPPED*\n';
+    message += `Reason: ${reason}\n`;
+    if (stopInfo?.stoppedAt) {
+      message += `Stopped: ${stopInfo.stoppedAt.toISOString()}\n`;
+    }
+    message += 'Use /start (chat owner only) to resume.\n\n';
+  }
+
   message += '📋 *Diagnostic Information:*\n';
   message += `• Chat ID: \`${chatId}\`\n`;
   message += `• Chat Type: ${chatType}\n`;
@@ -666,8 +674,10 @@ bot.command('help', async ctx => {
   message += '*/merge* - Merge queue (experimental)\n';
   message += 'Usage: `/merge <github-repo-url>`\n';
   message += "Merges all PRs with 'ready' label sequentially.\n";
-  message += '*/help* - Show this help message\n\n';
-  message += '⚠️ *Note:* /solve, /hive, /solve\\_queue, /limits, /version, /accept\\_invites and /merge commands only work in group chats.\n\n';
+  message += '*/help* - Show this help message\n';
+  message += '*/stop* - Stop accepting new tasks (owner only)\n';
+  message += '*/start* - Resume accepting tasks (owner only)\n\n';
+  message += '⚠️ *Note:* /solve, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats.\n\n';
   message += '🔧 *Common Options:*\n';
   message += `• \`--model <model>\` or \`-m\` - ${buildModelOptionDescription()}\n`;
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
@@ -693,36 +703,20 @@ bot.command('help', async ctx => {
 });
 
 bot.command('limits', async ctx => {
-  if (VERBOSE) {
-    console.log('[VERBOSE] /limits command received');
-  }
+  VERBOSE && console.log('[VERBOSE] /limits command received');
 
   // Add breadcrumb for error tracking
-  await addBreadcrumb({
-    category: 'telegram.command',
-    message: '/limits command received',
-    level: 'info',
-    data: {
-      chatId: ctx.chat?.id,
-      chatType: ctx.chat?.type,
-      userId: ctx.from?.id,
-      username: ctx.from?.username,
-    },
-  });
+  await addBreadcrumb({ category: 'telegram.command', message: '/limits command received', level: 'info', data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username } });
 
   // Ignore messages sent before bot started
   if (isOldMessage(ctx)) {
-    if (VERBOSE) {
-      console.log('[VERBOSE] /limits ignored: old message');
-    }
+    VERBOSE && console.log('[VERBOSE] /limits ignored: old message');
     return;
   }
 
   // Ignore forwarded or reply messages
   if (isForwardedOrReply(ctx)) {
-    if (VERBOSE) {
-      console.log('[VERBOSE] /limits ignored: forwarded or reply');
-    }
+    VERBOSE && console.log('[VERBOSE] /limits ignored: forwarded or reply');
     return;
   }
 
@@ -736,9 +730,7 @@ bot.command('limits', async ctx => {
 
   const chatId = ctx.chat.id;
   if (!isChatAuthorized(chatId)) {
-    if (VERBOSE) {
-      console.log('[VERBOSE] /limits ignored: chat not authorized');
-    }
+    VERBOSE && console.log('[VERBOSE] /limits ignored: chat not authorized');
     await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
@@ -807,6 +799,8 @@ registerMergeCommand(bot, {
   isGroupChat: _isGroupChat,
   isChatAuthorized,
   addBreadcrumb,
+  isChatStopped,
+  getStoppedChatRejectMessage,
 });
 
 // Register /solve_queue command from separate module (issue #1232)
@@ -886,10 +880,15 @@ async function handleSolveCommand(ctx) {
     return;
   }
 
-  if (VERBOSE) {
-    console.log('[VERBOSE] /solve passed all checks, executing...');
+  // Check if chat is stopped (issue #1081) - reject with same style as queue rejected mode
+  if (isChatStopped(chatId)) {
+    VERBOSE && console.log('[VERBOSE] /solve rejected: chat is stopped');
+    await safeReply(ctx, getStoppedChatRejectMessage(chatId, 'Solve'), { reply_to_message_id: ctx.message.message_id });
+    return;
   }
 
+  VERBOSE && console.log('[VERBOSE] /solve passed all checks, executing...');
+
   let userArgs = parseCommandArgs(ctx.message.text);
 
   // Check if this is a reply to a message and user didn't provide URL as first argument
@@ -1109,10 +1108,15 @@ async function handleHiveCommand(ctx) {
     return;
   }
 
-  if (VERBOSE) {
-    console.log('[VERBOSE] /hive passed all checks, executing...');
+  // Check if chat is stopped (issue #1081) - reject with same style as queue rejected mode
+  if (isChatStopped(chatId)) {
+    VERBOSE && console.log('[VERBOSE] /hive rejected: chat is stopped');
+    await safeReply(ctx, getStoppedChatRejectMessage(chatId, 'Hive'), { reply_to_message_id: ctx.message.message_id });
+    return;
   }
 
+  VERBOSE && console.log('[VERBOSE] /hive passed all checks, executing...');
+
   const userArgs = parseCommandArgs(ctx.message.text);
 
   // Issue #1102: Allow issues_list/pulls_list URLs and normalize to repo URLs
@@ -1197,16 +1201,12 @@ async function handleHiveCommand(ctx) {
 
 bot.command(/^hive$/i, handleHiveCommand);
 
-// Register /top command from separate module
-// This keeps telegram-bot.mjs under the 1500 line limit
+// Register commands from separate modules (keeps telegram-bot.mjs under line limit)
 const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
-registerTopCommand(bot, {
-  VERBOSE,
-  isOldMessage,
-  isForwardedOrReply,
-  isGroupChat: _isGroupChat,
-  isChatAuthorized,
-});
+const { registerStartStopCommands } = await import('./telegram-start-stop-command.lib.mjs');
+const commandOptions = { VERBOSE, isOldMessage, isForwardedOrReply, isGroupChat: _isGroupChat, isChatAuthorized };
+registerTopCommand(bot, commandOptions);
+registerStartStopCommands(bot, commandOptions); // issue #1081
 
 // Add message listener for verbose debugging
 if (VERBOSE) {

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

@@ -133,7 +133,7 @@ function formatUserError(error, verbose) {
  * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
  */
 export function registerMergeCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb, isChatStopped, getStoppedChatRejectMessage } = options;
 
   bot.command(/^merge$/i, async ctx => {
     VERBOSE && console.log('[VERBOSE] /merge command received');
@@ -161,6 +161,13 @@ export function registerMergeCommand(bot, options) {
       });
     }
 
+    // Check if chat is stopped (issue #1081) - reject with same style as queue rejected mode
+    if (isChatStopped && isChatStopped(chatId)) {
+      VERBOSE && console.log('[VERBOSE] /merge rejected: chat is stopped');
+      const rejectMsg = getStoppedChatRejectMessage ? getStoppedChatRejectMessage(chatId, 'Merge') : '❌ Merge command rejected.';
+      return await ctx.reply(rejectMsg, { reply_to_message_id: ctx.message.message_id });
+    }
+
     // Parse arguments
     const args = parseCommandArgs(ctx.message.text);
 

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

@@ -0,0 +1,253 @@
+/**
+ * Telegram /start and /stop command implementation
+ *
+ * This module provides the /start and /stop command functionality for the Telegram bot,
+ * allowing chat owners to control whether the bot accepts new tasks in a specific chat.
+ *
+ * Features:
+ * - Per-chat stop state management
+ * - Owner-only access control (creator only, not admins)
+ * - Graceful stop: existing queue items continue to process
+ * - Read-only commands (/help, /limits, /version) remain available when stopped
+ * - Write commands (/solve, /hive) are rejected when stopped
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1081
+ */
+
+// Store stopped chats: Map<chatId, { stoppedAt: Date, stoppedBy: { id, username, firstName }, reason?: string }>
+const stoppedChats = new Map();
+
+/**
+ * Check if a chat is currently stopped
+ * @param {number} chatId - The chat ID to check
+ * @returns {boolean} True if the chat is stopped
+ */
+export function isChatStopped(chatId) {
+  return stoppedChats.has(chatId);
+}
+
+/**
+ * Get stop information for a chat
+ * @param {number} chatId - The chat ID
+ * @returns {Object|null} Stop info or null if not stopped
+ */
+export function getChatStopInfo(chatId) {
+  return stoppedChats.get(chatId) || null;
+}
+
+/**
+ * Set chat stopped state
+ * @param {number} chatId - The chat ID
+ * @param {boolean} stopped - Whether to stop or start the chat
+ * @param {Object} user - The user who issued the command (for stop)
+ * @param {string} [reason] - Optional reason for stopping (only used when stopped=true)
+ */
+export function setChatStopped(chatId, stopped, user = null, reason = null) {
+  if (stopped) {
+    stoppedChats.set(chatId, {
+      stoppedAt: new Date(),
+      stoppedBy: user
+        ? {
+            id: user.id,
+            username: user.username,
+            firstName: user.first_name,
+          }
+        : null,
+      reason: reason || null,
+    });
+  } else {
+    stoppedChats.delete(chatId);
+  }
+}
+
+/**
+ * Get all stopped chats (for debugging/admin purposes)
+ * @returns {Map} Map of stopped chats
+ */
+export function getStoppedChats() {
+  return stoppedChats;
+}
+
+/**
+ * Default reason used when no custom reason is provided for /stop
+ */
+export const DEFAULT_STOP_REASON = 'This bot is currently not accepting new tasks.';
+
+/**
+ * Get rejection message for when a command is used on a stopped chat.
+ * Matches the style of queue `rejected` mode output for consistency.
+ * @param {number} chatId - The chat ID
+ * @param {string} commandName - The command that was rejected (e.g., 'Solve', 'Hive')
+ * @returns {string} Markdown-formatted rejection message
+ */
+export function getStoppedChatRejectMessage(chatId, commandName = 'Command') {
+  const stopInfo = getChatStopInfo(chatId);
+  const reason = stopInfo?.reason || DEFAULT_STOP_REASON;
+  return `❌ ${commandName} command rejected.\n\n🚫 Reason: ${reason}\n\nUse /start to resume (chat owner only).`;
+}
+
+/**
+ * Registers the /start and /stop command handlers with the bot
+ * @param {Object} bot - The Telegraf bot instance
+ * @param {Object} options - Options object
+ * @param {boolean} options.VERBOSE - Whether to enable verbose logging
+ * @param {Function} options.isOldMessage - Function to check if message is old
+ * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
+ * @param {Function} options.isGroupChat - Function to check if chat is a group
+ * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ */
+export function registerStartStopCommands(bot, options) {
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized } = options;
+
+  /**
+   * Validate command context: checks old message, forwarded, group chat, authorized, and owner status.
+   * @param {Object} ctx - Telegraf context
+   * @param {string} cmdName - Command name for logging (e.g., '/stop', '/start')
+   * @param {Object} [opts] - Options
+   * @param {boolean} [opts.allowPrivate] - If true, skip group chat check (for /start welcome)
+   * @returns {Promise<{valid: boolean, chatId?: number, isPrivate?: boolean}>}
+   */
+  async function validateOwnerCommand(ctx, cmdName, opts = {}) {
+    VERBOSE && console.log(`[VERBOSE] ${cmdName} command received`);
+    if (isOldMessage(ctx)) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: old message`);
+      return { valid: false };
+    }
+    if (isForwardedOrReply(ctx)) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: forwarded or reply`);
+      return { valid: false };
+    }
+    if (!isGroupChat(ctx)) {
+      if (opts.allowPrivate) return { valid: false, isPrivate: true };
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: not a group chat`);
+      await ctx.reply(`❌ The ${cmdName} command only works in group chats.`, { reply_to_message_id: ctx.message.message_id });
+      return { valid: false };
+    }
+    const chatId = ctx.chat.id;
+    if (!isChatAuthorized(chatId)) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: chat not authorized`);
+      await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot.`, { reply_to_message_id: ctx.message.message_id });
+      return { valid: false };
+    }
+    try {
+      const chatMember = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (chatMember.status !== 'creator') {
+        VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: user is not chat owner`);
+        await ctx.reply('❌ This command is only available to the chat owner.', { reply_to_message_id: ctx.message.message_id });
+        return { valid: false };
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to check chat member status:', error);
+      await ctx.reply('❌ Failed to verify permissions.', { reply_to_message_id: ctx.message.message_id });
+      return { valid: false };
+    }
+    VERBOSE && console.log(`[VERBOSE] ${cmdName} passed all checks`);
+    return { valid: true, chatId };
+  }
+
+  // /stop command - stop accepting new tasks in this chat
+  // Only accessible by chat owner (creator)
+  bot.command('stop', async ctx => {
+    const check = await validateOwnerCommand(ctx, '/stop');
+    if (!check.valid) return;
+    const chatId = check.chatId;
+
+    // Check if already stopped
+    if (isChatStopped(chatId)) {
+      const stopInfo = getChatStopInfo(chatId);
+      const stoppedAtStr = stopInfo?.stoppedAt ? stopInfo.stoppedAt.toISOString() : 'unknown';
+      let alreadyStoppedMsg = `ℹ️ Bot is already stopped in this chat.\n\nStopped at: ${stoppedAtStr}`;
+      if (stopInfo?.reason) {
+        alreadyStoppedMsg += `\nReason: ${stopInfo.reason}`;
+      }
+      alreadyStoppedMsg += '\n\nUse /start to resume accepting tasks.';
+      await ctx.reply(alreadyStoppedMsg, {
+        reply_to_message_id: ctx.message.message_id,
+      });
+      return;
+    }
+
+    // Parse optional reason from message text (anything after "/stop ")
+    // Supports: /stop reason, /stop "reason", /stop 'reason'
+    const messageText = ctx.message.text || '';
+    let reason = messageText.replace(/^\/stop(@\w+)?\s*/i, '').trim() || null;
+    // Strip surrounding quotes (single or double) from reason
+    if (reason && ((reason.startsWith('"') && reason.endsWith('"')) || (reason.startsWith("'") && reason.endsWith("'")))) {
+      reason = reason.slice(1, -1).trim() || null;
+    }
+
+    if (VERBOSE && reason) {
+      console.log(`[VERBOSE] /stop reason: ${reason}`);
+    }
+
+    // Set chat as stopped with optional reason
+    setChatStopped(chatId, true, ctx.from, reason);
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Chat ${chatId} is now stopped`);
+    }
+
+    let stopMessage = '🛑 *Bot Stopped*\n\n' + 'This bot is now in read-only mode for this chat.\n\n';
+    if (reason) {
+      stopMessage += `*Reason:* ${reason}\n\n`;
+    }
+    stopMessage += '*Disabled commands:*\n' + '• /solve - No new issues will be accepted\n' + '• /hive - No new hive commands will be accepted\n' + '• /merge - No new merge operations will be accepted\n\n' + '*Still available:*\n' + '• /help - Show help\n' + '• /limits - Show usage limits\n' + '• /version - Show version info\n' + '• /start - Resume accepting tasks (owner only)\n\n' + '💡 Any tasks already in queue will continue to process.';
+
+    await ctx.reply(stopMessage, {
+      parse_mode: 'Markdown',
+      reply_to_message_id: ctx.message.message_id,
+    });
+  });
+
+  // /start command - resume accepting new tasks in this chat
+  // Only accessible by chat owner (creator)
+  // Note: This overrides Telegram's default /start behavior, but that's intentional
+  // as in group chats we want this to control the bot's task acceptance
+  bot.command('start', async ctx => {
+    const check = await validateOwnerCommand(ctx, '/start', { allowPrivate: true });
+    if (!check.valid) {
+      // In private chats, show a welcome message instead
+      if (check.isPrivate) {
+        VERBOSE && console.log('[VERBOSE] /start in private chat: showing welcome');
+        await ctx.reply('👋 *Welcome to SwarmMindBot!*\n\n' + 'This bot helps solve GitHub issues using AI.\n\n' + 'To use this bot:\n' + '1. Add me to a group chat\n' + '2. Make me an admin\n' + '3. Use /solve to solve GitHub issues\n\n' + 'Use /help in a group chat for more information.', { parse_mode: 'Markdown' });
+      }
+      return;
+    }
+    const chatId = check.chatId;
+
+    // Check if already running (not stopped)
+    if (!isChatStopped(chatId)) {
+      await ctx.reply('ℹ️ Bot is already accepting tasks in this chat.\n\nUse /help to see available commands.', {
+        reply_to_message_id: ctx.message.message_id,
+      });
+      return;
+    }
+
+    // Get stop info for the message
+    const stopInfo = getChatStopInfo(chatId);
+    const stoppedDuration = stopInfo?.stoppedAt ? Math.round((Date.now() - stopInfo.stoppedAt.getTime()) / 1000) : 0;
+
+    // Clear the stopped state
+    setChatStopped(chatId, false);
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Chat ${chatId} is now started`);
+    }
+
+    let durationStr = '';
+    if (stoppedDuration > 0) {
+      if (stoppedDuration < 60) {
+        durationStr = `${stoppedDuration} seconds`;
+      } else if (stoppedDuration < 3600) {
+        durationStr = `${Math.round(stoppedDuration / 60)} minutes`;
+      } else {
+        durationStr = `${Math.round(stoppedDuration / 3600)} hours`;
+      }
+    }
+
+    await ctx.reply('✅ *Bot Started*\n\n' + 'This bot is now accepting tasks in this chat.\n\n' + (durationStr ? `Bot was stopped for ${durationStr}.\n\n` : '') + 'Use /help to see available commands.', {
+      parse_mode: 'Markdown',
+      reply_to_message_id: ctx.message.message_id,
+    });
+  });
+}