@helyx/bot 1.1.0 → 1.2.1

package/dist/embedded-auto-moderation-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=embedded-auto-moderation-worker.d.ts.map

package/dist/embedded-auto-moderation-worker.js

@@ -0,0 +1,13 @@
+import { parentPort } from "node:worker_threads";
+import { EmbeddedWorkerRuntime, } from "./embedded-auto-moderation-worker-runtime.js";
+const workerPort = parentPort;
+if (!workerPort)
+    throw new Error("Embedded Auto Moderation worker requires a parent port");
+const runtime = new EmbeddedWorkerRuntime();
+workerPort.on("message", (request) => {
+    const response = runtime.handle(request);
+    if (response)
+        workerPort.postMessage(response);
+});
+workerPort.postMessage({ type: "ready" });
+//# sourceMappingURL=embedded-auto-moderation-worker.js.map

package/dist/events.d.ts

@@ -1,8 +1,12 @@
 import type { DiscordChannelAudienceInspection, DiscordChannelInspection, DiscordEmojiInspection, DiscordMessageInspection, DiscordGuildCapabilityInspection, DiscordGuildChannelAudienceInspection, DiscordResourceInspectionService, DiscordRoleInspection, DiscordMessageService, InstallationService, MemberEnforcementService, MemberRoleService, ModuleDefinition, ServiceAccess, VerificationMemberService } from "@helyx/sdk";
 import { type Client, type MessageReaction, type PartialMessageReaction } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
 export declare function availabilityAwareInstallations(services: ServiceAccess, modulesById?: ReadonlyMap<string, ModuleDefinition>): Pick<InstallationService, "isModuleEnabled">;
-export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess): ModuleEventHandle;
+export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess, options?: {
+    runtimeProfile?: "hosted" | "self-hosted";
+    evidenceStore?: TransientViolationEvidenceStore;
+}): ModuleEventHandle;
 export interface ModuleEventHandle {
     stop(): Promise<void>;
     queueDepth(): number;

package/dist/events.js

@@ -5,6 +5,8 @@ import { toReplyOptions } from "./interactions.js";
 import { createHash } from "node:crypto";
 import { classifyGuildMessage, unavailableGuildMessageClassification, } from "./message-classification.js";
 import { canAccessModule } from "./premium-access.js";
+import { fromDiscordAction, toRuleSnapshot, } from "./discord-auto-moderation-service.js";
+import { PrivilegedMessageMetadataCache } from "./privileged-message-metadata-cache.js";
 export function availabilityAwareInstallations(services, modulesById) {
     const installations = services.get(HELYX_SERVICE_NAMES.installations);
     const candidate = typeof services.has === "function" &&
@@ -21,12 +23,65 @@ export function availabilityAwareInstallations(services, modulesById) {
         },
     };
 }
