@minesa-org/mini-interaction 0.4.3 → 0.4.5

package/dist/compat/MiniInteraction.d.ts

@@ -0,0 +1,99 @@
+import { type DiscordUser, type OAuthTokens } from "../oauth/DiscordOAuth.js";
+type TimeoutConfig = {
+    initialResponseTimeout?: number;
+    autoDeferSlowOperations?: boolean;
+    enableTimeoutWarnings?: boolean;
+    enableResponseDebugLogging?: boolean;
+};
+export type MiniInteractionOptions = {
+    commandsDirectory?: string;
+    componentsDirectory?: string;
+    utilsDirectory?: string;
+    timeoutConfig?: TimeoutConfig;
+    debug?: boolean;
+    cwd?: string;
+    publicKey?: string;
+    applicationId?: string;
+    token?: string;
+    guildId?: string;
+};
+type OAuthPageTemplate = {
+    htmlFile: string;
+};
+type OAuthCallbackTemplates = {
+    success: OAuthPageTemplate;
+    missingCode: OAuthPageTemplate;
+    oauthError: OAuthPageTemplate;
+    invalidState: OAuthPageTemplate;
+    serverError: OAuthPageTemplate;
+};
+type NodeRequest = {
+    body?: unknown;
+    rawBody?: string | Uint8Array | Buffer;
+    headers: Record<string, string | string[] | undefined> | {
+        get(name: string): string | null;
+    };
+    method?: string;
+    url?: string;
+    [Symbol.asyncIterator]?: () => AsyncIterableIterator<Uint8Array>;
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+};
+type NodeResponse = {
+    statusCode?: number;
+    setHeader?: (name: string, value: string) => void;
+    end: (body?: string) => void;
+    status?: (code: number) => NodeResponse;
+    json?: (body: unknown) => void;
+};
+export declare class MiniInteraction {
+    private readonly options;
+    private readonly projectRoot;
+    private readonly rest;
+    private readonly responseStates;
+    private loadedModulesPromise?;
+    constructor(options?: MiniInteractionOptions);
+    createNodeHandler(): (req: NodeRequest, res: NodeResponse) => Promise<void>;
+    registerCommands(tokenOverride?: string): Promise<unknown>;
+    discordOAuthVerificationPage(options: {
+        htmlFile: string;
+        scopes?: string[];
+    }): (req: NodeRequest, res: NodeResponse) => Promise<void>;
+    connectedOAuthPage(htmlFile: string): OAuthPageTemplate;
+    failedOAuthPage(htmlFile: string): OAuthPageTemplate;
+    discordOAuthCallback(options: {
+        templates: OAuthCallbackTemplates;
+        onAuthorize?: (payload: {
+            user: DiscordUser;
+            tokens: OAuthTokens;
+            req: NodeRequest;
+            res: NodeResponse;
+        }) => Promise<void> | void;
+    }): (req: NodeRequest, res: NodeResponse) => Promise<void>;
+    private dispatch;
+    private executeCommandHandler;
+    private executeComponentHandler;
+    private executeModalHandler;
+    private runWithResponseLifecycle;
+    private loadModules;
+    private discoverModules;
+    private loadDirectory;
+    private normalizeModuleExports;
+    private normalizeExportValue;
+    private walkFiles;
+    private isImportableModule;
+    private isInteractionCommand;
+    private getCommandName;
+    private resolveCommandPayload;
+    private isCustomIdHandler;
+    private looksLikeModalFile;
+    private readRawBody;
+    private getHeader;
+    private sendJson;
+    private loadHtmlFile;
+    private renderOAuthTemplate;
+    private sendHtml;
+    private getOAuthConfig;
+    private getCookie;
+}
+export declare const LegacyMiniInteractionAdapter: typeof MiniInteraction;
+export {};

package/dist/compat/MiniInteraction.js

