telegram-claude-mcp 1.6.0 → 2.0.1

package/bin/daemon-ctl.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+/**
+ * Daemon Control CLI
+ *
+ * Manage the telegram-claude-daemon:
+ *   daemon-ctl start   - Start the daemon
+ *   daemon-ctl stop    - Stop the daemon
+ *   daemon-ctl restart - Restart the daemon
+ *   daemon-ctl status  - Check daemon status
+ *   daemon-ctl logs    - Show daemon logs (if running with pm2 or similar)
+ */
+
+import { spawn, execSync } from 'child_process';
+import { existsSync, readFileSync, unlinkSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const DAEMON_PID_FILE = '/tmp/telegram-claude-daemon.pid';
+const DAEMON_SOCKET_PATH = '/tmp/telegram-claude-daemon.sock';
+const DAEMON_HTTP_PORT = 3333;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const daemonScript = join(__dirname, '..', 'dist', 'daemon', 'index.js');
+const daemonSrc = join(__dirname, '..', 'src', 'daemon', 'index.ts');
+
+function getPid() {
+  if (existsSync(DAEMON_PID_FILE)) {
+    try {
+      const pid = parseInt(readFileSync(DAEMON_PID_FILE, 'utf-8').trim(), 10);
+      // Check if process is alive
+      try {
+        process.kill(pid, 0);
+        return pid;
+      } catch {
+        // Process not running, clean up stale files
+        cleanup();
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function cleanup() {
+  try {
+    if (existsSync(DAEMON_PID_FILE)) unlinkSync(DAEMON_PID_FILE);
+    if (existsSync(DAEMON_SOCKET_PATH)) unlinkSync(DAEMON_SOCKET_PATH);
+  } catch {}
+}
+
+async function getStatus() {
+  const pid = getPid();
+  if (!pid) {
+    return { running: false };
+  }
+
+  try {
+    const response = await fetch(`http://localhost:${DAEMON_HTTP_PORT}/status`);
+    const data = await response.json();
+    return { running: true, pid, ...data };
+  } catch {
+    return { running: true, pid, sessions: [] };
+  }
+}
+
+async function start() {
+  const pid = getPid();
+  if (pid) {
+    console.log(`Daemon already running (PID: ${pid})`);
+    return;
+  }
+
+  // Determine which script to run
+  let script = daemonScript;
+  let runner = 'node';
+
+  if (!existsSync(daemonScript)) {
+    if (existsSync(daemonSrc)) {
+      script = daemonSrc;
+      runner = 'bun';
+    } else {
+      console.error('Error: Daemon script not found. Run `npm run build` first.');
+      process.exit(1);
+    }
+  }
+
+  console.log('Starting telegram-claude-daemon...');
+
+  const child = spawn(runner, [script], {
+    detached: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: process.env,
+  });
+
+  child.unref();
+
+  // Wait for daemon to start
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  const newPid = getPid();
+  if (newPid) {
+    console.log(`Daemon started (PID: ${newPid})`);
+    console.log(`  Socket: ${DAEMON_SOCKET_PATH}`);
+    console.log(`  HTTP: http://localhost:${DAEMON_HTTP_PORT}`);
+  } else {
+    console.error('Failed to start daemon');
+    process.exit(1);
+  }
+}
+
+function stop() {
+  const pid = getPid();
+  if (!pid) {
+    console.log('Daemon is not running');
+    return;
+  }
+
+  console.log(`Stopping daemon (PID: ${pid})...`);
+
+  try {
+    process.kill(pid, 'SIGTERM');
+
+    // Wait for process to exit
+    let attempts = 0;
+    while (attempts < 10) {
+      try {
+        process.kill(pid, 0);
+        execSync('sleep 0.5');
+        attempts++;
+      } catch {
+        break;
+      }
+    }
+
+    cleanup();
+    console.log('Daemon stopped');
+  } catch (err) {
+    console.error('Failed to stop daemon:', err.message);
+    cleanup();
+  }
+}
+
+async function status() {
+  const info = await getStatus();
+
+  if (!info.running) {
+    console.log('Daemon: not running');
+    return;
+  }
+
+  console.log('Daemon: running');
+  console.log(`  PID: ${info.pid}`);
+  console.log(`  Version: ${info.version || 'unknown'}`);
+  console.log(`  Active Sessions: ${info.activeSessions || 0}`);
+
+  if (info.sessions && info.sessions.length > 0) {
+    console.log('  Sessions:');
+    for (const session of info.sessions) {
+      console.log(`    - ${session.sessionName} (${session.sessionId})`);
+      console.log(`      Connected: ${session.connectedAt}`);
+      console.log(`      Last Activity: ${session.lastActivity}`);
+    }
+  }
+}
+
+async function main() {
+  const command = process.argv[2];
+
+  switch (command) {
+    case 'start':
+      await start();
+      break;
+
+    case 'stop':
+      stop();
+      break;
+
+    case 'restart':
+      stop();
+      await new Promise((r) => setTimeout(r, 500));
+      await start();
+      break;
+
+    case 'status':
+      await status();
+      break;
+
+    default:
+      console.log('Usage: daemon-ctl <command>');
+      console.log('');
+      console.log('Commands:');
+      console.log('  start   - Start the daemon');
+      console.log('  stop    - Stop the daemon');
+      console.log('  restart - Restart the daemon');
+      console.log('  status  - Check daemon status');
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/bin/daemon.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+/**
+ * Telegram Claude Daemon launcher
+ *
+ * Usage: telegram-claude-daemon
+ *
+ * Required environment variables:
+ *   TELEGRAM_BOT_TOKEN - Your Telegram bot token
+ *   TELEGRAM_CHAT_ID - Your Telegram chat ID
+ */
+
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+// Register tsx loader for TypeScript support
+register('tsx', pathToFileURL('./'));
+
+// Import and run the daemon
+import('../src/daemon/index.ts');

package/bin/proxy.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+/**
+ * Telegram Claude MCP Proxy launcher
+ *
+ * Usage: telegram-claude-proxy
+ *
+ * This connects to a running telegram-claude-daemon via Unix socket.
+ * Make sure to start the daemon first: telegram-claude-ctl start
+ *
+ * Optional environment variables:
+ *   SESSION_NAME - Session identifier (default: auto-detected from CWD)
+ */
+
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+// Register tsx loader for TypeScript support
+register('tsx', pathToFileURL('./'));
+
+// Import and run the proxy
+import('../src/proxy/index.ts');

package/bin/setup.js

@@ -97,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
@@ -121,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
-
-INFO_FILE=$(find_active_session)
+[ "$STOP_HOOK_ACTIVE" = "true" ] && exit 0
 
-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")
@@ -156,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
@@ -190,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")
@@ -218,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');
@@ -291,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) {
@@ -337,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-v2/notify-hook.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Notify hook for telegram-claude-daemon (v2)
+# Uses single daemon port instead of session discovery
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/notify"
+
+# Read input from stdin
+INPUT=$(cat)
+MESSAGE=$(echo "$INPUT" | jq -r '.message // "Notification"')
+
+# Build payload
+if [ -n "$SESSION_NAME" ]; then
+  PAYLOAD=$(jq -n \
+    --arg type "notification" \
+    --arg message "$MESSAGE" \
+    --arg session_name "$SESSION_NAME" \
+    '{type: $type, message: $message, session_name: $session_name}')
+else
+  PAYLOAD=$(jq -n \
+    --arg type "notification" \
+    --arg message "$MESSAGE" \
+    '{type: $type, message: $message}')
+fi
+
+# Send to daemon (non-blocking, 10 second timeout)
+curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 10 >/dev/null 2>&1

package/hooks-v2/permission-hook.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Permission hook for telegram-claude-daemon (v2)
+# Uses single daemon port instead of session discovery
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/permission"
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Extract tool name and input
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // .toolName // .name // empty')
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // .toolInput // .input // .arguments // {}')
+
+if [ -z "$TOOL_NAME" ]; then
+  exit 0
+fi
+
+# Build payload with session name if available
+if [ -n "$SESSION_NAME" ]; then
+  PAYLOAD=$(jq -n \
+    --arg tool_name "$TOOL_NAME" \
+    --argjson tool_input "$TOOL_INPUT" \
+    --arg session_name "$SESSION_NAME" \
+    '{tool_name: $tool_name, tool_input: $tool_input, session_name: $session_name}')
+else
+  PAYLOAD=$(jq -n \
+    --arg tool_name "$TOOL_NAME" \
+    --argjson tool_input "$TOOL_INPUT" \
+    '{tool_name: $tool_name, tool_input: $tool_input}')
+fi
+
+# Send to daemon (10 minute timeout)
+RESPONSE=$(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 600 2>/dev/null)
+
+if [ $? -eq 0 ] && [ -n "$RESPONSE" ]; then
+  echo "$RESPONSE"
+fi

package/hooks-v2/stop-hook.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# Stop hook for telegram-claude-daemon (v2)
+# Uses single daemon port instead of session discovery
+
+DAEMON_PORT="${TELEGRAM_CLAUDE_PORT:-3333}"
+DAEMON_HOST="${TELEGRAM_CLAUDE_HOST:-localhost}"
+HOOK_URL="http://${DAEMON_HOST}:${DAEMON_PORT}/stop"
+
+# Read input from stdin
+INPUT=$(cat)
+
+# Check if stop hook is already active (prevent recursion)
+STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
+  exit 0
+fi
+
+# Extract transcript path
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // empty')
+
+# Build payload
+if [ -n "$SESSION_NAME" ]; then
+  PAYLOAD=$(jq -n \
+    --arg transcript_path "$TRANSCRIPT_PATH" \
+    --arg session_name "$SESSION_NAME" \
+    '{transcript_path: $transcript_path, session_name: $session_name}')
+else
+  PAYLOAD=$(jq -n \
+    --arg transcript_path "$TRANSCRIPT_PATH" \
+    '{transcript_path: $transcript_path}')
+fi
+
+# Send to daemon (5 minute timeout)
+RESPONSE=$(curl -s -X POST "$HOOK_URL" \
+  -H "Content-Type: application/json" \
+  -H "X-Session-Name: ${SESSION_NAME:-default}" \
+  -d "$PAYLOAD" \
+  --max-time 300 2>/dev/null)
+
+if [ $? -eq 0 ] && [ -n "$RESPONSE" ]; then
+  DECISION=$(echo "$RESPONSE" | jq -r '.decision // empty')
+  if [ "$DECISION" = "block" ]; then
+    echo "$RESPONSE"
+  fi
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-claude-mcp",
-  "version": "1.6.0",
+  "version": "2.0.1",
   "description": "MCP server that lets Claude message you on Telegram with hooks support",
   "author": "Geravant",
   "license": "MIT",
@@ -16,23 +16,34 @@
     "bot",
     "messaging",
     "hooks",
-    "permissions"
+    "permissions",
+    "daemon"
   ],
   "type": "module",
   "main": "src/index.ts",
   "bin": {
     "telegram-claude-mcp": "./bin/run.js",
-    "telegram-claude-setup": "./bin/setup.js"
+    "telegram-claude-setup": "./bin/setup.js",
+    "telegram-claude-daemon": "./bin/daemon.js",
+    "telegram-claude-proxy": "./bin/proxy.js",
+    "telegram-claude-ctl": "./bin/daemon-ctl.js"
   },
   "files": [
     "src",
     "bin",
     "hooks",
-    "README.md"
+    "hooks-v2",
+    "README.md",
+    "ARCHITECTURE.md"
   ],
   "scripts": {
     "start": "node --import tsx src/index.ts",
-    "dev": "node --watch --import tsx src/index.ts"
+    "dev": "node --watch --import tsx src/index.ts",
+    "daemon": "node --import tsx src/daemon/index.ts",
+    "proxy": "node --import tsx src/proxy/index.ts",
+    "daemon:start": "node bin/daemon-ctl.js start",
+    "daemon:stop": "node bin/daemon-ctl.js stop",
+    "daemon:status": "node bin/daemon-ctl.js status"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",