@helyx/bot 0.1.3 → 0.2.1

package/dist/cloud-control-dispatcher.js

@@ -0,0 +1,250 @@
+import { assertCloudResponseSize, parseOperationInput, } from "@helyx/control-protocol";
+import { CloudConnectorRepository } from "@helyx/database";
+export class CloudControlDispatcher {
+    database;
+    control;
+    constructor(database, control) {
+        this.database = database;
+        this.control = control;
+    }
+    async execute(request, correlationId) {
+        const actorUserId = request.actor.kind === "customer"
+            ? request.actor.accountUserId
+            : undefined;
+        let result;
+        switch (request.operation) {
+            case "installation.health.read.v1":
+                parseOperationInput(request.operation, request.input);
+                result = {
+                    status: "online",
+                    observedAt: new Date().toISOString(),
+                };
+                break;
+            case "guild.state.read.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.getGuildState(input.guildId);
+                break;
+            }
+            case "guild.module.status.write.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.setModuleStatus({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "guild.module.configuration.write.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.updateConfiguration({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "guild.module.permissions.write.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.updatePermissions({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "guild.module.logging.write.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.updateLoggingPolicy({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "guild.module.action.execute.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.executeDashboardAction({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "support.guild.snapshot.read.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                if (request.actor.kind !== "helyx_staff")
+                    throw new CloudControlDeniedError("staff_actor_required");
+                result = await this.#supportSnapshot({
+                    ...input,
+                    actorReference: request.actor.assignmentId,
+                    purpose: request.actor.purpose,
+                    correlationId,
+                });
+                break;
+            }
+        }
+        assertCloudResponseSize(result);
+        return result;
+    }
+    async #supportSnapshot(input) {
+        const repository = new CloudConnectorRepository(this.database);
+        const consent = await repository.getConsent();
+        const requested = input.dataClasses.filter((dataClass) => consent.supportDataClasses.includes(dataClass));
+        if (!consent.supportInspectionEnabled || requested.length === 0) {
+            await repository.appendAudit({
+                action: "support.snapshot.read",
+                source: "cloud",
+                outcome: "denied",
+                actorReference: input.actorReference,
+                guildId: input.guildId,
+                bindingId: input.bindingId,
+                purpose: input.purpose,
+                dataClasses: input.dataClasses,
+                safeReasonCode: "support_inspection_not_consented",
+                correlationId: input.correlationId,
+            });
+            throw new CloudControlDeniedError("support_inspection_not_consented");
+        }
+        try {
+            const state = await this.control.getGuildState(input.guildId);
+            const result = buildSupportSnapshot(state, requested, input.guildId);
+            await repository.appendAudit({
+                action: "support.snapshot.read",
+                source: "cloud",
+                outcome: "succeeded",
+                actorReference: input.actorReference,
+                guildId: input.guildId,
+                bindingId: input.bindingId,
+                purpose: input.purpose,
+                dataClasses: requested,
+                correlationId: input.correlationId,
+            });
+            return result;
+        }
+        catch (error) {
+            await repository.appendAudit({
+                action: "support.snapshot.read",
+                source: "cloud",
+                outcome: "failed",
+                actorReference: input.actorReference,
+                guildId: input.guildId,
+                bindingId: input.bindingId,
+                purpose: input.purpose,
+                dataClasses: requested,
+                safeReasonCode: "snapshot_failed",
+                correlationId: input.correlationId,
+            });
+            throw error;
+        }
+    }
+}
+export class CloudControlDeniedError extends Error {
+    safeReasonCode;
+    constructor(safeReasonCode) {
+        super("Cloud Connect request was denied by the local policy");
+        this.safeReasonCode = safeReasonCode;
+        this.name = "CloudControlDeniedError";
+    }
+}
+export function buildSupportSnapshot(state, dataClasses, guildId) {
+    const include = new Set(dataClasses);
+    const includeModules = [
+        "module_inventory",
+        "configuration",
+        "permissions",
+        "logging",
+    ].some((dataClass) => include.has(dataClass));
+    return {
+        guildId,
+        observedAt: new Date().toISOString(),
+        dataClasses,
+        ...(includeModules
+            ? {
+                modules: state.modules.map((module) => {
+                    const configuration = state.configurations[module.id];
+                    const fields = module.settings.map((setting) => {
+                        const visibility = "supportVisibility" in Object(setting)
+                            ? (setting.supportVisibility ?? "hidden")
+                            : "hidden";
+                        if (!include.has("configuration") || visibility === "hidden")
+                            return {
+                                key: settingKey(setting),
+                                state: "omitted",
+                            };
+                        const key = settingKey(setting);
+                        const value = configuration?.value[key];
+                        if (visibility === "set_only")
+                            return {
+                                key,
+                                state: "redacted",
+                                isSet: value !== undefined && value !== "" && value !== null,
+                            };
+                        return value === undefined
+                            ? { key, state: "unavailable" }
+                            : { key, state: "value", value };
+                    });
+                    const permission = state.permissions[module.id];
+                    return {
+                        id: module.id,
+                        version: module.version,
+                        enabled: state.moduleStatuses[module.id] === "enabled",
+                        ...(include.has("configuration")
+                            ? {
+                                configuration: {
+                                    version: configuration?.version ?? null,
+                                    fields,
+                                },
+                            }
+                            : {}),
+                        ...(include.has("permissions") && permission
+                            ? {
+                                permissions: {
+                                    modulePreset: permission.module.preset,
+                                    allowedRoleCount: permission.module.allowedRoleIds.length,
+                                    deniedRoleCount: permission.module.deniedRoleIds.length,
+                                    commands: permission.commands.map((command) => ({
+                                        commandId: command.commandId,
+                                        inherited: !command.enabled,
+                                        preset: command.policy.preset,
+                                        allowedRoleCount: command.policy.allowedRoleIds.length,
+                                        deniedRoleCount: command.policy.deniedRoleIds.length,
+                                    })),
+                                },
+                            }
+                            : {}),
+                        ...(include.has("logging")
+                            ? {
+                                logging: (state.logging[module.id] ?? []).map((event) => ({
+                                    eventId: event.eventId,
+                                    enabled: event.enabled,
+                                    version: event.version,
+                                })),
+                            }
+                            : {}),
+                    };
+                }),
+            }
+            : {}),
+        ...(include.has("health")
+            ? {
+                health: {
+                    state: "available",
+                    moduleCount: state.modules.length,
+                },
+            }
+            : {}),
+    };
+}
+function settingKey(setting) {
+    if (typeof setting !== "object" ||
+        setting === null ||
+        typeof setting.key !== "string")
+        return "unknown";
+    return setting.key;
+}
+function requiredActor(value) {
+    if (!value)
+        throw new CloudControlDeniedError("customer_actor_required");
+    return value;
+}
+//# sourceMappingURL=cloud-control-dispatcher.js.map

package/dist/cloud-management-module.d.ts

@@ -0,0 +1,9 @@
+import { type ModuleDefinition } from "@helyx/sdk";
+import type { Client } from "discord.js";
+import type { CloudConnectorController } from "./cloud-connector.js";
+export declare function createCloudManagementModule(input: {
+    connector: CloudConnectorController;
+    client: Client;
+    configuredOwnerUserIds: readonly string[];
+}): ModuleDefinition;
+//# sourceMappingURL=cloud-management-module.d.ts.map