@ebowwa/channel-telegram 1.12.5 → 1.13.0

package/dist/index.js

@@ -1,335 +1,181 @@
 /**
- * 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 = null;
-const TOOLS = [
-    {
-        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']
+import TelegramBot from "node-telegram-bot-api";
+import { createChannelId, } from "@ebowwa/channel-types";
+import { ConversationMemory } from "./conversation-memory.js";
+import { registerAllCommands } from "./commands/index.js";
+// Re-export for external use
+export { ConversationMemory } from "./conversation-memory.js";
+export { registerAllCommands, isQuiet } from "./commands/index.js";
+export function createTelegramConfigFromEnv() {
+    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,
+    };
+}
+// ============================================================
+// TELEGRAM CHANNEL
+// ============================================================
+export class TelegramChannel {
+    id;
+    label = "Telegram";
+    capabilities = {
+        supports: {
+            text: true,
+            media: true,
+            replies: true,
+            threads: false,
+            reactions: true,
+            editing: true,
+            streaming: false,
         },
-        handler: async (args) => {
-            const path = args.path;
-            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.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']
+        media: {
+            maxFileSize: 50 * 1024 * 1024, // 50MB
+            supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/pdf"],
         },
-        handler: async (args) => {
-            const path = args.path;
-            const content = args.content;
-            try {
-                writeFileSync(path, content, 'utf-8');
-                return `Successfully wrote ${content.length} bytes to ${path}`;
-            }
-            catch (e) {
-                return `Error writing file: ${e.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']
+        rateLimits: {
+            messagesPerMinute: 30,
+            charactersPerMessage: 4096,
         },
-        handler: async (args) => {
-            const path = args.path;
-            const oldStr = args.old_string;
-            const newStr = args.new_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.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;
-            const content = args.content;
-            try {
-                appendFileSync(path, content, 'utf-8');
-                return `Successfully appended ${content.length} bytes to ${path}`;
-            }
-            catch (e) {
-                return `Error appending to file: ${e.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 || process.cwd();
-            try {
-                const items = execSync(`ls -la "${path}" 2>&1`).toString();
-                return items;
-            }
-            catch (e) {
-                return `Error listing directory: ${e.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)' }
+    };
+    bot;
+    config;
+    memory;
+    tools;
+    messageHandler;
+    typingIntervals = new Map();
+    connected = false;
+    constructor(config) {
+        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 || [];
+    }
+    // ============================================================
+    // ChannelConnector Implementation
+    // ============================================================
+    async start() {
+        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"],
+                },
             },
-            required: ['command']
-        },
-        handler: async (args) => {
-            const cmd = args.command;
-            const cwd = args.cwd || 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) {
-                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)' }
-            }
-        },
-        handler: async (args) => {
-            const cwd = args.cwd || 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.message}`;
-            }
+        });
+        // 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");
         }
-    },
-    {
-        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']
-        },
-        handler: async (args) => {
-            const store = getStore(process.env.PROMPTS_FILE);
-            const prompt = store.get(args.id);
-            return prompt ? JSON.stringify(prompt, null, 2) : `Prompt not found: ${args.id}`;
+    }
+    async stop() {
+        console.log("[TelegramChannel] Stopping...");
+        await this.bot.stopPolling();
+        this.connected = false;
+    }
+    /**
+     * Set the message handler. The daemon/consumer provides intelligence.
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    /**
+     * Send a response back to Telegram.
+     */
+    async send(response) {
+        const chatId = this.extractChatId(response.replyTo);
+        if (!chatId) {
+            console.error("[TelegramChannel] Cannot send: no chat ID");
+            return;
         }
-    },
-    {
-        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';
+        const options = {};
+        if (response.content.replyToOriginal) {
+            options.reply_to_message_id = parseInt(response.replyTo.messageId, 10);
         }
-    },
-    {
-        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.message}`;
-            }
+        if (response.content.options?.parseMode) {
+            options.parse_mode = response.content.options.parseMode;
         }
+        await this.sendLongMessage(chatId, response.content.text, options);
     }
-];
-// Get all tools (local + MCP) in GLM API format
-function getGLMTools() {
-    const allTools = [...TOOLS.map(t => ({
-            type: 'function',
-            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
-                }
-            });
-        }
+    isConnected() {
+        return this.connected;
     }
-    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
+    // ============================================================
+    // Public Helpers
+    // ============================================================
+    /**
+     * Get the underlying TelegramBot instance for advanced operations.
+     */
+    getBot() {
+        return this.bot;
     }
-}));
-// Execute a tool by name (checks local tools first, then MCP)
-async function executeTool(name, args) {
-    // Check local tools first
-    const tool = TOOLS.find(t => t.name === name);
-    if (tool) {
-        return tool.handler(args);
+    /**
+     * Get the conversation memory.
+     */
+    getMemory() {
+        return this.memory;
     }
-    // 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.message}`;
-            }
-        }
+    /**
+     * Send a simple text message.
+     */
+    async sendMessage(chatId, text, options) {
+        await this.bot.sendMessage(chatId, text, options);
     }
