@zhin.js/adapter-discord 1.1.3 → 1.1.5

package/src/gateway.ts

@@ -1,7 +1,9 @@
+import { DiscordFaultProxyStrategy } from './gateway-fault-proxy.js';
 import { createReadStream, promises as fs } from 'node:fs';
 import path from 'node:path';
 import {
   Client,
+  Partials,
   GatewayIntentBits,
   EmbedBuilder,
   AttachmentBuilder,
@@ -9,6 +11,7 @@ import {
   ButtonBuilder,
   ButtonStyle,
   REST,
+  type RESTOptions,
   Routes,
   PermissionFlagsBits,
   type MessageCreateOptions,
@@ -37,6 +40,7 @@ export const DEFAULT_INTENTS = [
 
 /** Minimal client surface used by the endpoint (real discord.js or test mock). */
 export interface DiscordClientTransport {
+  isReady?(): boolean;
   login(token: string): Promise<string>;
   destroy(): Promise<void>;
   on(event: string, listener: (...args: unknown[]) => void): void;
@@ -109,10 +113,10 @@ export interface DiscordClientTransport {
   };
 }
 
-export type CreateDiscordClient = (intents: readonly number[]) => DiscordClientTransport;
+export type CreateDiscordClient = (intents: readonly number[], gatewayFaultProxyUrl?: string, restOptions?: Partial<RESTOptions>) => DiscordClientTransport;
 
-export function defaultCreateClient(intents: readonly number[]): DiscordClientTransport {
-  return new Client({ intents: [...intents] }) as unknown as DiscordClientTransport;
+export function defaultCreateClient(intents: readonly number[], gatewayFaultProxyUrl?: string, restOptions: Partial<RESTOptions> = {}): DiscordClientTransport {
+  return new Client({ rest: { ...restOptions, retries: 0, rejectOnRateLimit: () => true }, intents: [...intents], partials: [Partials.Channel], ...(gatewayFaultProxyUrl ? { ws: { buildStrategy: manager => new DiscordFaultProxyStrategy(manager, gatewayFaultProxyUrl) } } : {}) }) as unknown as DiscordClientTransport;
 }
 
 export function resolveSenderRole(msg: DiscordInboundMessage): string | undefined {
@@ -176,6 +180,7 @@ export function normalizeDiscordMessage(raw: unknown): DiscordInboundMessage | n
 
 export async function toMessageCreateOptions(body: DiscordOutboundBody): Promise<MessageCreateOptions> {
   const options: MessageCreateOptions = {};
+  if (body.reply) options.reply = { ...body.reply };
   if (body.content) options.content = body.content;
   if (body.embeds?.length) {
     options.embeds = body.embeds.map((data) => {
@@ -296,9 +301,14 @@ export async function connectDiscordGatewayClient(
   client: DiscordClientTransport,
   config: ResolvedDiscordGatewayConfig,
   handlers: DiscordGatewayConnectHandlers,
+  signal?: AbortSignal,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     let settled = false;
+    const onAbort = () => { if (!settled) { settled = true; reject(new Error('Discord startup stopped')); } };
+    if (signal?.aborted) { onAbort(); return; }
+    signal?.addEventListener('abort', onAbort, { once: true });
+    const releaseAbort = () => signal?.removeEventListener('abort', onAbort);
 
     client.on('messageCreate', (raw) => {
       handlers.onPlatformEvent('messageCreate', raw);
@@ -319,17 +329,31 @@ export async function connectDiscordGatewayClient(
         id: string;
         customId: string;
         channel?: { id: string; type: number } | null;
+        channelId?: string;
+        guildId?: string | 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;
+      const isButton = interaction.isButton?.() === true;
+      logger.info(formatCompact({ op: 'discord_gateway_interaction_received', button: isButton, cachedChannel: !!interaction.channel, hasChannelId: !!interaction.channelId }));
+      if (!isButton) return;
+      void interaction.deferUpdate?.().then(() => {
+        logger.info(formatCompact({ op: 'discord_gateway_button_ack', status: 'confirmed' }));
+      }).catch(() => {
+        // SDK errors may contain token-bearing callback URLs; log no raw error.
+        logger.warn(formatCompact({ op: 'discord_gateway_button_ack', status: 'failed' }));
+      });
+      const channelId = interaction.channelId ?? interaction.channel?.id;
+      if (!channelId) {
+        logger.warn(formatCompact({ op: 'discord_gateway_button_dropped', reason: 'missing_channel_id' }));
+        return;
+      }
       handlers.onButton({
         id: interaction.id,
         customId: interaction.customId,
-        channelId: interaction.channel.id,
-        channelKind: resolveChannelKind(interaction.channel.type),
+        channelId,
+        channelKind: interaction.channel ? resolveChannelKind(interaction.channel.type) : interaction.guildId ? 'channel' : 'private',
+        ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
         userId: interaction.user.id,
         userName: interaction.user.username || interaction.user.displayName || interaction.user.id,
         sourceMessageId: interaction.message?.id,
@@ -369,6 +393,7 @@ export async function connectDiscordGatewayClient(
     });
 
     client.once('clientReady', () => {
+      if (signal?.aborted) return;
       handlers.onPlatformEvent('clientReady', client.user);
       void (async () => {
         try {
@@ -384,11 +409,13 @@ export async function connectDiscordGatewayClient(
           }
           if (!settled) {
             settled = true;
+            releaseAbort();
             resolve();
           }
         } catch (error) {
           if (!settled) {
             settled = true;
+            releaseAbort();
             reject(error);
           }
         }
@@ -399,6 +426,7 @@ export async function connectDiscordGatewayClient(
       logger.error('Discord client error:', error);
       if (!settled) {
         settled = true;
+        releaseAbort();
         reject(error instanceof Error ? error : new Error(String(error)));
       }
     });
@@ -407,9 +435,12 @@ export async function connectDiscordGatewayClient(
       logger.warn('Discord client warning:', info);
     });
 
-    client.login(config.token).catch((error) => {
+    client.login(config.token).then(() => {
+      if (signal?.aborted) void Promise.resolve(client.destroy()).catch(() => {});
+    }).catch((error) => {
       if (!settled) {
         settled = true;
+        releaseAbort();
         const raw = error instanceof Error ? error.message : String(error);
         const tokenShapeHint = config.token.split('.').length === 3
           ? ''

package/src/protocol.ts

@@ -1,3 +1,4 @@
+import { validateDiscordGatewayFaultProxy } from './gateway-fault-proxy.js';
 /** Discord Gateway protocol helpers. Canonicalization is owned by Core. */
 
 import { createPublicKey, verify as cryptoVerify } from 'node:crypto';
@@ -19,6 +20,9 @@ export interface DiscordEndpointConfig {
   readonly token: string;
   /** Default `gateway`. `interactions` uses httpHostToken POST + Ed25519 verify. */
   readonly connection?: 'gateway' | 'interactions';
+  /** Test instance only: ws://127.0.0.1:PORT/ fault proxy. */
+  readonly restApiProxy?: import('./rest-api-proxy.js').DiscordRestApiProxy;
+  readonly gatewayFaultProxyUrl?: string;
   readonly intents?: readonly number[];
   readonly enableSlashCommands?: boolean;
   readonly globalCommands?: boolean;
@@ -35,6 +39,9 @@ export interface ResolvedDiscordGatewayConfig {
   readonly connection: 'gateway';
   readonly id: string;
   readonly token: string;
+  /** Test instance only: ws://127.0.0.1:PORT/ fault proxy. */
+  readonly restApiProxy?: import('./rest-api-proxy.js').DiscordRestApiProxy;
+  readonly gatewayFaultProxyUrl?: string;
   readonly intents?: readonly number[];
   readonly enableSlashCommands: boolean;
   readonly globalCommands: boolean;
@@ -85,6 +92,7 @@ export interface DiscordInboundMessage {
 }
 
 export interface DiscordButtonInbound {
+  readonly guildId?: string;
   readonly id: string;
   readonly customId: string;
   readonly channelId: string;
@@ -113,6 +121,7 @@ export interface DiscordOutboundActionRow {
 }
 
 export interface DiscordOutboundBody {
+  readonly reply?: { readonly messageReference: string; readonly failIfNotExists: boolean };
   readonly content?: string;
   readonly embeds?: ReadonlyArray<Record<string, unknown>>;
   readonly files?: ReadonlyArray<{
@@ -125,6 +134,8 @@ export interface DiscordOutboundBody {
 }
 
 export function resolveDiscordConfig(config: DiscordEndpointConfig): ResolvedDiscordConfig {
+  if (config.restApiProxy && (!Number.isInteger(config.restApiProxy.port) || config.restApiProxy.port < 1 || config.restApiProxy.port > 65535)) throw new TypeError('Invalid Discord restApiProxy port');
+  if (config.restApiProxy && config.connection === 'interactions') throw new TypeError('Discord restApiProxy requires gateway mode');
   const id = requiredEndpointField(config.id, 'id');
   const token = requiredEndpointField(config.token, 'token');
   const connection = config.connection ?? 'gateway';
@@ -148,6 +159,8 @@ export function resolveDiscordConfig(config: DiscordEndpointConfig): ResolvedDis
     connection: 'gateway',
     id,
     token,
+    ...(config.restApiProxy ? { restApiProxy: config.restApiProxy } : {}),
+    gatewayFaultProxyUrl: config.gatewayFaultProxyUrl ? validateDiscordGatewayFaultProxy(config.gatewayFaultProxyUrl) : undefined,
     intents: config.intents,
     enableSlashCommands: config.enableSlashCommands === true,
     globalCommands: config.globalCommands === true,
@@ -306,6 +319,7 @@ export function formatOutboundBody(payload: unknown): DiscordOutboundBody {
   const embeds: Record<string, unknown>[] = [];
   const files: Array<{ name: string; url?: string; file?: string; base64?: string }> = [];
   let components: DiscordOutboundBody['components'];
+  let reply: DiscordOutboundBody['reply'];
 
   for (const item of segments) {
     if (typeof item === 'string') {
@@ -348,8 +362,13 @@ export function formatOutboundBody(payload: unknown): DiscordOutboundBody {
           }));
           break;
         }
+        const extension = ({
+          'image/png': 'png', 'image/jpeg': 'jpg', 'image/gif': 'gif',
+          'image/webp': 'webp', 'audio/mpeg': 'mp3', 'audio/ogg': 'ogg',
+          'audio/wav': 'wav', 'video/mp4': 'mp4', 'video/webm': 'webm',
+        } as Record<string, string>)[media.mime_type?.split(';')[0].trim().toLowerCase() ?? ''];
         const name = media.file_name
-          ?? (typeof data.name === 'string' && data.name ? data.name : item.type);
+          ?? (typeof data.name === 'string' && data.name ? data.name : `${item.type}${extension ? `.${extension}` : ''}`);
         if (media.kind === 'url') {
           files.push({ name, url: media.value });
         } else if (media.kind === 'base64') {
@@ -367,6 +386,14 @@ export function formatOutboundBody(payload: unknown): DiscordOutboundBody {
         }
         break;
       }
+      case 'reply':
+        if (typeof data.message_id === 'string' && data.message_id) {
+          reply = { messageReference: data.message_id, failIfNotExists: true };
+        }
+        break;
+      case 'share':
+        embeds.push({ title: String(data.title ?? ''), url: String(data.url ?? ''), description: String(data.description ?? data.content ?? ''), ...(data.image ? { image: { url: String(data.image) } } : {}) });
+        break;
       case 'embed':
         embeds.push({ ...data });
         break;
@@ -400,6 +427,7 @@ export function formatOutboundBody(payload: unknown): DiscordOutboundBody {
     ...(embeds.length > 0 ? { embeds: embeds.slice(0, 10) } : {}),
     ...(files.length > 0 ? { files } : {}),
     ...(components ? { components } : {}),
+    ...(reply ? { reply } : {}),
   };
 }
 

package/src/rest-api-proxy.ts

@@ -0,0 +1,37 @@
+import tls from 'node:tls';
+import { Agent } from 'undici';
+
+export interface DiscordRestApiProxy { readonly port: number }
+
+/** JSON REST only, fixed Discord TLS identity and loopback TCP route. */
+export function createDiscordRestApiAgent(proxy: DiscordRestApiProxy): Agent & { destroyProxy(): Promise<void> } {
+  const pending = new Set<() => void>();
+  let closed = false;
+  const agent = new Agent({ connect(options, callback) {
+    if (closed) { queueMicrotask(() => callback(new Error('Discord REST proxy stopped'), null)); return; }
+    if (options.hostname !== 'discord.com' || options.protocol !== 'https:' || Number(options.port || 443) !== 443) {
+      queueMicrotask(() => callback(new Error('Discord REST proxy rejected destination identity'), null));
+      return;
+    }
+    const socket = tls.connect({ host: '127.0.0.1', port: proxy.port,
+      servername: 'discord.com', rejectUnauthorized: true, ALPNProtocols: ['http/1.1'] });
+    let complete = false;
+    const finish = (error?: Error) => {
+      if (complete) return; complete = true;
+      pending.delete(cancel);
+      clearTimeout(timer); socket.off('error', onError);
+      if (error) { socket.destroy(); callback(error, null); }
+      else callback(null, socket);
+    };
+    const cancel = () => finish(new Error('Discord REST proxy stopped'));
+    pending.add(cancel);
+    const onError = (error: Error) => finish(error);
+    const timer = setTimeout(() => finish(new Error('Discord REST proxy TLS connection timed out')), 10_000);
+    timer.unref(); socket.once('error', onError); socket.once('secureConnect', () => finish());
+  } });
+  return Object.assign(agent, { async destroyProxy() {
+    closed = true;
+    for (const cancel of [...pending]) cancel();
+    await agent.destroy();
+  } });
+}

package/src/side-event-dispatch.ts

@@ -1,4 +1,4 @@
-import { buildNotice, senderFromId } from '@zhin.js/core';
+import { composeSideEventName, buildNotice, senderFromId } from '@zhin.js/core';
 import type { EndpointEventEmitter } from 'zhin.js/adapter';
 import { formatCompact, type getAdapterLogger } from '@zhin.js/logger';
 
@@ -17,15 +17,14 @@ export function receiveDiscordGuildMemberSideEvent(
 ): void {
   if (!emit) return;
   void emit('notice.receive', buildNotice(event, {
-    $id: `discord:guild_member:${kind}:${event.guildId}:${event.userId}:${Date.now()}`,
-    $adapter: 'discord' as never,
-    $endpoint: configId,
-    $type: 'notice',
-    $scene_id: event.guildId,
-    $scene_type: 'group',
-    $sub_type: kind,
-    $actor: senderFromId(event.userId, event.userName),
-    $timestamp: Date.now(),
+    id: `discord:guild_member:${kind}:${event.guildId}:${event.userId}:${Date.now()}`,
+    clientAdapter: 'discord',
+    endpointId: configId,
+    type: 'notice',
+    // Guild membership does not identify a replyable channel.
+    name: composeSideEventName('notice', 'group', kind),
+    target: senderFromId(event.userId, event.userName),
+    timestamp: Date.now(),
   })).catch((err) => {
     logger.warn(formatCompact({
       op: 'discord_side_event_failed',

package/src/webhook.ts

@@ -8,6 +8,7 @@ import {
   interactionToInboundMessage,
   verifyDiscordInteractionSignature,
   type DiscordInboundMessage,
+  type DiscordButtonInbound,
   type ResolvedDiscordInteractionsConfig,
 } from './protocol.js';
 
@@ -24,6 +25,7 @@ export interface DiscordInteractionsHandler {
   readonly config: ResolvedDiscordInteractionsConfig;
   readonly isOpen: boolean;
   admit(msg: DiscordInboundMessage): void;
+  admitButton(interaction: DiscordButtonInbound): void;
   admitPlatform(event: Record<string, unknown>): void;
 }
 
@@ -69,6 +71,16 @@ export async function handleDiscordInteractionRequest(
       writeJson(response, 200, { type: INTERACTION_RESPONSE_PONG });
       return;
     }
+    if (interaction.type === 3) {
+      const data = interaction.data as { component_type?: number; custom_id?: string } | undefined;
+      if (data?.component_type === 2 && typeof data.custom_id === 'string') {
+        if (!handler.isOpen) { response.writeHead(503); response.end('Unavailable'); return; }
+        const message = interactionToInboundMessage(interaction);
+        handler.admitButton({ id: message.id, customId: data.custom_id, channelId: message.channelId, channelKind: message.channelKind, userId: message.authorId, userName: message.authorName, ...(message.guildId ? { guildId: message.guildId } : {}), sourceMessageId: (interaction.message as { id?: string } | undefined)?.id });
+        writeJson(response, 200, { type: 6 });
+        return;
+      }
+    }
     if (interaction.type === INTERACTION_TYPE_APPLICATION_COMMAND) {
       if (handler.isOpen) {
         handler.admit(interactionToInboundMessage(interaction));