@zhin.js/adapter-discord 5.0.2 → 6.0.0

package/lib/gateway.js

@@ -0,0 +1,235 @@
+import { createReadStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Client, GatewayIntentBits, EmbedBuilder, AttachmentBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, REST, Routes, PermissionFlagsBits, } from 'discord.js';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { activityTypeCode, resolveChannelKind, } from './protocol.js';
+const logger = getLogger('discord');
+export const DEFAULT_INTENTS = [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.DirectMessages,
+    GatewayIntentBits.GuildMembers,
+    GatewayIntentBits.GuildMessageReactions,
+];
+export function defaultCreateClient(intents) {
+    return new Client({ intents: [...intents] });
+}
+export function resolveSenderRole(msg) {
+    if (msg.isGuildOwner)
+        return 'owner';
+    const tokens = msg.permissionTokens ?? [];
+    if (tokens.includes('ADMINISTRATOR') || tokens.includes('MODERATE_MEMBERS'))
+        return 'admin';
+    if (msg.guildId)
+        return 'member';
+    return undefined;
+}
+export function normalizeDiscordMessage(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const msg = raw;
+    if (!msg.author || !msg.channel)
+        return null;
+    const permissionTokens = [];
+    let isGuildOwner = false;
+    const member = msg.member;
+    const guild = msg.guild;
+    if (member && guild) {
+        const checks = [
+            [PermissionFlagsBits.Administrator, 'ADMINISTRATOR'],
+            [PermissionFlagsBits.ManageRoles, 'MANAGE_ROLES'],
+            [PermissionFlagsBits.ModerateMembers, 'MODERATE_MEMBERS'],
+            [PermissionFlagsBits.ManageChannels, 'MANAGE_CHANNELS'],
+            [PermissionFlagsBits.ManageGuild, 'MANAGE_GUILD'],
+        ];
+        for (const [bit, name] of checks) {
+            if (member.permissions.has(bit))
+                permissionTokens.push(name);
+        }
+        if (guild.ownerId === msg.author.id) {
+            isGuildOwner = true;
+            permissionTokens.push('guild_owner', 'ADMINISTRATOR');
+        }
+    }
+    return {
+        id: msg.id,
+        content: msg.content ?? '',
+        channelId: msg.channel.id,
+        channelKind: resolveChannelKind(msg.channel.type),
+        authorId: msg.author.id,
+        authorName: member?.displayName || msg.author.displayName || msg.author.username,
+        authorBot: msg.author.bot,
+        createdTimestamp: msg.createdTimestamp,
+        guildId: guild?.id,
+        isGuildOwner,
+        permissionTokens,
+        attachments: [...msg.attachments.values()].map((a) => ({
+            id: a.id,
+            name: a.name ?? undefined,
+            url: a.url,
+            contentType: a.contentType ?? undefined,
+            size: a.size,
+        })),
+        embedTitles: msg.embeds.map((e) => e.title || e.description || 'embed').filter(Boolean),
+        stickerNames: [...msg.stickers.values()].map((s) => s.name),
+        replyToId: msg.reference?.messageId ?? undefined,
+    };
+}
+export async function toMessageCreateOptions(body) {
+    const options = {};
+    if (body.content)
+        options.content = body.content;
+    if (body.embeds?.length) {
+        options.embeds = body.embeds.map((data) => {
+            const embed = new EmbedBuilder();
+            if (data.title)
+                embed.setTitle(String(data.title));
+            if (data.description)
+                embed.setDescription(String(data.description));
+            if (data.color != null)
+                embed.setColor(data.color);
+            if (data.url)
+                embed.setURL(String(data.url));
+            const thumb = data.thumbnail;
+            if (thumb?.url)
+                embed.setThumbnail(thumb.url);
+            const image = data.image;
+            if (image?.url)
+                embed.setImage(image.url);
+            if (data.author)
+                embed.setAuthor(data.author);
+            if (data.footer)
+                embed.setFooter(data.footer);
+            if (data.timestamp)
+                embed.setTimestamp(new Date(String(data.timestamp)));
+            if (Array.isArray(data.fields))
+                embed.addFields(data.fields);
+            return embed;
+        });
+    }
+    if (body.files?.length) {
+        const files = [];
+        for (const file of body.files) {
+            if (file.file && await fileExists(file.file)) {
+                files.push(new AttachmentBuilder(createReadStream(file.file), {
+                    name: file.name || path.basename(file.file),
+                }));
+            }
+            else if (file.url) {
+                files.push(new AttachmentBuilder(file.url, { name: file.name || 'attachment' }));
+            }
+        }
+        if (files.length)
+            options.files = files;
+    }
+    if (body.components?.length) {
+        options.components = body.components.map((row) => new ActionRowBuilder().addComponents(...row.components.map((btn) => {
+            const b = new ButtonBuilder()
+                .setCustomId(btn.custom_id)
+                .setLabel(btn.label)
+                .setDisabled(!!btn.disabled);
+            if (btn.style === 4)
+                b.setStyle(ButtonStyle.Danger);
+            else if (btn.style === 1)
+                b.setStyle(ButtonStyle.Primary);
+            else
+                b.setStyle(ButtonStyle.Secondary);
+            return b;
+        })));
+    }
+    return options;
+}
+async function registerSlashCommands(config, applicationId) {
+    if (!config.slashCommands?.length)
+        return;
+    const rest = new REST({ version: '10' }).setToken(config.token);
+    if (config.globalCommands) {
+        await rest.put(Routes.applicationCommands(applicationId), {
+            body: config.slashCommands,
+        });
+        logger.info(formatCompact({ op: 'slash_commands', scope: 'global' }));
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function connectDiscordGatewayClient(client, config, handlers) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        client.on('messageCreate', (raw) => {
+            const msg = normalizeDiscordMessage(raw);
+            if (!msg)
+                return;
+            // clientReady 之后 client.user 一定可用；消息事件只会在此之后到达
+            const botId = client.user?.id;
+            const mentions = raw.mentions;
+            const mentionedBot = !!botId && mentions?.users?.has?.(botId) === true;
+            handlers.onMessage(mentionedBot ? { ...msg, mentionedBot: true } : msg);
+        });
+        client.on('interactionCreate', (raw) => {
+            const interaction = raw;
+            if (!interaction.isButton?.())
+                return;
+            void interaction.deferUpdate?.().catch(() => { });
+            if (!interaction.channel)
+                return;
+            handlers.onButton({
+                id: interaction.id,
+                customId: interaction.customId,
+                channelId: interaction.channel.id,
+                channelKind: resolveChannelKind(interaction.channel.type),
+                userId: interaction.user.id,
+                userName: interaction.user.username || interaction.user.displayName || interaction.user.id,
+                sourceMessageId: interaction.message?.id,
+            });
+        });
+        client.once('clientReady', () => {
+            void (async () => {
+                try {
+                    if (config.defaultActivity && client.user?.setActivity) {
+                        client.user.setActivity(config.defaultActivity.name, {
+                            type: activityTypeCode(config.defaultActivity.type),
+                            url: config.defaultActivity.url,
+                        });
+                    }
+                    if (config.enableSlashCommands && config.slashCommands?.length && client.user) {
+                        await registerSlashCommands(config, client.user.id);
+                    }
+                    if (!settled) {
+                        settled = true;
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    if (!settled) {
+                        settled = true;
+                        reject(error);
+                    }
+                }
+            })();
+        });
+        client.on('error', (error) => {
+            logger.error('Discord client error:', error);
+            if (!settled) {
+                settled = true;
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        client.on('warn', (info) => {
+            logger.warn('Discord client warning:', info);
+        });
+        client.login(config.token).catch((error) => {
+            if (!settled) {
+                settled = true;
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    });
+}

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { activityTypeCode, formatButtonContent, formatInboundContent, formatOutboundBody, resolveChannelKind, resolveDiscordConfig, senderDisplayName, type DiscordAdapterConfig, type DiscordButtonInbound, type DiscordInboundAttachment, type DiscordInboundMessage, type DiscordOutboundBody, type DiscordWireSegment, type ResolvedDiscordConfig, type ResolvedDiscordGatewayConfig, type ResolvedDiscordInteractionsConfig, } from './protocol.js';
+export { getDiscordAgentDeps, registerDiscordAgentEndpoint, setDiscordAgentDeps, type DiscordAgentDeps, type DiscordAgentEndpoint, } from './discord-agent-deps.js';
+export { checkDiscordPlatformPermit, discordGroupPermitResolver, normalizeDiscordSenderForPermit, platformPermit, registerDiscordPlatformPermitChecker, } from './platform-permit.js';
+export { DiscordGatewayEndpoint, DiscordInteractionsEndpoint, type CreateDiscordClient, type DiscordClientTransport, type DiscordEndpointOptions, type DiscordInteractionsEndpointOptions, } from './endpoint.js';
+export { connectDiscordGatewayClient, defaultCreateClient, normalizeDiscordMessage, resolveSenderRole, toMessageCreateOptions, type DiscordGatewayConnectHandlers, } from './gateway.js';
+export { handleDiscordInteractionRequest, registerDiscordInteractionRoutes, type DiscordInteractionsHandler, } from './webhook.js';

package/lib/index.js

@@ -0,0 +1,6 @@
+export { activityTypeCode, formatButtonContent, formatInboundContent, formatOutboundBody, resolveChannelKind, resolveDiscordConfig, senderDisplayName, } from './protocol.js';
+export { getDiscordAgentDeps, registerDiscordAgentEndpoint, setDiscordAgentDeps, } from './discord-agent-deps.js';
+export { checkDiscordPlatformPermit, discordGroupPermitResolver, normalizeDiscordSenderForPermit, platformPermit, registerDiscordPlatformPermitChecker, } from './platform-permit.js';
+export { DiscordGatewayEndpoint, DiscordInteractionsEndpoint, } from './endpoint.js';
+export { connectDiscordGatewayClient, defaultCreateClient, normalizeDiscordMessage, resolveSenderRole, toMessageCreateOptions, } from './gateway.js';
+export { handleDiscordInteractionRequest, registerDiscordInteractionRoutes, } from './webhook.js';

package/lib/platform-permit.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Discord platform permit — Guild 权限位
+ */
+import { type Message } from '@zhin.js/core';
+export declare function platformPermit(perm: string): string;
+export declare function discordGroupPermitResolver(logicalPerm: string): string;
+export declare function normalizeDiscordSenderForPermit(input: {
+    isOwner?: boolean;
+    permissions?: string[];
+}): {
+    role?: string;
+    permissions?: string[];
+};
+export declare function checkDiscordPlatformPermit(perm: string, message: Message<any>): boolean;
+export declare function registerDiscordPlatformPermitChecker(): () => void;

package/lib/{src/platform-permit.js → platform-permit.js}

@@ -1,7 +1,7 @@
 /**
  * Discord platform permit — Guild 权限位
  */
-import { registerPlatformPermitChecker } from 'zhin.js';
+import { registerPlatformPermitChecker } from '@zhin.js/core';
 const ADAPTER = 'discord';
 export function platformPermit(perm) {
     return `platform(${ADAPTER},${perm})`;
@@ -50,4 +50,3 @@ export function checkDiscordPlatformPermit(perm, message) {
 export function registerDiscordPlatformPermitChecker() {
     return registerPlatformPermitChecker(ADAPTER, checkDiscordPlatformPermit);
 }
-//# sourceMappingURL=platform-permit.js.map

package/lib/protocol.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Discord Gateway protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+/** Plugin Runtime owner config (`plugins.<instanceKey>` / schema.json). */
+export interface DiscordAdapterConfig {
+    readonly name?: string;
+    readonly token?: string;
+    /** Default `gateway`. `interactions` uses httpHostToken POST + Ed25519 verify. */
+    readonly connection?: 'gateway' | 'interactions';
+    readonly intents?: readonly number[];
+    readonly enableSlashCommands?: boolean;
+    readonly globalCommands?: boolean;
+    readonly defaultActivity?: {
+        readonly name: string;
+        readonly type: 'PLAYING' | 'STREAMING' | 'LISTENING' | 'WATCHING' | 'COMPETING';
+        readonly url?: string;
+    };
+    readonly slashCommands?: readonly Record<string, unknown>[];
+    /** Interactions-only fields. */
+    readonly applicationId?: string;
+    readonly publicKey?: string;
+    readonly interactionsPath?: string;
+    /** Transitional: legacy root `endpoints[]` with `context: discord`. */
+    readonly endpoints?: ReadonlyArray<{
+        readonly context?: string;
+        readonly name?: string;
+        readonly token?: string;
+        readonly connection?: 'gateway' | 'interactions';
+        readonly intents?: readonly number[];
+        readonly enableSlashCommands?: boolean;
+        readonly globalCommands?: boolean;
+        readonly defaultActivity?: DiscordAdapterConfig['defaultActivity'];
+        readonly slashCommands?: readonly Record<string, unknown>[];
+        readonly applicationId?: string;
+        readonly publicKey?: string;
+        readonly interactionsPath?: string;
+    }>;
+}
+export interface ResolvedDiscordGatewayConfig {
+    readonly context: 'discord';
+    readonly connection: 'gateway';
+    readonly name: string;
+    readonly token: string;
+    readonly intents?: readonly number[];
+    readonly enableSlashCommands: boolean;
+    readonly globalCommands: boolean;
+    readonly defaultActivity?: DiscordAdapterConfig['defaultActivity'];
+    readonly slashCommands?: readonly Record<string, unknown>[];
+}
+export interface ResolvedDiscordInteractionsConfig {
+    readonly context: 'discord';
+    readonly connection: 'interactions';
+    readonly name: string;
+    readonly token: string;
+    readonly applicationId: string;
+    readonly publicKey: string;
+    readonly interactionsPath: string;
+}
+export type ResolvedDiscordConfig = ResolvedDiscordGatewayConfig | ResolvedDiscordInteractionsConfig;
+export interface DiscordInboundAttachment {
+    readonly id?: string;
+    readonly name?: string;
+    readonly url?: string;
+    readonly contentType?: string;
+    readonly size?: number;
+}
+export interface DiscordInboundMessage {
+    readonly id: string;
+    readonly content: string;
+    readonly channelId: string;
+    readonly channelKind: 'private' | 'group' | 'channel';
+    readonly authorId: string;
+    readonly authorName: string;
+    readonly authorBot?: boolean;
+    readonly createdTimestamp: number;
+    readonly guildId?: string;
+    readonly isGuildOwner?: boolean;
+    readonly permissionTokens?: readonly string[];
+    readonly attachments?: readonly DiscordInboundAttachment[];
+    readonly embedTitles?: readonly string[];
+    readonly stickerNames?: readonly string[];
+    readonly replyToId?: string;
+    /** 入站 mentions 数组含 bot 用户时由 gateway connect 装配标注（Message.content 纯文本，@ 只能走 metadata）。 */
+    readonly mentionedBot?: boolean;
+}
+export interface DiscordButtonInbound {
+    readonly id: string;
+    readonly customId: string;
+    readonly channelId: string;
+    readonly channelKind: 'private' | 'group' | 'channel';
+    readonly userId: string;
+    readonly userName: string;
+    readonly sourceMessageId?: string;
+}
+export interface DiscordWireSegment {
+    readonly type: string;
+    readonly data?: Record<string, unknown>;
+}
+export interface DiscordOutboundComponentButton {
+    type: 2;
+    custom_id: string;
+    label: string;
+    style: number;
+    disabled?: boolean;
+}
+export interface DiscordOutboundActionRow {
+    type: 1;
+    components: DiscordOutboundComponentButton[];
+}
+export interface DiscordOutboundBody {
+    readonly content?: string;
+    readonly embeds?: ReadonlyArray<Record<string, unknown>>;
+    readonly files?: ReadonlyArray<{
+        name: string;
+        url?: string;
+        file?: string;
+    }>;
+    readonly components?: ReadonlyArray<DiscordOutboundActionRow>;
+}
+export declare function resolveDiscordConfig(config?: DiscordAdapterConfig): ResolvedDiscordConfig;
+export declare function resolveChannelKind(channelType: number | string | undefined): 'private' | 'group' | 'channel';
+export declare function senderDisplayName(msg: DiscordInboundMessage): string;
+/** Build inbound text for MessageGateway.receive (gateway owns reply routing). */
+export declare function formatInboundContent(msg: DiscordInboundMessage): string;
+export declare function formatButtonContent(interaction: DiscordButtonInbound): string;
+/**
+ * Wire-encode an already-rendered outbound payload into Discord message body.
+ * Segment canonicalization is intentionally not done here.
+ */
+export declare function formatOutboundBody(payload: unknown): DiscordOutboundBody;
+export declare function activityTypeCode(type: NonNullable<DiscordAdapterConfig['defaultActivity']>['type']): number;
+export declare function verifyDiscordInteractionSignature(publicKeyHex: string, body: string, signature: string, timestamp: string): boolean;
+export declare function formatSlashCommandContent(interaction: Record<string, unknown>): string;
+export declare function interactionToInboundMessage(interaction: Record<string, unknown>): DiscordInboundMessage;

package/lib/protocol.js

@@ -0,0 +1,234 @@
+/**
+ * Discord Gateway protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import { createPublicKey, verify as cryptoVerify } from 'node:crypto';
+export function resolveDiscordConfig(config = {}) {
+    const entry = config.endpoints?.find((item) => item.context === 'discord' || !item.context);
+    const token = (typeof config.token === 'string' && config.token)
+        || (typeof entry?.token === 'string' && entry.token)
+        || process.env.DISCORD_BOT_TOKEN
+        || '';
+    if (!token) {
+        throw new TypeError('Discord adapter requires token (plugins.<key>.token or endpoints with context: discord)');
+    }
+    const name = (typeof config.name === 'string' && config.name)
+        || (typeof entry?.name === 'string' && entry.name)
+        || process.env.DISCORD_BOT_NAME
+        || 'discord-bot';
+    const connection = config.connection
+        ?? entry?.connection
+        ?? 'gateway';
+    if (connection === 'interactions') {
+        const applicationId = config.applicationId || entry?.applicationId || '';
+        const publicKey = config.publicKey || entry?.publicKey || '';
+        if (!applicationId || !publicKey) {
+            throw new TypeError('Discord connection:interactions requires applicationId and publicKey');
+        }
+        return {
+            context: 'discord',
+            connection: 'interactions',
+            name,
+            token,
+            applicationId,
+            publicKey,
+            interactionsPath: config.interactionsPath || entry?.interactionsPath || '/discord/interactions',
+        };
+    }
+    return {
+        context: 'discord',
+        connection: 'gateway',
+        name,
+        token,
+        intents: config.intents ?? entry?.intents,
+        enableSlashCommands: config.enableSlashCommands === true
+            || entry?.enableSlashCommands === true,
+        globalCommands: config.globalCommands === true || entry?.globalCommands === true,
+        defaultActivity: config.defaultActivity ?? entry?.defaultActivity,
+        slashCommands: config.slashCommands ?? entry?.slashCommands,
+    };
+}
+export function resolveChannelKind(channelType) {
+    // discord.js ChannelType.DM = 1, GroupDM = 3
+    if (channelType === 1 || channelType === 'DM' || channelType === 'private')
+        return 'private';
+    if (channelType === 3 || channelType === 'GroupDM' || channelType === 'group')
+        return 'group';
+    return 'channel';
+}
+export function senderDisplayName(msg) {
+    return msg.authorName || msg.authorId;
+}
+/** Build inbound text for MessageGateway.receive (gateway owns reply routing). */
+export function formatInboundContent(msg) {
+    const parts = [];
+    if (msg.replyToId)
+        parts.push(`[reply:${msg.replyToId}]`);
+    if (msg.content?.trim())
+        parts.push(msg.content.trim());
+    for (const attachment of msg.attachments ?? []) {
+        const kind = attachment.contentType?.startsWith('image/')
+            ? 'image'
+            : attachment.contentType?.startsWith('audio/')
+                ? 'audio'
+                : attachment.contentType?.startsWith('video/')
+                    ? 'video'
+                    : 'file';
+        const name = attachment.name || attachment.url || 'attachment';
+        parts.push(`[${kind}: ${name}]`);
+    }
+    for (const title of msg.embedTitles ?? []) {
+        parts.push(`[embed: ${title}]`);
+    }
+    for (const name of msg.stickerNames ?? []) {
+        parts.push(`[sticker: ${name}]`);
+    }
+    const text = parts.join('\n').trim();
+    return text || '(Empty message)';
+}
+export function formatButtonContent(interaction) {
+    return `[action: ${interaction.customId}]`;
+}
+/**
+ * Wire-encode an already-rendered outbound payload into Discord message body.
+ * Segment canonicalization is intentionally not done here.
+ */
+export function formatOutboundBody(payload) {
+    if (typeof payload === 'string') {
+        return { content: payload };
+    }
+    const segments = Array.isArray(payload)
+        ? payload
+        : payload && typeof payload === 'object' && 'type' in payload
+            ? [payload]
+            : [];
+    if (segments.length === 0) {
+        return {
+            content: payload == null
+                ? ''
+                : typeof payload === 'object'
+                    ? JSON.stringify(payload)
+                    : String(payload),
+        };
+    }
+    let content = '';
+    const embeds = [];
+    const files = [];
+    let components;
+    for (const item of segments) {
+        if (typeof item === 'string') {
+            content += item;
+            continue;
+        }
+        const data = item.data ?? {};
+        switch (item.type) {
+            case 'text':
+                content += String(data.text ?? data.content ?? '');
+                break;
+            case 'at':
+                content += `<@${String(data.id ?? '')}>`;
+                break;
+            case 'channel_mention':
+                content += `<#${String(data.id ?? '')}>`;
+                break;
+            case 'role_mention':
+                content += `<@&${String(data.id ?? '')}>`;
+                break;
+            case 'emoji':
+                content += data.animated
+                    ? `<a:${String(data.name)}:${String(data.id)}>`
+                    : `<:${String(data.name)}:${String(data.id)}>`;
+                break;
+            case 'image':
+            case 'audio':
+            case 'video':
+            case 'file': {
+                const name = String(data.name || data.filename || item.type);
+                if (typeof data.file === 'string' && data.file) {
+                    files.push({ name, file: data.file });
+                }
+                else if (typeof data.url === 'string' && data.url) {
+                    files.push({ name, url: data.url });
+                }
+                break;
+            }
+            case 'embed':
+                embeds.push({ ...data });
+                break;
+            case 'keyboard': {
+                const rows = (data.rows ?? []);
+                components = rows.map((row) => ({
+                    type: 1,
+                    components: row.map((btn) => ({
+                        type: 2,
+                        custom_id: String(btn.payload).slice(0, 100),
+                        label: btn.label,
+                        style: btn.style === 'danger' ? 4 : btn.style === 'primary' ? 1 : 2,
+                        disabled: !!btn.disabled,
+                    })),
+                }));
+                break;
+            }
+            default:
+                if (data.text != null)
+                    content += String(data.text);
+                break;
+        }
+    }
+    return {
+        ...(content.trim() ? { content: content.trim() } : {}),
+        ...(embeds.length > 0 ? { embeds: embeds.slice(0, 10) } : {}),
+        ...(files.length > 0 ? { files } : {}),
+        ...(components ? { components } : {}),
+    };
+}
+export function activityTypeCode(type) {
+    const map = {
+        PLAYING: 0,
+        STREAMING: 1,
+        LISTENING: 2,
+        WATCHING: 3,
+        COMPETING: 5,
+    };
+    return map[type] ?? 0;
+}
+export function verifyDiscordInteractionSignature(publicKeyHex, body, signature, timestamp) {
+    if (!publicKeyHex || !signature || !timestamp)
+        return false;
+    try {
+        const key = createPublicKey({
+            key: Buffer.concat([
+                Buffer.from('302a300506032b6570032100', 'hex'),
+                Buffer.from(publicKeyHex, 'hex'),
+            ]),
+            format: 'der',
+            type: 'spki',
+        });
+        return cryptoVerify(null, Buffer.from(timestamp + body), key, Buffer.from(signature, 'hex'));
+    }
+    catch {
+        return false;
+    }
+}
+export function formatSlashCommandContent(interaction) {
+    const data = interaction.data;
+    const parts = [`/${data?.name ?? 'command'}`];
+    for (const opt of data?.options ?? []) {
+        parts.push(`${opt.name}:${String(opt.value)}`);
+    }
+    return parts.join(' ');
+}
+export function interactionToInboundMessage(interaction) {
+    const user = interaction.member?.user
+        ?? interaction.user;
+    return {
+        id: String(interaction.id),
+        content: formatSlashCommandContent(interaction),
+        channelId: String(interaction.channel_id ?? ''),
+        channelKind: interaction.guild_id ? 'channel' : 'private',
+        authorId: String(user?.id ?? ''),
+        authorName: String(user?.username ?? user?.id ?? ''),
+        createdTimestamp: Date.now(),
+        guildId: interaction.guild_id != null ? String(interaction.guild_id) : undefined,
+    };
+}

package/lib/webhook.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Discord interactions HTTP: signature → parse → admit.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
+import { type DiscordInboundMessage, type ResolvedDiscordInteractionsConfig } from './protocol.js';
+export interface DiscordInteractionsHandler {
+    readonly config: ResolvedDiscordInteractionsConfig;
+    readonly isOpen: boolean;
+    admit(msg: DiscordInboundMessage): void;
+}
+export declare function registerDiscordInteractionRoutes(http: HttpHost, handler: DiscordInteractionsHandler): HttpRouteRegistration[];
+export declare function handleDiscordInteractionRequest(request: IncomingMessage, response: ServerResponse, handler: DiscordInteractionsHandler): Promise<void>;