telegram-claude-mcp 1.4.1 → 1.6.0

package/README.md

@@ -20,6 +20,7 @@ Then:
 
 - **Permission buttons** - Allow/Deny tool usage from Telegram
 - **Interactive stop** - Reply to continue Claude's work after it stops
+- **Auto-retry with reminders** - Get reminders every 2 minutes if you miss a message
 - **Notifications** - Get notified about Claude events
 - **Multi-session** - Run multiple Claude instances with message tagging
 
@@ -225,12 +226,14 @@ Replace `YOUR_BOT_TOKEN` and `YOUR_CHAT_ID` in `~/.claude/settings.json`
 
 ## Environment Variables
 
-| Variable | Description | Required |
-|----------|-------------|----------|
-| `TELEGRAM_BOT_TOKEN` | Bot token from @BotFather | Yes |
-| `TELEGRAM_CHAT_ID` | Your Telegram chat ID | Yes |
-| `SESSION_NAME` | Session identifier (for multi-instance) | No (default: "default") |
-| `SESSION_PORT` | Preferred HTTP port | No (default: 3333, auto-finds available) |
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `TELEGRAM_BOT_TOKEN` | Bot token from @BotFather | Required |
+| `TELEGRAM_CHAT_ID` | Your Telegram chat ID | Required |
+| `SESSION_NAME` | Session identifier (for multi-instance) | "default" |
+| `SESSION_PORT` | Preferred HTTP port (auto-finds if busy) | 3333 |
+| `CHAT_RESPONSE_TIMEOUT_MS` | Timeout for message responses | 600000 (10 min) |
+| `PERMISSION_TIMEOUT_MS` | Timeout for permission decisions | 600000 (10 min) |
 
 ## How It Works
 

package/bin/setup.js

@@ -22,23 +22,35 @@ const CLAUDE_DIR = join(homedir(), '.claude');
 const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
 const SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
 