-    return `Unknown tool: ${name}`;
-}
-const ZAI_API_ENDPOINT = 'https://api.z.ai/api/coding/paas/v4/chat/completions';
-export class TelegramGLMBot {
-    bot;
-    memory;
-    typingIntervals = new Map();
-    constructor(token) {
-        // 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);
+    /**
+     * Send typing indicator.
+     */
+    async sendTyping(chatId) {
+        await this.bot.sendChatAction(chatId, "typing");
     }
     /**
-     * Start periodic typing indicator for a chat
-     * Telegram typing indicator lasts ~5 seconds, so refresh every 3 seconds
+     * Start continuous typing indicator (until response is ready).
      */
     startTypingIndicator(chatId) {
-        // Clear any existing interval
         this.stopTypingIndicator(chatId);
-        // Send initial typing action
-        this.bot.sendChatAction(chatId, 'typing').catch(() => { });
-        // Set up periodic refresh every 3 seconds
+        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.
      */
     stopTypingIndicator(chatId) {
         const interval = this.typingIntervals.get(chatId);
@@ -339,456 +185,248 @@ export class TelegramGLMBot {
         }
     }
     /**
-     * Send message, splitting if too long for Telegram (4096 char limit)
+     * Check if user/chat is allowed.
      */
-    async sendLongMessage(chatId, text) {
-        const MAX_LENGTH = 4000; // Leave buffer for safety
-        if (text.length <= MAX_LENGTH) {
-            await this.bot.sendMessage(chatId, text);
-            return;
+    isAllowed(userId, chatId) {
+        if (!this.config.allowedUsers?.length && !this.config.allowedChats?.length) {
+            return true;
         }
-        // Split into chunks at word boundaries when possible
-        const chunks = [];
-        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;
         }
+        return false;
     }
-    async start() {
-        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) => {
-            if (!msg.text)
+    // ============================================================
+    // Message Routing (Internal)
+    // ============================================================
+    setupMessageHandlers() {
+        // Text messages (skip commands - handled by onText handlers)
+        this.bot.on("message", async (msg) => {
+            if (!msg.text || msg.text.startsWith("/"))
                 return;
-            if (msg.text.startsWith('/'))
+            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;
-            // 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}`;
-            }
-            // 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);
+            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.message}`);
+                }
             }
         });
-        // Polling errors
-        this.bot.on('polling_error', (error) => {
-            console.error('[Telegram] Polling error:', error.message);
-        });
-        // ====================================================================
-        // Message Edit Handler
-        // ====================================================================
-        this.bot.on('edited_message', async (msg) => {
+        // Edited messages
+        this.bot.on("edited_message", async (msg) => {
             if (!msg.text)
                 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}`);
+            if (!this.isAllowed(msg.from?.id, msg.chat.id))
+                return;
+            const message = this.createChannelMessage(msg);
+            // Mark as edited in text
+            message.text = `[Edited] ${msg.text}`;
+            if (this.messageHandler) {
+                try {
+                    const response = await this.messageHandler(message);
+                    if (response) {
+                        await this.send(response);
+                    }
+                }
+                catch (error) {
+                    console.error("[TelegramChannel] Handler error:", error);
+                }
             }
         });
-        // ====================================================================
-        // 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.on('message_reaction', async (reaction) => {
-            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);
-            }
-            // 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 (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.on("message_reaction", async (reaction) => {
+            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);
             }
         });
