telegram-claude-mcp 2.0.2 → 2.0.4

package/bin/daemon-ctl.js

@@ -76,12 +76,13 @@ async function start() {
 
   // Determine which script to run
   let script = daemonScript;
-  let runner = 'node';
+  let args = [script];
 
   if (!existsSync(daemonScript)) {
     if (existsSync(daemonSrc)) {
       script = daemonSrc;
-      runner = 'bun';
+      // Use node with tsx for TypeScript support
+      args = ['--import', 'tsx', script];
     } else {
       console.error('Error: Daemon script not found. Run `npm run build` first.');
       process.exit(1);
@@ -90,7 +91,7 @@ async function start() {
 
   console.log('Starting telegram-claude-daemon...');
 
-  const child = spawn(runner, [script], {
+  const child = spawn('node', args, {
     detached: true,
     stdio: ['ignore', 'pipe', 'pipe'],
     env: process.env,

package/bin/setup.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Setup script for telegram-claude-mcp hooks integration
+ * Setup script for telegram-claude-mcp hooks integration (v2 - Daemon Architecture)
  *
  * Usage: npx telegram-claude-mcp setup
  *
@@ -22,198 +22,101 @@ const CLAUDE_DIR = join(homedir(), '.claude');
 const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
 const SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
 
-// 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_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
+// Default daemon configuration
+const DAEMON_PORT = 3333;
+const DAEMON_HOST = 'localhost';
 
-  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
-      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
-  done
-  echo "$latest_file"
-}
+// Hook scripts content - v2 daemon architecture
+// These hooks communicate with a single daemon process via HTTP
 
-INFO_FILE=$(find_session)
-[ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ] && exit 0
+const PERMISSION_HOOK = `#!/bin/bash
+# Permission hook for telegram-claude-daemon (v2)
+# Sends permission requests to the daemon for Telegram approval
+
+DAEMON_PORT="\${TELEGRAM_CLAUDE_PORT:-${DAEMON_PORT}}"
+DAEMON_HOST="\${TELEGRAM_CLAUDE_HOST:-${DAEMON_HOST}}"
+HOOK_URL="http://\${DAEMON_HOST}:\${DAEMON_PORT}/permission"
 
-HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
-HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")
-HOOK_URL="http://\${HOOK_HOST}:\${HOOK_PORT}/permission"
+# Auto-detect project name from current working directory
+PROJECT_NAME=$(basename "$(pwd)")
+BASE_SESSION="\${SESSION_NAME:-default}"
+FULL_SESSION_NAME="\${BASE_SESSION}:\${PROJECT_NAME}"
 
 INPUT=$(cat)
-TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty')
-TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
 
-if [ -z "$TOOL_NAME" ]; then
-  TOOL_NAME=$(echo "$INPUT" | jq -r '.toolName // .name // empty')
-  TOOL_INPUT=$(echo "$INPUT" | jq -c '.toolInput // .input // .arguments // {}')
-fi
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // .toolInput // .input // .arguments // {}')
+
+[ -z "$TOOL_NAME" ] && exit 0
 
 PAYLOAD=$(jq -n \\
   --arg tool_name "$TOOL_NAME" \\
   --argjson tool_input "$TOOL_INPUT" \\
-  '{tool_name: $tool_name, tool_input: $tool_input}')
+  --arg session_name "$FULL_SESSION_NAME" \\
+  '{tool_name: $tool_name, tool_input: $tool_input, session_name: $session_name}')
 
 RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
   -H "Content-Type: application/json" \\
+  -H "X-Session-Name: $FULL_SESSION_NAME" \\
   -d "$PAYLOAD" \\
-  --max-time 600)
+  --max-time 600 2>/dev/null)
 
-[ $? -eq 0 ] && echo "$RESPONSE"
+[ $? -eq 0 ] && [ -n "$RESPONSE" ] && echo "$RESPONSE"
 `;
 
 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_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
+# Stop hook for telegram-claude-daemon (v2)
+# Sends stop notification and waits for user response
 
-  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
-      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
-  done
-  echo "$latest_file"
-}
+DAEMON_PORT="\${TELEGRAM_CLAUDE_PORT:-${DAEMON_PORT}}"
+DAEMON_HOST="\${TELEGRAM_CLAUDE_HOST:-${DAEMON_HOST}}"
+HOOK_URL="http://\${DAEMON_HOST}:\${DAEMON_PORT}/stop"
+
+# Auto-detect project name from current working directory
+PROJECT_NAME=$(basename "$(pwd)")
+BASE_SESSION="\${SESSION_NAME:-default}"
+FULL_SESSION_NAME="\${BASE_SESSION}:\${PROJECT_NAME}"
 
 INPUT=$(cat)
 
+# Prevent recursion
 STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
 [ "$STOP_HOOK_ACTIVE" = "true" ] && exit 0
 
-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")
-HOOK_URL="http://\${HOOK_HOST}:\${HOOK_PORT}/stop"
-
 TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // empty')
 
 PAYLOAD=$(jq -n \\
   --arg transcript_path "$TRANSCRIPT_PATH" \\
-  '{transcript_path: $transcript_path}')
+  --arg session_name "$FULL_SESSION_NAME" \\
+  '{transcript_path: $transcript_path, session_name: $session_name}')
 
 RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
   -H "Content-Type: application/json" \\
+  -H "X-Session-Name: $FULL_SESSION_NAME" \\
   -d "$PAYLOAD" \\
-  --max-time 300)
+  --max-time 300 2>/dev/null)
 
-if [ $? -eq 0 ]; then
+if [ $? -eq 0 ] && [ -n "$RESPONSE" ]; then
   DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
-  REASON=$(echo "$RESPONSE" | jq -r '.reason // empty')
-  [ "$DECISION" = "block" ] && [ -n "$REASON" ] && echo "$RESPONSE"
+  if [ "$DECISION" = "block" ]; then
+    echo "$RESPONSE"
+    exit 2
+  fi
 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_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
-      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
-  done
-  echo "$latest_file"
-}
+# Notification hook for telegram-claude-daemon (v2)
+# Sends notifications to the daemon (fire-and-forget)
 
-INFO_FILE=$(find_session)
-[ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ] && exit 0
+DAEMON_PORT="\${TELEGRAM_CLAUDE_PORT:-${DAEMON_PORT}}"
+DAEMON_HOST="\${TELEGRAM_CLAUDE_HOST:-${DAEMON_HOST}}"
+HOOK_URL="http://\${DAEMON_HOST}:\${DAEMON_PORT}/notify"
 
-HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
-HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")
-HOOK_URL="http://\${HOOK_HOST}:\${HOOK_PORT}/notify"
+# Auto-detect project name from current working directory
+PROJECT_NAME=$(basename "$(pwd)")
+BASE_SESSION="\${SESSION_NAME:-default}"
+FULL_SESSION_NAME="\${BASE_SESSION}:\${PROJECT_NAME}"
 
 INPUT=$(cat)
 MESSAGE=$(echo "$INPUT" | jq -r '.message // "Notification from Claude"')
@@ -221,12 +124,137 @@ MESSAGE=$(echo "$INPUT" | jq -r '.message // "Notification from Claude"')
 PAYLOAD=$(jq -n \\
   --arg type "notification" \\
   --arg message "$MESSAGE" \\
-  '{type: $type, message: $message}')
+  --arg session_name "$FULL_SESSION_NAME" \\
+  '{type: $type, message: $message, session_name: $session_name}')
 
 curl -s -X POST "$HOOK_URL" \\
   -H "Content-Type: application/json" \\
+  -H "X-Session-Name: $FULL_SESSION_NAME" \\
+  -d "$PAYLOAD" \\
+  --max-time 10 >/dev/null 2>&1
+`;
+
+// Progress tracking hooks - fire-and-forget for real-time progress updates
+
+const PROGRESS_PRE_TOOL_HOOK = `#!/bin/bash
+# PreToolUse progress hook for telegram-claude-daemon
+# Sends tool start events to update progress display (fire-and-forget)
+
+DAEMON_PORT="\${TELEGRAM_CLAUDE_PORT:-${DAEMON_PORT}}"
+DAEMON_HOST="\${TELEGRAM_CLAUDE_HOST:-${DAEMON_HOST}}"
+HOOK_URL="http://\${DAEMON_HOST}:\${DAEMON_PORT}/progress"
+
+# Auto-detect project name from current working directory
+PROJECT_NAME=$(basename "$(pwd)")
+BASE_SESSION="\${SESSION_NAME:-default}"
+FULL_SESSION_NAME="\${BASE_SESSION}:\${PROJECT_NAME}"
+
+INPUT=$(cat)
+
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // .toolInput // .input // .arguments // {}')
+
+[ -z "$TOOL_NAME" ] && exit 0
+
+# Skip progress for Telegram tools (would be recursive)
+case "$TOOL_NAME" in
+  mcp__telegram__*|send_message|continue_chat|notify_user|end_chat)
+    exit 0
+    ;;
+esac
+
+PAYLOAD=$(jq -n \\
+  --arg type "pre_tool" \\
+  --arg session_name "$FULL_SESSION_NAME" \\
+  --arg tool_name "$TOOL_NAME" \\
+  --argjson tool_input "$TOOL_INPUT" \\
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \\
+  '{type: $type, session_name: $session_name, tool_name: $tool_name, tool_input: $tool_input, timestamp: $timestamp}')
+
+# Fire and forget
+(curl -s -X POST "$HOOK_URL" \\
+  -H "Content-Type: application/json" \\
+  -H "X-Session-Name: $FULL_SESSION_NAME" \\
+  -d "$PAYLOAD" \\
+  --max-time 2 2>/dev/null) &
+
+exit 0
+`;
+
+const PROGRESS_POST_TOOL_HOOK = `#!/bin/bash
+# PostToolUse progress hook for telegram-claude-daemon
+# Sends tool completion events to update progress display (fire-and-forget)
+
+DAEMON_PORT="\${TELEGRAM_CLAUDE_PORT:-${DAEMON_PORT}}"
+DAEMON_HOST="\${TELEGRAM_CLAUDE_HOST:-${DAEMON_HOST}}"
+HOOK_URL="http://\${DAEMON_HOST}:\${DAEMON_PORT}/progress"
+
+# Auto-detect project name from current working directory
+PROJECT_NAME=$(basename "$(pwd)")
+BASE_SESSION="\${SESSION_NAME:-default}"
+FULL_SESSION_NAME="\${BASE_SESSION}:\${PROJECT_NAME}"
+
+INPUT=$(cat)
+
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+
+IS_ERROR=$(echo "$INPUT" | jq -r '.is_error // .isError // false')
+[ "$IS_ERROR" = "true" ] && SUCCESS="false" || SUCCESS="true"
+
+[ -z "$TOOL_NAME" ] && exit 0
+
+# Skip progress for Telegram tools
+case "$TOOL_NAME" in
+  mcp__telegram__*|send_message|continue_chat|notify_user|end_chat)
+    exit 0
+    ;;
+esac
+
+PAYLOAD=$(jq -n \\
+  --arg type "post_tool" \\
+  --arg session_name "$FULL_SESSION_NAME" \\
+  --arg tool_name "$TOOL_NAME" \\
+  --argjson success "$SUCCESS" \\
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \\
+  '{type: $type, session_name: $session_name, tool_name: $tool_name, success: $success, timestamp: $timestamp}')
+
+# Fire and forget
+(curl -s -X POST "$HOOK_URL" \\
+  -H "Content-Type: application/json" \\
+  -H "X-Session-Name: $FULL_SESSION_NAME" \\
   -d "$PAYLOAD" \\
-  --max-time 10 > /dev/null 2>&1
+  --max-time 2 2>/dev/null) &
+
+exit 0
+`;
+
+const PROGRESS_STOP_HOOK = `#!/bin/bash
+# Stop progress hook for telegram-claude-daemon
+# Sends stop event to finalize progress display (fire-and-forget)
+
+DAEMON_PORT="\${TELEGRAM_CLAUDE_PORT:-${DAEMON_PORT}}"
+DAEMON_HOST="\${TELEGRAM_CLAUDE_HOST:-${DAEMON_HOST}}"
+HOOK_URL="http://\${DAEMON_HOST}:\${DAEMON_PORT}/progress"
+
+# Auto-detect project name from current working directory
+PROJECT_NAME=$(basename "$(pwd)")
+BASE_SESSION="\${SESSION_NAME:-default}"
+FULL_SESSION_NAME="\${BASE_SESSION}:\${PROJECT_NAME}"
+
+PAYLOAD=$(jq -n \\
+  --arg type "stop" \\
+  --arg session_name "$FULL_SESSION_NAME" \\
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \\
+  '{type: $type, session_name: $session_name, timestamp: $timestamp}')
+
+# Fire and forget
+(curl -s -X POST "$HOOK_URL" \\
+  -H "Content-Type: application/json" \\
+  -H "X-Session-Name: $FULL_SESSION_NAME" \\
+  -d "$PAYLOAD" \\
+  --max-time 2 2>/dev/null) &
+
+exit 0
 `;
 
 // Generate hooks configuration for Claude settings
@@ -234,6 +262,7 @@ curl -s -X POST "$HOOK_URL" \\
 function generateHooksConfig(sessionName = 'default') {
   const envPrefix = `SESSION_NAME=${sessionName}`;
   return {
+    // Permission request handling
     PermissionRequest: [
       {
         matcher: '*',
@@ -245,17 +274,23 @@ function generateHooksConfig(sessionName = 'default') {
         ]
       }
     ],
+    // Stop hook with interactive continue option
     Stop: [
       {
         matcher: '*',
         hooks: [
           {
             type: 'command',
-            command: `${envPrefix} ~/.claude/hooks/stop-hook.sh`
+            command: `${envPrefix} ~/.claude/hooks/progress-stop-hook.sh`  // Progress finalization
+          },
+          {
+            type: 'command',
+            command: `${envPrefix} ~/.claude/hooks/stop-hook.sh`  // Interactive stop
           }
         ]
       }
     ],
+    // Notification forwarding
     Notification: [
       {
         matcher: '*',
@@ -266,6 +301,30 @@ function generateHooksConfig(sessionName = 'default') {
           }
         ]
       }
+    ],
+    // Progress tracking - PreToolUse
+    PreToolUse: [
+      {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: `${envPrefix} ~/.claude/hooks/progress-pre-tool-hook.sh`
+          }
+        ]
+      }
+    ],
+    // Progress tracking - PostToolUse
+    PostToolUse: [
+      {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: `${envPrefix} ~/.claude/hooks/progress-post-tool-hook.sh`
+          }
+        ]
+      }
     ]
   };
 }
@@ -280,7 +339,7 @@ function setup() {
     console.log('✓ Created ~/.claude/hooks/');
   }
 
-  // Write hook scripts
+  // Write hook scripts - core hooks
   const permissionHookPath = join(HOOKS_DIR, 'permission-hook.sh');
   writeFileSync(permissionHookPath, PERMISSION_HOOK);
   chmodSync(permissionHookPath, 0o755);
@@ -296,6 +355,22 @@ function setup() {
   chmodSync(notifyHookPath, 0o755);
   console.log('✓ Installed notify-hook.sh');
 
+  // Write hook scripts - progress tracking
+  const progressPreToolPath = join(HOOKS_DIR, 'progress-pre-tool-hook.sh');
+  writeFileSync(progressPreToolPath, PROGRESS_PRE_TOOL_HOOK);
+  chmodSync(progressPreToolPath, 0o755);
+  console.log('✓ Installed progress-pre-tool-hook.sh');
+
+  const progressPostToolPath = join(HOOKS_DIR, 'progress-post-tool-hook.sh');
+  writeFileSync(progressPostToolPath, PROGRESS_POST_TOOL_HOOK);
+  chmodSync(progressPostToolPath, 0o755);
+  console.log('✓ Installed progress-post-tool-hook.sh');
+
+  const progressStopPath = join(HOOKS_DIR, 'progress-stop-hook.sh');
+  writeFileSync(progressStopPath, PROGRESS_STOP_HOOK);
+  chmodSync(progressStopPath, 0o755);
+  console.log('✓ Installed progress-stop-hook.sh');
+
   // Update Claude settings
   let settings = {};
   if (existsSync(SETTINGS_FILE)) {

package/hooks-v2/hooks-config-example.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "_comment": "Example Claude Code hooks configuration for progress tracking. Copy relevant sections to ~/.claude/settings.json or .claude/settings.json in your project.",
+
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "*",
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/progress-pre-tool.sh"
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/progress-post-tool.sh"
+      }
+    ],
+    "Stop": [
+      {
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/progress-stop.sh"
+      },
+      {
+        "_comment": "Optional: Interactive stop hook (waits for user response)",
+        "command": "SESSION_NAME=${SESSION_NAME:-$(basename \"$PWD\")} /path/to/call-me/server/hooks-v2/stop-hook.sh"
+      }
+    ]
+  }
+}

package/hooks-v2/progress-post-tool.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# PostToolUse progress hook for telegram-claude-daemon
+# Sends tool completion events to update progress display
+#
+# This hook is fire-and-forget - it doesn't block Claude's execution
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/progress"
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Extract tool info
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_RESULT=$(echo "$INPUT" | jq -c '.tool_result // .result // {}')
+
+# Check if tool succeeded
+IS_ERROR=$(echo "$INPUT" | jq -r '.is_error // .isError // false')
+if [ "$IS_ERROR" = "true" ]; then
+  SUCCESS="false"
+else
+  SUCCESS="true"
+fi
+
+# Skip if no tool name
+if [ -z "$TOOL_NAME" ]; then
+  exit 0
+fi
+
+# Skip progress updates for Telegram tools (would be recursive)
+case "$TOOL_NAME" in
+  mcp__telegram__*|send_message|continue_chat|notify_user|end_chat)
+    exit 0
+    ;;
+esac
+
+# Build payload
+PAYLOAD=$(jq -n \
+  --arg type "post_tool" \
+  --arg session_name "${SESSION_NAME:-default}" \
+  --arg tool_name "$TOOL_NAME" \
+  --argjson success "$SUCCESS" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    type: $type,
+    session_name: $session_name,
+    tool_name: $tool_name,
+    success: $success,
+    timestamp: $timestamp
+  }')
+
+# Fire and forget - send in background and don't wait
+(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 2 2>/dev/null) &
+
+# Exit immediately - don't block Claude
+exit 0

package/hooks-v2/progress-pre-tool.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# PreToolUse progress hook for telegram-claude-daemon
+# Sends tool start events to update progress display
+#
+# This hook is fire-and-forget - it doesn't block Claude's execution
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/progress"
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Extract tool info
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // .toolInput // .input // .arguments // {}')
+
+# Skip if no tool name
+if [ -z "$TOOL_NAME" ]; then
+  exit 0
+fi
+
+# Skip progress updates for Telegram tools (would be recursive)
+case "$TOOL_NAME" in
+  mcp__telegram__*|send_message|continue_chat|notify_user|end_chat)
+    exit 0
+    ;;
+esac
+
+# Build payload
+PAYLOAD=$(jq -n \
+  --arg type "pre_tool" \
+  --arg session_name "${SESSION_NAME:-default}" \
+  --arg tool_name "$TOOL_NAME" \
+  --argjson tool_input "$TOOL_INPUT" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    type: $type,
+    session_name: $session_name,
+    tool_name: $tool_name,
+    tool_input: $tool_input,
+    timestamp: $timestamp
+  }')
+
+# Fire and forget - send in background and don't wait
+(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 2 2>/dev/null) &
+
+# Exit immediately - don't block Claude
+exit 0

package/hooks-v2/progress-stop.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Stop progress hook for telegram-claude-daemon
+# Sends stop events to finalize progress display
+#
+# This hook is fire-and-forget - it doesn't block Claude's execution
+# Note: This is separate from stop-hook.sh which handles interactive stop
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/progress"
+
+# Read input from stdin (if any)
+INPUT=$(cat)
+
+# Build payload
+PAYLOAD=$(jq -n \
+  --arg type "stop" \
+  --arg session_name "${SESSION_NAME:-default}" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    type: $type,
+    session_name: $session_name,
+    timestamp: $timestamp
+  }')
+
+# Fire and forget - send in background and don't wait
+(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 2 2>/dev/null) &
+
+# Exit immediately - don't block Claude
+exit 0

package/package.json

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

package/src/daemon/index.ts

@@ -13,6 +13,7 @@ import { existsSync, unlinkSync, writeFileSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { SessionManager } from './session-manager.js';
 import { MultiTelegramManager, type HookEvent } from './telegram-multi.js';
+import { ProgressTracker, type ProgressEvent } from './progress-tracker.js';
 import {
   DAEMON_SOCKET_PATH,
   DAEMON_PID_FILE,
@@ -96,6 +97,16 @@ async function main() {
 
   telegram.start();
 
+  // Create progress tracker
+  const progressTracker = new ProgressTracker(
+    telegram.getBot(),
+    telegram.getChatId(),
+    sessionManager
+  );
+
+  // Register progress tracker's callback handler for mute buttons
+  telegram.registerCallbackInterceptor((query) => progressTracker.handleCallback(query));
+
   // Track socket buffers for each connection
   const socketBuffers = new Map<net.Socket, string>();
 
@@ -223,6 +234,41 @@ async function main() {
         return;
       }
 
+      // Progress tracking endpoint
+      if (url === '/progress' || url === '/hooks/progress') {
+        const event = data as ProgressEvent;
+
+        console.error(`[HTTP] Progress: ${event.type} - ${event.tool_name || ''} (session: ${sessionName})`);
+
+        try {
+          switch (event.type) {
+            case 'start':
+              await progressTracker.handleSessionStart(sessionName);
+              break;
+            case 'pre_tool':
+              await progressTracker.handlePreTool(sessionName, event.tool_name!, event.tool_input);
+              break;
+            case 'post_tool':
+              await progressTracker.handlePostTool(sessionName, event.tool_name!, event.success ?? true);
+              break;
+            case 'stop':
+              await progressTracker.handleStop(sessionName);
+              break;
+            case 'notification':
+              await progressTracker.handleNotification(sessionName, event.tool_name || '');
+              break;
+          }
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (error) {
+          console.error('[HTTP] Progress error:', error);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true })); // Don't fail hooks
+        }
+        return;
+      }
+
       // Status endpoint
       if (url === '/status') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -284,9 +330,10 @@ async function main() {
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 
-  // Periodic cleanup of dead sessions
+  // Periodic cleanup of dead sessions and progress state
   setInterval(() => {
     sessionManager.cleanup();
+    progressTracker.cleanup();
   }, 30000);
 }
 

package/src/daemon/telegram-multi.ts

@@ -54,6 +54,7 @@ export class MultiTelegramManager {
   private pendingPermissions: Map<string, PendingPermission> = new Map();
   private messageToSession: Map<number, string> = new Map(); // messageId -> sessionId
   private isRunning = false;
+  private callbackInterceptors: Array<(query: TelegramBot.CallbackQuery) => Promise<boolean>> = [];
 
   constructor(config: MultiTelegramConfig, sessionManager: SessionManager) {
     this.config = {
@@ -68,6 +69,28 @@ export class MultiTelegramManager {
     this.setupCallbackHandler();
   }
 
+  /**
+   * Get the underlying bot instance for advanced operations.
+   */
+  getBot(): TelegramBot {
+    return this.bot;
+  }
+
+  /**
+   * Get the configured chat ID.
+   */
+  getChatId(): number {
+    return this.config.chatId;
+  }
+
+  /**
+   * Register a callback interceptor that handles callback queries before the default handler.
+   * Return true to indicate the query was handled and stop further processing.
+   */
+  registerCallbackInterceptor(handler: (query: TelegramBot.CallbackQuery) => Promise<boolean>): void {
+    this.callbackInterceptors.push(handler);
+  }
+
   start(): void {
     this.isRunning = true;
     console.error('[MultiTelegram] Bot started');
@@ -544,6 +567,16 @@ export class MultiTelegramManager {
     this.bot.on('callback_query', async (query) => {
       if (!query.data || !query.message) return;
 
+      // Check interceptors first
+      for (const interceptor of this.callbackInterceptors) {
+        try {
+          const handled = await interceptor(query);
+          if (handled) return;
+        } catch (error) {
+          console.error('[MultiTelegram] Callback interceptor error:', error);
+        }
+      }
+
       const [action, messageId] = query.data.split(':');
       const key = messageId;