@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/src/channels/discord.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * Discord Channel Adapter
+ *
+ * Implements ChannelConnector from @ebowwa/channel-types.
+ * Discord bot using discord.js.
+ */
+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.DiscordChannel = void 0;
+exports.createDiscordChannel = createDiscordChannel;
+exports.createDiscordConfigFromEnv = createDiscordConfigFromEnv;
+var discord_js_1 = require("discord.js");
+var base_js_1 = require("./base.js");
+// ============================================================
+// DISCORD CHANNEL
+// ============================================================
+var DiscordChannel = /** @class */ (function (_super) {
+    __extends(DiscordChannel, _super);
+    function DiscordChannel(config) {
+        var _this = _super.call(this, config) || this;
+        _this.label = "Discord";
+        _this.capabilities = {
+            supports: {
+                text: true,
+                media: true,
+                replies: true,
+                threads: true,
+                reactions: true,
+                editing: true,
+                streaming: false, // Discord doesn't support true streaming
+            },
+            media: {
+                maxFileSize: 25 * 1024 * 1024, // 25MB (nitro is higher)
+                supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/*"],
+            },
+            rateLimits: {
+                messagesPerMinute: 50,
+                charactersPerMessage: 2000,
+            },
+        };
+        _this.token = config.botToken;
+        _this.guildId = config.guildId;
+        _this.channelIds = config.channelIds;
+        _this.id = _this.createId();
+        _this.client = new discord_js_1.Client({
+            intents: [
+                discord_js_1.GatewayIntentBits.Guilds,
+                discord_js_1.GatewayIntentBits.GuildMessages,
+                discord_js_1.GatewayIntentBits.MessageContent,
+            ],
+        });
+        return _this;
+    }
+    // ============================================================
+    // ChannelConnector Implementation
+    // ============================================================
+    /**
+     * Send response to Discord
+     */
+    DiscordChannel.prototype.send = function (response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, channelId, messageId, channel, textChannel, message, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = response.replyTo, channelId = _a.channelId, messageId = _a.messageId;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 8, , 9]);
+                        return [4 /*yield*/, this.client.channels.fetch(channelId.accountId)];
+                    case 2:
+                        channel = _b.sent();
+                        if (!channel || !channel.isTextBased()) {
+                            console.error("[Discord] Cannot send: channel not found or not text-based");
+                            return [2 /*return*/];
+                        }
+                        textChannel = channel;
+                        return [4 /*yield*/, textChannel.messages.fetch(messageId)];
+                    case 3:
+                        message = _b.sent();
+                        if (!response.content.replyToOriginal) return [3 /*break*/, 5];
+                        return [4 /*yield*/, message.reply(response.content.text)];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, textChannel.send(response.content.text)];
+                    case 6:
+                        _b.sent();
+                        _b.label = 7;
+                    case 7: return [3 /*break*/, 9];
+                    case 8:
+                        error_1 = _b.sent();
+                        console.error("[Discord] Error sending response:", error_1);
+                        return [3 /*break*/, 9];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================================
+    // Platform-Specific Implementation
+    // ============================================================
+    /**
+     * Start Discord bot
+     */
+    DiscordChannel.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("[Discord] Starting bot...");
+                        this.client.on("ready", function () {
+                            var _a;
+                            console.log("[Discord] Logged in as ".concat((_a = _this.client.user) === null || _a === void 0 ? void 0 : _a.tag));
+                            console.log("[Discord] Ready to handle messages");
+                        });
+                        this.client.on("messageCreate", function (message) { return __awaiter(_this, void 0, void 0, function () {
+                            var channelMessage, response, error_2;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        // Ignore bot messages
+                                        if (message.author.bot)
+                                            return [2 /*return*/];
+                                        // Check guild restriction
+                                        if (this.guildId && message.guildId !== this.guildId) {
+                                            return [2 /*return*/];
+                                        }
+                                        // Check channel restriction
+                                        if (((_a = this.channelIds) === null || _a === void 0 ? void 0 : _a.length) && !this.channelIds.includes(message.channelId)) {
+                                            return [2 /*return*/];
+                                        }
+                                        console.log("[Discord] [".concat(message.author.tag, "]: ").concat(message.content));
+                                        if (!("sendTyping" in message.channel && typeof message.channel.sendTyping === "function")) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, message.channel.sendTyping()];
+                                    case 1:
+                                        _b.sent();
+                                        _b.label = 2;
+                                    case 2:
+                                        _b.trys.push([2, 5, , 7]);
+                                        channelMessage = this.createChannelMessage(message);
+                                        return [4 /*yield*/, this.routeChannelMessage(channelMessage)];
+                                    case 3:
+                                        response = _b.sent();
+                                        // Send response
+                                        return [4 /*yield*/, this.send(response)];
+                                    case 4:
+                                        // Send response
+                                        _b.sent();
+                                        return [3 /*break*/, 7];
+                                    case 5:
+                                        error_2 = _b.sent();
+                                        console.error("[Discord] Error handling message:", error_2);
+                                        return [4 /*yield*/, message.reply("Sorry, I encountered an error: ".concat(error_2 instanceof Error ? error_2.message : String(error_2)))];
+                                    case 6:
+                                        _b.sent();
+                                        return [3 /*break*/, 7];
+                                    case 7: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, this.client.login(this.token)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stop Discord bot
+     */
+    DiscordChannel.prototype.stopPlatform = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[Discord] Shutting down...");
+                        return [4 /*yield*/, this.client.destroy()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================================
+    // Discord-Specific Helpers
+    // ============================================================
+    /**
+     * Create normalized ChannelMessage from Discord message
+     */
+    DiscordChannel.prototype.createChannelMessage = function (msg) {
+        var _a, _b;
+        var sender = {
+            id: msg.author.id,
+            username: msg.author.username,
+            displayName: msg.author.displayName || msg.author.username,
+            isBot: msg.author.bot,
+        };
+        var context = {
+            isDM: msg.channel.isDMBased(),
+            groupName: !msg.channel.isDMBased() ? (_a = msg.guild) === null || _a === void 0 ? void 0 : _a.name : undefined,
+            threadId: msg.channel.isThread() ? msg.channelId : undefined,
+            metadata: {
+                guildId: msg.guildId,
+                channelId: msg.channelId,
+            },
+        };
+        // Extract media attachments
+        var media = msg.attachments.size > 0
+            ? msg.attachments.map(function (att) {
+                var _a, _b, _c;
+                return ({
+                    type: ((_a = att.contentType) === null || _a === void 0 ? void 0 : _a.startsWith("image"))
+                        ? "image"
+                        : ((_b = att.contentType) === null || _b === void 0 ? void 0 : _b.startsWith("video"))
+                            ? "video"
+                            : ((_c = att.contentType) === null || _c === void 0 ? void 0 : _c.startsWith("audio"))
+                                ? "audio"
+                                : "file",
+                    url: att.url,
+                    mimeType: att.contentType || undefined,
+                    filename: att.name || undefined,
+                });
+            })
+            : undefined;
+        return {
+            messageId: msg.id,
+            channelId: {
+                platform: "discord",
+                accountId: msg.channelId,
+            },
+            timestamp: new Date(msg.createdTimestamp),
+            sender: sender,
+            text: msg.content,
+            media: media,
+            context: context,
+            replyTo: ((_b = msg.reference) === null || _b === void 0 ? void 0 : _b.messageId)
+                ? {
+                    messageId: msg.reference.messageId,
+                    channelId: {
+                        platform: "discord",
+                        accountId: msg.reference.channelId,
+                    },
+                }
+                : undefined,
+            quotedText: undefined,
+        };
+    };
+    /**
+     * Send response, handling chunking for long messages
+     */
+    DiscordChannel.prototype.sendResponse = function (message, 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 = 2000;
+                        if (!(response.length > maxLength)) return [3 /*break*/, 5];
+                        chunks = response.match(/[\s\S]{1,2000}/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*/, message.reply(chunk)];
+                    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*/, message.reply(response)];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DiscordChannel;
+}(base_js_1.BaseChannel));
+exports.DiscordChannel = DiscordChannel;
+// ============================================================
+// FACTORY FUNCTION
+// ============================================================
+/**
+ * Create a Discord channel from config
+ */
+function createDiscordChannel(config) {
+    return new DiscordChannel(config);
+}
+/**
+ * Create Discord channel config from environment (Doppler)
+ */
+function createDiscordConfigFromEnv() {
+    var _a;
+    var token = process.env.DISCORD_BOT_TOKEN;
+    if (!token)
+        return null;
+    var channelIds = (_a = process.env.DISCORD_CHANNEL_IDS) === null || _a === void 0 ? void 0 : _a.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
+    return {
+        platform: "discord",
+        accountId: process.env.DISCORD_ACCOUNT_ID || "default",
+        instanceId: process.env.DISCORD_INSTANCE_ID,
+        botToken: token,
+        applicationId: process.env.DISCORD_APPLICATION_ID,
+        guildId: process.env.DISCORD_GUILD_ID,
+        channelIds: channelIds,
+        enableSlashCommands: process.env.DISCORD_ENABLE_SLASH_COMMANDS !== "false",
+        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,
+    };
+}

package/src/channels/index.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * GLM Daemon Channels
+ *
+ * Communication channel adapters for GLM Daemon.
+ * All channels implement ChannelConnector from @ebowwa/channel-types.
+ *
+ * Supported platforms:
+ * - Telegram
+ * - Discord
+ */
+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.ChannelRegistry = exports.createDiscordConfigFromEnv = exports.createDiscordChannel = exports.DiscordChannel = exports.createTelegramConfigFromEnv = exports.createTelegramChannel = exports.TelegramChannel = exports.BaseChannel = void 0;
+exports.createChannelsFromEnv = createChannelsFromEnv;
+exports.initializeChannelsFromEnv = initializeChannelsFromEnv;
+// Base channel
+var base_js_1 = require("./base.js");
+Object.defineProperty(exports, "BaseChannel", { enumerable: true, get: function () { return base_js_1.BaseChannel; } });
+// Telegram
+var telegram_js_1 = require("./telegram.js");
+Object.defineProperty(exports, "TelegramChannel", { enumerable: true, get: function () { return telegram_js_1.TelegramChannel; } });
+Object.defineProperty(exports, "createTelegramChannel", { enumerable: true, get: function () { return telegram_js_1.createTelegramChannel; } });
+Object.defineProperty(exports, "createTelegramConfigFromEnv", { enumerable: true, get: function () { return telegram_js_1.createTelegramConfigFromEnv; } });
+// Discord
+var discord_js_1 = require("./discord.js");
+Object.defineProperty(exports, "DiscordChannel", { enumerable: true, get: function () { return discord_js_1.DiscordChannel; } });
+Object.defineProperty(exports, "createDiscordChannel", { enumerable: true, get: function () { return discord_js_1.createDiscordChannel; } });
+Object.defineProperty(exports, "createDiscordConfigFromEnv", { enumerable: true, get: function () { return discord_js_1.createDiscordConfigFromEnv; } });
+var telegram_js_2 = require("./telegram.js");
+var discord_js_2 = require("./discord.js");
+/**
+ * Channel registry for managing multiple channels
+ */
+var ChannelRegistry = /** @class */ (function () {
+    function ChannelRegistry() {
+    }
+    /**
+     * Register a channel
+     */
+    ChannelRegistry.register = function (name, channel) {
+        this.channels.set(name, channel);
+    };
+    /**
+     * Get a registered channel
+     */
+    ChannelRegistry.get = function (name) {
+        return this.channels.get(name);
+    };
+    /**
+     * Unregister a channel
+     */
+    ChannelRegistry.unregister = function (name) {
+        var channel = this.channels.get(name);
+        if (channel) {
+            channel.stop();
+            this.channels.delete(name);
+        }
+    };
+    /**
+     * Get all registered channels
+     */
+    ChannelRegistry.getAll = function () {
+        return new Map(this.channels);
+    };
+    /**
+     * Stop all channels
+     */
+    ChannelRegistry.stopAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var stopPromises;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        stopPromises = Array.from(this.channels.values()).map(function (channel) { return channel.stop(); });
+                        return [4 /*yield*/, Promise.all(stopPromises)];
+                    case 1:
+                        _a.sent();
+                        this.channels.clear();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Start all channels
+     */
+    ChannelRegistry.startAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startPromises;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startPromises = Array.from(this.channels.values()).map(function (channel) { return channel.start(); });
+                        return [4 /*yield*/, Promise.all(startPromises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ChannelRegistry.channels = new Map();
+    return ChannelRegistry;
+}());
+exports.ChannelRegistry = ChannelRegistry;
+// ============================================================
+// FACTORY FUNCTIONS
+// ============================================================
+/**
+ * Create all channels from environment variables (Doppler)
+ */
+function createChannelsFromEnv() {
+    var channels = [];
+    // Telegram
+    var telegramConfig = (0, telegram_js_2.createTelegramConfigFromEnv)();
+    if (telegramConfig) {
+        channels.push(new telegram_js_2.TelegramChannel(telegramConfig));
+    }
+    // Discord
+    var discordConfig = (0, discord_js_2.createDiscordConfigFromEnv)();
+    if (discordConfig) {
+        channels.push(new discord_js_2.DiscordChannel(discordConfig));
+    }
+    return channels;
+}
+/**
+ * Initialize channels from environment and register them
+ */
+function initializeChannelsFromEnv() {
+    return __awaiter(this, void 0, void 0, function () {
+        var channels, _i, channels_1, channel, key;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    channels = createChannelsFromEnv();
+                    for (_i = 0, channels_1 = channels; _i < channels_1.length; _i++) {
+                        channel = channels_1[_i];
+                        key = "".concat(channel.id.platform, ":").concat(channel.id.accountId);
+                        ChannelRegistry.register(key, channel);
+                    }
+                    // Start all channels
+                    return [4 /*yield*/, ChannelRegistry.startAll()];
+                case 1:
+                    // Start all channels
+                    _a.sent();
+                    return [2 /*return*/, ChannelRegistry];
+            }
+        });
+    });
+}