telegram-claude-mcp 1.5.0 → 1.6.1

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
 
@@ -34,29 +35,29 @@ Create directory `~/.claude/hooks/` and add these scripts:
 **~/.claude/hooks/permission-hook.sh**
 ```bash
 #!/bin/bash
+# Set SESSION_NAME env var to target a specific session (for multi-session setups)
 SESSION_DIR="/tmp/telegram-claude-sessions"
 
-find_active_session() {
-  local latest_file=""
-  local latest_time=0
+find_session() {
+  if [ -n "$SESSION_NAME" ]; then
+    local f="$SESSION_DIR/${SESSION_NAME}.info"
+    [ -f "$f" ] && { local p=$(jq -r '.pid // empty' "$f" 2>/dev/null); [ -n "$p" ] && kill -0 "$p" 2>/dev/null && echo "$f"; return; }
+    return
+  fi
+  local latest="" 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
-      local file_time
-      file_time=$(stat -f %m "$info_file" 2>/dev/null || stat -c %Y "$info_file" 2>/dev/null)
-      if [ "$file_time" -gt "$latest_time" ]; then
-        latest_time=$file_time
-        latest_file=$info_file
-      fi
-    fi
+  for f in "$SESSION_DIR"/*.info; do
+    [ -e "$f" ] || continue
+    local p=$(jq -r '.pid // empty' "$f" 2>/dev/null)
+    [ -n "$p" ] && kill -0 "$p" 2>/dev/null && {
+      local t=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null)
+      [ "$t" -gt "$latest_time" ] && { latest_time=$t; latest=$f; }
+    }
   done
-  echo "$latest_file"
+  echo "$latest"
 }
 
-INFO_FILE=$(find_active_session)
+INFO_FILE=$(find_session)
 [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ] && exit 0
 
 HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
@@ -77,33 +78,33 @@ RESPONSE=$(curl -s -X POST "$HOOK_URL" -H "Content-Type: application/json" -d "$
 **~/.claude/hooks/stop-hook.sh**
 ```bash
 #!/bin/bash
+# Set SESSION_NAME env var to target a specific session (for multi-session setups)
 SESSION_DIR="/tmp/telegram-claude-sessions"
 
