seyfert 1.5.0 → 2.0.0

package/lib/websocket/discord/shared.d.ts

@@ -1,5 +1,5 @@
-import type { APIGatewayBotInfo, GatewayDispatchPayload, GatewayIntentBits, GatewayPresenceUpdateData } from 'discord-api-types/v10';
-import type { Logger } from '../../common';
+import type { APIGatewayBotInfo, GatewayDispatchPayload, GatewayIntentBits, GatewayPresenceUpdateData } from '../../types';
+import type { Awaitable, DeepPartial, Logger } from '../../common';
 import type { IdentifyProperties } from '../constants';
 export interface ShardManagerOptions extends ShardDetails {
     /** Important data which is used by the manager to connect shards to the gateway. */
@@ -30,8 +30,13 @@ export interface ShardManagerOptions extends ShardDetails {
     presence?: (shardId: number, workerId: number) => GatewayPresenceUpdateData;
     compress?: boolean;
 }
-export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload'> {
-    mode: 'threads' | 'clusters';
+export interface CustomManagerAdapter {
+    postMessage(workerId: number, body: unknown): Awaitable<unknown>;
+    spawn(workerData: WorkerData, env: Record<string, any>): Awaitable<unknown>;
+}
+export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload' | 'properties'> {
+    mode: 'threads' | 'clusters' | 'custom';
+    adapter?: CustomManagerAdapter;
     workers?: number;
     /**
      * @default 32
@@ -40,10 +45,11 @@ export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handleP
     workerProxy?: boolean;
     path: string;
     handlePayload(shardId: number, workerId: number, packet: GatewayDispatchPayload): unknown;
+    properties?: DeepPartial<NonNullable<ShardManagerOptions['properties']>>;
 }
 export interface ShardData {
     /** resume seq to resume connections */
-    resumeSeq: number | null;
+    resume_seq: number | null;
     /**
      * resume_gateway_url is the url to resume the connection
      * @link https://discord.com/developers/docs/topics/gateway#ready-event
@@ -97,6 +103,8 @@ export interface WorkerData {
     token: string;
     path: string;
     shards: number[];
+    totalShards: number;
+    mode: 'custom' | 'clusters' | 'threads';
     workerId: number;
     debug: boolean;
     workerProxy: boolean;

package/lib/websocket/discord/socket/custom.d.ts

@@ -0,0 +1,52 @@
+import type { Socket } from 'node:net';
+export declare class SeyfertWebSocket {
+    #private;
+    socket?: Socket;
+    hostname: string;
+    path: string;
+    __stored: Buffer[];
+    __opcode: number;
+    __promises: Map<string, {
+        resolve: () => void;
+        reject: (reason?: any) => void;
+    }>;
+    __lastError: null | {
+        code: number;
+        reason: string;
+    };
+    __closeCalled?: boolean;
+    constructor(url: string);
+    private connect;
+    handleReadable(): void;
+    handleEvent(body: Buffer, opcode: number): void;
+    handleClose(): void;
+    send(data: string): void;
+    private _write;
+    onping(_data: string): void;
+    onpong(_data: string): void;
+    onopen(): void;
+    onmessage(_payload: {
+        data: string | Buffer;
+    }): void;
+    onclose(_close: {
+        code: number;
+        reason: string;
+    }): void;
+    onerror(_err: unknown): void;
+    close(code: number, reason: string): void;
+    pong(data: string): void;
+    ping(data: string): void;
+    waitPing(): Promise<number>;
+    get readyState(): number;
+    /**
+     *
+     * @param start Start calculating bytes from `start`
+     * @param bits Num of bits since `start`
+     * @returns
+     */
+    private readBytes;
+}
+export type ReadableHeadData = {
+    next?: ReadableHeadData;
+    data: Buffer;
+};