@@ -0,0 +1,467 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { ApplicationCommandType, InteractionResponseType, InteractionType, } from "discord-api-types/v10";
+import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
+import { createAppCommandInteraction, createMessageContextMenuInteraction, createUserContextMenuInteraction, } from "../utils/ContextMenuInteraction.js";
+import { createMessageComponentInteraction } from "../utils/MessageComponentInteraction.js";
+import { createModalSubmitInteraction } from "../utils/ModalSubmitInteraction.js";
+import { DiscordRestClient } from "../core/http/DiscordRestClient.js";
+import { verifyAndParseInteraction } from "../core/interactions/InteractionVerifier.js";
+import { generateOAuthUrl, getDiscordUser, getOAuthTokens, } from "../oauth/DiscordOAuth.js";
+export class MiniInteraction {
+    options;
+    projectRoot;
+    rest;
+    responseStates = new Map();
+    loadedModulesPromise;
+    constructor(options = {}) {
+        this.options = options;
+        this.projectRoot = path.resolve(options.cwd ?? process.cwd());
+        const applicationId = options.applicationId ??
+            process.env.DISCORD_APPLICATION_ID ??
+            process.env.DISCORD_APP_ID;
+        const token = options.token ??
+            process.env.DISCORD_BOT_TOKEN ??
+            process.env.DISCORD_TOKEN;
+        if (!applicationId || !token) {
+            throw new Error("[MiniInteraction] Missing Discord REST credentials. Set applicationId/token or DISCORD_APPLICATION_ID + DISCORD_BOT_TOKEN.");
+        }
+        this.rest = new DiscordRestClient({ applicationId, token });
+    }
+    createNodeHandler() {
+        return async (req, res) => {
+            try {
+                const body = await this.readRawBody(req);
+                const signature = this.getHeader(req.headers, "x-signature-ed25519");
+                const timestamp = this.getHeader(req.headers, "x-signature-timestamp");
+                const publicKey = this.options.publicKey ?? process.env.DISCORD_PUBLIC_KEY;
+                if (!publicKey) {
+                    this.sendJson(res, 500, {
+                        error: "[MiniInteraction] Missing DISCORD_PUBLIC_KEY.",
+                    });
+                    return;
+                }
+                if (!signature || !timestamp) {
+                    this.sendJson(res, 401, {
+                        error: "[MiniInteraction] Missing Discord signature headers.",
+                    });
+                    return;
+                }
+                const interaction = await verifyAndParseInteraction({
+                    body,
+                    signature,
+                    timestamp,
+                    publicKey,
+                });
+                if (interaction.type === InteractionType.Ping) {
+                    this.sendJson(res, 200, { type: InteractionResponseType.Pong });
+                    return;
+                }
+                const response = await this.dispatch(interaction);
+                this.sendJson(res, 200, response ?? {
+                    type: InteractionResponseType.DeferredChannelMessageWithSource,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "[MiniInteraction] Unknown error";
+                if (this.options.debug) {
+                    console.error("[MiniInteraction] createNodeHandler failed", error);
+                }
+                this.sendJson(res, 500, { error: message });
+            }
+        };
+    }
+    async registerCommands(tokenOverride) {
+        const modules = await this.loadModules();
+        const payload = modules.commands.map((command) => this.resolveCommandPayload(command));
+        const applicationId = this.options.applicationId ??
+            process.env.DISCORD_APPLICATION_ID ??
+            process.env.DISCORD_APP_ID;
+        if (!applicationId) {
+            throw new Error("[MiniInteraction] Missing applicationId for command registration.");
+        }
+        const token = tokenOverride ??
+            this.options.token ??
+            process.env.DISCORD_BOT_TOKEN ??
+            process.env.DISCORD_TOKEN;
+        if (!token) {
+            throw new Error("[MiniInteraction] Missing bot token for command registration.");
+        }
+        const rest = new DiscordRestClient({ applicationId, token });
+        const guildId = this.options.guildId ?? process.env.DISCORD_GUILD_ID;
+        const route = guildId
+            ? `/applications/${applicationId}/guilds/${guildId}/commands`
+            : `/applications/${applicationId}/commands`;
+        if (this.options.debug) {
+            console.debug(`[MiniInteraction] Registering ${payload.length} command(s) on ${guildId ? `guild ${guildId}` : "global"} scope.`);
+        }
+        return rest.request(route, {
+            method: "PUT",
+            body: JSON.stringify(payload),
+        });
+    }
+    discordOAuthVerificationPage(options) {
+        return async (_req, res) => {
+            const oauthConfig = this.getOAuthConfig();
+            const { url, state } = generateOAuthUrl(oauthConfig, options.scopes ?? [
+                "applications.commands",
+                "identify",
+                "guilds",
+                "role_connections.write",
+            ]);
+            const html = await this.loadHtmlFile(options.htmlFile);
+            const rendered = html.replaceAll("{{OAUTH_URL_RAW}}", url);
+            res.setHeader?.("Set-Cookie", `mini_oauth_state=${encodeURIComponent(state)}; Path=/; HttpOnly; SameSite=Lax; Max-Age=900`);
+            this.sendHtml(res, 200, rendered);
+        };
+    }
+    connectedOAuthPage(htmlFile) {
+        return { htmlFile };
+    }
+    failedOAuthPage(htmlFile) {
+        return { htmlFile };
+    }
+    discordOAuthCallback(options) {
+        return async (req, res) => {
+            try {
+                const requestUrl = new URL(req.url ?? "/", process.env.DISCORD_REDIRECT_URI ?? "http://localhost");
+                const error = requestUrl.searchParams.get("error");
+                const code = requestUrl.searchParams.get("code");
+                const state = requestUrl.searchParams.get("state");
+                const cookieState = this.getCookie(req, "mini_oauth_state");
+                if (error) {
+                    await this.renderOAuthTemplate(res, options.templates.oauthError);
+                    return;
+                }
+                if (!code) {
+                    await this.renderOAuthTemplate(res, options.templates.missingCode);
+                    return;
+                }
+                if (state && cookieState && state !== cookieState) {
+                    await this.renderOAuthTemplate(res, options.templates.invalidState);
+                    return;
+                }
+                const tokens = await getOAuthTokens(code, this.getOAuthConfig());
+                const user = await getDiscordUser(tokens.access_token);
+                await options.onAuthorize?.({ user, tokens, req, res });
+                res.setHeader?.("Set-Cookie", "mini_oauth_state=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0");
+                await this.renderOAuthTemplate(res, options.templates.success);
+            }
+            catch (error) {
+                if (this.options.debug) {
+                    console.error("[MiniInteraction] discordOAuthCallback failed", error);
+                }
+                await this.renderOAuthTemplate(res, options.templates.serverError);
+            }
+        };
+    }
+    async dispatch(interaction) {
+        const modules = await this.loadModules();
+        if (interaction.type === InteractionType.ApplicationCommand) {
+            const command = modules.commands.find((candidate) => this.getCommandName(candidate) === interaction.data.name);
+            if (!command)
+                return undefined;
+            return this.executeCommandHandler(command.handler, interaction);
+        }
+        if (interaction.type === InteractionType.MessageComponent) {
+            const component = modules.components.find((candidate) => candidate.customId === interaction.data.custom_id);
+            if (!component)
+                return undefined;
+            return this.executeComponentHandler(component.handler, interaction);
+        }
+        if (interaction.type === InteractionType.ModalSubmit) {
+            const modal = modules.modals.find((candidate) => candidate.customId === interaction.data.custom_id);
+            if (!modal)
+                return undefined;
+            return this.executeModalHandler(modal.handler, interaction);
+        }
+        return undefined;
+    }
+    async executeCommandHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => {
+            switch (interaction.data.type) {
+                case ApplicationCommandType.ChatInput:
+                    return handler(createCommandInteraction(interaction, helpers));
+                case ApplicationCommandType.User:
+                    return handler(createUserContextMenuInteraction(interaction, helpers));
+                case ApplicationCommandType.Message:
+                    return handler(createMessageContextMenuInteraction(interaction, helpers));
+                default:
+                    if (interaction.data.type === ApplicationCommandType.PrimaryEntryPoint) {
+                        return handler(createAppCommandInteraction(interaction, helpers));
+                    }
+                    throw new Error(`[MiniInteraction] Unsupported application command type: ${String(interaction.data.type)}`);
+            }
+        });
+    }
+    async executeComponentHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)));
+    }
+    async executeModalHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)));
+    }
+    async runWithResponseLifecycle(interaction, executor) {
+        let ackResponse;
+        const helpers = {
+            canRespond: (interactionId) => (this.responseStates.get(interactionId) ?? "pending") === "pending",
+            trackResponse: (interactionId, _token, state) => {
+                this.responseStates.set(interactionId, state);
+            },
+            onAck: (response) => {
+                ackResponse = response;
+            },
+            sendFollowUp: async (token, response, messageId) => {
+                const responseData = "data" in response ? response.data ?? {} : {};
+                if (messageId === "@original") {
+                    await this.rest.editOriginal(token, responseData);
+                    return;
+                }
+                await this.rest.createFollowup(token, responseData);
+            },
+        };
+        const autoDeferMs = Math.min(2500, this.options.timeoutConfig?.initialResponseTimeout ?? 2500);
+        const autoDeferTimer = this.options.timeoutConfig?.autoDeferSlowOperations === true
+            ? setTimeout(() => {
+                if (!helpers.canRespond(interaction.id))
+                    return;
+                if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
+                    console.warn(`[MiniInteraction] Auto-deferred interaction ${interaction.id} after ${autoDeferMs}ms.`);
+                }
+                ackResponse = {
+                    type: InteractionResponseType.DeferredChannelMessageWithSource,
+                };
+                helpers.trackResponse(interaction.id, interaction.token, "deferred");
+            }, autoDeferMs)
+            : undefined;
+        const timeoutWarningMs = this.options.timeoutConfig?.initialResponseTimeout;
+        const timeoutWarningTimer = this.options.timeoutConfig?.enableTimeoutWarnings && timeoutWarningMs
+            ? setTimeout(() => {
+                if (this.responseStates.get(interaction.id))
+                    return;
+                console.warn(`[MiniInteraction] Interaction ${interaction.id} exceeded ${timeoutWarningMs}ms without a response.`);
+            }, timeoutWarningMs)
+            : undefined;
+        try {
+            const result = await executor(helpers);
+            if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
+                console.debug(`[MiniInteraction] Interaction ${interaction.id} completed with ${result ? "explicit" : "fallback"} response.`);
+            }
+            return result ?? ackResponse;
+        }
+        finally {
+            if (autoDeferTimer)
+                clearTimeout(autoDeferTimer);
+            if (timeoutWarningTimer)
+                clearTimeout(timeoutWarningTimer);
+        }
+    }
+    async loadModules() {
+        if (!this.loadedModulesPromise) {
+            this.loadedModulesPromise = this.discoverModules();
+        }
+        return this.loadedModulesPromise;
+    }
+    async discoverModules() {
+        const commands = this.options.commandsDirectory
+            ? await this.loadDirectory(this.options.commandsDirectory)
+            : [];
+        const components = this.options.componentsDirectory
+            ? await this.loadDirectory(this.options.componentsDirectory)
+            : [];
+        const loaded = {
+            commands: [],
+            components: [],
+            modals: [],
+        };
+        for (const { filePath, value } of commands) {
+            if (this.isInteractionCommand(value)) {
+                loaded.commands.push(value);
+            }
+            else if (this.options.debug) {
+                console.warn(`[MiniInteraction] Ignored non-command module: ${filePath}`);
+            }
+        }
+        for (const { filePath, value } of components) {
+            if (!this.isCustomIdHandler(value)) {
+                if (this.options.debug) {
+                    console.warn(`[MiniInteraction] Ignored non-component module: ${filePath}`);
+                }
+                continue;
+            }
+            if (this.looksLikeModalFile(filePath)) {
+                loaded.modals.push(value);
+            }
+            else {
+                loaded.components.push(value);
+            }
+        }
+        return loaded;
+    }
+    async loadDirectory(directory) {
+        const absoluteDirectory = path.resolve(this.projectRoot, directory);
+        const files = await this.walkFiles(absoluteDirectory);
+        const loaded = await Promise.all(files
+            .filter((filePath) => this.isImportableModule(filePath))
+            .map(async (filePath) => ({
+            filePath,
+            values: this.normalizeModuleExports(await import(pathToFileURL(filePath).href)),
+        })));
+        return loaded.flatMap(({ filePath, values }) => values.map((value) => ({ filePath, value })));
+    }
+    normalizeModuleExports(moduleValue) {
+        const values = [];
+        if ("default" in moduleValue) {
+            values.push(...this.normalizeExportValue(moduleValue.default));
+        }
+        for (const [key, value] of Object.entries(moduleValue)) {
+            if (key === "default")
+                continue;
+            values.push(...this.normalizeExportValue(value));
+        }
+        return values;
+    }
+    normalizeExportValue(value) {
+        if (Array.isArray(value))
+            return value;
+        return [value];
+    }
+    async walkFiles(directory) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const results = await Promise.all(entries.map(async (entry) => {
+            const resolvedPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                return this.walkFiles(resolvedPath);
+            }
+            return [resolvedPath];
+        }));
+        return results.flat();
+    }
+    isImportableModule(filePath) {
+        if (filePath.endsWith(".d.ts"))
+            return false;
+        return /\.(ts|mts|js|mjs|cjs)$/i.test(filePath);
+    }
+    isInteractionCommand(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "data" in value &&
+            "handler" in value &&
+            typeof value.handler === "function");
+    }
+    getCommandName(command) {
+        const data = command.data;
+        if (typeof data.toJSON === "function") {
+            return data.toJSON().name;
+        }
+        return data.name;
+    }
+    resolveCommandPayload(command) {
+        const data = command.data;
+        if (typeof data.toJSON === "function") {
+            return data.toJSON();
+        }
+        return command.data;
+    }
+    isCustomIdHandler(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "customId" in value &&
+            "handler" in value &&
+            typeof value.customId === "string" &&
+            typeof value.handler === "function");
+    }
+    looksLikeModalFile(filePath) {
+        const normalized = filePath.toLowerCase();
+        return (normalized.includes(`${path.sep}modals${path.sep}`) ||
+            normalized.endsWith(".modal.ts") ||
+            normalized.endsWith(".modal.js") ||
+            normalized.includes("_modal.") ||
+            normalized.includes("-modal."));
+    }
+    async readRawBody(req) {
+        if (typeof req.rawBody === "string")
+            return req.rawBody;
+        if (req.rawBody instanceof Uint8Array) {
+            return Buffer.from(req.rawBody).toString("utf8");
+        }
+        if (typeof req.body === "string")
+            return req.body;
+        if (req.body instanceof Uint8Array) {
+            return Buffer.from(req.body).toString("utf8");
+        }
+        if (req.body && typeof req.body === "object") {
+            return JSON.stringify(req.body);
+        }
+        if (typeof req[Symbol.asyncIterator] === "function") {
+            const chunks = [];
+            for await (const chunk of req) {
+                chunks.push(Buffer.from(chunk));
+            }
+            return Buffer.concat(chunks).toString("utf8");
+        }
+        return "";
+    }
+    getHeader(headers, name) {
+        if (typeof headers.get === "function") {
+            return headers.get(name) ?? undefined;
+        }
+        const recordHeaders = headers;
+        const direct = recordHeaders[name] ??
+            recordHeaders[name.toLowerCase()] ??
+            recordHeaders[name.toUpperCase()];
+        if (Array.isArray(direct))
+            return direct[0];
+        return direct;
+    }
+    sendJson(res, statusCode, body) {
+        if (typeof res.status === "function" && typeof res.json === "function") {
+            const response = res.status(statusCode);
+            response.json?.(body);
+            return;
+        }
+        res.statusCode = statusCode;
+        res.setHeader?.("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify(body));
+    }
+    async loadHtmlFile(htmlFile) {
+        const absolutePath = path.resolve(this.projectRoot, htmlFile);
+        return readFile(absolutePath, "utf8");
+    }
+    async renderOAuthTemplate(res, template) {
+        const html = await this.loadHtmlFile(template.htmlFile);
+        this.sendHtml(res, 200, html);
+    }
+    sendHtml(res, statusCode, html) {
+        if (typeof res.status === "function" && typeof res.end === "function") {
+            res.status(statusCode);
+        }
+        res.statusCode = statusCode;
+        res.setHeader?.("Content-Type", "text/html; charset=utf-8");
+        res.end(html);
+    }
+    getOAuthConfig() {
+        const appId = this.options.applicationId ??
+            process.env.DISCORD_APPLICATION_ID ??
+            process.env.DISCORD_APP_ID;
+        const appSecret = process.env.DISCORD_CLIENT_SECRET ?? process.env.DISCORD_APPLICATION_SECRET;
+        const redirectUri = process.env.DISCORD_REDIRECT_URI;
+        if (!appId || !appSecret || !redirectUri) {
+            throw new Error("[MiniInteraction] Missing OAuth config. Expected DISCORD_APPLICATION_ID, DISCORD_CLIENT_SECRET and DISCORD_REDIRECT_URI.");
+        }
+        return { appId, appSecret, redirectUri };
+    }
+    getCookie(req, name) {
+        const cookieHeader = this.getHeader(req.headers, "cookie");
+        if (!cookieHeader)
+            return undefined;
+        for (const rawPart of cookieHeader.split(";")) {
+            const [rawKey, ...rawValue] = rawPart.trim().split("=");
+            if (rawKey === name) {
+                return decodeURIComponent(rawValue.join("="));
+            }
+        }
+        return undefined;
+    }
+}
+export const LegacyMiniInteractionAdapter = MiniInteraction;

