@zhin.js/adapter-discord 5.0.1 → 5.0.3

package/lib/index.js

@@ -1,330 +1,6 @@
-/**
- * Discord 适配器入口：单一适配器，支持 Gateway / Interactions（connection: gateway | interactions）
- */
-import path from "node:path";
-import { usePlugin, createSceneManagementTools } from "zhin.js";
-import { DiscordAdapter } from "./adapter.js";
-import { discordGroupPermitResolver, platformPermit, registerDiscordPlatformPermitChecker, } from "./platform-permit.js";
-export * from "./types.js";
-export { DiscordEndpoint } from "./endpoint.js";
-export { DiscordInteractionsEndpoint } from "./endpoint-interactions.js";
-export { DiscordAdapter } from "./adapter.js";
-const plugin = usePlugin();
-const { provide, useContext } = plugin;
-provide({
-    name: "discord",
-    description: "Discord 适配器（Gateway / Interactions）",
-    mounted: async (p) => {
-        const adapter = new DiscordAdapter(p);
-        await adapter.start();
-        return adapter;
-    },
-    dispose: async (adapter) => {
-        await adapter.stop();
-    },
-});
-useContext('tool', 'discord', (toolService, discord) => {
-    const disposers = [];
-    disposers.push(registerDiscordPlatformPermitChecker());
-    const sceneTools = createSceneManagementTools(discord, 'discord', { permitResolver: discordGroupPermitResolver, registerChecker: false });
-    disposers.push(...sceneTools.map(t => toolService.addTool(t, plugin.name)));
-    function getGatewayBot(endpointId) {
-        const endpoint = discord.endpoints.get(endpointId);
-        if (!endpoint)
-            throw new Error(`Endpoint ${endpointId} 不存在`);
-        if (endpoint.$config.connection !== 'gateway') {
-            throw new Error('此工具仅支持 connection: gateway');
-        }
-        return endpoint;
-    }
-    disposers.push(toolService.addTool({
-        name: 'discord_add_role',
-        description: '给成员添加 Discord 角色',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                guild_id: { type: 'string', description: '服务器 ID' },
-                user_id: { type: 'string', description: '用户 ID' },
-                role_id: { type: 'string', description: '角色 ID' },
-            },
-            required: ['endpoint_id', 'guild_id', 'user_id', 'role_id'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        permissions: [platformPermit('manage_roles')],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            const success = await endpoint.addRole(args.guild_id, args.user_id, args.role_id);
-            return { success, message: success ? `已给用户 ${args.user_id} 添加角色` : '操作失败' };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'discord_remove_role',
-        description: '移除成员的 Discord 角色',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                guild_id: { type: 'string', description: '服务器 ID' },
-                user_id: { type: 'string', description: '用户 ID' },
-                role_id: { type: 'string', description: '角色 ID' },
-            },
-            required: ['endpoint_id', 'guild_id', 'user_id', 'role_id'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        permissions: [platformPermit('manage_roles')],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            const success = await endpoint.removeRole(args.guild_id, args.user_id, args.role_id);
-            return { success, message: success ? `已移除用户 ${args.user_id} 的角色` : '操作失败' };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'discord_list_roles',
-        description: '获取 Discord 服务器角色列表',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                guild_id: { type: 'string', description: '服务器 ID' },
-            },
-            required: ['endpoint_id', 'guild_id'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        permissions: [platformPermit('manage_roles')],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            const roles = await endpoint.getRoles(args.guild_id);
-            return { roles, count: roles.length };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'discord_create_thread',
-        description: '在 Discord 频道中创建帖子/子线程',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                channel_id: { type: 'string', description: '频道 ID' },
-                name: { type: 'string', description: '帖子标题' },
-                message_id: { type: 'string', description: '基于某条消息创建（可选）' },
-                auto_archive_duration: {
-                    type: 'number',
-                    description: '自动归档时间（分钟：60/1440/4320/10080）',
-                },
-            },
-            required: ['endpoint_id', 'channel_id', 'name'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        permissions: [platformPermit('manage_channels')],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            const thread = await endpoint.createThread(args.channel_id, args.name, args.message_id, args.auto_archive_duration);
-            return { success: true, thread_id: thread.id, message: `帖子 "${args.name}" 已创建` };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'discord_react',
-        description: '对 Discord 消息添加表情反应',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                channel_id: { type: 'string', description: '频道 ID' },
-                message_id: { type: 'string', description: '消息 ID' },
-                emoji: {
-                    type: 'string',
-                    description: '表情（Unicode 表情或自定义表情如 <:name:id>）',
-                },
-            },
-            required: ['endpoint_id', 'channel_id', 'message_id', 'emoji'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            await endpoint.addReaction(args.channel_id, args.message_id, args.emoji);
-            return { success: true, message: `已添加反应 ${args.emoji}` };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'discord_send_embed',
-        description: '发送 Discord 富文本嵌入消息（Embed）',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                channel_id: { type: 'string', description: '频道 ID' },
-                title: { type: 'string', description: 'Embed 标题' },
-                description: { type: 'string', description: 'Embed 描述' },
-                color: { type: 'number', description: '颜色值（十进制，如 0x00ff00 = 65280）' },
-                url: { type: 'string', description: '标题链接（可选）' },
-                fields: {
-                    type: 'string',
-                    description: '字段，JSON 格式: [{"name":"k","value":"v","inline":false}]',
-                },
-            },
-            required: ['endpoint_id', 'channel_id'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            const embedData = {};
-            if (args.title)
-                embedData.title = args.title;
-            if (args.description)
-                embedData.description = args.description;
-            if (args.color)
-                embedData.color = args.color;
-            if (args.url)
-                embedData.url = args.url;
-            if (args.fields) {
-                try {
-                    embedData.fields = JSON.parse(args.fields);
-                }
-                catch {
-                    return { success: false, message: 'fields 格式错误，应为 JSON 数组' };
-                }
-            }
-            const msg = await endpoint.sendEmbed(args.channel_id, embedData);
-            return { success: true, message_id: msg.id, message: 'Embed 已发送' };
-        },
-    }, plugin.name));
-    disposers.push(toolService.addTool({
-        name: 'discord_forum_post',
-        description: '在 Discord 论坛频道中创建帖子',
-        parameters: {
-            type: 'object',
-            properties: {
-                endpoint_id: { type: 'string', description: 'Endpoint 名称', contextKey: 'endpointId' },
-                channel_id: { type: 'string', description: '论坛频道 ID' },
-                name: { type: 'string', description: '帖子标题' },
-                content: { type: 'string', description: '帖子内容' },
-                tags: { type: 'string', description: '标签名，逗号分隔（可选）' },
-            },
-            required: ['endpoint_id', 'channel_id', 'name', 'content'],
-        },
-        platforms: ['discord'],
-        tags: ['discord'],
-        execute: async (args) => {
-            const endpoint = getGatewayBot(args.endpoint_id);
-            const tagList = args.tags ? args.tags.split(',').map((t) => t.trim()) : undefined;
-            const thread = await endpoint.createForumPost(args.channel_id, args.name, args.content, tagList);
-            return { success: true, thread_id: thread.id, message: `论坛帖 "${args.name}" 已创建` };
-        },
-    }, plugin.name));
-    return () => disposers.forEach(d => d());
-});
-// ── Web 控制台 ─────────────────────────────────────────────────────────
-useContext("web", (pageManager) => {
-    pageManager.addEntry({
-        id: "discord",
-        development: path.resolve(import.meta.dirname, "../client/index.tsx"),
-        production: path.resolve(import.meta.dirname, "../dist/index.js"),
-        meta: { name: "Discord" },
-    });
-});
-useContext("router", "discord", (router, discord) => {
-    router.get("/api/discord/endpoints", async (ctx) => {
-        try {
-            const endpoints = Array.from(discord.endpoints.values());
-            const result = endpoints.map((endpoint) => {
-                try {
-                    const client = endpoint.client || endpoint;
-                    return {
-                        name: endpoint.$config.name,
-                        connected: endpoint.$connected || false,
-                        mode: endpoint.$config.connection || "gateway",
-                        guildCount: client.guilds?.cache?.size || 0,
-                        channelCount: client.channels?.cache?.size || 0,
-                        status: endpoint.$connected ? "online" : "offline",
-                        user: client.user ? { tag: client.user.tag, id: client.user.id } : null,
-                    };
-                }
-                catch {
-                    return { name: endpoint.$config.name, connected: false, mode: "unknown", guildCount: 0, channelCount: 0, status: "error", user: null };
-                }
-            });
-            ctx.body = { success: true, data: result };
-        }
-        catch {
-            ctx.status = 500;
-            ctx.body = { success: false, error: "获取 Endpoint 数据失败" };
-        }
-    });
-    // Endpoint 连接/断开
-    router.post("/api/discord/endpoints/:name/connect", async (ctx) => {
-        try {
-            const endpoint = discord.endpoints.get(ctx.params.name);
-            if (!endpoint) {
-                ctx.status = 404;
-                ctx.body = { success: false, error: "Endpoint 不存在" };
-                return;
-            }
-            if (endpoint.$connected) {
-                ctx.body = { success: true, message: "已经在线" };
-                return;
-            }
-            await endpoint.$connect();
-            ctx.body = { success: true, message: "连接成功" };
-        }
-        catch (e) {
-            ctx.status = 500;
-            ctx.body = { success: false, error: e instanceof Error ? e.message : "连接失败" };
-        }
-    });
-    router.post("/api/discord/endpoints/:name/disconnect", async (ctx) => {
-        try {
-            const endpoint = discord.endpoints.get(ctx.params.name);
-            if (!endpoint) {
-                ctx.status = 404;
-                ctx.body = { success: false, error: "Endpoint 不存在" };
-                return;
-            }
-            if (!endpoint.$connected) {
-                ctx.body = { success: true, message: "已经离线" };
-                return;
-            }
-            await endpoint.$disconnect();
-            ctx.body = { success: true, message: "已断开" };
-        }
-        catch (e) {
-            ctx.status = 500;
-            ctx.body = { success: false, error: e instanceof Error ? e.message : "断开失败" };
-        }
-    });
-    // 服务器列表（仅 Gateway 模式）
-    router.get("/api/discord/endpoints/:name/guilds", async (ctx) => {
-        try {
-            const endpoint = discord.endpoints.get(ctx.params.name);
-            if (!endpoint) {
-                ctx.status = 404;
-                ctx.body = { success: false, error: "Endpoint 不存在" };
-                return;
-            }
-            if (!endpoint.$connected) {
-                ctx.status = 400;
-                ctx.body = { success: false, error: "Endpoint 未连接" };
-                return;
-            }
-            const client = endpoint.client || endpoint;
-            const guilds = client.guilds?.cache?.map((g) => ({
-                id: g.id,
-                name: g.name,
-                memberCount: g.memberCount,
-                icon: g.iconURL({ size: 64 }),
-            })) || [];
-            ctx.body = { success: true, data: guilds };
-        }
-        catch (e) {
-            ctx.status = 500;
-            ctx.body = { success: false, error: e instanceof Error ? e.message : "获取服务器列表失败" };
-        }
-    });
-});
-//# sourceMappingURL=index.js.map
+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

@@ -1,7 +1,7 @@
 /**
  * Discord platform permit — Guild 权限位
  */
-import type { Message } from 'zhin.js';
+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: {
@@ -13,4 +13,3 @@ export declare function normalizeDiscordSenderForPermit(input: {
 };
 export declare function checkDiscordPlatformPermit(perm: string, message: Message<any>): boolean;
 export declare function registerDiscordPlatformPermitChecker(): () => void;
-//# sourceMappingURL=platform-permit.d.ts.map

package/lib/platform-permit.js

@@ -1,4 +1,7 @@
-import { registerPlatformPermitChecker } from 'zhin.js';
+/**
+ * Discord platform permit — Guild 权限位
+ */
+import { registerPlatformPermitChecker } from '@zhin.js/core';
 const ADAPTER = 'discord';
 export function platformPermit(perm) {
     return `platform(${ADAPTER},${perm})`;
@@ -47,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;