-export function installModuleEvents(client, modules, logger, services) {
+async function featureContributionAvailable(services, guildId, moduleId, featureId) {
+    if (!featureId)
+        return true;
+    if (!services.has(HELYX_SERVICE_NAMES.featureAccess))
+        return false;
+    try {
+        const result = await services
+            .get(HELYX_SERVICE_NAMES.featureAccess)
+            .check({ guildId, moduleId, featureId });
+        return result.decision === "granted";
+    }
+    catch {
+        return false;
+    }
+}
+function privilegedSource(message) {
+    const author = message.author;
+    if (!author?.id)
+        return { resolved: false };
+    const channel = "channel" in message ? message.channel : undefined;
+    const channelIsThread = Boolean(channel && typeof channel.isThread === "function" && channel.isThread());
+    return {
+        resolved: true,
+        userId: author.id,
+        userIsBot: author.bot,
+        userIsSystem: Boolean(author.system || message.system),
+        webhookId: message.webhookId,
+        member: message.member
+            ? {
+                present: true,
+                roleIds: [...message.member.roles.cache.keys()].sort(),
+            }
+            : { present: false },
+        channelId: message.channelId,
+        parentChannelId: channelIsThread && channel && "parentId" in channel
+            ? channel.parentId
+            : null,
+        channelIsThread,
+    };
+}
+export function installModuleEvents(client, modules, logger, services, options) {
+    const runtimeProfile = options?.runtimeProfile ?? "hosted";
     const modulesById = new Map(modules.map((module) => [module.manifest.id, module]));
-    const privilegedMessageContributions = modules.flatMap((module) => (module.events?.privilegedMessageCreate ?? []).map((contribution) => ({
+    const privilegedMessageContributions = modules.flatMap((module) => (module.events?.privilegedMessageCreate ?? [])
+        .filter((contribution) => !contribution.featureId || runtimeProfile === "self-hosted")
+        .map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
     })));
+    const privilegedMessageUpdateContributions = modules.flatMap((module) => (module.events?.privilegedMessageUpdate ?? [])
+        .filter((contribution) => !contribution.featureId || runtimeProfile === "self-hosted")
+        .map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const autoModerationRuleCreateContributions = modules.flatMap((module) => (module.events?.discordAutoModerationRuleCreate ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
+    const autoModerationRuleUpdateContributions = modules.flatMap((module) => (module.events?.discordAutoModerationRuleUpdate ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
+    const autoModerationRuleDeleteContributions = modules.flatMap((module) => (module.events?.discordAutoModerationRuleDelete ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
+    const autoModerationActionContributions = modules.flatMap((module) => (module.events?.discordAutoModerationActionExecution ?? []).map((contribution) => ({ moduleId: module.manifest.id, contribution })));
     const guildMessageContributions = modules.flatMap((module) => (module.events?.guildMessageCreate ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         classificationRequested: module.requiredDiscordCapabilities?.includes("message-content") ??
@@ -101,6 +156,11 @@ export function installModuleEvents(client, modules, logger, services) {
         contribution,
     })));
     if (privilegedMessageContributions.length === 0 &&
+        privilegedMessageUpdateContributions.length === 0 &&
+        autoModerationRuleCreateContributions.length === 0 &&
+        autoModerationRuleUpdateContributions.length === 0 &&
+        autoModerationRuleDeleteContributions.length === 0 &&
+        autoModerationActionContributions.length === 0 &&
         guildMessageContributions.length === 0 &&
         guildVoiceSessionContributions.length === 0 &&
         reactionContributions.length === 0 &&
@@ -120,6 +180,7 @@ export function installModuleEvents(client, modules, logger, services) {
         guildEmojiUpdateContributions.length === 0)
         return { stop: () => Promise.resolve(), queueDepth: () => 0 };
     const queue = new BoundedGuildEventQueue(logger);
+    const privilegedMetadata = new PrivilegedMessageMetadataCache();
     const voiceSessions = new Map();
     const privilegedEligibilityQueue = privilegedMessageContributions.length > 0
         ? new BoundedGuildEventQueue(logger)
@@ -149,6 +210,21 @@ export function installModuleEvents(client, modules, logger, services) {
                 });
         });
     }
+    if (privilegedMessageUpdateContributions.length > 0) {
+        client.on(Events.MessageCreate, (message) => {
+            if (!message.guildId)
+                return;
+            const source = privilegedSource(message);
+            if (!source.resolved)
+                return;
+            privilegedMetadata.remember({
+                guildId: message.guildId,
+                channelId: message.channelId,
+                messageId: message.id,
+                source,
+            });
+        });
+    }
     if (privilegedMessageContributions.length > 0) {
         client.on(Events.MessageCreate, (message) => {
             if (!message.guildId || !privilegedEligibilityQueue)
@@ -159,6 +235,7 @@ export function installModuleEvents(client, modules, logger, services) {
                 for (const item of privilegedMessageContributions) {
                     try {
                         if ((await installations.isModuleEnabled(message.guildId, item.moduleId)) &&
+                            (await featureContributionAvailable(services, message.guildId, item.moduleId, item.contribution.featureId)) &&
                             (await item.contribution.isEligible({
                                 serverId: message.guildId,
                                 channelId: message.channelId,
@@ -167,6 +244,7 @@ export function installModuleEvents(client, modules, logger, services) {
                                 userIsSystem: message.author.system || message.system,
                                 webhookId: message.webhookId,
                                 content: message.content,
+                                source: privilegedSource(message),
                                 services,
                             }))) {
                             eligible.push(item);
@@ -241,6 +319,32 @@ export function installModuleEvents(client, modules, logger, services) {
                 queue.enqueue(message.guildId, () => handleMessageUpdate(message));
         });
     }
+    if (privilegedMessageUpdateContributions.length > 0) {
+        client.on(Events.MessageUpdate, (_before, message) => {
+            if (message.guildId)
+                queue.enqueue(message.guildId, () => handlePrivilegedMessageUpdate(message));
+        });
+    }
+    if (autoModerationRuleCreateContributions.length > 0) {
+        client.on(Events.AutoModerationRuleCreate, (rule) => {
+            queue.enqueue(rule.guild.id, () => handleAutoModerationRule(autoModerationRuleCreateContributions, rule, "create"));
+        });
+    }
+    if (autoModerationRuleUpdateContributions.length > 0) {
+        client.on(Events.AutoModerationRuleUpdate, (_before, rule) => {
+            queue.enqueue(rule.guild.id, () => handleAutoModerationRule(autoModerationRuleUpdateContributions, rule, "update"));
+        });
+    }
+    if (autoModerationRuleDeleteContributions.length > 0) {
+        client.on(Events.AutoModerationRuleDelete, (rule) => {
+            queue.enqueue(rule.guild.id, () => handleAutoModerationRule(autoModerationRuleDeleteContributions, rule, "delete"));
+        });
+    }
+    if (autoModerationActionContributions.length > 0) {
+        client.on(Events.AutoModerationActionExecution, (execution) => {
+            queue.enqueue(execution.guild.id, () => handleAutoModerationAction(execution));
+        });
+    }
     if (messageDeleteContributions.length > 0) {
         client.on(Events.MessageDelete, (message) => {
             if (message.guildId)
@@ -335,7 +439,8 @@ export function installModuleEvents(client, modules, logger, services) {
         const installations = availabilityAwareInstallations(services, modulesById);
         for (const { moduleId, contribution } of contributions) {
             try {
-                if (!(await installations.isModuleEnabled(message.guildId, moduleId)))
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId)) ||
+                    !(await featureContributionAvailable(services, message.guildId, moduleId, contribution.featureId)))
                     continue;
                 await contribution.execute({
                     serverId: message.guildId,
@@ -345,6 +450,7 @@ export function installModuleEvents(client, modules, logger, services) {
                     userIsBot: message.author.bot,
                     webhookId: message.webhookId,
                     content: message.content,
+                    source: privilegedSource(message),
                     services,
                     deleteSource: async () => {
                         await message.delete();
@@ -362,6 +468,138 @@ export function installModuleEvents(client, modules, logger, services) {
             }
         }
     }
+    async function handlePrivilegedMessageUpdate(message) {
+        if (!message.guildId)
+            return;
+        const payloadSource = privilegedSource(message);
+        const cachedSource = privilegedMetadata.resolve({
+            guildId: message.guildId,
+            channelId: message.channelId,
+            messageId: message.id,
+        });
+        const source = payloadSource.resolved
+            ? payloadSource
+            : (cachedSource ?? { resolved: false });
+        if (source.resolved)
+            privilegedMetadata.remember({
+                guildId: message.guildId,
+                channelId: message.channelId,
+                messageId: message.id,
+                source,
+            });
+        const observedAt = new Date();
+        const content = typeof message.content === "string"
+            ? { present: true, value: message.content }
+            : { present: false };
+        const installations = availabilityAwareInstallations(services, modulesById);
+        for (const { moduleId, contribution, } of privilegedMessageUpdateContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId)) ||
+                    !(await featureContributionAvailable(services, message.guildId, moduleId, contribution.featureId)))
+                    continue;
+                await contribution.execute({
+                    serverId: message.guildId,
+                    channelId: message.channelId,
+                    messageId: message.id,
+                    observationVersion: message.editedTimestamp?.toString() ?? observedAt.toISOString(),
+                    observedAt,
+                    content,
+                    source,
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.privileged_message_update_failed",
+                    moduleId,
+                    error: safeError(error),
+                    messageId: message.id,
+                    guildId: message.guildId,
+                }, "Module privileged message-update event failed");
+            }
+        }
+    }
+    async function handleAutoModerationRule(contributions, rule, eventName) {
+        const installations = availabilityAwareInstallations(services, modulesById);
+        for (const { moduleId, contribution } of contributions) {
+            try {
+                if (!(await installations.isModuleEnabled(rule.guild.id, moduleId)))
+                    continue;
+                await contribution.execute({
+                    serverId: rule.guild.id,
+                    rule: toRuleSnapshot(rule),
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: `module.auto_moderation_rule_${eventName}_failed`,
+                    moduleId,
+                    guildId: rule.guild.id,
+                    ruleId: rule.id,
+                    error: safeError(error),
+                }, "Module Auto Moderation rule event failed");
+            }
+        }
+    }
+    async function handleAutoModerationAction(execution) {
+        const installations = availabilityAwareInstallations(services, modulesById);
+        const action = fromDiscordAction(execution.action);
+        const executionId = createHash("sha256")
+            .update(JSON.stringify([
+            execution.guild.id,
+            execution.ruleId,
+            execution.userId,
+            execution.channelId,
+            execution.messageId,
+        ]))
+            .digest("hex");
+        const evidenceReference = options?.evidenceStore && execution.channelId && execution.content
+            ? options.evidenceStore.capture({
+                source: "discord_auto_moderation",
+                sourceEventId: executionId,
+                guildId: execution.guild.id,
+                channelId: execution.channelId,
+                messageId: execution.messageId,
+                authorUserId: execution.userId,
+                content: execution.content,
+            })
+            : null;
+        try {
+            for (const { moduleId, contribution, } of autoModerationActionContributions) {
+                try {
+                    if (!(await installations.isModuleEnabled(execution.guild.id, moduleId)))
+                        continue;
+                    await contribution.execute({
+                        serverId: execution.guild.id,
+                        ruleId: execution.ruleId,
+                        userId: execution.userId,
+                        channelId: execution.channelId,
+                        messageId: execution.messageId,
+                        alertSystemMessageId: execution.alertSystemMessageId,
+                        action,
+                        executionId,
+                        evidenceReference,
+                        occurredAt: new Date(),
+                        services,
+                    });
+                }
+                catch (error) {
+                    logger.warn({
+                        event: "module.auto_moderation_action_execution_failed",
+                        moduleId,
+                        guildId: execution.guild.id,
+                        ruleId: execution.ruleId,
+                        error: safeError(error),
+                    }, "Module Auto Moderation action event failed");
+                }
+            }
+        }
+        finally {
+            if (evidenceReference)
+                options?.evidenceStore?.discard(evidenceReference);
+        }
+    }
     async function handleGuildMessageCreate(message) {
         if (!message.guildId || !message.channelId)
             return;
@@ -862,6 +1100,7 @@ export function installModuleEvents(client, modules, logger, services) {
             await guildMessageQueue?.stop();
             await queue.stop();
             voiceSessions.clear();
+            privilegedMetadata.clear();
         },
         queueDepth: () => queue.queueDepth() +
             (privilegedEligibilityQueue?.queueDepth() ?? 0) +
@@ -2088,7 +2327,7 @@ function validateSnowflake(value, label) {
         throw new Error(`Invalid Discord ${label} ID`);
 }
 function discordAuditReason(input) {
-    return `Helyx ${input.moduleId}: ${input.reason.trim()}`;
+    return `Helyx ${input.moduleId}${input.operationKey ? ` ${input.operationKey}` : ""}: ${input.reason.trim()}`.slice(0, 512);
 }
 function normalizePermissionName(permission) {
     return permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();

package/dist/guilds.d.ts

@@ -2,7 +2,7 @@ import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
 import type { ModuleDefinition } from "@helyx/sdk";
 import { type Client } from "discord.js";
 import type { InteractionLogger } from "./interactions.js";
-import type { HostedBotInviteGate, HostedGuildSafety } from "./hosted-server-moderation.js";
+import type { HostedBotInviteGate, HostedGuildOwnerObserver, HostedGuildSafety } from "./hosted-server-moderation.js";
 export interface GuildReconciliationHealth {
     status: "pending" | "running" | "healthy" | "failed" | "stopped";
     lastStartedAt?: string;
@@ -22,5 +22,5 @@ export interface GuildTrackingPreparation {
     health(): GuildReconciliationHealth;
     stop(): 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): GuildTrackingPreparation;
+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;
 //# sourceMappingURL=guilds.d.ts.map

package/dist/guilds.js

@@ -3,7 +3,7 @@ import { safeError } from "@helyx/core";
 import { Events } from "discord.js";
 const RECONCILIATION_PAGE_SIZE = 250;
 const DEFAULT_RECONCILIATION_INTERVAL_MS = 15 * 60 * 1_000;
-export function installGuildTracking(client, database, modules, logger, enabledByDefaultModuleIds = new Set(), ownership, reconciliationIntervalMs = DEFAULT_RECONCILIATION_INTERVAL_MS, shardCount, applicationId, hostedSafety, hostedInviteGate) {
+export function installGuildTracking(client, database, modules, logger, enabledByDefaultModuleIds = new Set(), ownership, reconciliationIntervalMs = DEFAULT_RECONCILIATION_INTERVAL_MS, shardCount, applicationId, hostedSafety, hostedInviteGate, hostedOwnerObserver = hostedSafety) {
     if (!Number.isSafeInteger(reconciliationIntervalMs) ||
         reconciliationIntervalMs < 60_000)
         throw new Error("Guild reconciliation interval must be at least one minute");
@@ -14,8 +14,8 @@ export function installGuildTracking(client, database, modules, logger, enabledB
     let timer;
     const admissionRetries = new Map();
     const inviteGateRejections = new Map();
-    const ownerObservations = hostedSafety
-        ? new OwnerObservationQueue(hostedSafety, logger)
+    const ownerObservations = hostedOwnerObserver
+        ? new OwnerObservationQueue(hostedOwnerObserver, logger)
         : undefined;
     let health = {
         status: "pending",
@@ -26,11 +26,14 @@ export function installGuildTracking(client, database, modules, logger, enabledB
         unavailableGuilds: 0,
     };
     async function syncGuild(guild, firstObservation = false) {
+        const cachedOwner = guild.members?.cache.get(guild.ownerId)?.user ??
+            guild.client?.users.cache.get(guild.ownerId);
         const persist = async (connection) => {
             const installations = new InstallationRepository(connection);
             const record = await installations.syncGuild({
                 guildId: guild.id,
                 ownerUserId: guild.ownerId,
+                ...(cachedOwner ? { ownerUsername: cachedOwner.username } : {}),
                 name: guild.name,
                 ...(ownership ? { ownership } : {}),
             });
@@ -62,7 +65,10 @@ export function installGuildTracking(client, database, modules, logger, enabledB
             await withTransaction(database, persist);
         else
             await persist(database);
-        ownerObservations?.enqueue(guild);
+        if (cachedOwner && hostedOwnerObserver)
+            await hostedOwnerObserver.observeOwner(guild);
+        else
+            ownerObservations?.enqueue(guild);
     }
     async function leaveInviteRejectedGuild(guild) {
         const reasonCode = inviteGateRejections.get(guild.id);
@@ -325,13 +331,13 @@ export function installGuildTracking(client, database, modules, logger, enabledB
     return prepare;
 }
 class OwnerObservationQueue {
-    safety;
+    observer;
     logger;
     #pending = new Map();
     #active = 0;
     #stopped = false;
-    constructor(safety, logger) {
-        this.safety = safety;
+    constructor(observer, logger) {
+        this.observer = observer;
         this.logger = logger;
     }
     enqueue(guild) {
@@ -352,7 +358,7 @@ class OwnerObservationQueue {
             const [guildId, guild] = next;
             this.#pending.delete(guildId);
             this.#active += 1;
-            void this.safety
+            void this.observer
                 .observeOwner(guild)
                 .catch(() => {
                 this.logger.warn({

package/dist/hosted-server-moderation.d.ts

@@ -1,4 +1,4 @@
-import { type DatabasePool } from "@helyx/database";
+import { type DatabasePool, type HostedServerLeaveDeliveryOutcome } from "@helyx/database";
 import type { Client, Guild } from "discord.js";
 import { z } from "zod";
 import type { InteractionLogger } from "./interactions.js";
@@ -14,9 +14,9 @@ declare const resultSchema: z.ZodObject<{
         requires_review: "requires_review";
         failed: "failed";
         queued: "queued";
-        already_blacklisted: "already_blacklisted";
         not_currently_installed: "not_currently_installed";
         accepted_for_retry: "accepted_for_retry";
+        already_blacklisted: "already_blacklisted";
     }>;
     paidSlotsReleased: z.ZodNumber;
 }, z.core.$loose>;
@@ -45,7 +45,7 @@ export declare class HostedServerModerationClient implements DeveloperServerMode
         idempotencyKey: string;
     }): Promise<{
         operationId: string;
-        outcome: "completed" | "requires_review" | "failed" | "queued" | "already_blacklisted" | "not_currently_installed" | "accepted_for_retry";
+        outcome: "completed" | "requires_review" | "failed" | "queued" | "not_currently_installed" | "accepted_for_retry" | "already_blacklisted";
         paidSlotsReleased: number;
     }>;
 }
@@ -58,11 +58,17 @@ export declare class HostedBotInviteGateClient implements HostedBotInviteGate {
     constructor(apiUrl: string, secret: string);
     isEnabled(): Promise<boolean>;
 }
-export interface HostedGuildSafety {
+export interface HostedGuildOwnerObserver {
+    observeOwner(guild: Guild): Promise<void>;
+}
+export interface HostedGuildSafety extends HostedGuildOwnerObserver {
     isBlacklisted(guildId: string): Promise<boolean>;
     blacklistedGuildIds(guildIds: readonly string[]): Promise<Set<string>>;
     recordAutomaticLeave(guildId: string): Promise<string>;
-    observeOwner(guild: Guild): Promise<void>;
+}
+export interface HostedServerOwnerObservation {
+    username: string;
+    observedAt: string;
 }
 export declare class PostgresHostedGuildSafety implements HostedGuildSafety {
     #private;
@@ -71,6 +77,7 @@ export declare class PostgresHostedGuildSafety implements HostedGuildSafety {
     blacklistedGuildIds(guildIds: readonly string[]): Promise<Set<string>>;
     recordAutomaticLeave(guildId: string): Promise<string>;
     observeOwner(guild: Guild): Promise<void>;
+    refreshOwner(guild: Guild): Promise<HostedServerOwnerObservation>;
 }
 export declare class HostedServerLeaveWorker {
     #private;
@@ -83,6 +90,10 @@ export declare class HostedServerLeaveWorker {
     } | undefined);
     start(): void;
     runOnce(): Promise<void>;
+    deliverOperation(input: {
+        operationId: string;
+        guildId: string;
+    }): Promise<HostedServerLeaveDeliveryOutcome>;
     stop(): Promise<void>;
 }
 export {};

package/dist/hosted-server-moderation.js

@@ -84,13 +84,22 @@ export class PostgresHostedGuildSafety {
         return this.#repository.enqueueAutomaticLeave(guildId);
     }
     async observeOwner(guild) {
-        const cached = guild.members.cache.get(guild.ownerId)?.user;
+        await this.refreshOwner(guild);
+    }
+    async refreshOwner(guild) {
+        const cached = guild.members.cache.get(guild.ownerId)?.user ??
+            guild.client.users.cache?.get(guild.ownerId);
         const user = cached ?? (await guild.client.users.fetch(guild.ownerId));
-        await this.#repository.observeOwner({
+        const observedAt = new Date();
+        const persisted = await this.#repository.observeOwner({
             guildId: guild.id,
             ownerUserId: guild.ownerId,
             username: user.username,
+            observedAt,
         });
+        if (!persisted)
+            throw new Error("Guild owner observation no longer matched the installation");
+        return { username: user.username, observedAt: observedAt.toISOString() };
     }
 }
 export class HostedServerLeaveWorker {
@@ -122,6 +131,19 @@ export class HostedServerLeaveWorker {
         });
         return this.#active;
     }
+    async deliverOperation(input) {
+        if (this.#stopped)
+            return "queued";
+        await this.#active;
+        const claim = await this.#repository.claimLeaveDelivery({
+            ...input,
+            leaseSeconds: 30,
+            ...(this.shardScope ?? {}),
+        });
+        if (claim)
+            return this.#deliver(claim);
+        return ((await this.#repository.getLeaveDeliveryOutcome(input.operationId, input.guildId)) ?? "queued");
+    }
     async stop() {
         this.#stopped = true;
         if (this.#timer)
@@ -149,7 +171,7 @@ export class HostedServerLeaveWorker {
         const guild = this.client.guilds.cache.get(claim.guildId);
         if (!guild) {
             await this.#repository.completeLeaveDelivery(claim, "not_currently_installed");
-            return;
+            return "not_currently_installed";
         }
         try {
             await guild.leave();
@@ -159,12 +181,13 @@ export class HostedServerLeaveWorker {
                 guildId: claim.guildId,
                 operationId: claim.operationId,
             }, "Hosted server leave completed");
+            return "completed";
         }
         catch (error) {
             const failureCode = classifyLeaveFailure(error);
             if (failureCode === "discord_not_installed") {
                 await this.#repository.completeLeaveDelivery(claim, "not_currently_installed");
-                return;
+                return "not_currently_installed";
             }
             const outcome = await this.#repository.failLeaveDelivery({
                 claim,
@@ -178,6 +201,11 @@ export class HostedServerLeaveWorker {
                 failureCode,
                 outcome,
             }, "Hosted server leave will be retried or reviewed");
+            return outcome === "requires_review"
+                ? outcome
+                : outcome === "retry"
+                    ? "accepted_for_retry"
+                    : "queued";
         }
     }
 }

package/dist/index.d.ts

@@ -11,5 +11,5 @@ export interface BotHandle {
 export declare function startBot(processEnvironment?: NodeJS.ProcessEnv): Promise<BotHandle>;
 export declare function resolveBotWorkerEntryPoint(entryUrl?: string): string;
 export declare function readBotVersion(): string;
-export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[], messageContentEnabled?: boolean, guildMembersEnabled?: boolean): GatewayIntentBits[];
+export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[], messageContentEnabled?: boolean, guildMembersEnabled?: boolean, runtimeProfile?: "hosted" | "self-hosted"): GatewayIntentBits[];
 //# sourceMappingURL=index.d.ts.map