@songsid/agend 2.0.8-beta.1 → 2.0.8-beta.3

package/README.md

@@ -81,7 +81,7 @@ agend fleet start               # 3. Launch your fleet 🎉
 
 Open Telegram, send a message to your bot, and start coding from your phone.
 
-> **Discord?** `agend quickstart` supports Discord too — install the plugin first: `npm install -g @songsid/agend-plugin-discord`. See [Discord setup guide](docs/features.md#discord-adapter-mvp).
+> **Discord?** `agend quickstart` supports Discord too — it's built in, no extra install needed. See [Discord setup guide](docs/features.md#discord-adapter-mvp).
 
 ## How It Works
 
@@ -148,13 +148,10 @@ ClassicBot lets users start AI agents in any Discord text channel using slash co
 ### Setup
 
 ```bash
-# 1. Install Discord plugin
-npm install -g @songsid/agend-plugin-discord
-
-# 2. Run quickstart (select Discord)
+# 1. Run quickstart (select Discord — built in, no extra install)
 agend quickstart
 
-# 3. Start the fleet
+# 2. Start the fleet
 agend fleet start
 ```
 

package/dist/channel/adapters/discord.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter } from "node:events";
+import type { ChannelAdapter, ApprovalHandle, SendOpts, SentMessage, PermissionPrompt, Choice, AlertData } from "../types.js";
+import type { AccessManager } from "../access-manager.js";
+export interface DiscordAdapterOptions {
+    id: string;
+    botToken: string;
+    accessManager: AccessManager;
+    inboxDir: string;
+    guildId: string;
+    categoryName?: string;
+    generalChannelId?: string;
+}
+export declare class DiscordAdapter extends EventEmitter implements ChannelAdapter {
+    readonly type = "discord";
+    readonly topology: "channels";
+    readonly id: string;
+    private client;
+    private botToken;
+    private accessManager;
+    private inboxDir;
+    private guildId;
+    private openChannels;
+    private categoryName;
+    private generalChannelId?;
+    private queue;
+    private lastChatId;
+    private attachmentUrls;
+    private categoryIdPromise?;
+    constructor(opts: DiscordAdapterOptions);
+    private _fetchTextChannel;
+    private _registerHandlers;
+    /** Mark channels as open (skip access control) — used for classic bot channels */
+    setOpenChannels(channelIds: string[]): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendText(chatId: string, text: string, opts?: SendOpts): Promise<SentMessage>;
+    sendFile(chatId: string, filePath: string, opts?: SendOpts): Promise<SentMessage>;
+    editMessage(chatId: string, messageId: string, text: string): Promise<void>;
+    react(chatId: string, messageId: string, emoji: string): Promise<void>;
+    sendApproval(prompt: PermissionPrompt, callback: (decision: "approve" | "approve_always" | "deny") => void, signal?: AbortSignal, threadId?: string): Promise<ApprovalHandle>;
+    getChatId(): string | null;
+    setChatId(chatId: string): void;
+    downloadAttachment(fileId: string): Promise<string>;
+    promptUser(chatId: string, text: string, choices: Choice[], opts?: SendOpts): Promise<string>;
+    notifyAlert(chatId: string, alert: AlertData, opts?: SendOpts): Promise<SentMessage>;
+    private _resolveCategory;
+    private ensureCategoryId;
+    createTopic(name: string): Promise<string>;
+    deleteTopic(topicId: number | string): Promise<void>;
+    topicExists(topicId: number | string): Promise<boolean>;
+    handlePairing(chatId: string, userId: string): Promise<string>;
+    confirmPairing(code: string, callerUserId?: string): Promise<boolean>;
+}

package/dist/channel/adapters/discord.js