-        // ====================================================================
-        // Callback Query Handler (Inline Button Reactions)
-        // ====================================================================
-        this.bot.on('callback_query', async (query) => {
+        // 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;
+            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);
+                    if (response) {
+                        await this.send(response);
+                    }
                 }
-                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);
+                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!');
-        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');
-        }
+        // Polling errors
+        this.bot.on("polling_error", (error) => {
+            console.error("[TelegramChannel] Polling error:", error.message);
+        });
+    }
+    /**
+     * Register Telegram command menu
+     */
+    async registerCommands() {
+        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, userMessage, userName) {
-        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.
+     */
+    createChannelMessage(msg) {
+        const sender = {
+            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 = {
+            isDM: msg.chat.type === "private",
+            groupName: msg.chat.type !== "private" ? msg.chat.title : undefined,
+        };
+        // Build reply context
+        let replyText;
+        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 = [
-            { 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();
-                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) => {
-                                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
-                        });
-                    }
-                    // Continue loop to get final response
-                    continue;
-                }
-                // 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;
+        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,
                 }
-                // No content and no tool calls - something weird
-                return '❌ Empty response from AI.';
-            }
-            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.message);
-            if (error.message.includes('429')) {
-                return '⚠️ Rate limited by API. Please try again in a moment.';
-            }
-            return `❌ Error: ${error.message}`;
-        }
-        finally {
-            // Always stop typing indicator when done
-            this.stopTypingIndicator(chatId);
-        }
+                : undefined,
+        };
     }
-    async sendTestMessage(chatId) {
-        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}`);
-    }
-    async stop() {
-        console.log('🛑 Stopping Telegram bot...');
-        this.bot.stopPolling();
+    extractChatId(replyTo) {
+        const accountId = replyTo.channelId.accountId;
+        const parsed = parseInt(accountId, 10);
+        if (!isNaN(parsed))
+            return parsed;
+        return null;
     }
     /**
-     * Check for crash recovery - analyze previous session and report
-     * Always sends a startup message (crash or normal)
+     * Send long message by splitting into chunks.
      */
-    async checkCrashAndReport(chatId) {
-        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!');
+    async sendLongMessage(chatId, text, options) {
+        const MAX_LENGTH = 4000;
+        if (text.length <= MAX_LENGTH) {
+            await this.bot.sendMessage(chatId, text, options);
+            return;
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+            if (remaining.length <= MAX_LENGTH) {
+                chunks.push(remaining);
+                break;
             }
+            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();
         }
-        catch (e) {
-            // If we can't check logs, still notify of normal start
-            console.log('Crash check skipped:', e.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) {
+    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');
+    const config = createTelegramConfigFromEnv();
+    if (!config.botToken) {
+        console.error("TELEGRAM_BOT_TOKEN not found in environment");
         process.exit(1);
     }
-    // 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);
-    }
-    console.log(`📱 Bot token loaded: ${TELEGRAM_BOT_TOKEN.substring(0, 10)}...`);
-    console.log(`🤖 Bot name: @SimulationapiBot`);
-    const bot = new TelegramGLMBot(TELEGRAM_BOT_TOKEN);
-    await bot.start();
-    process.on('SIGINT', async () => {
-        await bot.stop();
+    const channel = createTelegramChannel(config);
+    // 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 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);
 //# sourceMappingURL=index.js.map