@helyx/bot 0.3.0 → 0.4.1

package/dist/interactions.d.ts

@@ -1,5 +1,5 @@
 import type { CommandContribution, MessageResponse, ModalDefinition, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
-import { ModalBuilder, type Client, type InteractionReplyOptions, type InteractionUpdateOptions } from "discord.js";
+import { ModalBuilder, type ChatInputCommandInteraction, type Client, type InteractionReplyOptions, type InteractionUpdateOptions } from "discord.js";
 export interface InteractionLogger {
     info(fields: Record<string, unknown>, message: string): void;
     warn(fields: Record<string, unknown>, message: string): void;
@@ -8,8 +8,14 @@ export interface InteractionLogger {
 export interface CommandRegistration {
     internalGuildId?: string;
     prepare?(client: Client<true>): Promise<void>;
+    synchronise?: boolean;
+    selfAuthorizingGuildModuleIds?: ReadonlySet<string>;
 }
 export declare function installInteractions(client: Client, modules: readonly ModuleDefinition[], registration: CommandRegistration, logger: InteractionLogger, services: ServiceAccess): Promise<void>;
+export declare function buildApplicationCommandDefinitions(modules: readonly ModuleDefinition[], internalGuildId?: string): {
+    global: ReturnType<typeof toCommandDefinition>[];
+    guild: ReturnType<typeof toCommandDefinition>[];
+};
 export declare function resolveCommandExecutor(command: CommandContribution, subcommandName: string | null): CommandContribution["execute"];
 export declare function toCommandDefinition(registered: {
     contribution: CommandContribution;
@@ -20,6 +26,7 @@ export declare function sendToChannel(client: Client, channelId: string, respons
 }>;
 export declare function deleteChannelMessage(client: Client, channelId: string, messageId: string): Promise<void>;
 export declare function editChannelMessage(client: Client, channelId: string, messageId: string, response: MessageResponse): Promise<void>;
+export declare function authorizeCommand(interaction: ChatInputCommandInteraction, moduleId: string, commandId: string, rateLimit: CommandContribution["rateLimit"], services: ServiceAccess, selfAuthorizingGuildCommand: boolean): Promise<boolean>;
 export declare function normalizeDiscordPermission(permission: string): string;
 export declare function toReplyOptions(response: MessageResponse): InteractionReplyOptions;
 export declare function toUpdateOptions(response: MessageResponse): InteractionUpdateOptions;

package/dist/interactions.js

@@ -42,6 +42,10 @@ export function installInteractions(client, modules, registration, logger, servi
         });
         async function registerCommands() {
             await registration.prepare?.(readyClient);
+            if (registration.synchronise === false) {
+                logger.info({ event: "commands.registration_delegated" }, "Application command registration is owned by the supervisor");
+                return;
+            }
             const globalDefinitions = globalCommands.map(toCommandDefinition);
             await readyClient.application.commands.set(globalDefinitions);
             if (registration.internalGuildId) {
@@ -94,7 +98,8 @@ export function installInteractions(client, modules, registration, logger, servi
                     const commandId = subcommandName
                         ? `${command.name}.${subcommandName}`
                         : command.name;
-                    if (await authorizeCommand(interaction, moduleId, commandId, subcommand?.rateLimit ?? command.rateLimit, services)) {
+                    if (await authorizeCommand(interaction, moduleId, commandId, subcommand?.rateLimit ?? command.rateLimit, services, registration.selfAuthorizingGuildModuleIds?.has(moduleId) ??
+                        false)) {
                         const context = createCommandContext(interaction, services);
                         await execute(context);
                     }
@@ -143,6 +148,21 @@ export function installInteractions(client, modules, registration, logger, servi
     }
     return registrationReady;
 }
+export function buildApplicationCommandDefinitions(modules, internalGuildId) {
+    const commands = uniqueMap(modules.flatMap((module) => (module.interactions?.commands ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    }))), ({ contribution }) => contribution.name, "command name");
+    const global = [...commands.values()]
+        .filter(({ contribution }) => contribution.registration === "global")
+        .map(toCommandDefinition);
+    const guild = [...commands.values()]
+        .filter(({ contribution }) => contribution.registration === "guild")
+        .map(toCommandDefinition);
+    if (guild.length > 0 && !internalGuildId)
+        throw new Error("DISCORD_INTERNAL_GUILD_ID is required when guild commands are loaded");
+    return { global, guild };
+}
 export function resolveCommandExecutor(command, subcommandName) {
     if (command.subcommands?.length) {
         if (!subcommandName)
@@ -249,6 +269,8 @@ function createContext(interaction, services) {
         userRoleIds: interaction.member instanceof GuildMember
             ? [...interaction.member.roles.cache.keys()]
             : (interaction.member?.roles ?? []),
+        isAdministrator: interaction.memberPermissions?.has(PermissionFlagsBits.Administrator) ??
+            false,
         ...(interaction.guildId ? { serverId: interaction.guildId } : {}),
         ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
         ...(interaction.isButton() ? { messageId: interaction.message.id } : {}),
@@ -309,6 +331,8 @@ function createModalContext(interaction, services) {
         userRoleIds: interaction.member instanceof GuildMember
             ? [...interaction.member.roles.cache.keys()]
             : (interaction.member?.roles ?? []),
+        isAdministrator: interaction.memberPermissions?.has(PermissionFlagsBits.Administrator) ??
+            false,
         ...(interaction.guildId ? { serverId: interaction.guildId } : {}),
         ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
         services,
@@ -407,31 +431,33 @@ async function replyEphemeralText(interaction, content) {
     }
     await interaction.reply({ content, flags: MessageFlags.Ephemeral });
 }
-async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services) {
+export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand) {
     if (!interaction.guildId)
         return true;
-    if (!(await authorizeComponent(interaction, moduleId, services)))
-        return false;
-    const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
-    const policy = await permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId);
-    const actor = {
-        userId: interaction.user.id,
-        roleIds: interaction.member instanceof GuildMember
-            ? [...interaction.member.roles.cache.keys()]
-            : (interaction.member?.roles ?? []),
-        permissions: interaction.memberPermissions
-            ?.toArray()
-            .map(normalizeDiscordPermission) ?? [],
-        isServerOwner: interaction.guild?.ownerId === interaction.user.id,
-        isAdministrator: interaction.memberPermissions?.has(PermissionFlagsBits.Administrator) ??
-            false,
-    };
-    if (!canUseCommand(actor, policy)) {
-        await interaction.reply({
-            content: "You do not have permission to use this command.",
-            flags: MessageFlags.Ephemeral,
-        });
-        return false;
+    if (!selfAuthorizingGuildCommand) {
+        if (!(await authorizeComponent(interaction, moduleId, services)))
+            return false;
+        const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
+        const policy = await permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId);
+        const actor = {
+            userId: interaction.user.id,
+            roleIds: interaction.member instanceof GuildMember
+                ? [...interaction.member.roles.cache.keys()]
+                : (interaction.member?.roles ?? []),
+            permissions: interaction.memberPermissions
+                ?.toArray()
+                .map(normalizeDiscordPermission) ?? [],
+            isServerOwner: interaction.guild?.ownerId === interaction.user.id,
+            isAdministrator: interaction.memberPermissions?.has(PermissionFlagsBits.Administrator) ??
+                false,
+        };
+        if (!canUseCommand(actor, policy)) {
+            await interaction.reply({
+                content: "You do not have permission to use this command.",
+                flags: MessageFlags.Ephemeral,
+            });
+            return false;
+        }
     }
     if (rateLimit) {
         const limits = services.get(HELYX_SERVICE_NAMES.rateLimits);

package/dist/shard-cloud-proxy.d.ts

@@ -0,0 +1,21 @@
+import type { CloudConnectorConsentRecord } from "@helyx/database";
+import type { CloudConnector, CloudConnectorStatus } from "./cloud-connector.js";
+import { type ShardCloudResponse } from "./shard-contracts.js";
+export declare class WorkerCloudConnectorProxy implements CloudConnector {
+    #private;
+    setControlHandler(): void;
+    start(): Promise<void>;
+    status(): CloudConnectorStatus;
+    getSupportConsent(): Promise<CloudConnectorConsentRecord>;
+    updateSupportConsent(input: {
+        supportInspectionEnabled: boolean;
+        supportDataClasses: string[];
+        diagnosticsEnabled: boolean;
+    }): Promise<CloudConnectorConsentRecord>;
+    enrol(token: string, source: "startup" | "discord" | "file"): Promise<CloudConnectorStatus>;
+    disconnect(): Promise<void>;
+    rotate(): Promise<CloudConnectorStatus>;
+    stop(): Promise<void>;
+    accept(response: ShardCloudResponse): void;
+}
+//# sourceMappingURL=shard-cloud-proxy.d.ts.map

package/dist/shard-cloud-proxy.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { SHARD_CONTROL_TIMEOUT_MS, assertShardMessageSize, shardCloudResponseSchema, } from "./shard-contracts.js";
+export class WorkerCloudConnectorProxy {
+    #pending = new Map();
+    #status = { state: "offline" };
+    setControlHandler() { }
+    async start() {
+        this.#status = parseStatus(await this.#request({ kind: "cloud.status" }));
+    }
+    status() {
+        return this.#status;
+    }
+    async getSupportConsent() {
+        return parseConsent(await this.#request({ kind: "cloud.consent.get" }));
+    }
+    async updateSupportConsent(input) {
+        return parseConsent(await this.#request({ kind: "cloud.consent.update", ...input }));
+    }
+    async enrol(token, source) {
+        this.#status = parseStatus(await this.#request({ kind: "cloud.enrol", token, source }));
+        return this.#status;
+    }
+    async disconnect() {
+        await this.#request({ kind: "cloud.disconnect" });
+        this.#status = { state: "unpaired" };
+    }
+    async rotate() {
+        this.#status = parseStatus(await this.#request({ kind: "cloud.rotate" }));
+        return this.#status;
+    }
+    stop() {
+        for (const pending of this.#pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Shard worker is stopping"));
+        }
+        this.#pending.clear();
+        return Promise.resolve();
+    }
+    accept(response) {
+        const accepted = shardCloudResponseSchema.parse(response);
+        const pending = this.#pending.get(accepted.requestId);
+        if (!pending)
+            return;
+        this.#pending.delete(accepted.requestId);
+        clearTimeout(pending.timer);
+        if (accepted.ok)
+            pending.resolve(accepted.result);
+        else
+            pending.reject(new Error(accepted.message));
+    }
+    async #request(operation) {
+        if (!process.send)
+            throw new Error("Shard supervisor IPC is unavailable");
+        const requestId = randomUUID();
+        const message = {
+            version: 1,
+            type: "helyx.cloud.request",
+            requestId,
+            deadlineAt: new Date(Date.now() + SHARD_CONTROL_TIMEOUT_MS).toISOString(),
+            operation,
+        };
+        assertShardMessageSize(message);
+        const response = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#pending.delete(requestId);
+                reject(new Error("Cloud supervisor request timed out"));
+            }, SHARD_CONTROL_TIMEOUT_MS);
+            timer.unref();
+            this.#pending.set(requestId, { resolve, reject, timer });
+        });
+        process.send(message);
+        return response;
+    }
+}
+function parseStatus(value) {
+    if (typeof value !== "object" || value === null || !("state" in value))
+        throw new Error("Cloud supervisor returned an invalid status");
+    const raw = value;
+    return {
+        state: raw.state,
+        ...(raw.installationId ? { installationId: raw.installationId } : {}),
+        ...(raw.lastConnectedAt
+            ? { lastConnectedAt: new Date(raw.lastConnectedAt) }
+            : {}),
+        ...(raw.lastErrorCode ? { lastErrorCode: raw.lastErrorCode } : {}),
+    };
+}
+function parseConsent(value) {
+    if (typeof value !== "object" || value === null || !("updatedAt" in value))
+        throw new Error("Cloud supervisor returned invalid consent");
+    const consent = value;
+    return { ...consent, updatedAt: new Date(consent.updatedAt) };
+}
+//# sourceMappingURL=shard-cloud-proxy.js.map