telegram-claude-mcp 1.6.0 → 2.0.1

package/src/daemon/index.ts

@@ -0,0 +1,415 @@
+#!/usr/bin/env bun
+
+/**
+ * Telegram Claude Daemon
+ *
+ * Singleton daemon that handles all Telegram communication for multiple
+ * Claude Code sessions. Proxies connect via Unix socket.
+ */
+
+import * as net from 'net';
+import { createServer, type IncomingMessage, type ServerResponse } from 'http';
+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 {
+  DAEMON_SOCKET_PATH,
+  DAEMON_PID_FILE,
+  DAEMON_HTTP_PORT,
+  serializeMessage,
+  parseMessages,
+  type ProxyMessage,
+  type DaemonMessage,
+  type DaemonConnectedMessage,
+  type DaemonToolResultMessage,
+  type DaemonErrorMessage,
+  type DaemonPongMessage,
+} from '../shared/protocol.js';
+
+const VERSION = '2.0.0';
+
+interface DaemonConfig {
+  telegramBotToken: string;
+  telegramChatId: number;
+  responseTimeoutMs: number;
+  permissionTimeoutMs: number;
+}
+
+function loadConfig(): DaemonConfig {
+  const botToken = process.env.TELEGRAM_BOT_TOKEN;
+  const chatId = process.env.TELEGRAM_CHAT_ID;
+
+  if (!botToken) {
+    console.error('Error: TELEGRAM_BOT_TOKEN is required');
+    process.exit(1);
+  }
+
+  if (!chatId) {
+    console.error('Error: TELEGRAM_CHAT_ID is required');
+    process.exit(1);
+  }
+
+  return {
+    telegramBotToken: botToken,
+    telegramChatId: parseInt(chatId, 10),
+    responseTimeoutMs: parseInt(process.env.CHAT_RESPONSE_TIMEOUT_MS || '600000', 10),
+    permissionTimeoutMs: parseInt(process.env.PERMISSION_TIMEOUT_MS || '600000', 10),
+  };
+}
+
+async function main() {
+  const config = loadConfig();
+
+  console.error('');
+  console.error('Telegram Claude Daemon v' + VERSION);
+  console.error('================================');
+
+  // Clean up stale socket
+  if (existsSync(DAEMON_SOCKET_PATH)) {
+    console.error('[Daemon] Removing stale socket');
+    unlinkSync(DAEMON_SOCKET_PATH);
+  }
+
+  // Ensure socket directory exists
+  const socketDir = dirname(DAEMON_SOCKET_PATH);
+  if (!existsSync(socketDir)) {
+    mkdirSync(socketDir, { recursive: true });
+  }
+
+  // Write PID file
+  writeFileSync(DAEMON_PID_FILE, process.pid.toString());
+
+  // Create session manager
+  const sessionManager = new SessionManager();
+
+  // Create multi-session Telegram manager
+  const telegram = new MultiTelegramManager(
+    {
+      botToken: config.telegramBotToken,
+      chatId: config.telegramChatId,
+      responseTimeoutMs: config.responseTimeoutMs,
+      permissionTimeoutMs: config.permissionTimeoutMs,
+    },
+    sessionManager
+  );
+
+  telegram.start();
+
+  // Track socket buffers for each connection
+  const socketBuffers = new Map<net.Socket, string>();
+
+  // Create Unix socket server for proxy connections
+  const ipcServer = net.createServer((socket) => {
+    console.error('[Daemon] New proxy connection');
+    socketBuffers.set(socket, '');
+
+    socket.on('data', async (data) => {
+      let buffer = socketBuffers.get(socket) || '';
+      buffer += data.toString();
+
+      const { messages, remainder } = parseMessages<ProxyMessage>(buffer);
+      socketBuffers.set(socket, remainder);
+
+      for (const msg of messages) {
+        await handleProxyMessage(socket, msg, sessionManager, telegram);
+      }
+    });
+
+    socket.on('close', () => {
+      const session = sessionManager.findBySocket(socket);
+      if (session) {
+        console.error(`[Daemon] Proxy disconnected: ${session.sessionId}`);
+        sessionManager.unregister(session.sessionId);
+      }
+      socketBuffers.delete(socket);
+    });
+
+    socket.on('error', (err) => {
+      console.error('[Daemon] Socket error:', err.message);
+    });
+  });
+
+  ipcServer.listen(DAEMON_SOCKET_PATH, () => {
+    console.error(`[Daemon] IPC server listening on ${DAEMON_SOCKET_PATH}`);
+  });
+
+  // Create HTTP server for hooks
+  const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    if (req.method !== 'POST') {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method not allowed' }));
+      return;
+    }
+
+    let body = '';
+    for await (const chunk of req) {
+      body += chunk;
+    }
+
+    try {
+      const data = JSON.parse(body);
+      const url = req.url || '/';
+
+      // Get session name from header or data
+      const sessionName = req.headers['x-session-name'] as string || data.session_name || 'default';
+
+      if (url === '/permission' || url === '/hooks/permission') {
+        const { tool_name, tool_input } = data;
+
+        if (!tool_name) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Missing tool_name' }));
+          return;
+        }
+
+        console.error(`[HTTP] Permission request: ${tool_name} (session: ${sessionName})`);
+
+        const decision = await telegram.handlePermissionRequest(
+          sessionName,
+          tool_name,
+          tool_input || {}
+        );
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'PermissionRequest',
+            decision: {
+              behavior: decision.behavior,
+              ...(decision.message && { message: decision.message }),
+            },
+          },
+        }));
+        return;
+      }
+
+      if (url === '/notify' || url === '/hooks/notify') {
+        const event: HookEvent = {
+          type: data.type || 'notification',
+          message: data.message,
+          session_id: data.session_id,
+          tool_name: data.tool_name,
+          tool_input: data.tool_input,
+          timestamp: data.timestamp || new Date().toISOString(),
+        };
+
+        console.error(`[HTTP] Notification: ${event.type} (session: ${sessionName})`);
+        await telegram.sendHookNotification(sessionName, event);
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true }));
+        return;
+      }
+
+      if (url === '/stop' || url === '/hooks/stop') {
+        const { transcript_path } = data;
+
+        console.error(`[HTTP] Interactive stop (session: ${sessionName})`);
+        const result = await telegram.handleInteractiveStop(sessionName, transcript_path);
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+        return;
+      }
+
+      // Status endpoint
+      if (url === '/status') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          version: VERSION,
+          activeSessions: sessionManager.count(),
+          sessions: sessionManager.getAll().map(s => ({
+            sessionId: s.sessionId,
+            sessionName: s.sessionName,
+            connectedAt: s.connectedAt,
+            lastActivity: s.lastActivity,
+          })),
+        }));
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found' }));
+    } catch (error) {
+      console.error('[HTTP] Error:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Internal server error' }));
+    }
+  });
+
+  httpServer.listen(DAEMON_HTTP_PORT, () => {
+    console.error(`[Daemon] HTTP hook server on port ${DAEMON_HTTP_PORT}`);
+  });
+
+  console.error('');
+  console.error('Daemon ready!');
+  console.error(`  IPC: ${DAEMON_SOCKET_PATH}`);
+  console.error(`  HTTP: http://localhost:${DAEMON_HTTP_PORT}`);
+  console.error(`  PID: ${process.pid}`);
+  console.error('');
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.error('\n[Daemon] Shutting down...');
+
+    // Close all proxy connections
+    for (const session of sessionManager.getAll()) {
+      session.socket.end();
+    }
+
+    ipcServer.close();
+    httpServer.close();
+    telegram.stop();
+
+    // Clean up files
+    try {
+      if (existsSync(DAEMON_SOCKET_PATH)) unlinkSync(DAEMON_SOCKET_PATH);
+      if (existsSync(DAEMON_PID_FILE)) unlinkSync(DAEMON_PID_FILE);
+    } catch {}
+
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Periodic cleanup of dead sessions
+  setInterval(() => {
+    sessionManager.cleanup();
+  }, 30000);
+}
+
+/**
+ * Handle a message from a proxy
+ */
+async function handleProxyMessage(
+  socket: net.Socket,
+  msg: ProxyMessage,
+  sessionManager: SessionManager,
+  telegram: MultiTelegramManager
+): Promise<void> {
+  console.error(`[Daemon] Received: ${msg.type} from ${msg.sessionId}`);
+
+  switch (msg.type) {
+    case 'connect': {
+      sessionManager.register(msg.sessionId, msg.sessionName, socket, msg.projectPath);
+
+      const response: DaemonConnectedMessage = {
+        type: 'connected',
+        sessionId: msg.sessionId,
+        daemonVersion: VERSION,
+      };
+      socket.write(serializeMessage(response));
+      break;
+    }
+
+    case 'disconnect': {
+      sessionManager.unregister(msg.sessionId);
+      break;
+    }
+
+    case 'ping': {
+      const response: DaemonPongMessage = {
+        type: 'pong',
+        sessionId: msg.sessionId,
+        activeSessions: sessionManager.count(),
+      };
+      socket.write(serializeMessage(response));
+      break;
+    }
+
+    case 'tool_call': {
+      const { requestId, tool, arguments: args } = msg;
+      sessionManager.touch(msg.sessionId);
+
+      try {
+        let result: { content: Array<{ type: string; text: string }>; isError?: boolean };
+
+        switch (tool) {
+          case 'send_message': {
+            const { message } = args as { message: string };
+            const res = await telegram.sendMessageAndWait(msg.sessionId, message);
+            result = {
+              content: [
+                {
+                  type: 'text',
+                  text: `Message sent to Telegram.\n\nChat ID: ${res.chatId}\n\nUser's response:\n${res.response}\n\nUse continue_chat for follow-ups or end_chat to close.`,
+                },
+              ],
+            };
+            break;
+          }
+
+          case 'continue_chat': {
+            const { message } = args as { chat_id: string; message: string };
+            const response = await telegram.continueChat(msg.sessionId, message);
+            result = {
+              content: [{ type: 'text', text: `User's response:\n${response}` }],
+            };
+            break;
+          }
+
+          case 'notify_user': {
+            const { message } = args as { chat_id: string; message: string };
+            await telegram.notify(msg.sessionId, message);
+            result = {
+              content: [{ type: 'text', text: `Notification sent: "${message}"` }],
+            };
+            break;
+          }
+
+          case 'end_chat': {
+            const { message } = args as { chat_id: string; message?: string };
+            await telegram.endChat(msg.sessionId, message);
+            result = {
+              content: [{ type: 'text', text: 'Chat session ended.' }],
+            };
+            break;
+          }
+
+          default:
+            throw new Error(`Unknown tool: ${tool}`);
+        }
+
+        const response: DaemonToolResultMessage = {
+          type: 'tool_result',
+          sessionId: msg.sessionId,
+          requestId,
+          success: true,
+          result,
+        };
+        socket.write(serializeMessage(response));
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const response: DaemonToolResultMessage = {
+          type: 'tool_result',
+          sessionId: msg.sessionId,
+          requestId,
+          success: false,
+          result: {
+            content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+            isError: true,
+          },
+        };
+        socket.write(serializeMessage(response));
+      }
+      break;
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/daemon/session-manager.ts

@@ -0,0 +1,173 @@
+/**
+ * Session Manager for the Telegram Claude Daemon
+ *
+ * Tracks all connected Claude Code sessions and their state.
+ */
+
+import type { Socket } from 'net';
+import type { SessionInfo } from '../shared/protocol.js';
+
+export interface ConnectedSession extends SessionInfo {
+  socket: Socket;
+}
+
+export class SessionManager {
+  private sessions: Map<string, ConnectedSession> = new Map();
+
+  /**
+   * Register a new session
+   */
+  register(
+    sessionId: string,
+    sessionName: string,
+    socket: Socket,
+    projectPath?: string
+  ): ConnectedSession {
+    const session: ConnectedSession = {
+      sessionId,
+      sessionName,
+      projectPath,
+      socket,
+      connectedAt: new Date(),
+      lastActivity: new Date(),
+      activeChats: new Set(),
+    };
+
+    this.sessions.set(sessionId, session);
+    console.error(`[SessionManager] Registered session: ${sessionId} (${sessionName})`);
+
+    return session;
+  }
+
+  /**
+   * Unregister a session
+   */
+  unregister(sessionId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      this.sessions.delete(sessionId);
+      console.error(`[SessionManager] Unregistered session: ${sessionId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get session by ID
+   */
+  get(sessionId: string): ConnectedSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Get session by name (returns first match)
+   */
+  getByName(sessionName: string): ConnectedSession | undefined {
+    for (const session of this.sessions.values()) {
+      if (session.sessionName === sessionName) {
+        return session;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get all sessions
+   */
+  getAll(): ConnectedSession[] {
+    return Array.from(this.sessions.values());
+  }
+
+  /**
+   * Get count of active sessions
+   */
+  count(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * Update last activity timestamp
+   */
+  touch(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.lastActivity = new Date();
+    }
+  }
+
+  /**
+   * Add active chat to session
+   */
+  addChat(sessionId: string, chatId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.activeChats.add(chatId);
+    }
+  }
+
+  /**
+   * Remove active chat from session
+   */
+  removeChat(sessionId: string, chatId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.activeChats.delete(chatId);
+    }
+  }
+
+  /**
+   * Find session by socket
+   */
+  findBySocket(socket: Socket): ConnectedSession | undefined {
+    for (const session of this.sessions.values()) {
+      if (session.socket === socket) {
+        return session;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get most recently active session
+   */
+  getMostRecentActive(): ConnectedSession | undefined {
+    let mostRecent: ConnectedSession | undefined;
+    let latestTime = 0;
+
+    for (const session of this.sessions.values()) {
+      const time = session.lastActivity.getTime();
+      if (time > latestTime) {
+        latestTime = time;
+        mostRecent = session;
+      }
+    }
+
+    return mostRecent;
+  }
+
+  /**
+   * Find session that should receive a hook event
+   * Priority: explicit session name > most recently active
+   */
+  findForHook(sessionName?: string): ConnectedSession | undefined {
+    if (sessionName) {
+      return this.getByName(sessionName);
+    }
+    return this.getMostRecentActive();
+  }
+
+  /**
+   * Clean up disconnected sessions
+   */
+  cleanup(): number {
+    let cleaned = 0;
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (session.socket.destroyed) {
+        this.sessions.delete(sessionId);
+        cleaned++;
+        console.error(`[SessionManager] Cleaned up dead session: ${sessionId}`);
+      }
+    }
+    return cleaned;
+  }
+}