@discord-selfbot/core 14.0.1 → 14.0.2

package/docs/README.md

@@ -1,6 +1,6 @@
 # Agent docs
 
-Version-matched documentation for `@discord-selfbot/core@14.0.1`.
+Version-matched documentation for `@discord-selfbot/core@14.0.2`.
 
 Start at [`llms.txt`](./llms.txt). The `reference/` tree is generated from the public typings and the API prose store; the guides and examples are generated from `apps/docs/content/docs`. Do not edit this tree by hand.
 

package/docs/llms.txt

@@ -1,4 +1,4 @@
-# @discord-selfbot/core 14.0.1 — Agent docs
+# @discord-selfbot/core 14.0.2 — Agent docs
 
 Version-matched documentation for coding agents. Read this file first, then open the page for the task. The reference is generated from the public typings; exact types stay in `typings/index.d.ts`.
 

package/docs/reference/index.md

@@ -1,6 +1,6 @@
 # API reference
 
-Public runtime surface of `@discord-selfbot/core@14.0.1`. Every page is generated from `typings/index.d.ts`.
+Public runtime surface of `@discord-selfbot/core@14.0.2`. Every page is generated from `typings/index.d.ts`.
 
 Type-only exports stay in `typings/index.d.ts`; this reference does not repeat them.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord-selfbot/core",
-  "version": "14.0.1",
+  "version": "14.0.2",
   "description": "An unofficial discord.js fork for creating selfbots, migrated to TypeScript and ESM",
   "keywords": [
     "api",

package/src/client/BaseClient.ts

@@ -20,6 +20,8 @@ class BaseClient extends EventEmitter {
     }
 
     this.options = Util.mergeDefault(Options.createDefault(), options);
+    this.options.ws.properties.browser_user_agent =
+      this.options.http.headers['User-Agent'];
 
     this.rest = new RESTManager(this);
   }

package/src/client/Client.ts

