telegram-claude-mcp 1.6.0 → 2.0.1

package/src/proxy/index.ts

@@ -0,0 +1,429 @@
+#!/usr/bin/env bun
+
+/**
+ * Telegram Claude MCP Proxy
+ *
+ * Thin MCP proxy that connects to the singleton daemon via Unix socket.
+ * This is what Claude Code spawns for each session.
+ *
+ * Auto-starts the daemon if it's not running.
+ */
+
+import * as net from 'net';
+import { spawn } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import {
+  DAEMON_SOCKET_PATH,
+  DAEMON_PID_FILE,
+  serializeMessage,
+  parseMessages,
+  generateSessionId,
+  generateRequestId,
+  type ProxyMessage,
+  type DaemonMessage,
+  type ProxyConnectMessage,
+  type ProxyDisconnectMessage,
+  type ProxyToolCallMessage,
+} from '../shared/protocol.js';
+
+const VERSION = '2.0.0';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+interface ProxyConfig {
+  sessionName: string;
+  projectPath?: string;
+}
+
+function loadConfig(): ProxyConfig {
+  // Session name from env or derive from CWD
+  let sessionName = process.env.SESSION_NAME;
+
+  if (!sessionName) {
+    const cwd = process.cwd();
+    const projectName = cwd.split('/').pop() || 'unknown';
+    sessionName = `default:${projectName}`;
+  }
+
+  return {
+    sessionName,
+    projectPath: process.cwd(),
+  };
+}
+
+/**
+ * Check if the daemon is running
+ */
+function isDaemonRunning(): boolean {
+  if (!existsSync(DAEMON_PID_FILE)) {
+    return false;
+  }
+
+  try {
+    const pid = parseInt(readFileSync(DAEMON_PID_FILE, 'utf-8').trim(), 10);
+    process.kill(pid, 0); // Check if process exists
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start the daemon process
+ */
+async function startDaemon(): Promise<void> {
+  console.error('[Proxy] Daemon not running, starting it...');
+
+  // Find daemon script - check multiple locations
+  const possiblePaths = [
+    join(__dirname, '..', 'daemon', 'index.ts'),           // src/proxy -> src/daemon (dev)
+    join(__dirname, '..', '..', 'src', 'daemon', 'index.ts'), // dist/proxy -> src/daemon
+    join(__dirname, '..', '..', 'daemon', 'index.js'),     // dist/proxy -> dist/daemon (built)
+  ];
+
+  let daemonScript: string | null = null;
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      daemonScript = p;
+      break;
+    }
+  }
+
+  if (!daemonScript) {
+    throw new Error('Daemon script not found. Please start daemon manually: telegram-claude-ctl start');
+  }
+
+  // Determine runner based on file extension
+  const isTypeScript = daemonScript.endsWith('.ts');
+  const runner = isTypeScript ? 'node' : 'node';
+  const args = isTypeScript ? ['--import', 'tsx', daemonScript] : [daemonScript];
+
+  // Spawn daemon as detached process
+  const child = spawn(runner, args, {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore'],
+    env: process.env,
+  });
+
+  child.unref();
+
+  // Wait for daemon to be ready (socket to exist)
+  const maxWait = 10000; // 10 seconds
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < maxWait) {
+    await new Promise((r) => setTimeout(r, 200));
+
+    if (existsSync(DAEMON_SOCKET_PATH)) {
+      console.error('[Proxy] Daemon started successfully');
+      return;
+    }
+  }
+
+  throw new Error('Daemon failed to start within timeout');
+}
+
+/**
+ * Ensure daemon is running, start if needed
+ */
+async function ensureDaemon(): Promise<void> {
+  if (isDaemonRunning() && existsSync(DAEMON_SOCKET_PATH)) {
+    return;
+  }
+
+  // Check if we have required env vars to start daemon
+  if (!process.env.TELEGRAM_BOT_TOKEN || !process.env.TELEGRAM_CHAT_ID) {
+    throw new Error(
+      'Daemon not running and cannot auto-start: TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID required.\n' +
+      'Either start daemon manually (telegram-claude-ctl start) or provide env vars.'
+    );
+  }
+
+  await startDaemon();
+}
+
+class DaemonClient {
+  private socket: net.Socket | null = null;
+  private buffer = '';
+  private sessionId: string;
+  private sessionName: string;
+  private projectPath?: string;
+  private connected = false;
+  private pendingRequests = new Map<
+    string,
+    { resolve: (result: any) => void; reject: (error: Error) => void }
+  >();
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 5;
+
+  constructor(config: ProxyConfig) {
+    this.sessionId = generateSessionId();
+    this.sessionName = config.sessionName;
+    this.projectPath = config.projectPath;
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.socket = net.createConnection(DAEMON_SOCKET_PATH);
+
+      this.socket.on('connect', () => {
+        console.error(`[Proxy] Connected to daemon`);
+        this.reconnectAttempts = 0;
+
+        // Send connect message
+        const msg: ProxyConnectMessage = {
+          type: 'connect',
+          sessionId: this.sessionId,
+          sessionName: this.sessionName,
+          projectPath: this.projectPath,
+        };
+        this.socket!.write(serializeMessage(msg));
+      });
+
+      this.socket.on('data', (data) => {
+        this.buffer += data.toString();
+        const { messages, remainder } = parseMessages<DaemonMessage>(this.buffer);
+        this.buffer = remainder;
+
+        for (const msg of messages) {
+          this.handleDaemonMessage(msg, resolve, reject);
+        }
+      });
+
+      this.socket.on('close', () => {
+        console.error('[Proxy] Disconnected from daemon');
+        this.connected = false;
+
+        // Reject all pending requests
+        for (const [, pending] of this.pendingRequests) {
+          pending.reject(new Error('Disconnected from daemon'));
+        }
+        this.pendingRequests.clear();
+      });
+
+      this.socket.on('error', (err) => {
+        console.error('[Proxy] Socket error:', err.message);
+        if (!this.connected) {
+          reject(new Error(`Failed to connect to daemon: ${err.message}. Is the daemon running?`));
+        }
+      });
+    });
+  }
+
+  private handleDaemonMessage(
+    msg: DaemonMessage,
+    connectResolve?: (value: void) => void,
+    connectReject?: (error: Error) => void
+  ): void {
+    console.error(`[Proxy] Received: ${msg.type}`);
+
+    switch (msg.type) {
+      case 'connected':
+        this.connected = true;
+        console.error(`[Proxy] Session registered: ${msg.sessionId}`);
+        console.error(`[Proxy] Daemon version: ${msg.daemonVersion}`);
+        connectResolve?.();
+        break;
+
+      case 'tool_result': {
+        const pending = this.pendingRequests.get(msg.requestId);
+        if (pending) {
+          this.pendingRequests.delete(msg.requestId);
+          if (msg.success) {
+            pending.resolve(msg.result);
+          } else {
+            pending.reject(new Error(msg.error || 'Tool call failed'));
+          }
+        }
+        break;
+      }
+
+      case 'error':
+        if (msg.requestId) {
+          const pending = this.pendingRequests.get(msg.requestId);
+          if (pending) {
+            this.pendingRequests.delete(msg.requestId);
+            pending.reject(new Error(msg.error));
+          }
+        } else {
+          console.error(`[Proxy] Daemon error: ${msg.error}`);
+        }
+        break;
+
+      case 'pong':
+        console.error(`[Proxy] Daemon alive, ${msg.activeSessions} active sessions`);
+        break;
+    }
+  }
+
+  async callTool(
+    tool: string,
+    args: Record<string, unknown>
+  ): Promise<{ content: Array<{ type: string; text: string }>; isError?: boolean }> {
+    if (!this.connected || !this.socket) {
+      throw new Error('Not connected to daemon');
+    }
+
+    const requestId = generateRequestId();
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(requestId, { resolve, reject });
+
+      const msg: ProxyToolCallMessage = {
+        type: 'tool_call',
+        sessionId: this.sessionId,
+        requestId,
+        tool,
+        arguments: args,
+      };
+
+      this.socket!.write(serializeMessage(msg));
+    });
+  }
+
+  disconnect(): void {
+    if (this.socket && this.connected) {
+      const msg: ProxyDisconnectMessage = {
+        type: 'disconnect',
+        sessionId: this.sessionId,
+      };
+      this.socket.write(serializeMessage(msg));
+      this.socket.end();
+    }
+  }
+}
+
+async function main() {
+  const config = loadConfig();
+
+  console.error('');
+  console.error('Telegram Claude MCP Proxy v' + VERSION);
+  console.error(`Session: ${config.sessionName}`);
+  console.error('');
+
+  // Ensure daemon is running (auto-start if possible)
+  try {
+    await ensureDaemon();
+  } catch (error) {
+    console.error('[Proxy] ' + (error as Error).message);
+    process.exit(1);
+  }
+
+  // Connect to daemon
+  const client = new DaemonClient(config);
+
+  try {
+    await client.connect();
+  } catch (error) {
+    console.error('[Proxy] Failed to connect to daemon:', (error as Error).message);
+    process.exit(1);
+  }
+
+  // Create MCP server
+  const mcpServer = new Server(
+    { name: 'telegram-claude-proxy', version: VERSION },
+    { capabilities: { tools: {} } }
+  );
+
+  // List available tools (same as before)
+  mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: 'send_message',
+          description:
+            'Send a message to the user via Telegram and wait for their response. Use when you need user input, want to report completed work, or need discussion.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              message: {
+                type: 'string',
+                description: 'What you want to say to the user. Be clear and concise.',
+              },
+            },
+            required: ['message'],
+          },
+        },
+        {
+          name: 'continue_chat',
+          description: 'Continue an active chat with a follow-up message and wait for response.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              chat_id: { type: 'string', description: 'The chat ID from send_message' },
+              message: { type: 'string', description: 'Your follow-up message' },
+            },
+            required: ['chat_id', 'message'],
+          },
+        },
+        {
+          name: 'notify_user',
+          description:
+            'Send a notification to the user without waiting for a response. Use for status updates or acknowledgments.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              chat_id: { type: 'string', description: 'The chat ID from send_message' },
+              message: { type: 'string', description: 'The notification message' },
+            },
+            required: ['chat_id', 'message'],
+          },
+        },
+        {
+          name: 'end_chat',
+          description: 'End an active chat session with an optional closing message.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              chat_id: { type: 'string', description: 'The chat ID from send_message' },
+              message: { type: 'string', description: 'Optional closing message' },
+            },
+            required: ['chat_id'],
+          },
+        },
+      ],
+    };
+  });
+
+  // Handle tool calls by forwarding to daemon
+  mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+      const result = await client.callTool(name, args as Record<string, unknown>);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+        isError: true,
+      };
+    }
+  });
+
+  // Connect MCP server via stdio
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+
+  console.error('[Proxy] MCP server ready');
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.error('\n[Proxy] Shutting down...');
+    client.disconnect();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/shared/protocol.ts

