@helyx/bot 0.4.37 → 0.4.38

package/dist/support-module.js

@@ -22,61 +22,62 @@ export function createSupportModule(transport) {
             framework: "^0.1.0",
             dependencies: [],
             permissions: [],
-            contributions: { commands: ["bug"], events: [] },
+            contributions: { commands: ["helyx.bug"], events: [] },
         },
-        interactions: {
-            commands: [
-                {
-                    name: "bug",
-                    description: "Report a Helyx bug to the support team",
-                    acknowledgement: "immediate-modal",
-                    registration: "global",
-                    contexts: ["guild"],
-                    integrationTypes: ["guild_install"],
-                    async execute(context) {
-                        await context.showModal({
-                            customId: MODAL_ID,
-                            title: "Report a Helyx bug",
-                            fields: [
-                                {
-                                    customId: MODULE_FIELD_ID,
-                                    label: "Module or area",
-                                    style: "short",
-                                    required: true,
-                                    minLength: 1,
-                                    maxLength: 100,
-                                },
-                                {
-                                    customId: SUMMARY_FIELD_ID,
-                                    label: "Summary",
-                                    style: "short",
-                                    required: true,
-                                    minLength: 10,
-                                    maxLength: 200,
-                                },
-                                {
-                                    customId: HAPPENED_FIELD_ID,
-                                    label: "What happened?",
-                                    style: "paragraph",
-                                    required: true,
-                                    minLength: 10,
-                                    maxLength: 1_000,
-                                },
-                                {
-                                    customId: DETAIL_FIELD_ID,
-                                    label: "Steps to reproduce or extra detail",
-                                    style: "paragraph",
-                                    required: false,
-                                    maxLength: 1_000,
-                                },
-                            ],
-                        });
-                    },
+        sharedCommands: [
+            {
+                family: "helyx",
+                path: "bug",
+                permissionId: "bug",
+                description: "Report a Helyx bug to the support team",
+                acknowledgement: "immediate-modal",
+                authorization: "public",
+                async execute(context) {
+                    await context.showModal({
+                        customId: MODAL_ID,
+                        title: "Report a Helyx bug",
+                        fields: [
+                            {
+                                customId: MODULE_FIELD_ID,
+                                label: "Module or area",
+                                style: "short",
+                                required: true,
+                                minLength: 1,
+                                maxLength: 100,
+                            },
+                            {
+                                customId: SUMMARY_FIELD_ID,
+                                label: "Summary",
+                                style: "short",
+                                required: true,
+                                minLength: 10,
+                                maxLength: 200,
+                            },
+                            {
+                                customId: HAPPENED_FIELD_ID,
+                                label: "What happened?",
+                                style: "paragraph",
+                                required: true,
+                                minLength: 10,
+                                maxLength: 1_000,
+                            },
+                            {
+                                customId: DETAIL_FIELD_ID,
+                                label: "Steps to reproduce or extra detail",
+                                style: "paragraph",
+                                required: false,
+                                maxLength: 1_000,
+                            },
+                        ],
+                    });
                 },
-            ],
+            },
+        ],
+        interactions: {
             modals: [
                 {
                     customId: MODAL_ID,
+                    acknowledgement: "deferred-ephemeral",
                     async execute(context) {
                         if (!context.serverId) {
                             await context.reply(notSavedResponse());
@@ -117,7 +118,6 @@ export function createSupportModule(transport) {
                             });
                             return;
                         }
-                        await context.deferReply?.(true);
                         const detail = context.getField(DETAIL_FIELD_ID).trim();
                         try {
                             const result = await transport.submitBug({

package/dist/trivia-data-provider.d.ts

@@ -0,0 +1,26 @@
+import type { DatabasePool } from "@helyx/database";
+import { type TriviaCategory } from "@helyx/sdk";
+export interface TriviaCategoryData {
+    category: TriviaCategory;
+    easy: number;
+    medium: number;
+    hard: number;
+}
+export interface TriviaDataSummary {
+    uniqueQuestions: number;
+    types: {
+        multipleChoice: number;
+        guess: number;
+        trueFalse: number;
+    };
+    categories: readonly TriviaCategoryData[];
+}
+export interface TriviaDataProvider {
+    getSummary(): Promise<TriviaDataSummary>;
+}
+export declare class PostgresTriviaDataProvider implements TriviaDataProvider {
+    #private;
+    constructor(database: DatabasePool);
+    getSummary(): Promise<TriviaDataSummary>;
+}
+//# sourceMappingURL=trivia-data-provider.d.ts.map

package/dist/trivia-data-provider.js

@@ -0,0 +1,51 @@
+import { TRIVIA_CATEGORIES, } from "@helyx/sdk";
+const difficulties = ["easy", "medium", "hard"];
+export class PostgresTriviaDataProvider {
+    #database;
+    constructor(database) {
+        this.#database = database;
+    }
+    async getSummary() {
+        const [uniqueResult, countResult] = await Promise.all([
+            this.#database.query(`SELECT count(DISTINCT lower(btrim(question ->> 'text'))) AS unique_questions
+           FROM trivia_questions`),
+            this.#database.query(`SELECT category, difficulty, type, count(*) AS questions
+           FROM trivia_questions
+          GROUP BY category, difficulty, type
+          ORDER BY category, difficulty, type`),
+        ]);
+        const counts = new Map();
+        for (const row of countResult.rows) {
+            if (!TRIVIA_CATEGORIES.includes(row.category) ||
+                !difficulties.includes(row.difficulty) ||
+                !["text_choice", "text_input", "true_false"].includes(row.type))
+                throw new Error("Trivia data contains an unsupported group");
+            counts.set(`${row.category}:${row.difficulty}`, (counts.get(`${row.category}:${row.difficulty}`) ?? 0) +
+                nonNegativeInteger(row.questions, "Trivia question count"));
+        }
+        const typeCount = (type) => countResult.rows
+            .filter((row) => row.type === type)
+            .reduce((total, row) => total + nonNegativeInteger(row.questions, "Trivia type count"), 0);
+        return {
+            uniqueQuestions: nonNegativeInteger(uniqueResult.rows[0]?.unique_questions, "Unique trivia question count"),
+            types: {
+                multipleChoice: typeCount("text_choice"),
+                guess: typeCount("text_input"),
+                trueFalse: typeCount("true_false"),
+            },
+            categories: TRIVIA_CATEGORIES.map((category) => ({
+                category,
+                easy: counts.get(`${category}:easy`) ?? 0,
+                medium: counts.get(`${category}:medium`) ?? 0,
+                hard: counts.get(`${category}:hard`) ?? 0,
+            })),
+        };
+    }
+}
+function nonNegativeInteger(value, label) {
+    const parsed = typeof value === "string" ? Number(value) : value;
+    if (typeof parsed !== "number" || !Number.isSafeInteger(parsed) || parsed < 0)
+        throw new Error(`${label} is invalid`);
+    return parsed;
+}
+//# sourceMappingURL=trivia-data-provider.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/bot",
-  "version": "0.4.37",
+  "version": "0.4.38",
   "description": "Production Discord runtime for the modular Helyx platform.",
   "keywords": [
     "helyx",
@@ -51,17 +51,18 @@
     "@helyx/config": ">=0.5.0 <0.6.0",
     "@helyx/control-protocol": ">=0.4.0 <0.5.0",
     "@helyx/core": ">=0.1.0 <0.2.0",
-    "@helyx/database": ">=0.8.0 <0.9.0",
+    "@helyx/database": ">=0.8.6 <0.9.0",
     "@helyx/framework": ">=0.1.0 <0.2.0",
     "@helyx/module-manifest": ">=0.7.0 <0.8.0",
-    "@helyx/platform": ">=0.6.0 <0.7.0",
-    "@helyx/sdk": ">=0.8.0 <0.9.0",
+    "@helyx/platform": ">=0.6.2 <0.7.0",
+    "@helyx/sdk": ">=0.8.4 <0.9.0",
     "@helyx/status-client": ">=0.1.0 <0.2.0",
     "@helyx/verification-contracts": ">=0.3.0 <0.4.0",
     "discord.js": "14.27.0",
     "fastify": "5.10.0",
     "pino": "10.3.1",
     "redis": "6.1.0",
+    "undici": "6.28.0",
     "ws": "8.21.1",
     "zod": "4.4.3"
   },

package/dist/oauth-module.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=oauth-module.test.d.ts.map

package/dist/oauth-module.test.js

@@ -1,172 +0,0 @@
-import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
-import { describe, expect, it, vi } from "vitest";
-import { createOAuthModule } from "./oauth-module.js";
-describe("global OAuth command", () => {
-    it("is global, guild-scoped and available without management permissions", () => {
-        const module = createOAuthModule();
-        const command = module.interactions?.commands?.[0];
-        const revoke = command?.subcommands?.[0];
-        expect(command).toMatchObject({
-            name: "oauth",
-            registration: "global",
-            contexts: ["guild"],
-            integrationTypes: ["guild_install"],
-        });
-        expect(revoke).toMatchObject({
-            name: "revoke",
-            rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
-        });
-        expect(module.manifest.permissions).toEqual([]);
-        expect(module.defaultPermissions?.commands["oauth.revoke"]).toMatchObject({
-            everyone: true,
-            requiredPermissions: [],
-        });
-    });
-    it("does not open a modal when the acting user has no connections", async () => {
-        const oauth = oauthService({ connections: [] });
-        const showModal = vi.fn();
-        const replies = [];
-        const command = createOAuthModule().interactions?.commands?.[0]?.subcommands?.[0];
-        await command?.execute(commandContext(oauth, {
-            showModal,
-            reply: (response) => {
-                replies.push(response);
-                return Promise.resolve();
-            },
-        }));
-        expect(showModal).not.toHaveBeenCalled();
-        expect(replies).toEqual([expect.objectContaining({ ephemeral: true })]);
-        expect(replies[0]?.componentsV2?.text?.[0]?.content).toContain("do not have any OAuth services");
-    });
-    it("uses opaque selections and requires explicit removal confirmation", async () => {
-        const oauth = oauthService({
-            connections: [
-                {
-                    selectionRef: "opaque-selection-reference-123",
-                    provider: "youtube",
-                    displayName: "Example creator",
-                    connectedAt: new Date().toISOString(),
-                },
-            ],
-        });
-        const showModal = vi.fn();
-        const command = createOAuthModule().interactions?.commands?.[0]?.subcommands?.[0];
-        await command?.execute(commandContext(oauth, { showModal }));
-        const modal = showModal.mock.calls[0]?.[0];
-        expect(modal?.title).toBe("Revoke OAuth access");
-        const service = modal?.items?.find((item) => "customId" in item && item.customId.endsWith("service"));
-        const confirmation = modal?.items?.find((item) => "customId" in item && item.customId.endsWith("confirm"));
-        expect(service).toMatchObject({
-            type: "string-select",
-            required: true,
-            options: [
-                expect.objectContaining({ value: "opaque-selection-reference-123" }),
-            ],
-        });
-        expect(confirmation).toMatchObject({
-            type: "string-select",
-            required: true,
-            options: [expect.objectContaining({ value: "remove_access" })],
-        });
-    });
-    it("revokes only for the acting user and returns an ephemeral advisory", async () => {
-        const revoke = vi.fn().mockResolvedValue({
-            provider: "twitch",
-            outcome: "completed",
-            providerRevocation: "failed",
-        });
-        const oauth = oauthService({ connections: [], revoke });
-        const replies = [];
-        const modal = createOAuthModule().interactions?.modals?.[0];
-        await modal?.execute(modalContext(oauth, {
-            reply: (response) => {
-                replies.push(response);
-                return Promise.resolve();
-            },
-        }));
-        expect(revoke).toHaveBeenCalledWith({
-            discordUserId: "12345678901234567",
-            selectionRef: "opaque-selection-reference-123",
-            confirmation: "remove_access",
-            comment: "No longer needed",
-            correlationId: "interaction-1",
-        });
-        expect(replies[0]).toMatchObject({ ephemeral: true });
-        expect(replies[0]?.componentsV2?.text?.[0]?.content).toContain("connected-app settings");
-    });
-});
-function oauthService(input) {
-    return {
-        connectionStatus: () => Promise.resolve([]),
-        listConnections: () => Promise.resolve(input.connections),
-        createAuthorization: () => Promise.resolve({
-            authorizationUrl: "https://example.com",
-            expiresAt: "",
-        }),
-        verifyEligibility: () => Promise.resolve({
-            provider: "youtube",
-            status: "unknown",
-            connected: false,
-            checkedAt: new Date().toISOString(),
-        }),
-        revoke: input.revoke ??
-            (() => Promise.resolve({
-                provider: "youtube",
-                outcome: "completed",
-                providerRevocation: "completed",
-            })),
-    };
-}
-function services(oauth) {
-    return {
-        has: (name) => name === HELYX_SERVICE_NAMES.oauth,
-        get: (name) => {
-            if (name !== HELYX_SERVICE_NAMES.oauth)
-                throw new Error("unknown service");
-            return oauth;
-        },
-    };
-}
-function commandContext(oauth, overrides = {}) {
-    return {
-        ...interactionBase(oauth),
-        showModal: () => Promise.resolve(),
-        getStringOption: () => null,
-        getBooleanOption: () => null,
-        getUserOption: () => null,
-        getChannelOption: () => null,
-        getRoleOption: () => null,
-        ...overrides,
-    };
-}
-function modalContext(oauth, overrides = {}) {
-    return {
-        ...interactionBase(oauth),
-        getField: (customId) => customId.endsWith("comment") ? "No longer needed" : "",
-        getStringSelectValues: (customId) => customId.endsWith("service")
-            ? ["opaque-selection-reference-123"]
-            : ["remove_access"],
-        getSelectedUserIds: () => [],
-        getSelectedRoleIds: () => [],
-        getSelectedMentionables: () => ({ userIds: [], roleIds: [] }),
-        getSelectedChannelIds: () => [],
-        ...overrides,
-    };
-}
-function interactionBase(oauth) {
-    return {
-        interactionId: "interaction-1",
-        userId: "12345678901234567",
-        userDisplayName: "Member",
-        userRoleIds: [],
-        isAdministrator: false,
-        serverId: "12345678901234568",
-        services: services(oauth),
-        reply: () => Promise.resolve(),
-        sendToChannel: () => Promise.resolve({ messageId: "message-1" }),
-        deleteChannelMessage: () => Promise.resolve(),
-        editChannelMessage: () => Promise.resolve(),
-        addChannelMessageReaction: () => Promise.resolve(),
-    };
-}
-//# sourceMappingURL=oauth-module.test.js.map