telegram-claude-mcp 1.6.0 → 2.0.1

package/src/telegram.ts

@@ -209,48 +209,55 @@ export class TelegramManager {
       { chat_id: this.config.chatId, message_id: sent.message_id }
     );
 
-    // Try with reminders
+    // Use a single long-lived pending permission with periodic reminders
+    const totalTimeoutMs = this.config.permissionTimeoutMs! + (120000 * 5); // Base timeout + 5 reminder intervals
     const reminderIntervalMs = 120000; // 2 minutes between reminders
-    const maxReminders = 4; // Up to 4 reminders (total ~10 min with initial wait)
 
-    for (let attempt = 0; attempt <= maxReminders; attempt++) {
-      try {
-        const decision = await this.waitForPermissionWithTimeout(sent.message_id, toolName, reminderIntervalMs);
-        return decision;
-      } catch (err) {
-        if (attempt < maxReminders) {
-          // Send reminder
-          await this.bot.sendMessage(
-            this.config.chatId,
-            `⏰ [${this.config.sessionName}] Reminder: Still waiting for permission\n\nTool: ${toolName}\n\n👆 Please respond to the message above`,
-            { reply_to_message_id: sent.message_id }
-          );
+    // Start reminder loop in background
+    let reminderCount = 0;
+    const maxReminders = 5;
+    const reminderInterval = setInterval(async () => {
+      reminderCount++;
+      if (reminderCount <= maxReminders) {
+        try {
+          const isLastChance = reminderCount === maxReminders;
+          if (isLastChance) {
+            // Send final reminder with new buttons
+            const retryMsg = await this.bot.sendMessage(
+              this.config.chatId,
+              `⚠️ [${this.config.sessionName}] Last chance! Permission will be denied soon.\n\nTool: ${toolName}\n\nClick below to respond now:`,
+            );
+            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 }
+            );
+          } else {
+            await this.bot.sendMessage(
+              this.config.chatId,
+              `⏰ [${this.config.sessionName}] Reminder ${reminderCount}/${maxReminders}: Permission needed\n\nTool: ${toolName}\n\n👆 Please respond to the message above`,
+              { reply_to_message_id: sent.message_id }
+            );
+          }
+        } catch (e) {
+          console.error('[Telegram] Error sending reminder:', e);
         }
       }
-    }
+    }, reminderIntervalMs);
 
-    // Final attempt: ask if they want to retry
-    const retryMsg = await this.bot.sendMessage(
-      this.config.chatId,
-      `⚠️ [${this.config.sessionName}] Permission request timed out\n\nTool: ${toolName}\n\nClick below to respond now:`,
-    );
-
-    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 }
-    );
-
-    // One more wait with the original timeout
     try {
-      return await this.waitForPermissionWithTimeout(sent.message_id, toolName, this.config.permissionTimeoutMs!);
+      // Wait for permission with full timeout
+      const decision = await this.waitForPermissionWithTimeout(sent.message_id, toolName, totalTimeoutMs);
+      clearInterval(reminderInterval);
+      return decision;
     } catch {
+      clearInterval(reminderInterval);
       // Truly timed out
       return { behavior: 'deny', message: 'Permission request timed out after multiple reminders' };
     }
@@ -351,8 +358,7 @@ export class TelegramManager {
               if (entry.type === 'assistant' && entry.message?.content) {
                 const textContent = entry.message.content.find((c: any) => c.type === 'text');
                 if (textContent?.text) {
-                  lastMessage = textContent.text.slice(0, 500);
-                  if (textContent.text.length > 500) lastMessage += '...';
+                  lastMessage = this.truncateMiddle(textContent.text, 600);
                   break;
                 }
               }
@@ -376,57 +382,47 @@ export class TelegramManager {
       messageIds: [...this.getSessionState().messageIds, sent.message_id],
     });
 
-    // Try with reminders
+    // Use a single long-lived pending response with periodic reminders
+    const totalTimeoutMs = this.config.responseTimeoutMs! + (120000 * 5); // Base timeout + 5 reminder intervals
     const reminderIntervalMs = 120000; // 2 minutes between reminders
