seyfert 1.2.0 → 1.2.2

package/lib/cache/index.d.ts

@@ -70,11 +70,7 @@ export declare class Cache {
         } & {
             guild_id: string;
         })[];
-        voiceStates: (Omit<import("discord-api-types/v10").GatewayVoiceState, "member"> & {
-            guild_id: string;
-        } & {
-            guild_id: string;
-        })[];
+        voiceStates: import("..").VoiceState[];
         stageInstances: (import("discord-api-types/v10").APIStageInstance & {
             guild_id: string;
         })[];

package/lib/cache/resources/voice-states.d.ts

@@ -1,8 +1,13 @@
 import type { GatewayVoiceState } from 'discord-api-types/v10';
+import type { ReturnCache } from '../..';
+import { VoiceState } from '../../structures';
 import { GuildBasedResource } from './default/guild-based';
-export declare class VoiceStates extends GuildBasedResource<VoiceStateResource> {
+export declare class VoiceStates extends GuildBasedResource {
     namespace: string;
-    parse(data: any, id: string, guild_id: string): VoiceStateResource;
+    get(memberId: string, guildId: string): ReturnCache<VoiceState | undefined>;
+    bulk(ids: string[], guild: string): ReturnCache<VoiceState[]>;
+    values(guildId: string): ReturnCache<VoiceState[]>;
+    parse(data: any, id: string, guild_id: string): any;
 }
 export type VoiceStateResource = Omit<GatewayVoiceState, 'member'> & {
     guild_id: string;

package/lib/cache/resources/voice-states.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VoiceStates = void 0;
+const common_1 = require("../../common");
+const structures_1 = require("../../structures");
 const guild_based_1 = require("./default/guild-based");
 class VoiceStates extends guild_based_1.GuildBasedResource {
     namespace = 'voice_state';
+    get(memberId, guildId) {
+        return (0, common_1.fakePromise)(super.get(memberId, guildId)).then(state => state ? new structures_1.VoiceState(this.client, state) : undefined);
+    }
+    bulk(ids, guild) {
+        return (0, common_1.fakePromise)(super.bulk(ids, guild)).then(states => states.map(state => (state ? new structures_1.VoiceState(this.client, state) : undefined)).filter(y => !!y));
+    }
+    values(guildId) {
+        return (0, common_1.fakePromise)(super.values(guildId)).then(states => states.map(state => new structures_1.VoiceState(this.client, state)));
+    }
     parse(data, id, guild_id) {
         const { member, ...rest } = super.parse(data, id, guild_id);
         return rest;

package/lib/client/http/adapters/bun.d.ts

@@ -0,0 +1,14 @@
+import { HttpAdapter } from ".";
+import { Logger } from "../../../common";
+import { HttpClient } from "../httpclient";
+export declare class HttpBunAdapter extends HttpAdapter {
+    app: ReturnType<typeof Bun.serve>;
+    constructor(options: {
+        client: HttpClient;
+        debugger?: Logger;
+        logger: Logger;
+    });
+    listen(): void;
+    verifySignature(req: Request): Promise<any>;
+    onPacket(req: Request): Promise<Response>;
+}

package/lib/client/http/adapters/bun.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpBunAdapter = void 0;
+const v10_1 = require("discord-api-types/v10");
+const magic_bytes_js_1 = __importDefault(require("magic-bytes.js"));
+const _1 = require(".");
+const api_1 = require("../../../api");
+const utils_1 = require("../../../api/utils/utils");
+const oninteractioncreate_1 = require("../../oninteractioncreate");
+let nacl;
+try {
+    nacl = require('tweetnacl');
+}
+catch {
+    // I always cum
+}
+class HttpBunAdapter extends _1.HttpAdapter {
+    app;
+    constructor(options) {
+        super();
+        this.client = options.client;
+        this.debugger = options.debugger;
+        this.logger = options.logger;
+        if (typeof Bun === 'undefined') {
+            throw new Error('You are not using buntime.');
+        }
+        if (!nacl) {
+            throw new Error('No tweetnacl installed.');
+        }
+    }
+    listen() {
+        const self = this;
+        this.app = Bun.serve({
+            fetch(request) {
+                if (new URL(request.url).pathname === '/interactions') {
+                    return self.onPacket(request);
+                }
+                return new Response('?');
+            },
+            port: 8080
+        });
+        this.logger.info(`Listening to port ${this.port}`);
+    }
+    async verifySignature(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;
+    }
+    async onPacket(req) {
+        const rawBody = await this.verifySignature(req);
+        if (!rawBody) {
+            this.debugger?.debug('Invalid request/No info, returning 418 status.');
+            // I'm a teapot
+            return new Response('', {
+                status: 418
+            });
+        }
+        else {
+            switch (rawBody.type) {
+                case v10_1.InteractionType.Ping:
+                    this.debugger?.debug('Ping interaction received, responding.');
+                    return new Response(JSON.stringify({ type: v10_1.InteractionResponseType.Pong }), {
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                default:
+                    return new Promise(resolve => {
+                        (0, oninteractioncreate_1.onInteractionCreate)(this.client, 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.default)(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';
+                            }
+                            resolve(new Response(JSON.stringify(response), {
+                                headers
+                            }));
+                        });
+                    });
+            }
+        }
+    }
+}
+exports.HttpBunAdapter = HttpBunAdapter;

package/lib/client/http/adapters/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Logger } from '../../../common';
+import { HttpClient } from '../httpclient';
+export * from './bun';
+export * from './uws';
+export declare abstract class HttpAdapter {
+    port: number;
+    client: HttpClient;
+    debugger?: Logger;
+    logger: Logger;
+    publicKeyHex: Buffer;
+    abstract onPacket(...args: any[]): any;
+    abstract listen(): any;
+    abstract verifySignature(...args: any[]): any;
+}

package/lib/client/http/adapters/index.js

@@ -0,0 +1,27 @@
+"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 });
+exports.HttpAdapter = void 0;
+__exportStar(require("./bun"), exports);
+__exportStar(require("./uws"), exports);
+class HttpAdapter {
+    port;
+    client;
+    debugger;
+    logger;
+    publicKeyHex;
+}
+exports.HttpAdapter = HttpAdapter;

package/lib/client/http/adapters/uws.d.ts

@@ -0,0 +1,17 @@
+import { APIInteraction } from "discord-api-types/v10";
+import { HttpRequest, HttpResponse } from "uWebSockets.js";
+import { HttpAdapter } from ".";
+import { Logger } from "../../../common";
+import { HttpClient } from "../httpclient";
+export declare class HttpUWSAdapter extends HttpAdapter {
+    app: ReturnType<typeof import('uWebSockets.js').App>;
+    constructor(options: {
+        client: HttpClient;
+        debugger?: Logger;
+        logger: Logger;
+    });
+    listen(): void;
+    verifySignature(res: HttpResponse, req: HttpRequest): Promise<APIInteraction | undefined>;
+    onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
+    protected readJson<T extends Record<string, any>>(res: HttpResponse): Promise<T>;
+}

package/lib/client/http/adapters/uws.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpUWSAdapter = void 0;
+const v10_1 = require("discord-api-types/v10");
+const magic_bytes_js_1 = __importDefault(require("magic-bytes.js"));
+const _1 = require(".");
+const api_1 = require("../../../api");
+const utils_1 = require("../../../api/utils/utils");
+const oninteractioncreate_1 = require("../../oninteractioncreate");
+let UWS;
+let nacl;
+try {
+    UWS = require('uWebSockets.js');
+}
+catch {
+    // easter egg #1
+}
+try {
+    nacl = require('tweetnacl');
+}
+catch {
+    // I always cum
+}
+class HttpUWSAdapter extends _1.HttpAdapter {
+    app;
+    constructor(options) {
+        super();
+        this.client = options.client;
+        this.debugger = options.debugger;
+        this.logger = options.logger;
+        if (!UWS) {
+            throw new Error('No uws installed.');
+        }
+        if (!nacl) {
+            throw new Error('No tweetnacl installed.');
+        }
+    }
+    listen() {
+        this.app = UWS.App();
+        this.app.post('/interactions', (res, req) => {
+            return this.onPacket(res, req);
+        });
+        this.app.listen(this.port, () => {
+            this.logger.info(`Listening to port ${this.port}`);
+        });
+    }
+    async verifySignature(res, req) {
+        const timestamp = req.getHeader('x-signature-timestamp');
+        const ed25519 = req.getHeader('x-signature-ed25519');
+        const body = await this.readJson(res);
+        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 v10_1.InteractionType.Ping:
+                    this.debugger?.debug('Ping interaction received, responding.');
+                    res
+                        .writeHeader('Content-Type', 'application/json')
+                        .end(JSON.stringify({ type: v10_1.InteractionResponseType.Pong }));
+                    break;
+                default:
+                    await (0, oninteractioncreate_1.onInteractionCreate)(this.client, rawBody, -1, async ({ body, files }) => {
+                        res.cork(() => {
+                            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.default)(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';
+                            }
+                            for (const i in headers) {
+                                res.writeHeader(i, headers[i]);
+                            }
+                            return res.end(JSON.stringify(response));
+                        });
+                    });
+                    break;
+            }
+        }
+    }
+    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);
+        });
+    }
+}
+exports.HttpUWSAdapter = HttpUWSAdapter;

