seyfert 1.0.0 → 1.1.0

package/lib/websocket/discord/workermanager.js

@@ -1,9 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerManager = void 0;
+const node_cluster_1 = __importDefault(require("node:cluster"));
 const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
+const __1 = require("../..");
 const cache_1 = require("../../cache");
+const base_1 = require("../../client/base");
 const common_1 = require("../../common");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
@@ -18,28 +24,18 @@ class WorkerManager extends Map {
     promises = new Map();
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
     presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    rest;
     constructor(options) {
         super();
-        options.totalShards ??= options.info.shards;
-        this.options = (0, common_1.MergeOptions)(constants_1.WorkerManagerDefaults, options);
-        this.options.workers ??= Math.ceil(this.options.totalShards / this.options.shardsPerWorker);
-        this.options.info.shards = options.totalShards;
-        options.shardEnd ??= options.totalShards;
-        options.shardStart ??= 0;
-        this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
-        if (this.options.debug) {
-            this.debugger = new common_1.Logger({
-                name: '[WorkerManager]',
-            });
-        }
-        if (this.totalShards / this.shardsPerWorker > this.workers) {
-            throw new Error(`Cannot create enough shards in the specified workers, minimum: ${Math.ceil(this.totalShards / this.shardsPerWorker)}`);
-        }
+        this.options = options;
         this.cacheAdapter = new cache_1.MemoryAdapter();
     }
     setCache(adapter) {
         this.cacheAdapter = adapter;
     }
+    setRest(rest) {
+        this.rest = rest;
+    }
     get remaining() {
         return this.options.info.session_start_limit.remaining;
     }
@@ -50,7 +46,13 @@ class WorkerManager extends Map {
         return this.options.workers;
     }
     get totalShards() {
-        return this.options.totalShards;
+        return this.options.totalShards ?? this.options.info.shards;
+    }
+    get shardStart() {
+        return this.options.shardStart ?? 0;
+    }
+    get shardEnd() {
+        return this.options.shardEnd ?? this.totalShards;
     }
     get shardsPerWorker() {
         return this.options.shardsPerWorker;
@@ -70,10 +72,10 @@ class WorkerManager extends Map {
         return data.shards.reduce((acc, prv) => acc + prv.latency, 0) / data.shards.length;
     }
     calculateShardId(guildId) {
-        return Number((BigInt(guildId) >> 22n) % BigInt(this.options.info.shards ?? 1));
+        return Number((BigInt(guildId) >> 22n) % BigInt(this.totalShards));
     }
     calculateWorkerId(shardId) {
-        const workerId = Math.floor(shardId / this.shardsPerWorker);
+        const workerId = Math.floor((shardId - this.shardStart) / this.shardsPerWorker);
         if (workerId >= this.workers) {
             throw new Error('Invalid shardId');
         }
@@ -81,18 +83,29 @@ class WorkerManager extends Map {
     }
     prepareSpaces() {
         this.debugger?.info('Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.options.shardStart !== undefined && this.options.shardEnd !== undefined
-            ? this.options.shardEnd - this.options.shardStart
-            : this.options.totalShards), this.options.shardsPerWorker);
+        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.options.shardsPerWorker);
         chunks.forEach((shards, index) => {
             for (let i = 0; i < shards.length; i++) {
-                const id = i + (index > 0 ? index * this.options.shardsPerWorker : 0) + (this.options.shardStart ?? 0);
+                const id = i + (index > 0 ? index * this.options.shardsPerWorker : 0) + this.shardStart;
                 chunks[index][i] = id;
             }
         });
         this.debugger?.info(`${chunks.length} buckets created`);
         return chunks;
     }
+    postMessage(id, body) {
+        const worker = this.get(id);
+        if (!worker)
+            return this.debugger?.error(`Worker ${id} doesnt exists.`);
+        switch (this.options.mode) {
+            case 'clusters':
+                worker.send(body);
+                break;
+            case 'threads':
+                worker.postMessage(body);
+                break;
+        }
+    }
     async prepareWorkers(shards) {
         for (let i = 0; i < shards.length; i++) {
             let worker = this.get(i);
@@ -104,21 +117,51 @@ class WorkerManager extends Map {
                     shards: shards[i],
                     intents: this.options.intents,
                     workerId: i,
+                    workerProxy: this.options.workerProxy,
                 });
                 this.set(i, worker);
             }
-            worker.postMessage({
-                type: 'SPAWN_SHARDS',
-                compress: this.options.compress ?? false,
-                info: this.options.info,
-                properties: this.options.properties,
-            });
+            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) {
-        const worker = new node_worker_threads_1.Worker(workerData.path, { workerData });
-        worker.on('message', data => this.handleWorkerMessage(data));
-        return worker;
+        const env = {
+            SEYFERT_SPAWNING: 'true',
+        };
+        for (const i in workerData) {
+            env[`SEYFERT_WORKER_${i.toUpperCase()}`] = workerData[i];
+        }
+        switch (this.options.mode) {
+            case 'threads': {
+                const worker = new node_worker_threads_1.Worker(workerData.path, {
+                    env,
+                });
+                worker.on('message', data => this.handleWorkerMessage(data));
+                return worker;
+            }
+            case 'clusters': {
+                node_cluster_1.default.setupPrimary({
+                    exec: workerData.path,
+                });
+                const worker = node_cluster_1.default.fork(env);
+                worker.on('message', data => this.handleWorkerMessage(data));
+                return worker;
+            }
+        }
     }
     spawn(workerId, shardId) {
         this.connectQueue.push(() => {
@@ -127,7 +170,7 @@ class WorkerManager extends Map {
                 this.debugger?.fatal("Trying spawn with worker doesn't exist");
                 return;
             }
-            worker.postMessage({
+            this.postMessage(workerId, {
                 type: 'ALLOW_CONNECT',
                 shardId,
                 presence: this.options.presence?.(shardId, workerId),
@@ -147,7 +190,7 @@ class WorkerManager extends Map {
                     }
                     // @ts-expect-error
                     const result = await this.cacheAdapter[message.method](...message.args);
-                    worker.postMessage({
+                    this.postMessage(message.workerId, {
                         type: 'CACHE_RESULT',
                         nonce: message.nonce,
                         result,
@@ -173,48 +216,90 @@ class WorkerManager extends Map {
                 break;
             case 'RESULT_PAYLOAD':
                 {
-                    const cacheData = this.promises.get(message.nonce);
-                    if (!cacheData) {
+                    const resultPayload = this.promises.get(message.nonce);
+                    if (!resultPayload) {
                         return;
                     }
                     this.promises.delete(message.nonce);
-                    clearTimeout(cacheData.timeout);
-                    cacheData.resolve(true);
+                    clearTimeout(resultPayload.timeout);
+                    resultPayload.resolve(true);
                 }
                 break;
             case 'SHARD_INFO':
                 {
                     const { nonce, type, ...data } = message;
-                    const cacheData = this.promises.get(nonce);
-                    if (!cacheData) {
+                    const shardInfo = this.promises.get(nonce);
+                    if (!shardInfo) {
                         return;
                     }
                     this.promises.delete(nonce);
-                    clearTimeout(cacheData.timeout);
-                    cacheData.resolve(data);
+                    clearTimeout(shardInfo.timeout);
+                    shardInfo.resolve(data);
                 }
                 break;
             case 'WORKER_INFO':
                 {
                     const { nonce, type, ...data } = message;
-                    const cacheData = this.promises.get(nonce);
-                    if (!cacheData) {
+                    const workerInfo = this.promises.get(nonce);
+                    if (!workerInfo) {
                         return;
                     }
                     this.promises.delete(nonce);
-                    clearTimeout(cacheData.timeout);
-                    cacheData.resolve(data);
+                    clearTimeout(workerInfo.timeout);
+                    workerInfo.resolve(data);
                 }
                 break;
             case 'WORKER_READY':
                 {
-                    if (message.workerId === [...this.keys()].at(-1)) {
-                        this.get(this.keys().next().value)?.postMessage({
+                    this.get(message.workerId).ready = true;
+                    if ([...this.values()].every(w => w.ready)) {
+                        this.postMessage(this.keys().next().value, {
                             type: 'BOT_READY',
                         });
+                        this.forEach(w => {
+                            delete w.ready;
+                        });
                     }
                 }
                 break;
+            case 'WORKER_API_REQUEST':
+                {
+                    const response = await this.rest.request(message.method, message.url, message.requestOptions);
+                    this.postMessage(message.workerId, {
+                        nonce: message.nonce,
+                        response,
+                        type: 'API_RESPONSE',
+                    });
+                }
+                break;
+            case 'EVAL_RESPONSE':
+                {
+                    const { nonce, type, ...data } = message;
+                    const evalResponse = this.promises.get(nonce);
+                    if (!evalResponse) {
+                        return;
+                    }
+                    this.promises.delete(nonce);
+                    clearTimeout(evalResponse.timeout);
+                    evalResponse.resolve(data.response);
+                }
+                break;
+            case 'EVAL':
+                {
+                    const nonce = this.generateNonce();
+                    this.postMessage(message.toWorkerId, {
+                        nonce,
+                        func: message.func,
+                        type: 'EXECUTE_EVAL',
+                        toWorkerId: message.toWorkerId,
+                    });
+                    this.generateSendPromise(nonce, 'Eval timeout').then(val => this.postMessage(message.workerId, {
+                        nonce: message.nonce,
+                        response: val,
+                        type: 'EVAL_RESPONSE',
+                    }));
+                }
+                break;
         }
     }
     generateNonce(large = true) {
@@ -234,7 +319,7 @@ class WorkerManager extends Map {
             timeout = setTimeout(() => {
                 this.promises.delete(nonce);
                 rej(new Error(message));
-            }, 3e3);
+            }, 60e3);
         });
         this.promises.set(nonce, { resolve, timeout });
         return promise;
@@ -246,7 +331,7 @@ class WorkerManager extends Map {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
         const nonce = this.generateNonce();
-        worker.postMessage({
+        this.postMessage(workerId, {
             type: 'SEND_PAYLOAD',
             shardId,
             nonce,
@@ -261,7 +346,7 @@ class WorkerManager extends Map {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
         const nonce = this.generateNonce(false);
-        worker.postMessage({ shardId, nonce, type: 'SHARD_INFO' });
+        this.postMessage(workerId, { shardId, nonce, type: 'SHARD_INFO' });
         return this.generateSendPromise(nonce, 'Get shard info timeout');
     }
     async getWorkerInfo(workerId) {
@@ -270,10 +355,34 @@ class WorkerManager extends Map {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
         const nonce = this.generateNonce();
-        worker.postMessage({ nonce, type: 'WORKER_INFO' });
+        this.postMessage(workerId, { nonce, type: 'WORKER_INFO' });
         return this.generateSendPromise(nonce, 'Get worker info timeout');
     }
     async start() {
+        const rc = await base_1.BaseClient.prototype.getRC();
+        this.options.debug ||= rc.debug;
+        this.options.intents ||= rc.intents ?? 0;
+        this.options.token ??= rc.token;
+        this.rest ??= new __1.ApiHandler({
+            token: this.options.token,
+            baseUrl: 'api/v10',
+            domain: 'https://discord.com',
+            debug: this.options.debug,
+        });
+        this.options.info ??= await new __1.Router(this.rest).createProxy().gateway.bot.get();
+        this.options.shardEnd ??= this.options.totalShards ?? this.options.info.shards;
+        this.options.totalShards ??= this.options.shardEnd;
+        this.options = (0, common_1.MergeOptions)(constants_1.WorkerManagerDefaults, this.options);
+        this.options.workers ??= Math.ceil(this.options.totalShards / this.options.shardsPerWorker);
+        this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
+        if (this.options.debug) {
+            this.debugger = new common_1.Logger({
+                name: '[WorkerManager]',
+            });
+        }
+        if (this.totalShards / this.shardsPerWorker > this.workers) {
+            throw new Error(`Cannot create enough shards in the specified workers, minimum: ${Math.ceil(this.totalShards / this.shardsPerWorker)}`);
+        }
         const spaces = this.prepareSpaces();
         await this.prepareWorkers(spaces);
     }

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "seyfert",
-	"version": "1.0.0",
+	"version": "1.1.0",
+	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
 	"types": "./lib/index.d.ts",
@@ -17,10 +18,10 @@
 		"check": "biome check --apply --changed --no-errors-on-unmatched ./src"
 	},
 	"author": "MARCROCK22",
-	"license": "ISC",
+	"license": "Apache-2.0",
 	"dependencies": {
 		"chokidar": "^3.6.0",
-		"discord-api-types": "^0.37.73",
+		"discord-api-types": "^0.37.76",
 		"magic-bytes.js": "^1.10.0",
 		"ts-mixer": "^6.0.4",
 		"ws": "^8.16.0"
@@ -33,11 +34,13 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "1.6.0",
-		"@types/node": "^20.11.25",
+		"@commitlint/cli": "^19.2.1",
+		"@commitlint/config-conventional": "^19.1.0",
+		"@types/node": "^20.11.30",
 		"@types/ws": "^8.5.10",
 		"husky": "^9.0.11",
 		"lint-staged": "^15.2.2",
-		"typescript": "^5.4.2"
+		"typescript": "^5.4.3"
 	},
 	"optionalDependencies": {
 		"ioredis": "^5.3.2",