@zhin.js/adapter-discord 5.0.1 → 5.0.3

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>;

package/lib/webhook.js

@@ -0,0 +1,86 @@
+import { getLogger } from '@zhin.js/logger';
+import { interactionToInboundMessage, verifyDiscordInteractionSignature, } from './protocol.js';
+const logger = getLogger('discord');
+const INTERACTION_TYPE_PING = 1;
+const INTERACTION_TYPE_APPLICATION_COMMAND = 2;
+const INTERACTION_RESPONSE_PONG = 1;
+const INTERACTION_RESPONSE_CHANNEL_MESSAGE_WITH_SOURCE = 4;
+/** EPHEHEMERAL — 仅发起者可见（对齐旧 endpoint-interactions 默认响应）。 */
+const INTERACTION_FLAG_EPHEMERAL = 64;
+export function registerDiscordInteractionRoutes(http, handler) {
+    const path = handler.config.interactionsPath;
+    return [
+        http.route('POST', path, async (request, response) => {
+            await handleDiscordInteractionRequest(request, response, handler);
+        }, { summary: 'Discord interactions callback', tags: ['discord'] }),
+    ];
+}
+export async function handleDiscordInteractionRequest(request, response, handler) {
+    try {
+        const signature = headerValue(request.headers['x-signature-ed25519']);
+        const timestamp = headerValue(request.headers['x-signature-timestamp']);
+        const rawBody = await readInteractionBody(request);
+        if (!signature || !timestamp) {
+            response.writeHead(401, { 'Content-Type': 'text/plain' });
+            response.end('Unauthorized');
+            return;
+        }
+        if (!verifyDiscordInteractionSignature(handler.config.publicKey, rawBody, signature, timestamp)) {
+            response.writeHead(401, { 'Content-Type': 'text/plain' });
+            response.end('Unauthorized');
+            return;
+        }
+        const interaction = JSON.parse(rawBody);
+        if (interaction.type === INTERACTION_TYPE_PING) {
+            writeJson(response, 200, { type: INTERACTION_RESPONSE_PONG });
+            return;
+        }
+        if (interaction.type === INTERACTION_TYPE_APPLICATION_COMMAND) {
+            if (handler.isOpen) {
+                handler.admit(interactionToInboundMessage(interaction));
+            }
+            // 即时响应（type 4）：defer(type 5) 需要 followup PATCH，未实现会让用户端一直转圈
+            const commandName = String(interaction.data?.name ?? '');
+            writeJson(response, 200, {
+                type: INTERACTION_RESPONSE_CHANNEL_MESSAGE_WITH_SOURCE,
+                data: {
+                    content: `处理命令: ${commandName}`,
+                    flags: INTERACTION_FLAG_EPHEMERAL,
+                },
+            });
+            return;
+        }
+        response.writeHead(400, { 'Content-Type': 'text/plain' });
+        response.end('Unsupported interaction type');
+    }
+    catch (error) {
+        logger.error('Discord interactions error:', error);
+        if (!response.headersSent) {
+            response.writeHead(500, { 'Content-Type': 'text/plain' });
+            response.end('Internal Server Error');
+        }
+    }
+}
+function headerValue(value) {
+    if (Array.isArray(value))
+        return value[0] ?? '';
+    return value ?? '';
+}
+async function readInteractionBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 1_048_576) {
+            request.destroy();
+            throw new Error('Request body exceeds 1MB');
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function writeJson(response, status, body) {
+    response.writeHead(status, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify(body));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zhin.js/adapter-discord",
-  "version": "5.0.1",
-  "description": "Zhin.js adapter for Discord",
+  "version": "5.0.3",
+  "description": "Zhin.js Discord adapter for Plugin Runtime (Gateway WebSocket)",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -33,45 +33,48 @@
   },
   "dependencies": {
     "discord.js": "^14.26.4",
-    "tweetnacl": "^1.0.3"
-  },
-  "devDependencies": {
-    "@types/node": "^26.1.0",
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
-    "lucide-react": "^1.22.0",
-    "typescript": "^6.0.3",
-    "@zhin.js/cli": "1.0.92",
-    "@zhin.js/client": "2.0.4",
-    "@zhin.js/contract": "1.0.2",
-    "@zhin.js/host-api": "2.0.4",
-    "@zhin.js/host-router": "2.0.2",
-    "zhin.js": "4.1.1"
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/host-http": "1.0.1",
+    "@zhin.js/logger": "1.0.75",
+    "@zhin.js/plugin-runtime": "1.0.1"
   },
   "peerDependencies": {
-    "@zhin.js/client": "2.0.4",
-    "@zhin.js/host-api": "2.0.4",
-    "@zhin.js/contract": "1.0.2",
-    "@zhin.js/host-router": "2.0.2",
-    "zhin.js": "4.1.1"
+    "zod": "^4.0.0",
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/agent": "1.0.4",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/plugin-runtime": "1.0.1",
+    "zhin.js": "4.1.3"
   },
   "peerDependenciesMeta": {
-    "@zhin.js/client": {
+    "zhin.js": {
+      "optional": true
+    },
+    "@zhin.js/agent": {
       "optional": true
     },
-    "@zhin.js/host-api": {
+    "zod": {
       "optional": true
     }
   },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3",
+    "@zhin.js/agent": "1.0.4",
+    "@zhin.js/host-http": "1.0.1",
+    "zhin.js": "4.1.3"
+  },
   "files": [
+    "adapters",
+    "plugin.ts",
+    "schema.json",
     "src",
     "lib",
-    "client",
-    "dist",
-    "skills",
-    "plugin.yml",
+    "agent",
     "README.md",
-    "node",
     "CHANGELOG.md"
   ],
   "publishConfig": {
@@ -81,9 +84,23 @@
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
+  "zhin": {
+    "protocol": 1,
+    "type": "plugin",
+    "entry": "./plugin.ts",
+    "engine": "^1.0.0",
+    "runtime": "trusted",
+    "features": [
+      {
+        "package": "@zhin.js/adapter",
+        "api": "^1.0.0"
+      }
+    ],
+    "plugins": []
+  },
   "scripts": {
-    "build": "zhin build",
-    "clean": "rimraf lib dist",
-    "build:node": "tsc"
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "test": "NODE_OPTIONS=--experimental-strip-types vitest run --root ../../.. plugins/adapters/discord/tests"
   }
 }

package/plugin.ts

@@ -0,0 +1,13 @@
+import { definePlugin } from '@zhin.js/plugin-runtime';
+import { registerDiscordPlatformPermitChecker } from './src/platform-permit.js';
+
+export default definePlugin({
+  name: 'discord',
+  metadata: {
+    displayName: 'Discord Gateway Adapter',
+  },
+  setup() {
+    // 平台权限门禁：guild_owner / moderate_members 等（agent 工具 platformPermit）
+    return registerDiscordPlatformPermitChecker();
+  },
+});

package/schema.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "default": "discord-bot"
+    },
+    "token": {
+      "type": "string"
+    },
+    "connection": {
+      "type": "string",
+      "enum": ["gateway", "interactions"],
+      "default": "gateway",
+      "description": "Gateway WebSocket (default). interactions uses httpHostToken POST + Ed25519 verify."
+    },
+    "intents": {
+      "type": "array",
+      "items": { "type": "number" }
+    },
+    "enableSlashCommands": {
+      "type": "boolean",
+      "default": false
+    },
+    "globalCommands": {
+      "type": "boolean",
+      "default": false
+    },
+    "defaultActivity": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "name": { "type": "string" },
+        "type": {
+          "type": "string",
+          "enum": ["PLAYING", "STREAMING", "LISTENING", "WATCHING", "COMPETING"]
+        },
+        "url": { "type": "string" }
+      },
+      "required": ["name", "type"]
+    },
+    "slashCommands": {
+      "type": "array",
+      "items": { "type": "object" }
+    },
+    "applicationId": {
+      "type": "string",
+      "description": "Required when connection is interactions."
+    },
+    "publicKey": {
+      "type": "string",
+      "description": "Required when connection is interactions (hex Ed25519 public key)."
+    },
+    "interactionsPath": {
+      "type": "string",
+      "default": "/discord/interactions",
+      "description": "POST path on httpHostToken when connection is interactions."
+    }
+  },
+  "required": ["token"]
+}