package/lib/client/http/httpclient.d.ts

@@ -0,0 +1,13 @@
+import type { DeepPartial } from '../../common';
+import type { BaseClientOptions, StartOptions } from '../base';
+import { BaseClient } from '../base';
+import { HttpAdapter } from './adapters';
+export declare class HttpClient extends BaseClient {
+    adapter: HttpAdapter;
+    constructor(options?: BaseClientOptions);
+    protected execute(options?: {
+        publicKey?: string;
+        port?: number;
+    }): Promise<any>;
+    start(options?: DeepPartial<Omit<StartOptions, 'connection'>>): Promise<any>;
+}

package/lib/client/http/httpclient.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const base_1 = require("../base");
+const adapters_1 = require("./adapters");
+class HttpClient extends base_1.BaseClient {
+    adapter;
+    constructor(options) {
+        super(options);
+        if (typeof Bun !== 'undefined') {
+            this.adapter = new adapters_1.HttpBunAdapter({
+                client: this,
+                logger: this.logger,
+                debugger: this.debugger
+            });
+        }
+        else {
+            this.adapter = new adapters_1.HttpUWSAdapter({
+                client: this,
+                logger: this.logger,
+                debugger: this.debugger
+            });
+        }
+    }
+    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.adapter.port = port;
+        this.adapter.publicKeyHex = Buffer.from(publicKey, 'hex');
+        return this.adapter.listen();
+    }
+    async start(options = {}) {
+        await super.start(options);
+        return this.execute(options.httpConnection);
+    }
+}
+exports.HttpClient = HttpClient;

