@ebowwa/channel-telegram 1.12.5 → 1.13.0

package/src/index.ts

@@ -1,357 +1,241 @@
 /**
- * GLM Daemon Telegram Bot
+ * @ebowwa/channel-telegram
  *
- * Full-featured Telegram bot with GLM-4.7 AI, git status, Doppler integration
+ * Telegram channel adapter implementing ChannelConnector.
  *
- * Features:
- * - GLM-4.7 AI responses via Z.AI API
- * - 429 rate limit handling with exponential backoff
- * - /git command for git status + GitHub auth
- * - /doppler command for Doppler secrets status
- * - Rolling API key support
+ * This package handles:
+ * - Telegram protocol operations (polling, message delivery)
+ * - Built-in commands (/start, /help, /status, etc.)
+ * - Typing indicators, message chunking, access control
+ * - Message normalization to ChannelMessage format
+ *
+ * Intelligence (GLM, tools, memory) can be provided by:
+ * 1. This package (standalone mode with built-in tools)
+ * 2. External daemon/consumer (adapter mode via onMessage handler)
  */
 
-import TelegramBot from 'node-telegram-bot-api';
-import { execSync } from 'child_process';
-import { getStore, seedPrompts } from '@ebowwa/structured-prompts';
-import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'fs';
-
-import { ConversationMemory } from './conversation-memory';
-import { getZAIKey } from './api/keys';
-import { fetchWithRetry } from './api/fetch-retry';
-import { registerAllCommands, isQuiet } from './commands';
-import { MCPClient } from './mcp';
-
-const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN || '';
-const TELEGRAM_TEST_CHAT_ID = process.env.TELEGRAM_TEST_CHAT_ID || '';
-
-// MCP Client instance (initialized on startup)
-let mcpClient: MCPClient | null = null;
-
-// ====================================================================
-// Tool Definitions for LLM
-// ====================================================================
+import TelegramBot from "node-telegram-bot-api";
+
+import {
+  type ChannelId,
+  type ChannelMessage,
+  type ChannelResponse,
+  type ChannelCapabilities,
+  type MessageSender,
+  type MessageContext,
+  type MessageHandler,
+  createChannelId,
+} from "@ebowwa/channel-types";
+
+import { ConversationMemory } from "./conversation-memory.js";
+import { registerAllCommands, isQuiet } from "./commands/index.js";
+import type { Tool } from "./types.js";
+
+// Re-export for external use
+export { ConversationMemory } from "./conversation-memory.js";
+export { registerAllCommands, isQuiet } from "./commands/index.js";
+export type { Tool } from "./types.js";
+
+// ============================================================
+// CONFIG
+// ============================================================
+
+export interface TelegramConfig {
+  botToken: string;
+  testChatId?: string;
+  allowedUsers?: number[];
+  allowedChats?: number[];
+  /** Optional tools for command handlers (e.g., /tools command) */
+  tools?: Tool[];
+  /** Optional conversations file path */
+  conversationsFile?: string;
+}
 
