seyfert 0.1.0

package/lib/client/httpclient.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const common_1 = require("../common");
+const base_1 = require("./base");
+const oninteraction_1 = require("./oninteraction");
+let UWS;
+let nacl;
+try {
+    UWS = require('uWebSockets.js');
+}
+catch {
+    // easter egg #1
+}
+try {
+    nacl = require('tweetnacl');
+}
+catch {
+    // I always cum
+}
+class HttpClient extends base_1.BaseClient {
+    app;
+    publicKey;
+    publicKeyHex;
+    constructor() {
+        super();
+        if (!UWS) {
+            throw new Error('No uws installed.');
+        }
+        if (!nacl) {
+            throw new Error('No tweetnacl installed.');
+        }
+    }
+    static readJson(res) {
+        return new Promise((cb, err) => {
+            let buffer;
+            res.onData((ab, isLast) => {
+                const chunk = Buffer.from(ab);
+                if (isLast) {
+                    let json;
+                    try {
+                        json = JSON.parse(buffer ? Buffer.concat([buffer, chunk]).toString() : chunk.toString());
+                    }
+                    catch (e) {
+                        res.close();
+                        return;
+                    }
+                    cb(json);
+                }
+                else {
+                    buffer = Buffer.concat(buffer ? [buffer, chunk] : [chunk]);
+                }
+            });
+            res.onAborted(err);
+        });
+    }
+    async execute(options) {
+        await super.execute();
+        const { publicKey: publicKeyRC, port: portRC, applicationId: applicationIdRC, } = await this.getRC();
+        const publicKey = options?.publicKey ?? publicKeyRC;
+        const port = options?.port ?? portRC;
+        if (!publicKey) {
+            throw new Error('Expected a publicKey, check your config file');
+        }
+        if (!port) {
+            throw new Error('Expected a port, check your config file');
+        }
+        if (applicationIdRC) {
+            this.applicationId = applicationIdRC;
+        }
+        this.publicKey = publicKey;
+        this.publicKeyHex = Buffer.from(this.publicKey, 'hex');
+        this.app = UWS.App();
+        this.app.post('/interactions', (res, req) => {
+            return this.onPacket(res, req);
+        });
+        this.app.listen(port, () => {
+            this.logger.info(`Listening to port ${port}`);
+        });
+    }
+    async start(options = {}) {
+        await super.start(options);
+        return this.execute(options.httpConnection);
+    }
+    // https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
+    async verifySignature(res, req) {
+        const body = await HttpClient.readJson(res);
+        const timestamp = req.getHeader('x-signature-timestamp');
+        const ed25519 = req.getHeader('x-signature-ed25519');
+        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
+            return body;
+        }
+        return;
+    }
+    async onPacket(res, req) {
+        const rawBody = await this.verifySignature(res, req);
+        if (!rawBody) {
+            this.debugger?.debug('Invalid request/No info, returning 418 status.');
+            // I'm a teapot
+            res.writeStatus('418').end();
+        }
+        else {
+            switch (rawBody.type) {
+                case common_1.InteractionType.Ping:
+                    this.debugger?.debug('Ping interaction received, responding.');
+                    res
+                        .writeHeader('Content-Type', 'application/json')
+                        .end(JSON.stringify({ type: common_1.InteractionResponseType.Pong }));
+                    break;
+                default:
+                    await (0, oninteraction_1.onInteraction)(-1, rawBody, this, async ({ body, files }) => {
+                        let response;
+                        let headers = {};
+                        if (files?.length) {
+                            response = new form_data_1.default();
+                            for (const key in files) {
+                                const file = files[key];
+                                response.append(key, file.data, file);
+                            }
+                            if (body) {
+                                response.append('payload_json', JSON.stringify(body));
+                            }
+                            headers = Object.assign(headers, response.getHeaders());
+                        }
+                        else {
+                            response = body ?? {};
+                            headers['Content-Type'] = 'application/json';
+                        }
+                        for (const i in headers) {
+                            res.writeHeader(i, headers[i]);
+                        }
+                        return res.end(JSON.stringify(response));
+                    });
+                    break;
+            }
+        }
+    }
+}
+exports.HttpClient = HttpClient;