package/lib/client/httpclient.js

@@ -112,41 +112,43 @@ class HttpClient extends base_1.BaseClient {
                     break;
                 default:
                     await (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';
+                        res.cork(() => {
+                            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);
                                     }
-                                    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));
                                 }
                             }
-                            if (body) {
-                                response.append('payload_json', JSON.stringify(body));
+                            else {
+                                response = body ?? {};
+                                headers['Content-Type'] = 'application/json';
+                            }
+                            for (const i in headers) {
+                                res.writeHeader(i, headers[i]);
                             }
-                        }
-                        else {
-                            response = body ?? {};
-                            headers['Content-Type'] = 'application/json';
-                        }
-                        for (const i in headers) {
-                            res.writeHeader(i, headers[i]);
-                        }
-                        return res.end(JSON.stringify(response));
+                            return res.end(JSON.stringify(response));
+                        });
                     });
                     break;
             }

package/lib/client/oninteractioncreate.js

@@ -11,7 +11,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
             {
                 const parentCommand = self.commands?.values.find(x => {
                     if (body.data.guild_id) {
-                        return x.guild_id?.includes(body.data.guild_id) && x.name === body.data.name;
+                        return x.guildId?.includes(body.data.guild_id) && x.name === body.data.name;
                     }
                     return x.name === body.data.name;
                 });
@@ -49,7 +49,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                         {
                             const command = self.commands?.values.find(x => {
                                 if (body.data.guild_id) {
-                                    return x.guild_id?.includes(body.data.guild_id) && x.name === body.data.name;
+                                    return x.guildId?.includes(body.data.guild_id) && x.name === body.data.name;
                                 }
                                 return x.name === body.data.name;
                             });
@@ -63,8 +63,8 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                             try {
                                 if (command.botPermissions && interaction.appPermissions) {
                                     const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values([command.botPermissions]));
-                                    if (permissions.length) {
-                                        return command.onPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
+                                    if (!interaction.appPermissions.has('Administrator') && permissions.length) {
+                                        return command.onBotPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
                                     }
                                 }
                                 const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
@@ -104,7 +104,7 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                         {
                             const parentCommand = self.commands?.values.find(x => {
                                 if (body.data.guild_id) {
-                                    return x.guild_id?.includes(body.data.guild_id) && x.name === body.data.name;
+                                    return x.guildId?.includes(body.data.guild_id) && x.name === body.data.name;
                                 }
                                 return x.name === body.data.name;
                             });
@@ -119,8 +119,8 @@ async function onInteractionCreate(self, body, shardId, __reply) {
                             try {
                                 if (command.botPermissions && interaction.appPermissions) {
                                     const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values([command.botPermissions]));
-                                    if (permissions.length) {
-                                        return command.onPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
+                                    if (!interaction.appPermissions.has('Administrator') && permissions.length) {
+                                        return command.onBotPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
                                     }
                                 }
                                 const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);

package/lib/client/onmessagecreate.js

@@ -55,7 +55,7 @@ async function onMessageCreate(self, rawMessage, shardId) {
         return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
     if (!command.contexts?.includes(__1.InteractionContextTypes.BOT_DM) && !message.guildId)
         return;
-    if (command.guild_id && !command.guild_id?.includes(message.guildId))
+    if (command.guildId && !command.guildId?.includes(message.guildId))
         return;
     const resolved = {
         channels: {},
@@ -72,14 +72,23 @@ async function onMessageCreate(self, rawMessage, shardId) {
     const extendContext = self.options?.context?.(message) ?? {};
     Object.assign(context, extendContext);
     try {
+        if (command.defaultMemberPermissions && message.guildId) {
+            const memberPermissions = await self.members.permissions(message.guildId, message.author.id);
+            const permissions = memberPermissions.missings(...memberPermissions.values([command.defaultMemberPermissions]));
+            if (!memberPermissions.has('Administrator') &&
+                permissions.length &&
+                (await message.guild()).ownerId !== message.author.id) {
+                return command.onPermissionsFail?.(context, memberPermissions.keys(permissions));
+            }
+        }
         if (command.botPermissions && message.guildId) {
             const meMember = await self.cache.members?.get(self.botId, message.guildId);
             if (!meMember)
                 return; //enable member cache and "Guilds" intent, lol
             const appPermissions = await meMember.fetchPermissions();
             const permissions = appPermissions.missings(...appPermissions.values([command.botPermissions]));
-            if (permissions.length) {
-                return command.onPermissionsFail?.(context, appPermissions.keys(permissions));
+            if (!appPermissions.has('Administrator') && permissions.length) {
+                return command.onBotPermissionsFail?.(context, appPermissions.keys(permissions));
             }
         }
         if (errors.length) {

package/lib/client/workerclient.js

@@ -115,7 +115,7 @@ class WorkerClient extends base_1.BaseClient {
                         this.logger.fatal('Worker trying send payload by non-existent shard');
                         return;
                     }
-                    await shard.send(0, {
+                    await shard.send(true, {
                         ...data,
                     });
                     this.postMessage({