seyfert 1.3.3 → 1.5.0

package/lib/client/httpclient.js

@@ -5,6 +5,7 @@ const v10_1 = require("discord-api-types/v10");
 const magic_bytes_js_1 = require("magic-bytes.js");
 const api_1 = require("../api");
 const utils_1 = require("../api/utils/utils");
+const common_1 = require("../common");
 const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 let UWS;
@@ -27,9 +28,9 @@ class HttpClient extends base_1.BaseClient {
     publicKeyHex;
     constructor(options) {
         super(options);
-        if (!UWS) {
-            throw new Error('No uws installed.');
-        }
+        // if (!UWS) {
+        // 	throw new Error('No uws installed.');
+        // }
         if (!nacl) {
             throw new Error('No tweetnacl installed.');
         }
@@ -60,8 +61,8 @@ class HttpClient extends base_1.BaseClient {
     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;
+        const publicKey = options.publicKey ?? publicKeyRC;
+        const port = options.port ?? portRC;
         if (!publicKey) {
             throw new Error('Expected a publicKey, check your config file');
         }
@@ -73,17 +74,33 @@ class HttpClient extends base_1.BaseClient {
         }
         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}`);
-        });
+        if (UWS && options.useUWS) {
+            this.app = UWS.App();
+            this.app.post('/interactions', (res, req) => {
+                return this.onPacket(res, req);
+            });
+            this.app.listen(port, () => {
+                this.logger.info(`Listening to <url>:${port}/interactions`);
+            });
+        }
+        else {
+            if (options.useUWS)
+                return this.logger.warn('No uWebSockets installed.');
+            this.logger.info('Use your preferred http server and invoke <HttpClient>.fetch(<Request>) to get started');
+        }
     }
     async start(options = {}) {
         await super.start(options);
-        return this.execute(options.httpConnection);
+        return this.execute((0, common_1.MergeOptions)({ useUWS: true }, options.httpConnection));
+    }
+    async verifySignatureGenericRequest(req) {
+        const timestamp = req.headers.get('x-signature-timestamp');
+        const ed25519 = req.headers.get('x-signature-ed25519') ?? '';
+        const body = (await req.json());
+        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
+            return body;
+        }
+        return;
     }
     // https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
     async verifySignature(res, req) {
@@ -95,14 +112,71 @@ class HttpClient extends base_1.BaseClient {
         }
         return;
     }
-    async onPacket(res, req) {
-        const rawBody = await this.verifySignature(res, req);
+    async fetch(req) {
+        const rawBody = await this.verifySignatureGenericRequest(req);
         if (!rawBody) {
             this.debugger?.debug('Invalid request/No info, returning 418 status.');
             // I'm a teapot
-            res.writeStatus('418').end();
+            return new Response('', { status: 418 });
         }
-        else {
+        switch (rawBody.type) {
+            case v10_1.InteractionType.Ping:
+                this.debugger?.debug('Ping interaction received, responding.');
+                return Response.json({ type: v10_1.InteractionResponseType.Pong }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+            default:
+                return new Promise(r => {
+                    if ((0, common_1.isCloudfareWorker)())
+                        return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1)
+                            .then(() => r(new Response()))
+                            .catch(() => r(new Response()));
+                    return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
+                        let response;
+                        const headers = {};
+                        if (files) {
+                            response = new FormData();
+                            for (const [index, file] of files.entries()) {
+                                const fileKey = file.key ?? `files[${index}]`;
+                                if ((0, utils_1.isBufferLike)(file.data)) {
+                                    let contentType = file.contentType;
+                                    if (!contentType) {
+                                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
+                                        if (parsedType) {
+                                            contentType =
+                                                api_1.OverwrittenMimeTypes[parsedType.mime] ??
+                                                    parsedType.mime ??
+                                                    'application/octet-stream';
+                                        }
+                                    }
+                                    response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
+                                }
+                                else {
+                                    response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
+                                }
+                            }
+                            if (body) {
+                                response.append('payload_json', JSON.stringify(body));
+                            }
+                        }
+                        else {
+                            response = body ?? {};
+                            headers['Content-Type'] = 'application/json';
+                        }
+                        r(response instanceof FormData
+                            ? new Response(response, { headers })
+                            : Response.json(response, {
+                                headers,
+                            }));
+                    });
+                });
+        }
+    }
+    async onPacket(res, req) {
+        const rawBody = await this.verifySignature(res, req);
+        if (rawBody) {
             switch (rawBody.type) {
                 case v10_1.InteractionType.Ping:
                     this.debugger?.debug('Ping interaction received, responding.');
@@ -153,6 +227,11 @@ class HttpClient extends base_1.BaseClient {
                     break;
             }
         }
+        else {
+            this.debugger?.debug('Invalid request/No info, returning 418 status.');
+            // I'm a teapot
+            res.writeStatus('418').end();
+        }
     }
 }
 exports.HttpClient = HttpClient;

package/lib/client/oninteractioncreate.d.ts

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

package/lib/client/oninteractioncreate.js

@@ -4,6 +4,7 @@ exports.onInteractionCreate = void 0;
 const v10_1 = require("discord-api-types/v10");
 const commands_1 = require("../commands");
 const structures_1 = require("../structures");
+const components_1 = require("../components");
 async function onInteractionCreate(self, body, shardId, __reply) {
     self.debugger?.debug(`[${v10_1.InteractionType[body.type] ?? body.type}] Interaction received.`);
     switch (body.type) {
@@ -16,7 +17,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                     return x.name === body.data.name;
                 });
                 const optionsResolver = new commands_1.OptionResolver(self, body.data.options ?? [], parentCommand, body.guild_id, body.data.resolved);
-                const interaction = new structures_1.AutocompleteInteraction(self, body, __reply);
+                const interaction = new structures_1.AutocompleteInteraction(self, body, optionsResolver, __reply);
                 const command = optionsResolver.getAutocomplete();
                 // idc, is a YOU problem
                 if (!command?.autocomplete)
@@ -64,17 +65,17 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                                 if (command.botPermissions && interaction.appPermissions) {
                                     const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values([command.botPermissions]));
                                     if (!interaction.appPermissions.has('Administrator') && permissions.length) {
-                                        return command.onBotPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
+                                        return command.onBotPermissionsFail(context, interaction.appPermissions.keys(permissions));
                                     }
                                 }
-                                const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
+                                const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (self.options?.globalMiddlewares ?? []), true);
                                 if (resultRunGlobalMiddlewares.pass) {
                                     return;
                                 }
                                 if ('error' in resultRunGlobalMiddlewares) {
                                     return command.onMiddlewaresError(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
                                 }
-                                const resultRunMiddlewares = await command.__runMiddlewares(context);
+                                const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, command.middlewares, false);
                                 if (resultRunMiddlewares.pass) {
                                     return;
                                 }
@@ -86,7 +87,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                                     await command.onAfterRun?.(context, undefined);
                                 }
                                 catch (error) {
-                                    await command.onRunError?.(context, error);
+                                    await command.onRunError(context, error);
                                     await command.onAfterRun?.(context, error);
                                 }
                             }
@@ -170,7 +171,10 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                     await self.components.onModalSubmit(interaction);
                 }
                 else {
-                    await self.components?.executeModal(interaction);
+                    const context = new components_1.ModalContext(self, interaction);
+                    const extended = self.options?.context?.(interaction) ?? {};
+                    Object.assign(context, extended);
+                    await self.components?.executeModal(context);
                 }
             }
             break;
@@ -181,7 +185,11 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                     await self.components.onComponent(body.message.id, interaction);
                 }
                 else {
-                    await self.components?.executeComponent(interaction);
+                    //@ts-expect-error
+                    const context = new components_1.ComponentContext(self, interaction);
+                    const extended = self.options?.context?.(interaction) ?? {};
+                    Object.assign(context, extended);
+                    await self.components?.executeComponent(context);
                 }
             }
             break;

package/lib/client/onmessagecreate.d.ts

@@ -1,3 +1,13 @@
-import { type GatewayMessageCreateDispatchData } from 'discord-api-types/v10';
-import { type Client, type WorkerClient } from '..';
+import { type APIApplicationCommandInteractionDataOption, type GatewayMessageCreateDispatchData } from 'discord-api-types/v10';
+import { Command, type MessageCommandOptionErrors, SubCommand, type UsingClient, type Client, type ContextOptionsResolved, type WorkerClient } from '..';
+import type { MakeRequired } from '../common';
 export declare function onMessageCreate(self: Client | WorkerClient, rawMessage: GatewayMessageCreateDispatchData, shardId: number): Promise<any>;
+export declare function defaultOptionsParser(self: UsingClient, command: Command | SubCommand, message: GatewayMessageCreateDispatchData, args: Partial<Record<string, string>>, resolved: MakeRequired<ContextOptionsResolved>): Promise<{
+    errors: {
+        name: string;
+        error: string;
+        fullError: MessageCommandOptionErrors;
+    }[];
+    options: APIApplicationCommandInteractionDataOption[];
+}>;
+export declare function defaultArgsParser(content: string): Record<string, string>;

package/lib/client/onmessagecreate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onMessageCreate = void 0;
+exports.defaultArgsParser = exports.defaultOptionsParser = exports.onMessageCreate = void 0;
 const v10_1 = require("discord-api-types/v10");
 const __1 = require("..");
 const structures_1 = require("../structures");
@@ -45,7 +45,7 @@ async function onMessageCreate(self, rawMessage, shardId) {
     const message = new structures_1.Message(self, rawMessage);
     const prefixes = (await self.options.commands.prefix(message)).sort((a, b) => b.length - a.length);
     const prefix = prefixes.find(x => message.content.startsWith(x));
-    if (!prefix || !message.content.startsWith(prefix))
+    if (!(prefix !== undefined && message.content.startsWith(prefix)))
         return;
     const content = message.content.slice(prefix.length).trimStart();
     const { fullCommandName, command, parent } = getCommandFromContent(content
@@ -56,7 +56,9 @@ async function onMessageCreate(self, rawMessage, shardId) {
         return;
     if (!command.run)
         return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
-    if (!command.contexts?.includes(__1.InteractionContextTypes.BOT_DM) && !message.guildId)
+    if (!command.contexts.includes(v10_1.InteractionContextType.BotDM) && !message.guildId)
+        return;
+    if (!command.contexts.includes(v10_1.InteractionContextType.Guild) && message.guildId)
         return;
     if (command.guildId && !command.guildId?.includes(message.guildId))
         return;
@@ -67,14 +69,30 @@ async function onMessageCreate(self, rawMessage, shardId) {
         members: {},
         attachments: {},
     };
-    const args = (self.options?.commands?.argsParser ?? defaultArgsParser)(content, command);
-    const { options, errors } = await parseOptions(self, command, rawMessage, args, resolved);
+    let newContent = content;
+    for (const i of fullCommandName.split(' ')) {
+        newContent = newContent.slice(newContent.indexOf(i) + i.length);
+    }
+    const args = self.options.commands.argsParser(newContent.slice(1), command, message);
+    const { options, errors } = await self.options.commands.optionsParser(self, command, rawMessage, args, resolved);
     const optionsResolver = new __1.OptionResolver(self, options, parent, message.guildId, resolved);
     const context = new __1.CommandContext(self, message, optionsResolver, shardId, command);
     //@ts-expect-error
     const extendContext = self.options?.context?.(message) ?? {};
     Object.assign(context, extendContext);
     try {
+        if (errors.length) {
+            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
+                return [
+                    x.name,
+                    {
+                        failed: true,
+                        value: x.error,
+                        parseError: x.fullError,
+                    },
+                ];
+            })));
+        }
         if (command.defaultMemberPermissions && message.guildId) {
             const memberPermissions = await self.members.permissions(message.guildId, message.author.id);
             const permissions = memberPermissions.missings(...memberPermissions.values([command.defaultMemberPermissions]));
@@ -94,17 +112,6 @@ async function onMessageCreate(self, rawMessage, shardId) {
                 return command.onBotPermissionsFail?.(context, appPermissions.keys(permissions));
             }
         }
-        if (errors.length) {
-            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
-                return [
-                    x.name,
-                    {
-                        failed: true,
-                        value: x.error,
-                    },
-                ];
-            })));
-        }
         const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
         if (erroredOptions) {
             return command.onOptionsError?.(context, result);
@@ -142,7 +149,7 @@ async function onMessageCreate(self, rawMessage, shardId) {
     }
 }
 exports.onMessageCreate = onMessageCreate;
-async function parseOptions(self, command, message, args, resolved) {
+async function defaultOptionsParser(self, command, message, args, resolved) {
     const options = [];
     const errors = [];
     for (const i of (command.options ?? [])) {
@@ -175,6 +182,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                             error: `The entered channel type is not one of ${i
                                                 .channel_types.map(t => v10_1.ChannelType[t])
                                                 .join(', ')}`,
+                                            fullError: ['CHANNEL_TYPES', i.channel_types],
                                         });
                                         break;
                                     }
@@ -262,95 +270,105 @@ async function parseOptions(self, command, message, args, resolved) {
                     {
                         value = args[i.name];
                         const option = i;
-                        if (value) {
-                            if (option.min_length) {
-                                if (value.length < option.min_length) {
-                                    value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
-                                    });
-                                    break;
-                                }
-                            }
-                            if (option.max_length) {
-                                if (value.length > option.max_length) {
-                                    value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
-                                    });
-                                    break;
-                                }
-                            }
-                            if (option.choices?.length) {
-                                if (!option.choices.some(x => x.name === value)) {
-                                    value = undefined;
-                                    errors.push({
-                                        name: i.name,
-                                        error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
-                                            .map(x => x.name)
-                                            .join(', ')}.`,
-                                    });
-                                    break;
-                                }
-                                value = option.choices.find(x => x.name === value).value;
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Number:
-                case v10_1.ApplicationCommandOptionType.Integer:
-                    {
-                        value = Number(args[i.name]);
-                        if (args[i.name] === undefined) {
-                            value = undefined;
+                        if (!value)
                             break;
-                        }
-                        if (Number.isNaN(value)) {
-                            value = undefined;
-                            errors.push({
-                                name: i.name,
-                                error: 'The entered choice is an invalid number.',
-                            });
-                            break;
-                        }
-                        const option = i;
-                        if (option.min_value) {
-                            if (value < option.min_value) {
+                        if (option.min_length) {
+                            if (value.length < option.min_length) {
                                 value = undefined;
                                 errors.push({
                                     name: i.name,
-                                    error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
+                                    error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                    fullError: ['STRING_MIN_LENGTH', option.min_length],
                                 });
                                 break;
                             }
                         }
-                        if (option.max_value) {
-                            if (value > option.max_value) {
+                        if (option.max_length) {
+                            if (value.length > option.max_length) {
                                 value = undefined;
                                 errors.push({
                                     name: i.name,
-                                    error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
+                                    error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                    fullError: ['STRING_MAX_LENGTH', option.max_length],
                                 });
                                 break;
                             }
                         }
                         if (option.choices?.length) {
-                            if (!option.choices.some(x => x.name === value)) {
+                            const choice = option.choices.find(x => x.name === value);
+                            if (!choice) {
                                 value = undefined;
                                 errors.push({
                                     name: i.name,
                                     error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
                                         .map(x => x.name)
                                         .join(', ')}.`,
+                                    fullError: ['STRING_INVALID_CHOICE', option.choices],
                                 });
                                 break;
                             }
-                            value = option.choices.find(x => x.name === value).value;
+                            value = choice.value;
                         }
                     }
                     break;
+                case v10_1.ApplicationCommandOptionType.Number:
+                case v10_1.ApplicationCommandOptionType.Integer:
+                    {
+                        const option = i;
+                        if (!option.choices?.length) {
+                            value = Number(args[i.name]);
+                            if (args[i.name] === undefined) {
+                                value = undefined;
+                                break;
+                            }
+                            if (Number.isNaN(value)) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: 'The entered choice is an invalid number.',
+                                    fullError: ['NUMBER_NAN', args[i.name]],
+                                });
+                                break;
+                            }
+                            if (option.min_value) {
+                                if (value < option.min_value) {
+                                    value = undefined;
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
+                                        fullError: ['NUMBER_MIN_VALUE', option.min_value],
+                                    });
+                                    break;
+                                }
+                            }
+                            if (option.max_value) {
+                                if (value > option.max_value) {
+                                    value = undefined;
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
+                                        fullError: ['NUMBER_MAX_VALUE', option.max_value],
+                                    });
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+                        const choice = option.choices.find(x => x.name === args[i.name]);
+                        if (!choice) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                    .map(x => x.name)
+                                    .join(', ')}.`,
+                                fullError: ['NUMBER_INVALID_CHOICE', option.choices],
+                            });
+                            break;
+                        }
+                        value = choice.value;
+                    }
+                    break;
                 default:
                     break;
             }
@@ -362,20 +380,24 @@ async function parseOptions(self, command, message, args, resolved) {
                 });
             }
             else if (i.required)
-                errors.push({
-                    error: 'Option is required but returned undefined',
-                    name: i.name,
-                });
+                if (!errors.some(x => x.name === i.name))
+                    errors.push({
+                        error: 'Option is required but returned undefined',
+                        name: i.name,
+                        fullError: ['OPTION_REQUIRED'],
+                    });
         }
         catch (e) {
             errors.push({
                 error: e && typeof e === 'object' && 'message' in e ? e.message : `${e}`,
                 name: i.name,
+                fullError: ['UNKNOWN', e],
             });
         }
     }
     return { errors, options };
 }