@@ -0,0 +1,146 @@
+/**
+ * Shared protocol definitions for daemon <-> proxy communication
+ */
+
+// Socket path for IPC
+export const DAEMON_SOCKET_PATH = '/tmp/telegram-claude-daemon.sock';
+export const DAEMON_PID_FILE = '/tmp/telegram-claude-daemon.pid';
+export const DAEMON_HTTP_PORT = 3333;
+
+/**
+ * Message types from proxy to daemon
+ */
+export type ProxyMessageType = 'connect' | 'disconnect' | 'tool_call' | 'ping';
+
+export interface ProxyConnectMessage {
+  type: 'connect';
+  sessionId: string;
+  sessionName: string;
+  projectPath?: string;
+}
+
+export interface ProxyDisconnectMessage {
+  type: 'disconnect';
+  sessionId: string;
+}
+
+export interface ProxyToolCallMessage {
+  type: 'tool_call';
+  sessionId: string;
+  requestId: string;
+  tool: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface ProxyPingMessage {
+  type: 'ping';
+  sessionId: string;
+}
+
+export type ProxyMessage =
+  | ProxyConnectMessage
+  | ProxyDisconnectMessage
+  | ProxyToolCallMessage
+  | ProxyPingMessage;
+
+/**
+ * Message types from daemon to proxy
+ */
+export type DaemonMessageType = 'connected' | 'disconnected' | 'tool_result' | 'error' | 'pong';
+
+export interface DaemonConnectedMessage {
+  type: 'connected';
+  sessionId: string;
+  daemonVersion: string;
+}
+
+export interface DaemonDisconnectedMessage {
+  type: 'disconnected';
+  sessionId: string;
+}
+
+export interface DaemonToolResultMessage {
+  type: 'tool_result';
+  sessionId: string;
+  requestId: string;
+  success: boolean;
+  result?: {
+    content: Array<{ type: string; text: string }>;
+    isError?: boolean;
+  };
+  error?: string;
+}
+
+export interface DaemonErrorMessage {
+  type: 'error';
+  sessionId: string;
+  requestId?: string;
+  error: string;
+}
+
+export interface DaemonPongMessage {
+  type: 'pong';
+  sessionId: string;
+  activeSessions: number;
+}
+
+export type DaemonMessage =
+  | DaemonConnectedMessage
+  | DaemonDisconnectedMessage
+  | DaemonToolResultMessage
+  | DaemonErrorMessage
+  | DaemonPongMessage;
+
+/**
+ * Session state tracked by daemon
+ */
+export interface SessionInfo {
+  sessionId: string;
+  sessionName: string;
+  projectPath?: string;
+  connectedAt: Date;
+  lastActivity: Date;
+  activeChats: Set<string>;
+}
+
+/**
+ * Serialize message for IPC (newline-delimited JSON)
+ */
+export function serializeMessage(msg: ProxyMessage | DaemonMessage): string {
+  return JSON.stringify(msg) + '\n';
+}
+
+/**
+ * Parse messages from buffer (handles partial reads)
+ */
+export function parseMessages<T>(buffer: string): { messages: T[]; remainder: string } {
+  const lines = buffer.split('\n');
+  const remainder = lines.pop() || ''; // Last element might be incomplete
+  const messages: T[] = [];
+
+  for (const line of lines) {
+    if (line.trim()) {
+      try {
+        messages.push(JSON.parse(line) as T);
+      } catch {
+        console.error('[Protocol] Failed to parse message:', line);
+      }
+    }
+  }
+
+  return { messages, remainder };
+}
+
+/**
+ * Generate unique session ID
+ */
+export function generateSessionId(): string {
+  return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Generate unique request ID for tool calls
+ */
+export function generateRequestId(): string {
+  return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}