package/lib/client/index.d.ts

@@ -0,0 +1,4 @@
+export type { RuntimeConfig, RuntimeConfigHTTP } from './base';
+export * from './client';
+export * from './httpclient';
+export * from './workerclient';

package/lib/client/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./httpclient"), exports);
+__exportStar(require("./workerclient"), exports);

package/lib/client/oninteraction.d.ts

@@ -0,0 +1,4 @@
+import { type APIInteraction } from 'discord-api-types/v10';
+import type { __InternalReplyFunction } from '../structures';
+import type { BaseClient } from './base';
+export declare function onInteraction(shardId: number, body: APIInteraction, self: BaseClient, __reply?: __InternalReplyFunction): Promise<any>;

package/lib/client/oninteraction.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onInteraction = void 0;
+const v10_1 = require("discord-api-types/v10");
+const commands_1 = require("../commands");
+const structures_1 = require("../structures");
+async function onInteraction(shardId, body, self, __reply) {
+    self.debugger?.debug(`[${v10_1.InteractionType[body.type] ?? body.type}] Interaction received.`);
+    switch (body.type) {
+        case v10_1.InteractionType.ApplicationCommandAutocomplete:
+            {
+                const parentCommand = self.commands.values.find(x => {
+                    if (x.guild_id && !x.guild_id.includes(body.data.guild_id ?? '')) {
+                        return false;
+                    }
+                    return x.name === body.data.name;
+                });
+                const optionsResolver = new commands_1.OptionResolver(self, body.data.options ?? [], parentCommand, body.data.guild_id, body.data.resolved);
+                const interaction = new structures_1.AutocompleteInteraction(self, body, __reply);
+                const command = optionsResolver.getAutocomplete();
+                // idc, is a YOU problem
+                if (!command?.autocomplete)
+                    return self.logger.warn(`${optionsResolver.fullCommandName} ${command?.name} command does not have 'autocomplete' callback`);
+                try {
+                    try {
+                        await command.autocomplete(interaction);
+                    }
+                    catch (error) {
+                        self.logger.error(`${optionsResolver.fullCommandName} ${command.name} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
+                        await command.onAutocompleteError?.(interaction, error);
+                    }
+                }
+                catch (error) {
+                    try {
+                        await optionsResolver.getCommand()?.onInternalError(self, error);
+                    }
+                    catch {
+                        // supress error
+                    }
+                }
+            }
+            break;
+        case v10_1.InteractionType.ApplicationCommand:
+            {
+                switch (body.data.type) {
+                    case v10_1.ApplicationCommandType.Message:
+                    case v10_1.ApplicationCommandType.User:
+                        {
+                            const command = self.commands.values.find(x => {
+                                if (x.guild_id && !x.guild_id.includes(body.data.guild_id ?? '')) {
+                                    return false;
+                                }
+                                return x.name === body.data.name;
+                            });
+                            const interaction = structures_1.BaseInteraction.from(self, body, __reply);
+                            // idc, is a YOU problem
+                            if (!command?.run)
+                                return self.logger.warn(`${command.name ?? 'Unknown'} command does not have 'run' callback`);
+                            const context = new commands_1.MenuCommandContext(self, interaction, shardId);
+                            const extendContext = self.options?.context?.(interaction) ?? {};
+                            Object.assign(context, extendContext);
+                            try {
+                                const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
+                                if (resultRunGlobalMiddlewares === 'pass') {
+                                    return;
+                                }
+                                if (resultRunGlobalMiddlewares) {
+                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares);
+                                }
+                                const resultRunMiddlewares = await command.__runMiddlewares(context);
+                                if (resultRunMiddlewares === 'pass') {
+                                    return;
+                                }
+                                if (resultRunGlobalMiddlewares) {
+                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares);
+                                }
+                                try {
+                                    await command.run(context);
+                                    await command.onAfterRun?.(context, undefined);
+                                }
+                                catch (error) {
+                                    self.logger.error(`${command.name} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
+                                    await command.onRunError?.(context, error);
+                                    await command.onAfterRun?.(context, error);
+                                }
+                            }
+                            catch (error) {
+                                try {
+                                    await command.onInternalError(self, error);
+                                }
+                                catch {
+                                    // supress error
+                                }
+                            }
+                        }
+                        break;
+                    case v10_1.ApplicationCommandType.ChatInput:
+                        {
+                            const packetData = body.data;
+                            const parentCommand = self.commands.values.find(x => {
+                                if (x.guild_id && !x.guild_id.includes(packetData.guild_id ?? '')) {
+                                    return false;
+                                }
+                                return x.name === packetData.name;
+                            });
+                            const optionsResolver = new commands_1.OptionResolver(self, packetData.options ?? [], parentCommand, packetData.guild_id, packetData.resolved);
+                            const interaction = structures_1.BaseInteraction.from(self, body, __reply);
+                            const command = optionsResolver.getCommand();
+                            if (!command?.run)
+                                return self.logger.warn(`${optionsResolver.fullCommandName} command does not have 'run' callback`);
+                            const context = new commands_1.CommandContext(self, interaction, optionsResolver, shardId);
+                            const extendContext = self.options?.context?.(interaction) ?? {};
+                            Object.assign(context, extendContext);
+                            try {
+                                const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
+                                if (erroredOptions) {
+                                    return command.onOptionsError?.(context, result);
+                                }
+                                const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
+                                if (resultRunGlobalMiddlewares === 'pass') {
+                                    return;
+                                }
+                                if (resultRunGlobalMiddlewares) {
+                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares);
+                                }
+                                const resultRunMiddlewares = await command.__runMiddlewares(context);
+                                if (resultRunMiddlewares === 'pass') {
+                                    return;
+                                }
+                                if (resultRunMiddlewares) {
+                                    return command.onMiddlewaresError?.(context, resultRunMiddlewares);
+                                }
+                                try {
+                                    await command.run(context);
+                                    await command.onAfterRun?.(context, undefined);
+                                }
+                                catch (error) {
+                                    self.logger.error(`${optionsResolver.fullCommandName} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
+                                    await command.onRunError?.(context, error);
+                                    await command.onAfterRun?.(context, error);
+                                }
+                            }
+                            catch (error) {
+                                try {
+                                    await command.onInternalError(self, error);
+                                }
+                                catch {
+                                    // supress error
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+            break;
+        case v10_1.InteractionType.ModalSubmit:
+            {
+                const interaction = structures_1.BaseInteraction.from(self, body, __reply);
+                if (self.components.hasModal(interaction)) {
+                    await self.components.onModalSubmit(interaction);
+                }
+                else {
+                    await self.components.executeModal(interaction);
+                }
+            }
+            break;
+        case v10_1.InteractionType.MessageComponent:
+            {
+                const interaction = structures_1.BaseInteraction.from(self, body, __reply);
+                if (self.components.hasComponent(body.message.interaction.id, interaction.customId)) {
+                    await self.components.onComponent(body.message.interaction.id, interaction);
+                }
+                else {
+                    await self.components.executeComponent(interaction);
+                }
+            }
+            break;
+    }
+}
+exports.onInteraction = onInteraction;

package/lib/client/workerclient.d.ts

@@ -0,0 +1,28 @@
+import type { Cache } from '../cache';
+import type { GatewayDispatchPayload, When } from '../common';
+import { Logger, type DeepPartial } from '../common';
+import { EventHandler } from '../events';
+import { ClientUser } from '../structures';
+import { Shard } from '../websocket';
+import type { WorkerShardInfo } from '../websocket/discord/worker';
+import type { ManagerMessages } from '../websocket/discord/workermanager';
+import type { BaseClientOptions, StartOptions } from './base';
+import { BaseClient } from './base';
+export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
+    logger: Logger;
+    events: EventHandler;
+    me: When<Ready, ClientUser>;
+    shards: Map<number, Shard>;
+    options: WorkerClientOptions | undefined;
+    constructor(options?: WorkerClientOptions);
+    get workerId(): number;
+    start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
+    loadEvents(dir?: string): Promise<void>;
+    protected handleManagerMessages(data: ManagerMessages): Promise<void>;
+    protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
+}
+export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
+interface WorkerClientOptions extends BaseClientOptions {
+    disabledCache: Cache['disabledCache'];
+}
+export {};

package/lib/client/workerclient.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateShardInfo = exports.WorkerClient = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const cache_1 = require("../cache");
+const common_1 = require("../common");
+const events_1 = require("../events");
+const structures_1 = require("../structures");
+const websocket_1 = require("../websocket");
+const base_1 = require("./base");
+const oninteraction_1 = require("./oninteraction");
+const workerData = node_worker_threads_1.workerData;
+class WorkerClient extends base_1.BaseClient {
+    logger = new common_1.Logger({
+        name: `[Worker #${workerData.workerId}]`,
+    });
+    events = new events_1.EventHandler(this.logger);
+    me;
+    shards = new Map();
+    constructor(options) {
+        super(options);
+        if (!node_worker_threads_1.parentPort) {
+            throw new Error('WorkerClient cannot spawn without manager');
+        }
+        node_worker_threads_1.parentPort.on('message', data => this.handleManagerMessages(data));
+        this.setServices({
+            cache: {
+                adapter: new cache_1.WorkerAdapter(node_worker_threads_1.parentPort),
+                disabledCache: options?.disabledCache,
+            },
+        });
+        if (workerData.debug) {
+            this.debugger = new common_1.Logger({
+                name: `[Worker #${workerData.workerId}]`,
+                logLevel: common_1.LogLevels.Debug,
+            });
+        }
+    }
+    get workerId() {
+        return workerData.workerId;
+    }
+    async start(options = {}) {
+        await super.start(options);
+        await this.loadEvents(options.eventsDir);
+        this.cache.intents = workerData.intents;
+    }
+    async loadEvents(dir) {
+        dir ??= await this.getRC().then(x => x.events);
+        if (dir) {
+            await this.events.load(dir);
+            this.logger.info('EventHandler loaded');
+        }
+    }
+    async handleManagerMessages(data) {
+        switch (data.type) {
+            case 'CACHE_RESULT':
+                if (this.cache.adapter.promises.has(data.nonce)) {
+                    this.cache.adapter.promises.get(data.nonce)?.(data.result);
+                    this.cache.adapter.promises.delete(data.nonce);
+                }
+                break;
+            case 'SEND_PAYLOAD':
+                {
+                    const shard = this.shards.get(data.shardId);
+                    if (!shard) {
+                        this.logger.fatal('Worker trying send payload by non-existent shard');
+                        return;
+                    }
+                    await shard.send(0, {
+                        ...data,
+                    });
+                    node_worker_threads_1.parentPort.postMessage({
+                        type: 'RESULT_PAYLOAD',
+                        nonce: data.nonce,
+                    });
+                }
+                break;
+            case 'ALLOW_CONNECT':
+                {
+                    const shard = this.shards.get(data.shardId);
+                    if (!shard) {
+                        this.logger.fatal('Worker trying connect non-existent shard');
+                        return;
+                    }
+                    shard.options.presence = data.presence;
+                    await shard.connect();
+                }
+                break;
+            case 'SPAWN_SHARDS':
+                {
+                    const cache = this.cache;
+                    const onPacket = this.onPacket.bind(this);
+                    for (const id of workerData.shards) {
+                        let shard = this.shards.get(id);
+                        if (!shard) {
+                            shard = new websocket_1.Shard(id, {
+                                token: workerData.token,
+                                intents: workerData.intents,
+                                info: data.info,
+                                compress: data.compress,
+                                debugger: this.debugger,
+                                async handlePayload(shardId, payload) {
+                                    await cache.onPacket(payload);
+                                    await onPacket?.(payload, shardId);
+                                    node_worker_threads_1.parentPort.postMessage({
+                                        workerId: workerData.workerId,
+                                        shardId,
+                                        type: 'RECEIVE_PAYLOAD',
+                                        payload,
+                                    });
+                                },
+                            });
+                            this.shards.set(id, shard);
+                        }
+                        node_worker_threads_1.parentPort.postMessage({
+                            type: 'CONNECT_QUEUE',
+                            shardId: id,
+                            workerId: workerData.workerId,
+                        });
+                    }
+                }
+                break;
+            case 'SHARD_INFO':
+                {
+                    const shard = this.shards.get(data.shardId);
+                    if (!shard) {
+                        this.logger.fatal('Worker trying get non-existent shard');
+                        return;
+                    }
+                    node_worker_threads_1.parentPort.postMessage({
+                        ...generateShardInfo(shard),
+                        nonce: data.nonce,
+                        type: 'SHARD_INFO',
+                    });
+                }
+                break;
+            case 'WORKER_INFO':
+                {
+                    node_worker_threads_1.parentPort.postMessage({
+                        shards: [...this.shards.values()].map(generateShardInfo),
+                        workerId: workerData.workerId,
+                        type: 'WORKER_INFO',
+                        nonce: data.nonce,
+                    });
+                }
+                break;
+            case 'BOT_READY':
+                if (this.events.values.BOT_READY &&
+                    (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
+                    this.events.values.BOT_READY.fired = true;
+                    await this.events.values.BOT_READY.run(this.me, this, -1);
+                }
+                break;
+        }
+    }
+    async onPacket(packet, shardId) {
+        switch (packet.t) {
+            case 'READY':
+                for (const g of packet.d.guilds) {
+                    this.__handleGuilds.add(g.id);
+                }
+                this.botId = packet.d.user.id;
+                this.applicationId = packet.d.application.id;
+                this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
+                if (!this.__handleGuilds.size) {
+                    if ([...this.shards.values()].every(shard => shard.data.session_id) &&
+                        this.events.values.WORKER_READY &&
+                        (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
+                        node_worker_threads_1.parentPort.postMessage({
+                            type: 'WORKER_READY',
+                            workerId: this.workerId,
+                        });
+                        this.events.values.WORKER_READY.fired = true;
+                        await this.events.values.WORKER_READY.run(this.me, this, -1);
+                    }
+                }
+                this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
+                break;
+            case 'INTERACTION_CREATE': {
+                await (0, oninteraction_1.onInteraction)(shardId, packet.d, this);
+                break;
+            }
+            case 'GUILD_CREATE': {
+                if (this.__handleGuilds.has(packet.d.id)) {
+                    this.__handleGuilds.delete(packet.d.id);
+                    if (!this.__handleGuilds.size &&
+                        [...this.shards.values()].every(shard => shard.data.session_id) &&
+                        this.events.values.WORKER_READY &&
+                        (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
+                        node_worker_threads_1.parentPort.postMessage({
+                            type: 'WORKER_READY',
+                            workerId: this.workerId,
+                        });
+                        this.events.values.WORKER_READY.fired = true;
+                        await this.events.values.WORKER_READY.run(this.me, this, -1);
+                    }
+                    return;
+                }
+            }
+        }
+        await this.events.execute(packet.t, packet, this, shardId);
+    }
+}
+exports.WorkerClient = WorkerClient;
+function generateShardInfo(shard) {
+    return {
+        open: shard.isOpen,
+        shardId: shard.id,
+        latency: shard.latency,
+        resumable: shard.resumable,
+    };
+}
+exports.generateShardInfo = generateShardInfo;