telegram-claude-mcp 1.2.4 → 1.4.0

package/bin/setup.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+/**
+ * Setup script for telegram-claude-mcp hooks integration
+ *
+ * Usage: npx telegram-claude-mcp setup
+ *
+ * This will:
+ * 1. Copy hook scripts to ~/.claude/hooks/
+ * 2. Update Claude settings with hooks configuration
+ * 3. Display instructions for completing setup
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+const HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+const SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
+
+// Hook scripts content
+const PERMISSION_HOOK = `#!/bin/bash
+#
+# Claude Code Permission Hook - forwards permission requests to Telegram
+#
+
+SESSION_DIR="/tmp/telegram-claude-sessions"
+
+find_active_session() {
+  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"
+}
+
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  exit 0
+fi
+
+HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
+HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")
+HOOK_URL="http://\${HOOK_HOST}:\${HOOK_PORT}/permission"
+
+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
+
+PAYLOAD=$(jq -n \\
+  --arg tool_name "$TOOL_NAME" \\
+  --argjson tool_input "$TOOL_INPUT" \\
+  '{tool_name: $tool_name, tool_input: $tool_input}')
+
+RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
+  -H "Content-Type: application/json" \\
+  -d "$PAYLOAD" \\
+  --max-time 600)
+
+[ $? -eq 0 ] && echo "$RESPONSE"
+`;
+
+const STOP_HOOK = `#!/bin/bash
+#
+# Claude Code Interactive Stop Hook - sends stop notification and waits for reply
+#
+
+SESSION_DIR="/tmp/telegram-claude-sessions"
+
+find_active_session() {
+  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"
+}
+
+INPUT=$(cat)
+
+STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
+  exit 0
+fi
+
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  exit 0
+fi
+
+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}')
+
+RESPONSE=$(curl -s -X POST "$HOOK_URL" \\
+  -H "Content-Type: application/json" \\
+  -d "$PAYLOAD" \\
+  --max-time 300)
+
+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
+fi
+`;
+
+const NOTIFY_HOOK = `#!/bin/bash
+#
+# Claude Code Notification Hook - sends notifications to Telegram
+#
+
+SESSION_DIR="/tmp/telegram-claude-sessions"
+
+find_active_session() {
+  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"
+}
+
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  exit 0
+fi
+
+HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
+HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")
+HOOK_URL="http://\${HOOK_HOST}:\${HOOK_PORT}/notify"
+
+INPUT=$(cat)
+MESSAGE=$(echo "$INPUT" | jq -r '.message // "Notification from Claude"')
+
+PAYLOAD=$(jq -n \\
+  --arg type "notification" \\
+  --arg message "$MESSAGE" \\
+  '{type: $type, message: $message}')
+
+curl -s -X POST "$HOOK_URL" \\
+  -H "Content-Type: application/json" \\
+  -d "$PAYLOAD" \\
+  --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'
+        }
+      ]
+    }
+  ]
+};
+
+function setup() {
+  console.log('\n📱 telegram-claude-mcp Setup\n');
+  console.log('This will configure Telegram notifications for Claude Code.\n');
+
+  // Create hooks directory
+  if (!existsSync(HOOKS_DIR)) {
+    mkdirSync(HOOKS_DIR, { recursive: true });
+    console.log('✓ Created ~/.claude/hooks/');
+  }
+
+  // Write hook scripts
+  const permissionHookPath = join(HOOKS_DIR, 'permission-hook.sh');
+  writeFileSync(permissionHookPath, PERMISSION_HOOK);
+  chmodSync(permissionHookPath, 0o755);
+  console.log('✓ Installed permission-hook.sh');
+
+  const stopHookPath = join(HOOKS_DIR, 'stop-hook.sh');
+  writeFileSync(stopHookPath, STOP_HOOK);
+  chmodSync(stopHookPath, 0o755);
+  console.log('✓ Installed stop-hook.sh');
+
+  const notifyHookPath = join(HOOKS_DIR, 'notify-hook.sh');
+  writeFileSync(notifyHookPath, NOTIFY_HOOK);
+  chmodSync(notifyHookPath, 0o755);
+  console.log('✓ Installed notify-hook.sh');
+
+  // Update Claude settings
+  let settings = {};
+  if (existsSync(SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(readFileSync(SETTINGS_FILE, 'utf-8'));
+    } catch {
+      console.log('⚠ Could not parse existing settings.json, creating new one');
+    }
+  }
+
+  // Merge hooks config
+  settings.hooks = { ...settings.hooks, ...HOOKS_CONFIG };
+
+  // Add MCP server config if not present
+  if (!settings.mcpServers) {
+    settings.mcpServers = {};
+  }
+
+  if (!settings.mcpServers.telegram) {
+    settings.mcpServers.telegram = {
+      command: 'npx',
+      args: ['-y', 'telegram-claude-mcp'],
+      env: {
+        TELEGRAM_BOT_TOKEN: 'YOUR_BOT_TOKEN',
+        TELEGRAM_CHAT_ID: 'YOUR_CHAT_ID',
+        SESSION_NAME: 'default'
+      }
+    };
+    console.log('✓ Added telegram MCP server config (needs bot token)');
+  }
+
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+  console.log('✓ Updated ~/.claude/settings.json with hooks');
+
+  // Print next steps
+  console.log('\n' + '─'.repeat(50));
+  console.log('\n📋 Next Steps:\n');
+
+  console.log('1. Create a Telegram bot:');
+  console.log('   - Open Telegram and message @BotFather');
+  console.log('   - Send /newbot and follow the prompts');
+  console.log('   - Copy the bot token\n');
+
+  console.log('2. Get your Chat ID:');
+  console.log('   - Start a chat with your new bot');
+  console.log('   - Send any message');
+  console.log('   - Visit: https://api.telegram.org/bot<TOKEN>/getUpdates');
+  console.log('   - Find "chat":{"id": YOUR_CHAT_ID}\n');
+
+  console.log('3. Update ~/.claude/settings.json:');
+  console.log('   - Set TELEGRAM_BOT_TOKEN to your bot token');
+  console.log('   - Set TELEGRAM_CHAT_ID to your chat ID\n');
+
+  console.log('4. Restart Claude Code\n');
+
+  console.log('─'.repeat(50));
+  console.log('\n✨ Setup complete! Configure your bot token and chat ID to finish.\n');
+}
+
+// Run setup
+setup();

package/hooks/stop-hook.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+#
+# Claude Code Interactive Stop Hook
+#
+# When Claude stops, this sends a message to Telegram and waits for your reply.
+# If you reply with instructions, Claude continues working on them.
+# If you reply "done" or don't reply, Claude stops.
+#
+
+SESSION_DIR="/tmp/telegram-claude-sessions"
+
+# Function to find the most recent active session
+find_active_session() {
+  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"
+}
+
+# Read hook input
+INPUT=$(cat)
+
+# Check if stop_hook_active - if true, we already continued once, don't loop
+STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
+  echo "[stop-hook] Already continued once, allowing stop" >&2
+  exit 0
+fi
+
+# Find active session
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  echo "[stop-hook] No active session found" >&2
+  exit 0
+fi
+
+# Read port from session info
+HOOK_PORT=$(jq -r '.port' "$INFO_FILE")
+HOOK_HOST=$(jq -r '.host // "localhost"' "$INFO_FILE")
+HOOK_URL="http://${HOOK_HOST}:${HOOK_PORT}/stop"
+
+echo "[stop-hook] Using session: $INFO_FILE (port $HOOK_PORT)" >&2
+
+# Extract transcript path to get context
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // empty')
+
+# Build request payload
+PAYLOAD=$(jq -n \
+  --arg transcript_path "$TRANSCRIPT_PATH" \
+  '{transcript_path: $transcript_path}')
+
+# Send to server and wait for response (blocking - waits for user reply)
+RESPONSE=$(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" \
+  --max-time 300)
+
+if [ $? -ne 0 ]; then
+  echo "[stop-hook] Failed to connect to server" >&2
+  exit 0
+fi
+
+echo "[stop-hook] Response: $RESPONSE" >&2
+
+# Check if user wants to continue
+DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
+REASON=$(echo "$RESPONSE" | jq -r '.reason // empty')
+
+if [ "$DECISION" = "block" ] && [ -n "$REASON" ]; then
+  # User provided instructions - continue with them
+  echo "$RESPONSE"
+else
+  # User said done or no response - allow stop
+  exit 0
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-claude-mcp",
-  "version": "1.2.4",
+  "version": "1.4.0",
   "description": "MCP server that lets Claude message you on Telegram with hooks support",
   "author": "Geravant",
   "license": "MIT",
@@ -21,7 +21,8 @@
   "type": "module",
   "main": "src/index.ts",
   "bin": {
-    "telegram-claude-mcp": "./bin/run.js"
+    "telegram-claude-mcp": "./bin/run.js",
+    "telegram-claude-setup": "./bin/setup.js"
   },
   "files": [
     "src",

package/src/index.ts

@@ -190,6 +190,19 @@ async function main() {
         return;
       }
 
+      // Handle interactive stop (waits for user reply)
+      if (url === '/stop' || url === '/hooks/stop') {
+        const { transcript_path } = data;
+
+        console.error(`[HTTP] Interactive stop request`);
+
+        const result = await telegram.handleInteractiveStop(transcript_path);
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+        return;
+      }
+
       // Unknown endpoint
       res.writeHead(404, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: 'Not found' }));

package/src/telegram.ts

@@ -241,6 +241,74 @@ export class TelegramManager {
     await this.bot.sendMessage(this.config.chatId, message);
   }
 
+  /**
+   * 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
+   */
+  async handleInteractiveStop(transcriptPath?: string): Promise<Record<string, unknown>> {
+    // Try to get last assistant message from transcript
+    let lastMessage = 'Claude has finished working.';
+    if (transcriptPath) {
+      try {
+        const fs = await import('fs');
+        if (fs.existsSync(transcriptPath)) {
+          const content = fs.readFileSync(transcriptPath, 'utf-8');
+          const lines = content.trim().split('\n');
+          // Find last assistant message
+          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) {
+                  lastMessage = textContent.text.slice(0, 500);
+                  if (textContent.text.length > 500) lastMessage += '...';
+                  break;
+                }
+              }
+            } catch {
+              // Skip invalid JSON lines
+            }
+          }
+        }
+      } catch (err) {
+        console.error('[Telegram] Error reading transcript:', err);
+      }
+    }
+
+    const message = `🏁 [${this.config.sessionName}] 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);
+
+    // Update session state
+    this.updateSessionState({
+      waitingForResponse: true,
+      messageIds: [...this.getSessionState().messageIds, sent.message_id],
+    });
+
+    // Wait for response with longer timeout for interactive stop
+    try {
+      const response = await this.waitForResponse(sent.message_id);
+
+      // 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);
+      return {};
+    }
+  }
+
   /**
    * Format tool input for display
    */