package/lib/websocket/discord/socket/custom.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeyfertWebSocket = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_https_1 = require("node:https");
+class SeyfertWebSocket {
+    socket = undefined;
+    hostname;
+    path;
+    __stored = [];
+    __opcode = 0;
+    __promises = new Map();
+    __lastError = null;
+    __closeCalled;
+    constructor(url) {
+        const urlParts = new URL(url);
+        this.hostname = urlParts.hostname || '';
+        this.path = `${urlParts.pathname}${urlParts.search || ''}`;
+        this.connect();
+    }
+    connect() {
+        const key = (0, node_crypto_1.randomBytes)(16).toString('base64');
+        const req = (0, node_https_1.request)({
+            //discord gateway hostname
+            hostname: this.hostname,
+            path: this.path,
+            headers: {
+                Connection: 'Upgrade',
+                Upgrade: 'websocket',
+                'Sec-WebSocket-Key': key,
+                'Sec-WebSocket-Version': '13',
+            },
+        });
+        req.on('upgrade', (res, socket) => {
+            const hash = (0, node_crypto_1.createHash)('sha1').update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest('base64');
+            const accept = res.headers['sec-websocket-accept'];
+            if (accept !== hash) {
+                socket.end(() => {
+                    this.onerror(new Error('Invalid sec-websocket-accept header'));
+                });
+                return;
+            }
+            this.socket = socket;
+            socket.on('readable', this.handleReadable.bind(this));
+            socket.on('close', this.handleClose.bind(this));
+            socket.on('error', err => this.onerror(err));
+            this.onopen();
+        });
+        req.on('close', () => {
+            req.removeAllListeners();
+        });
+        req.end();
+    }
+    handleReadable() {
+        // Keep reading until no data, this is useful when two payloads merges.
+        while (this.socket.readableLength > 0) {
+            // Read length without consuming the buffer
+            let length = this.readBytes(1, 1) & 127;
+            const slice = length === 126 ? 4 : length === 127 ? 10 : 2;
+            // Check if frame/data is complete
+            if (this.socket.readableLength < slice)
+                return; // Wait to next cycle if not
+            if (length > 125) {
+                // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
+                // If length is 126/127, read extended payload length instead
+                // Equivalent to readUint32BE
+                length = this.readBytes(2, slice - 2);
+            }
+            // Read the frame, ignore data next to it, leave it to next `while` cycle
+            const frame = this.socket.read(slice + length);
+            if (!frame)
+                return;
+            // Get fin (0 | 1)
+            const fin = frame[0] >> 7;
+            // Read opcode (continuation, text, binary, close, ping, pong)
+            let opcode = frame[0] & 15;
+            // Cut frame to get payload
+            let payload = frame.subarray(slice);
+            // If fin is 0, store the data and wait to next `while` cycle to be fin=1
+            if (fin === 0) {
+                this.__stored.push(payload);
+                // Only store opcode when is not 0 (continuation)
+                if (opcode !== 0) {
+                    this.__opcode = opcode;
+                }
+                return;
+            }
+            // When the message is from ws fragmentation, opcode of last message is 0
+            // If so, merge all messages.
+            if (opcode === 0) {
+                this.__stored.push(payload);
+                payload = Buffer.concat(this.__stored);
+                opcode = this.__opcode;
+                // Reset body
+                this.__stored = [];
+                // Reset opcode, should set as -1?
+                this.__opcode = 0;
+            }
+            // Handle opcodes
+            this.handleEvent(payload, opcode);
+        }
+    }
+    handleEvent(body, opcode) {
+        switch (opcode) {
+            // text
+            case 0x1:
+                this.onmessage({ data: body.toString() });
+                break;
+            // binary
+            case 0x2:
+                {
+                    if (body[1] === 80)
+                        body = body.subarray(6);
+                    this.onmessage({ data: body });
+                }
+                break;
+            // pong
+            case 0x9:
+                this.onping(body.toString());
+                break;
+            // ping
+            case 0xa:
+                this.onpong(body.toString());
+                break;
+            // close
+            case 0x8:
+                this.__lastError = {
+                    code: body.readUInt16BE(0),
+                    reason: body.subarray(2).toString(),
+                };
+                break;
+        }
+    }
+    handleClose() {
+        this.socket?.removeAllListeners();
+        this.socket?.destroy();
+        this.socket = undefined;
+        if (this.__closeCalled)
+            return;
+        if (!this.__lastError)
+            return this.connect();
+        this.onclose(this.__lastError);
+        this.__lastError = null;
+    }
+    send(data) {
+        this._write(Buffer.from(data), 1);
+    }
+    _write(buffer, opcode) {
+        const length = buffer.length;
+        let frame;
+        // Kinda same logic as above, but client-side
+        if (length < 126) {
+            frame = Buffer.allocUnsafe(6 + length);
+            frame[1] = 128 + length;
+        }
+        else if (length < 65536) {
+            frame = Buffer.allocUnsafe(8 + length);
+            frame[1] = 254;
+            frame[2] = (length >> 8) & 255;
+            frame[3] = length & 255;
+        }
+        else {
+            frame = Buffer.allocUnsafe(14 + length);
+            frame[1] = 255;
+            frame.writeBigUint64BE(BigInt(length), 2);
+        }
+        frame[0] = 128 + opcode;
+        frame.writeUint32BE(0, frame.length - length - 4);
+        frame.set(buffer, frame.length - length);
+        this.socket?.write(frame);
+    }
+    onping(_data) { }
+    onpong(_data) { }
+    onopen() { }
+    onmessage(_payload) { }
+    onclose(_close) { }
+    onerror(_err) { }
+    close(code, reason) {
+        this.__closeCalled = true;
+        // alloc payload length
+        const buffer = Buffer.alloc(2 + Buffer.byteLength(reason));
+        // gateway close code
+        buffer.writeUInt16BE(code, 0);
+        // reason
+        buffer.write(reason, 2);
+        // message, close opcode
+        this._write(buffer, 0x8);
+        this.socket?.end();
+    }
+    pong(data) {
+        //send pong opcode (10)
+        this._write(Buffer.from(data), 0xa);
+    }
+    ping(data) {
+        //send ping opcode (9)
+        this._write(Buffer.from(data), 0x9);
+    }
+    waitPing() {
+        const id = this.#randomUUID();
+        let timeout;
+        const start = performance.now();
+        this.ping(id);
+        return new Promise((resolve, reject) => {
+            this.__promises.set(id, {
+                reject,
+                resolve,
+            });
+            timeout = setTimeout(() => {
+                resolve();
+            }, 60e3);
+        })
+            .then(() => {
+            return performance.now() - start;
+        })
+            .finally(() => {
+            clearTimeout(timeout);
+        });
+    }
+    #randomUUID() {
+        const id = (0, node_crypto_1.randomUUID)();
+        if (this.__promises.has(id))
+            return this.#randomUUID();
+        return id;
+    }
+    get readyState() {
+        return ['opening', 'open', 'closed', 'closed'].indexOf(this.socket?.readyState ?? 'closed');
+    }
+    /**
+     *
+     * @param start Start calculating bytes from `start`
+     * @param bits Num of bits since `start`
+     * @returns
+     */
+    readBytes(start, bits) {
+        // @ts-expect-error this is private, thanks nodejs
+        const readable = this.socket._readableState;
+        // Num of bit read
+        let bitIndex = 0;
+        // Num of bit read counting since start
+        let read = 0;
+        // Bytes value
+        let value = 0;
+        // Node v20
+        if ('bufferIndex' in readable) {
+            // actual index of the buffer to read
+            let blockIndex = readable.bufferIndex;
+            // Buffer to read
+            let block;
+            while ((block = readable.buffer[blockIndex++])) {
+                for (let i = 0; i < block.length; i++) {
+                    if (++bitIndex > start) {
+                        value *= 256; // shift 8 bits (1 byte) `*= 256 is faster than <<= 8`
+                        value += block[i]; // sum value to bits
+                        // Read until read all bits
+                        if (++read === bits) {
+                            return value;
+                        }
+                    }
+                }
+            }
+        } /* Support for olders versions*/
+        else {
+            // readable.buffer is kinda a LinkedList
+            let head = readable.buffer.head;
+            while (head) {
+                for (let i = 0; i < head.data.length; i++) {
+                    if (++bitIndex > start) {
+                        value *= 256; // shift 8 bits (1 byte) `*= 256 is faster than <<= 8`
+                        value += head.data[i]; // sum value to bits
+                        // Read until read all bits
+                        if (++read === bits) {
+                            return value;
+                        }
+                    }
+                }
+                // continue with next node
+                head = head.next;
+            }
+        }
+        return 0;
+    }
+}
+exports.SeyfertWebSocket = SeyfertWebSocket;

