@shuyhere/takotako 0.0.1

package/dist/channels/discord.js

@@ -0,0 +1,664 @@
+/**
+ * Discord channel adapter.
+ *
+ * Connects to Discord via bot token using discord.js.
+ * Listens for messages, converts them to InboundMessage,
+ * and sends responses back to the appropriate channel.
+ */
+import { Client, GatewayIntentBits, Events, ChannelType, Partials, REST, Routes, } from 'discord.js';
+import { withRetry, DISCORD_RETRY } from './retry.js';
+import { scanSecrets } from '../core/security.js';
+const MAX_DISCORD_MESSAGE_LENGTH = 2000;
+/** Mask a name for privacy: keep first 2 and last 3 chars, replace middle with ***. */
+function maskName(name) {
+    if (name.length <= 5)
+        return name[0] + '***' + name[name.length - 1];
+    return name.slice(0, 2) + '***' + name.slice(-3);
+}
+export class DiscordChannel {
+    id = 'discord';
+    agentId;
+    token;
+    guilds;
+    client = null;
+    handlers = [];
+    slashCommandHandler = null;
+    interactiveHandlers = new Map();
+    modalHandlers = [];
+    selectMenuHandlers = [];
+    buttonHandlers = [];
+    nativeCommands = [];
+    previousSkillNames;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    reconnectDelay = 5000;
+    constructor(opts) {
+        this.token = opts.token;
+        this.guilds = opts.guilds ? new Set(opts.guilds) : undefined;
+    }
+    async connect() {
+        this.client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.DirectMessages,
+                GatewayIntentBits.MessageContent,
+            ],
+            // Partials required for DM support — discord.js won't emit
+            // MessageCreate for DMs without Channel + Message partials
+            partials: [Partials.Channel, Partials.Message],
+        });
+        this.client.on(Events.MessageCreate, async (message) => {
+            if (message.author.bot)
+                return;
+            if (this.guilds && message.guild && !this.guilds.has(message.guild.id))
+                return;
+            // ─── Mention-based routing ─────────────────────────────────────
+            // ALL bots (main and agent) require @mention in guild channels.
+            // DMs always go through. This prevents agent bots from responding
+            // to messages not addressed to them in shared servers.
+            const myBotId = this.client?.user?.id;
+            if (myBotId && message.guild) {
+                if (!message.mentions.has(myBotId)) {
+                    return; // Not mentioned — ignore
+                }
+            }
+            const inbound = this.convertInbound(message);
+            for (const handler of this.handlers) {
+                try {
+                    await handler(inbound);
+                }
+                catch (err) {
+                    console.error('[discord] Handler error:', err instanceof Error ? err.message : err);
+                }
+            }
+        });
+        // Handle native slash command interactions
+        this.client.on(Events.InteractionCreate, async (interaction) => {
+            if (!interaction.isChatInputCommand())
+                return;
+            const cmdInteraction = interaction;
+            // Check interactive handlers first (model picker, etc.)
+            const interactiveHandler = this.interactiveHandlers.get(cmdInteraction.commandName);
+            if (interactiveHandler) {
+                try {
+                    const handled = await interactiveHandler(cmdInteraction);
+                    if (handled)
+                        return;
+                }
+                catch (err) {
+                    console.error('[discord] Interactive handler error:', err instanceof Error ? err.message : err);
+                    if (!cmdInteraction.replied && !cmdInteraction.deferred) {
+                        await cmdInteraction.reply({ content: 'Something went wrong.', ephemeral: true });
+                    }
+                    return;
+                }
+            }
+            // Fall through to text-based slash command handler
+            if (!this.slashCommandHandler) {
+                await cmdInteraction.reply({ content: 'Commands not ready yet.', ephemeral: true });
+                return;
+            }
+            // Defer reply in case handler takes a moment
+            await cmdInteraction.deferReply();
+            const author = {
+                id: cmdInteraction.user.id,
+                name: cmdInteraction.user.displayName || cmdInteraction.user.username,
+                meta: {
+                    discriminator: cmdInteraction.user.discriminator,
+                    guildId: cmdInteraction.guild?.id,
+                    guildName: cmdInteraction.guild?.name,
+                },
+            };
+            const channelId = cmdInteraction.channelId;
+            const result = await this.slashCommandHandler(cmdInteraction.commandName, channelId, author, cmdInteraction.guild?.id);
+            await cmdInteraction.editReply({ content: result || 'Done.' });
+        });
+        // Handle modal submit interactions
+        this.client.on(Events.InteractionCreate, async (interaction) => {
+            if (!interaction.isModalSubmit())
+                return;
+            for (const handler of this.modalHandlers) {
+                try {
+                    const handled = await handler(interaction);
+                    if (handled)
+                        return;
+                }
+                catch (err) {
+                    console.error('[discord] Modal handler error:', err instanceof Error ? err.message : err);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({ content: 'Something went wrong.', flags: 64 }).catch(() => { });
+                    }
+                    return;
+                }
+            }
+        });
+        // Handle string select menu interactions
+        this.client.on(Events.InteractionCreate, async (interaction) => {
+            if (!interaction.isStringSelectMenu())
+                return;
+            for (const handler of this.selectMenuHandlers) {
+                try {
+                    const handled = await handler(interaction);
+                    if (handled)
+                        return;
+                }
+                catch (err) {
+                    console.error('[discord] Select menu handler error:', err instanceof Error ? err.message : err);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({ content: 'Something went wrong.', flags: 64 }).catch(() => { });
+                    }
+                    return;
+                }
+            }
+        });
+        // Handle button interactions
+        this.client.on(Events.InteractionCreate, async (interaction) => {
+            if (!interaction.isButton())
+                return;
+            for (const handler of this.buttonHandlers) {
+                try {
+                    const handled = await handler(interaction);
+                    if (handled)
+                        return;
+                }
+                catch (err) {
+                    console.error('[discord] Button handler error:', err instanceof Error ? err.message : err);
+                    if (!interaction.replied && !interaction.deferred) {
+                        await interaction.reply({ content: 'Something went wrong.', flags: 64 }).catch(() => { });
+                    }
+                    return;
+                }
+            }
+        });
+        this.client.on(Events.ClientReady, async (c) => {
+            this.reconnectAttempts = 0;
+            console.log(`[discord] ✦ Connected as ${maskName(c.user.tag)}`);
+            // Register native slash commands per guild (instant, no 1-hour delay)
+            if (this.nativeCommands.length > 0) {
+                await this.registerSlashCommands(c.user.id);
+            }
+        });
+        // When bot joins a new guild, introduce itself
+        this.client.on(Events.GuildCreate, async (guild) => {
+            console.log(`[discord] Joined guild: ${guild.name} (${guild.id})`);
+            const agentName = this.agentId ?? 'Tako';
+            const intro = [
+                `👋 **${agentName}** just joined **${guild.name}**!`,
+                '',
+                `I'm an AI assistant powered by Tako 🐙. Here's how to talk to me:`,
+                `• **Mention me** — \`@${this.client?.user?.displayName ?? agentName}\` followed by your message`,
+                `• **DM me** — send a direct message for private conversations`,
+                '',
+                `**Commands:**`,
+                `• \`/help\` — see available commands`,
+                `• \`/status\` — check my current status`,
+                `• \`/model\` — view or switch the AI model`,
+                `• \`/new\` — start a fresh conversation`,
+                '',
+                `Ready to help! 🐙`,
+            ].join('\n');
+            // Send to system channel or first text channel
+            const target = guild.systemChannel
+                ?? guild.channels.cache.find((ch) => ch.type === ChannelType.GuildText &&
+                    ch.permissionsFor(guild.members.me)?.has('SendMessages') === true);
+            if (target && 'send' in target) {
+                try {
+                    await target.send(intro);
+                }
+                catch (err) {
+                    console.error(`[discord] Failed to send intro to ${guild.name}:`, err.message);
+                }
+            }
+        });
+        this.client.on(Events.Error, (err) => {
+            console.error('[discord] Client error:', err.message);
+        });
+        this.client.on(Events.ShardDisconnect, () => {
+            console.warn('[discord] Disconnected, will attempt reconnect...');
+            this.attemptReconnect();
+        });
+        await this.client.login(this.token);
+    }
+    async disconnect() {
+        if (this.client) {
+            this.client.removeAllListeners();
+            await this.client.destroy();
+            this.client = null;
+            console.log('[discord] Disconnected');
+        }
+    }
+    async send(msg) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(msg.target);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error(`[discord] Cannot send to channel ${msg.target}`);
+        }
+        // Scan for secrets before sending
+        const safeContent = scanSecrets(msg.content);
+        const sendable = channel;
+        await this.sendChunks(sendable, safeContent, msg.replyTo);
+    }
+    /** Send message chunks to a text-based channel with retry. */
+    async sendChunks(channel, content, replyTo) {
+        const chunks = this.splitMessage(content);
+        for (let i = 0; i < chunks.length; i++) {
+            const opts = {
+                content: chunks[i],
+                ...(i === 0 && replyTo ? { reply: { messageReference: replyTo } } : {}),
+            };
+            await withRetry(() => channel.send(opts), DISCORD_RETRY, `send chunk ${i + 1}/${chunks.length}`);
+        }
+    }
+    async sendAndGetId(msg) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(msg.target);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error(`[discord] Cannot send to channel ${msg.target}`);
+        }
+        const sendable = channel;
+        const sent = await withRetry(() => sendable.send({
+            content: msg.content,
+            ...(msg.replyTo ? { reply: { messageReference: msg.replyTo } } : {}),
+        }), DISCORD_RETRY, 'sendAndGetId');
+        return sent.id;
+    }
+    async editMessage(chatId, messageId, content) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error(`[discord] Cannot edit in channel ${chatId}`);
+        }
+        const textChannel = channel;
+        const message = await textChannel.messages.fetch(messageId);
+        await withRetry(() => message.edit({ content }), DISCORD_RETRY, 'editMessage');
+    }
+    onMessage(handler) {
+        this.handlers.push(handler);
+    }
+    convertInbound(message) {
+        return {
+            id: message.id,
+            channelId: `discord:${message.channelId}`,
+            author: {
+                id: message.author.id,
+                name: message.author.displayName || message.author.username,
+                meta: {
+                    discriminator: message.author.discriminator,
+                    guildId: message.guild?.id,
+                    guildName: message.guild?.name,
+                },
+            },
+            content: message.content,
+            attachments: message.attachments.map((a) => ({
+                type: (a.contentType?.startsWith('image/') ? 'image'
+                    : a.contentType?.startsWith('audio/') ? 'audio'
+                        : a.contentType?.startsWith('video/') ? 'video'
+                            : 'file'),
+                url: a.url,
+                filename: a.name ?? undefined,
+                mimeType: a.contentType ?? undefined,
+            })),
+            timestamp: message.createdAt.toISOString(),
+            raw: message,
+        };
+    }
+    splitMessage(content) {
+        if (content.length <= MAX_DISCORD_MESSAGE_LENGTH)
+            return [content];
+        const chunks = [];
+        let remaining = content;
+        while (remaining.length > 0) {
+            if (remaining.length <= MAX_DISCORD_MESSAGE_LENGTH) {
+                chunks.push(remaining);
+                break;
+            }
+            let splitAt = remaining.lastIndexOf('\n', MAX_DISCORD_MESSAGE_LENGTH);
+            if (splitAt === -1 || splitAt < MAX_DISCORD_MESSAGE_LENGTH / 2) {
+                splitAt = remaining.lastIndexOf(' ', MAX_DISCORD_MESSAGE_LENGTH);
+            }
+            if (splitAt === -1 || splitAt < MAX_DISCORD_MESSAGE_LENGTH / 2) {
+                splitAt = MAX_DISCORD_MESSAGE_LENGTH;
+            }
+            chunks.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt).trimStart();
+        }
+        return chunks;
+    }
+    /** Get the underlying discord.js Client (for advanced operations). */
+    getClient() {
+        return this.client;
+    }
+    /** Create a text channel in a guild. */
+    async createChannel(guildId, name, opts) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const guild = await this.client.guilds.fetch(guildId);
+        const createOpts = {
+            name,
+            type: ChannelType.GuildText,
+            ...(opts?.topic ? { topic: opts.topic } : {}),
+            ...(opts?.parentId ? { parent: opts.parentId } : {}),
+        };
+        const channel = await guild.channels.create(createOpts);
+        return { id: channel.id, name: channel.name };
+    }
+    /** Broadcast a system message to all guild system/general channels. */
+    async broadcast(text) {
+        if (!this.client)
+            return;
+        try {
+            const guilds = this.guilds
+                ? [...this.guilds].map(id => this.client.guilds.cache.get(id)).filter(Boolean)
+                : [...this.client.guilds.cache.values()];
+            for (const guild of guilds) {
+                if (!guild)
+                    continue;
+                // Find the first text channel the bot can send to
+                const target = guild.systemChannel
+                    ?? guild.channels.cache.find((ch) => ch.type === ChannelType.GuildText &&
+                        ch.permissionsFor(guild.members.me)?.has('SendMessages') === true);
+                if (target && 'send' in target) {
+                    await target.send(text);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[discord] Broadcast failed:', err.message);
+        }
+    }
+    /** Delete a channel by ID. */
+    async deleteChannel(channelId) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel)
+            throw new Error(`[discord] Channel not found: ${channelId}`);
+        if ('delete' in channel && typeof channel.delete === 'function') {
+            await channel.delete();
+        }
+        else {
+            throw new Error(`[discord] Cannot delete channel ${channelId}`);
+        }
+    }
+    /** Edit a channel (name, topic). */
+    async editChannel(channelId, opts) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel)
+            throw new Error(`[discord] Channel not found: ${channelId}`);
+        if ('edit' in channel && typeof channel.edit === 'function') {
+            await channel.edit(opts);
+        }
+        else {
+            throw new Error(`[discord] Cannot edit channel ${channelId}`);
+        }
+    }
+    /** Send a message to a specific channel by ID. */
+    async sendToChannel(channelId, content) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error(`[discord] Cannot send to channel ${channelId}`);
+        }
+        const sendable = channel;
+        const chunks = this.splitMessage(content);
+        let lastMessageId = '';
+        for (const chunk of chunks) {
+            const msg = await sendable.send({ content: chunk });
+            lastMessageId = msg.id;
+        }
+        return lastMessageId;
+    }
+    /** Create a thread in a channel. */
+    async createThread(channelId, name, opts) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error(`[discord] Cannot create thread in ${channelId}`);
+        }
+        const textChannel = channel;
+        if (opts?.messageId) {
+            const message = await textChannel.messages.fetch(opts.messageId);
+            const thread = await message.startThread({ name });
+            return { id: thread.id, name: thread.name };
+        }
+        else {
+            const thread = await textChannel.threads.create({ name });
+            return { id: thread.id, name: thread.name };
+        }
+    }
+    /** React to a message with an emoji. */
+    async react(channelId, messageId, emoji) {
+        if (!this.client)
+            throw new Error('[discord] Not connected');
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error(`[discord] Cannot react in channel ${channelId}`);
+        }
+        const textChannel = channel;
+        const message = await textChannel.messages.fetch(messageId);
+        await message.react(emoji);
+    }
+    async sendTyping(channelId) {
+        if (!this.client)
+            return;
+        try {
+            const channel = await this.client.channels.fetch(channelId);
+            if (channel && channel.isTextBased() && 'sendTyping' in channel) {
+                await channel.sendTyping();
+            }
+        }
+        catch (err) {
+            console.error('[discord] sendTyping error:', err instanceof Error ? err.message : err);
+        }
+    }
+    async addReaction(channelId, messageId, emoji) {
+        if (!this.client)
+            return;
+        try {
+            const channel = await this.client.channels.fetch(channelId);
+            if (channel && channel.isTextBased()) {
+                const message = await channel.messages.fetch(messageId);
+                await message.react(emoji);
+            }
+        }
+        catch (err) {
+            console.error('[discord] addReaction error:', err instanceof Error ? err.message : err);
+        }
+    }
+    async removeReaction(channelId, messageId, emoji) {
+        if (!this.client)
+            return;
+        try {
+            const channel = await this.client.channels.fetch(channelId);
+            if (channel && channel.isTextBased()) {
+                const message = await channel.messages.fetch(messageId);
+                const botUser = this.client.user;
+                if (botUser) {
+                    await message.reactions.resolve(emoji)?.users.remove(botUser.id);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[discord] removeReaction error:', err instanceof Error ? err.message : err);
+        }
+    }
+    /** Set native slash commands and their handler. Call before connect(). */
+    setSlashCommands(commands, handler) {
+        this.nativeCommands = commands;
+        this.slashCommandHandler = handler;
+    }
+    /**
+     * Register an interactive handler for a specific slash command.
+     * Interactive handlers receive the raw ChatInputCommandInteraction and can
+     * reply with embeds, components, and collectors. They run before the
+     * text-based handler; if they return true the interaction is consumed.
+     */
+    setInteractiveHandler(commandName, handler) {
+        this.interactiveHandlers.set(commandName, handler);
+    }
+    /**
+     * Register skill commands as Discord slash commands.
+     * Merges skill specs with existing native commands, re-registers with Discord API.
+     * Call after connect() when skills are loaded.
+     */
+    async registerSkillCommands(specs, handler) {
+        // Rebuild command list: keep non-skill native commands, then add all skill specs
+        // This ensures no duplicates accumulate across hot-reloads
+        const skillNames = new Set(specs.map((s) => s.name));
+        const coreCommands = this.nativeCommands.filter((c) => !skillNames.has(c.name) && !this.previousSkillNames?.has(c.name));
+        const skillCommands = specs.map((s) => ({ name: s.name, description: s.description }));
+        // Deduplicate: if a core command has the same name as a skill, skill wins
+        const coreFiltered = coreCommands.filter((c) => !skillNames.has(c.name));
+        this.nativeCommands = [...coreFiltered, ...skillCommands];
+        this.previousSkillNames = skillNames;
+        this.slashCommandHandler = handler;
+        // Re-register with Discord API if already connected
+        const clientId = this.client?.user?.id;
+        if (clientId) {
+            await this.registerSlashCommands(clientId);
+        }
+    }
+    /** Register a handler for modal submit interactions. */
+    onModalSubmit(handler) {
+        this.modalHandlers.push(handler);
+    }
+    /** Register a handler for string select menu interactions. */
+    onSelectMenu(handler) {
+        this.selectMenuHandlers.push(handler);
+    }
+    /** Register a handler for button interactions. */
+    onButton(handler) {
+        this.buttonHandlers.push(handler);
+    }
+    /** Register slash commands with Discord API per guild (instant update). */
+    async registerSlashCommands(clientId) {
+        const rest = new REST({ version: '10' }).setToken(this.token);
+        // Deduplicate by command name (last wins) to avoid accidental duplicates
+        const deduped = new Map();
+        for (const cmd of this.nativeCommands) {
+            deduped.set(cmd.name, { name: cmd.name, description: cmd.description });
+        }
+        const body = Array.from(deduped.values());
+        const MAX_SLASH_COMMANDS = 25;
+        const registerBody = body.length > MAX_SLASH_COMMANDS
+            ? body.slice(0, MAX_SLASH_COMMANDS)
+            : body;
+        if (body.length > MAX_SLASH_COMMANDS) {
+            console.warn(`[discord] Slash command limit is ${MAX_SLASH_COMMANDS}; truncating ${body.length} -> ${registerBody.length}`);
+        }
+        if (this.guilds && this.guilds.size > 0) {
+            // Register per-guild for instant updates
+            for (const guildId of this.guilds) {
+                try {
+                    await rest.put(Routes.applicationGuildCommands(clientId, guildId), { body: registerBody });
+                    console.log(`[discord] ✦ Registered ${registerBody.length} slash commands for guild ${guildId}`);
+                }
+                catch (err) {
+                    console.error(`[discord] Failed to register commands for guild ${guildId}:`, err instanceof Error ? err.message : err);
+                }
+            }
+            // Keep global commands in sync so DMs also get slash commands
+            // (global propagation can take longer than guild commands)
+            try {
+                await rest.put(Routes.applicationCommands(clientId), { body: registerBody });
+                console.log(`[discord] ✦ Synced ${registerBody.length} global slash commands for DM support`);
+            }
+            catch (err) {
+                console.warn('[discord] Could not sync global slash commands:', err instanceof Error ? err.message : err);
+            }
+        }
+        else {
+            // No guild whitelist — discover guilds from cache and register per-guild
+            const client = this.client;
+            if (client) {
+                const guilds = client.guilds.cache;
+                if (guilds.size > 0) {
+                    for (const [guildId] of guilds) {
+                        try {
+                            await rest.put(Routes.applicationGuildCommands(clientId, guildId), { body: registerBody });
+                            console.log(`[discord] ✦ Registered ${registerBody.length} slash commands for guild ${guildId}`);
+                        }
+                        catch (err) {
+                            console.error(`[discord] Failed to register commands for guild ${guildId}:`, err instanceof Error ? err.message : err);
+                        }
+                    }
+                    // Keep global commands in sync so DMs also get slash commands
+                    // (global propagation can take longer than guild commands)
+                    try {
+                        await rest.put(Routes.applicationCommands(clientId), { body: registerBody });
+                        console.log(`[discord] ✦ Synced ${registerBody.length} global slash commands for DM support`);
+                    }
+                    catch (err) {
+                        console.warn('[discord] Could not sync global slash commands:', err instanceof Error ? err.message : err);
+                    }
+                }
+                else {
+                    // Fallback: register globally (takes up to 1 hour to propagate)
+                    try {
+                        await rest.put(Routes.applicationCommands(clientId), { body: registerBody });
+                        console.log(`[discord] ✦ Registered ${registerBody.length} slash commands globally`);
+                    }
+                    catch (err) {
+                        console.error('[discord] Failed to register global commands:', err instanceof Error ? err.message : err);
+                    }
+                }
+            }
+        }
+    }
+    /** Archive a Discord thread by ID. */
+    async archiveThread(threadId) {
+        if (!this.client)
+            return;
+        try {
+            const channel = await this.client.channels.fetch(threadId);
+            if (channel?.isThread()) {
+                await channel.setArchived(true);
+            }
+        }
+        catch (err) {
+            console.error('[discord] archiveThread error:', err instanceof Error ? err.message : err);
+        }
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('[discord] Max reconnection attempts reached — scheduling final retry in 5 minutes');
+            setTimeout(async () => {
+                try {
+                    if (this.client) {
+                        this.reconnectAttempts = 0;
+                        await this.client.login(this.token);
+                        console.log('[discord] Final retry succeeded');
+                    }
+                }
+                catch (err) {
+                    console.error('[discord] Final reconnection failed:', err instanceof Error ? err.message : err);
+                    console.error('[discord] CRITICAL: Discord channel is offline. Process will continue for other channels.');
+                }
+            }, 5 * 60 * 1000);
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        console.log(`[discord] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        setTimeout(async () => {
+            try {
+                if (this.client) {
+                    await this.client.login(this.token);
+                }
+            }
+            catch (err) {
+                console.error('[discord] Reconnection failed:', err instanceof Error ? err.message : err);
+                this.attemptReconnect();
+            }
+        }, delay);
+    }
+}
+//# sourceMappingURL=discord.js.map