@helyx/bot 0.1.0

package/dist/control-server.js

@@ -0,0 +1,663 @@
+import { AuditRepository, InstallationRepository, ModuleLoggingPolicyRepository, OptimisticConcurrencyError, PermissionPolicyRepository, withTransaction, } from "@helyx/database";
+import { DashboardActionValidationError, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
+import { ChannelType } from "discord.js";
+import Fastify, {} from "fastify";
+import { createHash, timingSafeEqual } from "node:crypto";
+import { z, ZodError } from "zod";
+import { deleteChannelMessage as deleteDiscordChannelMessage, sendToChannel as sendDiscordMessageToChannel, } from "./interactions.js";
+const snowflake = z.string().regex(/^\d{17,20}$/u);
+const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
+const configurationValue = z.record(z.string(), z.union([
+    z.string(),
+    z.boolean(),
+    z.number().finite(),
+    z.array(z.string()).max(100),
+]));
+const permissionPreset = z.enum([
+    "everyone",
+    "moderators",
+    "administrators",
+    "custom",
+]);
+const dashboardPermissionPolicy = z.object({
+    preset: permissionPreset,
+    allowedRoleIds: z.array(snowflake).max(100),
+    deniedRoleIds: z.array(snowflake).max(100),
+});
+const permissionState = z.object({
+    version: z.number().int().min(0),
+    module: dashboardPermissionPolicy,
+    commands: z
+        .array(z.object({
+        commandId: z.string().min(1).max(100),
+        version: z.number().int().min(0),
+        enabled: z.boolean(),
+        policy: dashboardPermissionPolicy,
+    }))
+        .max(100),
+});
+const mutationContext = z.object({
+    actorUserId: snowflake,
+    correlationId: z.uuid(),
+});
+export class DiscordGuildResourceDirectory {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getGuildResources(guildId) {
+        try {
+            const guild = await this.client.guilds.fetch(guildId);
+            const [channels, roles] = await Promise.all([
+                guild.channels.fetch(),
+                guild.roles.fetch(),
+            ]);
+            return {
+                channels: [...channels.values()]
+                    .filter((channel) => channel?.type === ChannelType.GuildText ||
+                    channel?.type === ChannelType.GuildAnnouncement)
+                    .map((channel) => ({
+                    id: channel.id,
+                    name: channel.name,
+                    type: channel.type === ChannelType.GuildAnnouncement
+                        ? "guild_announcement"
+                        : "guild_text",
+                }))
+                    .sort((left, right) => left.name.localeCompare(right.name)),
+                roles: [...roles.values()]
+                    .filter((role) => role.id !== guild.id && !role.managed)
+                    .sort((left, right) => right.position - left.position)
+                    .map((role) => ({
+                    id: role.id,
+                    name: role.name,
+                    colour: role.hexColor,
+                })),
+            };
+        }
+        catch (error) {
+            if (isUnknownGuildError(error))
+                throw new BotControlNotFoundError();
+            throw error;
+        }
+    }
+    sendToChannel(channelId, response) {
+        return sendDiscordMessageToChannel(this.client, channelId, response);
+    }
+    deleteChannelMessage(channelId, messageId) {
+        return deleteDiscordChannelMessage(this.client, channelId, messageId);
+    }
+}
+export class BotControlService {
+    database;
+    resources;
+    #modules;
+    #dashboardModules;
+    #configurations;
+    #installations;
+    #permissions;
+    #services;
+    constructor(database, modules, resources, services) {
+        this.database = database;
+        this.resources = resources;
+        this.#modules = new Map(modules.map((module) => [module.manifest.id, module]));
+        this.#dashboardModules = modules
+            .filter((module) => module.manifest.dashboard !== undefined)
+            .map(mapDashboardModule);
+        this.#configurations = services.get(HELYX_SERVICE_NAMES.configuration);
+        this.#installations = services.get(HELYX_SERVICE_NAMES.installations);
+        this.#permissions = services.get(HELYX_SERVICE_NAMES.permissions);
+        this.#services = services;
+    }
+    async getGuildState(guildId) {
+        const [resources, installedModules, storedLoggingPolicies] = await Promise.all([
+            this.resources.getGuildResources(guildId),
+            new InstallationRepository(this.database).listModules(guildId),
+            new ModuleLoggingPolicyRepository(this.database).listForGuild(guildId),
+        ]);
+        const installed = new Map(installedModules.map((module) => [module.moduleId, module]));
+        const moduleStatuses = {};
+        const configurations = {};
+        const permissions = {};
+        const logging = {};
+        const loggingPolicies = new Map(storedLoggingPolicies.map((policy) => [
+            `${policy.sourceModuleId}:${policy.eventId}`,
+            policy,
+        ]));
+        await Promise.all(this.#dashboardModules.map(async (dashboardModule) => {
+            const module = this.#requireModule(dashboardModule.id);
+            const installation = installed.get(dashboardModule.id);
+            moduleStatuses[dashboardModule.id] = installation
+                ? installation.enabled
+                    ? "enabled"
+                    : "disabled"
+                : "unavailable";
+            const [configuration, permission] = await Promise.all([
+                this.#configurations.get(guildId, dashboardModule.id),
+                this.#getPermissionState(guildId, module),
+            ]);
+            if (configuration)
+                configurations[dashboardModule.id] = {
+                    version: safeVersion(configuration.version),
+                    value: configuration.value,
+                };
+            permissions[dashboardModule.id] = permission;
+            logging[dashboardModule.id] = dashboardModule.logEvents.map((event) => {
+                const stored = loggingPolicies.get(`${dashboardModule.id}:${event.id}`);
+                return {
+                    eventId: event.id,
+                    enabled: stored?.enabled ?? event.defaultEnabled,
+                    version: stored ? safeVersion(stored.version) : 0,
+                };
+            });
+        }));
+        return {
+            ...resources,
+            modules: structuredClone(this.#dashboardModules),
+            moduleStatuses,
+            configurations,
+            permissions,
+            logging,
+        };
+    }
+    async setModuleStatus(input) {
+        this.#requireDashboardModule(input.moduleId);
+        await this.#installations.setModuleEnabled({
+            guildId: input.guildId,
+            moduleId: input.moduleId,
+            enabled: input.enabled,
+            context: {
+                actorUserId: input.actorUserId,
+                correlationId: input.correlationId,
+                source: "dashboard",
+            },
+        });
+        return this.getGuildState(input.guildId);
+    }
+    async updateConfiguration(input) {
+        const module = this.#requireDashboardModule(input.moduleId);
+        await this.#validateDiscordSettings(input.guildId, module, input.value);
+        const saved = await this.#configurations.update({
+            guildId: input.guildId,
+            moduleId: input.moduleId,
+            value: input.value,
+            expectedVersion: input.expectedVersion === null ? null : BigInt(input.expectedVersion),
+            context: {
+                actorUserId: input.actorUserId,
+                correlationId: input.correlationId,
+                source: "dashboard",
+            },
+        });
+        return { value: saved.value, version: safeVersion(saved.version) };
+    }
+    async updatePermissions(input) {
+        const module = this.#requireDashboardModule(input.moduleId);
+        const commands = dashboardCommands(module);
+        const supplied = new Map(input.state.commands.map((command) => [command.commandId, command]));
+        if (supplied.size !== input.state.commands.length ||
+            supplied.size !== commands.length ||
+            commands.some((command) => !supplied.has(command.id)))
+            throw new BotControlValidationError("Permission commands did not match the installed module");
+        await this.#validatePermissionRoles(input.guildId, input.state);
+        const currentModule = await this.#permissions.getPolicy(input.guildId, input.moduleId);
+        assertVersion(currentModule.version, input.state.version);
+        const currentCommands = new Map(await Promise.all(commands.map(async (command) => [
+            command.id,
+            await this.#permissions.getPolicy(input.guildId, input.moduleId, command.id),
+        ])));
+        for (const command of commands)
+            assertVersion(currentCommands.get(command.id).version, supplied.get(command.id).version);
+        await withTransaction(this.database, async (connection) => {
+            const policies = new PermissionPolicyRepository(connection);
+            const audit = new AuditRepository(connection);
+            const savedModule = await policies.save({
+                guildId: input.guildId,
+                moduleId: input.moduleId,
+                policy: {
+                    ...fromDashboardPolicy(input.state.module, currentModule.policy),
+                },
+                expectedVersion: currentModule.version,
+                updatedBy: input.actorUserId,
+            });
+            await audit.append({
+                guildId: input.guildId,
+                actorUserId: input.actorUserId,
+                action: "module.permission.updated",
+                source: "dashboard",
+                correlationId: input.correlationId,
+                moduleId: input.moduleId,
+                afterState: { version: savedModule.version.toString() },
+            });
+            for (const command of commands) {
+                const requested = supplied.get(command.id);
+                const current = currentCommands.get(command.id);
+                if (requested.enabled) {
+                    const saved = await policies.save({
+                        guildId: input.guildId,
+                        moduleId: input.moduleId,
+                        commandId: command.id,
+                        policy: {
+                            ...fromDashboardPolicy(requested.policy, current.policy),
+                        },
+                        inheritsModule: false,
+                        expectedVersion: current.version,
+                        updatedBy: input.actorUserId,
+                    });
+                    await audit.append({
+                        guildId: input.guildId,
+                        actorUserId: input.actorUserId,
+                        action: "command.permission.updated",
+                        source: "dashboard",
+                        correlationId: input.correlationId,
+                        moduleId: input.moduleId,
+                        commandId: command.id,
+                        afterState: { version: saved.version.toString() },
+                    });
+                }
+                else if (module.defaultPermissions?.commands[command.id]) {
+                    const saved = await policies.save({
+                        guildId: input.guildId,
+                        moduleId: input.moduleId,
+                        commandId: command.id,
+                        policy: { ...currentModule.policy },
+                        inheritsModule: true,
+                        expectedVersion: current.version,
+                        updatedBy: input.actorUserId,
+                    });
+                    await audit.append({
+                        guildId: input.guildId,
+                        actorUserId: input.actorUserId,
+                        action: "command.permission.inherited",
+                        source: "dashboard",
+                        correlationId: input.correlationId,
+                        moduleId: input.moduleId,
+                        commandId: command.id,
+                        afterState: { version: saved.version.toString() },
+                    });
+                }
+                else if (current.version !== null) {
+                    const deleted = await policies.deleteCommandPolicy(input.guildId, input.moduleId, command.id, current.version);
+                    if (!deleted)
+                        throw new OptimisticConcurrencyError("Command permission policy");
+                    await audit.append({
+                        guildId: input.guildId,
+                        actorUserId: input.actorUserId,
+                        action: "command.permission.cleared",
+                        source: "dashboard",
+                        correlationId: input.correlationId,
+                        moduleId: input.moduleId,
+                        commandId: command.id,
+                        beforeState: { version: current.version.toString() },
+                    });
+                }
+            }
+        });
+        return this.#getPermissionState(input.guildId, module);
+    }
+    async updateLoggingPolicy(input) {
+        if (!this.#modules.has("helyx.logging")) {
+            throw new BotControlNotFoundError("Logging is not installed");
+        }
+        if (!(await new InstallationRepository(this.database).isModuleEnabled(input.guildId, "helyx.logging"))) {
+            throw new BotControlValidationError("Enable Logging before changing activity events");
+        }
+        const source = this.#requireModule(input.moduleId);
+        const event = source.logging?.events.find(({ id }) => id === input.eventId);
+        if (!event) {
+            throw new BotControlNotFoundError("Logging event is not declared by this module");
+        }
+        const saved = await withTransaction(this.database, async (connection) => {
+            const policy = await new ModuleLoggingPolicyRepository(connection).save({
+                guildId: input.guildId,
+                sourceModuleId: input.moduleId,
+                eventId: input.eventId,
+                enabled: input.enabled,
+                expectedVersion: input.expectedVersion === 0 ? null : BigInt(input.expectedVersion),
+                updatedBy: input.actorUserId,
+            });
+            await new AuditRepository(connection).append({
+                guildId: input.guildId,
+                actorUserId: input.actorUserId,
+                action: "module.logging.updated",
+                source: "dashboard",
+                correlationId: input.correlationId,
+                moduleId: input.moduleId,
+                targetType: "module_log_event",
+                targetId: input.eventId,
+                afterState: {
+                    enabled: input.enabled,
+                    version: policy.version.toString(),
+                },
+            });
+            return policy;
+        });
+        return {
+            eventId: saved.eventId,
+            enabled: saved.enabled,
+            version: safeVersion(saved.version),
+        };
+    }
+    async executeDashboardAction(input) {
+        const module = this.#requireDashboardModule(input.moduleId);
+        const declared = module.manifest.dashboard?.actions?.find(({ id }) => id === input.actionId);
+        const action = module.dashboardActions?.find(({ id }) => id === input.actionId);
+        if (!declared || !action) {
+            throw new BotControlNotFoundError("Dashboard action is not declared by this module");
+        }
+        if (!(await new InstallationRepository(this.database).isModuleEnabled(input.guildId, input.moduleId))) {
+            throw new BotControlValidationError("Enable this module before running its dashboard actions");
+        }
+        return action.execute({
+            guildId: input.guildId,
+            actorUserId: input.actorUserId,
+            correlationId: input.correlationId,
+            services: this.#services,
+            sendToChannel: (channelId, response) => this.resources.sendToChannel(channelId, response),
+            deleteChannelMessage: (channelId, messageId) => this.resources.deleteChannelMessage(channelId, messageId),
+        });
+    }
+    #requireModule(moduleIdValue) {
+        const module = this.#modules.get(moduleIdValue);
+        if (!module)
+            throw new BotControlNotFoundError("Module is not installed");
+        return module;
+    }
+    #requireDashboardModule(moduleIdValue) {
+        const module = this.#requireModule(moduleIdValue);
+        if (!module.manifest.dashboard)
+            throw new BotControlNotFoundError("Module is not dashboard configurable");
+        return module;
+    }
+    async #getPermissionState(guildId, module) {
+        const commands = dashboardCommands(module);
+        const modulePolicy = await this.#permissions.getPolicy(guildId, module.manifest.id);
+        return {
+            version: safeOptionalVersion(modulePolicy.version),
+            module: toDashboardPolicy(modulePolicy.policy),
+            commands: await Promise.all(commands.map(async (command) => {
+                const value = await this.#permissions.getPolicy(guildId, module.manifest.id, command.id);
+                return {
+                    commandId: command.id,
+                    version: safeOptionalVersion(value.version),
+                    enabled: !value.inherited ||
+                        (value.version === null &&
+                            modulePolicy.version === null &&
+                            module.defaultPermissions?.commands[command.id] !== undefined),
+                    policy: toDashboardPolicy(value.policy),
+                };
+            })),
+        };
+    }
+    async #validateDiscordSettings(guildId, module, value) {
+        const settings = module.manifest.dashboard?.settings ?? [];
+        if (!settings.some((setting) => setting.type === "discord-channel" || setting.type === "discord-role"))
+            return;
+        const resources = await this.resources.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 = value[setting.key];
+            if (setting.type === "discord-channel") {
+                if (configured === "" || configured === undefined)
+                    continue;
+                const channel = typeof configured === "string" ? channels.get(configured) : null;
+                if (!channel || !setting.channelTypes.includes(channel.type))
+                    throw new BotControlValidationError(`${setting.label} must be an available supported Discord channel`);
+            }
+            if (setting.type === "discord-role") {
+                if (configured === "" || configured === undefined)
+                    continue;
+                if (setting.multiple !== Array.isArray(configured))
+                    throw new BotControlValidationError(`${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)))
+                    throw new BotControlValidationError(`${setting.label} must contain available Discord roles`);
+            }
+        }
+    }
+    async #validatePermissionRoles(guildId, state) {
+        const policies = [
+            state.module,
+            ...state.commands.map(({ policy }) => policy),
+        ];
+        for (const policy of policies) {
+            if (new Set(policy.allowedRoleIds).size !== policy.allowedRoleIds.length ||
+                new Set(policy.deniedRoleIds).size !== policy.deniedRoleIds.length) {
+                throw new BotControlValidationError("Permission settings contain duplicate Discord roles");
+            }
+            const denied = new Set(policy.deniedRoleIds);
+            if (policy.allowedRoleIds.some((roleId) => denied.has(roleId))) {
+                throw new BotControlValidationError("A Discord role cannot be both allowed and denied");
+            }
+        }
+        const requestedRoleIds = policies.flatMap((policy) => [
+            ...policy.allowedRoleIds,
+            ...policy.deniedRoleIds,
+        ]);
+        if (requestedRoleIds.length === 0)
+            return;
+        const resources = await this.resources.getGuildResources(guildId);
+        const roles = new Set(resources.roles.map((role) => role.id));
+        if (requestedRoleIds.some((roleId) => !roles.has(roleId)))
+            throw new BotControlValidationError("Permission settings contain a Discord role that is no longer available");
+    }
+}
+export async function createBotControlServer(input) {
+    const server = Fastify({
+        logger: input.logger ?? false,
+        bodyLimit: 64 * 1_024,
+        requestTimeout: 15_000,
+    });
+    const expectedSecret = digest(input.secret);
+    server.addHook("onRequest", async (request, reply) => {
+        if (request.url === "/health")
+            return;
+        const authorization = request.headers.authorization;
+        const supplied = authorization?.startsWith("Bearer ")
+            ? authorization.slice("Bearer ".length)
+            : "";
+        if (!timingSafeEqual(expectedSecret, digest(supplied)))
+            return reply.code(401).send({ message: "Control authentication failed" });
+    });
+    server.get("/health", () => ({ status: "ok" }));
+    server.get("/v1/health", () => ({ status: "ok" }));
+    server.get("/v1/guilds/:guildId/state", async (request) => {
+        const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
+        return input.service.getGuildState(guildId);
+    });
+    server.put("/v1/guilds/:guildId/modules/:moduleId/status", async (request) => {
+        const params = z
+            .object({ guildId: snowflake, moduleId })
+            .parse(request.params);
+        const body = mutationContext
+            .extend({ enabled: z.boolean() })
+            .parse(request.body);
+        return input.service.setModuleStatus({ ...params, ...body });
+    });
+    server.post("/v1/guilds/:guildId/modules/:moduleId/actions/:actionId", async (request) => {
+        const params = z
+            .object({
+            guildId: snowflake,
+            moduleId,
+            actionId: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+        })
+            .parse(request.params);
+        const body = mutationContext.parse(request.body);
+        return input.service.executeDashboardAction({ ...params, ...body });
+    });
+    server.put("/v1/guilds/:guildId/modules/:moduleId/configuration", async (request) => {
+        const params = z
+            .object({ guildId: snowflake, moduleId })
+            .parse(request.params);
+        const body = mutationContext
+            .extend({
+            value: configurationValue,
+            expectedVersion: z.number().int().positive().nullable(),
+        })
+            .parse(request.body);
+        return input.service.updateConfiguration({ ...params, ...body });
+    });
+    server.put("/v1/guilds/:guildId/modules/:moduleId/permissions", async (request) => {
+        const params = z
+            .object({ guildId: snowflake, moduleId })
+            .parse(request.params);
+        const body = mutationContext
+            .extend({ state: permissionState })
+            .parse(request.body);
+        return input.service.updatePermissions({ ...params, ...body });
+    });
+    server.put("/v1/guilds/:guildId/modules/:moduleId/logging/:eventId", async (request) => {
+        const params = z
+            .object({
+            guildId: snowflake,
+            moduleId,
+            eventId: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+        })
+            .parse(request.params);
+        const body = mutationContext
+            .extend({
+            enabled: z.boolean(),
+            expectedVersion: z.number().int().min(0),
+        })
+            .parse(request.body);
+        return input.service.updateLoggingPolicy({ ...params, ...body });
+    });
+    server.setErrorHandler(async (error, request, reply) => {
+        if (error instanceof ZodError)
+            return reply
+                .code(400)
+                .send({ message: "The control request was invalid" });
+        if (error instanceof BotControlValidationError)
+            return reply.code(400).send({ message: error.message });
+        if (error instanceof DashboardActionValidationError)
+            return reply.code(400).send({ message: error.message });
+        if (error instanceof ModuleStateValidationError)
+            return reply.code(400).send({ message: error.message });
+        if (error instanceof BotControlNotFoundError)
+            return reply.code(404).send({ message: error.message });
+        if (error instanceof OptimisticConcurrencyError)
+            return reply.code(409).send({
+                message: "Configuration changed in another session. Reload and try again.",
+            });
+        const safeError = error instanceof Error
+            ? { name: error.name, message: error.message }
+            : { name: "Error", message: "Unknown control failure" };
+        request.log.error({ error: safeError }, "Private bot control request failed");
+        return reply.code(500).send({ message: "The control request failed" });
+    });
+    return server;
+}
+class BotControlValidationError extends Error {
+}
+class BotControlNotFoundError extends Error {
+    constructor(message = "Discord server is not available to Helyx") {
+        super(message);
+        this.name = "BotControlNotFoundError";
+    }
+}
+function digest(value) {
+    return createHash("sha256").update(value).digest();
+}
+function isUnknownGuildError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === 10_004);
+}
+function mapDashboardModule(module) {
+    const dashboard = module.manifest.dashboard;
+    return {
+        id: module.manifest.id,
+        name: module.manifest.name,
+        version: module.manifest.version,
+        summary: module.manifest.description,
+        category: dashboard.category[0].toUpperCase() + dashboard.category.slice(1),
+        icon: dashboard.icon,
+        availability: "available",
+        requiredPermissions: [...module.manifest.permissions],
+        settings: dashboard.settings,
+        commands: dashboardCommands(module),
+        logEvents: (module.logging?.events ?? []).map((event) => ({ ...event })),
+        actions: (dashboard.actions ?? []).map((action) => ({ ...action })),
+    };
+}
+function dashboardCommands(module) {
+    return (module.interactions?.commands ?? []).flatMap((command) => command.subcommands?.length
+        ? command.subcommands.map((subcommand) => {
+            const id = `${command.name}.${subcommand.name}`;
+            return {
+                id,
+                name: `/${command.name} ${subcommand.name}`,
+                description: subcommand.description,
+                defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[id] ??
+                    module.defaultPermissions?.module ??
+                    emptyPolicy()).preset,
+            };
+        })
+        : [
+            {
+                id: command.name,
+                name: `/${command.name}`,
+                description: command.description,
+                defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[command.name] ??
+                    module.defaultPermissions?.module ??
+                    emptyPolicy()).preset,
+            },
+        ]);
+}
+function toDashboardPolicy(policy) {
+    const preset = policy.everyone
+        ? "everyone"
+        : policy.allowedRoleIds.length > 0 &&
+            policy.requiredPermissions.length === 0
+            ? "custom"
+            : policy.requiredPermissions.some((permission) => ["ADMINISTRATOR", "MANAGE_GUILD"].includes(permission))
+                ? "administrators"
+                : policy.requiredPermissions.length > 0
+                    ? "moderators"
+                    : "custom";
+    return {
+        preset,
+        allowedRoleIds: [...policy.allowedRoleIds],
+        deniedRoleIds: [...policy.deniedRoleIds],
+    };
+}
+function fromDashboardPolicy(input, current) {
+    return {
+        everyone: input.preset === "everyone",
+        requiredPermissions: input.preset === "administrators"
+            ? ["MANAGE_GUILD"]
+            : input.preset === "moderators"
+                ? ["MANAGE_MESSAGES"]
+                : [],
+        allowedRoleIds: input.preset === "custom" ? input.allowedRoleIds : [],
+        deniedRoleIds: input.deniedRoleIds,
+        allowedUserIds: [...current.allowedUserIds],
+        deniedUserIds: [...current.deniedUserIds],
+    };
+}
+function emptyPolicy() {
+    return {
+        everyone: false,
+        requiredPermissions: [],
+        allowedRoleIds: [],
+        deniedRoleIds: [],
+        allowedUserIds: [],
+        deniedUserIds: [],
+    };
+}
+function safeVersion(version) {
+    const value = Number(version);
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error("Configuration version exceeded the supported range");
+    return value;
+}
+function safeOptionalVersion(version) {
+    return version === null ? 0 : safeVersion(version);
+}
+function assertVersion(actual, requested) {
+    if (safeOptionalVersion(actual) !== requested)
+        throw new OptimisticConcurrencyError("Permission policy");
+}
+//# sourceMappingURL=control-server.js.map

package/dist/events.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleDefinition, ServiceAccess } from "@helyx/sdk";
+import { type Client, type MessageReaction, type PartialMessageReaction } from "discord.js";
+import { type InteractionLogger } from "./interactions.js";
+export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess): void;
+export declare function reactionEmojiKey(reaction: MessageReaction | PartialMessageReaction): string;
+export declare function reactionCacheKey(emojiIdentifier: string): string;
+//# sourceMappingURL=events.d.ts.map