@minesa-org/mini-interaction 0.4.4 → 0.4.6

package/dist/compat/MiniInteraction.d.ts

@@ -1,3 +1,4 @@
+import { type DiscordUser, type OAuthTokens } from "../oauth/DiscordOAuth.js";
 type TimeoutConfig = {
     initialResponseTimeout?: number;
     autoDeferSlowOperations?: boolean;
@@ -14,6 +15,17 @@ export type MiniInteractionOptions = {
     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;
@@ -22,6 +34,7 @@ type NodeRequest = {
         get(name: string): string | null;
     };
     method?: string;
+    url?: string;
     [Symbol.asyncIterator]?: () => AsyncIterableIterator<Uint8Array>;
     on?: (event: string, listener: (...args: unknown[]) => void) => void;
 };
@@ -40,6 +53,22 @@ export declare class MiniInteraction {
     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;
@@ -54,11 +83,17 @@ export declare class MiniInteraction {
     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

@@ -1,4 +1,4 @@
-import { readdir } from "node:fs/promises";
+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";
@@ -8,6 +8,7 @@ import { createMessageComponentInteraction } from "../utils/MessageComponentInte
 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;
@@ -71,6 +72,90 @@ export class MiniInteraction {
             }
         };
     }
+    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) {
@@ -118,8 +203,13 @@ export class MiniInteraction {
     }
     async runWithResponseLifecycle(interaction, executor) {
         let ackResponse;
+        let initialResponseCommitted = false;
         const helpers = {
-            canRespond: (interactionId) => (this.responseStates.get(interactionId) ?? "pending") === "pending",
+            // Legacy helper contracts use canRespond for both initial acknowledgements
+            // and later editReply/followUp calls. The compat layer does not currently
+            // track Discord token expiry, so we only block on real expiry outside of
+            // this helper and allow the wrapped interaction methods to complete.
+            canRespond: (_interactionId) => true,
             trackResponse: (interactionId, _token, state) => {
                 this.responseStates.set(interactionId, state);
             },
@@ -127,6 +217,14 @@ export class MiniInteraction {
                 ackResponse = response;
             },
             sendFollowUp: async (token, response, messageId) => {
+                // If the initial interaction response has not been sent yet, collapse the
+                // deferred/edit flow back into a single immediate response instead of
+                // calling the webhook endpoints early.
+                if (!initialResponseCommitted) {
+                    ackResponse = response;
+                    this.responseStates.set(interaction.id, "responded");
+                    return;
+                }
                 const responseData = "data" in response ? response.data ?? {} : {};
                 if (messageId === "@original") {
                     await this.rest.editOriginal(token, responseData);
@@ -162,6 +260,7 @@ export class MiniInteraction {
             if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
                 console.debug(`[MiniInteraction] Interaction ${interaction.id} completed with ${result ? "explicit" : "fallback"} response.`);
             }
+            initialResponseCommitted = true;
             return result ?? ackResponse;
         }
         finally {
@@ -271,6 +370,13 @@ export class MiniInteraction {
         }
         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 &&
@@ -332,5 +438,44 @@ export class MiniInteraction {
         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/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.4",
+  "version": "0.4.6",
   "description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
   "type": "module",
   "main": "dist/index.js",