package/lib/websocket/discord/worker.d.ts

@@ -1,5 +1,5 @@
-import type { GatewayDispatchPayload } from 'discord-api-types/v10';
 import type { ApiRequestOptions, HttpMethods } from '../..';
+import type { GatewayDispatchPayload } from '../../types';
 export interface WorkerShardInfo {
     open: boolean;
     shardId: number;
@@ -25,8 +25,8 @@ export type WorkerSendResultPayload = CreateWorkerMessage<'RESULT_PAYLOAD', {
 }>;
 export type WorkerSendCacheRequest = CreateWorkerMessage<'CACHE_REQUEST', {
     nonce: string;
-    method: 'scan' | 'get' | 'set' | 'patch' | 'values' | 'keys' | 'count' | 'remove' | 'flush' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
-    args: any[];
+    method: 'scan' | 'bulkGet' | 'get' | 'bulkSet' | 'set' | 'bulkPatch' | 'patch' | 'values' | 'keys' | 'count' | 'bulkRemove' | 'remove' | 'flush' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
+    args: unknown[];
 }>;
 export type WorkerSendShardInfo = CreateWorkerMessage<'SHARD_INFO', WorkerShardInfo & {
     nonce: string;
@@ -42,13 +42,8 @@ export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
     requestOptions: ApiRequestOptions;
     nonce: string;
 }>;
-export type WorkerExecuteEval = CreateWorkerMessage<'EXECUTE_EVAL', {
-    func: string;
-    nonce: string;
-    toWorkerId: number;
-}>;
 export type WorkerSendEvalResponse = CreateWorkerMessage<'EVAL_RESPONSE', {
-    response: any;
+    response: unknown;
     nonce: string;
 }>;
 export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
@@ -56,5 +51,5 @@ export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
     nonce: string;
     toWorkerId: number;
 }>;
