seyfert 2.1.1-dev-11727465603.0 → 2.1.1-dev-11768778519.0

package/lib/api/api.d.ts

@@ -19,6 +19,7 @@ export declare class ApiHandler {
     }>;
     onRatelimit?: OnRatelimitCallback;
     constructor(options: ApiHandlerOptions);
+    set debug(active: boolean);
     get proxy(): APIRoutes;
     globalUnblock(): void;
     request<T = unknown>(method: HttpMethods, url: `/${string}`, { auth, ...request }?: ApiRequestOptions): Promise<T>;

package/lib/api/api.js

@@ -20,16 +20,13 @@ class ApiHandler {
     constructor(options) {
         this.options = {
             baseUrl: 'api/v10',
-            domain: 'https://discord.com',
+            domain: common_1.BASE_HOST,
             type: 'Bot',
             ...options,
             userAgent: shared_1.DefaultUserAgent,
         };
-        if (options.debug) {
-            this.debugger = new common_1.Logger({
-                name: '[API]',
-            });
-        }
+        if (options.debug)
+            this.debug = true;
         const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
         if (options.workerProxy && !worker_threads?.parentPort)
             throw new Error('Cannot use workerProxy without a parent.');
@@ -41,6 +38,13 @@ class ApiHandler {
                 parentPort = worker_threads.parentPort;
         }
     }
+    set debug(active) {
+        this.debugger = active
+            ? new common_1.Logger({
+                name: '[API]',
+            })
+            : undefined;
+    }
     get proxy() {
         return (this._proxy_ ??= new Router_1.Router(this).createProxy());
     }

package/lib/client/base.js

@@ -14,8 +14,8 @@ const voiceStates_1 = require("../common/shorters/voiceStates");
 const handler_2 = require("../components/handler");
 const handler_3 = require("../langs/handler");
 class BaseClient {
-    rest;
-    cache;
+    rest = new api_1.ApiHandler({ token: 'INVALID' });
+    cache = new cache_1.Cache(0, new cache_1.MemoryAdapter());
     applications = new common_1.ApplicationShorter(this);
     users = new common_1.UsersShorter(this);
     channels = new common_1.ChannelShorter(this);
@@ -122,6 +122,7 @@ class BaseClient {
     }
     setServices({ rest, cache, langs, middlewares, handleCommand }) {
         if (rest) {
+            rest.onRatelimit ??= this.rest.onRatelimit?.bind(rest);
             this.rest = rest;
         }
         if (cache) {
@@ -141,7 +142,7 @@ class BaseClient {
                 'users',
                 'voiceStates',
             ];
-            let disabledCache = this.cache?.disabledCache ?? {};
+            let disabledCache = this.cache.disabledCache;
             if (typeof cache.disabledCache === 'boolean') {
                 for (const i of caches) {
                     disabledCache[i] = cache.disabledCache;
@@ -155,7 +156,7 @@ class BaseClient {
             else if (typeof cache.disabledCache === 'object') {
                 disabledCache = cache.disabledCache;
             }
-            this.cache = new cache_1.Cache(this.cache?.intents ?? 0, cache?.adapter ?? this.cache?.adapter ?? new cache_1.MemoryAdapter(), disabledCache, this);
+            this.cache = new cache_1.Cache(this.cache.intents, cache.adapter ?? this.cache.adapter, disabledCache, this);
         }
         if (middlewares) {
             this.middlewares = middlewares;
@@ -190,21 +191,11 @@ class BaseClient {
         await this.loadComponents(options.componentsDir);
         const { token: tokenRC, debug } = await this.getRC();
         const token = options?.token ?? tokenRC;
-        if (!this.rest) {
-            BaseClient.assertString(token, 'token is not a string');
-            this.rest = new api_1.ApiHandler({
-                token,
-                baseUrl: 'api/v10',
-                domain: 'https://discord.com',
-                debug,
-            });
-        }
-        if (this.cache) {
-            this.cache.__setClient(this);
-        }
-        else {
-            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), {}, this);
-        }
+        BaseClient.assertString(token, 'token is not a string');
+        if (this.rest.options.token === 'INVALID')
+            this.rest.options.token = token;
+        this.rest.debug = debug;
+        this.cache.__setClient(this);
         if (!this.handleCommand)
             this.handleCommand = new handle_1.HandleCommand(this);
         // The reason of this method is so for adapters that need to connect somewhere, have time to connect.
@@ -223,7 +214,6 @@ class BaseClient {
         });
     }
     syncCachePath(cachePath) {
-        this.logger.debug('Syncing commands cache');
         return node_fs_1.promises.writeFile(cachePath, JSON.stringify(this.commands.values.filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash).map(x => x.toJSON())));
     }
     async uploadCommands({ applicationId, cachePath } = {}) {

package/lib/client/client.js

@@ -68,6 +68,7 @@ class Client extends base_1.BaseClient {
         const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
         const token = options?.token ?? tokenRC;
         const intents = options?.connection?.intents ?? intentsRC;
+        this.cache.intents = intents;
         if (!this.gateway) {
             base_1.BaseClient.assertString(token, 'token is not a string');
             this.gateway = new websocket_1.ShardManager({
@@ -95,7 +96,6 @@ class Client extends base_1.BaseClient {
                 },
             });
         }
-        this.cache.intents = this.gateway.options.intents;
         if (execute) {
             await this.execute(options.connection);
         }
@@ -109,7 +109,6 @@ class Client extends base_1.BaseClient {
             this.collectors.run('RAW', packet, this),
         ]); //ignore promise
         switch (packet.t) {
-            // Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
                 {
                     if (!this.memberUpdateHandler.check(packet.d)) {

package/lib/client/workerclient.d.ts

@@ -1,14 +1,15 @@
-import { type DeepPartial, type When } from '../common';
+import { type DeepPartial, type MakeRequired, type When } from '../common';
 import { EventHandler } from '../events';
 import type { GatewayDispatchPayload } from '../types';
 import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
 import type { WorkerMessage, WorkerShardInfo } from '../websocket/discord/worker';
-import type { ManagerMessages } from '../websocket/discord/workermanager';
+import type { ManagerMessages, ManagerSpawnShards } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client, ClientOptions } from './client';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
+import type { ShardData } from '../websocket/discord/shared';
 import { Collectors } from './collectors';
 import { type ClientUserStructure } from './transformers';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
@@ -40,8 +41,10 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     handleManagerMessages(data: ManagerMessages): Promise<any>;
     private generateNonce;
     private generateSendPromise;
-    tellWorker<R>(workerId: number, func: (_: this) => R): Promise<R>;
-    tellWorkers<R>(func: (_: this) => R): Promise<Awaited<R>[]>;
+    tellWorker<R, V extends Record<string, unknown>>(workerId: number, func: (_: this, vars: V) => R, vars: V): Promise<R>;
+    tellWorkers<R, V extends Record<string, unknown>>(func: (_: this, vars: V) => R, vars: V): Promise<Awaited<R>[]>;
+    createShard(id: number, data: Pick<ManagerSpawnShards, 'info' | 'compress'>): Shard;
+    resumeShard(shardId: number, shardData: MakeRequired<ShardData>): Promise<unknown>;
     protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;

package/lib/client/workerclient.js

@@ -20,7 +20,7 @@ try {
         debug: process.env.SEYFERT_WORKER_DEBUG === 'true',
         intents: Number(process.env.SEYFERT_WORKER_INTENTS),
         path: process.env.SEYFERT_WORKER_PATH,
-        shards: process.env.SEYFERT_WORKER_SHARDS.split(',').map(id => Number(id)),
+        shards: JSON.parse(process.env.SEYFERT_WORKER_SHARDS),
         token: process.env.SEYFERT_WORKER_TOKEN,
         workerId: Number(process.env.SEYFERT_WORKER_WORKERID),
         workerProxy: process.env.SEYFERT_WORKER_WORKERPROXY === 'true',
@@ -28,6 +28,8 @@ try {
         mode: process.env.SEYFERT_WORKER_MODE,
         resharding: process.env.SEYFERT_WORKER_RESHARDING === 'true',
         totalWorkers: Number(process.env.SEYFERT_WORKER_TOTALWORKERS),
+        info: JSON.parse(process.env.SEYFERT_WORKER_INFO),
+        compress: process.env.SEYFERT_WORKER_COMPRESS === 'true',
     };
 }
 catch {
@@ -117,6 +119,7 @@ class WorkerClient extends base_1.BaseClient {
                 }),
             });
         }
+        this.cache.intents = workerData.intents;
         this.postMessage({
             type: workerData.resharding ? 'WORKER_START_RESHARDING' : 'WORKER_START',
             workerId: workerData.workerId,
@@ -126,7 +129,6 @@ class WorkerClient extends base_1.BaseClient {
         }
         await super.start(options);
         await this.loadEvents(options.eventsDir);
-        this.cache.intents = workerData.intents;
     }
     async loadEvents(dir) {
         dir ??= await this.getRC().then(x => ('events' in x.locations ? x.locations.events : undefined));
@@ -250,37 +252,13 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             case 'SPAWN_SHARDS':
                 {
-                    const onPacket = this.onPacket.bind(this);
-                    const handlePayload = this.options?.handlePayload?.bind(this);
-                    const self = this;
                     for (const id of workerData.shards) {
                         const existsShard = this.shards.has(id);
                         if (existsShard) {
                             this.logger.warn(`Trying to spawn existing shard #${id}`);
                             continue;
                         }
-                        const shard = new websocket_1.Shard(id, {
-                            token: workerData.token,
-                            intents: workerData.intents,
-                            info: data.info,
-                            compress: data.compress,
-                            debugger: this.debugger,
-                            properties: {
-                                ...websocket_1.properties,
-                                ...this.options.gateway?.properties,
-                            },
-                            async handlePayload(shardId, payload) {
-                                await handlePayload?.(shardId, payload);
-                                await onPacket(payload, shardId);
-                                if (self.options.sendPayloadToParent)
-                                    self.postMessage({
-                                        workerId: workerData.workerId,
-                                        shardId,
-                                        type: 'RECEIVE_PAYLOAD',
-                                        payload,
-                                    });
-                            },
-                        });
+                        const shard = this.createShard(id, data);
                         this.shards.set(id, shard);
                         this.postMessage({
                             type: 'CONNECT_QUEUE',
@@ -335,7 +313,7 @@ class WorkerClient extends base_1.BaseClient {
                     let result;
                     try {
                         result = await eval(`
-					(${data.func})(this)
+					(${data.func})(this, ${data.vars})
 					`);
                     }
                     catch (e) {
@@ -410,7 +388,7 @@ class WorkerClient extends base_1.BaseClient {
             this.promises.set(nonce, { resolve: res, timeout });
         });
     }
-    tellWorker(workerId, func) {
+    tellWorker(workerId, func, vars) {
         const nonce = this.generateNonce();
         this.postMessage({
             type: 'EVAL_TO_WORKER',
@@ -418,23 +396,67 @@ class WorkerClient extends base_1.BaseClient {
             toWorkerId: workerId,
             workerId: workerData.workerId,
             nonce,
+            vars: JSON.stringify(vars),
         });
         return this.generateSendPromise(nonce);
     }
-    tellWorkers(func) {
+    tellWorkers(func, vars) {
         const promises = [];
         for (let i = 0; i < workerData.totalWorkers; i++) {
-            promises.push(this.tellWorker(i, func));
+            promises.push(this.tellWorker(i, func, vars));
         }
         return Promise.all(promises);
     }
+    createShard(id, data) {
+        const onPacket = this.onPacket.bind(this);
+        const handlePayload = this.options?.handlePayload?.bind(this);
+        const self = this;
+        const shard = new websocket_1.Shard(id, {
+            token: workerData.token,
+            intents: workerData.intents,
+            info: data.info,
+            compress: data.compress,
+            debugger: this.debugger,
+            properties: {
+                ...websocket_1.properties,
+                ...this.options.gateway?.properties,
+            },
+            async handlePayload(shardId, payload) {
+                await handlePayload?.(shardId, payload);
+                await onPacket(payload, shardId);
+                if (self.options.sendPayloadToParent)
+                    self.postMessage({
+                        workerId: workerData.workerId,
+                        shardId,
+                        type: 'RECEIVE_PAYLOAD',
+                        payload,
+                    });
+            },
+        });
+        return shard;
+    }
+    async resumeShard(shardId, shardData) {
+        const exists = (await this.tellWorkers((r, vars) => r.shards.has(vars.shardId), { shardId })).some(x => x);
+        if (exists)
+            throw new Error('Cannot override existing shard');
+        const shard = this.createShard(shardId, {
+            info: this.workerData.info,
+            compress: this.workerData.compress,
+        });
+        shard.data = shardData;
+        this.shards.set(shardId, shard);
+        return this.postMessage({
+            workerId: this.workerId,
+            shardId,
+            type: 'CONNECT_QUEUE',
+        });
+    }
     async onPacket(packet, shardId) {
         Promise.allSettled([
             this.events?.runEvent('RAW', this, packet, shardId, false),
             this.collectors.run('RAW', packet, this),
         ]); //ignore promise
         switch (packet.t) {
-            //// Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
                 {
                     if (!this.memberUpdateHandler.check(packet.d)) {

package/lib/commands/handler.js

@@ -448,16 +448,14 @@ class CommandHandler extends common_1.BaseHandler {
         if (!(commandInstance instanceof menu_1.ContextMenuCommand))
             return false;
         commandInstance.onAfterRun ??= this.client.options.commands?.defaults?.onAfterRun;
-        //@ts-expect-error magic.
-        commandInstance.onBotPermissionsFail ??= this.client.options.commands?.defaults?.onBotPermissionsFail;
-        //@ts-expect-error magic.
-        commandInstance.onInternalError ??= this.client.options.commands?.defaults?.onInternalError;
-        //@ts-expect-error magic.
-        commandInstance.onMiddlewaresError ??= this.client.options.commands?.defaults?.onMiddlewaresError;
-        //@ts-expect-error magic.
-        commandInstance.onPermissionsFail ??= this.client.options.commands?.defaults?.onPermissionsFail;
-        //@ts-expect-error magic.
-        commandInstance.onRunError ??= this.client.options.commands?.defaults?.onRunError;
+        if (this.client.options.commands?.defaults?.onBotPermissionsFail)
+            commandInstance.onBotPermissionsFail ??= this.client.options.commands?.defaults?.onBotPermissionsFail;
+        if (this.client.options.commands?.defaults?.onInternalError)
+            commandInstance.onInternalError ??= this.client.options.commands.defaults.onInternalError;
+        if (this.client.options.commands?.defaults?.onMiddlewaresError)
+            commandInstance.onMiddlewaresError ??= this.client.options.commands.defaults.onMiddlewaresError;
+        if (this.client.options.commands?.defaults?.onRunError)
+            commandInstance.onRunError ??= this.client.options.commands.defaults.onRunError;
         return commandInstance;
     }
     stablishCommandDefaults(commandInstance) {

package/lib/components/modalcontext.d.ts

@@ -3,6 +3,7 @@ import type { GuildMemberStructure, GuildStructure } from '../client/transformer
 import type { CommandMetadata, ExtendContext, GlobalMetadata, RegisteredMiddlewares, UsingClient } from '../commands';
 import { BaseContext } from '../commands/basecontext';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, ModalCreateBodyRequest, UnionToTuple } from '../common';
+import type { Interaction } from '../structures/Interaction';
 export interface ModalContext extends BaseContext, ExtendContext {
 }
 /**
@@ -67,7 +68,7 @@ export declare class ModalContext<M extends keyof RegisteredMiddlewares = never>
      * @returns A promise that resolves when the response is deleted.
      */
     deleteResponse(): Promise<void | undefined>;
-    modal(body: ModalCreateBodyRequest): any;
+    modal(body: ModalCreateBodyRequest): ReturnType<Interaction['modal']>;
     /**
      * Gets the channel of the interaction.
      * @param mode - The mode to fetch the channel.

package/lib/events/handler.js

@@ -192,20 +192,20 @@ class EventHandler extends common_1.BaseHandler {
     async runCustom(name, ...args) {
         const Event = this.values[name];
         if (!Event) {
-            // @ts-expect-error working with non-existent types is hard
+            // @ts-expect-error
             return this.client.collectors.run(name, args, this.client);
         }
         try {
             if (Event.data.once && Event.fired) {
-                // @ts-expect-error working with non-existent types is hard
+                // @ts-expect-error
                 return this.client.collectors.run(name, args, this.client);
             }
             Event.fired = true;
             this.logger.debug(`executed a custom event [${name}]`, Event.data.once ? 'once' : '');
             await Promise.all([
-                // @ts-expect-error working with non-existent types is hard
+                // @ts-expect-error
                 Event.run(...args, this.client),
-                // @ts-expect-error working with non-existent types is hard
+                // @ts-expect-error
                 this.client.collectors.run(name, args, this.client),
             ]);
         }

package/lib/types/payloads/webhokEvents.d.ts

@@ -0,0 +1,73 @@
+import type { MakeRequired, OmitInsert } from '../../common';
+import type { APIGuild } from './guild';
+import type { ApplicationIntegrationType } from './interactions';
+import type { APIEntitlement } from './monetization';
+import type { OAuth2Scopes } from './oauth2';
+import type { APIUser } from './user';
+/**
+ * https://discord.com/developers/docs/events/webhook-events#payload-structure
+ */
+export interface WebhookEventPayload<WET extends WebhookEventTypes = WebhookEventTypes> {
+    /** Version scheme for the webhook event */
+    version: 1;
+    /**	ID of your app */
+    application_id: string;
+    /**	Type of webhook, either 0 for PING or 1 for webhook events */
+    type: WET;
+    /**	Event data payload */
+    event: EventBodyObject<WET>;
+}
+export type EventBodyObjectData<T extends WebhookEventTypes> = T extends WebhookEventTypes.ApplicationAuthorized ? ApplicationAuthorizedEvent : APIEntitlement;
+/**
+ * https://discord.com/developers/docs/events/webhook-events#event-body-object
+ */
+export interface EventBodyObject<T extends WebhookEventTypes = WebhookEventTypes> {
+    /** Event type */
+    type: T;
+    /** Timestamp of when the event occurred in ISO8601 format */
+    timestamp: string;
+    /** Data for the event. The shape depends on the event type */
+    data?: EventBodyObjectData<T>;
+}
+/**
+ * https://discord.com/developers/docs/events/webhook-events#application-authorized-application-authorized-structure
+ */
+export interface ApplicationAuthorizedEvent {
+    /** Installation context for the authorization. Either guild (0) if installed to a server or user (1) if installed to a user's account */
+    integration_type?: ApplicationIntegrationType;
+    /** User who authorized the app */
+    user: APIUser;
+    /** List of scopes the user authorized */
+    scopes: `${OAuth2Scopes}`[];
+    /**	Server which app was authorized for (when integration type is 0) */
+    guild?: APIGuild;
+}
+export type ApplicationGuildAuthorizedEvent = MakeRequired<OmitInsert<ApplicationAuthorizedEvent, 'integration_type', {
+    integration_type: ApplicationIntegrationType.GuildInstall;
+}>, 'guild'>;
+export type ApplicationUserAuthorizedEvent = OmitInsert<ApplicationAuthorizedEvent, 'integration_type' | 'guild', {
+    integration_type: ApplicationIntegrationType.UserInstall;
+}>;
+/**
+ * https://discord.com/developers/docs/events/webhook-events#webhook-types
+ */
+export declare enum WebhookRequestType {
+    /** PING event sent to verify your Webhook Event URL is active */
+    PING = 0,
+    /** Webhook event (details for event in event body object) */
+    Event = 1
+}
+/**
+ * https://discord.com/developers/docs/events/webhook-events#event-types
+ */
+export declare enum WebhookEventTypes {
+    /** Sent when an app was authorized by a user to a server or their account */
+    ApplicationAuthorized = "APPLICATION_AUTHORIZED",
+    /** Entitlement was created */
+    EntitlementCreate = "ENTITLEMENT_CREATE",
+    /**
+     * User was added to a Quest (currently unavailable)
+     * @unstable
+     */
+    QuestUserEnrollment = "QUEST_USER_ENROLLMENT"
+}

package/lib/types/payloads/webhokEvents.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookEventTypes = exports.WebhookRequestType = void 0;
+/**
+ * https://discord.com/developers/docs/events/webhook-events#webhook-types
+ */
+var WebhookRequestType;
+(function (WebhookRequestType) {
+    /** PING event sent to verify your Webhook Event URL is active */
+    WebhookRequestType[WebhookRequestType["PING"] = 0] = "PING";
+    /** Webhook event (details for event in event body object) */
+    WebhookRequestType[WebhookRequestType["Event"] = 1] = "Event";
+})(WebhookRequestType || (exports.WebhookRequestType = WebhookRequestType = {}));
+/**
+ * https://discord.com/developers/docs/events/webhook-events#event-types
+ */
+var WebhookEventTypes;
+(function (WebhookEventTypes) {
+    /** Sent when an app was authorized by a user to a server or their account */
+    WebhookEventTypes["ApplicationAuthorized"] = "APPLICATION_AUTHORIZED";
+    /** Entitlement was created */
+    WebhookEventTypes["EntitlementCreate"] = "ENTITLEMENT_CREATE";
+    /**
+     * User was added to a Quest (currently unavailable)
+     * @unstable
+     */
+    WebhookEventTypes["QuestUserEnrollment"] = "QUEST_USER_ENROLLMENT";
+})(WebhookEventTypes || (exports.WebhookEventTypes = WebhookEventTypes = {}));

package/lib/websocket/discord/shard.js

@@ -75,8 +75,8 @@ class Shard {
         }
         clearTimeout(this.heart.nodeInterval);
         this.debugger?.debug(`[Shard #${this.id}] Connecting to ${this.currentGatewayURL}`);
-        // @ts-expect-error @types/bun cause erros in compile
-        // biome-ignore lint/correctness/noUndeclaredVariables: /\ bun lol
+        // @ts-expect-error Use native websocket when using Bun
+        // biome-ignore lint/correctness/noUndeclaredVariables: /\
         this.websocket = new basesocket_1.BaseSocket(typeof Bun === 'undefined' ? 'ws' : 'bun', this.currentGatewayURL);
         this.websocket.onmessage = ({ data }) => {
             this.handleMessage(data);

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

@@ -117,6 +117,8 @@ export interface WorkerData {
     workerId: number;
     debug: boolean;
     workerProxy: boolean;
+    info: APIGatewayBotInfo;
+    compress: boolean;
     __USING_WATCHER__?: boolean;
     resharding: boolean;
 }

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

@@ -57,6 +57,7 @@ export type WorkerSendEvalResponse = CreateWorkerMessage<'EVAL_RESPONSE', {
 export type WorkerSendToWorkerEval = CreateWorkerMessage<'EVAL_TO_WORKER', {
     func: string;
     nonce: string;
+    vars: string;
     toWorkerId: number;
 }>;
 export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerShardsConnected | WorkerSendApiRequest | WorkerSendEvalResponse | WorkerSendToWorkerEval | WorkerStart | WorkerStartResharding | WorkerRequestConnectResharding | WorkerReadyResharding | WorkerDisconnectedAllShardsResharding;

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

@@ -68,8 +68,8 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | WorkerTh
     send(data: GatewaySendPayload, shardId: number): Promise<true>;
     getShardInfo(shardId: number): Promise<WorkerShardInfo>;
     getWorkerInfo(workerId: number): Promise<WorkerInfo>;
-    tellWorker<R>(workerId: number, func: (_: WorkerClient & UsingClient) => R): Promise<R>;
-    tellWorkers<R>(func: (_: WorkerClient & UsingClient) => R): Promise<Awaited<R>[]>;
+    tellWorker<R, V extends Record<string, unknown>>(workerId: number, func: (_: WorkerClient & UsingClient, vars: V) => R, vars: V): Promise<R>;
+    tellWorkers<R, V extends Record<string, unknown>>(func: (_: WorkerClient & UsingClient, vars: V) => R, vars: V): Promise<Awaited<R>[]>;
     start(): Promise<void>;
     startResharding(): Promise<void>;
 }
@@ -113,10 +113,12 @@ export type ManagerSendApiResponse = CreateManagerMessage<'API_RESPONSE', {
 export type ManagerExecuteEvalToWorker = CreateManagerMessage<'EXECUTE_EVAL_TO_WORKER', {
     func: string;
     nonce: string;
+    vars: string;
     toWorkerId: number;
 }>;
 export type ManagerExecuteEval = CreateManagerMessage<'EXECUTE_EVAL', {
     func: string;
+    vars: string;
     nonce: string;
 }>;
 export type ManagerSendEvalResponse = CreateManagerMessage<'EVAL_RESPONSE', {

package/lib/websocket/discord/workermanager.js

@@ -124,6 +124,11 @@ class WorkerManager extends Map {
                         mode: this.options.mode,
                         resharding,
                         totalWorkers: shards.length,
+                        info: {
+                            ...this.options.info,
+                            shards: this.totalShards,
+                        },
+                        compress: this.options.compress,
                     });
                     this.set(i, worker);
                 });
@@ -149,7 +154,8 @@ class WorkerManager extends Map {
         if (workerData.resharding)
             env.SEYFERT_WORKER_RESHARDING = 'true';
         for (const i in workerData) {
-            env[`SEYFERT_WORKER_${i.toUpperCase()}`] = workerData[i];
+            const data = workerData[i];
+            env[`SEYFERT_WORKER_${i.toUpperCase()}`] = typeof data === 'object' && data ? JSON.stringify(data) : data;
         }
         switch (this.options.mode) {
             case 'threads': {
@@ -381,6 +387,7 @@ class WorkerManager extends Map {
                         func: message.func,
                         type: 'EXECUTE_EVAL_TO_WORKER',
                         toWorkerId: message.toWorkerId,
+                        vars: message.vars,
                     });
                     this.generateSendPromise(nonce, 'Eval timeout').then(val => this.postMessage(message.workerId, {
                         nonce: message.nonce,
@@ -440,19 +447,20 @@ class WorkerManager extends Map {
         this.postMessage(workerId, { nonce, type: 'WORKER_INFO' });
         return this.generateSendPromise(nonce, 'Get worker info timeout');
     }
-    tellWorker(workerId, func) {
+    tellWorker(workerId, func, vars) {
         const nonce = this.generateNonce();
         this.postMessage(workerId, {
             type: 'EXECUTE_EVAL',
             func: func.toString(),
             nonce,
+            vars: JSON.stringify(vars),
         });
         return this.generateSendPromise(nonce);
     }
-    tellWorkers(func) {
+    tellWorkers(func, vars) {
         const promises = [];
         for (const i of this.keys()) {
-            promises.push(this.tellWorker(i, func));
+            promises.push(this.tellWorker(i, func, vars));
         }
         return Promise.all(promises);
     }
@@ -464,7 +472,7 @@ class WorkerManager extends Map {
         this.rest ??= new __1.ApiHandler({
             token: this.options.token,
             baseUrl: 'api/v10',
-            domain: 'https://discord.com',
+            domain: common_1.BASE_HOST,
             debug: this.options.debug,
         });
         this.options.info ??= await this.rest.proxy.gateway.bot.get();
@@ -487,7 +495,7 @@ class WorkerManager extends Map {
             shardEnd: this.shardEnd,
             shardsPerWorker: this.shardsPerWorker,
         }, this.debugger);
-        await this.prepareWorkers(spaces);
+        this.prepareWorkers(spaces);
         // Start workers queue
         this.workerQueue.shift()();
         await this.startResharding();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "2.1.1-dev-11727465603.0",
+	"version": "2.1.1-dev-11768778519.0",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",