@helyx/bot 1.3.1 → 1.5.0

package/dist/discord-owned-message-service.d.ts

@@ -4,6 +4,7 @@ export declare class DiscordOwnedMessageDeletionService implements DiscordOwnedM
     #private;
     private readonly client;
     constructor(client: Client);
+    isReady(): boolean;
     addOwnedMessageReaction(input: {
         guildId: string;
         channelId: string;

package/dist/discord-owned-message-service.js

@@ -6,6 +6,9 @@ export class DiscordOwnedMessageDeletionService {
     constructor(client) {
         this.client = client;
     }
+    isReady() {
+        return this.client.isReady();
+    }
     async addOwnedMessageReaction(input) {
         const emoji = prepareEmojiIdentifier(input.emojiIdentifier);
         const message = await this.#fetchOwnedMessage(input);

package/dist/discord-role-safety.d.ts

@@ -0,0 +1,4 @@
+/** The existing Helyx role-grant policy, shared by delivery and inspection. */
+export declare const dangerousRolePermissionNames: Set<string>;
+export declare function dangerousRolePermissions(permissions: bigint): string[];
+//# sourceMappingURL=discord-role-safety.d.ts.map

package/dist/discord-role-safety.js

@@ -0,0 +1,30 @@
+import { PermissionsBitField } from "discord.js";
+/** The existing Helyx role-grant policy, shared by delivery and inspection. */
+export const dangerousRolePermissionNames = new Set([
+    "ADMINISTRATOR",
+    "BAN_MEMBERS",
+    "DEAFEN_MEMBERS",
+    "KICK_MEMBERS",
+    "MANAGE_CHANNELS",
+    "MANAGE_EVENTS",
+    "MANAGE_GUILD",
+    "MANAGE_GUILD_EXPRESSIONS",
+    "MANAGE_MESSAGES",
+    "MANAGE_NICKNAMES",
+    "MANAGE_ROLES",
+    "MANAGE_THREADS",
+    "MANAGE_WEBHOOKS",
+    "MENTION_EVERYONE",
+    "MODERATE_MEMBERS",
+    "MOVE_MEMBERS",
+    "MUTE_MEMBERS",
+    "VIEW_AUDIT_LOG",
+]);
+export function dangerousRolePermissions(permissions) {
+    return new PermissionsBitField(permissions)
+        .toArray()
+        .map((permission) => permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase())
+        .filter((permission) => dangerousRolePermissionNames.has(permission))
+        .sort();
+}
+//# sourceMappingURL=discord-role-safety.js.map

package/dist/events.d.ts

@@ -1,4 +1,5 @@
 import type { DiscordChannelAudienceInspection, DiscordChannelInspection, DiscordEmojiInspection, DiscordMessageInspection, DiscordGuildCapabilityInspection, DiscordGuildChannelAudienceInspection, DiscordResourceInspectionService, DiscordRoleInspection, DiscordMessageService, InstallationService, MemberEnforcementService, MemberRoleService, ModuleDefinition, ServiceAccess, VerificationMemberService } from "@helyx/sdk";
+import { inspectDiscordChannelAudit } from "./discord-channel-audit.js";
 import { type Client, type MessageReaction, type PartialMessageReaction } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
 import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
@@ -80,6 +81,7 @@ export declare class DiscordResourceInspection implements DiscordResourceInspect
     #private;
     private readonly client;
     constructor(client: Client);
+    inspectChannelAudit(input: Parameters<typeof inspectDiscordChannelAudit>[1]): Promise<import("@helyx/sdk").ChannelAuditReport>;
     inspectGuildCapabilities(input: {
         guildId: string;
     }): Promise<DiscordGuildCapabilityInspection>;

package/dist/events.js

@@ -1,4 +1,6 @@
 import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
+import { inspectDiscordChannelAudit } from "./discord-channel-audit.js";
+import { dangerousRolePermissionNames } from "./discord-role-safety.js";
 import { safeError } from "@helyx/core";
 import { ChannelType, Events, GatewayIntentBits, GuildMemberFlags, PermissionFlagsBits, RESTJSONErrorCodes, UserFlags, } from "discord.js";
 import { toReplyOptions } from "./interactions.js";
@@ -1272,26 +1274,6 @@ export function reactionCacheKey(emojiIdentifier) {
 const discordSnowflake = /^\d{17,20}$/u;
 const moduleIdentifier = /^helyx\.[a-z0-9][a-z0-9-]*$/u;
 const customEmojiIdentifier = /^(?:<a?:([A-Za-z0-9_]{2,32}):(\d{17,20})>|([A-Za-z0-9_]{2,32}):(\d{17,20}))$/u;
-const dangerousRolePermissionNames = new Set([
-    "ADMINISTRATOR",
-    "BAN_MEMBERS",
-    "DEAFEN_MEMBERS",
-    "KICK_MEMBERS",
-    "MANAGE_CHANNELS",
-    "MANAGE_EVENTS",
-    "MANAGE_GUILD",
-    "MANAGE_GUILD_EXPRESSIONS",
-    "MANAGE_MESSAGES",
-    "MANAGE_NICKNAMES",
-    "MANAGE_ROLES",
-    "MANAGE_THREADS",
-    "MANAGE_WEBHOOKS",
-    "MENTION_EVERYONE",
-    "MODERATE_MEMBERS",
-    "MOVE_MEMBERS",
-    "MUTE_MEMBERS",
-    "VIEW_AUDIT_LOG",
-]);
 const directMessageAttemptTimeoutMs = 5_000;
 const guildChannelAudienceInspectionLimit = 500;
 export class DiscordMessageDeliveryService {
@@ -1696,6 +1678,9 @@ export class DiscordResourceInspection {
     constructor(client) {
         this.client = client;
     }
+    inspectChannelAudit(input) {
+        return inspectDiscordChannelAudit(this.client, input);
+    }
     async inspectGuildCapabilities(input) {
         validateSnowflake(input.guildId, "guild");
         const guild = await this.client.guilds.fetch(input.guildId);

package/dist/guild-command-read-service.d.ts

@@ -1,4 +1,5 @@
-import { type GuildCommandBudgetClass, type GuildCommandHealth, type GuildCommandHistoryRecord, type GuildCommandRequestRecord, type GuildCommandRequestSource, type GuildCommandStateRecord, type GuildCommandVisibilityProfile } from "@helyx/database";
+import { GuildCommandRepository, InstallationRepository, type GuildCommandBudgetClass, type GuildCommandHealth, type GuildCommandHistoryRecord, type GuildCommandRequestRecord, type GuildCommandRequestSource, type GuildCommandStateRecord, type GuildCommandVisibilityProfile } from "@helyx/database";
+import { type GuildCommandRepository as MysqlGuildCommandRepository, type InstallationRepository as MysqlInstallationRepository } from "@helyx/database-mysql";
 import type { ModuleDefinition } from "@helyx/sdk";
 import type { Pool } from "pg";
 import type { GuildCommandWorkerHealth } from "./guild-command-worker.js";
@@ -78,9 +79,13 @@ export interface GuildCommandReadHandler {
         scheduledGuildCount: number;
     }>;
 }
+type ReadCommandMethod = "getState" | "getActiveRequest" | "getCapacity" | "ensureState" | "schedule" | "recordStatusRefresh" | "changeVisibilityProfile" | "setMigrationHold" | "listHistory" | "getHealth";
+export interface GuildCommandReadRepositories {
+    commands: Pick<GuildCommandRepository, ReadCommandMethod> & Pick<MysqlGuildCommandRepository, ReadCommandMethod>;
+    installations: Pick<InstallationRepository, "listActiveGuildIdsWithEnabledModule"> & Pick<MysqlInstallationRepository, "listActiveGuildIdsWithEnabledModule">;
+}
 export declare class GuildCommandReadService implements GuildCommandReadHandler {
     #private;
-    private readonly database;
     private readonly applicationId;
     private readonly workerHealth?;
     private readonly discordToken?;
@@ -88,7 +93,7 @@ export declare class GuildCommandReadService implements GuildCommandReadHandler
     private readonly writeGuildIds;
     private readonly writeAllGuilds;
     private readonly modules;
-    constructor(database: Pool, applicationId: string, workerHealth?: (() => Promise<GuildCommandWorkerHealth> | undefined) | undefined, discordToken?: string | undefined, guildCommandWritesEnabled?: boolean, writeGuildIds?: readonly string[], writeAllGuilds?: boolean, modules?: readonly ModuleDefinition[]);
+    constructor(databaseOrRepositories: Pool | GuildCommandReadRepositories, applicationId: string, workerHealth?: (() => Promise<GuildCommandWorkerHealth> | undefined) | undefined, discordToken?: string | undefined, guildCommandWritesEnabled?: boolean, writeGuildIds?: readonly string[], writeAllGuilds?: boolean, modules?: readonly ModuleDefinition[]);
     previewFirstTimeSetup(moduleIds: string[]): Promise<{
         selectedModuleIds: string[];
         rootCount: number;

package/dist/guild-command-read-service.js

@@ -1,10 +1,10 @@
 import { GuildCommandRepository, GuildCommandRevisionConflictError, InstallationRepository, } from "@helyx/database";
+import { GuildCommandRevisionConflictError as MysqlGuildCommandRevisionConflictError, } from "@helyx/database-mysql";
 import { isCustomerSelectableModule } from "@helyx/module-manifest";
 import { createHash } from "node:crypto";
 import { REST, Routes } from "discord.js";
 import { guildCommandDefinitionHash, projectGuildCommands, } from "./guild-command-projection.js";
 export class GuildCommandReadService {
-    database;
     applicationId;
     workerHealth;
     discordToken;
@@ -13,8 +13,8 @@ export class GuildCommandReadService {
     writeAllGuilds;
     modules;
     #repository;
-    constructor(database, applicationId, workerHealth, discordToken, guildCommandWritesEnabled = false, writeGuildIds = [], writeAllGuilds = false, modules = []) {
-        this.database = database;
+    #installations;
+    constructor(databaseOrRepositories, applicationId, workerHealth, discordToken, guildCommandWritesEnabled = false, writeGuildIds = [], writeAllGuilds = false, modules = []) {
         this.applicationId = applicationId;
         this.workerHealth = workerHealth;
         this.discordToken = discordToken;
@@ -22,7 +22,14 @@ export class GuildCommandReadService {
         this.writeGuildIds = writeGuildIds;
         this.writeAllGuilds = writeAllGuilds;
         this.modules = modules;
-        this.#repository = new GuildCommandRepository(this.database);
+        const repositories = "commands" in databaseOrRepositories
+            ? databaseOrRepositories
+            : {
+                commands: new GuildCommandRepository(databaseOrRepositories),
+                installations: new InstallationRepository(databaseOrRepositories),
+            };
+        this.#repository = repositories.commands;
+        this.#installations = repositories.installations;
     }
     previewFirstTimeSetup(moduleIds) {
         const requested = new Set(moduleIds);
@@ -97,11 +104,10 @@ export class GuildCommandReadService {
         return this.getStatus(input.guildId);
     }
     async reconcileModuleAvailability(input) {
-        const installations = new InstallationRepository(this.database);
         let cursor;
         let scheduledGuildCount = 0;
         do {
-            const page = await installations.listActiveGuildIdsWithEnabledModule({
+            const page = await this.#installations.listActiveGuildIdsWithEnabledModule({
                 moduleId: input.moduleId,
                 ...(cursor ? { cursor } : {}),
                 limit: 500,
@@ -152,7 +158,8 @@ export class GuildCommandReadService {
             });
         }
         catch (error) {
-            if (!(error instanceof GuildCommandRevisionConflictError))
+            if (!(error instanceof GuildCommandRevisionConflictError) &&
+                !(error instanceof MysqlGuildCommandRevisionConflictError))
                 throw error;
         }
         return this.getStatus(input.guildId);

package/dist/guild-command-release.d.ts

@@ -1,16 +1,23 @@
 import { GuildCommandRepository, InstallationRepository, RuntimeStateRepository, type DatabasePool } from "@helyx/database";
-type ReleaseInstallationRepository = Pick<InstallationRepository, "listActiveGuilds">;
-type ReleaseCommandRepository = Pick<GuildCommandRepository, "getState" | "schedule">;
-type ReleaseRuntimeRepository = Pick<RuntimeStateRepository, "get" | "compareAndSet">;
-export declare function scheduleGuildCommandRelease(input: {
+import type { GuildCommandRepository as MysqlGuildCommandRepository, InstallationRepository as MysqlInstallationRepository, RuntimeStateRepository as MysqlRuntimeStateRepository } from "@helyx/database-mysql";
+type ReleaseInstallationRepository = Pick<InstallationRepository, "listActiveGuilds"> & Pick<MysqlInstallationRepository, "listActiveGuilds">;
+type ReleaseCommandRepository = Pick<GuildCommandRepository, "getState" | "schedule"> & Pick<MysqlGuildCommandRepository, "getState" | "schedule">;
+type ReleaseRuntimeRepository = Pick<RuntimeStateRepository, "get" | "compareAndSet"> & Pick<MysqlRuntimeStateRepository, "get" | "compareAndSet">;
+type ReleaseRepositories = {
+    installations: ReleaseInstallationRepository;
+    commands: ReleaseCommandRepository;
+    runtime: ReleaseRuntimeRepository;
+};
+type ReleasePersistence = ({
     database: DatabasePool;
+} & Partial<ReleaseRepositories>) | ({
+    database?: never;
+} & ReleaseRepositories);
+export declare function scheduleGuildCommandRelease(input: {
     applicationId: string;
     releaseId: string;
     staggerMs?: number;
-    installations?: ReleaseInstallationRepository;
-    commands?: ReleaseCommandRepository;
-    runtime?: ReleaseRuntimeRepository;
-}): Promise<{
+} & ReleasePersistence): Promise<{
     scheduled: number;
     skippedIncomplete: number;
     replay: boolean;

package/dist/guild-command-release.js

@@ -6,9 +6,16 @@ export async function scheduleGuildCommandRelease(input) {
     if (!RELEASE_ID.test(input.releaseId))
         throw new Error("Guild command release ID is invalid");
     const markerKey = `guild-commands:release:${input.applicationId}:${input.releaseId}`;
-    const installations = input.installations ?? new InstallationRepository(input.database);
-    const commands = input.commands ?? new GuildCommandRepository(input.database);
-    const runtime = input.runtime ?? new RuntimeStateRepository(input.database);
+    const database = input.database;
+    const installations = input.installations ??
+        (database ? new InstallationRepository(database) : undefined);
+    const commands = input.commands ??
+        (database ? new GuildCommandRepository(database) : undefined);
+    const runtime = input.runtime ??
+        (database ? new RuntimeStateRepository(database) : undefined);
+    if (!installations || !commands || !runtime) {
+        throw new Error("Guild command release requires a database or all three repositories");
+    }
     if (await runtime.get(markerKey))
         return { scheduled: 0, skippedIncomplete: 0, replay: true };
     const guilds = await installations.listActiveGuilds();

package/dist/guild-command-worker.d.ts

@@ -1,4 +1,5 @@
-import { GuildCommandRepository, type GuildCommandHealth, type GuildCommandRequestRecord } from "@helyx/database";
+import { GuildCommandRepository, InstallationRepository, ModuleAvailabilityRepository, type GuildCommandHealth, type GuildCommandRequestRecord } from "@helyx/database";
+import { type GuildCommandRepository as MysqlGuildCommandRepository, type InstallationRepository as MysqlInstallationRepository, type ModuleAvailabilityRepository as MysqlModuleAvailabilityRepository } from "@helyx/database-mysql";
 import type { Logger, ModuleDefinition } from "@helyx/sdk";
 import type { Pool } from "pg";
 import { type GuildCommandDiff, type GuildCommandProjection } from "./guild-command-projection.js";
@@ -9,10 +10,22 @@ export interface GuildCommandWorkerHealth extends GuildCommandHealth {
     workerRunning: boolean;
     activeCount: number;
 }
+type WorkerCommandRepository = Pick<GuildCommandRepository, "claimDue" | "getHealth" | "heartbeat" | "getState" | "completeDryRun" | "defer" | "markBlocked" | "markFailed" | "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation"> & Pick<MysqlGuildCommandRepository, "claimDue" | "getHealth" | "heartbeat" | "getState" | "completeDryRun" | "defer" | "markBlocked" | "markFailed" | "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation">;
+export interface GuildCommandWorkerRepositories {
+    commands: WorkerCommandRepository;
+    installations: Pick<InstallationRepository, "listEnabledModules"> & Pick<MysqlInstallationRepository, "listEnabledModules">;
+    availability: Pick<ModuleAvailabilityRepository, "list"> & Pick<MysqlModuleAvailabilityRepository, "list">;
+}
+type WorkerPersistence = {
+    database: Pool;
+    repositories?: never;
+} | {
+    database?: never;
+    repositories: GuildCommandWorkerRepositories;
+};
 export declare class GuildCommandWorker {
     #private;
     constructor(input: {
-        database: Pool;
         modules: readonly ModuleDefinition[];
         logger: Logger;
         workerId?: string;
@@ -24,13 +37,13 @@ export declare class GuildCommandWorker {
         claimLimit?: number;
         concurrency?: number;
         stopTimeoutMs?: number;
-    });
+    } & WorkerPersistence);
     start(): void;
     runOnce(): Promise<void>;
     stop(): Promise<void>;
     getHealth(): Promise<GuildCommandWorkerHealth>;
 }
-type LiveRepository = Pick<GuildCommandRepository, "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation">;
+type LiveRepository = Pick<GuildCommandRepository, "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation"> & Pick<MysqlGuildCommandRepository, "completeLive" | "isLeaseCurrent" | "reserveCreations" | "settleCreation">;
 export declare function reconcileLiveGuildCommands(input: {
     repository: LiveRepository;
     discord: Pick<GuildCommandDiscordClient, "observe" | "replace">;

package/dist/guild-command-worker.js

@@ -1,4 +1,5 @@
 import { GuildCommandBudgetExceededError, GuildCommandRepository, InstallationRepository, ModuleAvailabilityRepository, } from "@helyx/database";
+import { GuildCommandBudgetExceededError as MysqlGuildCommandBudgetExceededError, } from "@helyx/database-mysql";
 import { randomUUID } from "node:crypto";
 import { diffDryRunGuildCommands, diffGuildCommands, projectGuildCommands, } from "./guild-command-projection.js";
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
@@ -8,7 +9,8 @@ const DEFAULT_CONCURRENCY = 2;
 const DEFAULT_STOP_TIMEOUT_MS = 5_000;
 export class GuildCommandWorker {
     #repository;
-    #database;
+    #installations;
+    #availability;
     #modules;
     #logger;
     #workerId;
@@ -28,8 +30,16 @@ export class GuildCommandWorker {
     constructor(input) {
         if (input.fencingToken < 1n)
             throw new Error("Guild command worker fencing token must be positive");
-        this.#database = input.database;
-        this.#repository = new GuildCommandRepository(input.database);
+        const repositories = input.database
+            ? {
+                commands: new GuildCommandRepository(input.database),
+                installations: new InstallationRepository(input.database),
+                availability: new ModuleAvailabilityRepository(input.database),
+            }
+            : input.repositories;
+        this.#repository = repositories.commands;
+        this.#installations = repositories.installations;
+        this.#availability = repositories.availability;
         this.#modules = input.modules;
         this.#logger = input.logger;
         this.#workerId = input.workerId ?? `guild-command:${randomUUID()}`;
@@ -145,8 +155,8 @@ export class GuildCommandWorker {
         heartbeat.unref();
         try {
             const [enabled, availability, state] = await Promise.all([
-                new InstallationRepository(this.#database).listEnabledModules(request.guildId),
-                new ModuleAvailabilityRepository(this.#database).list(),
+                this.#installations.listEnabledModules(request.guildId),
+                this.#availability.list(),
                 this.#repository.getState(request.applicationId, request.guildId),
             ]);
             if (!state || state.desiredRevision !== request.requestedRevision) {
@@ -310,7 +320,8 @@ export async function reconcileLiveGuildCommands(input) {
             })).ledgerId;
         }
         catch (error) {
-            if (error instanceof GuildCommandBudgetExceededError)
+            if (error instanceof GuildCommandBudgetExceededError ||
+                error instanceof MysqlGuildCommandBudgetExceededError)
                 throw new GuildCommandLiveError("creation_budget_exhausted");
             throw error;
         }

package/dist/guilds.d.ts

@@ -1,4 +1,5 @@
-import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
+import { InstallationRepository, type DatabasePool, type GuildShardOwnership } from "@helyx/database";
+import type { MysqlPool } from "@helyx/database-mysql";
 import type { ModuleDefinition } from "@helyx/sdk";
 import { type Client } from "discord.js";
 import type { InteractionLogger } from "./interactions.js";
@@ -20,7 +21,27 @@ export interface GuildTrackingPreparation {
     (readyClient: Client<true>): Promise<void>;
     reconcile(reason: "ready" | "resume" | "periodic"): Promise<void>;
     health(): GuildReconciliationHealth;
-    stop(): void;
+    stop(): Promise<void>;
 }
-export declare function installGuildTracking(client: Client, database: DatabasePool, modules: readonly ModuleDefinition[], logger: InteractionLogger, enabledByDefaultModuleIds?: ReadonlySet<string>, ownership?: GuildShardOwnership, reconciliationIntervalMs?: number, shardCount?: number, applicationId?: string, hostedSafety?: HostedGuildSafety, hostedInviteGate?: HostedBotInviteGate, hostedOwnerObserver?: HostedGuildOwnerObserver | undefined): GuildTrackingPreparation;
+interface GuildObservation {
+    guildId: string;
+    ownerUserId: string;
+    ownerUsername?: string;
+    name: string;
+    modules: readonly ModuleDefinition[];
+    enabledByDefaultModuleIds: ReadonlySet<string>;
+    firstObservation: boolean;
+    applicationId?: string;
+    ownership?: GuildShardOwnership;
+    continueObservation?: () => boolean;
+}
+type ReconciliationRepository = Pick<InstallationRepository, "listActiveGuildIdsForOwnership" | "adoptGuildsForReconciliation" | "markGuildsRemovedForReconciliation">;
+export interface GuildTrackingPersistence extends ReconciliationRepository {
+    readonly engine: "postgresql" | "mysql";
+    syncGuild(input: GuildObservation): Promise<void>;
+    markGuildRemoved(guildId: string, ownership: GuildShardOwnership | undefined, applicationId: string | undefined): Promise<boolean>;
+}
+export declare function createMysqlGuildTrackingPersistence(database: MysqlPool): Promise<GuildTrackingPersistence>;
+export declare function installGuildTracking(client: Client, database: DatabasePool | GuildTrackingPersistence, modules: readonly ModuleDefinition[], logger: InteractionLogger, enabledByDefaultModuleIds?: ReadonlySet<string>, ownership?: GuildShardOwnership, reconciliationIntervalMs?: number, shardCount?: number, applicationId?: string, hostedSafety?: HostedGuildSafety, hostedInviteGate?: HostedBotInviteGate, hostedOwnerObserver?: HostedGuildOwnerObserver | undefined): GuildTrackingPreparation;
+export {};
 //# sourceMappingURL=guilds.d.ts.map