@zhin.js/adapter-discord 5.0.2 → 6.0.0

package/src/gateway.ts

@@ -0,0 +1,337 @@
+import { createReadStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+import {
+  Client,
+  GatewayIntentBits,
+  EmbedBuilder,
+  AttachmentBuilder,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  REST,
+  Routes,
+  PermissionFlagsBits,
+  type MessageCreateOptions,
+  type Message as DiscordMessage,
+} from 'discord.js';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import {
+  activityTypeCode,
+  resolveChannelKind,
+  type DiscordButtonInbound,
+  type DiscordInboundMessage,
+  type DiscordOutboundBody,
+  type ResolvedDiscordGatewayConfig,
+} from './protocol.js';
+
+const logger = getLogger('discord');
+
+export const DEFAULT_INTENTS = [
+  GatewayIntentBits.Guilds,
+  GatewayIntentBits.GuildMessages,
+  GatewayIntentBits.MessageContent,
+  GatewayIntentBits.DirectMessages,
+  GatewayIntentBits.GuildMembers,
+  GatewayIntentBits.GuildMessageReactions,
+];
+
+/** Minimal client surface used by the endpoint (real discord.js or test mock). */
+export interface DiscordClientTransport {
+  login(token: string): Promise<string>;
+  destroy(): Promise<void>;
+  on(event: string, listener: (...args: unknown[]) => void): void;
+  once(event: string, listener: (...args: unknown[]) => void): void;
+  removeAllListeners(): void;
+  readonly user?: {
+    readonly id: string;
+    readonly tag?: string;
+    setActivity?(name: string, options?: { type?: number; url?: string }): void;
+  } | null;
+  channels: {
+    fetch(id: string): Promise<{
+      id: string;
+      type: number;
+      isTextBased(): boolean;
+      send?(options: MessageCreateOptions): Promise<{ id: string }>;
+      messages?: {
+        fetch(id: string): Promise<{
+          react(emoji: string): Promise<unknown>;
+          reactions: {
+            resolve(emoji: unknown): { users: { remove(userId: string): Promise<unknown> } } | null;
+            cache: { find(fn: (r: { emoji: { toString(): string; name?: string | null; id?: string | null } }) => boolean): { users: { remove(userId: string): Promise<unknown> } } | undefined };
+          };
+        }>;
+      };
+      threads?: {
+        create(options: Record<string, unknown>): Promise<{ id: string }>;
+      };
+      availableTags?: Array<{ id: string; name: string }>;
+    } | null>;
+  };
+  guilds: {
+    fetch(id: string): Promise<{
+      id: string;
+      name: string;
+      ownerId: string;
+      memberCount: number;
+      createdAt?: Date | null;
+      iconURL?(options?: { size?: number }): string | null;
+      roles: {
+        fetch(): Promise<unknown>;
+        cache: Map<string, {
+          id: string;
+          name: string;
+          hexColor: string;
+          position: number;
+          permissions: { bitfield: bigint };
+        }> | { map(fn: (role: {
+          id: string;
+          name: string;
+          hexColor: string;
+          position: number;
+          permissions: { bitfield: bigint };
+        }) => unknown): unknown[] };
+      };
+      members: {
+        fetch(userId: string | { limit?: number }): Promise<unknown>;
+        ban(userId: string, options?: { reason?: string; deleteMessageSeconds?: number }): Promise<unknown>;
+        unban(userId: string, reason?: string): Promise<unknown>;
+      };
+    }>;
+    cache: { values(): IterableIterator<{ id: string }> };
+  };
+}
+
+export type CreateDiscordClient = (intents: readonly number[]) => DiscordClientTransport;
+
+export function defaultCreateClient(intents: readonly number[]): DiscordClientTransport {
+  return new Client({ intents: [...intents] }) as unknown as DiscordClientTransport;
+}
+
+export function resolveSenderRole(msg: DiscordInboundMessage): string | undefined {
+  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: unknown): DiscordInboundMessage | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const msg = raw as DiscordMessage;
+  if (!msg.author || !msg.channel) return null;
+
+  const permissionTokens: string[] = [];
+  let isGuildOwner = false;
+  const member = msg.member;
+  const guild = msg.guild;
+  if (member && guild) {
+    const checks: Array<[bigint, string]> = [
+      [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) as string[],
+    stickerNames: [...msg.stickers.values()].map((s) => s.name),
+    replyToId: msg.reference?.messageId ?? undefined,
+  };
+}
+
+export async function toMessageCreateOptions(body: DiscordOutboundBody): Promise<MessageCreateOptions> {
+  const options: MessageCreateOptions = {};
+  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 as number);
+      if (data.url) embed.setURL(String(data.url));
+      const thumb = data.thumbnail as { url?: string } | undefined;
+      if (thumb?.url) embed.setThumbnail(thumb.url);
+      const image = data.image as { url?: string } | undefined;
+      if (image?.url) embed.setImage(image.url);
+      if (data.author) embed.setAuthor(data.author as { name: string });
+      if (data.footer) embed.setFooter(data.footer as { text: string });
+      if (data.timestamp) embed.setTimestamp(new Date(String(data.timestamp)));
+      if (Array.isArray(data.fields)) embed.addFields(data.fields as Array<{ name: string; value: string }>);
+      return embed;
+    });
+  }
+  if (body.files?.length) {
+    const files: AttachmentBuilder[] = [];
+    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<ButtonBuilder>().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: ResolvedDiscordGatewayConfig,
+  applicationId: string,
+): Promise<void> {
+  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: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface DiscordGatewayConnectHandlers {
+  onMessage(msg: DiscordInboundMessage): void;
+  onButton(interaction: DiscordButtonInbound): void;
+}
+
+export async function connectDiscordGatewayClient(
+  client: DiscordClientTransport,
+  config: ResolvedDiscordGatewayConfig,
+  handlers: DiscordGatewayConnectHandlers,
+): Promise<void> {
+  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 as DiscordMessage).mentions;
+      const mentionedBot = !!botId && mentions?.users?.has?.(botId) === true;
+      handlers.onMessage(mentionedBot ? { ...msg, mentionedBot: true } : msg);
+    });
+
+    client.on('interactionCreate', (raw) => {
+      const interaction = raw as {
+        isButton?(): boolean;
+        deferUpdate?(): Promise<unknown>;
+        id: string;
+        customId: string;
+        channel?: { id: string; type: number } | null;
+        user: { id: string; username?: string; displayName?: string };
+        message?: { id: string };
+      };
+      if (!interaction.isButton?.()) return;
+      void interaction.deferUpdate?.().catch(() => { /* already ack */ });
+      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/src/index.ts

@@ -1,159 +1,58 @@
-/**
- * Discord 适配器入口：单一适配器，支持 Gateway / Interactions（connection: gateway | interactions）
- */
-import path from "node:path";
-import { usePlugin, type Plugin, type Context, type ISceneManagement, createSceneManagementTools, type ToolFeature } from "zhin.js";
-import type { Router } from "@zhin.js/host-router";
-import { PageManager } from "@zhin.js/host-api";
-import { DiscordAdapter } from "./adapter.js";
-import {
+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";
-import { setDiscordAgentDeps } from "./discord-agent-deps.js";
-
-declare module "zhin.js" {
-  namespace Plugin {
-    interface Contexts {
-      router: import("@zhin.js/host-router").Router;
-      web: PageManager;
-    }
-  }
-  interface Adapters {
-    discord: DiscordAdapter;
-  }
-}
-
-export * from "./types.js";
-export { DiscordEndpoint } from "./endpoint.js";
-export { DiscordInteractionsEndpoint } from "./endpoint-interactions.js";
-export { DiscordAdapter, type DiscordEndpointLike } from "./adapter.js";
-
-const plugin = usePlugin();
-const { provide, useContext } = plugin;
-provide({
-  name: "discord",
-  description: "Discord 适配器（Gateway / Interactions）",
-  mounted: async (p: Plugin) => {
-    const adapter = new DiscordAdapter(p);
-    await adapter.start();
-    return adapter;
-  },
-  dispose: async (adapter: DiscordAdapter) => {
-    await adapter.stop();
-  },
-});
-
-useContext('tool', 'discord', (toolService: ToolFeature, discord: DiscordAdapter) => {
-  const disposers: (() => void)[] = [];
-  disposers.push(registerDiscordPlatformPermitChecker());
-  setDiscordAgentDeps({
-    getEndpoint: (endpointId) => {
-      const endpoint = discord.endpoints.get(endpointId);
-      if (!endpoint) throw new Error(`Endpoint ${endpointId} 不存在`);
-      return endpoint;
-    },
-    getGatewayEndpoint: (endpointId) => {
-      const endpoint = discord.endpoints.get(endpointId);
-      if (!endpoint) throw new Error(`Endpoint ${endpointId} 不存在`);
-      if ((endpoint.$config as { connection?: string }).connection !== 'gateway') {
-        throw new Error('此工具仅支持 connection: gateway');
-      }
-      return endpoint;
-    },
-    getAdapter: () => discord,
-  });
-  const sceneTools = createSceneManagementTools(
-    discord as unknown as ISceneManagement,
-    'discord',
-    { permitResolver: discordGroupPermitResolver, registerChecker: false },
-  );
-  disposers.push(...sceneTools.map(t => toolService.addTool(t, 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: Router, discord: DiscordAdapter) => {
-  router.get("/api/discord/endpoints", async (ctx: any) => {
-    try {
-      const endpoints = Array.from(discord.endpoints.values());
-      const result = endpoints.map((endpoint: any) => {
-        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: any) => {
-    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: unknown) {
-      ctx.status = 500;
-      ctx.body = { success: false, error: e instanceof Error ? e.message : "连接失败" };
-    }
-  });
-
-  router.post("/api/discord/endpoints/:name/disconnect", async (ctx: any) => {
-    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: unknown) {
-      ctx.status = 500;
-      ctx.body = { success: false, error: e instanceof Error ? e.message : "断开失败" };
-    }
-  });
-
-  // 服务器列表（仅 Gateway 模式）
-  router.get("/api/discord/endpoints/:name/guilds", async (ctx: any) => {
-    try {
-      const endpoint: any = 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: any) => ({
-        id: g.id,
-        name: g.name,
-        memberCount: g.memberCount,
-        icon: g.iconURL({ size: 64 }),
-      })) || [];
-      ctx.body = { success: true, data: guilds };
-    } catch (e: unknown) {
-      ctx.status = 500;
-      ctx.body = { success: false, error: e instanceof Error ? e.message : "获取服务器列表失败" };
-    }
-  });
-});
+} 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/src/platform-permit.ts

@@ -1,7 +1,7 @@
 /**
  * Discord platform permit — Guild 权限位
  */
-import { registerPlatformPermitChecker, type Message } from 'zhin.js';
+import { registerPlatformPermitChecker, type Message } from '@zhin.js/core';
 
 const ADAPTER = 'discord';