telegram-claude-mcp 1.1.0 → 1.2.0

package/hooks/notify-hook.sh

@@ -5,19 +5,51 @@
 # This script receives notification events from Claude Code (stop, session events)
 # and forwards them to the Telegram MCP server.
 #
-# Usage: Configure this script in your Claude Code hooks settings for Stop event
-#
-# Environment variables:
-#   TELEGRAM_HOOK_PORT - Port of the MCP server (default: 3333)
-#   TELEGRAM_HOOK_HOST - Host of the MCP server (default: localhost)
-#   TELEGRAM_HOOK_EVENT - Event type override (default: from input or 'stop')
+# The script auto-discovers the MCP server port from session info files.
+# No configuration needed - it finds running MCP servers automatically.
 #
 
-HOOK_PORT="${TELEGRAM_HOOK_PORT:-3333}"
-HOOK_HOST="${TELEGRAM_HOOK_HOST:-localhost}"
-HOOK_URL="http://${HOOK_HOST}:${HOOK_PORT}/notify"
+SESSION_DIR="/tmp/telegram-claude-sessions"
 EVENT_TYPE="${TELEGRAM_HOOK_EVENT:-stop}"
 
+# Function to find the most recent active session
+find_active_session() {
+  local latest_file=""
+  local latest_time=0
+
+  for info_file in "$SESSION_DIR"/*.info 2>/dev/null; do
+    [ -f "$info_file" ] || continue
+
+    # Check if the process is still running
+    local pid=$(jq -r '.pid // empty' "$info_file" 2>/dev/null)
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      local 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"
+}
+
+# Find active session info
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  echo "[notify-hook] No active session found, skipping notification" >&2
+  echo '{"continue": true}'
+  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}/notify"
+
+echo "[notify-hook] Using session: $INFO_FILE (port $HOOK_PORT)" >&2
+
 # Read the hook input from stdin
 INPUT=$(cat)
 
@@ -25,9 +57,7 @@ INPUT=$(cat)
 SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
 MESSAGE=$(echo "$INPUT" | jq -r '.message // .stop_reason // "Agent stopped"')
 
-# Log for debugging
-echo "[notify-hook] Event: $EVENT_TYPE" >&2
-echo "[notify-hook] Message: $MESSAGE" >&2
+echo "[notify-hook] Event: $EVENT_TYPE, Message: $MESSAGE" >&2
 
 # Build the request payload
 PAYLOAD=$(jq -n \
@@ -36,11 +66,11 @@ PAYLOAD=$(jq -n \
   --arg session_id "$SESSION_ID" \
   '{type: $type, message: $message, session_id: $session_id}')
 
-# Send the notification (non-blocking, we don't need to wait)
+# Send the notification (non-blocking)
 curl -s -X POST "$HOOK_URL" \
   -H "Content-Type: application/json" \
   -d "$PAYLOAD" \
   --max-time 10 >/dev/null 2>&1 &
 
-# Return success immediately (hook doesn't need to block)
+# Return success immediately
 echo '{"continue": true}'

package/hooks/permission-hook.sh

@@ -5,17 +5,50 @@
 # This script receives permission requests from Claude Code and forwards them
 # to the Telegram MCP server for interactive approval via Telegram.
 #
-# Usage: Configure this script in your Claude Code hooks settings
-#
-# Environment variables:
-#   TELEGRAM_HOOK_PORT - Port of the MCP server (default: 3333)
-#   TELEGRAM_HOOK_HOST - Host of the MCP server (default: localhost)
+# The script auto-discovers the MCP server port from session info files.
+# No configuration needed - it finds running MCP servers automatically.
 #
 
-HOOK_PORT="${TELEGRAM_HOOK_PORT:-3333}"
-HOOK_HOST="${TELEGRAM_HOOK_HOST:-localhost}"
+SESSION_DIR="/tmp/telegram-claude-sessions"
+
+# Function to find the most recent active session
+find_active_session() {
+  local latest_file=""
+  local latest_time=0
+
+  for info_file in "$SESSION_DIR"/*.info 2>/dev/null; do
+    [ -f "$info_file" ] || continue
+
+    # Check if the process is still running
+    local pid=$(jq -r '.pid // empty' "$info_file" 2>/dev/null)
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+      local 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"
+}
+
+# Find active session info
+INFO_FILE=$(find_active_session)
+
+if [ -z "$INFO_FILE" ] || [ ! -f "$INFO_FILE" ]; then
+  echo "[permission-hook] No active session found" >&2
+  # Return empty to fall back to default behavior (terminal prompt)
+  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}/permission"
 
+echo "[permission-hook] Using session: $INFO_FILE (port $HOOK_PORT)" >&2
+
 # Read the hook input from stdin
 INPUT=$(cat)
 
@@ -23,16 +56,13 @@ INPUT=$(cat)
 TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty')
 TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
 
-# If no tool_name, this might be a different format - try to extract from the input
+# If no tool_name, try alternative paths
 if [ -z "$TOOL_NAME" ]; then
-  # Claude Code might send the data differently, try alternative paths
   TOOL_NAME=$(echo "$INPUT" | jq -r '.toolName // .name // empty')
   TOOL_INPUT=$(echo "$INPUT" | jq -c '.toolInput // .input // .arguments // {}')
 fi
 
-# Log for debugging (goes to stderr, not stdout)
 echo "[permission-hook] Tool: $TOOL_NAME" >&2
-echo "[permission-hook] Sending to: $HOOK_URL" >&2
 
 # Build the request payload
 PAYLOAD=$(jq -n \
@@ -46,16 +76,11 @@ RESPONSE=$(curl -s -X POST "$HOOK_URL" \
   -d "$PAYLOAD" \
   --max-time 600)
 
-# Check if curl succeeded
 if [ $? -ne 0 ]; then
   echo "[permission-hook] Error: Failed to connect to hook server" >&2
-  # Return deny on error for safety
-  echo '{"hookSpecificOutput":{"decision":{"behavior":"deny","message":"Failed to connect to Telegram hook server"}}}'
+  # Return empty to fall back to default behavior
   exit 0
 fi
 
-# Log the response
 echo "[permission-hook] Response: $RESPONSE" >&2
-
-# Output the response (this goes back to Claude Code)
 echo "$RESPONSE"

package/package.json

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

package/src/index.ts

@@ -16,6 +16,70 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import { TelegramManager, type HookEvent, type PermissionDecision } from './telegram.js';
 import { loadAppConfig, validateAppConfig } from './providers/index.js';
 import { createServer, type IncomingMessage, type ServerResponse } from 'http';
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+// Session info directory (shared with hooks)
+const SESSION_DIR = '/tmp/telegram-claude-sessions';
+
+/**
+ * Find an available port starting from the preferred port
+ */
+async function findAvailablePort(preferredPort: number): Promise<number> {
+  const net = await import('net');
+
+  return new Promise((resolve) => {
+    const tryPort = (port: number) => {
+      const server = net.createServer();
+      server.listen(port, '127.0.0.1');
+
+      server.on('listening', () => {
+        server.close(() => resolve(port));
+      });
+
+      server.on('error', () => {
+        // Port in use, try next
+        tryPort(port + 1);
+      });
+    };
+
+    tryPort(preferredPort);
+  });
+}
+
+/**
+ * Write session info file for hooks to discover
+ */
+function writeSessionInfo(sessionName: string, port: number): string {
+  if (!existsSync(SESSION_DIR)) {
+    mkdirSync(SESSION_DIR, { recursive: true });
+  }
+
+  const infoFile = join(SESSION_DIR, `${sessionName}.info`);
+  const info = {
+    port,
+    host: 'localhost',
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+  };
+
+  writeFileSync(infoFile, JSON.stringify(info, null, 2));
+  return infoFile;
+}
+
+/**
+ * Clean up session info file
+ */
+function cleanupSessionInfo(sessionName: string): void {
+  const infoFile = join(SESSION_DIR, `${sessionName}.info`);
+  try {
+    if (existsSync(infoFile)) {
+      unlinkSync(infoFile);
+    }
+  } catch {
+    // Ignore cleanup errors
+  }
+}
 
 async function main() {
   // Load configuration
@@ -39,6 +103,10 @@ async function main() {
 
   telegram.start();
 
+  // Find available port and start HTTP server for hooks
+  const actualPort = await findAvailablePort(config.sessionPort);
+  const sessionInfoFile = writeSessionInfo(config.sessionName, actualPort);
+
   // Start HTTP server for hooks
   const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
     // CORS headers
@@ -127,8 +195,11 @@ async function main() {
     }
   });
 
-  httpServer.listen(config.sessionPort, () => {
-    console.error(`[HTTP] Hook server listening on port ${config.sessionPort}`);
+  httpServer.listen(actualPort, () => {
+    console.error(`[HTTP] Hook server listening on port ${actualPort}`);
+    if (actualPort !== config.sessionPort) {
+      console.error(`[HTTP] (preferred port ${config.sessionPort} was in use)`);
+    }
   });
 
   // Track active chat sessions
@@ -282,12 +353,14 @@ async function main() {
   console.error('Telegram Claude MCP server ready');
   console.error(`Session: ${config.sessionName}`);
   console.error(`Chat ID: ${config.telegramChatId}`);
-  console.error(`Hook server: http://localhost:${config.sessionPort}`);
+  console.error(`Hook server: http://localhost:${actualPort}`);
+  console.error(`Session info: ${sessionInfoFile}`);
   console.error('');
 
   // Graceful shutdown
   const shutdown = async () => {
     console.error('\nShutting down...');
+    cleanupSessionInfo(config.sessionName);
     httpServer.close();
     telegram.stop();
     process.exit(0);