@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/src/channels/telegram.js

@@ -0,0 +1,395 @@
+"use strict";
+/**
+ * Telegram Channel Adapter
+ *
+ * Implements ChannelConnector from @ebowwa/channel-types.
+ * Telegram bot using node-telegram-bot-api.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramChannel = void 0;
+exports.createTelegramChannel = createTelegramChannel;
+exports.createTelegramConfigFromEnv = createTelegramConfigFromEnv;
+var node_telegram_bot_api_1 = require("node-telegram-bot-api");
+var base_js_1 = require("./base.js");
+// ============================================================
+// TELEGRAM CHANNEL
+// ============================================================
+var TelegramChannel = /** @class */ (function (_super) {
+    __extends(TelegramChannel, _super);
+    function TelegramChannel(config) {
+        var _this = _super.call(this, config) || this;
+        _this.label = "Telegram";
+        _this.capabilities = {
+            supports: {
+                text: true,
+                media: true,
+                replies: true,
+                threads: false,
+                reactions: false,
+                editing: true,
+                streaming: false,
+            },
+            media: {
+                maxFileSize: 50 * 1024 * 1024, // 50MB
+                supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/pdf"],
+            },
+            rateLimits: {
+                messagesPerMinute: 30,
+                charactersPerMessage: 4096,
+            },
+        };
+        _this.token = config.botToken;
+        _this.testChatId = config.testChatId;
+        _this.allowedUsers = config.allowedUsers;
+        _this.allowedChats = config.allowedChats;
+        _this.id = _this.createId();
+        _this.bot = new node_telegram_bot_api_1.default(_this.token, { polling: false }); // Don't start polling yet
+        return _this;
+    }
+    // ============================================================
+    // ChannelConnector Implementation
+    // ============================================================
+    /**
+     * Send response to Telegram
+     */
+    TelegramChannel.prototype.send = function (response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chatId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chatId = this.extractChatId(response.replyTo);
+                        if (!chatId) {
+                            console.error("[Telegram] Cannot send: no chat ID in response");
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.sendResponse(chatId, response.content.text)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================================
+    // Platform-Specific Implementation
+    // ============================================================
+    /**
+     * Start Telegram bot
+     */
+    TelegramChannel.prototype.startPlatform = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[Telegram] Starting bot...");
+                        // Start polling
+                        this.bot = new node_telegram_bot_api_1.default(this.token, { polling: true });
+                        // Handle /start command
+                        this.bot.onText(/\/start/, function (msg) { return __awaiter(_this, void 0, void 0, function () {
+                            var chatId;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        chatId = msg.chat.id;
+                                        return [4 /*yield*/, this.bot.sendMessage(chatId, "👋 Hello! I'm the GLM Daemon Telegram Bot.\n\n" +
+                                                "I can help you with:\n" +
+                                                "- Chat and questions (handled locally)\n" +
+                                                "- Coding tasks and features (delegated to daemon)\n\n" +
+                                                "Just send me a message!")];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        // Handle all text messages
+                        this.bot.on("message", function (msg) { return __awaiter(_this, void 0, void 0, function () {
+                            var chatId, userId, userName, message, response, error_1;
+                            var _a, _b, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        if (!msg.text)
+                                            return [2 /*return*/];
+                                        if (msg.text.startsWith("/"))
+                                            return [2 /*return*/];
+                                        chatId = msg.chat.id;
+                                        userId = (_a = msg.from) === null || _a === void 0 ? void 0 : _a.id;
+                                        // Check allowlist
+                                        if (!this.isAllowed(userId, chatId)) {
+                                            console.log("[Telegram] Blocked message from unauthorized user/chat: ".concat(userId, "/").concat(chatId));
+                                            return [2 /*return*/];
+                                        }
+                                        userName = ((_b = msg.from) === null || _b === void 0 ? void 0 : _b.first_name) || ((_c = msg.from) === null || _c === void 0 ? void 0 : _c.username) || "User";
+                                        console.log("[Telegram] ".concat(userName, ": ").concat(msg.text));
+                                        // Show typing indicator
+                                        return [4 /*yield*/, this.bot.sendChatAction(chatId, "typing")];
+                                    case 1:
+                                        // Show typing indicator
+                                        _d.sent();
+                                        _d.label = 2;
+                                    case 2:
+                                        _d.trys.push([2, 5, , 7]);
+                                        message = this.createChannelMessage(msg);
+                                        return [4 /*yield*/, this.routeChannelMessage(message)];
+                                    case 3:
+                                        response = _d.sent();
+                                        // Send response
+                                        return [4 /*yield*/, this.send(response)];
+                                    case 4:
+                                        // Send response
+                                        _d.sent();
+                                        return [3 /*break*/, 7];
+                                    case 5:
+                                        error_1 = _d.sent();
+                                        console.error("[Telegram] Error handling message:", error_1);
+                                        return [4 /*yield*/, this.bot.sendMessage(chatId, "Sorry, I encountered an error: ".concat(error_1 instanceof Error ? error_1.message : String(error_1)))];
+                                    case 6:
+                                        _d.sent();
+                                        return [3 /*break*/, 7];
+                                    case 7: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        // Handle polling errors
+                        this.bot.on("polling_error", function (error) {
+                            console.error("[Telegram] Polling error:", error);
+                        });
+                        console.log("[Telegram] Bot is running!");
+                        if (!this.testChatId) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.sendTestMessage(Number(this.testChatId))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stop Telegram bot
+     */
+    TelegramChannel.prototype.stopPlatform = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[Telegram] Stopping bot...");
+                        return [4 /*yield*/, this.bot.stopPolling()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================================
+    // Telegram-Specific Helpers
+    // ============================================================
+    /**
+     * Create normalized ChannelMessage from Telegram message
+     */
+    TelegramChannel.prototype.createChannelMessage = function (msg) {
+        var _a, _b, _c, _d, _e, _f;
+        var sender = {
+            id: ((_b = (_a = msg.from) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.toString()) || msg.chat.id.toString(),
+            username: (_c = msg.from) === null || _c === void 0 ? void 0 : _c.username,
+            displayName: ((_d = msg.from) === null || _d === void 0 ? void 0 : _d.first_name) || ((_e = msg.from) === null || _e === void 0 ? void 0 : _e.username),
+            isBot: ((_f = msg.from) === null || _f === void 0 ? void 0 : _f.is_bot) || false,
+        };
+        var context = {
+            isDM: msg.chat.type === "private",
+            groupName: msg.chat.type !== "private" ? msg.chat.title : undefined,
+        };
+        return {
+            messageId: msg.message_id.toString(),
+            channelId: this.id,
+            timestamp: new Date(msg.date * 1000),
+            sender: sender,
+            text: msg.text || "",
+            context: context,
+            replyTo: msg.reply_to_message
+                ? {
+                    messageId: msg.reply_to_message.message_id.toString(),
+                    channelId: this.id,
+                }
+                : undefined,
+        };
+    };
+    /**
+     * Check if user/chat is allowed
+     */
+    TelegramChannel.prototype.isAllowed = function (userId, chatId) {
+        var _a, _b, _c, _d;
+        // No allowlist configured = allow all
+        if (!((_a = this.allowedUsers) === null || _a === void 0 ? void 0 : _a.length) && !((_b = this.allowedChats) === null || _b === void 0 ? void 0 : _b.length)) {
+            return true;
+        }
+        // Check user allowlist
+        if (((_c = this.allowedUsers) === null || _c === void 0 ? void 0 : _c.length) && userId) {
+            if (this.allowedUsers.includes(userId))
+                return true;
+        }
+        // Check chat allowlist
+        if (((_d = this.allowedChats) === null || _d === void 0 ? void 0 : _d.length) && chatId) {
+            if (this.allowedChats.includes(chatId))
+                return true;
+        }
+        return false;
+    };
+    /**
+     * Extract chat ID from MessageRef
+     */
+    TelegramChannel.prototype.extractChatId = function (replyTo) {
+        // Chat ID is stored in channelId.accountId for Telegram
+        var accountId = replyTo.channelId.accountId;
+        // Try to parse as number, fallback to null
+        var parsed = parseInt(accountId, 10);
+        return isNaN(parsed) ? null : parsed;
+    };
+    /**
+     * Send response, handling chunking for long messages
+     */
+    TelegramChannel.prototype.sendResponse = function (chatId, response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxLength, chunks, _i, chunks_1, chunk;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        maxLength = 4096;
+                        if (!(response.length > maxLength)) return [3 /*break*/, 5];
+                        chunks = response.match(/[\s\S]{1,4000}/g) || [];
+                        _i = 0, chunks_1 = chunks;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < chunks_1.length)) return [3 /*break*/, 4];
+                        chunk = chunks_1[_i];
+                        return [4 /*yield*/, this.bot.sendMessage(chatId, chunk, { parse_mode: "Markdown" })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, this.bot.sendMessage(chatId, response, { parse_mode: "Markdown" })];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Send test message
+     */
+    TelegramChannel.prototype.sendTestMessage = function (chatId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.bot.sendMessage(chatId, "✅ GLM Daemon Telegram Bot is NOW ONLINE!\n\n" +
+                            "🎉 The bot is working correctly!\n\n" +
+                            "Commands:\n" +
+                            "/start - Show welcome message\n" +
+                            'Any message - Chat or task\n' +
+                            '"status" - Check daemon status\n\n' +
+                            "I'll route your messages appropriately!")];
+                    case 1:
+                        _a.sent();
+                        console.log("[Telegram] Test message sent to chat ".concat(chatId));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return TelegramChannel;
+}(base_js_1.BaseChannel));
+exports.TelegramChannel = TelegramChannel;
+// ============================================================
+// FACTORY FUNCTION
+// ============================================================
+/**
+ * Create a Telegram channel from config
+ */
+function createTelegramChannel(config) {
+    return new TelegramChannel(config);
+}
+/**
+ * Create Telegram channel config from environment (Doppler)
+ */
+function createTelegramConfigFromEnv() {
+    var _a, _b;
+    var token = process.env.TELEGRAM_BOT_TOKEN;
+    if (!token)
+        return null;
+    var allowedUsers = (_a = process.env.TELEGRAM_ALLOWED_USERS) === null || _a === void 0 ? void 0 : _a.split(",").map(function (s) { return parseInt(s.trim(), 10); }).filter(function (n) { return !isNaN(n); });
+    var allowedChats = (_b = process.env.TELEGRAM_ALLOWED_CHATS) === null || _b === void 0 ? void 0 : _b.split(",").map(function (s) { return parseInt(s.trim(), 10); }).filter(function (n) { return !isNaN(n); });
+    return {
+        platform: "telegram",
+        accountId: process.env.TELEGRAM_ACCOUNT_ID || "default",
+        instanceId: process.env.TELEGRAM_INSTANCE_ID,
+        botToken: token,
+        testChatId: process.env.TELEGRAM_TEST_CHAT_ID,
+        allowedUsers: allowedUsers,
+        allowedChats: allowedChats,
+        daemonWorkdir: process.env.DAEMON_WORKDIR,
+        daemonBaseBranch: process.env.DAEMON_BASE_BRANCH,
+        enableDaemonAutoPR: process.env.DAEMON_AUTO_PR === "true",
+        enableDaemonAutoCommit: process.env.DAEMON_AUTO_COMMIT === "true",
+        butlerStorageDir: process.env.BUTLER_STORAGE_DIR,
+    };
+}