-export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
+export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
 export {};

package/lib/websocket/discord/workermanager.d.ts

@@ -1,24 +1,17 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { GatewayPresenceUpdateData, GatewaySendPayload } from 'discord-api-types/v10';
+import type { GatewayPresenceUpdateData, GatewaySendPayload } from '../../types';
 import { type Worker as ClusterWorker } from 'node:cluster';
 import { ApiHandler, Logger } from '../..';
 import { type Adapter } from '../../cache';
 import { type MakePartial } from '../../common';
 import { ConnectQueue } from '../structures/timeout';
-import { MemberUpdateHandler } from './events/memberUpdate';
-import { PresenceUpdateHandler } from './events/presenceUpdate';
 import type { ShardOptions, WorkerData, WorkerManagerOptions } from './shared';
 import type { WorkerInfo, WorkerMessage, WorkerShardInfo } from './worker';
-export declare class WorkerManager extends Map<number, (ClusterWorker | import('node:worker_threads').Worker) & {
+export declare class WorkerManager extends Map<number, (ClusterWorker | import('node:worker_threads').Worker | {
+    ready: boolean;
+}) & {
     ready?: boolean;
 }> {
-    options: Required<WorkerManagerOptions>;
+    options: MakePartial<Required<WorkerManagerOptions>, 'adapter'>;
     debugger?: Logger;
     connectQueue: ConnectQueue;
     cacheAdapter: Adapter;
@@ -26,8 +19,6 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | import('
         resolve: (value: any) => void;
         timeout: NodeJS.Timeout;
     }>;
-    memberUpdateHandler: MemberUpdateHandler;
-    presenceUpdateHandler: PresenceUpdateHandler;
     rest: ApiHandler;
     constructor(options: MakePartial<WorkerManagerOptions, 'token' | 'intents' | 'info' | 'handlePayload'>);
     setCache(adapter: Adapter): void;
@@ -49,7 +40,9 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | import('
     prepareSpaces(): number[][];
     postMessage(id: number, body: any): void;
     prepareWorkers(shards: number[][]): Promise<void>;
-    createWorker(workerData: WorkerData): ClusterWorker | import("worker_threads").Worker;
+    createWorker(workerData: WorkerData): ClusterWorker | import("worker_threads").Worker | {
+        ready: boolean;
+    };
     spawn(workerId: number, shardId: number): void;
     handleWorkerMessage(message: WorkerMessage): Promise<void>;
     private generateNonce;

package/lib/websocket/discord/workermanager.js

@@ -13,16 +13,12 @@ const common_1 = require("../../common");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
 const timeout_1 = require("../structures/timeout");
-const memberUpdate_1 = require("./events/memberUpdate");
-const presenceUpdate_1 = require("./events/presenceUpdate");
 class WorkerManager extends Map {
     options;
     debugger;
     connectQueue;
     cacheAdapter;
     promises = new Map();
-    memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
-    presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
     rest;
     constructor(options) {
         super();
@@ -103,9 +99,15 @@ class WorkerManager extends Map {
             case 'threads':
                 worker.postMessage(body);
                 break;
+            case 'custom':
+                this.options.adapter.postMessage(id, body);
+                break;
         }
     }
     async prepareWorkers(shards) {
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (!worker_threads)
+            throw new Error('Cannot prepare workers without worker_threads.');
         for (let i = 0; i < shards.length; i++) {
             let worker = this.get(i);
             if (!worker) {
@@ -117,24 +119,11 @@ class WorkerManager extends Map {
                     intents: this.options.intents,
                     workerId: i,
                     workerProxy: this.options.workerProxy,
+                    totalShards: this.totalShards,
+                    mode: this.options.mode,
                 });
                 this.set(i, worker);
             }
-            const listener = (message) => {
-                if (message.type !== 'WORKER_START')
-                    return;
-                worker.removeListener('message', listener);
-                this.postMessage(i, {
-                    type: 'SPAWN_SHARDS',
-                    compress: this.options.compress ?? false,
-                    info: {
-                        ...this.options.info,
-                        shards: this.totalShards,
-                    },
-                    properties: this.options.properties,
-                });
-            };
-            worker.on('message', listener);
         }
     }
     createWorker(workerData) {
@@ -163,11 +152,16 @@ class WorkerManager extends Map {
                 worker.on('message', data => this.handleWorkerMessage(data));
                 return worker;
             }
+            case 'custom':
+                this.options.adapter.spawn(workerData, env);
+                return {
+                    ready: false,
+                };
         }
     }
     spawn(workerId, shardId) {
         this.connectQueue.push(() => {
-            const worker = this.get(workerId);
+            const worker = this.has(workerId);
             if (!worker) {
                 this.debugger?.fatal("Trying spawn with worker doesn't exist");
                 return;
@@ -181,12 +175,28 @@ class WorkerManager extends Map {
     }
     async handleWorkerMessage(message) {
         switch (message.type) {
+            case 'WORKER_START':
+                {
+                    this.postMessage(message.workerId, {
+                        type: 'SPAWN_SHARDS',
+                        compress: this.options.compress ?? false,
+                        info: {
+                            ...this.options.info,
+                            shards: this.totalShards,
+                        },
+                        properties: {
+                            ...constants_1.properties,
+                            ...this.options.properties,
+                        },
+                    });
+                }
+                break;
             case 'CONNECT_QUEUE':
                 this.spawn(message.workerId, message.shardId);
                 break;
             case 'CACHE_REQUEST':
                 {
-                    const worker = this.get(message.workerId);
+                    const worker = this.has(message.workerId);
                     if (!worker) {
                         throw new Error('Invalid request from unavailable worker');
                     }
@@ -200,21 +210,7 @@ class WorkerManager extends Map {
                 }
                 break;
             case 'RECEIVE_PAYLOAD':
-                {
-                    switch (message.payload.t) {
-                        case 'GUILD_MEMBER_UPDATE':
-                            if (!this.memberUpdateHandler.check(message.payload.d)) {
-                                return;
-                            }
-                            break;
-                        case 'PRESENCE_UPDATE':
-                            if (!this.presenceUpdateHandler.check(message.payload.d)) {
-                                return;
-                            }
-                            break;
-                    }
-                    this.options.handlePayload(message.shardId, message.workerId, message.payload);
-                }
+                await this.options.handlePayload(message.shardId, message.workerId, message.payload);
                 break;
             case 'RESULT_PAYLOAD':
                 {
@@ -322,7 +318,7 @@ class WorkerManager extends Map {
     }
     async send(data, shardId) {
         const workerId = this.calculateWorkerId(shardId);
-        const worker = this.get(workerId);
+        const worker = this.has(workerId);
         if (!worker) {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
@@ -337,7 +333,7 @@ class WorkerManager extends Map {
     }
     async getShardInfo(shardId) {
         const workerId = this.calculateWorkerId(shardId);
-        const worker = this.get(workerId);
+        const worker = this.has(workerId);
         if (!worker) {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
@@ -346,7 +342,7 @@ class WorkerManager extends Map {
         return this.generateSendPromise(nonce, 'Get shard info timeout');
     }
     async getWorkerInfo(workerId) {
-        const worker = this.get(workerId);
+        const worker = this.has(workerId);
         if (!worker) {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }

package/lib/websocket/structures/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { type Logger } from '../../common';
 /**
  * options of the dynamic bucket

package/lib/websocket/structures/index.js

@@ -62,7 +62,7 @@ class DynamicBucket {
     acquire(force = false) {
         return new Promise(res => {
             this.queue[force ? 'unshift' : 'push'](res);
-            void this.processQueue();
+            this.processQueue();
         });
     }
     static chunk(array, chunks) {

package/lib/websocket/structures/timeout.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export declare class ConnectTimeout {
     intervalTime: number;
     readonly promises: ((x: boolean) => any)[];