-    const maxReminders = 4; // Up to 4 reminders
 
-    for (let attempt = 0; attempt <= maxReminders; attempt++) {
-      try {
-        const response = await this.waitForResponseWithTimeout(sent.message_id, reminderIntervalMs);
-
-        // Check if user wants to stop
-        const lowerResponse = response.toLowerCase().trim();
-        if (lowerResponse === 'done' || lowerResponse === 'stop' || lowerResponse === 'finish' || lowerResponse === 'ok') {
-          return {};
-        }
-
-        // User provided instructions - continue
-        return {
-          decision: 'block',
-          reason: response,
-        };
-      } catch (err) {
-        if (attempt < maxReminders) {
-          // Send reminder
-          await this.bot.sendMessage(
-            this.config.chatId,
-            `⏰ [${this.config.sessionName}] Reminder: Claude is waiting for your response\n\n💬 Reply with instructions to continue, or "done" to let Claude stop`,
-            { reply_to_message_id: sent.message_id }
-          );
+    // Start reminder loop in background
+    let reminderCount = 0;
+    const maxReminders = 5;
+    const reminderInterval = setInterval(async () => {
+      reminderCount++;
+      if (reminderCount <= maxReminders) {
+        try {
+          const isLastChance = reminderCount === maxReminders;
+          const message = isLastChance
+            ? `⚠️ [${this.config.sessionName}] Last chance! Claude will stop soon if no response.\n\n💬 Reply now to continue working.`
+            : `⏰ [${this.config.sessionName}] Reminder ${reminderCount}/${maxReminders}: Claude is waiting\n\n💬 Reply with instructions to continue, or "done" to stop`;
+
+          await this.bot.sendMessage(this.config.chatId, message, { reply_to_message_id: sent.message_id });
+        } catch (e) {
+          console.error('[Telegram] Error sending reminder:', e);
         }
       }
-    }
+    }, reminderIntervalMs);
 
-    // Final attempt with longer timeout
     try {
-      await this.bot.sendMessage(
-        this.config.chatId,
-        `⚠️ [${this.config.sessionName}] Last chance! Claude will stop in ${Math.round(this.config.responseTimeoutMs! / 60000)} minutes if no response.\n\n💬 Reply now to continue working.`,
-        { reply_to_message_id: sent.message_id }
-      );
-
-      const response = await this.waitForResponseWithTimeout(sent.message_id, this.config.responseTimeoutMs!);
+      // Wait for response with full timeout
+      const response = await this.waitForResponseWithTimeout(sent.message_id, totalTimeoutMs);
+      clearInterval(reminderInterval);
 
+      // Check if user wants to stop
       const lowerResponse = response.toLowerCase().trim();
       if (lowerResponse === 'done' || lowerResponse === 'stop' || lowerResponse === 'finish' || lowerResponse === 'ok') {
         return {};
       }
 
+      // User provided instructions - continue
       return {
         decision: 'block',
         reason: response,
       };
     } catch (err) {
+      clearInterval(reminderInterval);
       // Truly timed out - notify and allow stop
       await this.bot.sendMessage(
         this.config.chatId,
@@ -476,6 +472,24 @@ export class TelegramManager {
     });
   }
 
+  /**
+   * Truncate text by removing the middle, keeping beginning and end
+   * This is useful because Claude's questions are usually at the end
+   */
+  private truncateMiddle(text: string, maxLength: number): string {
+    if (text.length <= maxLength) return text;
+
+    // Keep more at the end (where questions usually are)
+    const startLength = Math.floor(maxLength * 0.3); // 30% from start
+    const endLength = Math.floor(maxLength * 0.6);   // 60% from end
+    // ~10% for the ellipsis marker
+
+    const start = text.slice(0, startLength);
+    const end = text.slice(-endLength);
+
+    return `${start}\n\n[...truncated...]\n\n${end}`;
+  }
+
   /**
    * Format tool input for display
    */