pikiloop 0.4.0

package/dist/channels/discord/channel.js

@@ -0,0 +1,245 @@
+/**
+ * Discord channel transport — Gateway WebSocket (no public IP needed).
+ *
+ * Uses discord.js v14 with the bare minimum gateway intents:
+ *   - Guilds, GuildMessages, MessageContent, DirectMessages
+ *
+ * IMPORTANT: For the bot to read message content in shared channels you must
+ * enable the "Message Content Intent" toggle in the Discord developer portal
+ * Bot page. Without it the gateway will silently emit empty `content`.
+ *
+ * Receives DMs and messages where the bot is mentioned. Self-authored
+ * messages are filtered out before dispatch.
+ */
+import { Client, Events, GatewayIntentBits, Partials, } from 'discord.js';
+import { Channel, DEFAULT_CHANNEL_CAPABILITIES, splitText, sleep, } from '../base.js';
+import { DISCORD_LIMITS } from '../../core/constants.js';
+import { writeScopedLog } from '../../core/logging.js';
+const DISCORD_MAX = DISCORD_LIMITS.maxMessageLength;
+function describeError(err) {
+    return err instanceof Error ? err.message : String(err ?? 'unknown error');
+}
+export class DiscordChannel extends Channel {
+    capabilities = {
+        ...DEFAULT_CHANNEL_CAPABILITIES,
+        editMessages: true,
+    };
+    knownChats = new Set();
+    botToken;
+    allowedChatIds;
+    requireMention;
+    client;
+    botUserId = null;
+    running = false;
+    listenResolve = null;
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    constructor(opts) {
+        super();
+        this.botToken = opts.botToken;
+        this.allowedChatIds = opts.allowedChatIds;
+        this.requireMention = opts.requireMentionInChannel ?? true;
+    }
+    onMessage(handler) { this.messageHandlers.add(handler); return this; }
+    onError(handler) { this.errorHandlers.add(handler); return this; }
+    // ========================================================================
+    // Lifecycle
+    // ========================================================================
+    async connect() {
+        this.client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.MessageContent,
+                GatewayIntentBits.DirectMessages,
+            ],
+            partials: [Partials.Channel, Partials.Message],
+        });
+        let resolveReady = null;
+        let rejectReady = null;
+        const ready = new Promise((resolve, reject) => {
+            resolveReady = resolve;
+            rejectReady = reject;
+        });
+        this.client.once(Events.ClientReady, () => resolveReady?.());
+        this.client.once(Events.Error, err => rejectReady?.(err instanceof Error ? err : new Error(describeError(err))));
+        let lastErr = null;
+        for (let attempt = 1; attempt <= 5; attempt++) {
+            try {
+                await this.client.login(this.botToken);
+                await ready;
+                const me = this.client.user;
+                if (!me)
+                    throw new Error('Discord client missing user after ready');
+                this.botUserId = me.id;
+                this.bot = {
+                    id: me.id,
+                    username: me.username || '',
+                    displayName: me.displayName || me.username || 'discord-bot',
+                };
+                return this.bot;
+            }
+            catch (err) {
+                lastErr = err;
+                try {
+                    await this.client.destroy();
+                }
+                catch { }
+                if (attempt >= 5)
+                    break;
+                await sleep(Math.min(1000 * attempt, 5_000));
+            }
+        }
+        throw new Error(`Discord connect failed: ${describeError(lastErr)}`);
+    }
+    async listen() {
+        this.running = true;
+        this.client.on(Events.MessageCreate, (msg) => {
+            void this.dispatchMessage(msg).catch(error => {
+                this.emitError(error instanceof Error ? error : new Error(describeError(error)));
+            });
+        });
+        this.client.on(Events.Error, err => {
+            this.emitError(err instanceof Error ? err : new Error(describeError(err)));
+        });
+        this.client.on(Events.ShardDisconnect, () => {
+            this.debug('[gateway] shard disconnected — discord.js will auto-reconnect');
+        });
+        if (!this.running)
+            return;
+        await new Promise(resolve => {
+            this.listenResolve = resolve;
+            if (!this.running)
+                resolve();
+        });
+    }
+    disconnect() {
+        this.running = false;
+        try {
+            void this.client?.destroy();
+        }
+        catch { }
+        this.listenResolve?.();
+        this.listenResolve = null;
+    }
+    // ========================================================================
+    // Outgoing primitives
+    // ========================================================================
+    async send(chatId, text, opts = {}) {
+        const channelId = String(chatId);
+        const channel = await this.fetchTextChannel(channelId);
+        const chunks = splitText((text || '').trim() || '(empty)', DISCORD_MAX);
+        let lastId = null;
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const payload = { content: chunk };
+            if (opts.replyTo)
+                payload.reply = { messageReference: String(opts.replyTo), failIfNotExists: false };
+            const sent = await channel.send(payload);
+            lastId = sent.id;
+        }
+        return lastId;
+    }
+    async editMessage(chatId, msgId, text, _opts) {
+        const trimmed = String(text);
+        if (!trimmed.trim())
+            return;
+        const channel = await this.fetchTextChannel(String(chatId));
+        const truncated = trimmed.length > DISCORD_MAX ? trimmed.slice(0, DISCORD_MAX) + '\n…(truncated)' : trimmed;
+        try {
+            const message = await channel.messages.fetch(String(msgId));
+            await message.edit({ content: truncated });
+        }
+        catch (err) {
+            const detail = describeError(err).toLowerCase();
+            if (detail.includes('unknown message') || detail.includes('cannot edit'))
+                return;
+            throw err;
+        }
+    }
+    async deleteMessage(chatId, msgId) {
+        try {
+            const channel = await this.fetchTextChannel(String(chatId));
+            const message = await channel.messages.fetch(String(msgId));
+            await message.delete();
+        }
+        catch { }
+    }
+    async sendTyping(chatId, _opts) {
+        try {
+            const channel = await this.fetchTextChannel(String(chatId));
+            if (typeof channel.sendTyping === 'function') {
+                await channel.sendTyping();
+            }
+        }
+        catch { }
+    }
+    // ========================================================================
+    // Internal dispatch
+    // ========================================================================
+    async dispatchMessage(msg) {
+        if (msg.author?.bot)
+            return;
+        if (this.botUserId && msg.author?.id === this.botUserId)
+            return;
+        const channelId = msg.channelId;
+        const messageId = msg.id;
+        const userId = msg.author?.id || '';
+        if (!channelId || !messageId || !userId)
+            return;
+        if (!this.isAllowed(channelId))
+            return;
+        this.knownChats.add(channelId);
+        const isDm = msg.channel?.isDMBased?.() ?? false;
+        const mentioned = this.botUserId ? msg.mentions?.users?.has(this.botUserId) === true : false;
+        if (!isDm && this.requireMention && !mentioned)
+            return;
+        let cleaned = String(msg.content || '');
+        if (this.botUserId) {
+            cleaned = cleaned.replace(new RegExp(`<@!?${this.botUserId}>`, 'g'), '').trim();
+        }
+        const ctx = {
+            chatId: channelId,
+            messageId,
+            from: { userId, username: msg.author?.username || undefined },
+            reply: (text, opts) => this.send(channelId, text, { ...opts, replyTo: opts?.replyTo ?? messageId }),
+            editReply: (replyMsgId, text, opts) => this.editMessage(channelId, replyMsgId, text, opts),
+            channel: this,
+            raw: msg,
+        };
+        const payload = { text: cleaned, files: [] };
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(payload, ctx);
+            }
+            catch (error) {
+                this.emitError(error instanceof Error ? error : new Error(describeError(error)));
+            }
+        }
+    }
+    isAllowed(chatId) {
+        if (!this.allowedChatIds?.size)
+            return true;
+        return this.allowedChatIds.has(chatId);
+    }
+    async fetchTextChannel(channelId) {
+        const cached = this.client.channels.cache.get(channelId);
+        if (cached && 'send' in cached)
+            return cached;
+        const fetched = await this.client.channels.fetch(channelId);
+        if (!fetched || !('send' in fetched)) {
+            throw new Error(`Discord channel ${channelId} is not text-based`);
+        }
+        return fetched;
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error);
+            }
+            catch { }
+        }
+    }
+    debug(msg) { this.log(msg, 'debug'); }
+    log(msg, level = 'info') { writeScopedLog('discord', msg, { level }); }
+}