@helyx/bot 1.0.1 → 1.2.0

package/dist/control-server.js

@@ -12,13 +12,18 @@ import { mutateDashboardModuleStatus, } from "./module-status-control.js";
 import { canAccessModule, PREMIUM_MODULE_UNAVAILABLE_MESSAGE, } from "./premium-access.js";
 import { completeFirstTimeCommandSetup, } from "./first-time-command-setup.js";
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.js";
-import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
+import { assertVersion, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
 import { assertPermissionMutationAllowed, BotControlForbiddenError, } from "./control-errors.js";
 import { dashboardCommands } from "./dashboard-commands.js";
 import { mapDashboardModule, } from "./dashboard-module-projection.js";
 import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, statusCatalogueDefinitions, } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
 import { createPrivacyProviderRegistry, describePrivacyProviders, } from "./privacy-provider-registry.js";
+import { changedSettingFeatureIds, configurationPreviewFeatureIds, hasBoundedManagedResourceBytes, isBoundedManagedResourceValue, managedResourceColumnKeys, normalizeManagedResourceDetail, normalizeManagedResourcePage, normalizeManagedResourceRelationPage, projectManagedResourceObject, requireDashboardFeatures, resourceFieldFeatureIds, scalarInputFeatureIds, validateManagedResourceInput, } from "./dashboard-feature-control.js";
+import { registerDashboardPreviewImportRoutes, registerDashboardResourceMutationRoutes, } from "./dashboard-preview-import-routes.js";
+import { executeDashboardAction as executeDeclaredDashboardAction, previewDashboardAction as previewDeclaredDashboardAction, } from "./dashboard-action-control.js";
+import { registerDashboardActionRoutes, } from "./dashboard-action-routes.js";
+import { registerEckoTransportRoutes, } from "./ecko-transport-routes.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 MAX_DISCORD_SETTING_SELECTIONS = 25;
@@ -444,6 +449,7 @@ export class BotControlService {
         const configurations = {};
         const permissions = {};
         const logging = {};
+        const featureAccess = {};
         const loggingPolicies = new Map(storedLoggingPolicies.map((policy) => [
             `${policy.sourceModuleId}:${policy.eventId}`,
             policy,
@@ -466,6 +472,22 @@ export class BotControlService {
                     version: stored ? safeVersion(stored.version) : 0,
                 };
             });
+            if (module.manifest.manifestVersion === "0.5" &&
+                module.manifest.features.length > 0) {
+                const access = this.#services.has(HELYX_SERVICE_NAMES.featureAccess)
+                    ? this.#services.get(HELYX_SERVICE_NAMES.featureAccess)
+                    : undefined;
+                featureAccess[dashboardModule.id] = Object.fromEntries(await Promise.all(module.manifest.features.map(async (feature) => [
+                    feature.id,
+                    access
+                        ? (await access.check({
+                            guildId,
+                            moduleId: module.manifest.id,
+                            featureId: feature.id,
+                        })).decision
+                        : "dependency_unhealthy",
+                ])));
+            }
         }
         return {
             discordCapabilities: {
@@ -473,6 +495,7 @@ export class BotControlService {
             },
             ...resources,
             modules: structuredClone(this.#dashboardModules),
+            featureAccess,
             moduleStatuses,
             globallyDisabledModuleIds: disabledModules.ids,
             configurations,
@@ -652,6 +675,15 @@ export class BotControlService {
     async updateConfiguration(input) {
         const module = this.#requireDashboardModule(input.moduleId);
         await this.#requireModuleAccessible(input.guildId, input.moduleId);
+        const settingsPermissionId = module.manifest.manifestVersion === "0.5"
+            ? module.manifest.dashboard?.settingsMutationPermissionId
+            : undefined;
+        if (settingsPermissionId)
+            await this.#authorizeAction(input.guildId, module, input.actorUserId, settingsPermissionId);
+        if (module.manifest.manifestVersion === "0.5") {
+            const current = await this.#configurations.get(input.guildId, input.moduleId);
+            await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, changedSettingFeatureIds(module.manifest.dashboard?.settings ?? [], current?.value ?? {}, input.value));
+        }
         await this.#validateDiscordSettings(input.guildId, module, input.value);
         if (module.configuration?.validateUpdate) {
             try {
@@ -683,6 +715,25 @@ export class BotControlService {
         });
         return { value: saved.value, version: safeVersion(saved.version) };
     }
+    async previewConfiguration(input) {
+        const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, input.moduleId);
+        const declaration = module.manifest.manifestVersion === "0.5"
+            ? module.manifest.dashboard?.settingsPreview
+            : undefined;
+        if (!declaration || !module.configuration?.settingsPreview)
+            throw new BotControlNotFoundError("Module settings preview is not declared by this module");
+        const actor = await this.#authorizeAction(input.guildId, module, input.actorUserId, declaration.permissionId);
+        validateManagedResourceInput(declaration.inputs, input.input);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, await configurationPreviewFeatureIds(this.#configurations, input.guildId, module, declaration, input));
+        const value = module.configuration.validate(input.value);
+        return managedResourceObject.parse(await module.configuration.settingsPreview({
+            guildId: input.guildId,
+            actor,
+            correlationId: input.correlationId,
+            services: this.#services,
+        }, { value, input: input.input }));
+    }
     async updatePermissions(input) {
         const module = this.#requireDashboardModule(input.moduleId);
         await this.#requireModuleAccessible(input.guildId, input.moduleId);
@@ -856,31 +907,28 @@ export class BotControlService {
         };
     }
     async executeDashboardAction(input) {
-        const module = this.#requireDashboardModule(input.moduleId);
-        await this.#requireModuleAccessible(input.guildId, 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");
-        }
-        const [enabled] = await Promise.all([
-            new InstallationRepository(this.database).isModuleEnabled(input.guildId, input.moduleId),
-            this.#authorizeAction(input.guildId, module, input.actorUserId, dashboardActionPermissionId(module, input.actionId)),
-        ]);
-        if (!enabled) {
-            throw new BotControlValidationError("Enable this module before running its dashboard actions");
-        }
-        return action.execute({
-            guildId: input.guildId,
-            actorUserId: input.actorUserId,
-            correlationId: input.correlationId,
+        return executeDeclaredDashboardAction(input, this.#dashboardActionControl());
+    }
+    async previewDashboardAction(input) {
+        return previewDeclaredDashboardAction(input, this.#dashboardActionControl());
+    }
+    #dashboardActionControl() {
+        return {
+            database: this.database,
             services: this.#services,
+            requireDashboardModule: (moduleIdValue) => this.#requireDashboardModule(moduleIdValue),
+            requireModuleAccessible: (guildId, moduleIdValue) => this.#requireModuleAccessible(guildId, moduleIdValue),
+            authorizeAction: (guildId, module, actorUserId, permissionId) => this.#authorizeAction(guildId, module, actorUserId, permissionId),
             sendToChannel: (channelId, response) => this.resources.sendToChannel(channelId, response),
             deleteChannelMessage: (channelId, messageId) => this.resources.deleteChannelMessage(channelId, messageId),
-        });
+            notFound: (message) => new BotControlNotFoundError(message),
+            invalid: (message) => new BotControlValidationError(message),
+        };
     }
     async listManagedResources(input) {
         const { module, resource } = this.#prepareManagedResource(input);
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [declaration?.featureId]);
         this.#requireManagedResourceOperation(module, input.resourceType, "list");
         this.#validateManagedResourceQuery(module, input.resourceType, input);
         const result = await resource.list(await this.#managedResourceContext(input, module, "list"), {
@@ -893,6 +941,8 @@ export class BotControlService {
     }
     async readManagedResource(input) {
         const { module, resource } = this.#prepareManagedResource(input);
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [declaration?.featureId]);
         this.#requireManagedResourceOperation(module, input.resourceType, "read");
         const result = await resource.read(await this.#managedResourceContext(input, module, "read"), input.resourceId);
         if (!result)
@@ -907,6 +957,8 @@ export class BotControlService {
             ?.relations?.find(({ id }) => id === input.relationId);
         if (!relation || !resource.listRelation)
             throw new BotControlNotFoundError("Managed resource relation is not declared by this module");
+        const resourceDeclaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [resourceDeclaration?.featureId, relation.featureId]);
         const context = await this.#managedResourceContext(input, module, "read", relation.permissionId);
         return normalizeManagedResourceRelationPage(managedResourceRelationPageSchema.parse(await resource.listRelation(context, input.resourceId, input.relationId, {
             ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
@@ -919,14 +971,44 @@ export class BotControlService {
         await this.#requireModuleAccessible(input.guildId, input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "preview");
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [
+            declaration?.featureId,
+            ...resourceFieldFeatureIds(declaration?.fields ?? [], input.value),
+        ]);
         return resource.preview(await this.#managedResourceContext(input, module, "preview"), input.value);
     }
+    async importManagedResource(input) {
+        await this.#requireModuleAccessible(input.guildId, input.moduleId);
+        const { module, resource } = this.#prepareManagedResource(input);
+        this.#requireManagedResourceOperation(module, input.resourceType, "import");
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        if (!declaration || !("import" in declaration) || !declaration.import)
+            throw new BotControlNotFoundError("Managed resource import is not declared by this module");
+        if (!resource.import)
+            throw new BotControlNotFoundError("Managed resource import is not implemented by this module");
+        if (Buffer.byteLength(input.content, "utf8") > declaration.import.maxBytes)
+            throw new BotControlValidationError("Managed resource import exceeds the declared byte limit");
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [declaration.featureId, declaration.import.featureId]);
+        const result = await resource.import(await this.#managedResourceContext(input, module, "import"), { format: input.format, content: input.content });
+        const value = managedResourceObject.parse(result.value);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, resourceFieldFeatureIds(declaration.fields, value));
+        return {
+            value: projectManagedResourceObject(value, declaration.fields.map(({ key }) => key)),
+            preview: managedResourceObject.parse(result.preview),
+        };
+    }
     async createManagedResource(input) {
         await this.#requireModuleAccessible(input.guildId, input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "create");
         const context = await this.#managedResourceContext(input, module, "create");
-        const declaredIntents = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType)?.creationIntents ?? ["publish"];
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [
+            declaration?.featureId,
+            ...resourceFieldFeatureIds(declaration?.fields ?? [], input.value),
+        ]);
+        const declaredIntents = declaration?.creationIntents ?? ["publish"];
         if (!declaredIntents.includes(input.intent))
             throw new DashboardActionValidationError("This creation intent is not declared by the module.");
         return normalizeManagedResourceDetail(managedResourceDetailSchema.parse(await resource.create(context, input.value, input.intent)), managedResourceColumnKeys(module, input.resourceType));
@@ -935,6 +1017,11 @@ export class BotControlService {
         await this.#requireModuleAccessible(input.guildId, input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "update");
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [
+            declaration?.featureId,
+            ...resourceFieldFeatureIds(declaration?.fields ?? [], input.value),
+        ]);
         return normalizeManagedResourceDetail(managedResourceDetailSchema.parse(await resource.update(await this.#managedResourceContext(input, module, "update"), {
             resourceId: input.resourceId,
             expectedRevision: input.expectedRevision,
@@ -945,6 +1032,8 @@ export class BotControlService {
         await this.#requireModuleAccessible(input.guildId, input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "delete");
+        const declaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [declaration?.featureId]);
         return managedResourceDeleteResultSchema.parse(await resource.delete(await this.#managedResourceContext(input, module, "delete"), {
             resourceId: input.resourceId,
             expectedRevision: input.expectedRevision,
@@ -961,7 +1050,13 @@ export class BotControlService {
             throw new BotControlNotFoundError("Managed resource action is not declared by this module");
         const permissionId = managedResourcePermissionId(module, input.resourceType, "action", input.actionId, declared.permissionId);
         const context = await this.#managedResourceContext(input, module, "action", permissionId);
-        validateManagedResourceActionValue(declared.inputs ?? [], input.value);
+        validateManagedResourceInput(declared.inputs ?? [], input.value);
+        const resourceDeclaration = module.manifest.dashboard?.resources?.find(({ id }) => id === input.resourceType);
+        await requireDashboardFeatures(this.#services, input.guildId, input.moduleId, [
+            resourceDeclaration?.featureId,
+            declared.featureId,
+            ...scalarInputFeatureIds(declared.inputs ?? [], input.value),
+        ]);
         const result = await resource.executeAction(context, {
             resourceId: input.resourceId,
             actionId: input.actionId,
@@ -1207,9 +1302,13 @@ export async function createBotControlServer(input) {
         requestTimeout: 15_000,
     });
     const expectedSecret = digest(input.secret);
+    if (input.ecko)
+        server.addContentTypeParser("application/ecko+json", { parseAs: "buffer", bodyLimit: 256 * 1_024 }, (_request, body, done) => done(null, body));
     server.addHook("onRequest", async (request, reply) => {
         if (request.url === "/health")
             return;
+        if (input.ecko && request.url.startsWith("/v1/ecko/"))
+            return;
         const authorization = request.headers.authorization;
         const supplied = authorization?.startsWith("Bearer ")
             ? authorization.slice("Bearer ".length)
@@ -1240,7 +1339,27 @@ export async function createBotControlServer(input) {
     }
     server.get("/health", (_request, reply) => readiness(reply));
     server.get("/v1/health", (_request, reply) => readiness(reply));
+    server.get("/v1/runtime-configuration", (_request, reply) => reply.header("Cache-Control", "no-store").send({
+        hostedModerationEnabled: input.runtimeConfiguration?.hostedModerationEnabled ?? false,
+    }));
+    server.post("/v1/hosted-server-moderation/leave/deliver", async (request) => {
+        if (!input.deliverHostedServerLeave)
+            throw new BotControlTransportError(503, "Hosted server moderation delivery is unavailable");
+        const body = z
+            .object({ operationId: z.uuid(), guildId: snowflake })
+            .strict()
+            .parse(request.body);
+        return { outcome: await input.deliverHostedServerLeave(body) };
+    });
+    server.post("/v1/hosted-servers/:guildId/owner/refresh", async (request) => {
+        if (!input.refreshHostedServerOwner)
+            throw new BotControlTransportError(503, "Hosted server owner refresh is unavailable");
+        const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
+        return input.refreshHostedServerOwner(guildId);
+    });
     registerGuildCommandControlRoutes(server, input.guildCommands, input.service);
+    if (input.ecko)
+        registerEckoTransportRoutes(server, input.ecko);
     server.post("/v1/verification/results", async (request) => input.service.acceptVerificationResult(signedAssessmentEnvelopeSchema.parse(request.body)));
     server.post("/v1/oauth/consumers/cleanup", async (request) => {
         const body = z
@@ -1458,17 +1577,7 @@ export async function createBotControlServer(input) {
             .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 });
-    });
+    registerDashboardActionRoutes(server, input.service);
     server.get("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType", async (request) => {
         const params = z
             .object({
@@ -1570,104 +1679,8 @@ export async function createBotControlServer(input) {
             correlationId: query.correlationId,
         });
     });
-    server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/preview", async (request) => {
-        const params = z
-            .object({
-            guildId: snowflake,
-            moduleId,
-            resourceType: resourceActionId,
-        })
-            .strict()
-            .parse(request.params);
-        const body = mutationContext
-            .extend({ value: managedResourceObject })
-            .strict()
-            .parse(request.body);
-        return input.service.previewManagedResource({ ...params, ...body });
-    });
-    server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType", async (request) => {
-        const params = z
-            .object({
-            guildId: snowflake,
-            moduleId,
-            resourceType: resourceActionId,
-        })
-            .strict()
-            .parse(request.params);
-        const body = mutationContext
-            .extend({
-            intent: z.enum(["draft", "publish"]).optional().default("publish"),
-            value: managedResourceObject,
-        })
-            .strict()
-            .parse(request.body);
-        return input.service.createManagedResource({ ...params, ...body });
-    });
-    server.put("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/:resourceId", async (request) => {
-        const params = z
-            .object({
-            guildId: snowflake,
-            moduleId,
-            resourceType: resourceActionId,
-            resourceId,
-        })
-            .strict()
-            .parse(request.params);
-        const body = mutationContext
-            .extend({
-            expectedRevision: z.number().int().min(0),
-            value: managedResourceObject.optional().default({}),
-        })
-            .strict()
-            .parse(request.body);
-        return input.service.updateManagedResource({ ...params, ...body });
-    });
-    server.delete("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/:resourceId", async (request) => {
-        const params = z
-            .object({
-            guildId: snowflake,
-            moduleId,
-            resourceType: resourceActionId,
-            resourceId,
-        })
-            .strict()
-            .parse(request.params);
-        const body = mutationContext
-            .extend({ expectedRevision: z.number().int().min(0) })
-            .strict()
-            .parse(request.body);
-        return input.service.deleteManagedResource({ ...params, ...body });
-    });
-    server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/:resourceId/actions/:actionId", async (request) => {
-        const params = z
-            .object({
-            guildId: snowflake,
-            moduleId,
-            resourceType: resourceActionId,
-            resourceId,
-            actionId: resourceActionId,
-        })
-            .strict()
-            .parse(request.params);
-        const body = mutationContext
-            .extend({
-            expectedRevision: z.number().int().min(0),
-            value: managedResourceObject.optional().default({}),
-            actorAuthenticatedAt: z.iso.datetime({ offset: true }).optional(),
-        })
-            .strict()
-            .parse(request.body);
-        return input.service.executeManagedResourceAction({
-            ...params,
-            actorUserId: body.actorUserId,
-            correlationId: body.correlationId,
-            expectedRevision: body.expectedRevision,
-            value: body.value,
-            ...(body.actorAuthenticatedAt === undefined
-                ? {}
-                : { actorAuthenticatedAt: body.actorAuthenticatedAt }),
-        });
-    });
+    registerDashboardPreviewImportRoutes(server, input.service);
+    registerDashboardResourceMutationRoutes(server, input.service);
     server.put("/v1/guilds/:guildId/modules/:moduleId/configuration", async (request) => {
         const params = z
             .object({ guildId: snowflake, moduleId })
@@ -1711,7 +1724,12 @@ export async function createBotControlServer(input) {
             return reply.code(mapped.status).send({ message: mapped.message });
         if (error instanceof BotControlTransportError)
             return reply.code(error.status).send({ message: error.message });
-        request.log.error({ error: safeError(error) }, "Private bot control request failed");
+        request.log.error({
+            error: safeError(error),
+            errorCode: typeof error.code === "string"
+                ? error.code
+                : "unclassified",
+        }, "Private bot control request failed");
         return reply.code(500).send({ message: "The control request failed" });
     });
     return server;
@@ -1772,122 +1790,4 @@ function isUnknownMemberError(error) {
         "code" in error &&
         error.code === 10_007);
 }
-function isBoundedManagedResourceValue(value, depth = 0, budget = { keys: 0 }) {
-    if (depth > 8)
-        return false;
-    if (value === null ||
-        typeof value === "boolean" ||
-        (typeof value === "number" && Number.isFinite(value)))
-        return true;
-    if (typeof value === "string")
-        return value.length <= 4_000;
-    if (Array.isArray(value))
-        return (value.length <= 100 &&
-            value.every((item) => isBoundedManagedResourceValue(item, depth + 1, budget)));
-    if (typeof value !== "object")
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null)
-        return false;
-    const entries = Object.entries(value);
-    budget.keys += entries.length;
-    return (entries.length <= 100 &&
-        budget.keys <= 500 &&
-        entries.every(([key, item]) => key.length >= 1 &&
-            key.length <= 100 &&
-            isBoundedManagedResourceValue(item, depth + 1, budget)));
-}
-function hasBoundedManagedResourceBytes(value) {
-    return (new TextEncoder().encode(JSON.stringify(value)).byteLength <= 48 * 1_024);
-}
-function normalizeManagedResourceDetail(value, attributeKeys) {
-    return {
-        id: value.id,
-        revision: value.revision,
-        status: value.status,
-        title: value.title,
-        ...(value.description === undefined
-            ? {}
-            : { description: value.description }),
-        ...(value.attributes === undefined || attributeKeys.length === 0
-            ? {}
-            : {
-                attributes: projectManagedResourceObject(value.attributes, attributeKeys),
-            }),
-        updatedAt: value.updatedAt,
-        value: value.value,
-    };
-}
-function normalizeManagedResourcePage(value, attributeKeys) {
-    return {
-        items: value.items.map((item) => ({
-            id: item.id,
-            revision: item.revision,
-            status: item.status,
-            title: item.title,
-            ...(item.description === undefined
-                ? {}
-                : { description: item.description }),
-            ...(item.attributes === undefined || attributeKeys.length === 0
-                ? {}
-                : {
-                    attributes: projectManagedResourceObject(item.attributes, attributeKeys),
-                }),
-            updatedAt: item.updatedAt,
-        })),
-        ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
-        ...(value.total === undefined ? {} : { total: value.total }),
-    };
-}
-function normalizeManagedResourceRelationPage(value, valueKeys) {
-    return {
-        items: value.items.map((item) => ({
-            id: item.id,
-            value: projectManagedResourceObject(item.value, valueKeys),
-        })),
-        ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
-    };
-}
-function projectManagedResourceObject(value, declaredKeys) {
-    const allowed = new Set(declaredKeys);
-    return Object.fromEntries(Object.entries(value)
-        .filter(([key]) => allowed.has(key))
-        .map(([key, item]) => [key, structuredClone(item)]));
-}
-function managedResourceColumnKeys(module, resourceType) {
-    return (module.manifest.dashboard?.resources
-        ?.find(({ id }) => id === resourceType)
-        ?.columns?.map(({ key }) => key) ?? []);
-}
-function validateManagedResourceActionValue(inputs, value) {
-    const declared = new Map(inputs.map((input) => [input.key, input]));
-    for (const key of Object.keys(value))
-        if (!declared.has(key))
-            throw new DashboardActionValidationError(`The action value "${key}" is not declared by the module.`);
-    for (const input of inputs) {
-        const item = value[input.key];
-        if (item === undefined) {
-            if (input.required)
-                throw new DashboardActionValidationError(`${input.label} is required for this action.`);
-            continue;
-        }
-        const valid = input.type === "boolean"
-            ? typeof item === "boolean"
-            : input.type === "integer"
-                ? typeof item === "number" &&
-                    Number.isInteger(item) &&
-                    item >= input.minimum &&
-                    item <= input.maximum
-                : input.type === "select"
-                    ? typeof item === "string" &&
-                        input.options.some(({ value: option }) => option === item)
-                    : input.type === "discord-channel" || input.type === "discord-role"
-                        ? typeof item === "string" && snowflake.safeParse(item).success
-                        : typeof item === "string" &&
-                            item.length >= input.minLength &&
-                            item.length <= input.maxLength;
-        if (!valid)
-            throw new DashboardActionValidationError(`${input.label} is not a valid action value.`);
-    }
-}
 //# sourceMappingURL=control-server.js.map

package/dist/dashboard-action-control.d.ts

@@ -0,0 +1,25 @@
+import { type DatabasePool } from "@helyx/database";
+import { type DashboardActionContext, type DashboardActionInspection, type DashboardActionResult, type ModuleDefinition, type PermissionActor, type ServiceAccess } from "@helyx/sdk";
+export interface DashboardActionInput {
+    guildId: string;
+    moduleId: string;
+    actionId: string;
+    actorUserId: string;
+    correlationId: string;
+    inspectionRevision?: string;
+}
+export type DashboardActionPreviewInput = Omit<DashboardActionInput, "inspectionRevision">;
+export interface DashboardActionControl {
+    database: DatabasePool;
+    services: ServiceAccess;
+    requireDashboardModule(moduleId: string): ModuleDefinition;
+    requireModuleAccessible(guildId: string, moduleId: string): Promise<void>;
+    authorizeAction(guildId: string, module: ModuleDefinition, actorUserId: string, permissionId: string): Promise<PermissionActor>;
+    sendToChannel: DashboardActionContext["sendToChannel"];
+    deleteChannelMessage: DashboardActionContext["deleteChannelMessage"];
+    notFound(message: string): Error;
+    invalid(message: string): Error;
+}
+export declare function executeDashboardAction(input: DashboardActionInput, control: DashboardActionControl): Promise<DashboardActionResult>;
+export declare function previewDashboardAction(input: DashboardActionPreviewInput, control: DashboardActionControl): Promise<DashboardActionInspection>;
+//# sourceMappingURL=dashboard-action-control.d.ts.map

package/dist/dashboard-action-control.js

@@ -0,0 +1,73 @@
+import { InstallationRepository } from "@helyx/database";
+import {} from "@helyx/sdk";
+import { dashboardActionPermissionId } from "./control-permissions.js";
+import { requireDashboardFeatures } from "./dashboard-feature-control.js";
+function prepareAction(input, control) {
+    const module = control.requireDashboardModule(input.moduleId);
+    const declared = module.manifest.dashboard?.actions?.find(({ id }) => id === input.actionId);
+    const action = module.dashboardActions?.find(({ id }) => id === input.actionId);
+    return { module, declared, action };
+}
+async function requireEnabledAndAuthorized(input, control, module, permissionId, disabledMessage) {
+    const [enabled] = await Promise.all([
+        new InstallationRepository(control.database).isModuleEnabled(input.guildId, input.moduleId),
+        control.authorizeAction(input.guildId, module, input.actorUserId, permissionId),
+    ]);
+    if (!enabled)
+        throw control.invalid(disabledMessage);
+}
+function actionContext(input, control, module, permissionId) {
+    return {
+        guildId: input.guildId,
+        actorUserId: input.actorUserId,
+        correlationId: input.correlationId,
+        services: control.services,
+        revalidate: async () => {
+            try {
+                await control.requireModuleAccessible(input.guildId, input.moduleId);
+                const enabled = await new InstallationRepository(control.database).isModuleEnabled(input.guildId, input.moduleId);
+                if (!enabled)
+                    return false;
+                await control.authorizeAction(input.guildId, module, input.actorUserId, permissionId);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        sendToChannel: control.sendToChannel,
+        deleteChannelMessage: control.deleteChannelMessage,
+    };
+}
+export async function executeDashboardAction(input, control) {
+    const { module, declared, action } = prepareAction(input, control);
+    await control.requireModuleAccessible(input.guildId, input.moduleId);
+    if (!declared || !action)
+        throw control.notFound("Dashboard action is not declared by this module");
+    await requireDashboardFeatures(control.services, input.guildId, input.moduleId, [declared.featureId]);
+    if (declared.inspection === "required" &&
+        (typeof input.inspectionRevision !== "string" ||
+            input.inspectionRevision.length < 1 ||
+            input.inspectionRevision.length > 200))
+        throw control.invalid("Run the action inspection before applying this change");
+    const permissionId = dashboardActionPermissionId(module, input.actionId, declared.permissionId);
+    await requireEnabledAndAuthorized(input, control, module, permissionId, "Enable this module before running its dashboard actions");
+    return action.execute(actionContext(input, control, module, permissionId), input.inspectionRevision
+        ? { inspectionRevision: input.inspectionRevision }
+        : undefined);
+}
+export async function previewDashboardAction(input, control) {
+    const { module, declared, action } = prepareAction(input, control);
+    await control.requireModuleAccessible(input.guildId, input.moduleId);
+    if (!declared || !action?.inspect || !declared.inspection)
+        throw control.notFound("Dashboard action inspection is not declared by this module");
+    await requireDashboardFeatures(control.services, input.guildId, input.moduleId, [declared.featureId]);
+    const permissionId = dashboardActionPermissionId(module, input.actionId, declared.permissionId);
+    await requireEnabledAndAuthorized(input, control, module, permissionId, "Enable this module before inspecting its dashboard actions");
+    const result = await action.inspect(actionContext(input, control, module, permissionId));
+    if (result.inspectionRevision.length < 1 ||
+        result.inspectionRevision.length > 200)
+        throw new Error("Dashboard action returned an invalid inspection revision");
+    return result;
+}
+//# sourceMappingURL=dashboard-action-control.js.map

package/dist/dashboard-action-routes.d.ts

@@ -0,0 +1,9 @@
+import type { DashboardActionInspection, DashboardActionResult } from "@helyx/sdk";
+import type { FastifyInstance } from "fastify";
+import type { DashboardActionInput, DashboardActionPreviewInput } from "./dashboard-action-control.js";
+export interface DashboardActionHandler {
+    executeDashboardAction(input: DashboardActionInput): Promise<DashboardActionResult>;
+    previewDashboardAction(input: DashboardActionPreviewInput): Promise<DashboardActionInspection>;
+}
+export declare function registerDashboardActionRoutes(server: FastifyInstance, service: DashboardActionHandler): void;
+//# sourceMappingURL=dashboard-action-routes.d.ts.map