@helyx/bot 1.4.0 → 1.5.1

package/dist/channel-audit-routes.js

@@ -0,0 +1,42 @@
+import { channelAuditModuleIdSchema, channelAuditInputSchema, channelAuditConfigurationSchema, channelAuditReportSchema, } from "@helyx/control-protocol/channel-audit";
+import { z } from "zod";
+import { BotControlTransportError } from "./control-errors.js";
+const parameters = z
+    .object({
+    guildId: z.string().regex(/^\d{17,20}$/u),
+    moduleId: channelAuditModuleIdSchema,
+})
+    .strict();
+const actor = z
+    .object({
+    actorUserId: z.string().regex(/^\d{17,20}$/u),
+    correlationId: z.uuid(),
+})
+    .strict();
+export function registerChannelAuditRoutes(server, control) {
+    server.post("/v1/guilds/:guildId/modules/:moduleId/channel-audit/config", async (request) => {
+        const input = {
+            ...parameters.parse(request.params),
+            ...actor.parse(request.body),
+        };
+        if (!control.readChannelAuditConfiguration)
+            throw unsupported();
+        return channelAuditConfigurationSchema.parse(await control.readChannelAuditConfiguration(input));
+    });
+    server.post("/v1/guilds/:guildId/modules/:moduleId/channel-audit/check", async (request) => {
+        const input = {
+            ...parameters.parse(request.params),
+            ...actor
+                .extend({ assumptions: channelAuditInputSchema })
+                .strict()
+                .parse(request.body),
+        };
+        if (!control.checkChannelAudit)
+            throw unsupported();
+        return channelAuditReportSchema.parse(await control.checkChannelAudit(input));
+    });
+}
+function unsupported() {
+    return new BotControlTransportError(503, "This bot version does not support Channel audit. Update the bot before trying again.");
+}
+//# sourceMappingURL=channel-audit-routes.js.map

package/dist/cloud-connector.js

@@ -763,6 +763,8 @@ function connectorCapabilities() {
         "guild.module.status.write.v1",
         "guild.module.configuration.write.v1",
         "guild.module.configuration.preview.v1",
+        "guild.module.channel-audit.config.read.v1",
+        "guild.module.channel-audit.check.v1",
         "guild.module.permissions.write.v1",
         "guild.module.logging.write.v1",
         "guild.module.action.execute.v1",

package/dist/cloud-control-dispatcher.js

@@ -121,6 +121,28 @@ export class CloudControlDispatcher {
                 });
                 break;
             }