-// Hook scripts content
+// Hook scripts content - with SESSION_NAME support for multi-session setups
 const PERMISSION_HOOK = `#!/bin/bash
 #
 # Claude Code Permission Hook - forwards permission requests to Telegram
+# Set SESSION_NAME env var to target a specific session (for multi-session setups)
 #
 
 SESSION_DIR="/tmp/telegram-claude-sessions"
 
-find_active_session() {
+find_session() {
+  if [ -n "$SESSION_NAME" ]; then
+    local specific_file="$SESSION_DIR/\${SESSION_NAME}.info"
+    if [ -f "$specific_file" ]; then
+      local pid
+      pid=$(jq -r '.pid // empty' "$specific_file" 2>/dev/null)
+      if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+        echo "$specific_file"
+        return
+      fi
+    fi
+    return
+  fi
+
   local latest_file=""
   local latest_time=0
-
   [ -d "$SESSION_DIR" ] || return
 
   for info_file in "$SESSION_DIR"/*.info; do
     [ -e "$info_file" ] || continue
-
     local pid
     pid=$(jq -r '.pid // empty' "$info_file" 2>/dev/null)
     if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
@@ -50,15 +62,11 @@ find_active_session() {
       fi
     fi
   done
-
   echo "$latest_file"
 }
 
-INFO_FILE=$(find_active_session)
-
-if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
-  exit 0
-fi
+INFO_FILE=$(find_session)
+[ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ] && exit 0
 
 HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
 HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")

package/hooks/notify-hook.sh

@@ -5,25 +5,41 @@
 # This script receives notification events from Claude Code (stop, session events)
 # and forwards them to the Telegram MCP server.
 #
-# The script auto-discovers the MCP server port from session info files.
+# Set SESSION_NAME env var to target a specific session (for multi-session setups).
+# Without SESSION_NAME, falls back to the most recently started session.
 #
 
 SESSION_DIR="/tmp/telegram-claude-sessions"
 EVENT_TYPE="${TELEGRAM_HOOK_EVENT:-stop}"
 
-# Function to find the most recent active session
-find_active_session() {
+# Function to find session info file
+# If SESSION_NAME is set, use that specific session
+# Otherwise, find the most recent active session
+find_session() {
+  # If SESSION_NAME is set, use specific session
+  if [ -n "$SESSION_NAME" ]; then
+    local specific_file="$SESSION_DIR/${SESSION_NAME}.info"
+    if [ -f "$specific_file" ]; then
+      local pid
+      pid=$(jq -r '.pid // empty' "$specific_file" 2>/dev/null)
+      if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+        echo "$specific_file"
+        return
+      fi
+    fi
+    echo "[notify-hook] Session '$SESSION_NAME' not found or not running" >&2
+    return
+  fi
+
+  # Fallback: find most recent active session
   local latest_file=""
   local latest_time=0
 
-  # Check if directory exists
   [ -d "$SESSION_DIR" ] || return
 
   for info_file in "$SESSION_DIR"/*.info; do
-    # Skip if no matches (glob didn't expand)
     [ -e "$info_file" ] || continue
 
-    # Check if the process is still running
     local pid
     pid=$(jq -r '.pid // empty' "$info_file" 2>/dev/null)
     if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
@@ -39,8 +55,8 @@ find_active_session() {
   echo "$latest_file"
 }
 
-# Find active session info
-INFO_FILE=$(find_active_session)
+# Find session info
+INFO_FILE=$(find_session)
 
 if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
   echo "[notify-hook] No active session found, skipping notification" >&2

package/hooks/permission-hook.sh

@@ -5,24 +5,40 @@
 # This script receives permission requests from Claude Code and forwards them
 # to the Telegram MCP server for interactive approval via Telegram.
 #
-# The script auto-discovers the MCP server port from session info files.
+# Set SESSION_NAME env var to target a specific session (for multi-session setups).
+# Without SESSION_NAME, falls back to the most recently started session.
 #
 
 SESSION_DIR="/tmp/telegram-claude-sessions"
 
-# Function to find the most recent active session
-find_active_session() {
+# Function to find session info file
+# If SESSION_NAME is set, use that specific session
+# Otherwise, find the most recent active session
+find_session() {
+  # If SESSION_NAME is set, use specific session
+  if [ -n "$SESSION_NAME" ]; then
+    local specific_file="$SESSION_DIR/${SESSION_NAME}.info"
+    if [ -f "$specific_file" ]; then
+      local pid
+      pid=$(jq -r '.pid // empty' "$specific_file" 2>/dev/null)
+      if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+        echo "$specific_file"
+        return
+      fi
+    fi
+    echo "[permission-hook] Session '$SESSION_NAME' not found or not running" >&2
+    return
+  fi
+
+  # Fallback: find most recent active session
   local latest_file=""
   local latest_time=0
 
-  # Check if directory exists
   [ -d "$SESSION_DIR" ] || return
 
   for info_file in "$SESSION_DIR"/*.info; do
-    # Skip if no matches (glob didn't expand)
     [ -e "$info_file" ] || continue
 
-    # Check if the process is still running
     local pid
     pid=$(jq -r '.pid // empty' "$info_file" 2>/dev/null)
     if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
@@ -38,8 +54,8 @@ find_active_session() {
   echo "$latest_file"
 }
 
-# Find active session info
-INFO_FILE=$(find_active_session)
+# Find session info
+INFO_FILE=$(find_session)
 
 if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
   echo "[permission-hook] No active session found" >&2

package/hooks/stop-hook.sh

@@ -6,11 +6,32 @@
 # If you reply with instructions, Claude continues working on them.
 # If you reply "done" or don't reply, Claude stops.
 #
+# Set SESSION_NAME env var to target a specific session (for multi-session setups).
+# Without SESSION_NAME, falls back to the most recently started session.
+#
 
 SESSION_DIR="/tmp/telegram-claude-sessions"
 
-# Function to find the most recent active session
-find_active_session() {
+# Function to find session info file
+# If SESSION_NAME is set, use that specific session
+# Otherwise, find the most recent active session
+find_session() {
+  # If SESSION_NAME is set, use specific session
+  if [ -n "$SESSION_NAME" ]; then
+    local specific_file="$SESSION_DIR/${SESSION_NAME}.info"
+    if [ -f "$specific_file" ]; then
+      local pid
+      pid=$(jq -r '.pid // empty' "$specific_file" 2>/dev/null)
+      if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+        echo "$specific_file"
+        return
+      fi
+    fi
+    echo "[stop-hook] Session '$SESSION_NAME' not found or not running" >&2
+    return
+  fi
+
+  # Fallback: find most recent active session
   local latest_file=""
   local latest_time=0
 
@@ -44,8 +65,8 @@ if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
   exit 0
 fi
 
-# Find active session
-INFO_FILE=$(find_active_session)
+# Find session info
+INFO_FILE=$(find_session)
 
 if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
   echo "[stop-hook] No active session found" >&2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-claude-mcp",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "MCP server that lets Claude message you on Telegram with hooks support",
   "author": "Geravant",
   "license": "MIT",

package/src/index.ts

@@ -99,6 +99,7 @@ async function main() {
     chatId: config.telegramChatId,
     sessionName: config.sessionName,
     responseTimeoutMs: config.responseTimeoutMs,
+    permissionTimeoutMs: config.permissionTimeoutMs,
   });
 
   telegram.start();

package/src/providers/index.ts

@@ -25,6 +25,7 @@ export interface AppConfig {
 
   // Chat settings
   responseTimeoutMs: number;
+  permissionTimeoutMs: number;
 }
 
 export function loadAppConfig(): AppConfig {
@@ -48,7 +49,8 @@ export function loadAppConfig(): AppConfig {
     sessionPort: parseInt(sessionPort, 10),
     openrouterApiKey: process.env.OPENROUTER_API_KEY,
     openrouterModel: process.env.OPENROUTER_MODEL || 'openai/gpt-oss-120b',
-    responseTimeoutMs: parseInt(process.env.CHAT_RESPONSE_TIMEOUT_MS || '180000', 10),
+    responseTimeoutMs: parseInt(process.env.CHAT_RESPONSE_TIMEOUT_MS || '600000', 10),
+    permissionTimeoutMs: parseInt(process.env.PERMISSION_TIMEOUT_MS || '600000', 10),
   };
 }
 

package/src/telegram.ts

@@ -70,8 +70,8 @@ export class TelegramManager {
 
   constructor(config: TelegramConfig) {
     this.config = {
-      responseTimeoutMs: 180000, // 3 minutes default
-      permissionTimeoutMs: 300000, // 5 minutes for permissions
+      responseTimeoutMs: 600000, // 10 minutes default
+      permissionTimeoutMs: 600000, // 10 minutes for permissions
       ...config,
     };
 
@@ -182,6 +182,7 @@ export class TelegramManager {
   /**
    * Handle a permission request from Claude Code hooks
    * Sends a message with inline buttons and waits for user decision
+   * Includes auto-retry with reminders if user doesn't respond
    */
   async handlePermissionRequest(
     toolName: string,
@@ -208,7 +209,94 @@ export class TelegramManager {
       { chat_id: this.config.chatId, message_id: sent.message_id }
     );
 
-    return this.waitForPermission(sent.message_id, toolName);
+    // Try with reminders
+    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 }
+          );
+        }
+      }
+    }
+
+    // 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!);
+    } catch {
+      // Truly timed out
+      return { behavior: 'deny', message: 'Permission request timed out after multiple reminders' };
+    }
+  }
+
+  /**
+   * Wait for permission with a specific timeout (throws on timeout)
+   */
+  private waitForPermissionWithTimeout(
+    messageId: number,
+    toolName: string,
+    timeoutMs: number
+  ): Promise<PermissionDecision> {
+    return new Promise((resolve, reject) => {
+      const key = `${messageId}`;
+
+      // Check if already resolved
+      const existing = this.pendingPermissions.get(key);
+      if (existing) {
+        // Already waiting, just update the callbacks
+        existing.resolve = resolve;
+        existing.reject = reject;
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        this.pendingPermissions.delete(key);
+        reject(new Error('Timeout'));
+      }, timeoutMs);
+
+      this.pendingPermissions.set(key, {
+        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,
+      });
+    });
   }
 
   /**
@@ -245,6 +333,7 @@ export class TelegramManager {
    * Handle interactive stop - send message and wait for user to reply with instructions
    * Returns { decision: "block", reason: "..." } if user wants to continue
    * Returns {} if user is done
+   * Includes auto-retry with reminders if user doesn't respond
    */
   async handleInteractiveStop(transcriptPath?: string): Promise<Record<string, unknown>> {
     // Try to get last assistant message from transcript
@@ -287,28 +376,106 @@ export class TelegramManager {
       messageIds: [...this.getSessionState().messageIds, sent.message_id],
     });
 
-    // Wait for response with longer timeout for interactive stop
+    // Try with reminders
+    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 }
+          );
+        }
+      }
+    }
+
+    // Final attempt with longer timeout
     try {
-      const response = await this.waitForResponse(sent.message_id);
+      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!);
 
-      // 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) {
-      // Timeout or error - allow stop
-      console.error('[Telegram] Interactive stop timeout or error:', err);
+      // Truly timed out - notify and allow stop
+      await this.bot.sendMessage(
+        this.config.chatId,
+        `😴 [${this.config.sessionName}] Claude stopped (no response received)\n\nStart a new conversation to continue.`
+      );
+      console.error('[Telegram] Interactive stop timeout after reminders');
       return {};
     }
   }
 
+  /**
+   * Wait for response with a specific timeout (throws on timeout)
+   */
+  private waitForResponseWithTimeout(messageId: number, timeoutMs: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const key = `${messageId}`;
+
+      // Check if already has pending response
+      const existing = this.pendingResponses.get(key);
+      if (existing) {
+        existing.resolve = resolve;
+        existing.reject = reject;
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        this.pendingResponses.delete(key);
+        this.updateSessionState({ waitingForResponse: false });
+        reject(new Error('Timeout'));
+      }, timeoutMs);
+
+      this.pendingResponses.set(key, {
+        resolve: (response: string) => {
+          clearTimeout(timeout);
+          this.pendingResponses.delete(key);
+          this.updateSessionState({ waitingForResponse: false });
+          resolve(response);
+        },
+        reject: (error: Error) => {
+          clearTimeout(timeout);
+          this.pendingResponses.delete(key);
+          reject(error);
+        },
+        messageId,
+        timestamp: Date.now(),
+      });
+    });
+  }
+
   /**
    * Format tool input for display
    */
@@ -338,37 +505,6 @@ export class TelegramManager {
     }
   }
 
-  /**
-   * Wait for a permission decision with timeout
-   */
-  private waitForPermission(messageId: number, toolName: string): Promise<PermissionDecision> {
-    return new Promise((resolve, reject) => {
-      const key = `${messageId}`;
-
-      const timeout = setTimeout(() => {
-        this.pendingPermissions.delete(key);
-        // Default to deny on timeout for safety
-        resolve({ behavior: 'deny', message: 'Permission request timed out' });
-      }, this.config.permissionTimeoutMs);
-
-      this.pendingPermissions.set(key, {
-        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,
-      });
-    });
-  }
-
   /**
    * Set up message handler for incoming messages
    */