-export interface Tool {
-  name: string;
-  description: string;
-  parameters: Record<string, unknown>;
-  handler: (args: Record<string, unknown>) => Promise<string>;
+export function createTelegramConfigFromEnv(): TelegramConfig {
+  const allowedUsers = process.env.TELEGRAM_ALLOWED_USERS
+    ?.split(",")
+    .map((s) => parseInt(s.trim(), 10))
+    .filter((n) => !isNaN(n));
+
+  const allowedChats = process.env.TELEGRAM_ALLOWED_CHATS
+    ?.split(",")
+    .map((s) => parseInt(s.trim(), 10))
+    .filter((n) => !isNaN(n));
+
+  return {
+    botToken: process.env.TELEGRAM_BOT_TOKEN || "",
+    testChatId: process.env.TELEGRAM_TEST_CHAT_ID,
+    allowedUsers,
+    allowedChats,
+    conversationsFile: process.env.CONVERSATIONS_FILE,
+  };
 }
 
-const TOOLS: Tool[] = [
-  {
-    name: 'read_file',
-    description: 'Read a file from the filesystem. Use for checking configs, logs, code.',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: 'Absolute file path to read' }
-      },
-      required: ['path']
-    },
-    handler: async (args) => {
-      const path = args.path as string;
-      try {
-        if (!existsSync(path)) return `File not found: ${path}`;
-        const content = readFileSync(path, 'utf-8');
-        return content.length > 4000 ? content.slice(0, 4000) + '\n...[truncated]' : content;
-      } catch (e) {
-        return `Error reading file: ${(e as Error).message}`;
-      }
-    }
-  },
-  {
-    name: 'write_file',
-    description: 'Write content to a file. Creates the file if it does not exist, overwrites if it does.',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: 'Absolute file path to write' },
-        content: { type: 'string', description: 'Content to write to the file' }
-      },
-      required: ['path', 'content']
-    },
-    handler: async (args) => {
-      const path = args.path as string;
-      const content = args.content as string;
-      try {
-        writeFileSync(path, content, 'utf-8');
-        return `Successfully wrote ${content.length} bytes to ${path}`;
-      } catch (e) {
-        return `Error writing file: ${(e as Error).message}`;
-      }
-    }
-  },
-  {
-    name: 'edit_file',
-    description: 'Edit a file by replacing a specific string with new content.',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: 'Absolute file path to edit' },
-        old_string: { type: 'string', description: 'The exact text to find and replace' },
-        new_string: { type: 'string', description: 'The text to replace it with' }
-      },
-      required: ['path', 'old_string', 'new_string']
-    },
-    handler: async (args) => {
-      const path = args.path as string;
-      const oldStr = args.old_string as string;
-      const newStr = args.new_string as string;
-      try {
-        if (!existsSync(path)) return `File not found: ${path}`;
-        const content = readFileSync(path, 'utf-8');
-        if (!content.includes(oldStr)) {
-          return `String not found in file. First 500 chars:\n${content.slice(0, 500)}`;
-        }
-        const newContent = content.replace(oldStr, newStr);
-        writeFileSync(path, newContent, 'utf-8');
-        return `Successfully edited ${path}`;
-      } catch (e) {
-        return `Error editing file: ${(e as Error).message}`;
-      }
-    }
-  },
-  {
-    name: 'append_file',
-    description: 'Append content to the end of a file. Creates the file if it does not exist.',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: 'Absolute file path to append to' },
-        content: { type: 'string', description: 'Content to append to the file' }
-      },
-      required: ['path', 'content']
-    },
-    handler: async (args) => {
-      const path = args.path as string;
-      const content = args.content as string;
-      try {
-        appendFileSync(path, content, 'utf-8');
-        return `Successfully appended ${content.length} bytes to ${path}`;
-      } catch (e) {
-        return `Error appending to file: ${(e as Error).message}`;
-      }
-    }
-  },
-  {
-    name: 'list_dir',
-    description: 'List contents of a directory. Shows files and subdirectories.',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: 'Directory path to list (default: current working directory)' }
-      }
-    },
-    handler: async (args) => {
-      const path = (args.path as string) || process.cwd();
-      try {
-        const items = execSync(`ls -la "${path}" 2>&1`).toString();
-        return items;
-      } catch (e) {
-        return `Error listing directory: ${(e as Error).message}`;
-      }
-    }
-  },
-  {
-    name: 'run_command',
-    description: 'Execute a shell command. Use for git, system info, etc. BE CAREFUL with destructive commands.',
-    parameters: {
-      type: 'object',
-      properties: {
-        command: { type: 'string', description: 'Shell command to execute' },
-        cwd: { type: 'string', description: 'Working directory (optional)' }
-      },
-      required: ['command']
+// ============================================================
+// TELEGRAM CHANNEL
+// ============================================================
+
+export class TelegramChannel {
+  readonly id: ChannelId;
+  readonly label = "Telegram";
+  readonly capabilities: ChannelCapabilities = {
+    supports: {
+      text: true,
+      media: true,
+      replies: true,
+      threads: false,
+      reactions: true,
+      editing: true,
+      streaming: false,
     },
-    handler: async (args) => {
-      const cmd = args.command as string;
-      const cwd = (args.cwd as string) || process.cwd();
-      // Safety check - block dangerous commands
-      const blocked = ['rm -rf', 'mkfs', 'dd if=', '> /dev/', 'chmod 777'];
-      if (blocked.some(b => cmd.includes(b))) {
-        return `Blocked: command contains dangerous pattern`;
-      }
-      try {
-        const result = execSync(cmd, { timeout: 10000, cwd }).toString();
-        return result || '(no output)';
-      } catch (e: any) {
-        return e.stdout?.toString() || e.message;
-      }
-    }
-  },
-  {
-    name: 'git_status',
-    description: 'Check git repository status',
-    parameters: {
-      type: 'object',
-      properties: {
-        cwd: { type: 'string', description: 'Repository path (optional)' }
-      }
+    media: {
+      maxFileSize: 50 * 1024 * 1024, // 50MB
+      supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/pdf"],
     },
-    handler: async (args) => {
-      const cwd = (args.cwd as string) || process.cwd();
-      try {
-        const status = execSync('git status 2>&1', { cwd }).toString();
-        const branch = execSync('git branch --show-current 2>&1', { cwd }).toString();
-        return `Branch: ${branch}\n\n${status}`;
-      } catch (e) {
-        return `Error: ${(e as Error).message}`;
-      }
-    }
-  },
-  {
-    name: 'get_prompt',
-    description: 'Get a prompt template from the prompt store',
-    parameters: {
-      type: 'object',
-      properties: {
-        id: { type: 'string', description: 'Prompt ID to retrieve' }
-      },
-      required: ['id']
+    rateLimits: {
+      messagesPerMinute: 30,
+      charactersPerMessage: 4096,
     },
-    handler: async (args) => {
-      const store = getStore(process.env.PROMPTS_FILE);
-      const prompt = store.get(args.id as string);
-      return prompt ? JSON.stringify(prompt, null, 2) : `Prompt not found: ${args.id}`;
-    }
-  },
-  {
-    name: 'list_prompts',
-    description: 'List all available prompt templates',
-    parameters: { type: 'object', properties: {} },
-    handler: async () => {
-      const store = getStore(process.env.PROMPTS_FILE);
-      const prompts = store.list();
-      return prompts.map(p => `- ${p.id}: ${p.name}`).join('\n') || 'No prompts found';
-    }
-  },
-  {
-    name: 'system_info',
-    description: 'Get system resource info (CPU, memory, disk, uptime)',
-    parameters: { type: 'object', properties: {} },
-    handler: async () => {
-      try {
-        const cpu = execSync('nproc 2>/dev/null || echo "unknown"').toString().trim();
-        const mem = execSync('free -h 2>/dev/null | grep Mem || echo "unknown"').toString().trim();
-        const disk = execSync('df -h / 2>/dev/null | tail -1 || echo "unknown"').toString().trim();
-        const uptime = execSync('uptime -p 2>/dev/null || uptime 2>/dev/null || echo "unknown"').toString().trim();
-        return `CPU cores: ${cpu}\nMemory: ${mem}\nDisk: ${disk}\nUptime: ${uptime}`;
-      } catch (e) {
-        return `Error: ${(e as Error).message}`;
-      }
-    }
+  };
+
+  private bot: TelegramBot;
+  private config: TelegramConfig;
+  private memory: ConversationMemory;
+  private tools: Tool[];
+  private messageHandler?: MessageHandler;
+  private typingIntervals: Map<number, NodeJS.Timeout> = new Map();
+  private connected = false;
+
+  constructor(config: TelegramConfig) {
+    this.config = config;
+    this.id = createChannelId("telegram", "default");
+    this.bot = new TelegramBot(config.botToken, { polling: false });
+    this.memory = new ConversationMemory(config.conversationsFile);
+    this.tools = config.tools || [];
   }
-];
-
-// Get all tools (local + MCP) in GLM API format
-function getGLMTools(): Array<{ type: string; function: { name: string; description: string; parameters: Record<string, unknown> } }> {
-  const allTools = [...TOOLS.map(t => ({
-    type: 'function' as const,
-    function: {
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters
-    }
-  }))];
-
-  // Add MCP tools if connected
-  if (mcpClient) {
-    const mcpTools = mcpClient.getTools();
-    for (const tool of mcpTools) {
-      allTools.push({
-        type: 'function',
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema
-        }
-      });
+
+  // ============================================================
+  // ChannelConnector Implementation
+  // ============================================================
+
+  async start(): Promise<void> {
+    console.log("[TelegramChannel] Starting...");
+
+    // Start polling
+    this.bot = new TelegramBot(this.config.botToken, {
+      polling: {
+        interval: 300,
+        autoStart: true,
+        params: {
+          allowed_updates: ["message", "edited_message", "message_reaction", "callback_query"],
+        },
+      },
+    });
+
+    // Register built-in commands
+    registerAllCommands(this.bot, this.memory, this.tools);
+
+    // Setup message routing
+    this.setupMessageHandlers();
+
+    // Register Telegram commands menu
+    await this.registerCommands();
+
+    this.connected = true;
+    console.log("[TelegramChannel] Connected and polling");
+
+    // Send startup notification if configured
+    if (this.config.testChatId) {
+      await this.sendMessage(Number(this.config.testChatId), "Telegram channel adapter online");
     }
   }
 
-  return allTools;
-}
-
-// Convert tools to GLM API format (static fallback)
-const GLM_TOOLS = TOOLS.map(t => ({
-  type: 'function',
-  function: {
-    name: t.name,
-    description: t.description,
-    parameters: t.parameters
+  async stop(): Promise<void> {
+    console.log("[TelegramChannel] Stopping...");
+    await this.bot.stopPolling();
+    this.connected = false;
   }
-}));
-
-// Execute a tool by name (checks local tools first, then MCP)
-async function executeTool(name: string, args: Record<string, unknown>): Promise<string> {
-  // Check local tools first
-  const tool = TOOLS.find(t => t.name === name);
-  if (tool) {
-    return tool.handler(args);
+
+  /**
+   * Set the message handler. The daemon/consumer provides intelligence.
+   */
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
   }
 
-  // Check MCP tools
-  if (mcpClient) {
-    const mcpTools = mcpClient.getTools();
-    const mcpTool = mcpTools.find(t => t.name === name);
-    if (mcpTool) {
-      try {
-        return await mcpClient.callTool(name, args);
-      } catch (error) {
-        return `MCP tool error: ${(error as Error).message}`;
-      }
+  /**
+   * Send a response back to Telegram.
+   */
+  async send(response: ChannelResponse): Promise<void> {
+    const chatId = this.extractChatId(response.replyTo);
+    if (!chatId) {
+      console.error("[TelegramChannel] Cannot send: no chat ID");
+      return;
+    }
+
+    const options: TelegramBot.SendMessageOptions = {};
+    if (response.content.replyToOriginal) {
+      options.reply_to_message_id = parseInt(response.replyTo.messageId, 10);
     }
+    if (response.content.options?.parseMode) {
+      options.parse_mode = response.content.options.parseMode as "Markdown" | "HTML";
+    }
+
+    await this.sendLongMessage(chatId, response.content.text, options);
   }
 
-  return `Unknown tool: ${name}`;
-}
+  isConnected(): boolean {
+    return this.connected;
+  }
 
-const ZAI_API_ENDPOINT = 'https://api.z.ai/api/coding/paas/v4/chat/completions';
+  // ============================================================
+  // Public Helpers
+  // ============================================================
 
-export class TelegramGLMBot {
-  private bot: TelegramBot;
-  private memory: ConversationMemory;
-  private typingIntervals: Map<number, NodeJS.Timeout> = new Map();
+  /**
+   * Get the underlying TelegramBot instance for advanced operations.
+   */
+  getBot(): TelegramBot {
+    return this.bot;
+  }
 
-  constructor(token: string) {
-    // Enable polling with all required update types
-    this.bot = new TelegramBot(token, {
-      polling: {
-        interval: 300,
-        autoStart: true,
-        params: {
-          allowed_updates: ['message', 'edited_message', 'message_reaction', 'callback_query']
-        }
-      }
-    });
-    this.memory = new ConversationMemory(process.env.CONVERSATIONS_FILE);
+  /**
+   * Get the conversation memory.
+   */
+  getMemory(): ConversationMemory {
+    return this.memory;
   }
 
   /**
-   * Start periodic typing indicator for a chat
-   * Telegram typing indicator lasts ~5 seconds, so refresh every 3 seconds
+   * Send a simple text message.
    */
-  private startTypingIndicator(chatId: number): void {
-    // Clear any existing interval
-    this.stopTypingIndicator(chatId);
+  async sendMessage(chatId: number, text: string, options?: TelegramBot.SendMessageOptions): Promise<void> {
+    await this.bot.sendMessage(chatId, text, options);
+  }
 
-    // Send initial typing action
-    this.bot.sendChatAction(chatId, 'typing').catch(() => {});
+  /**
+   * Send typing indicator.
+   */
+  async sendTyping(chatId: number): Promise<void> {
+    await this.bot.sendChatAction(chatId, "typing");
+  }
 
-    // Set up periodic refresh every 3 seconds
+  /**
+   * Start continuous typing indicator (until response is ready).
+   */
+  startTypingIndicator(chatId: number): void {
+    this.stopTypingIndicator(chatId);
+    this.bot.sendChatAction(chatId, "typing").catch(() => {});
     const interval = setInterval(() => {
-      this.bot.sendChatAction(chatId, 'typing').catch(() => {});
+      this.bot.sendChatAction(chatId, "typing").catch(() => {});
     }, 3000);
-
     this.typingIntervals.set(chatId, interval);
   }
 
   /**
-   * Stop periodic typing indicator for a chat
+   * Stop typing indicator.
    */
-  private stopTypingIndicator(chatId: number): void {
+  stopTypingIndicator(chatId: number): void {
     const interval = this.typingIntervals.get(chatId);
     if (interval) {
       clearInterval(interval);
@@ -360,572 +244,280 @@ export class TelegramGLMBot {
   }
 
   /**
-   * Send message, splitting if too long for Telegram (4096 char limit)
+   * Check if user/chat is allowed.
    */
-  private async sendLongMessage(chatId: number, text: string): Promise<void> {
-    const MAX_LENGTH = 4000; // Leave buffer for safety
-
-    if (text.length <= MAX_LENGTH) {
-      await this.bot.sendMessage(chatId, text);
-      return;
+  isAllowed(userId?: number, chatId?: number): boolean {
+    if (!this.config.allowedUsers?.length && !this.config.allowedChats?.length) {
+      return true;
     }
 
-    // Split into chunks at word boundaries when possible
-    const chunks: string[] = [];
-    let remaining = text;
-
-    while (remaining.length > 0) {
-      if (remaining.length <= MAX_LENGTH) {
-        chunks.push(remaining);
-        break;
-      }
-
-      // Try to find a good break point (newline or space)
-      let breakPoint = remaining.lastIndexOf('\n', MAX_LENGTH);
-      if (breakPoint < 1000) {
-        breakPoint = remaining.lastIndexOf(' ', MAX_LENGTH);
-      }
-      if (breakPoint < 1000) {
-        breakPoint = MAX_LENGTH;
-      }
-
-      chunks.push(remaining.slice(0, breakPoint));
-      remaining = remaining.slice(breakPoint).trim();
+    if (this.config.allowedUsers?.length && userId) {
+      if (this.config.allowedUsers.includes(userId)) return true;
     }
 
-    // Send chunks with continuation indicator
-    for (let i = 0; i < chunks.length; i++) {
-      const prefix = chunks.length > 1 ? `[${i + 1}/${chunks.length}] ` : '';
-      await this.bot.sendMessage(chatId, prefix + chunks[i]);
+    if (this.config.allowedChats?.length && chatId) {
+      if (this.config.allowedChats.includes(chatId)) return true;
     }
-  }
-
-  async start(): Promise<void> {
-    console.log('🤖 GLM Daemon Telegram Bot starting with GLM-4.7...');
-
-    // Initialize MCP client for external tool access
-    mcpClient = new MCPClient();
-    try {
-      await mcpClient.connect();
-    } catch (error) {
-      console.error('[MCP] Failed to initialize MCP client:', error);
-      // Continue without MCP - local tools still work
-    }
-
-    // Register all commands from commands/ directory
-    registerAllCommands(this.bot, this.memory, TOOLS);
-
-    // Register commands with Telegram for autocomplete
-    await this.bot.setMyCommands([
-      { command: 'start', description: 'Start the bot' },
-      { command: 'help', description: 'Show available commands' },
-      { command: 'status', description: 'Check bot and API status' },
-      { command: 'git', description: 'Check git status and GitHub auth' },
-      { command: 'doppler', description: 'Check Doppler secrets status' },
-      { command: 'logs', description: 'View recent bot logs' },
-      { command: 'clear', description: 'Clear conversation history' },
-      { command: 'tools', description: 'List available tools' },
-      { command: 'cancel', description: 'Stop current task immediately' },
-      { command: 'pause', description: 'Pause execution' },
-      { command: 'resume', description: 'Resume after pause/cancel' },
-      { command: 'quiet', description: 'Hide tool logging' },
-      { command: 'verbose', description: 'Show tool logging' },
-    ]);
-
-    // Handle all text messages with GLM-4.7
-    this.bot.on('message', async (msg: TelegramBot.Message) => {
-      if (!msg.text) return;
-      if (msg.text.startsWith('/')) return;
-
-      const chatId = msg.chat.id;
-      const userName = msg.from?.first_name || msg.from?.username || 'User';
-      const messageId = msg.message_id;
-
-      // Check if this is a reply to another message
-      const replyContext = msg.reply_to_message ? {
-        isReply: true,
-        originalMessage: msg.reply_to_message.text || '[non-text message]',
-        originalFrom: msg.reply_to_message.from?.first_name || 'User',
-        originalMessageId: msg.reply_to_message.message_id
-      } : null;
-
-      if (replyContext) {
-        console.log(`[Telegram] ${userName} (replying to ${replyContext.originalFrom}): ${msg.text}`);
-      } else {
-        console.log(`[Telegram] ${userName}: ${msg.text}`);
-      }
 
-      // Build message with reply context if present
-      let messageWithContext = msg.text;
-      if (replyContext) {
-        messageWithContext = `[Replying to ${replyContext.originalFrom}'s message: "${replyContext.originalMessage.slice(0, 200)}${replyContext.originalMessage.length > 200 ? '...' : ''}"]\n\n${msg.text}`;
-      }
+    return false;
+  }
 
-      // Typing indicator is now handled by getGLMResponse with periodic refresh
-
-      // Get response with conversation history
-      const response = await this.getGLMResponse(chatId, messageWithContext, userName);
-
-      // Save to memory with message ID and reply context
-      this.memory.addWithReply(chatId, 'user', msg.text, {
-        messageId,
-        replyTo: replyContext ? {
-          messageId: replyContext.originalMessageId,
-          text: replyContext.originalMessage,
-          from: replyContext.originalFrom
-        } : undefined
-      });
-      this.memory.add(chatId, 'assistant', response);
-
-      // Send response - if replying, use reply_to_message_id for threading
-      if (replyContext) {
-        await this.bot.sendMessage(chatId, response, {
-          reply_to_message_id: messageId
-        });
-      } else {
-        await this.sendLongMessage(chatId, response);
+  // ============================================================
+  // Message Routing (Internal)
+  // ============================================================
+
+  private setupMessageHandlers(): void {
+    // Text messages (skip commands - handled by onText handlers)
+    this.bot.on("message", async (msg) => {
+      if (!msg.text || msg.text.startsWith("/")) return;
+      if (!this.isAllowed(msg.from?.id, msg.chat.id)) return;
+
+      const message = this.createChannelMessage(msg);
+      console.log(`[TelegramChannel] Message from ${message.sender.displayName}: ${message.text.slice(0, 50)}...`);
+
+      // Route to handler if set
+      if (this.messageHandler) {
+        try {
+          const response = await this.messageHandler(message);
+          if (response) {
+            await this.send(response);
+          }
+        } catch (error) {
+          console.error("[TelegramChannel] Handler error:", error);
+          await this.sendMessage(msg.chat.id, `Error: ${(error as Error).message}`);
+        }
       }
     });
 
-    // Polling errors
-    this.bot.on('polling_error', (error: Error) => {
-      console.error('[Telegram] Polling error:', error.message);
-    });
-
-    // ====================================================================
-    // Message Edit Handler
-    // ====================================================================
-    this.bot.on('edited_message', async (msg: TelegramBot.Message) => {
+    // Edited messages
+    this.bot.on("edited_message", async (msg) => {
       if (!msg.text) return;
+      if (!this.isAllowed(msg.from?.id, msg.chat.id)) return;
 
-      const chatId = msg.chat.id;
-      const userName = msg.from?.first_name || msg.from?.username || 'User';
-      const messageId = msg.message_id;
-      const editDate = msg.edit_date || Date.now();
-
-      console.log(`[Telegram] EDIT ${userName}: ${msg.text.slice(0, 50)}...`);
-
-      // Update the message in memory
-      const updated = this.memory.updateByMessageId(chatId, messageId, msg.text, editDate);
-
-      if (updated) {
-        // Message was found and updated - optionally re-process with AI
-        const response = await this.getGLMResponse(
-          chatId,
-          `[User edited their previous message to: "${msg.text}"]`,
-          userName
-        );
-        this.memory.add(chatId, 'assistant', response);
-        await this.sendLongMessage(chatId, `📝 *Edit noted:*\n\n${response}`);
-      } else {
-        // Message not in memory (too old or new) - just acknowledge
-        console.log(`[Telegram] Edit for unknown message ${messageId}`);
-      }
-    });
-
-    // ====================================================================
-    // Reaction Handler (Likes/Emojis)
-    // ====================================================================
-    // Note: message_reaction requires Telegram Bot API 5.0+
-    // The type definitions may not include this yet, so we use any
-    (this.bot as any).on('message_reaction', async (reaction: {
-      chat: { id: number };
-      message_id: number;
-      user: { id: number; first_name?: string };
-      old_reaction: Array<{ type: string; emoji?: string; custom_emoji_id?: string }>;
-      new_reaction: Array<{ type: string; emoji?: string; custom_emoji_id?: string }>;
-    }) => {
-      const chatId = reaction.chat.id;
-      const messageId = reaction.message_id;
-      const userId = reaction.user.id;
-      const userName = reaction.user.first_name || 'User';
-
-      // Extract emojis from reactions
-      const newEmojis = reaction.new_reaction
-        .filter(r => r.type === 'emoji' && r.emoji)
-        .map(r => r.emoji!);
-
-      const oldEmojis = reaction.old_reaction
-        .filter(r => r.type === 'emoji' && r.emoji)
-        .map(r => r.emoji!);
-
-      // Find added reactions
-      const added = newEmojis.filter(e => !oldEmojis.includes(e));
-      const removed = oldEmojis.filter(e => !newEmojis.includes(e));
-
-      console.log(`[Telegram] REACTION by ${userName}: +${added.join(',')} -${removed.join(',')} on msg ${messageId}`);
-
-      // Update memory for each added reaction
-      for (const emoji of added) {
-        this.memory.addReaction(chatId, messageId, emoji, userId);
-      }
-
-      // Update memory for each removed reaction
-      for (const emoji of removed) {
-        this.memory.removeReaction(chatId, messageId, emoji, userId);
-      }
+      const message = this.createChannelMessage(msg);
+      // Mark as edited in text
+      (message as any).text = `[Edited] ${msg.text}`;
 
-      // Optionally respond to specific reactions
-      if (added.includes('👍') || added.includes('❤️')) {
-        // Positive feedback - could track for learning
-        console.log(`[Telegram] Positive feedback received on message ${messageId}`);
+      if (this.messageHandler) {
+        try {
+          const response = await this.messageHandler(message);
+          if (response) {
+            await this.send(response);
+          }
+        } catch (error) {
+          console.error("[TelegramChannel] Handler error:", error);
+        }
       }
+    });
 
-      if (added.includes('👎')) {
-        // Negative feedback - could ask for clarification
-        await this.bot.sendMessage(chatId, `Thanks for the feedback, ${userName}. I'll try to do better!`);
+    // Reactions
+    (this.bot as any).on("message_reaction", async (reaction: any) => {
+      const message = {
+        messageId: reaction.message_id?.toString(),
+        channelId: this.id,
+        timestamp: new Date(),
+        sender: {
+          id: reaction.user?.id?.toString(),
+          displayName: reaction.user?.first_name || "User",
+        },
+        text: "",
+        context: { isDM: reaction.chat?.type === "private" },
+        metadata: { type: "reaction", reaction: reaction.new_reaction },
+      };
+
+      if (this.messageHandler) {
+        await this.messageHandler(message as any);
       }
     });
 
-    // ====================================================================
-    // Callback Query Handler (Inline Button Reactions)
-    // ====================================================================
-    this.bot.on('callback_query', async (query: TelegramBot.CallbackQuery) => {
+    // Callback queries (button clicks)
+    this.bot.on("callback_query", async (query) => {
       const chatId = query.message?.chat.id;
-      const messageId = query.message?.message_id;
-      const data = query.data;
-      const userName = query.from.first_name || 'User';
-
-      if (!chatId || !data) {
+      if (!chatId || !query.data) {
         await this.bot.answerCallbackQuery(query.id);
         return;
       }
 
-      console.log(`[Telegram] CALLBACK ${userName}: ${data}`);
-
-      // Parse callback data (format: "action:value")
-      const [action, value] = data.split(':');
-
-      switch (action) {
-        case 'react': {
-          // Toggle reaction via inline button
-          const count = parseInt(value) || 0;
-          const newCount = count + 1;
-          await this.bot.editMessageReplyMarkup(
-            {
-              inline_keyboard: [[
-                { text: `👍 ${newCount}`, callback_data: `react:${newCount}` }
-              ]]
-            },
-            { chat_id: chatId, message_id: messageId }
-          );
-          break;
-        }
-
-        case 'approve': {
-          // Approval action (useful for workflows)
-          await this.bot.sendMessage(chatId, `✅ Approved by ${userName}`);
-          // Could trigger follow-up actions here
-          break;
-        }
-
-        case 'reject': {
-          // Rejection action
-          await this.bot.sendMessage(chatId, `❌ Rejected by ${userName}`);
-          break;
-        }
-
-        case 'cancel': {
-          // Cancel current task
-          await this.bot.sendMessage(chatId, `🛑 Task cancelled by ${userName}`);
-          break;
-        }
-
-        default: {
-          // Unknown callback - let AI handle it
-          const response = await this.getGLMResponse(
-            chatId,
-            `[User clicked button: "${data}". Respond appropriately.]`,
-            userName
-          );
-          await this.bot.sendMessage(chatId, response);
+      const message = {
+        messageId: query.id,
+        channelId: this.id,
+        timestamp: new Date(),
+        sender: {
+          id: query.from?.id?.toString(),
+          displayName: query.from?.first_name || "User",
+        },
+        text: query.data,
+        context: { isDM: query.message?.chat.type === "private" },
+        metadata: { type: "callback" },
+      };
+
+      if (this.messageHandler) {
+        try {
+          const response = await this.messageHandler(message as any);
+          if (response) {
+            await this.send(response);
+          }
+        } catch (error) {
+          console.error("[TelegramChannel] Callback handler error:", error);
         }
       }
 
-      // Always acknowledge the callback to remove loading state
       await this.bot.answerCallbackQuery(query.id);
     });
 
-    console.log('✅ Telegram bot is running with GLM-4.7!');
+    // Polling errors
+    this.bot.on("polling_error", (error) => {
+      console.error("[TelegramChannel] Polling error:", error.message);
+    });
+  }
 
-    if (TELEGRAM_TEST_CHAT_ID) {
-      await this.sendTestMessage(Number(TELEGRAM_TEST_CHAT_ID));
-      // Check for crash and report
-      await this.checkCrashAndReport(Number(TELEGRAM_TEST_CHAT_ID));
-    } else {
-      console.log('\n💡 Tip: Get your chat ID from @userinfobot and set TELEGRAM_TEST_CHAT_ID');
-    }
+  /**
+   * Register Telegram command menu
+   */
+  private async registerCommands(): Promise<void> {
+    await this.bot.setMyCommands([
+      { command: "start", description: "Start the bot" },
+      { command: "help", description: "Show available commands" },
+      { command: "status", description: "Check bot status" },
+      { command: "git", description: "Check git status" },
+      { command: "doppler", description: "Check Doppler secrets" },
+      { command: "logs", description: "View recent logs" },
+      { command: "clear", description: "Clear conversation history" },
+      { command: "tools", description: "List available tools" },
+      { command: "restart", description: "Restart the bot service" },
+      { command: "cancel", description: "Stop current task" },
+      { command: "quiet", description: "Hide tool logging" },
+      { command: "verbose", description: "Show tool logging" },
+    ]);
   }
 
-  async getGLMResponse(chatId: number, userMessage: string, userName: string): Promise<string> {
-    const apiKey = getZAIKey();
-    if (!apiKey) {
-      return '⚠️ Z_AI_API_KEY not configured in Doppler secrets.\n\nPlease set Z_AI_API_KEY to use GLM-4.7.';
+  /**
+   * Normalize Telegram message to ChannelMessage format.
+   */
+  private createChannelMessage(msg: TelegramBot.Message): ChannelMessage {
+    const sender: MessageSender = {
+      id: msg.from?.id?.toString() || msg.chat.id.toString(),
+      username: msg.from?.username,
+      displayName: msg.from?.first_name || msg.from?.username || "User",
+      isBot: msg.from?.is_bot || false,
+    };
+
+    const context: MessageContext = {
+      isDM: msg.chat.type === "private",
+      groupName: msg.chat.type !== "private" ? msg.chat.title : undefined,
+    };
+
+    // Build reply context
+    let replyText: string | undefined;
+    if (msg.reply_to_message?.text) {
+      const replyFrom = msg.reply_to_message.from?.first_name || "User";
+      replyText = `[Replying to ${replyFrom}: "${msg.reply_to_message.text.slice(0, 100)}"]`;
     }
 
-    // Start typing indicator - will refresh every 3 seconds during processing
-    this.startTypingIndicator(chatId);
-
-    // Get system prompt from structured-prompts store
-    const store = getStore(process.env.PROMPTS_FILE);
-    const systemPrompt = store.get('glm-daemon-system');
-    const systemContent = systemPrompt?.template ?? 'You are GLM Daemon, a helpful AI assistant.';
-    const temperature = systemPrompt?.metadata?.temperature ?? 0.7;
-    const maxTokens = systemPrompt?.metadata?.maxTokens ?? 2048;
-
-    // Build messages with conversation history
-    const history = this.memory.get(chatId);
-    const messages: Array<{ role: string; content?: string; tool_calls?: unknown[]; name?: string }> = [
-      { role: 'system', content: systemContent },
-      ...history,
-      { role: 'user', content: userMessage }
-    ];
-
-    try {
-      console.log(`🔄 Calling GLM-4.7 API for: ${userMessage} (${history.length} history)`);
-
-      // Loop to handle tool calls
-      let iterations = 0;
-      const maxIterations = 50; // Allow more tool calls for complex tasks
-
-      while (iterations < maxIterations) {
-        iterations++;
-
-        const response = await fetchWithRetry(ZAI_API_ENDPOINT, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${apiKey}`
-          },
-          body: JSON.stringify({
-            model: 'glm-4.7',
-            messages,
-            tools: getGLMTools(),
-            temperature,
-            max_tokens: maxTokens
-          })
-        }, 3, 1000);
-
-        const data = await response.json() as {
-          choices?: Array<{
-            message?: {
-              content?: string;
-              tool_calls?: Array<{
-                id: string;
-                function: { name: string; arguments: string };
-              }>;
-            }
-          }>
-        };
-
-        const message = data.choices?.[0]?.message;
-        if (!message) {
-          console.error('❌ Unexpected API response format:', data);
-          return '❌ Unexpected response from AI API.';
-        }
-
-        // Check if LLM wants to call tools
-        if (message.tool_calls && message.tool_calls.length > 0) {
-          console.log(`🔧 LLM calling ${message.tool_calls.length} tool(s)`);
-
-          // Add assistant message with tool calls to history
-          messages.push({
-            role: 'assistant',
-            tool_calls: message.tool_calls
-          });
-
-          // Check quiet mode for Telegram messages
-          const quiet = isQuiet();
-
-          // Execute each tool and add results
-          for (const toolCall of message.tool_calls) {
-            const toolName = toolCall.function.name;
-            const args = JSON.parse(toolCall.function.arguments);
-
-            console.log(`  → ${toolName}(${JSON.stringify(args)})`);
-
-            // Send tool call notification to Telegram (skip if quiet)
-            if (!quiet) {
-              // Sanitize to prevent entity parsing errors - strip Markdown special chars
-              const sanitizeForTelegram = (str: string): string => {
-                return str
-                  .replace(/[_*[\]()~`>#+=|{}.!-]/g, '') // Remove Markdown special chars
-                  .replace(/\\/g, '') // Remove backslashes
-                  .slice(0, 100); // Truncate to prevent long messages
-              };
-              const argsPreview = Object.keys(args).length > 0
-                ? sanitizeForTelegram(JSON.stringify(args))
-                : '';
-              await this.bot.sendMessage(chatId, `🔧 ${toolName}${argsPreview ? ' ' + argsPreview : ''}`);
-            }
-
-            // Execute tool locally
-            const result = await executeTool(toolName, args);
-
-            console.log(`  ← ${result.slice(0, 100)}...`);
-
-            // Send result to Telegram (skip if quiet)
-            if (!quiet) {
-              const sanitizedResult = result
-                .replace(/[_*[\]()~`>#+=|{}.!-]/g, '')
-                .replace(/\\/g, '');
-              const resultPreview = sanitizedResult.length > 500 ? sanitizedResult.slice(0, 500) + ' [truncated]' : sanitizedResult;
-              await this.bot.sendMessage(chatId, `📥 ${resultPreview}`);
-            }
-
-            // Add tool result to messages
-            messages.push({
-              role: 'tool',
-              name: toolName,
-              content: result
-            });
+    return {
+      messageId: msg.message_id.toString(),
+      channelId: this.id,
+      timestamp: new Date(msg.date * 1000),
+      sender,
+      text: replyText ? `${replyText}\n\n${msg.text || ""}` : (msg.text || ""),
+      context,
+      replyTo: msg.reply_to_message
+        ? {
+            messageId: msg.reply_to_message.message_id.toString(),
+            channelId: this.id,
           }
+        : undefined,
+    };
+  }
 
-          // Continue loop to get final response
-          continue;
-        }
+  private extractChatId(replyTo: { messageId: string; channelId: ChannelId }): number | null {
+    const accountId = replyTo.channelId.accountId;
+    const parsed = parseInt(accountId, 10);
+    if (!isNaN(parsed)) return parsed;
+    return null;
+  }
 
-        // No tool calls - we have the final response
-        if (message.content) {
-          console.log(`✅ GLM-4.7 response: ${message.content.slice(0, 100)}...`);
-          return message.content;
-        }
+  /**
+   * Send long message by splitting into chunks.
+   */
+  private async sendLongMessage(
+    chatId: number,
+    text: string,
+    options?: TelegramBot.SendMessageOptions
+  ): Promise<void> {
+    const MAX_LENGTH = 4000;
 
-        // No content and no tool calls - something weird
-        return '❌ Empty response from AI.';
-      }
+    if (text.length <= MAX_LENGTH) {
+      await this.bot.sendMessage(chatId, text, options);
+      return;
+    }
 
-      return '⚠️ Reached tool limit (50). The AI was being very thorough! Try a more specific request.';
-    } catch (error) {
-      console.error('❌ Error calling GLM-4.7:', (error as Error).message);
+    const chunks: string[] = [];
+    let remaining = text;
 
-      if ((error as Error).message.includes('429')) {
-        return '⚠️ Rate limited by API. Please try again in a moment.';
+    while (remaining.length > 0) {
+      if (remaining.length <= MAX_LENGTH) {
+        chunks.push(remaining);
+        break;
       }
-      return `❌ Error: ${(error as Error).message}`;
-    } finally {
-      // Always stop typing indicator when done
-      this.stopTypingIndicator(chatId);
-    }
-  }
 
-  async sendTestMessage(chatId: number): Promise<void> {
-    const apiKey = getZAIKey();
-    await this.bot.sendMessage(
-      chatId,
-      '✅ GLM Daemon Telegram Bot is NOW ONLINE!\n\n' +
-      '🎉 Connected from seed-node-prod!\n\n' +
-      `🧠 AI: ${apiKey ? 'GLM-4.7 via Z.AI' : 'Not configured'}\n\n` +
-      'Commands:\n' +
-      '/start - Show welcome message\n' +
-      '/status - Check API status\n' +
-      '/git - Git & GitHub status\n' +
-      '/doppler - Doppler config\n' +
-      '/help - Show all commands\n' +
-      'Any message - Chat with GLM-4.7 AI'
-    );
-    console.log(`✅ Test message sent to chat ${chatId}`);
-  }
+      let breakPoint = remaining.lastIndexOf("\n", MAX_LENGTH);
+      if (breakPoint < 1000) breakPoint = remaining.lastIndexOf(" ", MAX_LENGTH);
+      if (breakPoint < 1000) breakPoint = MAX_LENGTH;
 
-  async stop(): Promise<void> {
-    console.log('🛑 Stopping Telegram bot...');
-    this.bot.stopPolling();
-  }
+      chunks.push(remaining.slice(0, breakPoint));
+      remaining = remaining.slice(breakPoint).trim();
+    }
 
-  /**
-   * Check for crash recovery - analyze previous session and report
-   * Always sends a startup message (crash or normal)
-   */
-  async checkCrashAndReport(chatId: number): Promise<void> {
-    try {
-      // Get previous boot/session logs to check for crash
-      const crashLog = execSync(
-        'journalctl -u telegram-bot -b -1 -n 50 --no-pager 2>/dev/null || journalctl -u telegram-bot --since "5 minutes ago" -n 50 --no-pager 2>/dev/null',
-        { encoding: 'utf-8', timeout: 5000 }
-      ).trim();
-
-      // Look for crash indicators
-      const crashIndicators = ['Error:', 'error', 'crashed', 'killed', 'ETELEGRAM', '400 Bad Request', 'exception'];
-      const hasCrash = crashLog && crashIndicators.some(ind => crashLog.toLowerCase().includes(ind.toLowerCase()));
-
-      if (hasCrash) {
-        // Crash detected - analyze and report
-        console.log('🔍 Crash detected, analyzing...');
-        await this.bot.sendMessage(chatId, '🔄 I detected a crash in my previous session. Analyzing...');
-
-        // Extract error lines
-        const errorLines = crashLog.split('\n')
-          .filter(line => crashIndicators.some(ind => line.toLowerCase().includes(ind.toLowerCase())))
-          .slice(-10)
-          .join('\n');
-
-        if (errorLines) {
-          // Ask LLM to diagnose
-          const diagnosis = await this.getGLMResponse(
-            chatId,
-            `Analyze this crash log and tell me what went wrong in one short paragraph, then suggest a fix:
-
-\`\`\`
-${errorLines.slice(0, 1000)}
-\`\`\`
-
-Format: "Issue: [what happened]. Fix: [how to fix it]"`,
-            'CrashAnalyzer'
-          );
-
-          await this.sendLongMessage(chatId, `🏥 Crash Diagnosis:\n\n${diagnosis}`);
-        }
-      } else {
-        // Normal start - no crash detected
-        await this.bot.sendMessage(
-          chatId,
-          '✅ Bot started normally.\n\n' +
-          'Previous session ended cleanly. Ready to assist!'
-        );
-      }
-    } catch (e) {
-      // If we can't check logs, still notify of normal start
-      console.log('Crash check skipped:', (e as Error).message);
-      await this.bot.sendMessage(
-        chatId,
-        '✅ Bot started fresh.\n\n' +
-        'No previous session data available. Ready to assist!'
-      );
+    for (let i = 0; i < chunks.length; i++) {
+      const prefix = chunks.length > 1 ? `[${i + 1}/${chunks.length}] ` : "";
+      await this.bot.sendMessage(chatId, prefix + chunks[i], options);
     }
   }
 }
 
-// Main entry point
+// ============================================================
+// FACTORY
+// ============================================================
+
+export function createTelegramChannel(config: TelegramConfig): TelegramChannel {
+  return new TelegramChannel(config);
+}
+
+// ============================================================
+// MAIN ENTRY POINT (for standalone testing)
+// ============================================================
+
 async function main() {
-  if (!TELEGRAM_BOT_TOKEN) {
-    console.error('❌ TELEGRAM_BOT_TOKEN not found in Doppler secrets');
-    console.error('Make sure to set in your seed/prd Doppler project');
-    process.exit(1);
-  }
+  const config = createTelegramConfigFromEnv();
 
-  // Ensure prompts are seeded
-  const promptsFile = process.env.PROMPTS_FILE;
-  const store = getStore(promptsFile);
-  if (!store.get('glm-daemon-system')) {
-    console.log('📝 Seeding prompts...');
-    seedPrompts(promptsFile);
+  if (!config.botToken) {
+    console.error("TELEGRAM_BOT_TOKEN not found in environment");
+    process.exit(1);
   }
 
-  console.log(`📱 Bot token loaded: ${TELEGRAM_BOT_TOKEN.substring(0, 10)}...`);
-  console.log(`🤖 Bot name: @SimulationapiBot`);
+  const channel = createTelegramChannel(config);
 
-  const bot = new TelegramGLMBot(TELEGRAM_BOT_TOKEN);
-  await bot.start();
+  // Example: Echo handler for testing
+  channel.onMessage(async (msg) => {
+    console.log(`Received: ${msg.text}`);
+    return {
+      content: { text: `Echo: ${msg.text}` },
+      replyTo: { messageId: msg.messageId, channelId: msg.channelId },
+    };
+  });
 
-  process.on('SIGINT', async () => {
-    await bot.stop();
+  process.on("SIGINT", async () => {
+    await channel.stop();
     process.exit(0);
   });
 
-  process.on('SIGTERM', async () => {
-    await bot.stop();
+  process.on("SIGTERM", async () => {
+    await channel.stop();
     process.exit(0);
   });
+
+  await channel.start();
 }
 
 main().catch(console.error);