telegram-claude-mcp 1.6.0 → 2.0.1

package/src/daemon/telegram-multi.ts

@@ -0,0 +1,611 @@
+/**
+ * Multi-Session Telegram Manager for the Daemon
+ *
+ * Unlike the per-session TelegramManager, this one handles all sessions
+ * with proper routing based on session IDs.
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import type { SessionManager, ConnectedSession } from './session-manager.js';
+
+export interface PermissionDecision {
+  behavior: 'allow' | 'deny';
+  message?: string;
+}
+
+export interface HookEvent {
+  type: 'permission_request' | 'stop' | 'notification' | 'session_start' | 'session_end';
+  session_id?: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  message?: string;
+  timestamp?: string;
+}
+
+interface PendingResponse {
+  sessionId: string;
+  resolve: (response: string) => void;
+  reject: (error: Error) => void;
+  messageId: number;
+  timestamp: number;
+}
+
+interface PendingPermission {
+  sessionId: string;
+  resolve: (decision: PermissionDecision) => void;
+  reject: (error: Error) => void;
+  messageId: number;
+  timestamp: number;
+  toolName: string;
+}
+
+export interface MultiTelegramConfig {
+  botToken: string;
+  chatId: number;
+  responseTimeoutMs?: number;
+  permissionTimeoutMs?: number;
+}
+
+export class MultiTelegramManager {
+  private bot: TelegramBot;
+  private config: MultiTelegramConfig;
+  private sessionManager: SessionManager;
+  private pendingResponses: Map<string, PendingResponse> = new Map();
+  private pendingPermissions: Map<string, PendingPermission> = new Map();
+  private messageToSession: Map<number, string> = new Map(); // messageId -> sessionId
+  private isRunning = false;
+
+  constructor(config: MultiTelegramConfig, sessionManager: SessionManager) {
+    this.config = {
+      responseTimeoutMs: 600000,
+      permissionTimeoutMs: 600000,
+      ...config,
+    };
+    this.sessionManager = sessionManager;
+    this.bot = new TelegramBot(config.botToken, { polling: true });
+
+    this.setupMessageHandler();
+    this.setupCallbackHandler();
+  }
+
+  start(): void {
+    this.isRunning = true;
+    console.error('[MultiTelegram] Bot started');
+  }
+
+  stop(): void {
+    this.isRunning = false;
+    this.bot.stopPolling();
+    console.error('[MultiTelegram] Bot stopped');
+  }
+
+  /**
+   * Send a message for a specific session and wait for response
+   */
+  async sendMessageAndWait(
+    sessionId: string,
+    message: string
+  ): Promise<{ chatId: string; response: string }> {
+    const session = this.sessionManager.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const taggedMessage = `[${session.sessionName}] ${message}`;
+    const sent = await this.bot.sendMessage(this.config.chatId, taggedMessage);
+
+    // Track message ownership
+    this.messageToSession.set(sent.message_id, sessionId);
+    this.sessionManager.touch(sessionId);
+
+    // Wait for response
+    const response = await this.waitForResponse(sessionId, sent.message_id);
+
+    return {
+      chatId: `${session.sessionName}:${this.config.chatId}`,
+      response,
+    };
+  }
+
+  /**
+   * Continue a chat for a specific session
+   */
+  async continueChat(sessionId: string, message: string): Promise<string> {
+    const session = this.sessionManager.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const taggedMessage = `[${session.sessionName}] ${message}`;
+    const sent = await this.bot.sendMessage(this.config.chatId, taggedMessage);
+
+    this.messageToSession.set(sent.message_id, sessionId);
+    this.sessionManager.touch(sessionId);
+
+    return this.waitForResponse(sessionId, sent.message_id);
+  }
+
+  /**
+   * Send a notification without waiting
+   */
+  async notify(sessionId: string, message: string): Promise<void> {
+    const session = this.sessionManager.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const taggedMessage = `[${session.sessionName}] ${message}`;
+    const sent = await this.bot.sendMessage(this.config.chatId, taggedMessage);
+    this.messageToSession.set(sent.message_id, sessionId);
+  }
+
+  /**
+   * End a chat session
+   */
+  async endChat(sessionId: string, message?: string): Promise<void> {
+    const session = this.sessionManager.get(sessionId);
+    if (!session) {
+      return;
+    }
+
+    if (message) {
+      const taggedMessage = `[${session.sessionName}] ${message}`;
+      await this.bot.sendMessage(this.config.chatId, taggedMessage);
+    }
+
+    // Clean up pending responses for this session
+    for (const [key, pending] of this.pendingResponses) {
+      if (pending.sessionId === sessionId) {
+        pending.reject(new Error('Chat ended'));
+        this.pendingResponses.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Handle permission request for a session (called by hook)
+   */
+  async handlePermissionRequest(
+    sessionName: string,
+    toolName: string,
+    toolInput: Record<string, unknown>
+  ): Promise<PermissionDecision> {
+    const session = this.sessionManager.getByName(sessionName);
+    const displayName = session?.sessionName || sessionName;
+
+    const inputDisplay = this.formatToolInput(toolName, toolInput);
+    const message = `🔐 [${displayName}] Permission Request\n\nTool: ${toolName}\n${inputDisplay}`;
+
+    const sent = await this.bot.sendMessage(this.config.chatId, message);
+
+    if (session) {
+      this.messageToSession.set(sent.message_id, session.sessionId);
+    }
+
+    await this.bot.editMessageReplyMarkup(
+      {
+        inline_keyboard: [
+          [
+            { text: '✅ Allow', callback_data: `allow:${sent.message_id}` },
+            { text: '❌ Deny', callback_data: `deny:${sent.message_id}` },
+          ],
+        ],
+      },
+      { chat_id: this.config.chatId, message_id: sent.message_id }
+    );
+
+    // Wait with reminders
+    const reminderIntervalMs = 120000;
+    const maxReminders = 4;
+
+    for (let attempt = 0; attempt <= maxReminders; attempt++) {
+      try {
+        return await this.waitForPermissionWithTimeout(
+          sent.message_id,
+          toolName,
+          session?.sessionId || 'hook',
+          reminderIntervalMs
+        );
+      } catch {
+        if (attempt < maxReminders) {
+          await this.bot.sendMessage(
+            this.config.chatId,
+            `⏰ [${displayName}] Reminder: Still waiting for permission\n\nTool: ${toolName}`,
+            { reply_to_message_id: sent.message_id }
+          );
+        }
+      }
+    }
+
+    // Final timeout message with buttons
+    const retryMsg = await this.bot.sendMessage(
+      this.config.chatId,
+      `⚠️ [${displayName}] Permission request timed out\n\nTool: ${toolName}\n\nClick below to respond:`
+    );
+
+    await this.bot.editMessageReplyMarkup(
+      {
+        inline_keyboard: [
+          [
+            { text: '✅ Allow Now', callback_data: `allow:${sent.message_id}` },
+            { text: '❌ Deny', callback_data: `deny:${sent.message_id}` },
+          ],
+        ],
+      },
+      { chat_id: this.config.chatId, message_id: retryMsg.message_id }
+    );
+
+    try {
+      return await this.waitForPermissionWithTimeout(
+        sent.message_id,
+        toolName,
+        session?.sessionId || 'hook',
+        this.config.permissionTimeoutMs!
+      );
+    } catch {
+      return { behavior: 'deny', message: 'Permission request timed out' };
+    }
+  }
+
+  /**
+   * Handle interactive stop for a session (called by hook)
+   */
+  async handleInteractiveStop(
+    sessionName: string,
+    transcriptPath?: string
+  ): Promise<Record<string, unknown>> {
+    const session = this.sessionManager.getByName(sessionName);
+    const displayName = session?.sessionName || sessionName;
+
+    let lastMessage = 'Claude has finished working.';
+    if (transcriptPath) {
+      lastMessage = await this.extractLastMessage(transcriptPath);
+    }
+
+    const message = `🏁 [${displayName}] Claude stopped\n\n${lastMessage}\n\n💬 Reply with instructions to continue, or "done" to finish.`;
+    const sent = await this.bot.sendMessage(this.config.chatId, message);
+
+    if (session) {
+      this.messageToSession.set(sent.message_id, session.sessionId);
+    }
+
+    const reminderIntervalMs = 120000;
+    const maxReminders = 4;
+
+    for (let attempt = 0; attempt <= maxReminders; attempt++) {
+      try {
+        const response = await this.waitForResponseWithTimeout(
+          session?.sessionId || 'hook',
+          sent.message_id,
+          reminderIntervalMs
+        );
+
+        const lower = response.toLowerCase().trim();
+        if (['done', 'stop', 'finish', 'ok'].includes(lower)) {
+          return {};
+        }
+
+        return { decision: 'block', reason: response };
+      } catch {
+        if (attempt < maxReminders) {
+          await this.bot.sendMessage(
+            this.config.chatId,
+            `⏰ [${displayName}] Reminder: Claude is waiting for your response`,
+            { reply_to_message_id: sent.message_id }
+          );
+        }
+      }
+    }
+
+    // Final attempt
+    try {
+      await this.bot.sendMessage(
+        this.config.chatId,
+        `⚠️ [${displayName}] Last chance! Claude will stop soon.\n\n💬 Reply now to continue.`,
+        { reply_to_message_id: sent.message_id }
+      );
+
+      const response = await this.waitForResponseWithTimeout(
+        session?.sessionId || 'hook',
+        sent.message_id,
+        this.config.responseTimeoutMs!
+      );
+
+      const lower = response.toLowerCase().trim();
+      if (['done', 'stop', 'finish', 'ok'].includes(lower)) {
+        return {};
+      }
+
+      return { decision: 'block', reason: response };
+    } catch {
+      await this.bot.sendMessage(
+        this.config.chatId,
+        `😴 [${displayName}] Claude stopped (no response received)`
+      );
+      return {};
+    }
+  }
+
+  /**
+   * Send hook notification
+   */
+  async sendHookNotification(sessionName: string, event: HookEvent): Promise<void> {
+    let emoji = '📢';
+    let title = 'Notification';
+
+    switch (event.type) {
+      case 'stop':
+        emoji = '🛑';
+        title = 'Agent Stopped';
+        break;
+      case 'session_start':
+        emoji = '🚀';
+        title = 'Session Started';
+        break;
+      case 'session_end':
+        emoji = '👋';
+        title = 'Session Ended';
+        break;
+    }
+
+    const message = `${emoji} [${sessionName}] ${title}\n\n${event.message || 'No details'}`;
+    await this.bot.sendMessage(this.config.chatId, message);
+  }
+
+  private async extractLastMessage(transcriptPath: string): Promise<string> {
+    try {
+      const fs = await import('fs');
+      if (!fs.existsSync(transcriptPath)) {
+        return 'Claude has finished working.';
+      }
+
+      const content = fs.readFileSync(transcriptPath, 'utf-8');
+      const lines = content.trim().split('\n');
+
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const entry = JSON.parse(lines[i]);
+          if (entry.type === 'assistant' && entry.message?.content) {
+            const textContent = entry.message.content.find((c: any) => c.type === 'text');
+            if (textContent?.text) {
+              return this.truncateMiddle(textContent.text, 600);
+            }
+          }
+        } catch {
+          // Skip invalid lines
+        }
+      }
+    } catch (err) {
+      console.error('[MultiTelegram] Error reading transcript:', err);
+    }
+
+    return 'Claude has finished working.';
+  }
+
+  private truncateMiddle(text: string, maxLength: number): string {
+    if (text.length <= maxLength) return text;
+
+    const startLength = Math.floor(maxLength * 0.3);
+    const endLength = Math.floor(maxLength * 0.6);
+
+    return `${text.slice(0, startLength)}\n\n[...truncated...]\n\n${text.slice(-endLength)}`;
+  }
+
+  private formatToolInput(toolName: string, input: Record<string, unknown>): string {
+    if (toolName === 'Bash' && input.command) {
+      return `Command: \`${input.command}\``;
+    }
+    if (toolName === 'Write' && input.file_path) {
+      const content = input.content as string;
+      const preview = content?.length > 100 ? content.slice(0, 100) + '...' : content;
+      return `File: ${input.file_path}\nContent: ${preview || '(empty)'}`;
+    }
+    if (toolName === 'Edit' && input.file_path) {
+      return `File: ${input.file_path}\nOld: ${input.old_string}\nNew: ${input.new_string}`;
+    }
+    if (toolName === 'Read' && input.file_path) {
+      return `File: ${input.file_path}`;
+    }
+
+    try {
+      const str = JSON.stringify(input, null, 2);
+      return str.length > 500 ? str.slice(0, 500) + '...' : str;
+    } catch {
+      return '(unable to display input)';
+    }
+  }
+
+  private waitForResponse(sessionId: string, messageId: number): Promise<string> {
+    return this.waitForResponseWithTimeout(sessionId, messageId, this.config.responseTimeoutMs!);
+  }
+
+  private waitForResponseWithTimeout(
+    sessionId: string,
+    messageId: number,
+    timeoutMs: number
+  ): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const key = `${messageId}`;
+
+      const existing = this.pendingResponses.get(key);
+      if (existing) {
+        existing.resolve = resolve;
+        existing.reject = reject;
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        this.pendingResponses.delete(key);
+        reject(new Error('Timeout'));
+      }, timeoutMs);
+
+      this.pendingResponses.set(key, {
+        sessionId,
+        resolve: (response: string) => {
+          clearTimeout(timeout);
+          this.pendingResponses.delete(key);
+          resolve(response);
+        },
+        reject: (error: Error) => {
+          clearTimeout(timeout);
+          this.pendingResponses.delete(key);
+          reject(error);
+        },
+        messageId,
+        timestamp: Date.now(),
+      });
+    });
+  }
+
+  private waitForPermissionWithTimeout(
+    messageId: number,
+    toolName: string,
+    sessionId: string,
+    timeoutMs: number
+  ): Promise<PermissionDecision> {
+    return new Promise((resolve, reject) => {
+      const key = `${messageId}`;
+
+      const existing = this.pendingPermissions.get(key);
+      if (existing) {
+        existing.resolve = resolve;
+        existing.reject = reject;
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        this.pendingPermissions.delete(key);
+        reject(new Error('Timeout'));
+      }, timeoutMs);
+
+      this.pendingPermissions.set(key, {
+        sessionId,
+        resolve: (decision: PermissionDecision) => {
+          clearTimeout(timeout);
+          this.pendingPermissions.delete(key);
+          resolve(decision);
+        },
+        reject: (error: Error) => {
+          clearTimeout(timeout);
+          this.pendingPermissions.delete(key);
+          reject(error);
+        },
+        messageId,
+        timestamp: Date.now(),
+        toolName,
+      });
+    });
+  }
+
+  private setupMessageHandler(): void {
+    this.bot.on('message', (msg) => {
+      if (msg.chat.id !== this.config.chatId) return;
+      if (msg.from?.is_bot) return;
+
+      const text = msg.text || '';
+      console.error(`[MultiTelegram] Received: "${text}"`);
+
+      // Check if reply to known message
+      if (msg.reply_to_message) {
+        const replyToId = msg.reply_to_message.message_id;
+        const sessionId = this.messageToSession.get(replyToId);
+
+        if (sessionId) {
+          console.error(`[MultiTelegram] Is reply to session ${sessionId}`);
+          this.resolveResponseForSession(sessionId, text);
+          return;
+        }
+      }
+
+      // Check for @sessionName prefix
+      for (const session of this.sessionManager.getAll()) {
+        const prefix = `@${session.sessionName}`;
+        if (text.toLowerCase().startsWith(prefix.toLowerCase())) {
+          const response = text.slice(prefix.length).trim();
+          this.resolveResponseForSession(session.sessionId, response);
+          return;
+        }
+      }
+
+      // Route to most recently active waiting session
+      const mostRecent = this.findMostRecentWaitingSession();
+      if (mostRecent) {
+        console.error(`[MultiTelegram] Routing to most recent: ${mostRecent}`);
+        this.resolveResponseForSession(mostRecent, text);
+      }
+    });
+
+    this.bot.on('polling_error', (error) => {
+      console.error('[MultiTelegram] Polling error:', error.message);
+    });
+  }
+
+  private setupCallbackHandler(): void {
+    this.bot.on('callback_query', async (query) => {
+      if (!query.data || !query.message) return;
+
+      const [action, messageId] = query.data.split(':');
+      const key = messageId;
+
+      const pending = this.pendingPermissions.get(key);
+      if (!pending) {
+        await this.bot.answerCallbackQuery(query.id, { text: 'Request expired' });
+        return;
+      }
+
+      const decision: PermissionDecision = {
+        behavior: action === 'allow' ? 'allow' : 'deny',
+        message: action === 'deny' ? 'Denied by user via Telegram' : undefined,
+      };
+
+      const statusEmoji = action === 'allow' ? '✅' : '❌';
+      const statusText = action === 'allow' ? 'Allowed' : 'Denied';
+
+      try {
+        await this.bot.editMessageReplyMarkup(
+          { inline_keyboard: [] },
+          { chat_id: query.message.chat.id, message_id: query.message.message_id }
+        );
+        await this.bot.editMessageText(
+          `${query.message.text}\n\n${statusEmoji} ${statusText}`,
+          { chat_id: query.message.chat.id, message_id: query.message.message_id }
+        );
+      } catch {
+        // Ignore edit errors
+      }
+
+      await this.bot.answerCallbackQuery(query.id, { text: `${statusText}!` });
+      pending.resolve(decision);
+    });
+  }
+
+  private resolveResponseForSession(sessionId: string, text: string): void {
+    // Find pending response for this session
+    for (const [key, pending] of this.pendingResponses) {
+      if (pending.sessionId === sessionId) {
+        pending.resolve(text);
+        return;
+      }
+    }
+
+    // Also check hook-based pending responses
+    for (const [key, pending] of this.pendingResponses) {
+      if (pending.sessionId === 'hook') {
+        pending.resolve(text);
+        return;
+      }
+    }
+  }
+
+  private findMostRecentWaitingSession(): string | null {
+    let mostRecent: PendingResponse | null = null;
+
+    for (const pending of this.pendingResponses.values()) {
+      if (!mostRecent || pending.timestamp > mostRecent.timestamp) {
+        mostRecent = pending;
+      }
+    }
+
+    return mostRecent?.sessionId || null;
+  }
+}