@@ -0,0 +1,584 @@
+import { EventEmitter } from "node:events";
+import { randomBytes } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { createWriteStream } from "node:fs";
+import { Client, GatewayIntentBits, ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, } from "discord.js";
+import { MessageQueue } from "../message-queue.js";
+const DISCORD_MAX_LENGTH = 2000;
+export class DiscordAdapter extends EventEmitter {
+    type = "discord";
+    topology = "channels";
+    id;
+    client;
+    botToken;
+    accessManager;
+    inboxDir;
+    guildId;
+    openChannels = new Set();
+    categoryName;
+    generalChannelId;
+    queue;
+    lastChatId = null;
+    attachmentUrls = new Map();
+    categoryIdPromise;
+    constructor(opts) {
+        super();
+        this.id = opts.id;
+        this.botToken = opts.botToken;
+        this.accessManager = opts.accessManager;
+        this.inboxDir = opts.inboxDir;
+        this.guildId = opts.guildId;
+        this.categoryName = opts.categoryName ?? "AgEnD Agents";
+        this.generalChannelId = opts.generalChannelId;
+        mkdirSync(this.inboxDir, { recursive: true });
+        this.client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.MessageContent,
+            ],
+        });
+        this.queue = new MessageQueue({
+            send: async (chatId, threadId, text) => {
+                const channel = await this._fetchTextChannel(threadId ?? chatId);
+                const msg = await channel.send(text);
+                return { messageId: msg.id };
+            },
+            edit: async (chatId, messageId, text) => {
+                const channel = await this._fetchTextChannel(chatId);
+                const msg = await channel.messages.fetch(messageId);
+                await msg.edit(text);
+            },
+            sendFile: async (chatId, threadId, filePath) => {
+                const channel = await this._fetchTextChannel(threadId ?? chatId);
+                const msg = await channel.send({ files: [filePath] });
+                return { messageId: msg.id };
+            },
+        });
+        this._registerHandlers();
+    }
+    async _fetchTextChannel(channelId) {
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel?.isTextBased()) {
+            throw new Error(`Channel ${channelId} is not a text channel`);
+        }
+        return channel;
+    }
+    _registerHandlers() {
+        this.client.on("messageCreate", async (msg) => {
+            if (msg.author.id === this.client.user?.id)
+                return; // Ignore own messages
+            if (!msg.guildId)
+                return;
+            if (msg.guildId !== this.guildId) {
+                if (!this.openChannels.has(msg.channelId))
+                    return;
+                console.log(`[discord] classic channel message from non-primary guild ${msg.guildId} channel ${msg.channelId}`);
+            }
+            const userId = msg.author.id;
+            // Access control moved to fleet-manager to allow classic channels for all users
+            const chatId = this.guildId;
+            const threadId = msg.channelId;
+            const messageId = msg.id;
+            const username = msg.author.username;
+            let text = msg.content;
+            // Handle forwarded messages (messageSnapshots) and embeds
+            if (!text) {
+                const parts = [];
+                // Forwarded message snapshots (Discord forward feature)
+                if (msg.messageSnapshots?.size > 0) {
+                    for (const [, snap] of msg.messageSnapshots) {
+                        if (snap.message?.content)
+                            parts.push(snap.message.content);
+                        if (snap.message?.embeds?.length) {
+                            for (const e of snap.message.embeds) {
+                                if (e.title)
+                                    parts.push(e.title);
+                                if (e.description)
+                                    parts.push(e.description);
+                            }
+                        }
+                        // Forward attachments (images, files) into the main message
+                        if (snap.message?.attachments?.size > 0) {
+                            for (const [, att] of snap.message.attachments) {
+                                msg.attachments.set(att.id, att);
+                            }
+                        }
+                    }
+                }
+                // Rich embeds (links, bot messages, etc.)
+                if (parts.length === 0 && msg.embeds.length > 0) {
+                    for (const e of msg.embeds) {
+                        if (e.title)
+                            parts.push(e.title);
+                        if (e.description)
+                            parts.push(e.description);
+                        if (e.fields?.length) {
+                            for (const f of e.fields)
+                                parts.push(`${f.name}: ${f.value}`);
+                        }
+                    }
+                }
+                if (parts.length > 0)
+                    text = parts.join("\n");
+            }
+            const isBotMessage = msg.author.bot;
+            // Collect attachments
+            const attachments = msg.attachments.map((att) => ({
+                kind: (att.contentType?.startsWith("image/") ? "photo"
+                    : att.contentType?.startsWith("video/") ? "video"
+                        : att.contentType?.startsWith("audio/") ? "audio"
+                            : "document"),
+                fileId: att.id,
+                mime: att.contentType ?? undefined,
+                size: att.size,
+                filename: att.name ?? undefined,
+            }));
+            // Store attachment URLs for later download
+            for (const att of msg.attachments.values()) {
+                this.attachmentUrls.set(att.id, att.url);
+            }
+            while (this.attachmentUrls.size > 1000) {
+                const first = this.attachmentUrls.keys().next().value;
+                if (first)
+                    this.attachmentUrls.delete(first);
+                else
+                    break;
+            }
+            let replyToText;
+            if (msg.reference?.messageId) {
+                try {
+                    const ref = await msg.fetchReference();
+                    replyToText = ref.content || ref.embeds?.[0]?.description || undefined;
+                }
+                catch { /* deleted message or no permission */ }
+            }
+            this.emit("message", {
+                source: "discord",
+                adapterId: this.id,
+                chatId,
+                threadId,
+                messageId,
+                userId,
+                username,
+                text,
+                timestamp: msg.createdAt,
+                isBotMessage,
+                attachments: attachments.length > 0 ? attachments : undefined,
+                replyTo: msg.reference?.messageId ?? undefined,
+                replyToText,
+            });
+        });
+        // Handle button interactions and slash commands
+        // Trust boundary: interaction responses can throw DiscordAPIError[10062] if the
+        // interaction expires (>3s). Catch to prevent crashing the entire daemon.
+        this.client.on("interactionCreate", async (interaction) => {
+            try {
+                if (interaction.guildId !== this.guildId) {
+                    // Allow slash commands through — guild whitelist is checked by fleet-manager.
+                    // Only block non-slash interactions (buttons) from unknown channels.
+                    if (!interaction.isChatInputCommand() && !this.openChannels.has(interaction.channelId ?? ""))
+                        return;
+                    if (!interaction.isChatInputCommand()) {
+                        console.log(`[discord] classic channel interaction from non-primary guild ${interaction.guildId} channel ${interaction.channelId}`);
+                    }
+                }
+                if (interaction.isButton()) {
+                    await interaction.deferUpdate();
+                    this.emit("callback_query", {
+                        callbackData: interaction.customId,
+                        chatId: this.guildId,
+                        threadId: interaction.channelId,
+                        messageId: interaction.message.id,
+                    });
+                    return;
+                }
+                if (interaction.isChatInputCommand()) {
+                    const channelName = interaction.channel && "name" in interaction.channel ? (interaction.channel.name ?? "") : "";
+                    const username = interaction.user.username;
+                    if (interaction.commandName === "chat") {
+                        const text = interaction.options.getString("message") ?? "";
+                        await interaction.deferReply();
+                        this.emit("slash_command", {
+                            command: "chat",
+                            channelId: interaction.channelId,
+                            channelName,
+                            guildId: interaction.guildId ?? undefined,
+                            userId: interaction.user.id,
+                            username,
+                            text,
+                            respond: async (reply) => { try {
+                                const m = await interaction.editReply(reply);
+                                return m.id;
+                            }
+                            catch {
+                                return undefined;
+                            } },
+                        });
+                    }
+                    else {
+                        await interaction.deferReply({ ephemeral: true });
+                        // Extract options as key-value pairs for fleet-manager
+                        const options = {};
+                        for (const opt of interaction.options.data) {
+                            options[opt.name] = opt.value;
+                        }
+                        this.emit("slash_command", {
+                            command: interaction.commandName,
+                            channelId: interaction.channelId,
+                            channelName,
+                            guildId: interaction.guildId ?? undefined,
+                            userId: interaction.user.id,
+                            username,
+                            options,
+                            respond: async (reply) => { try {
+                                await interaction.editReply(reply);
+                            }
+                            catch { /* expired */ } },
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`[discord] interactionCreate error (${err.message})`);
+            }
+        });
+        // Handle channel deletion (equivalent to topic_closed)
+        this.client.on("guildCreate", (guild) => {
+            this.emit("new_group_detected", {
+                groupId: guild.id,
+                groupTitle: guild.name,
+                source: "discord",
+            });
+        });
+        this.client.on("channelDelete", (channel) => {
+            if (!("guildId" in channel))
+                return;
+            if (channel.guildId !== this.guildId) {
+                if (!this.openChannels.has(channel.id))
+                    return;
+                console.log(`[discord] classic channel deleted from non-primary guild ${channel.guildId} channel ${channel.id}`);
+            }
+            this.emit("topic_closed", {
+                chatId: this.guildId,
+                threadId: channel.id,
+            });
+        });
+    }
+    /** Mark channels as open (skip access control) — used for classic bot channels */
+    setOpenChannels(channelIds) {
+        this.openChannels = new Set(channelIds);
+        console.log(`[AgEnD] setOpenChannels: ${channelIds.length} channels`, channelIds);
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────────
+    async start() {
+        this.queue.start();
+        this.client.once("ready", async () => {
+            // Register classic bot slash commands
+            try {
+                await this.client.application?.commands.set([
+                    { name: "start", description: "Start an agent in this channel" },
+                    { name: "stop", description: "Stop the agent in this channel" },
+                    {
+                        name: "chat", description: "Send a message to the agent",
+                        options: [{ name: "message", description: "Your message", type: 3, required: true }],
+                    },
+                    { name: "status", description: "Show fleet status and costs" },
+                    { name: "sysinfo", description: "System diagnostics" },
+                    { name: "ctx", description: "Show agent context usage" },
+                    { name: "restart", description: "🔒 Graceful restart all instances" },
+                    { name: "update", description: "🔒 Update AgEnD to latest version" },
+                    { name: "doctor", description: "🔒 Run health diagnostics" },
+                    { name: "compact", description: "🔒 Compact agent context window" },
+                    { name: "collab", description: "🔒 Toggle bot/webhook collaboration mode" },
+                    {
+                        name: "save", description: "🔒 Save the agent's conversation",
+                        options: [
+                            { name: "filename", description: "File name to save as", type: 3, required: true },
+                            { name: "force", description: "Overwrite if file exists", type: 5, required: false },
+                        ],
+                    },
+                    {
+                        name: "load", description: "🔒 Load a saved conversation",
+                        options: [{ name: "filename", description: "File name to load", type: 3, required: true }],
+                    },
+                ]);
+            }
+            catch (err) {
+                // Non-fatal — slash commands may fail on network issues
+            }
+            this.emit("started", this.client.user?.username ?? "discord-bot", this.client.user?.id);
+        });
+        await this.client.login(this.botToken);
+    }
+    async stop() {
+        this.queue.stop();
+        this.client.destroy();
+    }
+    // ── Text / file sending ────────────────────────────────────────────────
+    async sendText(chatId, text, opts) {
+        const channelId = opts?.threadId ?? chatId;
+        const channel = await this._fetchTextChannel(channelId);
+        const chunkLimit = opts?.chunkLimit ?? DISCORD_MAX_LENGTH;
+        const chunks = splitText(text, chunkLimit);
+        if (chunks.length === 0)
+            throw new Error("Empty text");
+        const first = await channel.send(chunks[0]);
+        // Enqueue remaining chunks
+        for (let i = 1; i < chunks.length; i++) {
+            this.queue.enqueue(chatId, opts?.threadId, { type: "content", text: chunks[i] });
+        }
+        return {
+            messageId: first.id,
+            chatId,
+            threadId: opts?.threadId,
+        };
+    }
+    async sendFile(chatId, filePath, opts) {
+        const channelId = opts?.threadId ?? chatId;
+        const channel = await this._fetchTextChannel(channelId);
+        const msg = await channel.send({ files: [filePath] });
+        return { messageId: msg.id, chatId, threadId: opts?.threadId };
+    }
+    async editMessage(chatId, messageId, text) {
+        // chatId is guild ID in channels topology, but messageId is in a channel.
+        // We need to find the message. Try all text channels in the guild.
+        // Optimization: caller usually provides the channel via sendText return value.
+        try {
+            // Try the general channel first, then search
+            const guild = await this.client.guilds.fetch(this.guildId);
+            const channels = guild.channels.cache.filter((c) => c.type === ChannelType.GuildText);
+            for (const [, ch] of channels) {
+                try {
+                    const textCh = ch;
+                    const msg = await textCh.messages.fetch(messageId);
+                    await msg.edit(text.slice(0, DISCORD_MAX_LENGTH));
+                    return;
+                }
+                catch {
+                    continue;
+                }
+            }
+            throw new Error(`Message ${messageId} not found in any channel`);
+        }
+        catch (err) {
+            // Fallback: send a new message if edit fails
+            if (this.generalChannelId) {
+                const channel = await this._fetchTextChannel(this.generalChannelId);
+                await channel.send(text.slice(0, DISCORD_MAX_LENGTH));
+            }
+        }
+    }
+    async react(chatId, messageId, emoji) {
+        try {
+            // Direct REST call — single API request instead of 3 (fetchChannel → fetchMessage → react)
+            const encoded = encodeURIComponent(emoji);
+            await this.client.rest.put(`/channels/${chatId}/messages/${messageId}/reactions/${encoded}/@me`);
+        }
+        catch {
+            // No-op per degradation strategy
+        }
+    }
+    // ── Approval ───────────────────────────────────────────────────────────
+    async sendApproval(prompt, callback, signal, threadId) {
+        const nonce = randomBytes(5).toString("hex");
+        const approveData = `approval:approve:${nonce}`;
+        const alwaysData = `approval:approve_always:${nonce}`;
+        const denyData = `approval:deny:${nonce}`;
+        const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
+            .setCustomId(approveData)
+            .setLabel("Allow")
+            .setStyle(ButtonStyle.Success), new ButtonBuilder()
+            .setCustomId(alwaysData)
+            .setLabel("Always")
+            .setStyle(ButtonStyle.Success), new ButtonBuilder()
+            .setCustomId(denyData)
+            .setLabel("Deny")
+            .setStyle(ButtonStyle.Danger));
+        let text = `⚠️ **Permission Request**\nTool: \`${prompt.tool_name}\``;
+        if (prompt.input_preview) {
+            const preview = prompt.input_preview.length > 200
+                ? prompt.input_preview.slice(0, 200) + "…"
+                : prompt.input_preview;
+            text += `\n\`\`\`\n${preview}\n\`\`\``;
+        }
+        else if (prompt.description) {
+            text += `\n${prompt.description}`;
+        }
+        const cleanup = () => {
+            this.off("callback_query", handler);
+        };
+        const handler = (query) => {
+            if (!query.callbackData)
+                return;
+            const isApprove = query.callbackData === approveData;
+            const isAlways = query.callbackData === alwaysData;
+            const isDeny = query.callbackData === denyData;
+            if (!isApprove && !isAlways && !isDeny)
+                return;
+            cleanup();
+            // Update the message to show the decision
+            if (query.threadId && query.messageId) {
+                this._fetchTextChannel(query.threadId).then((ch) => {
+                    ch.messages.fetch(query.messageId).then((msg) => {
+                        const label = isDeny ? "❌ Denied" : isAlways ? "✅ Always Allowed" : "✅ Allowed";
+                        msg.edit({
+                            content: `${label}\nTool: \`${prompt.tool_name}\``,
+                            components: [],
+                        }).catch(() => { });
+                    }).catch(() => { });
+                }).catch(() => { });
+            }
+            callback(isDeny ? "deny" : isAlways ? "approve_always" : "approve");
+        };
+        this.on("callback_query", handler);
+        if (signal) {
+            signal.addEventListener("abort", () => cleanup());
+        }
+        const channelId = threadId ?? this.generalChannelId;
+        if (channelId) {
+            const channel = await this._fetchTextChannel(channelId);
+            await channel.send({ content: text, components: [row] });
+        }
+        else {
+            this.emit("approval_request", { prompt: text, components: [row], nonce });
+        }
+        return { cancel: cleanup };
+    }
+    // ── Chat ID management ──────────────────────────────────────────────────
+    getChatId() { return this.lastChatId; }
+    setChatId(chatId) { this.lastChatId = chatId; }
+    // ── File download ──────────────────────────────────────────────────────
+    async downloadAttachment(fileId) {
+        const url = this.attachmentUrls.get(fileId);
+        if (!url)
+            throw new Error(`No URL for attachment: ${fileId}`);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Download failed: ${response.status}`);
+        const filename = `${Date.now()}-${fileId.slice(-8)}-${url.split("/").pop()?.split("?")[0] ?? "file"}`;
+        const localPath = join(this.inboxDir, filename);
+        const dest = createWriteStream(localPath);
+        const body = response.body;
+        if (!body)
+            throw new Error("No response body");
+        await pipeline(Readable.fromWeb(body), dest);
+        return localPath;
+    }
+    // ── Intent-oriented methods ──────────────────────────────────────────
+    async promptUser(chatId, text, choices, opts) {
+        const channelId = opts?.threadId ?? chatId;
+        const channel = await this._fetchTextChannel(channelId);
+        const row = new ActionRowBuilder();
+        for (const choice of choices) {
+            row.addComponents(new ButtonBuilder()
+                .setCustomId(choice.id)
+                .setLabel(choice.label.slice(0, 80)) // Discord button label max 80 chars
+                .setStyle(ButtonStyle.Primary));
+        }
+        const msg = await channel.send({ content: text, components: [row] });
+        return msg.id;
+    }
+    async notifyAlert(chatId, alert, opts) {
+        if (alert.choices && alert.choices.length > 0) {
+            const channelId = opts?.threadId ?? chatId;
+            const channel = await this._fetchTextChannel(channelId);
+            const row = new ActionRowBuilder();
+            for (const choice of alert.choices) {
+                row.addComponents(new ButtonBuilder()
+                    .setCustomId(choice.id)
+                    .setLabel(choice.label.slice(0, 80))
+                    .setStyle(ButtonStyle.Secondary));
+            }
+            const msg = await channel.send({ content: alert.message, components: [row] });
+            return { messageId: msg.id, chatId, threadId: opts?.threadId };
+        }
+        return this.sendText(chatId, alert.message, opts);
+    }
+    // ── Topology: create channel ────────────────────────────────────────────
+    async _resolveCategory() {
+        const guild = await this.client.guilds.fetch(this.guildId);
+        await guild.channels.fetch();
+        const existing = guild.channels.cache.find((c) => c.type === ChannelType.GuildCategory && c.name === this.categoryName);
+        if (existing)
+            return existing.id;
+        const cat = await guild.channels.create({
+            name: this.categoryName,
+            type: ChannelType.GuildCategory,
+        });
+        return cat.id;
+    }
+    async ensureCategoryId() {
+        if (!this.categoryIdPromise) {
+            this.categoryIdPromise = this._resolveCategory().catch((err) => {
+                this.categoryIdPromise = undefined;
+                throw err;
+            });
+        }
+        return this.categoryIdPromise;
+    }
+    async createTopic(name) {
+        const guild = await this.client.guilds.fetch(this.guildId);
+        const categoryId = await this.ensureCategoryId();
+        try {
+            const channel = await guild.channels.create({
+                name,
+                type: ChannelType.GuildText,
+                parent: categoryId,
+            });
+            return channel.id;
+        }
+        catch (err) {
+            // 10003 = Unknown Channel — category was deleted externally
+            if (err.code === 10003) {
+                this.categoryIdPromise = undefined;
+                const freshId = await this.ensureCategoryId();
+                const channel = await guild.channels.create({
+                    name,
+                    type: ChannelType.GuildText,
+                    parent: freshId,
+                });
+                return channel.id;
+            }
+            throw err;
+        }
+    }
+    async deleteTopic(topicId) {
+        const channel = await this.client.channels.fetch(String(topicId));
+        // Only delete GuildText channels created by createTopic — never categories or forums
+        if (channel && "type" in channel && channel.type === ChannelType.GuildText && "delete" in channel) {
+            await channel.delete();
+        }
+    }
+    async topicExists(topicId) {
+        try {
+            const channel = await this.client.channels.fetch(String(topicId));
+            return channel != null;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── Pairing ────────────────────────────────────────────────────────────
+    async handlePairing(chatId, userId) {
+        const code = this.accessManager.generateCode(userId);
+        return code;
+    }
+    async confirmPairing(code, callerUserId) {
+        return this.accessManager.confirmCode(code, callerUserId);
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+function splitText(text, limit) {
+    const chunks = [];
+    let offset = 0;
+    while (offset < text.length) {
+        chunks.push(text.slice(offset, offset + limit));
+        offset += limit;
+    }
+    return chunks;
+}
+//# sourceMappingURL=discord.js.map