@link-assistant/hive-mind 1.69.4 → 1.69.6

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

@@ -21,6 +21,7 @@ import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunni
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
+import { t } from './i18n.lib.mjs';
 
 export const QueueItemStatus = {
   QUEUED: 'queued',
@@ -51,6 +52,7 @@ class SolveQueueItem {
     // Issue #594: --show-limits virtual option (hive-telegram-bot only).
     this.showLimits = options.showLimits === true;
     this.limitsAtStart = options.limitsAtStart || null;
+    this.locale = options.locale || null;
     this.createdAt = new Date();
     this.startedAt = null;
     this.status = QueueItemStatus.QUEUED;
@@ -1094,7 +1096,7 @@ export class SolveQueue {
         this.stats.totalStarted++;
 
         // Update message to show Starting status
-        await this.updateItemMessage(item, formatStartingWorkSessionMessage({ infoBlock: item.infoBlock }));
+        await this.updateItemMessage(item, formatStartingWorkSessionMessage({ infoBlock: item.infoBlock, locale: item.locale }));
 
         this.log(`Starting: ${item.toString()} from ${tool} queue`);
 
@@ -1142,7 +1144,7 @@ export class SolveQueue {
 
           if (shouldUpdate) {
             const position = i + 1; // Position within this tool's queue
-            await this.updateItemMessage(item, `⏳ Waiting (${tool} queue #${position})\n\n${item.infoBlock}\n\n*Reason:*\n${item.waitingReason}`);
+            await this.updateItemMessage(item, `${t('telegram.solve_waiting', { tool, position }, { locale: item.locale })}\n\n${item.infoBlock}\n\n*${t('telegram.reason_label', {}, { locale: item.locale })}:*\n${item.waitingReason}`);
           }
         }
       }
@@ -1186,10 +1188,11 @@ export class SolveQueue {
                   sessionName,
                   isolationBackend: result.isolationBackend,
                   infoBlock: item.infoBlock,
+                  locale: item.locale,
                 });
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               } else {
-                const response = `❌ Error executing solve command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\`\n\n${item.infoBlock}`;
+                const response = `${t('telegram.error_executing_command', { commandName: 'solve' }, { locale: item.locale })}:\n\n\`\`\`\n${result.error || result.output}\n\`\`\`\n\n${item.infoBlock}`;
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               }
             } catch (error) {
@@ -1415,6 +1418,7 @@ export function createQueueExecuteCallback(executeStartScreen, trackSessionFn) {
           //   handler so it can render an end-of-task delta.
           showLimits: item.showLimits === true,
           limitsAtStart: item.limitsAtStart || null,
+          locale: item.locale || null,
         });
       }
     }

package/src/telegram-terminal-watch-command.lib.mjs

@@ -17,7 +17,7 @@ const activeWatches = new Map();
 
 function splitCommandArgs(text) {
   const body = String(text || '')
-    .replace(/^\/terminal_watch(?:@\w+)?\b/i, '')
+    .replace(/^\/(?:terminal_watch|watch)(?:@\w+)?\b/i, '')
     .trim();
   return body.match(/"[^"]*"|'[^']*'|\S+/g)?.map(token => token.replace(/^(['"])(.*)\1$/, '$2')) || [];
 }
@@ -171,6 +171,12 @@ async function querySessionStatusWithRetry(querySessionStatus, sessionId, verbos
   return null;
 }
 