@@ -347,6 +347,7 @@ class Client extends BaseClient {
     this.ws = new WebSocketManager(this);
 
     this.actions = new ActionsManager(this);
+    this.ws.dispatch.registerDefaults(this.actions);
 
     this.voice = new ClientVoiceManager(this);
 

package/src/client/WebhookClient.ts

@@ -7,12 +7,26 @@ import type { WebhookClientData, ClientOptions } from '../../typings';
 
 const { Error } = _errorsModule;
 
+let _webhookPatched = false;
+
 class WebhookClient extends BaseClient {
   declare id: string | null;
 
   constructor(data: WebhookClientData, options?: ClientOptions) {
     super(options);
     Object.defineProperty(this, 'client', { value: this });
+    if (!_webhookPatched) {
+      try {
+        const WebhookMod = require('../structures/Webhook');
+        const Webhook = WebhookMod.default ?? WebhookMod;
+        if (typeof Webhook.applyToClass === 'function') {
+          Webhook.applyToClass(WebhookClient);
+          _webhookPatched = true;
+        }
+      } catch {
+        // Ignore a missing Webhook structure module.
+      }
+    }
     let id: string | null = null;
     let token: string | null = null;
 
@@ -68,12 +82,3 @@ class WebhookClient extends BaseClient {
 
 export default WebhookClient;
 export { WebhookClient };
-
-setTimeout(() => {
-  try {
-    const Webhook = require('../structures/Webhook');
-    Webhook.applyToClass(WebhookClient);
-  } catch {
-    // Ignore a missing Webhook structure module.
-  }
-}, 0);

package/src/client/websocket/GatewayDispatch.ts

@@ -0,0 +1,192 @@
+import { setImmediate } from 'node:timers';
+import PacketHandlers from './handlers';
+import _ConstantsModule from '../../util/Constants';
+import type Client from '../Client';
+import type WebSocketShard from './WebSocketShard';
+import type ActionsManager from '../actions/ActionsManager';
+
+const { Events, Status, WSEvents } = _ConstantsModule;
+
+export interface GatewayPacket {
+  ['t']?: string;
+  ['d']?: unknown;
+  ['op']?: number;
+  ['s']?: number;
+}
+
+type PacketHandler = (
+  client: Client,
+  packet: GatewayPacket,
+  shard?: WebSocketShard
+) => unknown;
+
+interface ActionLike {
+  handle: (data: unknown, shard?: WebSocketShard) => unknown;
+}
+
+const BEFORE_READY_WHITELIST = new Set<string>([
+  WSEvents.READY,
+  WSEvents.RESUMED,
+  WSEvents.GUILD_CREATE,
+  WSEvents.GUILD_DELETE,
+  WSEvents.GUILD_MEMBERS_CHUNK,
+  WSEvents.GUILD_MEMBER_ADD,
+  WSEvents.GUILD_MEMBER_REMOVE,
+]);
+
+const ACTION_EVENT_TYPES = [
+  'APPLICATION_COMMAND_PERMISSIONS_UPDATE',
+  'AUTO_MODERATION_ACTION_EXECUTION',
+  'AUTO_MODERATION_RULE_CREATE',
+  'AUTO_MODERATION_RULE_DELETE',
+  'AUTO_MODERATION_RULE_UPDATE',
+  'CHANNEL_CREATE',
+  'CHANNEL_DELETE',
+  'CHANNEL_UPDATE',
+  'GUILD_AUDIT_LOG_ENTRY_CREATE',
+  'GUILD_BAN_ADD',
+  'GUILD_BAN_REMOVE',
+  'GUILD_CHANNELS_POSITION_UPDATE',
+  'GUILD_DELETE',
+  'GUILD_EMOJI_CREATE',
+  'GUILD_EMOJI_DELETE',
+  'GUILD_EMOJI_UPDATE',
+  'GUILD_EMOJIS_UPDATE',
+  'GUILD_INTEGRATIONS_UPDATE',
+  'GUILD_MEMBER_REMOVE',
+  'GUILD_MEMBER_UPDATE',
+  'GUILD_ROLE_CREATE',
+  'GUILD_ROLE_DELETE',
+  'GUILD_ROLE_UPDATE',
+  'GUILD_ROLES_POSITION_UPDATE',
+  'GUILD_SCHEDULED_EVENT_CREATE',
+  'GUILD_SCHEDULED_EVENT_DELETE',
+  'GUILD_SCHEDULED_EVENT_UPDATE',
+  'GUILD_SCHEDULED_EVENT_USER_ADD',
+  'GUILD_SCHEDULED_EVENT_USER_REMOVE',
+  'GUILD_STICKER_CREATE',
+  'GUILD_STICKER_DELETE',
+  'GUILD_STICKER_UPDATE',
+  'GUILD_STICKERS_UPDATE',
+  'GUILD_UPDATE',
+  'INVITE_CREATE',
+  'INVITE_DELETE',
+  'MESSAGE_CREATE',
+  'MESSAGE_DELETE',
+  'MESSAGE_DELETE_BULK',
+  'MESSAGE_POLL_VOTE_ADD',
+  'MESSAGE_POLL_VOTE_REMOVE',
+  'MESSAGE_REACTION_ADD',
+  'MESSAGE_REACTION_REMOVE',
+  'MESSAGE_REACTION_REMOVE_ALL',
+  'MESSAGE_REACTION_REMOVE_EMOJI',
+  'MESSAGE_UPDATE',
+  'PRESENCE_UPDATE',
+  'STAGE_INSTANCE_CREATE',
+  'STAGE_INSTANCE_DELETE',
+  'STAGE_INSTANCE_UPDATE',
+  'THREAD_CREATE',
+  'THREAD_DELETE',
+  'THREAD_LIST_SYNC',
+  'THREAD_MEMBER_UPDATE',
+  'THREAD_MEMBERS_UPDATE',
+  'TYPING_START',
+  'USER_UPDATE',
+  'VOICE_STATE_UPDATE',
+  'WEBHOOKS_UPDATE',
+] as const;
+
+function toActionPropertyName(eventType: string): string {
+  return eventType
+    .split('_')
+    .map((part) => part.charAt(0) + part.slice(1).toLowerCase())
+    .join('');
+}
+
+function isActionLike(value: unknown): value is ActionLike {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'handle' in value &&
+    typeof (value as { handle?: unknown }).handle === 'function'
+  );
+}
+
+export class GatewayDispatch {
+  private readonly client: Client;
+  private readonly packetQueue: {
+    packet: GatewayPacket;
+    shard?: WebSocketShard;
+  }[] = [];
+  private readonly registry = new Map<string, PacketHandler>();
+
+  constructor(client: Client) {
+    this.client = client;
+  }
+
+  registerDefaults(actions: ActionsManager): void {
+    const handlers = PacketHandlers as Record<
+      string,
+      PacketHandler | undefined
+    >;
+    for (const [eventType, handler] of Object.entries(handlers)) {
+      if (typeof handler === 'function') {
+        this.registry.set(eventType, handler);
+      }
+    }
+
+    for (const eventType of ACTION_EVENT_TYPES) {
+      if (this.registry.has(eventType)) {
+        continue;
+      }
+      const actionName = toActionPropertyName(eventType);
+      const action = Reflect.get(actions, actionName);
+      if (!isActionLike(action)) {
+        continue;
+      }
+      this.registry.set(eventType, (_client, packet, shard) =>
+        action.handle(packet.d, shard)
+      );
+    }
+  }
+
+  handle(packet?: GatewayPacket, shard?: WebSocketShard): boolean {
+    const manager = this.client.ws;
+
+    if (
+      packet &&
+      manager.status !== Status.READY &&
+      !BEFORE_READY_WHITELIST.has(packet.t ?? '')
+    ) {
+      this.packetQueue.push({ packet, shard });
+      return false;
+    }
+
+    if (this.packetQueue.length) {
+      const item = this.packetQueue.shift();
+      if (item) {
+        setImmediate(() => {
+          this.handle(item.packet, item.shard);
+        }).unref();
+      }
+    }
+
+    if (!packet) {
+      return true;
+    }
+
+    const eventType = packet.t;
+    if (eventType) {
+      const handler = this.registry.get(eventType);
+      if (handler) {
+        handler(this.client, packet, shard);
+        return true;
+      }
+    }
+
+    this.client.emit(Events.UNHANDLED_PACKET, packet, shard);
+    return true;
+  }
+}
+
+export default GatewayDispatch;

package/src/client/websocket/WebSocketManager.ts

@@ -1,33 +1,16 @@
 import EventEmitter from 'node:events';
-import { setImmediate } from 'node:timers';
 import { Collection } from '@discordjs/collection';
 import { RPCErrorCodes } from 'discord-api-types/v10';
 import WebSocketShard from './WebSocketShard';
-import PacketHandlers from './handlers';
+import GatewayDispatch from './GatewayDispatch';
+import type { GatewayPacket } from './GatewayDispatch';
 import _errorsModule from '../../errors';
 
 const { Error } = _errorsModule;
 import _ConstantsModule from '../../util/Constants';
 import type Client from '../Client';
 
-const { Events, ShardEvents, Status, WSCodes, WSEvents } = _ConstantsModule;
-
-const BeforeReadyWhitelist: readonly string[] = [
-  WSEvents.READY,
-  WSEvents.RESUMED,
-  WSEvents.GUILD_CREATE,
-  WSEvents.GUILD_DELETE,
-  WSEvents.GUILD_MEMBERS_CHUNK,
-  WSEvents.GUILD_MEMBER_ADD,
-  WSEvents.GUILD_MEMBER_REMOVE,
-];
-
-interface GatewayPacket {
-  ['t']?: string;
-  d?: unknown;
-  op?: number;
-  s?: number;
-}
+const { Events, ShardEvents, Status, WSCodes } = _ConstantsModule;
 
 interface GatewayInfo {
   url: string;
@@ -56,7 +39,7 @@ class WebSocketManager extends EventEmitter {
   declare totalShards: number;
   declare shards: Collection<number, WebSocketShard>;
   declare shardQueue: Set<WebSocketShard>;
-  declare packetQueue: { packet: GatewayPacket; shard?: WebSocketShard }[];
+  declare dispatch: GatewayDispatch;
   declare status: number;
   declare destroyed: boolean;
   declare reconnecting: boolean;
@@ -79,7 +62,7 @@ class WebSocketManager extends EventEmitter {
       writable: true,
     });
 
-    Object.defineProperty(this, 'packetQueue', { value: [] });
+    this.dispatch = new GatewayDispatch(client);
 
     this.status = Status.IDLE;
 
@@ -319,45 +302,7 @@ class WebSocketManager extends EventEmitter {
   }
 
   handlePacket(packet?: GatewayPacket, shard?: WebSocketShard) {
-    if (
-      packet &&
-      this.status !== Status.READY &&
-      !BeforeReadyWhitelist.includes(packet.t ?? '')
-    ) {
-      this.packetQueue.push({ packet, shard });
-      return false;
-    }
-
-    if (this.packetQueue.length) {
-      const item = this.packetQueue.shift();
-      if (item) {
-        setImmediate(() => {
-          this.handlePacket(item.packet, item.shard);
-        }).unref();
-      }
-    }
-
-    if (packet?.t && PacketHandlers[packet.t]) {
-      PacketHandlers[packet.t](this.client, packet, shard);
-    } else if (packet) {
-      const actionName = String(packet.t || '')
-        .split('_')
-        .map((part) => part.charAt(0) + part.slice(1).toLowerCase())
-        .join('');
-      const action = Reflect.get(this.client.actions, actionName);
-      if (
-        action &&
-        typeof action === 'object' &&
-        'handle' in action &&
-        typeof action.handle === 'function'
-      ) {
-        Reflect.apply(action.handle, action, [packet.d, shard]);
-        return true;
-      }
-      this.client.emit(Events.UNHANDLED_PACKET, packet, shard);
-    }
-
-    return true;
+    return this.dispatch.handle(packet, shard);
   }
 
   checkShardsReady() {

package/src/managers/GuildForumThreadManager.ts

@@ -4,8 +4,9 @@ import _errorsModule from '../errors';
 const { TypeError } = _errorsModule;
 import MessagePayload from '../structures/MessagePayload';
 import _UtilModule from '../util/Util';
+import { uploadMessageAttachments } from '../util/OutboundMessagePipeline';
 
-const { resolveAutoArchiveMaxLimit, getUploadURL, uploadFile } = _UtilModule;
+const { resolveAutoArchiveMaxLimit } = _UtilModule;
 import type { RESTPostAPIChannelThreadsResult } from 'discord-api-types/v10';
 import type { GuildForumThreadCreateOptions } from '../../typings';
 import type { MessagePayloadOptions } from '../structures/MessagePayload';
@@ -36,34 +37,10 @@ class GuildForumThreadManager extends ThreadManager {
         : MessagePayload.create(this, message).resolveData();
 
     const { data: body, files } = await messagePayload.resolveFiles();
-    const fileList = files ?? [];
-
-    // New API
-    const attachments = await getUploadURL(
+    const attachmentsData = await uploadMessageAttachments(
       this.client,
       this.channel.id,
-      fileList
-    );
-    const requestPromises = attachments.map(async (attachment) => {
-      const index = Number(attachment.id);
-      const file = fileList[index];
-      if (!file) {
-        throw new TypeError('GUILD_FORUM_ATTACHMENT_MISSING');
-      }
-      await uploadFile(file.file, attachment.upload_url);
-      return {
-        description: file.description,
-        duration_secs: file.duration_secs,
-        filename: file.name,
-        id: attachment.id,
-        uploaded_filename: attachment.upload_filename,
-        waveform: file.waveform,
-      };
-    });
-    const attachmentsData = await Promise.all(requestPromises);
-    attachmentsData.sort(
-      (left, right) =>
-        Math.trunc(Number(left.id)) - Math.trunc(Number(right.id))
+      files ?? []
     );
 
     let archiveDuration = autoArchiveDuration;

package/src/managers/MessageManager.ts

@@ -9,6 +9,7 @@ const { Message } = _MessageModule;
 import MessagePayload from '../structures/MessagePayload';
 import type { MessagePayloadOptions } from '../structures/MessagePayload';
 import Util from '../util/Util';
+import { uploadMessageAttachments } from '../util/OutboundMessagePipeline';
 import type { Snowflake } from 'discord-api-types/v10';
 import type {
   BaseFetchOptions,
@@ -22,7 +23,6 @@ import type {
 import type { RawMessageData, RawUserData } from '../../typings/rawDataTypes';
 import type { Message as SourceMessage } from '../structures/Message';
 import type { User } from '../structures/User';
-import type { UploadAttachment } from '../types/uploads';
 import type { Client } from '../client/Client';
 import type { Guild } from '../structures/Guild';
 
@@ -184,35 +184,10 @@ class MessageManager extends CachedManager<SourceMessage> {
       .resolveData()
       .resolveFiles();
 
-    const fileList = files ?? [];
-
-    // New API
-    const attachments = await Util.getUploadURL(
+    const attachmentsData = await uploadMessageAttachments(
       this.client,
       this.channel.id,
-      fileList
-    );
-    const requestPromises = attachments.map(
-      async (attachment: UploadAttachment) => {
-        const file = fileList[Number(attachment.id)];
-        if (!file) {
-          throw new TypeError('INVALID_TYPE', 'attachment', 'FileOptions');
-        }
-        await Util.uploadFile(file.file, attachment.upload_url);
-        return {
-          description: file.description,
-          duration_secs: file.duration_secs,
-          filename: file.name,
-          id: attachment.id,
-          uploaded_filename: attachment.upload_filename,
-          waveform: file.waveform,
-        };
-      }
-    );
-    const attachmentsData = await Promise.all(requestPromises);
-    attachmentsData.sort(
-      (left, right) =>
-        Math.trunc(Number(left.id)) - Math.trunc(Number(right.id))
+      files ?? []
     );
     if (data) {
       Object.assign(data, { attachments: attachmentsData });

package/src/rest/APIRequest.ts

@@ -1,15 +1,9 @@
 import { Buffer } from 'node:buffer';
 import { setTimeout } from 'node:timers';
-import { FormData, buildConnector, Client, ProxyAgent } from 'undici';
-import _ConstantsModule from '../util/Constants';
-
-const { ciphers } = _ConstantsModule;
-import Util from '../util/Util';
+import { FormData } from 'undici';
 import type RESTManager from '../rest/RESTManager';
 import type { BaseClient } from '../client/BaseClient';
 
-let agent: unknown = null;
-
 class APIRequest {
   rest: RESTManager;
   client: BaseClient;
@@ -37,10 +31,6 @@ class APIRequest {
       this.client.options as { http: { headers: Record<string, string> } }
     ).http.headers['User-Agent'];
 
-    (
-      this.client.options as { ws: { properties: Record<string, string> } }
-    ).ws.properties.browser_user_agent = this.fullUserAgent;
-
     let queryString = '';
     if (options.query) {
       const queryOptions = options.query as Record<string, unknown>;
@@ -57,7 +47,7 @@ class APIRequest {
   }
 
   make(captchaKey?: unknown, captchaRqToken?: unknown): Promise<unknown> {
-    this.ensureAgent();
+    const dispatcher = this.rest.getDispatcher() as never;
 
     const API =
       this.options.versioned === false
@@ -77,33 +67,15 @@ class APIRequest {
       .fetch(url, {
         body,
         credentials: 'include',
-        dispatcher: agent as never,
+        dispatcher,
         headers: headers as never,
         method: this.method.toUpperCase(),
-        // Undici doesn't normalize "patch" into "PATCH" (which surprisingly follows the spec).
         redirect: 'follow',
         signal: controller.signal,
       })
       .finally(() => clearTimeout(timeout));
   }
 
-  private ensureAgent(): void {
-    if (agent) {
-      return;
-    }
-    const proxyAgent = Util.checkUndiciProxyAgent(
-      this.client.options.http.agent
-    );
-    agent = proxyAgent
-      ? new ProxyAgent({
-          ...proxyAgent,
-          ciphers: ciphers.join(':'),
-        } as never)
-      : new Client('https://discord.com', {
-          connect: buildConnector({ ciphers: ciphers.join(':') }),
-        });
-  }
-
   private buildHeaders(
     captchaKey?: unknown,
     captchaRqToken?: unknown

package/src/rest/RESTManager.ts

@@ -2,7 +2,12 @@ import { setInterval } from 'node:timers';
 import { Collection } from '@discordjs/collection';
 import makeFetchCookie from 'fetch-cookie';
 import { CookieJar } from 'tough-cookie';
-import { fetch as fetchOriginal } from 'undici';
+import {
+  Client as UndiciClient,
+  ProxyAgent,
+  buildConnector,
+  fetch as fetchOriginal,
+} from 'undici';
 import APIRequest from './APIRequest';
 import type { ApiRouter } from './APIRouter';
 import routeBuilder from './APIRouter';
@@ -11,9 +16,10 @@ import _errorsModule from '../errors';
 
 const { Error } = _errorsModule;
 import _ConstantsModule from '../util/Constants';
+import Util from '../util/Util';
 import type { BaseClient } from '../client/BaseClient';
 
-const { Endpoints } = _ConstantsModule;
+const { Endpoints, ciphers } = _ConstantsModule;
 
 class RESTManager {
   client: BaseClient;
@@ -26,6 +32,9 @@ class RESTManager {
   cookieJar: CookieJar;
   fetch: typeof fetchOriginal;
   sweepInterval?: ReturnType<typeof setInterval>;
+  agent: unknown;
+  invalidCount: number;
+  invalidCountResetTime: number | null;
 
   constructor(client: BaseClient) {
     this.client = client;
@@ -40,6 +49,9 @@ class RESTManager {
     this.globalDelay = null;
     this.cookieJar = new CookieJar();
     this.fetch = makeFetchCookie(fetchOriginal, this.cookieJar);
+    this.agent = null;
+    this.invalidCount = 0;
+    this.invalidCountResetTime = null;
     if (client.options.restSweepInterval > 0) {
       this.sweepInterval = setInterval(() => {
         this.handlers.sweep((handler: RequestHandler) => handler._inactive);
@@ -47,6 +59,24 @@ class RESTManager {
     }
   }
 
+  getDispatcher(): unknown {
+    if (this.agent) {
+      return this.agent;
+    }
+    const proxyAgent = Util.checkUndiciProxyAgent(
+      this.client.options.http.agent
+    );
+    this.agent = proxyAgent
+      ? new ProxyAgent({
+          ...proxyAgent,
+          ciphers: ciphers.join(':'),
+        } as never)
+      : new UndiciClient('https://discord.com', {
+          connect: buildConnector({ ciphers: ciphers.join(':') }),
+        });
+    return this.agent;
+  }
+
   get api(): ApiRouter {
     return routeBuilder(this);
   }

package/src/rest/RequestHandler.ts

@@ -93,14 +93,7 @@ function calculateReset(
   return new Date(Number(reset) * 1000).getTime() - getAPIOffset(serverDate);
 }
 
-/* Invalid request limiting is done on a per-IP basis, not a per-token basis.
- * The best we can do is track invalid counts process-wide (on the theory that
- * users could have multiple bots run from one process) rather than per-bot.
- * Therefore, store these at file scope here rather than in the client's
- * RESTManager object.
- */
-let invalidCount = 0;
-let invalidCountResetTime: number | null = null;
+/* Invalid request limiting is tracked on the REST manager to keep state local to the client/module seam. */
 
 class RequestHandler {
   manager: RESTManager;
@@ -385,22 +378,26 @@ class RequestHandler {
 
   private trackInvalidRequest(res: RestResponse): void {
     if (res.status === 401 || res.status === 403 || res.status === 429) {
-      if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
-        invalidCountResetTime = Date.now() + 1000 * 60 * 10;
-        invalidCount = 0;
+      if (
+        !this.manager.invalidCountResetTime ||
+        this.manager.invalidCountResetTime < Date.now()
+      ) {
+        this.manager.invalidCountResetTime = Date.now() + 1000 * 60 * 10;
+        this.manager.invalidCount = 0;
       }
-      invalidCount++;
+      this.manager.invalidCount++;
 
       const emitInvalid =
         this.manager.client.listenerCount(INVALID_REQUEST_WARNING) &&
         this.manager.client.options.invalidRequestWarningInterval > 0 &&
-        invalidCount %
+        this.manager.invalidCount %
           this.manager.client.options.invalidRequestWarningInterval ===
           0;
       if (emitInvalid) {
         this.manager.client.emit(INVALID_REQUEST_WARNING, {
-          count: invalidCount,
-          remainingTime: invalidCountResetTime - Date.now(),
+          count: this.manager.invalidCount,
+          remainingTime:
+            (this.manager.invalidCountResetTime ?? Date.now()) - Date.now(),
         });
       }
     }