+            case "guild.module.channel-audit.config.read.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                if (!this.control.readChannelAuditConfiguration)
+                    throw new Error("Channel audit is not supported by this bot version");
+                result = await this.control.readChannelAuditConfiguration({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "guild.module.channel-audit.check.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                if (!this.control.checkChannelAudit)
+                    throw new Error("Channel audit is not supported by this bot version");
+                result = await this.control.checkChannelAudit({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
             case "guild.module.configuration.write.v1": {
                 const input = parseOperationInput(request.operation, request.input);
                 result = await this.control.updateConfiguration({

package/dist/command-registration-policy.js

@@ -1,6 +1,7 @@
 import { isCustomerSelectableModule } from "@helyx/module-manifest";
 const platformGlobalModuleIds = new Set([
     "helyx.management",
+    "helyx.diagnostics",
     "helyx.support",
     "helyx.oauth",
     "helyx.permissions",

package/dist/control-errors.d.ts

@@ -1,8 +1,16 @@
 import { type PermissionMutationDenialReason } from "@helyx/core";
+export declare function isUnknownGuildError(error: unknown): boolean;
+export declare function isUnknownMemberError(error: unknown): boolean;
 export declare class BotControlTransportError extends Error {
     readonly status: 400 | 403 | 404 | 409 | 502 | 503 | 504;
     constructor(status: 400 | 403 | 404 | 409 | 502 | 503 | 504, message: string);
 }
+export declare class BotControlValidationError extends Error {
+    constructor(message: string);
+}
+export declare class BotControlNotFoundError extends Error {
+    constructor(message?: string);
+}
 export declare class BotControlForbiddenError extends Error {
     constructor(message?: string);
 }

package/dist/control-errors.js

@@ -1,4 +1,16 @@
 import { permissionMutationDenialMessage, } from "@helyx/core";
+export function isUnknownGuildError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === 10_004);
+}
+export function isUnknownMemberError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === 10_007);
+}
 export class BotControlTransportError extends Error {
     status;
     constructor(status, message) {
@@ -7,6 +19,18 @@ export class BotControlTransportError extends Error {
         this.name = "BotControlTransportError";
     }
 }
+export class BotControlValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BotControlValidationError";
+    }
+}
+export class BotControlNotFoundError extends Error {
+    constructor(message = "Discord server is not available to Helyx") {
+        super(message);
+        this.name = "BotControlNotFoundError";
+    }
+}
 export class BotControlForbiddenError extends Error {
     constructor(message = "You no longer have permission to perform this action") {
         super(message);

package/dist/control-server-schemas.d.ts

@@ -7,10 +7,10 @@ export declare const permissionState: z.ZodObject<{
     version: z.ZodNumber;
     module: z.ZodObject<{
         preset: z.ZodEnum<{
-            custom: "custom";
             everyone: "everyone";
             moderators: "moderators";
             administrators: "administrators";
+            custom: "custom";
         }>;
         allowedRoleIds: z.ZodArray<z.ZodString>;
         deniedRoleIds: z.ZodArray<z.ZodString>;
@@ -21,10 +21,10 @@ export declare const permissionState: z.ZodObject<{
         enabled: z.ZodBoolean;
         policy: z.ZodObject<{
             preset: z.ZodEnum<{
-                custom: "custom";
                 everyone: "everyone";
                 moderators: "moderators";
                 administrators: "administrators";
+                custom: "custom";
             }>;
             allowedRoleIds: z.ZodArray<z.ZodString>;
             deniedRoleIds: z.ZodArray<z.ZodString>;

package/dist/control-server.d.ts

@@ -10,6 +10,7 @@ import { type FirstTimeCommandSetupHandler } from "./first-time-command-setup.js
 import { type ShardHealthSnapshot } from "./shard-contracts.js";
 import { type DashboardPermissionState } from "./control-permissions.js";
 export { BotControlTransportError } from "./control-errors.js";
+import type { ChannelAuditControl } from "@helyx/sdk";
 import { type DashboardModuleDefinition } from "./dashboard-module-projection.js";
 import { type AvailabilityModuleCatalogue } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
@@ -120,7 +121,7 @@ export interface DashboardGuildAccessState extends GuildAccessPolicy {
     actorHighestRolePosition: number | null;
     updatedAt: string | null;
 }
-export interface BotControlHandler extends FirstTimeCommandSetupHandler, DashboardActionHandler {
+export interface BotControlHandler extends FirstTimeCommandSetupHandler, DashboardActionHandler, ChannelAuditControl {
     creatorOnboarding?(input: CreatorOnboardingRequest): Promise<CreatorOnboardingResponse>;
     cleanupOAuthConsumer(input: {
         consumerBindingId: string;
@@ -349,6 +350,8 @@ export declare class BotControlService implements BotControlHandler {
     private readonly supportNotifications?;
     private readonly presenceOwnership?;
     private readonly presenceShardCount?;
+    readonly readChannelAuditConfiguration: Required<ChannelAuditControl>["readChannelAuditConfiguration"];
+    readonly checkChannelAudit: Required<ChannelAuditControl>["checkChannelAudit"];
     constructor(databaseOrPersistence: DatabasePool | BotControlPersistence, modules: readonly ModuleDefinition[], resources: BotControlGuildResourceDirectory, services: ServiceAccess, privacyExecutor?: PrivacyProviderExecutor, supportNotifications?: {
         guildId: string;
         channelId: string;

package/dist/control-server.js

@@ -13,9 +13,11 @@ import { canAccessModule, PREMIUM_MODULE_UNAVAILABLE_MESSAGE, } from "./premium-
 import { completeFirstTimeCommandSetup, } from "./first-time-command-setup.js";
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.js";
 import { assertVersion, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
-import { assertPermissionMutationAllowed, BotControlForbiddenError, BotControlTransportError, } from "./control-errors.js";
+import { assertPermissionMutationAllowed, BotControlForbiddenError, BotControlNotFoundError, BotControlValidationError, BotControlTransportError, isUnknownGuildError, isUnknownMemberError, } from "./control-errors.js";
 export { BotControlTransportError } from "./control-errors.js";
 import { dashboardCommands } from "./dashboard-commands.js";
+import { registerChannelAuditRoutes } from "./channel-audit-routes.js";
+import { createChannelAuditControl } from "./channel-audit-control.js";
 import { executeCreatorOnboarding, registerCreatorOnboardingControlRoute, } from "./creator-onboarding-control.js";
 import { mapDashboardModule, } from "./dashboard-module-projection.js";
 import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, statusCatalogueDefinitions, } from "./module-availability-control.js";
@@ -215,6 +217,8 @@ export class BotControlService {
     #services;
     #privacyProviders;
     #persistence;
+    readChannelAuditConfiguration;
+    checkChannelAudit;
     constructor(databaseOrPersistence, modules, resources, services, privacyExecutor, supportNotifications, presenceOwnership, presenceShardCount, statusModules) {
         this.resources = resources;
         this.supportNotifications = supportNotifications;
@@ -235,6 +239,18 @@ export class BotControlService {
         this.#permissions = services.get(HELYX_SERVICE_NAMES.permissions);
         this.#services = services;
         this.#privacyProviders = createPrivacyProviderRegistry(modules, privacyExecutor, this.#services);
+        const audit = createChannelAuditControl({
+            modules: this.#modules,
+            resources,
+            services,
+            configurations: this.#configurations,
+            permissions: this.#permissions,
+            listModules: (guildId) => this.#persistence.repositories.installations.listModules(guildId),
+            readGuildPolicy: (guildId) => this.#readGuildAccessPolicy(guildId),
+            requireAccessible: (guildId, moduleId) => this.#requireModuleAccessible(guildId, moduleId),
+        });
+        this.readChannelAuditConfiguration = audit.readChannelAuditConfiguration;
+        this.checkChannelAudit = audit.checkChannelAudit;
     }
     async creatorOnboarding(input) {
         return executeCreatorOnboarding(input, {
@@ -1493,6 +1509,7 @@ export async function createBotControlServer(input) {
         return input.service.setModuleStatus({ ...params, ...body });
     });
     registerDashboardActionRoutes(server, input.service);
+    registerChannelAuditRoutes(server, input.service);
     server.get("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType", async (request) => {
         const params = z
             .object({
@@ -1690,31 +1707,7 @@ export function mapBotControlError(error) {
         };
     return undefined;
 }
-class BotControlValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "BotControlValidationError";
-    }
-}
-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 isUnknownMemberError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === 10_007);
-}
 //# sourceMappingURL=control-server.js.map

package/dist/diagnostic-command.d.ts

@@ -0,0 +1,76 @@
+import type { DatabasePool } from "@helyx/database";
+import type { MysqlPool } from "@helyx/database-mysql";
+import { type ModuleDefinition, type ModuleRecordService, type PermissionActor, type ServiceAccess } from "@helyx/sdk";
+import { type Client } from "discord.js";
+export interface DiagnosticIssue {
+    kind: "repairable" | "human" | "technical" | "incomplete";
+    message: string;
+    evidence?: Readonly<Record<string, unknown>>;
+    afterRepair?: string;
+}
+export interface DiagnosticProbe {
+    id: string;
+    moduleId?: string;
+    label: string;
+    inspect(this: void): Promise<DiagnosticIssue | null>;
+    repair?(round: 1 | 2, issue: DiagnosticIssue): Promise<"attempted" | "unchanged" | "stale">;
+    verify?(issue: DiagnosticIssue): Promise<boolean>;
+}
+export interface DiagnosticLease {
+    signal: AbortSignal;
+    assertOwned(): Promise<void>;
+}
+export type DiagnosticRunExclusive = (guildId: string, operation: (lease: DiagnosticLease) => Promise<void>) => Promise<boolean>;
+export interface DiagnosticResources {
+    actor(userId: string): Promise<PermissionActor>;
+    message(channelId: string, messageId: string): Promise<"present" | "absent" | "unknown">;
+    channel(channelId: string, types: readonly string[], permissions: readonly string[]): Promise<DiagnosticIssue | null>;
+    role(roleId: string, managed: boolean): Promise<DiagnosticIssue | null>;
+    capabilities(): {
+        guildMembers: boolean;
+        messageContent: boolean;
+    };
+    guildCommands?(): Promise<{
+        definitionHash: string;
+        rootCount: number;
+    }>;
+}
+export interface DiagnosticModuleOptions {
+    modules: readonly ModuleDefinition[];
+    client?: Client;
+    resources?: (guildId: string) => DiagnosticResources;
+    runExclusive?: DiagnosticRunExclusive;
+    assertGuildAvailable?: (guildId: string) => Promise<void>;
+    listEnabledModules?: (guildId: string) => Promise<readonly {
+        moduleId: string;
+    }[]>;
+    commandStatus?: {
+        get(guildId: string): Promise<unknown>;
+        refresh(input: {
+            guildId: string;
+            actorUserId: string;
+            correlationId: string;
+        }): Promise<unknown>;
+    };
+    stageMilliseconds?: number;
+    maximumRunMilliseconds?: number;
+}
+export interface DiagnosticRecordEnvironment {
+    guildId: string;
+    actorUserId: string;
+    correlationId: string;
+    modules: readonly ModuleDefinition[];
+    records: ModuleRecordService;
+    services: ServiceAccess;
+    assertCanInspect(): Promise<void>;
+    assertCanMutate(moduleId: string): Promise<void>;
+    inspectMessage(channelId: string, messageId: string): Promise<"present" | "absent" | "unknown">;
+    now(): Date;
+}
+/** A core command, never a selectable module or a module-repair hook. */
+export declare function createDiagnosticModule(options: DiagnosticModuleOptions): ModuleDefinition;
+/** Reserve at most four sessions, leaving at least two pool slots for repairs. */
+export declare function createPostgresDiagnosticLock(pool: DatabasePool): DiagnosticRunExclusive;
+/** Reserve at most four sessions, leaving at least two pool slots for repairs. */
+export declare function createMysqlDiagnosticLock(pool: MysqlPool): DiagnosticRunExclusive;
+//# sourceMappingURL=diagnostic-command.d.ts.map