+export function isTerminalWatchSessionRequester({ sessionInfo = null, userId = null } = {}) {
+  if (userId === null || userId === undefined) return false;
+  if (sessionInfo?.requesterUserId === null || sessionInfo?.requesterUserId === undefined) return false;
+  return String(sessionInfo.requesterUserId) === String(userId);
+}
+
 // Note: /terminal_watch never uploads the full session log itself (issue #1720).
 // Use /log <uuid> if you want the log file delivered as a document.
 function getDisplayedTerminalSnapshot(logText, options) {
@@ -229,7 +235,7 @@ export function watchTerminalLogSession({ bot, chatId, messageId, sessionId, log
 }
 
 function buildUsage() {
-  return 'Usage:\n• `/terminal_watch <UUID>`\n• Reply to a session message with `/terminal_watch`\n\nOptions: `--size 120x25`, `--width 120`, `--height 25`, `--interval-ms 2500`, `--max-chars 3400`';
+  return 'Usage:\n• `/terminal_watch <UUID>` (alias: `/watch <UUID>`)\n• Reply to a session message with `/terminal_watch` or `/watch`\n\nOptions: `--size 120x25`, `--width 120`, `--height 25`, `--interval-ms 2500`, `--max-chars 3400`';
 }
 
 async function createWatchMessage({ ctx, targetChatId, replyToMessageId, text }) {
@@ -302,12 +308,14 @@ export async function startAutoTerminalWatchForSession({ bot, ctx, sessionId, se
 
 export async function registerTerminalWatchCommand(bot, options) {
   const { VERBOSE = false, isOldMessage, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
-  const runner = await import('./isolation-runner.lib.mjs');
+  const runner = !options.querySessionStatus || !options.isTerminalSessionStatus ? await import('./isolation-runner.lib.mjs') : null;
+  const querySessionStatus = options.querySessionStatus || runner.querySessionStatus;
+  const isTerminalSessionStatus = options.isTerminalSessionStatus || runner.isTerminalSessionStatus;
   const getTrackedSessionInfo = options.getTrackedSessionInfo || (await import('./session-monitor.lib.mjs')).getTrackedSessionInfo;
   const detectRepositoryVisibility = options.detectRepositoryVisibility || (await import('./github.lib.mjs')).detectRepositoryVisibility;
   const parseGitHubUrl = options.parseGitHubUrl || (await import('./github.lib.mjs')).parseGitHubUrl;
 
-  bot.command('terminal_watch', async ctx => {
+  const handleTerminalWatchCommand = async ctx => {
     VERBOSE && console.log('[VERBOSE] /terminal_watch command received');
     if (isOldMessage && isOldMessage(ctx)) return;
 
@@ -327,17 +335,23 @@ export async function registerTerminalWatchCommand(bot, options) {
       return;
     }
 
+    const sessionInfo = getTrackedSessionInfo ? getTrackedSessionInfo(sessionId) : null;
+
     if (chat.type !== 'private') {
-      try {
-        const member = await ctx.telegram.getChatMember(chat.id, ctx.from.id);
-        if (!member || member.status !== 'creator') {
-          await ctx.reply('❌ /terminal_watch is only available to the chat owner.', { reply_to_message_id: message.message_id });
+      if (isTerminalWatchSessionRequester({ sessionInfo, userId: ctx.from?.id })) {
+        VERBOSE && console.log(`[VERBOSE] /terminal_watch allowed for session requester ${ctx.from?.id} on ${sessionId}`);
+      } else {
+        try {
+          const member = await ctx.telegram.getChatMember(chat.id, ctx.from.id);
+          if (!member || member.status !== 'creator') {
+            await ctx.reply('❌ /terminal_watch is only available to the chat owner or the user who started this session.', { reply_to_message_id: message.message_id });
+            return;
+          }
+        } catch (error) {
+          console.error('[ERROR] /terminal_watch: getChatMember failed:', error);
+          await ctx.reply('❌ Failed to verify permissions for /terminal_watch.', { reply_to_message_id: message.message_id });
           return;
         }
-      } catch (error) {
-        console.error('[ERROR] /terminal_watch: getChatMember failed:', error);
-        await ctx.reply('❌ Failed to verify permissions for /terminal_watch.', { reply_to_message_id: message.message_id });
-        return;
       }
     }
 
@@ -349,7 +363,7 @@ export async function registerTerminalWatchCommand(bot, options) {
 
     let statusResult;
     try {
-      statusResult = await runner.querySessionStatus(sessionId, VERBOSE);
+      statusResult = await querySessionStatus(sessionId, VERBOSE);
     } catch (error) {
       console.error('[ERROR] /terminal_watch: querySessionStatus failed:', error);
       await ctx.reply(`❌ Failed to query session status: ${error.message || String(error)}`, { reply_to_message_id: message.message_id });
@@ -361,7 +375,6 @@ export async function registerTerminalWatchCommand(bot, options) {
       return;
     }
 
-    const sessionInfo = getTrackedSessionInfo ? getTrackedSessionInfo(sessionId) : null;
     const { repoVisibility, repoDescription } = await resolveTerminalWatchRepository({ sessionInfo, statusResult, parseGitHubUrl, detectRepositoryVisibility });
     const decision = decideLogDestination({ statusResult, sessionInfo, repoVisibility, chatType: chat.type });
     if (decision.destination === 'reject') {
@@ -378,13 +391,16 @@ export async function registerTerminalWatchCommand(bot, options) {
     }
 
     try {
-      await startWatchFromResolvedSession({ bot, ctx, sessionId, statusResult, sessionInfo, decision, logPath, watchOptions: parsedArgs.options, querySessionStatus: runner.querySessionStatus, isTerminalSessionStatus: runner.isTerminalSessionStatus, repoDescription, verbose: VERBOSE });
+      await startWatchFromResolvedSession({ bot, ctx, sessionId, statusResult, sessionInfo, decision, logPath, watchOptions: parsedArgs.options, querySessionStatus, isTerminalSessionStatus, repoDescription, verbose: VERBOSE });
     } catch (error) {
       console.error('[ERROR] /terminal_watch: failed to start watch:', error);
       const friendly = error?.code === 403 || /chat not found|bot can't initiate conversation/i.test(error?.message || '') ? 'I could not send you a DM. Please open a private chat with me and send /start, then try again.' : `Failed to start terminal watch: ${error.message || String(error)}`;
       await ctx.reply(`❌ ${friendly}`, { reply_to_message_id: message.message_id });
     }
-  });
+  };
+
+  bot.command('terminal_watch', handleTerminalWatchCommand);
+  bot.command('watch', handleTerminalWatchCommand);
 }
 
 export const __INTERNAL_FOR_TESTS__ = {

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

@@ -0,0 +1,112 @@
+import { t } from './i18n.lib.mjs';
+
+function tr(key, params = {}, locale = null) {
+  return t(key, params, { locale });
+}
+
+function addLine(parts, key, params, locale) {
+  parts.push(tr(key, params, locale));
+}
+
+export function buildTelegramInfoBlock({ locale = null, requester = '', urlKind = 'url', url = '', optionsRaw = '', lockedOptions = '' } = {}) {
+  const labelKey = urlKind === 'issue' ? 'telegram.info_issue_label' : urlKind === 'pullRequest' ? 'telegram.info_pull_request_label' : 'telegram.info_url_label';
+  let infoBlock = `${tr('telegram.info_requested_by_label', {}, locale)}: ${requester}\n${tr(labelKey, {}, locale)}: ${url}`;
+  if (optionsRaw) infoBlock += `\n\n${tr('telegram.info_options_label', {}, locale)}: ${optionsRaw}`;
+  if (lockedOptions) infoBlock += `${optionsRaw ? '\n' : '\n\n'}${tr('telegram.info_locked_options_label', {}, locale)}: ${lockedOptions}`;
+  return infoBlock;
+}
+
+export function buildSolveQueuedMessage({ locale = null, tool = 'claude', position = 1, infoBlock = '', reason = '' } = {}) {
+  let message = tr('telegram.solve_queued', { tool, position }, locale);
+  if (infoBlock) message += `\n\n${infoBlock}`;
+  if (reason) message += `\n\n${tr('telegram.waiting_label', {}, locale)}: ${reason}`;
+  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 = '' } = {}) {
+  const message = [];
+  addLine(message, 'telegram.help_title', {}, locale);
+  message.push('');
+
+  if (isStopped) {
+    addLine(message, 'telegram.help_status_stopped', {}, locale);
+    addLine(message, 'telegram.help_reason', { reason: stopReason }, locale);
+    if (stopInfo?.stoppedAt) addLine(message, 'telegram.help_stopped', { stoppedAt: stopInfo.stoppedAt.toISOString() }, locale);
+    addLine(message, 'telegram.help_resume', {}, locale);
+    message.push('');
+  }
+
+  addLine(message, 'telegram.help_diagnostic_information', {}, locale);
+  addLine(message, 'telegram.help_chat_id', { chatId }, locale);
+  if (topicId) addLine(message, 'telegram.help_topic_id', { topicId }, locale);
+  addLine(message, 'telegram.help_chat_type', { chatType }, locale);
+  addLine(message, 'telegram.help_chat_title', { chatTitle }, locale);
+  message.push('');
+  addLine(message, 'telegram.help_available_commands', {}, locale);
+  message.push('');
+
+  if (solveEnabled) {
+    addLine(message, 'telegram.help_solve_enabled', {}, locale);
+    addLine(message, 'telegram.help_solve_usage', {}, locale);
+    addLine(message, 'telegram.help_solve_example', {}, locale);
+    addLine(message, 'telegram.help_solve_alias_detail', {}, locale);
+    addLine(message, 'telegram.help_solve_reply', {}, locale);
+    if (solveOverrides.length > 0) addLine(message, 'telegram.help_locked_options', { options: solveOverrides.join(' ') }, locale);
+    message.push('');
+  } else {
+    addLine(message, 'telegram.help_solve_disabled', {}, locale);
+    message.push('');
+  }
+
+  if (taskEnabled) {
+    addLine(message, 'telegram.help_task_enabled', {}, locale);
+    addLine(message, 'telegram.help_task_usage', {}, locale);
+    addLine(message, 'telegram.help_task_example', {}, locale);
+    addLine(message, 'telegram.help_split_enabled', {}, locale);
+    addLine(message, 'telegram.help_split_usage', {}, locale);
+    addLine(message, 'telegram.help_split_example', {}, locale);
+    message.push('');
+  } else {
+    addLine(message, 'telegram.help_task_disabled', {}, locale);
+    message.push('');
+  }
+
+  if (hiveEnabled) {
+    addLine(message, 'telegram.help_hive_enabled', {}, locale);
+    addLine(message, 'telegram.help_hive_usage', {}, locale);
+    addLine(message, 'telegram.help_hive_example', {}, locale);
+    if (hiveOverrides.length > 0) addLine(message, 'telegram.help_locked_options', { options: hiveOverrides.join(' ') }, locale);
+    message.push('');
+  } else {
+    addLine(message, 'telegram.help_hive_disabled', {}, locale);
+    message.push('');
+  }
+
+  const simpleCommandKeys = ['telegram.help_solve_queue', 'telegram.help_limits', 'telegram.help_version', 'telegram.help_language', 'telegram.help_accept_invites', 'telegram.help_merge', 'telegram.help_merge_usage', 'telegram.help_merge_description', 'telegram.help_subscribe', 'telegram.help_help', 'telegram.help_stop_start', 'telegram.help_stop_uuid', 'telegram.help_log', 'telegram.help_terminal_watch'];
+  for (const key of simpleCommandKeys) addLine(message, key, {}, locale);
+  message.push('');
+  addLine(message, 'telegram.help_notifications', {}, locale);
+  if (isolationBackend) addLine(message, 'telegram.help_isolation_mode', { isolationBackend }, locale);
+  message.push('');
+  addLine(message, 'telegram.help_group_note', {}, locale);
+  message.push('');
+  addLine(message, 'telegram.help_common_options', {}, locale);
+  addLine(message, 'telegram.help_model_option', { modelDescription }, locale);
+  addLine(message, 'telegram.help_base_branch_option', {}, locale);
+  addLine(message, 'telegram.help_think_option', {}, locale);
+  addLine(message, 'telegram.help_verbose_option', {}, locale);
+  if (showLimitsEnabled) addLine(message, 'telegram.help_show_limits_option', {}, locale);
+  addLine(message, 'telegram.help_tip', {}, locale);
+
+  if (restrictedMode) {
+    message.push('');
+    addLine(message, 'telegram.help_restricted_mode', { authorized: authorized ? tr('telegram.yes', {}, locale) : tr('telegram.no', {}, locale) }, locale);
+    if (!authorized && allowTopicHint) addLine(message, 'telegram.help_allow_topic_hint', { allowTopicHint }, locale);
+  }
+
+  message.push('');
+  message.push('');
+  addLine(message, 'telegram.help_troubleshooting_header', {}, locale);
+  addLine(message, 'telegram.help_troubleshooting_body', {}, locale);
+  return message.join('\n');
+}

package/src/work-session-formatting.lib.mjs

@@ -1,5 +1,12 @@
+import { t } from './i18n.lib.mjs';
+
 const FAILURE_STATUSES = new Set(['failed', 'cancelled', 'canceled', 'error']);
 
+function text(locale, key, fallback, params = {}) {
+  if (!locale) return fallback;
+  return t(key, params, { locale });
+}
+
 function parseDateValue(value) {
   if (!value) return null;
   const date = value instanceof Date ? value : new Date(value);
@@ -41,15 +48,17 @@ export function formatSessionDurationSeconds(seconds) {
   return parts.join(' ');
 }
 
-export function formatStartingWorkSessionMessage({ infoBlock = '' } = {}) {
+export function formatStartingWorkSessionMessage({ infoBlock = '', locale = null } = {}) {
   const details = infoBlock ? `\n\n${infoBlock}` : '';
-  return `🔄 Starting...${details}`;
+  return `${text(locale, 'telegram.work_session_starting', '🔄 Starting...')}${details}`;
 }
 
-export function formatExecutingWorkSessionMessage({ sessionName = 'unknown', isolationBackend = null, infoBlock = '' } = {}) {
-  const isolationInfo = isolationBackend ? `\n🔒 Isolation: \`${isolationBackend}\`` : '';
+export function formatExecutingWorkSessionMessage({ sessionName = 'unknown', isolationBackend = null, infoBlock = '', locale = null } = {}) {
+  const sessionLabel = text(locale, 'telegram.session_label', 'Session');
+  const isolationLabel = text(locale, 'telegram.isolation_label', 'Isolation');
+  const isolationInfo = isolationBackend ? `\n🔒 ${isolationLabel}: \`${isolationBackend}\`` : '';
   const details = infoBlock ? `\n\n${infoBlock}` : '';
-  return `⏳ Executing...\n\n📊 Session: \`${sessionName}\`${isolationInfo}${details}`;
+  return `${text(locale, 'telegram.work_session_executing', '⏳ Executing...')}\n\n📊 ${sessionLabel}: \`${sessionName}\`${isolationInfo}${details}`;
 }
 
 /**
@@ -63,18 +72,24 @@ export function formatExecutingWorkSessionMessage({ sessionName = 'unknown', iso
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1688
  */
-export function appendPullRequestLine(infoBlock, pullRequestUrl) {
+export function appendPullRequestLine(infoBlock, pullRequestUrl, { locale = null } = {}) {
   if (!pullRequestUrl || !infoBlock) return infoBlock || '';
   if (infoBlock.includes(pullRequestUrl)) return infoBlock;
 
   const lines = infoBlock.split('\n');
   let lastUrlLineIdx = -1;
+  const urlLabels = ['Issue', 'Pull request', 'URL'];
+  if (locale) {
+    urlLabels.push(t('telegram.info_issue_label', {}, { locale }));
+    urlLabels.push(t('telegram.info_pull_request_label', {}, { locale }));
+    urlLabels.push(t('telegram.info_url_label', {}, { locale }));
+  }
   for (let i = 0; i < lines.length; i++) {
-    if (/^(Issue|Pull request|URL):\s/.test(lines[i])) {
+    if (urlLabels.some(label => lines[i].startsWith(`${label}: `))) {
       lastUrlLineIdx = i;
     }
   }
-  const prLine = `Pull request: ${pullRequestUrl}`;
+  const prLine = `${text(locale, 'telegram.info_pull_request_label', 'Pull request')}: ${pullRequestUrl}`;
   if (lastUrlLineIdx === -1) {
     return `${infoBlock}\n${prLine}`;
   }
@@ -83,24 +98,28 @@ export function appendPullRequestLine(infoBlock, pullRequestUrl) {
   return [...before, prLine, ...after].join('\n');
 }
 
-export function formatSessionCompletionMessage({ sessionName, sessionInfo, statusResult = null, observedEndTime = new Date(), exitCode = null, infoBlock = '', pullRequestUrl = null, extraSections = [] } = {}) {
+export function formatSessionCompletionMessage({ sessionName, sessionInfo, statusResult = null, observedEndTime = new Date(), exitCode = null, infoBlock = '', pullRequestUrl = null, extraSections = [], locale = null } = {}) {
   const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
   const failed = finalExitCode !== null && finalExitCode !== 0;
   const statusEmoji = failed ? '❌' : '✅';
-  const statusText = failed ? `Work session failed (exit code: ${finalExitCode})` : 'Work session finished successfully';
-  const isolationInfo = sessionInfo?.isolationBackend ? `\n🔒 Isolation: \`${sessionInfo.isolationBackend}\`` : '';
+  const messageLocale = locale || sessionInfo?.locale || null;
+  const statusText = failed ? text(messageLocale, 'telegram.work_session_failed', `Work session failed (exit code: ${finalExitCode})`, { exitCode: finalExitCode }) : text(messageLocale, 'telegram.work_session_finished', 'Work session finished successfully');
+  const durationLabel = text(messageLocale, 'telegram.duration_label', 'Duration');
+  const sessionLabel = text(messageLocale, 'telegram.session_label', 'Session');
+  const isolationLabel = text(messageLocale, 'telegram.isolation_label', 'Isolation');
+  const isolationInfo = sessionInfo?.isolationBackend ? `\n🔒 ${isolationLabel}: \`${sessionInfo.isolationBackend}\`` : '';
   const startTime = parseDateValue(statusResult?.startTime) || parseDateValue(sessionInfo?.startTime) || observedEndTime;
   const endTime = parseDateValue(statusResult?.endTime) || observedEndTime;
   const durationSeconds = Math.max(0, (endTime.getTime() - startTime.getTime()) / 1000);
   let resolvedInfoBlock = infoBlock || sessionInfo?.infoBlock || '';
   // Issue #1688: When the agent created a PR for an issue-driven /solve, append
   //   a 'Pull request:' line so the completion message includes both Issue and PR links.
-  if (pullRequestUrl) resolvedInfoBlock = appendPullRequestLine(resolvedInfoBlock, pullRequestUrl);
+  if (pullRequestUrl) resolvedInfoBlock = appendPullRequestLine(resolvedInfoBlock, pullRequestUrl, { locale: messageLocale });
   const details = resolvedInfoBlock ? `\n\n${resolvedInfoBlock}` : '';
 
   let message = `${statusEmoji} *${statusText}*\n\n`;
-  message += `⏱️ Duration: ${formatSessionDurationSeconds(durationSeconds)}\n`;
-  message += `📊 Session: \`${sessionName || 'unknown'}\`${isolationInfo}${details}`;
+  message += `⏱️ ${durationLabel}: ${formatSessionDurationSeconds(durationSeconds)}\n`;
+  message += `📊 ${sessionLabel}: \`${sessionName || 'unknown'}\`${isolationInfo}${details}`;
 
   // Issue #594: --show-limits virtual option appends snapshot/delta sections
   // (Markdown code blocks) below the standard completion details.