@waifucave/discord-waifus 1.5.154

package/dist/discord/client.js

@@ -0,0 +1,1196 @@
+import { ApplicationCommandOptionType, Client, Events, GatewayIntentBits, MessageFlags, Partials, PermissionFlagsBits } from "discord.js";
+import { buildNormalizedDiscordContext } from "./contextBuilder.js";
+import { unresolvedMentionIdsByType } from "./memberCache.js";
+import { denormalizeModelContentForDiscord } from "./normalization.js";
+export class DiscordJsGateway {
+    options;
+    clients = new Map();
+    listeners = new Set();
+    reviewListeners = new Set();
+    clearListeners = new Set();
+    runListeners = new Set();
+    runWaifuAutocompleteListeners = new Set();
+    stopListeners = new Set();
+    memoriesListeners = new Set();
+    printListeners = new Set();
+    printWaifuAutocompleteListeners = new Set();
+    debugListeners = new Set();
+    recentMentionRefreshes = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        const bots = [this.options.orchestrator, ...(this.options.waifus ?? [])].filter((bot) => Boolean(bot.token));
+        await Promise.all(bots.map(async (bot) => {
+            const client = new Client({
+                intents: [
+                    GatewayIntentBits.Guilds,
+                    GatewayIntentBits.GuildMessages,
+                    GatewayIntentBits.GuildMessageReactions,
+                    GatewayIntentBits.MessageContent
+                ],
+                partials: [Partials.Channel, Partials.Message, Partials.Reaction]
+            });
+            this.attachClientRuntimeHandlers(client, bot.id);
+            if (bot.id === this.options.orchestrator.id) {
+                client.on("messageCreate", (message) => {
+                    if (!message.guildId)
+                        return;
+                    const event = {
+                        guildId: message.guildId,
+                        channelId: message.channelId,
+                        messageId: message.id,
+                        authorId: message.author.id,
+                        authorDisplayName: message.member?.displayName ?? message.author.globalName ?? message.author.username,
+                        authorBot: message.author.bot
+                    };
+                    this.options.logger?.info("Discord gateway received message", {
+                        guildId: event.guildId,
+                        channelId: event.channelId,
+                        messageId: event.messageId,
+                        authorBot: event.authorBot
+                    });
+                    for (const listener of this.listeners) {
+                        this.dispatchListener("Discord message listener failed", listener, event, {
+                            guildId: event.guildId,
+                            channelId: event.channelId,
+                            messageId: event.messageId
+                        });
+                    }
+                });
+                client.on(Events.InteractionCreate, (interaction) => {
+                    if (interaction.isAutocomplete()) {
+                        if (interaction.commandName === RUN_COMMAND_NAME) {
+                            this.runBackground("Discord run autocomplete interaction failed", {
+                                commandName: interaction.commandName,
+                                guildId: interaction.guildId,
+                                channelId: interaction.channelId
+                            }, () => this.handleRunAutocompleteInteraction(interaction));
+                        }
+                        else if (interaction.commandName === PRINT_COMMAND_NAME) {
+                            this.runBackground("Discord print autocomplete interaction failed", {
+                                commandName: interaction.commandName,
+                                guildId: interaction.guildId,
+                                channelId: interaction.channelId
+                            }, () => this.handlePrintAutocompleteInteraction(interaction));
+                        }
+                        return;
+                    }
+                    if (!interaction.isChatInputCommand())
+                        return;
+                    if (interaction.commandName === REVIEW_COMMAND_NAME) {
+                        this.runBackground("Discord review interaction failed", interactionLogContext(interaction), () => this.handleReviewInteraction(interaction));
+                    }
+                    else if (interaction.commandName === CLEAR_COMMAND_NAME) {
+                        this.runBackground("Discord clear interaction failed", interactionLogContext(interaction), () => this.handleClearInteraction(interaction));
+                    }
+                    else if (interaction.commandName === RUN_COMMAND_NAME) {
+                        this.runBackground("Discord run interaction failed", interactionLogContext(interaction), () => this.handleRunInteraction(interaction));
+                    }
+                    else if (interaction.commandName === STOP_COMMAND_NAME) {
+                        this.runBackground("Discord stop interaction failed", interactionLogContext(interaction), () => this.handleStopInteraction(interaction));
+                    }
+                    else if (interaction.commandName === MEMORIES_COMMAND_NAME) {
+                        this.runBackground("Discord memories interaction failed", interactionLogContext(interaction), () => this.handleMemoriesInteraction(interaction));
+                    }
+                    else if (interaction.commandName === PRINT_COMMAND_NAME) {
+                        this.runBackground("Discord print interaction failed", interactionLogContext(interaction), () => this.handlePrintInteraction(interaction));
+                    }
+                    else if (interaction.commandName === DEBUG_COMMAND_NAME) {
+                        this.runBackground("Discord debug interaction failed", interactionLogContext(interaction), () => this.handleDebugInteraction(interaction));
+                    }
+                });
+            }
+            await loginAndWaitUntilReady(client, bot.token);
+            this.clients.set(bot.id, client);
+            if (bot.id === this.options.orchestrator.id) {
+                await registerOrchestratorCommands(client, this.options.logger);
+            }
+            this.options.logger?.info("Discord bot connected", {
+                botId: bot.id,
+                displayName: bot.displayName,
+                kind: bot.id === this.options.orchestrator.id ? "orchestrator" : "waifu"
+            });
+        }));
+        return {
+            connected: this.clients.size > 0,
+            orchestratorConnected: this.clients.has(this.options.orchestrator.id),
+            waifuBotCount: (this.options.waifus ?? []).filter((bot) => this.clients.has(bot.id)).length,
+            warnings: this.clients.size > 0
+                ? []
+                : ["No enabled Discord bot tokens are configured."]
+        };
+    }
+    async disconnect() {
+        await Promise.all([...this.clients.values()].map((client) => client.destroy()));
+        this.clients.clear();
+    }
+    onMessage(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    onReviewCommand(listener) {
+        this.reviewListeners.add(listener);
+        return () => this.reviewListeners.delete(listener);
+    }
+    onClearCommand(listener) {
+        this.clearListeners.add(listener);
+        return () => this.clearListeners.delete(listener);
+    }
+    onRunCommand(listener) {
+        this.runListeners.add(listener);
+        return () => this.runListeners.delete(listener);
+    }
+    onRunWaifuAutocomplete(listener) {
+        this.runWaifuAutocompleteListeners.add(listener);
+        return () => this.runWaifuAutocompleteListeners.delete(listener);
+    }
+    onStopCommand(listener) {
+        this.stopListeners.add(listener);
+        return () => this.stopListeners.delete(listener);
+    }
+    onMemoriesCommand(listener) {
+        this.memoriesListeners.add(listener);
+        return () => this.memoriesListeners.delete(listener);
+    }
+    onPrintCommand(listener) {
+        this.printListeners.add(listener);
+        return () => this.printListeners.delete(listener);
+    }
+    onPrintWaifuAutocomplete(listener) {
+        this.printWaifuAutocompleteListeners.add(listener);
+        return () => this.printWaifuAutocompleteListeners.delete(listener);
+    }
+    onDebugCommand(listener) {
+        this.debugListeners.add(listener);
+        return () => this.debugListeners.delete(listener);
+    }
+    async listGuilds() {
+        const client = this.orchestratorClient();
+        await client.guilds.fetch();
+        return client.guilds.cache.map((guild) => ({
+            guildId: guild.id,
+            name: guild.name
+        }));
+    }
+    async fetchChannelMetadata(input) {
+        const client = this.orchestratorClient();
+        const [guild, channel] = await Promise.all([
+            client.guilds.fetch(input.guildId),
+            client.channels.fetch(input.channelId)
+        ]);
+        if (!channel) {
+            throw new Error(`Discord channel ${input.channelId} is not accessible to the orchestrator bot.`);
+        }
+        const channelGuildId = "guildId" in channel && typeof channel.guildId === "string" ? channel.guildId : undefined;
+        if (channelGuildId && channelGuildId !== input.guildId) {
+            throw new Error(`Discord channel ${input.channelId} does not belong to guild ${input.guildId}.`);
+        }
+        return {
+            guildId: guild.id,
+            guildName: guild.name,
+            channelId: channel.id,
+            channelName: "name" in channel && typeof channel.name === "string" ? channel.name : undefined
+        };
+    }
+    async fetchFreshContext(input) {
+        throwIfAborted(input.signal);
+        const client = this.orchestratorClient();
+        let cache = await this.cacheForGuild(input.guildId);
+        const channel = await client.channels.fetch(input.channelId);
+        if (!channel || !("messages" in channel)) {
+            return [];
+        }
+        const collection = await channel.messages.fetch({ limit: input.limit });
+        const rawMessages = [...collection.values()].sort((a, b) => a.createdTimestamp - b.createdTimestamp);
+        const mentionedRoles = uniqueMentionedRoles(rawMessages, cache.roles ?? []);
+        const roleCacheForResolution = mergeRoleCaches(cache.roles ?? [], mentionedRoles);
+        const missingMentionIds = unresolvedMentionIdsByType(rawMessages.map((message) => message.content), cache.members ?? [], roleCacheForResolution);
+        if ((missingMentionIds.userIds.length > 0 || missingMentionIds.roleIds.length > 0) && this.shouldRefreshMentions(input.guildId)) {
+            this.options.logger?.info("Refreshing Discord mention caches for unresolved mentions", {
+                guildId: input.guildId,
+                channelId: input.channelId,
+                userMentionCount: missingMentionIds.userIds.length,
+                roleMentionCount: missingMentionIds.roleIds.length,
+                mentionIds: [...missingMentionIds.userIds, ...missingMentionIds.roleIds].slice(0, 5)
+            });
+            try {
+                const [refreshedMembers, refreshedRoles] = await Promise.all([
+                    missingMentionIds.userIds.length > 0 ? this.options.refreshMembersForGuild?.(input.guildId) : undefined,
+                    missingMentionIds.roleIds.length > 0 ? this.options.refreshRolesForGuild?.(input.guildId) : undefined
+                ]);
+                cache = {
+                    ...cache,
+                    ...refreshedMembers,
+                    ...refreshedRoles
+                };
+            }
+            catch (error) {
+                this.options.logger?.warn("Discord mention cache refresh for unresolved mentions failed", {
+                    guildId: input.guildId,
+                    channelId: input.channelId,
+                    message: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        const messages = await Promise.all(rawMessages.map(async (message) => {
+            const [replyTo, reactions] = await Promise.all([
+                message.reference?.messageId
+                    ? resolveReplyReference(message).catch(() => ({ messageId: message.reference?.messageId ?? "" }))
+                    : undefined,
+                summarizeReactions(message.reactions.cache.values(), cache)
+            ]);
+            return {
+                id: message.id,
+                channelId: message.channelId,
+                guildId: message.guildId ?? input.guildId,
+                authorId: message.author.id,
+                authorName: message.author.username,
+                authorDisplayName: message.member?.displayName ?? message.author.globalName ?? message.author.username,
+                authorBot: message.author.bot,
+                content: message.content,
+                createdAt: message.createdAt,
+                images: collectImageAttachments(message),
+                replyTo,
+                reactions
+            };
+        }));
+        return buildNormalizedDiscordContext(messages, { ...cache, roles: mergeRoleCaches(cache.roles ?? [], mentionedRoles) }, {
+            orchestratorAuthorIds: botAuthorIds([this.options.orchestrator]),
+            waifuAuthorIds: botAuthorIds(this.options.waifus ?? [])
+        }).messages;
+    }
+    async sendWaifuMessage(input) {
+        const client = input.senderBotId ? this.clients.get(input.senderBotId) : this.orchestratorClient();
+        if (!client) {
+            throw new Error(input.senderBotId
+                ? `Waifu Discord bot ${input.senderBotId} is not connected.`
+                : "Orchestrator Discord client is not connected.");
+        }
+        const cache = await this.cacheForGuild(input.guildId);
+        const channel = await client.channels.fetch(input.channelId);
+        if (!channel || !("send" in channel)) {
+            throw new Error(`Discord channel ${input.channelId} is not sendable.`);
+        }
+        const denormalized = denormalizeModelContentForDiscord(input.content, {
+            ...cache,
+            activeAuthorIds: input.allowedUserMentionIds
+        });
+        const replyToMessageId = sanitizeReplyTarget(input.replyToMessageId);
+        if (input.replyToMessageId && !replyToMessageId) {
+            this.options.logger?.warn("Dropping non-snowflake replyToMessageId", {
+                guildId: input.guildId,
+                channelId: input.channelId,
+                value: input.replyToMessageId
+            });
+        }
+        const sent = await channel.send({
+            content: denormalized.content,
+            allowedMentions: denormalized.allowedMentions,
+            reply: replyToMessageId ? { messageReference: replyToMessageId } : undefined
+        });
+        return { messageId: sent.id };
+    }
+    async sendTyping(input) {
+        const client = input.senderBotId ? this.clients.get(input.senderBotId) : this.orchestratorClient();
+        if (!client)
+            return;
+        try {
+            const channel = await client.channels.fetch(input.channelId);
+            if (channel && "sendTyping" in channel) {
+                await channel.sendTyping();
+            }
+        }
+        catch (error) {
+            this.options.logger?.warn("Failed to send typing indicator", {
+                guildId: input.guildId,
+                channelId: input.channelId,
+                senderBotId: input.senderBotId,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    async validateDebugChannel(input) {
+        const channel = await this.orchestratorClient().channels.fetch(input.channelId);
+        if (!channel) {
+            throw new Error(`Discord channel ${input.channelId} is not accessible to the orchestrator bot.`);
+        }
+        if (input.requireMessages && !("messages" in channel)) {
+            throw new Error(`Discord channel ${input.channelId} is not readable by the orchestrator bot.`);
+        }
+        if (input.requireSend && !("send" in channel)) {
+            throw new Error(`Discord channel ${input.channelId} is not sendable by the orchestrator bot.`);
+        }
+        return {
+            channelId: input.channelId,
+            guildId: "guildId" in channel && typeof channel.guildId === "string" ? channel.guildId : undefined,
+            name: "name" in channel && typeof channel.name === "string" ? channel.name : undefined
+        };
+    }
+    async sendDebugMessage(input) {
+        const channel = await this.orchestratorClient().channels.fetch(input.channelId);
+        if (!channel || !("send" in channel)) {
+            throw new Error(`Discord channel ${input.channelId} is not sendable by the orchestrator bot.`);
+        }
+        const sent = await channel.send({
+            content: input.content,
+            allowedMentions: { parse: [], users: [], roles: [], repliedUser: false }
+        });
+        return { messageId: sent.id };
+    }
+    async deleteMessages(input) {
+        const result = {
+            deletedMessageIds: [],
+            failedMessageIds: []
+        };
+        if (input.messageIds.length === 0)
+            return result;
+        const orchestrator = this.orchestratorClient();
+        const orchestratorChannel = await orchestrator.channels.fetch(input.channelId);
+        if (!orchestratorChannel || !("messages" in orchestratorChannel)) {
+            throw new Error(`Discord channel ${input.channelId} is not message-manageable.`);
+        }
+        const remaining = new Set(input.messageIds);
+        const supportsBulkDelete = "bulkDelete" in orchestratorChannel &&
+            typeof orchestratorChannel.bulkDelete === "function";
+        if (input.messageIds.length >= 2 && supportsBulkDelete) {
+            try {
+                const bulkChannel = orchestratorChannel;
+                const bulkDeleted = await bulkChannel.bulkDelete(input.messageIds, true);
+                for (const id of bulkDeleted.keys()) {
+                    if (remaining.has(id)) {
+                        result.deletedMessageIds.push(id);
+                        remaining.delete(id);
+                    }
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.options.logger?.warn("Discord bulk delete failed, falling back to per-message deletes", {
+                    guildId: input.guildId,
+                    channelId: input.channelId,
+                    messageCount: input.messageIds.length,
+                    message
+                });
+            }
+        }
+        if (remaining.size === 0)
+            return result;
+        const channelByBotId = new Map();
+        channelByBotId.set(this.options.orchestrator.id, orchestratorChannel);
+        for (const messageId of input.messageIds) {
+            if (!remaining.has(messageId))
+                continue;
+            const messageAuthorId = input.authorIdByMessageId?.[messageId] ?? input.authorId;
+            const client = this.clientForAuthor(messageAuthorId);
+            const botId = this.botIdForClient(client);
+            let channel = botId ? channelByBotId.get(botId) : undefined;
+            try {
+                if (!channel) {
+                    const fetched = await client.channels.fetch(input.channelId);
+                    if (!fetched || !("messages" in fetched)) {
+                        throw new Error(`Discord channel ${input.channelId} is not message-manageable from this bot.`);
+                    }
+                    channel = fetched;
+                    if (botId)
+                        channelByBotId.set(botId, fetched);
+                }
+                await channel.messages.delete(messageId);
+                result.deletedMessageIds.push(messageId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                result.failedMessageIds.push({ messageId, message });
+                this.options.logger?.warn("Failed to delete Discord message", {
+                    guildId: input.guildId,
+                    channelId: input.channelId,
+                    messageId,
+                    authorId: messageAuthorId,
+                    deletingBotId: botId,
+                    message
+                });
+            }
+        }
+        return result;
+    }
+    async deleteAllMessages(input) {
+        const result = {
+            scannedMessageCount: 0,
+            deletedCount: 0,
+            failedCount: 0,
+            failedMessageIds: []
+        };
+        const orchestrator = this.orchestratorClient();
+        const fetchedChannel = await orchestrator.channels.fetch(input.channelId);
+        if (!fetchedChannel || !("messages" in fetchedChannel)) {
+            throw new Error(`Discord channel ${input.channelId} is not message-manageable.`);
+        }
+        const channel = fetchedChannel;
+        let before;
+        while (true) {
+            const page = await channel.messages.fetch(before ? { limit: 100, before } : { limit: 100 });
+            const messages = [...page.values()];
+            if (messages.length === 0)
+                break;
+            result.scannedMessageCount += messages.length;
+            await this.deleteFetchedMessages({
+                guildId: input.guildId,
+                channelId: input.channelId,
+                channel,
+                messages,
+                result
+            });
+            const nextBefore = oldestMessageId(messages);
+            if (!nextBefore || nextBefore === before)
+                break;
+            before = nextBefore;
+        }
+        return result;
+    }
+    async deleteFetchedMessages(input) {
+        const remaining = new Set(input.messages.map((message) => message.id));
+        const bulkIds = input.messages
+            .filter((message) => isBulkDeletableMessage(message))
+            .map((message) => message.id);
+        if (bulkIds.length >= 2 && input.channel.bulkDelete) {
+            for (const chunk of chunks(bulkIds, DISCORD_BULK_DELETE_MAX_MESSAGES)) {
+                if (chunk.length < 2)
+                    continue;
+                try {
+                    const bulkDeleted = await input.channel.bulkDelete(chunk, true);
+                    for (const id of bulkDeleted.keys()) {
+                        if (remaining.delete(id)) {
+                            input.result.deletedCount += 1;
+                        }
+                    }
+                }
+                catch (error) {
+                    this.options.logger?.warn("Discord bulk delete failed during full channel clear", {
+                        guildId: input.guildId,
+                        channelId: input.channelId,
+                        messageCount: chunk.length,
+                        message: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+        }
+        for (const message of input.messages) {
+            if (!remaining.has(message.id))
+                continue;
+            try {
+                await input.channel.messages.delete(message.id);
+                remaining.delete(message.id);
+                input.result.deletedCount += 1;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                remaining.delete(message.id);
+                input.result.failedCount += 1;
+                input.result.failedMessageIds.push({ messageId: message.id, message: errorMessage });
+                this.options.logger?.warn("Failed to delete Discord message during full channel clear", {
+                    guildId: input.guildId,
+                    channelId: input.channelId,
+                    messageId: message.id,
+                    message: errorMessage
+                });
+            }
+        }
+    }
+    async cacheForGuild(guildId) {
+        return this.options.cacheForGuild?.(guildId) ?? {
+            members: this.options.members,
+            emojis: this.options.emojis
+        };
+    }
+    orchestratorClient() {
+        const client = this.clients.get(this.options.orchestrator.id);
+        if (!client) {
+            throw new Error("Orchestrator Discord client is not connected.");
+        }
+        return client;
+    }
+    clientForAuthor(authorId) {
+        if (authorId) {
+            const bots = [this.options.orchestrator, ...(this.options.waifus ?? [])];
+            const bot = bots.find((candidate) => candidate.id === authorId || candidate.applicationId === authorId);
+            const client = bot ? this.clients.get(bot.id) : undefined;
+            if (client) {
+                return client;
+            }
+        }
+        return this.orchestratorClient();
+    }
+    botIdForClient(client) {
+        for (const [botId, candidate] of this.clients) {
+            if (candidate === client)
+                return botId;
+        }
+        return undefined;
+    }
+    shouldRefreshMentions(guildId) {
+        if (!this.options.refreshMembersForGuild)
+            return false;
+        const now = Date.now();
+        const previous = this.recentMentionRefreshes.get(guildId) ?? 0;
+        if (now - previous < MENTION_REFRESH_COOLDOWN_MS) {
+            return false;
+        }
+        this.recentMentionRefreshes.set(guildId, now);
+        return true;
+    }
+    attachClientRuntimeHandlers(client, botId) {
+        client.on(Events.Error, (error) => {
+            this.reportRuntimeIssue({
+                source: "client-error",
+                botId,
+                message: errorMessage(error),
+                error
+            });
+        });
+        client.on(Events.ShardError, (error, shardId) => {
+            this.reportRuntimeIssue({
+                source: "shard-error",
+                botId,
+                shardId,
+                message: errorMessage(error),
+                error
+            });
+        });
+        client.on(Events.ShardDisconnect, (event, shardId) => {
+            const code = closeEventCode(event);
+            const reason = closeEventReason(event);
+            this.reportRuntimeIssue({
+                source: "shard-disconnect",
+                botId,
+                shardId,
+                code,
+                wasClean: closeEventWasClean(event),
+                message: `Discord shard disconnected${code === undefined ? "" : ` with code ${code}`}${reason ? `: ${reason}` : "."}`
+            });
+        });
+        client.on(Events.Invalidated, () => {
+            this.reportRuntimeIssue({
+                source: "invalidated",
+                botId,
+                message: "Discord gateway session was invalidated."
+            });
+        });
+        client.on(Events.Warn, (message) => {
+            this.reportRuntimeIssue({
+                source: "warn",
+                botId,
+                message
+            });
+        });
+    }
+    reportRuntimeIssue(issue) {
+        const context = runtimeIssueLogContext(issue);
+        if (issue.source === "warn") {
+            this.options.logger?.warn("Discord gateway warning", context);
+        }
+        else {
+            this.options.logger?.error("Discord gateway runtime issue", context);
+        }
+        if (!this.options.onRuntimeIssue)
+            return;
+        this.runBackground("Discord runtime issue callback failed", context, () => this.options.onRuntimeIssue?.(issue));
+    }
+    async callListener(label, listener, event, context) {
+        try {
+            await listener(event);
+        }
+        catch (error) {
+            this.options.logger?.error(label, {
+                ...context,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    dispatchListener(label, listener, event, context) {
+        void this.callListener(label, listener, event, context);
+    }
+    runBackground(label, context, task) {
+        void Promise.resolve()
+            .then(task)
+            .catch((error) => {
+            this.options.logger?.error(label, {
+                ...context,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        });
+    }
+    async handleReviewInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/review can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.reviewListeners) {
+            this.dispatchListener("Discord review command listener failed", listener, event, slashCommandLogContext(event));
+        }
+    }
+    async handleClearInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/clear can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            count: interaction.options.getInteger(CLEAR_COUNT_OPTION_NAME) ?? undefined,
+            type: parseClearType(interaction.options.getString(CLEAR_TYPE_OPTION_NAME)),
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.clearListeners) {
+            this.dispatchListener("Discord clear command listener failed", listener, event, slashCommandLogContext(event));
+        }
+    }
+    async handleRunInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/run can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            waifuId: sanitizeRunString(interaction.options.getString(RUN_WAIFU_OPTION_NAME)),
+            sceneDirection: sanitizeRunString(interaction.options.getString(RUN_SCENE_DIRECTION_OPTION_NAME)),
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.runListeners) {
+            this.dispatchListener("Discord run command listener failed", listener, event, slashCommandLogContext(event));
+        }
+    }
+    async handleRunAutocompleteInteraction(interaction) {
+        const focused = interaction.options.getFocused(true);
+        if (focused.name !== RUN_WAIFU_OPTION_NAME) {
+            await interaction.respond([]);
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId ?? undefined,
+            channelId: interaction.channelId ?? undefined,
+            focusedValue: typeof focused.value === "string" ? focused.value : String(focused.value ?? ""),
+            respond: async (choices) => {
+                await interaction.respond(choices.slice(0, MAX_AUTOCOMPLETE_CHOICES));
+            }
+        };
+        if (this.runWaifuAutocompleteListeners.size === 0) {
+            await interaction.respond([]);
+            return;
+        }
+        await Promise.all([...this.runWaifuAutocompleteListeners].map((listener) => this.callListener("Discord run autocomplete listener failed", listener, event, {
+            guildId: event.guildId,
+            channelId: event.channelId,
+            focusedValue: event.focusedValue
+        })));
+    }
+    async handleStopInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/stop can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.stopListeners) {
+            this.dispatchListener("Discord stop command listener failed", listener, event, slashCommandLogContext(event));
+        }
+    }
+    async handleMemoriesInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/memories can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.memoriesListeners) {
+            this.dispatchListener("Discord memories command listener failed", listener, event, slashCommandLogContext(event));
+        }
+    }
+    async handlePrintInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/print can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            type: parsePrintCommandType(interaction.options.getString(PRINT_TYPE_OPTION_NAME)),
+            waifuId: sanitizeRunString(interaction.options.getString(PRINT_WAIFU_OPTION_NAME)),
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.printListeners) {
+            this.dispatchListener("Discord print command listener failed", listener, event, {
+                ...slashCommandLogContext(event),
+                type: event.type,
+                waifuId: event.waifuId
+            });
+        }
+    }
+    async handlePrintAutocompleteInteraction(interaction) {
+        const focused = interaction.options.getFocused(true);
+        if (focused.name !== PRINT_WAIFU_OPTION_NAME) {
+            await interaction.respond([]);
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId ?? undefined,
+            channelId: interaction.channelId ?? undefined,
+            focusedValue: typeof focused.value === "string" ? focused.value : String(focused.value ?? ""),
+            respond: async (choices) => {
+                await interaction.respond(choices.slice(0, MAX_AUTOCOMPLETE_CHOICES));
+            }
+        };
+        if (this.printWaifuAutocompleteListeners.size === 0) {
+            await interaction.respond([]);
+            return;
+        }
+        await Promise.all([...this.printWaifuAutocompleteListeners].map((listener) => this.callListener("Discord print autocomplete listener failed", listener, event, {
+            guildId: event.guildId,
+            channelId: event.channelId,
+            focusedValue: event.focusedValue
+        })));
+    }
+    async handleDebugInteraction(interaction) {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+        if (!interaction.guildId || !interaction.channelId) {
+            await interaction.editReply("/console can only be used in a server channel.");
+            return;
+        }
+        const event = {
+            guildId: interaction.guildId,
+            channelId: interaction.channelId,
+            userId: interaction.user.id,
+            type: parseDebugCommandType(interaction.options.getString(DEBUG_TYPE_OPTION_NAME)),
+            sourceChannelId: sanitizeRunString(interaction.options.getString(DEBUG_CHANNEL_ID_OPTION_NAME)),
+            respond: async (content) => {
+                await interaction.editReply(content);
+            }
+        };
+        for (const listener of this.debugListeners) {
+            this.dispatchListener("Discord debug command listener failed", listener, event, {
+                ...slashCommandLogContext(event),
+                type: event.type,
+                sourceChannelId: event.sourceChannelId
+            });
+        }
+    }
+}
+export class DiscordGatewayNotConfigured {
+    async connect() {
+        return {
+            connected: false,
+            orchestratorConnected: false,
+            waifuBotCount: 0,
+            warnings: ["Discord tokens are not configured yet."]
+        };
+    }
+    async disconnect() { }
+    async fetchFreshContext() {
+        return [];
+    }
+    async sendWaifuMessage() {
+        throw new Error("Discord sending is not configured yet.");
+    }
+    async sendTyping() { }
+}
+async function loginAndWaitUntilReady(client, token) {
+    if (client.isReady())
+        return;
+    await Promise.all([
+        new Promise((resolve) => {
+            client.once(Events.ClientReady, () => resolve());
+        }),
+        client.login(token)
+    ]);
+}
+function botAuthorIds(bots) {
+    return bots.flatMap((bot) => [bot.id, bot.applicationId].filter((id) => Boolean(id)));
+}
+function collectImageAttachments(message) {
+    if (!message.attachments)
+        return undefined;
+    const images = [];
+    for (const attachment of message.attachments.values()) {
+        if (!attachment.url)
+            continue;
+        const contentType = attachment.contentType ?? undefined;
+        if (isImageAttachment(contentType, attachment.name ?? undefined)) {
+            images.push({
+                url: attachment.url,
+                contentType,
+                contentLengthBytes: attachment.size ?? undefined
+            });
+        }
+    }
+    return images.length ? images : undefined;
+}
+function isImageAttachment(contentType, name) {
+    if (contentType)
+        return contentType.startsWith("image/");
+    return /\.(png|jpe?g|webp|gif)$/i.test(name ?? "");
+}
+async function resolveReplyReference(message) {
+    if (!message.reference?.messageId)
+        return undefined;
+    if (!message.fetchReference) {
+        return { messageId: message.reference.messageId };
+    }
+    const referenced = await message.fetchReference();
+    return {
+        messageId: message.reference.messageId,
+        authorName: referenced.member?.displayName ?? referenced.author.globalName ?? referenced.author.username,
+        contentPreview: referenced.content.slice(0, 160)
+    };
+}
+async function summarizeReactions(reactions, cache) {
+    const membersById = new Map((cache.members ?? []).map((member) => [member.userId, member]));
+    const emojisById = new Map((cache.emojis ?? []).map((emoji) => [emoji.id, emoji]));
+    return Promise.all([...reactions].map(async (reaction) => {
+        let users;
+        if (reaction.users) {
+            try {
+                const fetched = await reaction.users.fetch({ limit: 20 });
+                users = [...fetched.values()].map((user) => {
+                    const member = membersById.get(user.id);
+                    return member?.guildDisplayName ?? member?.globalDisplayName ?? user.globalName ?? user.username;
+                });
+            }
+            catch {
+                users = undefined;
+            }
+        }
+        return {
+            emoji: modelVisibleReactionEmoji(reaction.emoji, emojisById),
+            count: reaction.count ?? 0,
+            users
+        };
+    }));
+}
+function modelVisibleReactionEmoji(emoji, emojisById) {
+    if (emoji.id) {
+        const cached = emojisById.get(emoji.id);
+        if (cached) {
+            return `<${cached.animated ? "a" : ""}:${cached.name}:>`;
+        }
+        return emoji.name ? `:${emoji.name}:` : emoji.identifier;
+    }
+    return emoji.name ?? emoji.identifier;
+}
+function uniqueMentionedRoles(messages, cachedRoles) {
+    const cachedById = new Map(cachedRoles.map((role) => [role.id, role]));
+    const rolesById = new Map();
+    for (const message of messages) {
+        for (const role of message.mentions?.roles?.values() ?? []) {
+            rolesById.set(role.id, cachedById.get(role.id) ?? {
+                id: role.id,
+                name: role.name,
+                color: 0,
+                hoist: false,
+                mentionable: false,
+                managed: false,
+                fetchedAt: new Date().toISOString()
+            });
+        }
+    }
+    return [...rolesById.values()];
+}
+function mergeRoleCaches(primary, fallback) {
+    const rolesById = new Map(fallback.map((role) => [role.id, role]));
+    for (const role of primary) {
+        rolesById.set(role.id, role);
+    }
+    return [...rolesById.values()];
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error("Discord request aborted.");
+    }
+}
+const SNOWFLAKE_PATTERN = /^\d{17,20}$/;
+const MENTION_REFRESH_COOLDOWN_MS = 5 * 60 * 1000;
+const REVIEW_COMMAND_NAME = "review";
+const CLEAR_COMMAND_NAME = "clear";
+const RUN_COMMAND_NAME = "run";
+const STOP_COMMAND_NAME = "stop";
+const MEMORIES_COMMAND_NAME = "memories";
+const PRINT_COMMAND_NAME = "print";
+const DEBUG_COMMAND_NAME = "console";
+const LEGACY_DEBUG_COMMAND_NAMES = ["debug"];
+const CLEAR_COUNT_OPTION_NAME = "count";
+const CLEAR_TYPE_OPTION_NAME = "type";
+const PRINT_TYPE_OPTION_NAME = "type";
+const PRINT_WAIFU_OPTION_NAME = "waifu";
+const DEBUG_TYPE_OPTION_NAME = "type";
+const DEBUG_CHANNEL_ID_OPTION_NAME = "channel_id";
+const RUN_WAIFU_OPTION_NAME = "waifu";
+const RUN_SCENE_DIRECTION_OPTION_NAME = "scene_direction";
+const MAX_CLEAR_COUNT = 100;
+const MAX_AUTOCOMPLETE_CHOICES = 25;
+const DISCORD_BULK_DELETE_MAX_MESSAGES = 100;
+const DISCORD_BULK_DELETE_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+const ADMIN_COMMAND_PERMISSIONS = PermissionFlagsBits.Administrator;
+function sanitizeReplyTarget(value) {
+    return value && SNOWFLAKE_PATTERN.test(value) ? value : undefined;
+}
+function sanitizeRunString(value) {
+    const trimmed = value?.trim();
+    return trimmed || undefined;
+}
+function parseDebugCommandType(value) {
+    return value === "set" || value === "unset" || value === "print" ? value : undefined;
+}
+function parsePrintCommandType(value) {
+    return value === "system_prompt" || value === "memories" || value === "personality" ? value : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function closeEventCode(event) {
+    return typeof event.code === "string" || typeof event.code === "number" ? event.code : undefined;
+}
+function closeEventReason(event) {
+    return typeof event.reason === "string" && event.reason.trim() ? event.reason.trim() : undefined;
+}
+function closeEventWasClean(event) {
+    return typeof event.wasClean === "boolean" ? event.wasClean : undefined;
+}
+function runtimeIssueLogContext(issue) {
+    return {
+        source: issue.source,
+        botId: issue.botId,
+        shardId: issue.shardId,
+        code: issue.code,
+        wasClean: issue.wasClean,
+        message: issue.message
+    };
+}
+function interactionLogContext(interaction) {
+    return {
+        commandName: interaction.commandName,
+        guildId: interaction.guildId,
+        channelId: interaction.channelId,
+        userId: interaction.user.id
+    };
+}
+function slashCommandLogContext(event) {
+    return {
+        guildId: event.guildId,
+        channelId: event.channelId,
+        userId: event.userId,
+        commandMessageId: event.commandMessageId
+    };
+}
+function isBulkDeletableMessage(message) {
+    return message.createdTimestamp === undefined || Date.now() - message.createdTimestamp < DISCORD_BULK_DELETE_MAX_AGE_MS;
+}
+function oldestMessageId(messages) {
+    if (messages.length === 0)
+        return undefined;
+    if (messages.some((message) => typeof message.createdTimestamp !== "number")) {
+        return messages[messages.length - 1]?.id;
+    }
+    let oldest = messages[0];
+    for (const message of messages.slice(1)) {
+        if ((message.createdTimestamp ?? 0) < (oldest.createdTimestamp ?? 0)) {
+            oldest = message;
+        }
+    }
+    return oldest.id;
+}
+function chunks(values, size) {
+    const result = [];
+    for (let index = 0; index < values.length; index += size) {
+        result.push(values.slice(index, index + size));
+    }
+    return result;
+}
+async function registerOrchestratorCommands(client, logger) {
+    try {
+        const manager = client.application?.commands;
+        if (!manager)
+            return;
+        const payloads = buildOrchestratorCommandPayloads();
+        const commands = await manager.fetch();
+        for (const payload of payloads) {
+            const existing = commands.find((command) => command.name === payload.name);
+            if (existing) {
+                await manager.edit(existing.id, payload);
+            }
+            else {
+                await manager.create(payload);
+            }
+        }
+        const payloadNames = new Set(payloads.map((payload) => payload.name));
+        for (const legacyName of LEGACY_DEBUG_COMMAND_NAMES) {
+            if (payloadNames.has(legacyName))
+                continue;
+            const existing = commands.find((command) => command.name === legacyName);
+            if (existing) {
+                await manager.delete(existing.id);
+            }
+        }
+    }
+    catch (error) {
+        logger?.warn("Failed to register orchestrator slash commands", {
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+export function buildOrchestratorCommandPayloads() {
+    return [
+        {
+            name: REVIEW_COMMAND_NAME,
+            description: "Review and remove the latest waifu message if it leaked hallucinated internals.",
+            defaultMemberPermissions: ADMIN_COMMAND_PERMISSIONS
+        },
+        {
+            name: CLEAR_COMMAND_NAME,
+            description: "Delete channel messages without running reviewer judgment.",
+            defaultMemberPermissions: ADMIN_COMMAND_PERMISSIONS,
+            options: [
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: CLEAR_TYPE_OPTION_NAME,
+                    description: "Which messages to clear.",
+                    required: true,
+                    choices: [
+                        { name: "waifus", value: "waifus" },
+                        { name: "users", value: "users" },
+                        { name: "both", value: "both" },
+                        { name: "everything", value: "everything" }
+                    ]
+                },
+                {
+                    type: ApplicationCommandOptionType.Integer,
+                    name: CLEAR_COUNT_OPTION_NAME,
+                    description: "How many latest messages to delete for waifus, users, or both.",
+                    required: false,
+                    min_value: 1,
+                    max_value: MAX_CLEAR_COUNT
+                }
+            ]
+        },
+        {
+            name: RUN_COMMAND_NAME,
+            description: "Run the orchestrator in this channel immediately if the runtime is idle.",
+            options: [
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: RUN_WAIFU_OPTION_NAME,
+                    description: "Optional waifu id or display name to speak first.",
+                    required: false,
+                    autocomplete: true
+                },
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: RUN_SCENE_DIRECTION_OPTION_NAME,
+                    description: "Optional private scene direction for the selected waifu.",
+                    required: false
+                }
+            ]
+        },
+        {
+            name: STOP_COMMAND_NAME,
+            description: "Stop the current orchestrator and waifu work in this channel.",
+            defaultMemberPermissions: ADMIN_COMMAND_PERMISSIONS
+        },
+        {
+            name: MEMORIES_COMMAND_NAME,
+            description: "Run the stage manager for this channel and update guild memories.",
+            defaultMemberPermissions: ADMIN_COMMAND_PERMISSIONS
+        },
+        {
+            name: PRINT_COMMAND_NAME,
+            description: "Print a configured waifu field for this server.",
+            defaultMemberPermissions: ADMIN_COMMAND_PERMISSIONS,
+            options: [
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: PRINT_TYPE_OPTION_NAME,
+                    description: "Which waifu field to print.",
+                    required: true,
+                    choices: [
+                        { name: "system prompt", value: "system_prompt" },
+                        { name: "memories", value: "memories" },
+                        { name: "personality", value: "personality" }
+                    ]
+                },
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: PRINT_WAIFU_OPTION_NAME,
+                    description: "Waifu to inspect from this server.",
+                    required: true,
+                    autocomplete: true
+                }
+            ]
+        },
+        {
+            name: DEBUG_COMMAND_NAME,
+            description: "Route debug logs for a source channel.",
+            defaultMemberPermissions: ADMIN_COMMAND_PERMISSIONS,
+            options: [
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: DEBUG_TYPE_OPTION_NAME,
+                    description: "Whether to set or unset debug output.",
+                    required: true,
+                    choices: [
+                        { name: "set", value: "set" },
+                        { name: "unset", value: "unset" }
+                    ]
+                },
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: DEBUG_CHANNEL_ID_OPTION_NAME,
+                    description: "Source channel ID for set/unset.",
+                    required: false
+                }
+            ]
+        }
+    ];
+}
+function parseClearType(value) {
+    if (value === "waifus" || value === "users" || value === "both" || value === "everything") {
+        return value;
+    }
+    if (value === "all") {
+        return "both";
+    }
+    return undefined;
+}
+//# sourceMappingURL=client.js.map