-find_active_session() {
-  local latest_file=""
-  local latest_time=0
+find_session() {
+  if [ -n "$SESSION_NAME" ]; then
+    local f="$SESSION_DIR/${SESSION_NAME}.info"
+    [ -f "$f" ] && { local p=$(jq -r '.pid // empty' "$f" 2>/dev/null); [ -n "$p" ] && kill -0 "$p" 2>/dev/null && echo "$f"; return; }
+    return
+  fi
+  local latest="" 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
-      local file_time
-      file_time=$(stat -f %m "$info_file" 2>/dev/null || stat -c %Y "$info_file" 2>/dev/null)
-      if [ "$file_time" -gt "$latest_time" ]; then
-        latest_time=$file_time
-        latest_file=$info_file
-      fi
-    fi
+  for f in "$SESSION_DIR"/*.info; do
+    [ -e "$f" ] || continue
+    local p=$(jq -r '.pid // empty' "$f" 2>/dev/null)
+    [ -n "$p" ] && kill -0 "$p" 2>/dev/null && {
+      local t=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null)
+      [ "$t" -gt "$latest_time" ] && { latest_time=$t; latest=$f; }
+    }
   done
-  echo "$latest_file"
+  echo "$latest"
 }
 
 INPUT=$(cat)
 STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
 [ "$STOP_HOOK_ACTIVE" = "true" ] && exit 0
 
-INFO_FILE=$(find_active_session)
+INFO_FILE=$(find_session)
 [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ] && exit 0
 
 HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
@@ -123,29 +124,29 @@ fi
 **~/.claude/hooks/notify-hook.sh**
 ```bash
 #!/bin/bash
+# Set SESSION_NAME env var to target a specific session (for multi-session setups)
 SESSION_DIR="/tmp/telegram-claude-sessions"
 
-find_active_session() {
-  local latest_file=""
-  local latest_time=0
+find_session() {
+  if [ -n "$SESSION_NAME" ]; then
+    local f="$SESSION_DIR/${SESSION_NAME}.info"
+    [ -f "$f" ] && { local p=$(jq -r '.pid // empty' "$f" 2>/dev/null); [ -n "$p" ] && kill -0 "$p" 2>/dev/null && echo "$f"; return; }
+    return
+  fi
+  local latest="" 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
-      local file_time
-      file_time=$(stat -f %m "$info_file" 2>/dev/null || stat -c %Y "$info_file" 2>/dev/null)
-      if [ "$file_time" -gt "$latest_time" ]; then
-        latest_time=$file_time
-        latest_file=$info_file
-      fi
-    fi
+  for f in "$SESSION_DIR"/*.info; do
+    [ -e "$f" ] || continue
+    local p=$(jq -r '.pid // empty' "$f" 2>/dev/null)
+    [ -n "$p" ] && kill -0 "$p" 2>/dev/null && {
+      local t=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null)
+      [ "$t" -gt "$latest_time" ] && { latest_time=$t; latest=$f; }
+    }
   done
-  echo "$latest_file"
+  echo "$latest"
 }
 
-INFO_FILE=$(find_active_session)
+INFO_FILE=$(find_session)
 [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ] && exit 0
 
 HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
@@ -174,19 +175,19 @@ Add to `~/.claude/settings.json`:
     "PermissionRequest": [
       {
         "matcher": "*",
-        "hooks": [{ "type": "command", "command": "~/.claude/hooks/permission-hook.sh" }]
+        "hooks": [{ "type": "command", "command": "SESSION_NAME=default ~/.claude/hooks/permission-hook.sh" }]
       }
     ],
     "Stop": [
       {
         "matcher": "*",
-        "hooks": [{ "type": "command", "command": "~/.claude/hooks/stop-hook.sh" }]
+        "hooks": [{ "type": "command", "command": "SESSION_NAME=default ~/.claude/hooks/stop-hook.sh" }]
       }
     ],
     "Notification": [
       {
         "matcher": "*",
-        "hooks": [{ "type": "command", "command": "~/.claude/hooks/notify-hook.sh" }]
+        "hooks": [{ "type": "command", "command": "SESSION_NAME=default ~/.claude/hooks/notify-hook.sh" }]
       }
     ]
   },
@@ -204,6 +205,8 @@ Add to `~/.claude/settings.json`:
 }
 ```
 
+**Important:** The `SESSION_NAME` in hook commands must match the `SESSION_NAME` in the MCP server env.
+
 ### 3. Create Telegram Bot
 
 1. Open Telegram and message [@BotFather](https://t.me/BotFather)
@@ -256,17 +259,84 @@ Claude Code                    Hook Scripts                 telegram-claude-mcp
 
 ## Multiple Sessions
 
-Run multiple Claude instances with different session names:
+Run multiple Claude Code instances (e.g., `~/.claude` and `~/.claude-personal`) with proper message routing.
+
+### Why This Matters
 
+Without proper configuration, hooks from one Claude session might route to another session's MCP server. The `SESSION_NAME` environment variable ensures each session connects to its own MCP server.
+
+### Configuration
+
+Each Claude config needs a unique `SESSION_NAME` in **both** the MCP server env and the hook commands.
+
+**~/.claude/settings.json** (main):
 ```json
 {
-  "env": {
-    "SESSION_NAME": "project-a"
+  "hooks": {
+    "PermissionRequest": [{
+      "matcher": "*",
+      "hooks": [{ "type": "command", "command": "SESSION_NAME=main ~/.claude/hooks/permission-hook.sh" }]
+    }],
+    "Stop": [{
+      "matcher": "*",
+      "hooks": [{ "type": "command", "command": "SESSION_NAME=main ~/.claude/hooks/stop-hook.sh" }]
+    }],
+    "Notification": [{
+      "matcher": "*",
+      "hooks": [{ "type": "command", "command": "SESSION_NAME=main ~/.claude/hooks/notify-hook.sh" }]
+    }]
+  },
+  "mcpServers": {
+    "telegram": {
+      "command": "npx",
+      "args": ["-y", "telegram-claude-mcp"],
+      "env": {
+        "TELEGRAM_BOT_TOKEN": "YOUR_BOT_TOKEN",
+        "TELEGRAM_CHAT_ID": "YOUR_CHAT_ID",
+        "SESSION_NAME": "main"
+      }
+    }
   }
 }
 ```
 
-Messages are tagged with `[project-a]` so you know which instance sent them.
+**~/.claude-personal/settings.json** (personal):
+```json
+{
+  "hooks": {
+    "PermissionRequest": [{
+      "matcher": "*",
+      "hooks": [{ "type": "command", "command": "SESSION_NAME=personal ~/.claude/hooks/permission-hook.sh" }]
+    }],
+    "Stop": [{
+      "matcher": "*",
+      "hooks": [{ "type": "command", "command": "SESSION_NAME=personal ~/.claude/hooks/stop-hook.sh" }]
+    }],
+    "Notification": [{
+      "matcher": "*",
+      "hooks": [{ "type": "command", "command": "SESSION_NAME=personal ~/.claude/hooks/notify-hook.sh" }]
+    }]
+  },
+  "mcpServers": {
+    "telegram": {
+      "command": "npx",
+      "args": ["-y", "telegram-claude-mcp"],
+      "env": {
+        "TELEGRAM_BOT_TOKEN": "YOUR_BOT_TOKEN",
+        "TELEGRAM_CHAT_ID": "YOUR_CHAT_ID",
+        "SESSION_NAME": "personal"
+      }
+    }
+  }
+}
+```
+
+### Key Points
+
+- **SESSION_NAME must match** - The env var in hook commands must match the MCP server's SESSION_NAME
+- **Share hook scripts** - All configs can use the same hook scripts in `~/.claude/hooks/`
+- **Message tagging** - Messages are tagged with `[main]` or `[personal]` so you know the source
+- **Separate ports** - Each MCP server auto-discovers an available port
 
 ## Troubleshooting
 

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")
@@ -89,19 +97,31 @@ RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
 const STOP_HOOK = `#!/bin/bash
 #
 # Claude Code Interactive Stop Hook - sends stop notification and waits for reply
+# 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
@@ -113,22 +133,16 @@ find_active_session() {
       fi
     fi
   done
-
   echo "$latest_file"
 }
 
 INPUT=$(cat)
 
 STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
-if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
-  exit 0
-fi
+[ "$STOP_HOOK_ACTIVE" = "true" ] && exit 0
 
-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")
@@ -148,29 +162,38 @@ RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
 if [ $? -eq 0 ]; then
   DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
   REASON=$(echo "$RESPONSE" | jq -r '.reason // empty')
-
-  if [ "$DECISION" = "block" ] && [ -n "$REASON" ]; then
-    echo "$RESPONSE"
-  fi
+  [ "$DECISION" = "block" ] && [ -n "$REASON" ] && echo "$RESPONSE"
 fi
 `;
 
 const NOTIFY_HOOK = `#!/bin/bash
 #
 # Claude Code Notification Hook - sends notifications 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
@@ -182,15 +205,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")
@@ -210,42 +229,46 @@ curl -s -X POST "$HOOK_URL" \\
   --max-time 10 > /dev/null 2>&1
 `;
 
-// Hooks configuration for Claude settings
-const HOOKS_CONFIG = {
-  PermissionRequest: [
-    {
-      matcher: '*',
-      hooks: [
-        {
-          type: 'command',
-          command: '~/.claude/hooks/permission-hook.sh'
-        }
-      ]
-    }
-  ],
-  Stop: [
-    {
-      matcher: '*',
-      hooks: [
-        {
-          type: 'command',
-          command: '~/.claude/hooks/stop-hook.sh'
-        }
-      ]
-    }
-  ],
-  Notification: [
-    {
-      matcher: '*',
-      hooks: [
-        {
-          type: 'command',
-          command: '~/.claude/hooks/notify-hook.sh'
-        }
-      ]
-    }
-  ]
-};
+// Generate hooks configuration for Claude settings
+// sessionName parameter enables multi-session support
+function generateHooksConfig(sessionName = 'default') {
+  const envPrefix = `SESSION_NAME=${sessionName}`;
+  return {
+    PermissionRequest: [
+      {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: `${envPrefix} ~/.claude/hooks/permission-hook.sh`
+          }
+        ]
+      }
+    ],
+    Stop: [
+      {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: `${envPrefix} ~/.claude/hooks/stop-hook.sh`
+          }
+        ]
+      }
+    ],
+    Notification: [
+      {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: `${envPrefix} ~/.claude/hooks/notify-hook.sh`
+          }
+        ]
+      }
+    ]
+  };
+}
 
 function setup() {
   console.log('\n📱 telegram-claude-mcp Setup\n');
@@ -283,8 +306,8 @@ function setup() {
     }
   }
 
-  // Merge hooks config
-  settings.hooks = { ...settings.hooks, ...HOOKS_CONFIG };
+  // Merge hooks config (default session)
+  settings.hooks = { ...settings.hooks, ...generateHooksConfig('default') };
 
   // Add MCP server config if not present
   if (!settings.mcpServers) {
@@ -329,6 +352,18 @@ function setup() {
   console.log('4. Restart Claude Code\n');
 
   console.log('─'.repeat(50));
+  console.log('\n📋 Multi-Session Setup (optional):\n');
+  console.log('If you have multiple Claude configs (e.g., ~/.claude and ~/.claude-personal),');
+  console.log('each needs its own SESSION_NAME to avoid message routing conflicts.\n');
+  console.log('For each additional config, update its settings.json:');
+  console.log('  1. Change SESSION_NAME in mcpServers.telegram.env');
+  console.log('  2. Update hook commands to use that SESSION_NAME:\n');
+  console.log('     "command": "SESSION_NAME=personal ~/.claude/hooks/permission-hook.sh"\n');
+  console.log('Example for ~/.claude-personal/settings.json:');
+  console.log('  SESSION_NAME: "personal" (in mcpServers.telegram.env)');
+  console.log('  Hook commands: "SESSION_NAME=personal ~/.claude/hooks/..."');
+
+  console.log('\n' + '─'.repeat(50));
   console.log('\n✨ Setup complete! Configure your bot token and chat ID to finish.\n');
 }
 

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.5.0",
+  "version": "1.6.1",
   "description": "MCP server that lets Claude message you on Telegram with hooks support",
   "author": "Geravant",
   "license": "MIT",

package/src/telegram.ts

@@ -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
@@ -262,8 +351,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;
                 }
               }
@@ -287,28 +375,124 @@ 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(),
+      });
+    });
+  }
+
+  /**
+   * 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
    */
@@ -338,37 +522,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
    */