package/dist/index.d.ts

@@ -30,6 +30,8 @@ export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export type { InteractionContextOptions } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";
+export { MiniInteraction, LegacyMiniInteractionAdapter, } from "./compat/MiniInteraction.js";
+export type { MiniInteractionOptions } from "./compat/MiniInteraction.js";
 export type { APIRadioComponent, APIRadioOption } from "./types/radio.js";
 export { RADIO_COMPONENT_TYPE } from "./types/radio.js";
 export type { APICheckboxComponent, APICheckboxOption } from "./types/checkbox.js";

package/dist/index.js

@@ -23,6 +23,7 @@ export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";
+export { MiniInteraction, LegacyMiniInteractionAdapter, } from "./compat/MiniInteraction.js";
 export { RADIO_COMPONENT_TYPE } from "./types/radio.js";
 export { CHECKBOX_COMPONENT_TYPE } from "./types/checkbox.js";
 export { ValidationError } from "./types/validation.js";

package/dist/types/ComponentTypes.d.ts

@@ -4,7 +4,7 @@ import type { APICheckboxComponent } from "./checkbox.js";
 /** Defines a component structure for use in ActionRow builders. */
 export type ActionRowComponent = APIComponentInActionRow | APIRadioComponent | APICheckboxComponent;
 /** Defines a message component structure for use in message builders. */
-export type MessageActionRowComponent = APIComponentInMessageActionRow | APIRadioComponent | APICheckboxComponent;
+export type MessageActionRowComponent = APIComponentInMessageActionRow;
 /** Structure for an action row containing mini-interaction components. */
 export interface MiniActionRow<T extends ActionRowComponent = ActionRowComponent> {
     type: 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minesa-org/mini-interaction",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
   "type": "module",
   "main": "dist/index.js",