package/src/discord-agent-deps.ts

@@ -0,0 +1,79 @@
+/**
+ * Agent tool deps for discord.
+ * Endpoints register themselves on start; tools look up by config name / endpoint id.
+ */
+
+export interface DiscordAgentEndpoint {
+  addRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
+  removeRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
+  getRoles(guildId: string): Promise<unknown[]>;
+  createThread(
+    channelId: string,
+    name: string,
+    messageId?: string,
+    autoArchiveDuration?: number,
+  ): Promise<{ id: string }>;
+  addReaction(channelId: string, messageId: string, emoji: string): Promise<void>;
+  sendEmbed(
+    channelId: string,
+    embedData: Record<string, unknown>,
+  ): Promise<{ id: string }>;
+  createForumPost(
+    channelId: string,
+    name: string,
+    content: string,
+    tags?: string[],
+  ): Promise<{ id: string }>;
+  kickMember(guildId: string, userId: string, reason?: string): Promise<boolean>;
+  banMember(guildId: string, userId: string, reason?: string): Promise<boolean>;
+  unbanMember(guildId: string, userId: string, reason?: string): Promise<boolean>;
+  timeoutMember(
+    guildId: string,
+    userId: string,
+    duration?: number,
+    reason?: string,
+  ): Promise<boolean>;
+  setNickname(guildId: string, userId: string, nickname: string): Promise<boolean>;
+  getMembers(guildId: string, limit?: number): Promise<unknown[]>;
+  getGuildInfo(guildId: string): Promise<unknown>;
+}
+
+export interface DiscordAgentDeps {
+  getEndpoint: (endpointId: string) => DiscordAgentEndpoint;
+  /** Alias kept for existing agent/tools that call getGatewayEndpoint. */
+  getGatewayEndpoint: (endpointId: string) => DiscordAgentEndpoint;
+}
+
+const endpoints = new Map<string, DiscordAgentEndpoint>();
+let override: DiscordAgentDeps | null = null;
+
+export function registerDiscordAgentEndpoint(
+  endpointId: string,
+  endpoint: DiscordAgentEndpoint,
+): () => void {
+  endpoints.set(endpointId, endpoint);
+  return () => {
+    if (endpoints.get(endpointId) === endpoint) {
+      endpoints.delete(endpointId);
+    }
+  };
+}
+
+/** Optional override used by tests / transitional callers. Pass `null` to clear. */
+export function setDiscordAgentDeps(deps: DiscordAgentDeps | null): void {
+  override = deps;
+}
+
+function lookup(endpointId: string): DiscordAgentEndpoint {
+  const registered = endpoints.get(endpointId);
+  if (!registered) throw new Error(`Endpoint ${endpointId} 不存在`);
+  return registered;
+}
+
+export function getDiscordAgentDeps(): DiscordAgentDeps {
+  if (override) return override;
+  return {
+    getEndpoint: lookup,
+    getGatewayEndpoint: lookup,
+  };
+}