+exports.defaultOptionsParser = defaultOptionsParser;
 function defaultArgsParser(content) {
     const args = {};
     for (const i of content.match(/-(.*?)(?=\s-|$)/gs) ?? []) {
@@ -383,5 +405,6 @@ function defaultArgsParser(content) {
     }
     return args;
 }
+exports.defaultArgsParser = defaultArgsParser;
 //-(.*?)(?=\s-|$)/gs
 //-(?<text>[^-]*)/gm

package/lib/client/workerclient.d.ts

@@ -14,10 +14,12 @@ import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
-import type { Client } from './client';
+import type { Client, ClientOptions } from './client';
+import { Collectors } from './collectors';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     logger: Logger;
+    collectors: Collectors;
     events?: EventHandler | undefined;
     me: When<Ready, ClientUser>;
     promises: Map<string, {
@@ -25,7 +27,7 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
         timeout: NodeJS.Timeout;
     }>;
     shards: Map<number, Shard>;
-    options: WorkerClientOptions | undefined;
+    options: WorkerClientOptions;
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
     get latency(): number;
@@ -48,5 +50,6 @@ interface WorkerClientOptions extends BaseClientOptions {
     disabledCache: Cache['disabledCache'];
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
+    gateway?: ClientOptions['gateway'];
 }
 export {};