@helyx/bot 0.1.0

package/dist/management-module.js

@@ -0,0 +1,865 @@
+import { defineModule, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
+const MODULE_SELECT_ID = "helyx.management.module";
+const SETTING_SELECT_ID = "helyx.management.setting";
+const VALUE_SELECT_ID = "helyx.management.value";
+const ENABLE_ID = "helyx.management.enable";
+const DISABLE_ID = "helyx.management.disable";
+const CONFIGURE_ID = "helyx.management.configure";
+const SAVE_ID = "helyx.management.save";
+const CLEAR_ID = "helyx.management.clear";
+const BACK_TO_MODULES_ID = "helyx.management.back.modules";
+const BACK_TO_MODULE_ID = "helyx.management.back.module";
+const CANCEL_ID = "helyx.management.cancel";
+const MODULE_PREVIOUS_ID = "helyx.management.module.previous";
+const MODULE_NEXT_ID = "helyx.management.module.next";
+const SETTING_PREVIOUS_ID = "helyx.management.setting.previous";
+const SETTING_NEXT_ID = "helyx.management.setting.next";
+const VALUE_MODAL_ID = "helyx.management.value.modal";
+const VALUE_FIELD_ID = "value";
+const SESSION_PURPOSE = "modules.manage";
+const PAGE_SIZE = 25;
+const SESSION_LIFETIME_MS = 15 * 60 * 1_000;
+const VIOLET = 0x7c3aed;
+const SUCCESS = 0x16a34a;
+const DANGER = 0xdc2626;
+export function createManagementModule(configurableModules, resources) {
+    const modules = [...configurableModules].sort((left, right) => left.manifest.name.localeCompare(right.manifest.name, "en-GB"));
+    const byId = new Map(modules.map((module) => [module.manifest.id, module]));
+    return defineModule({
+        manifest: {
+            manifestVersion: "0.1",
+            id: "helyx.management",
+            name: "Helyx management",
+            version: "0.1.0",
+            description: "Manages installed Helyx modules from Discord.",
+            entry: "./dist/management-module.js",
+            framework: "^0.1.0",
+            dependencies: [],
+            permissions: [],
+            contributions: { commands: ["helyx"], events: [] },
+        },
+        defaultPermissions: {
+            module: restrictedPolicy(),
+            commands: { helyx: restrictedPolicy() },
+        },
+        interactions: {
+            commands: [
+                {
+                    name: "helyx",
+                    description: "Manage Helyx modules and settings",
+                    registration: "global",
+                    contexts: ["guild"],
+                    integrationTypes: ["guild_install"],
+                    rateLimit: { scope: "user", limit: 30, windowSeconds: 60 },
+                    async execute(context) {
+                        if (!context.serverId)
+                            return;
+                        if (modules.length === 0) {
+                            await context.reply({
+                                ephemeral: true,
+                                componentsV2: {
+                                    accentColor: DANGER,
+                                    text: [
+                                        {
+                                            content: "## No feature modules installed\nInstall at least one official Helyx module before configuring this server.",
+                                        },
+                                    ],
+                                },
+                            });
+                            return;
+                        }
+                        await context.services
+                            .get(HELYX_SERVICE_NAMES.sessions)
+                            .create({
+                            guildId: context.serverId,
+                            userId: context.userId,
+                            purpose: SESSION_PURPOSE,
+                            state: { modulePage: 0 },
+                            expiresAt: sessionExpiry(),
+                            replace: true,
+                        });
+                        await context.reply(await modulePickerResponse(context, modules, 0));
+                    },
+                },
+            ],
+            selects: [
+                {
+                    customId: MODULE_SELECT_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session || !context.serverId)
+                            return;
+                        const moduleId = context.selectedValues[0];
+                        const module = moduleId ? byId.get(moduleId) : undefined;
+                        if (!module)
+                            throw new Error("Selected module is unavailable");
+                        const configuration = await context.services
+                            .get(HELYX_SERVICE_NAMES.configuration)
+                            .get(context.serverId, module.manifest.id);
+                        const state = {
+                            ...session.state,
+                            moduleId,
+                            settingPage: 0,
+                            draft: initialDraft(module, configuration?.value),
+                            expectedConfigurationVersion: configuration?.version.toString() ?? null,
+                        };
+                        await updateSession(context, session, state);
+                        await respond(context, await moduleResponse(context, module));
+                    },
+                },
+                {
+                    customId: SETTING_SELECT_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        const module = selectedModule(session.state, byId);
+                        const setting = selectedSetting(module, context.selectedValues[0]);
+                        const state = { ...session.state, selectedSettingKey: setting.key };
+                        await updateSession(context, session, state);
+                        if (setting.type === "string" || setting.type === "integer") {
+                            await context.showModal(settingModal(setting, draft(state)));
+                            return;
+                        }
+                        await respond(context, settingValueResponse(setting));
+                    },
+                },
+                {
+                    customId: VALUE_SELECT_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        const module = selectedModule(session.state, byId);
+                        const setting = selectedSetting(module, stringState(session.state, "selectedSettingKey"));
+                        const value = selectedValue(setting, context.selectedValues);
+                        const nextDraft = { ...draft(session.state), [setting.key]: value };
+                        const state = { ...session.state, draft: nextDraft };
+                        const updated = await updateSession(context, session, state);
+                        await respond(context, configurationResponse(module, updated.state));
+                    },
+                },
+            ],
+            buttons: [
+                statusButton(ENABLE_ID, true),
+                statusButton(DISABLE_ID, false),
+                {
+                    customId: CONFIGURE_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        const module = selectedModule(session.state, byId);
+                        if (!module.configuration ||
+                            !module.manifest.dashboard?.settings.length) {
+                            throw new Error("Selected module has no configurable settings");
+                        }
+                        await respond(context, configurationResponse(module, session.state));
+                    },
+                },
+                {
+                    customId: SAVE_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session || !context.serverId)
+                            return;
+                        const module = selectedModule(session.state, byId);
+                        const value = draft(session.state);
+                        const problem = validateDraft(module, value);
+                        if (problem) {
+                            await context.reply(validationResponse(problem));
+                            return;
+                        }
+                        const resourceProblem = await validateDiscordSettings(resources, context.serverId, module, value);
+                        if (resourceProblem) {
+                            await context.reply(validationResponse(resourceProblem));
+                            return;
+                        }
+                        try {
+                            module.configuration?.validate(value);
+                        }
+                        catch (error) {
+                            await context.reply(validationResponse(error instanceof Error
+                                ? error.message
+                                : "The module rejected these settings."));
+                            return;
+                        }
+                        const saved = await context.services
+                            .get(HELYX_SERVICE_NAMES.configuration)
+                            .update({
+                            guildId: context.serverId,
+                            moduleId: module.manifest.id,
+                            value,
+                            expectedVersion: optionalBigIntState(session.state, "expectedConfigurationVersion"),
+                            context: {
+                                actorUserId: context.userId,
+                                correlationId: context.interactionId,
+                                source: "discord",
+                            },
+                        });
+                        await updateSession(context, session, {
+                            ...session.state,
+                            draft: saved.value,
+                            expectedConfigurationVersion: saved.version.toString(),
+                        });
+                        await respond(context, {
+                            ephemeral: true,
+                            componentsV2: {
+                                accentColor: SUCCESS,
+                                text: [
+                                    {
+                                        content: `## ${module.manifest.name} settings saved\nThe complete configuration was validated and saved for this server.`,
+                                    },
+                                ],
+                            },
+                            buttons: [
+                                button(BACK_TO_MODULE_ID, "Back to module", "secondary"),
+                                button(CANCEL_ID, "Done", "success"),
+                            ],
+                        });
+                    },
+                },
+                {
+                    customId: CLEAR_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        const module = selectedModule(session.state, byId);
+                        const setting = selectedSetting(module, stringState(session.state, "selectedSettingKey"));
+                        if (setting.required)
+                            throw new Error("Required settings cannot be cleared");
+                        const nextDraft = {
+                            ...draft(session.state),
+                            [setting.key]: emptyValue(setting),
+                        };
+                        const updated = await updateSession(context, session, {
+                            ...session.state,
+                            draft: nextDraft,
+                        });
+                        await respond(context, configurationResponse(module, updated.state));
+                    },
+                },
+                {
+                    customId: BACK_TO_MODULES_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        const page = numberState(session.state, "modulePage");
+                        await respond(context, await modulePickerResponse(context, modules, page));
+                    },
+                },
+                {
+                    customId: BACK_TO_MODULE_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        await respond(context, await moduleResponse(context, selectedModule(session.state, byId)));
+                    },
+                },
+                {
+                    customId: CANCEL_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        await context.services
+                            .get(HELYX_SERVICE_NAMES.sessions)
+                            .delete(session.sessionId);
+                        await respond(context, {
+                            ephemeral: true,
+                            componentsV2: {
+                                accentColor: VIOLET,
+                                text: [
+                                    {
+                                        content: "## Helyx management closed\nRun `/helyx` whenever you need to manage modules.",
+                                    },
+                                ],
+                            },
+                        });
+                    },
+                },
+                modulePageButton(MODULE_PREVIOUS_ID, -1),
+                modulePageButton(MODULE_NEXT_ID, 1),
+                settingPageButton(SETTING_PREVIOUS_ID, -1),
+                settingPageButton(SETTING_NEXT_ID, 1),
+            ],
+            modals: [
+                {
+                    customId: VALUE_MODAL_ID,
+                    async execute(context) {
+                        const session = await getSession(context);
+                        if (!session)
+                            return;
+                        const module = selectedModule(session.state, byId);
+                        const setting = selectedSetting(module, stringState(session.state, "selectedSettingKey"));
+                        if (setting.type !== "string" && setting.type !== "integer") {
+                            throw new Error("Selected setting does not use text input");
+                        }
+                        const parsed = parseModalValue(setting, context.getField(VALUE_FIELD_ID));
+                        if (parsed.problem) {
+                            await context.reply(validationResponse(parsed.problem));
+                            return;
+                        }
+                        const updated = await updateSession(context, session, {
+                            ...session.state,
+                            draft: { ...draft(session.state), [setting.key]: parsed.value },
+                        });
+                        await respond(context, configurationResponse(module, updated.state));
+                    },
+                },
+            ],
+        },
+        start: () => Promise.resolve(),
+        stop: () => Promise.resolve(),
+    });
+    function statusButton(customId, enabled) {
+        return {
+            customId,
+            async execute(context) {
+                const session = await getSession(context);
+                if (!session || !context.serverId)
+                    return;
+                const module = selectedModule(session.state, byId);
+                try {
+                    await context.services
+                        .get(HELYX_SERVICE_NAMES.installations)
+                        .setModuleEnabled({
+                        guildId: context.serverId,
+                        moduleId: module.manifest.id,
+                        enabled,
+                        context: {
+                            actorUserId: context.userId,
+                            correlationId: context.interactionId,
+                            source: "discord",
+                        },
+                    });
+                }
+                catch (error) {
+                    if (error instanceof ModuleStateValidationError) {
+                        await context.reply(validationResponse(error.message));
+                        return;
+                    }
+                    throw error;
+                }
+                await respond(context, {
+                    ephemeral: true,
+                    componentsV2: {
+                        accentColor: enabled ? SUCCESS : VIOLET,
+                        text: [
+                            {
+                                content: `## ${module.manifest.name} ${enabled ? "enabled" : "disabled"}\n${enabled ? "Its configured commands and events can now run in this server." : "Its configuration and stored data have been retained."}`,
+                            },
+                        ],
+                    },
+                    buttons: [
+                        button(BACK_TO_MODULE_ID, "Back to module", "secondary"),
+                        button(CANCEL_ID, "Done", "success"),
+                    ],
+                });
+            },
+        };
+    }
+    function modulePageButton(customId, change) {
+        return {
+            customId,
+            async execute(context) {
+                const session = await getSession(context);
+                if (!session)
+                    return;
+                const page = clampPage(numberState(session.state, "modulePage") + change, pageCount(modules.length));
+                const updated = await updateSession(context, session, {
+                    ...session.state,
+                    modulePage: page,
+                });
+                await respond(context, await modulePickerResponse(context, modules, page));
+                void updated;
+            },
+        };
+    }
+    function settingPageButton(customId, change) {
+        return {
+            customId,
+            async execute(context) {
+                const session = await getSession(context);
+                if (!session)
+                    return;
+                const module = selectedModule(session.state, byId);
+                const settings = module.manifest.dashboard?.settings ?? [];
+                const page = clampPage(numberState(session.state, "settingPage") + change, pageCount(settings.length));
+                const updated = await updateSession(context, session, {
+                    ...session.state,
+                    settingPage: page,
+                });
+                await respond(context, configurationResponse(module, updated.state));
+            },
+        };
+    }
+}
+function restrictedPolicy() {
+    return {
+        everyone: false,
+        requiredPermissions: ["MANAGE_GUILD"],
+        allowedRoleIds: [],
+        deniedRoleIds: [],
+        allowedUserIds: [],
+        deniedUserIds: [],
+    };
+}
+async function modulePickerResponse(context, modules, requestedPage) {
+    if (!context.serverId)
+        throw new Error("Server context is required");
+    const pages = pageCount(modules.length);
+    const page = clampPage(requestedPage, pages);
+    const visible = pageItems(modules, page);
+    const installations = context.services.get(HELYX_SERVICE_NAMES.installations);
+    const statuses = await Promise.all(visible.map((module) => installations.isModuleEnabled(context.serverId, module.manifest.id)));
+    return {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: VIOLET,
+            text: [
+                {
+                    content: "## Helyx modules\nChoose an installed module to manage its server-level state and settings." +
+                        (pages > 1 ? ` Page ${String(page + 1)} of ${String(pages)}.` : ""),
+                },
+            ],
+        },
+        selects: [
+            {
+                customId: MODULE_SELECT_ID,
+                placeholder: "Choose an installed module",
+                options: visible.map((module, index) => ({
+                    label: module.manifest.name,
+                    value: module.manifest.id,
+                    description: `${statuses[index] ? "Enabled" : "Disabled"} · ${truncate(module.manifest.description, 87)}`,
+                })),
+            },
+        ],
+        buttons: [
+            ...paginationButtons(page, pages, MODULE_PREVIOUS_ID, MODULE_NEXT_ID),
+            button(CANCEL_ID, "Close", "secondary"),
+        ],
+    };
+}
+async function moduleResponse(context, module) {
+    if (!context.serverId)
+        throw new Error("Server context is required");
+    const enabled = await context.services
+        .get(HELYX_SERVICE_NAMES.installations)
+        .isModuleEnabled(context.serverId, module.manifest.id);
+    const configurable = !!module.configuration && !!module.manifest.dashboard?.settings.length;
+    return {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: enabled ? SUCCESS : VIOLET,
+            text: [
+                {
+                    content: `## ${module.manifest.name}\n${module.manifest.description}\n\n**Status:** ${enabled ? "Enabled" : "Disabled"}\n**Installed version:** ${module.manifest.version}\n**Settings:** ${configurable ? "Available" : "No configurable settings"}`,
+                },
+            ],
+        },
+        buttons: [
+            enabled
+                ? button(DISABLE_ID, "Disable module", "danger")
+                : button(ENABLE_ID, "Enable module", "success"),
+            ...(configurable
+                ? [button(CONFIGURE_ID, "Configure settings", "primary")]
+                : []),
+            button(BACK_TO_MODULES_ID, "All modules", "secondary"),
+            button(CANCEL_ID, "Close", "secondary"),
+        ],
+    };
+}
+function configurationResponse(module, state) {
+    const settings = module.manifest.dashboard?.settings ?? [];
+    if (!module.configuration || settings.length === 0) {
+        throw new Error("Selected module has no configurable settings");
+    }
+    const pages = pageCount(settings.length);
+    const page = clampPage(numberState(state, "settingPage"), pages);
+    const visible = pageItems(settings, page);
+    const value = draft(state);
+    return {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: VIOLET,
+            text: [
+                {
+                    content: `## ${module.manifest.name} settings\nChoose a setting to edit. Changes remain private and unsaved until you select Save settings.` +
+                        (pages > 1 ? ` Page ${String(page + 1)} of ${String(pages)}.` : ""),
+                },
+            ],
+        },
+        selects: [
+            {
+                customId: SETTING_SELECT_ID,
+                placeholder: "Choose a setting",
+                options: visible.map((setting) => ({
+                    label: setting.label,
+                    value: setting.key,
+                    description: `${settingStatus(setting, value[setting.key])} · ${truncate(setting.description, 85)}`,
+                })),
+            },
+        ],
+        buttons: [
+            ...paginationButtons(page, pages, SETTING_PREVIOUS_ID, SETTING_NEXT_ID),
+            button(SAVE_ID, "Save settings", "success"),
+            button(BACK_TO_MODULE_ID, "Back", "secondary"),
+            button(CANCEL_ID, "Cancel", "secondary"),
+        ],
+    };
+}
+function settingValueResponse(setting) {
+    const clear = setting.required
+        ? []
+        : [button(CLEAR_ID, "Clear setting", "secondary")];
+    const base = {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: VIOLET,
+            text: [{ content: `## ${setting.label}\n${setting.description}` }],
+        },
+        buttons: [
+            ...clear,
+            button(CONFIGURE_ID, "Back to settings", "secondary"),
+            button(CANCEL_ID, "Cancel", "secondary"),
+        ],
+    };
+    if (setting.type === "boolean") {
+        return {
+            ...base,
+            selects: [
+                {
+                    customId: VALUE_SELECT_ID,
+                    placeholder: "Choose enabled or disabled",
+                    options: [
+                        { label: "Enabled", value: "true" },
+                        { label: "Disabled", value: "false" },
+                    ],
+                },
+            ],
+        };
+    }
+    if (setting.type === "select") {
+        return {
+            ...base,
+            selects: [
+                {
+                    customId: VALUE_SELECT_ID,
+                    placeholder: "Choose an option",
+                    options: setting.options,
+                },
+            ],
+        };
+    }
+    if (setting.type === "discord-channel") {
+        return {
+            ...base,
+            selects: [
+                {
+                    type: "discord-channel",
+                    customId: VALUE_SELECT_ID,
+                    placeholder: "Choose a channel",
+                    channelTypes: setting.channelTypes,
+                },
+            ],
+        };
+    }
+    if (setting.type === "discord-role") {
+        return {
+            ...base,
+            selects: [
+                {
+                    type: "discord-role",
+                    customId: VALUE_SELECT_ID,
+                    placeholder: setting.multiple ? "Choose roles" : "Choose a role",
+                    minValues: 1,
+                    maxValues: setting.multiple ? 25 : 1,
+                },
+            ],
+        };
+    }
+    throw new Error("Selected setting requires a modal");
+}
+function settingModal(setting, values) {
+    const current = values[setting.key];
+    return {
+        customId: VALUE_MODAL_ID,
+        title: truncate(setting.label, 45),
+        text: [{ content: setting.description, markdown: false }],
+        fields: [
+            {
+                customId: VALUE_FIELD_ID,
+                label: setting.type === "integer" ? "Whole number" : setting.label,
+                ...(setting.type === "integer"
+                    ? {
+                        description: `From ${String(setting.minimum)} to ${String(setting.maximum)}.`,
+                    }
+                    : {}),
+                style: setting.type === "string" && setting.maxLength > 200
+                    ? "paragraph"
+                    : "short",
+                required: setting.required,
+                minLength: setting.type === "string" ? setting.minLength : 1,
+                maxLength: setting.type === "string" ? setting.maxLength : 30,
+                ...(setting.type === "string" && setting.placeholder
+                    ? { placeholder: setting.placeholder }
+                    : {}),
+                ...(typeof current === "string" || typeof current === "number"
+                    ? { value: String(current) }
+                    : {}),
+            },
+        ],
+    };
+}
+function initialDraft(module, existing) {
+    const result = { ...(existing ?? {}) };
+    for (const setting of module.manifest.dashboard?.settings ?? []) {
+        if (result[setting.key] !== undefined)
+            continue;
+        if ("default" in setting && setting.default !== undefined) {
+            result[setting.key] = setting.default;
+            continue;
+        }
+        if (!setting.required)
+            result[setting.key] = emptyValue(setting);
+    }
+    return result;
+}
+function emptyValue(setting) {
+    if (setting.type === "discord-role" && setting.multiple)
+        return [];
+    if (setting.type === "string" ||
+        setting.type === "discord-channel" ||
+        setting.type === "discord-role") {
+        return "";
+    }
+    return undefined;
+}
+function selectedValue(setting, values) {
+    if (setting.type === "boolean") {
+        if (values.length !== 1 || !["true", "false"].includes(values[0])) {
+            throw new Error("Selected boolean value is invalid");
+        }
+        return values[0] === "true";
+    }
+    if (setting.type === "select") {
+        if (values.length !== 1 ||
+            !setting.options.some((option) => option.value === values[0])) {
+            throw new Error("Selected option is unavailable");
+        }
+        return values[0];
+    }
+    if (setting.type === "discord-channel") {
+        if (values.length !== 1 || !isSnowflake(values[0])) {
+            throw new Error("Selected channel is invalid");
+        }
+        return values[0];
+    }
+    if (setting.type === "discord-role") {
+        if (values.length < 1 ||
+            values.length > (setting.multiple ? 25 : 1) ||
+            new Set(values).size !== values.length ||
+            values.some((value) => !isSnowflake(value))) {
+            throw new Error("Selected role value is invalid");
+        }
+        return setting.multiple ? [...values] : values[0];
+    }
+    throw new Error("Selected setting does not use a selector");
+}
+function parseModalValue(setting, input) {
+    const value = input.normalize("NFKC").trim();
+    if (setting.type === "string") {
+        if (!setting.required && value.length === 0)
+            return { value: "" };
+        if (value.length < setting.minLength || value.length > setting.maxLength) {
+            return {
+                problem: `${setting.label} must contain ${String(setting.minLength)} to ${String(setting.maxLength)} characters.`,
+            };
+        }
+        return { value };
+    }
+    if (!/^-?\d+$/u.test(value)) {
+        return { problem: `${setting.label} must be a whole number.` };
+    }
+    const number = Number(value);
+    if (!Number.isSafeInteger(number) ||
+        number < setting.minimum ||
+        number > setting.maximum) {
+        return {
+            problem: `${setting.label} must be from ${String(setting.minimum)} to ${String(setting.maximum)}.`,
+        };
+    }
+    return { value: number };
+}
+function validateDraft(module, values) {
+    for (const setting of module.manifest.dashboard?.settings ?? []) {
+        const value = values[setting.key];
+        if (!setting.required)
+            continue;
+        const missing = value === undefined ||
+            value === null ||
+            value === "" ||
+            (Array.isArray(value) && value.length === 0);
+        if (missing)
+            return `${setting.label} is required before settings can be saved.`;
+    }
+    return null;
+}
+async function validateDiscordSettings(directory, guildId, module, values) {
+    const settings = module.manifest.dashboard?.settings ?? [];
+    if (!settings.some((setting) => setting.type === "discord-channel" || setting.type === "discord-role")) {
+        return null;
+    }
+    const resources = await directory.getGuildResources(guildId);
+    const channels = new Map(resources.channels.map((channel) => [channel.id, channel]));
+    const roles = new Set(resources.roles.map((role) => role.id));
+    for (const setting of settings) {
+        const configured = values[setting.key];
+        if (configured === "" || configured === undefined)
+            continue;
+        if (setting.type === "discord-channel") {
+            const channel = typeof configured === "string" ? channels.get(configured) : undefined;
+            if (!channel || !setting.channelTypes.includes(channel.type)) {
+                return `${setting.label} must be an available supported Discord channel.`;
+            }
+        }
+        if (setting.type === "discord-role") {
+            if (setting.multiple !== Array.isArray(configured)) {
+                return `${setting.label} has an invalid Discord role selection.`;
+            }
+            const configuredRoles = Array.isArray(configured)
+                ? configured
+                : [configured];
+            if (configuredRoles.some((roleId) => typeof roleId !== "string" || !roles.has(roleId))) {
+                return `${setting.label} must contain available Discord roles.`;
+            }
+        }
+    }
+    return null;
+}
+function validationResponse(description) {
+    return {
+        ephemeral: true,
+        componentsV2: {
+            accentColor: DANGER,
+            text: [{ content: `## Settings not changed\n${description}` }],
+        },
+    };
+}
+function respond(context, response) {
+    return context.updateResponse
+        ? context.updateResponse(response)
+        : context.reply(response);
+}
+function selectedModule(state, modules) {
+    const module = modules.get(stringState(state, "moduleId"));
+    if (!module)
+        throw new Error("Selected module is unavailable");
+    return module;
+}
+function selectedSetting(module, key) {
+    const setting = module.manifest.dashboard?.settings.find((candidate) => candidate.key === key);
+    if (!setting)
+        throw new Error("Selected setting is unavailable");
+    return setting;
+}
+function settingStatus(setting, value) {
+    if (value === undefined ||
+        value === "" ||
+        (Array.isArray(value) && !value.length)) {
+        return setting.required ? "Required" : "Not set";
+    }
+    if (setting.type === "boolean")
+        return value === true ? "Enabled" : "Disabled";
+    if (setting.type === "discord-channel")
+        return "Channel selected";
+    if (setting.type === "discord-role") {
+        return Array.isArray(value)
+            ? `${String(value.length)} roles selected`
+            : "Role selected";
+    }
+    return "Configured";
+}
+async function getSession(context) {
+    if (!context.serverId)
+        return null;
+    const session = await context.services
+        .get(HELYX_SERVICE_NAMES.sessions)
+        .getFor(context.serverId, context.userId, SESSION_PURPOSE);
+    if (!session)
+        throw new Error("Management session expired; run /helyx again");
+    return session;
+}
+function updateSession(context, session, state) {
+    return context.services
+        .get(HELYX_SERVICE_NAMES.sessions)
+        .update({
+        sessionId: session.sessionId,
+        state,
+        expectedVersion: session.version,
+        expiresAt: sessionExpiry(),
+    });
+}
+function draft(state) {
+    const value = state.draft;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Management session is invalid");
+    }
+    return value;
+}
+function stringState(state, key) {
+    const value = state[key];
+    if (typeof value !== "string")
+        throw new Error("Management session is invalid");
+    return value;
+}
+function numberState(state, key) {
+    const value = state[key];
+    if (value === undefined)
+        return 0;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error("Management session is invalid");
+    }
+    return value;
+}
+function optionalBigIntState(state, key) {
+    const value = state[key];
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "string" || !/^\d+$/u.test(value)) {
+        throw new Error("Management session is invalid");
+    }
+    return BigInt(value);
+}
+function pageItems(items, page) {
+    return items.slice(page * PAGE_SIZE, (page + 1) * PAGE_SIZE);
+}
+function pageCount(itemCount) {
+    return Math.max(1, Math.ceil(itemCount / PAGE_SIZE));
+}
+function clampPage(page, pages) {
+    return Math.max(0, Math.min(page, pages - 1));
+}
+function paginationButtons(page, pages, previousId, nextId) {
+    return [
+        ...(page > 0 ? [button(previousId, "Previous page", "secondary")] : []),
+        ...(page + 1 < pages ? [button(nextId, "Next page", "secondary")] : []),
+    ];
+}
+function button(customId, label, style) {
+    return { type: "button", customId, label, style };
+}
+function sessionExpiry() {
+    return new Date(Date.now() + SESSION_LIFETIME_MS);
+}
+function isSnowflake(value) {
+    return /^\d{17,20}$/u.test(value);
+}
+function truncate(value, maximum) {
+    return value.length <= maximum ? value : `${value.slice(0, maximum - 1)}…`;
+}
+//# sourceMappingURL=management-module.js.map