@helyx/bot 1.0.1 → 1.2.0

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

@@ -0,0 +1,100 @@
+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";
+declare const resultSchema: z.ZodObject<{
+    operationId: z.ZodUUID;
+    guildId: z.ZodString;
+    action: z.ZodEnum<{
+        leave: "leave";
+        blacklist: "blacklist";
+    }>;
+    outcome: z.ZodEnum<{
+        completed: "completed";
+        requires_review: "requires_review";
+        failed: "failed";
+        queued: "queued";
+        not_currently_installed: "not_currently_installed";
+        accepted_for_retry: "accepted_for_retry";
+        already_blacklisted: "already_blacklisted";
+    }>;
+    paidSlotsReleased: z.ZodNumber;
+}, z.core.$loose>;
+export interface DeveloperServerModeration {
+    moderate(input: {
+        action: "leave" | "blacklist";
+        guildId: string;
+        actorUserId: string;
+        reason: string;
+        idempotencyKey: string;
+    }): Promise<{
+        operationId: string;
+        outcome: z.infer<typeof resultSchema>["outcome"];
+        paidSlotsReleased: number;
+    }>;
+}
+export declare class HostedServerModerationClient implements DeveloperServerModeration {
+    private readonly apiUrl;
+    private readonly secret;
+    constructor(apiUrl: string, secret: string);
+    moderate(input: {
+        action: "leave" | "blacklist";
+        guildId: string;
+        actorUserId: string;
+        reason: string;
+        idempotencyKey: string;
+    }): Promise<{
+        operationId: string;
+        outcome: "completed" | "requires_review" | "failed" | "queued" | "not_currently_installed" | "accepted_for_retry" | "already_blacklisted";
+        paidSlotsReleased: number;
+    }>;
+}
+export interface HostedBotInviteGate {
+    isEnabled(): Promise<boolean>;
+}
+export declare class HostedBotInviteGateClient implements HostedBotInviteGate {
+    private readonly apiUrl;
+    private readonly secret;
+    constructor(apiUrl: string, secret: string);
+    isEnabled(): Promise<boolean>;
+}
+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>;
+}
+export interface HostedServerOwnerObservation {
+    username: string;
+    observedAt: string;
+}
+export declare class PostgresHostedGuildSafety implements HostedGuildSafety {
+    #private;
+    constructor(database: DatabasePool);
+    isBlacklisted(guildId: string): Promise<boolean>;
+    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;
+    private readonly client;
+    private readonly logger;
+    private readonly shardScope?;
+    constructor(database: DatabasePool, client: Client, logger: InteractionLogger, shardScope?: {
+        shardId: number;
+        shardCount: number;
+    } | undefined);
+    start(): void;
+    runOnce(): Promise<void>;
+    deliverOperation(input: {
+        operationId: string;
+        guildId: string;
+    }): Promise<HostedServerLeaveDeliveryOutcome>;
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=hosted-server-moderation.d.ts.map

package/dist/hosted-server-moderation.js

@@ -0,0 +1,226 @@
+import { HostedServerSafetyRepository, } from "@helyx/database";
+import { z } from "zod";
+const resultSchema = z
+    .object({
+    operationId: z.uuid(),
+    guildId: z.string().regex(/^\d{17,20}$/u),
+    action: z.enum(["leave", "blacklist"]),
+    outcome: z.enum([
+        "queued",
+        "completed",
+        "already_blacklisted",
+        "not_currently_installed",
+        "accepted_for_retry",
+        "requires_review",
+        "failed",
+    ]),
+    paidSlotsReleased: z.number().int().nonnegative(),
+})
+    .passthrough();
+const botInviteGateSchema = z.object({ enabled: z.boolean() }).strict();
+export class HostedServerModerationClient {
+    apiUrl;
+    secret;
+    constructor(apiUrl, secret) {
+        this.apiUrl = apiUrl;
+        this.secret = secret;
+    }
+    async moderate(input) {
+        const response = await fetch(new URL(`/v1/internal/hosted-server-moderation/${input.action}`, this.apiUrl), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.secret}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                guildId: input.guildId,
+                actorUserId: input.actorUserId,
+                reason: input.reason,
+                idempotencyKey: input.idempotencyKey,
+            }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok)
+            throw new Error(`Hosted moderation request failed with ${response.status}`);
+        const result = resultSchema.parse(await response.json());
+        if (result.guildId !== input.guildId || result.action !== input.action)
+            throw new Error("Hosted moderation response did not match the request");
+        return {
+            operationId: result.operationId,
+            outcome: result.outcome,
+            paidSlotsReleased: result.paidSlotsReleased,
+        };
+    }
+}
+export class HostedBotInviteGateClient {
+    apiUrl;
+    secret;
+    constructor(apiUrl, secret) {
+        this.apiUrl = apiUrl;
+        this.secret = secret;
+    }
+    async isEnabled() {
+        const response = await fetch(new URL("/v1/internal/incident-gates/bot-invites", this.apiUrl), {
+            headers: { authorization: `Bearer ${this.secret}` },
+            signal: AbortSignal.timeout(3_000),
+        });
+        if (!response.ok)
+            throw new Error(`Bot Invite gate request failed with ${response.status}`);
+        return botInviteGateSchema.parse(await response.json()).enabled;
+    }
+}
+export class PostgresHostedGuildSafety {
+    #repository;
+    constructor(database) {
+        this.#repository = new HostedServerSafetyRepository(database);
+    }
+    async isBlacklisted(guildId) {
+        return (await this.#repository.getState(guildId)).blacklisted;
+    }
+    blacklistedGuildIds(guildIds) {
+        return this.#repository.getBlacklistedGuildIds(guildIds);
+    }
+    recordAutomaticLeave(guildId) {
+        return this.#repository.enqueueAutomaticLeave(guildId);
+    }
+    async observeOwner(guild) {
+        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));
+        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 {
+    client;
+    logger;
+    shardScope;
+    #repository;
+    #timer;
+    #active;
+    #stopped = false;
+    constructor(database, client, logger, shardScope) {
+        this.client = client;
+        this.logger = logger;
+        this.shardScope = shardScope;
+        this.#repository = new HostedServerSafetyRepository(database);
+    }
+    start() {
+        if (this.#timer || this.#stopped)
+            return;
+        this.#runSoon();
+        this.#timer = setInterval(() => this.#runSoon(), 15_000);
+        this.#timer.unref();
+    }
+    async runOnce() {
+        if (this.#stopped || this.#active)
+            return this.#active;
+        this.#active = this.#drain().finally(() => {
+            this.#active = undefined;
+        });
+        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)
+            clearInterval(this.#timer);
+        this.#timer = undefined;
+        await this.#active;
+    }
+    async #drain() {
+        const claims = await this.#repository.claimLeaveDeliveries({
+            limit: 10,
+            leaseSeconds: 30,
+            ...(this.shardScope ?? {}),
+        });
+        await Promise.all(claims.map((claim) => this.#deliver(claim)));
+    }
+    #runSoon() {
+        void this.runOnce().catch(() => {
+            this.logger.error({
+                event: "hosted_moderation.leave_claim_failed",
+                reasonCode: "database_unavailable",
+            }, "Hosted server leave claims are temporarily unavailable");
+        });
+    }
+    async #deliver(claim) {
+        const guild = this.client.guilds.cache.get(claim.guildId);
+        if (!guild) {
+            await this.#repository.completeLeaveDelivery(claim, "not_currently_installed");
+            return "not_currently_installed";
+        }
+        try {
+            await guild.leave();
+            await this.#repository.completeLeaveDelivery(claim, "completed");
+            this.logger.info({
+                event: "hosted_moderation.leave_completed",
+                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 "not_currently_installed";
+            }
+            const outcome = await this.#repository.failLeaveDelivery({
+                claim,
+                failureCode,
+                retryAfterSeconds: Math.min(3_600, 15 * 2 ** claim.attemptCount),
+            });
+            this.logger.warn({
+                event: "hosted_moderation.leave_deferred",
+                guildId: claim.guildId,
+                operationId: claim.operationId,
+                failureCode,
+                outcome,
+            }, "Hosted server leave will be retried or reviewed");
+            return outcome === "requires_review"
+                ? outcome
+                : outcome === "retry"
+                    ? "accepted_for_retry"
+                    : "queued";
+        }
+    }
+}
+function classifyLeaveFailure(error) {
+    if (typeof error !== "object" || error === null)
+        return "discord_transient";
+    const candidate = error;
+    const code = candidate.code;
+    if (code === 10_004 || code === 50_001)
+        return "discord_not_installed";
+    const status = candidate.status;
+    if (status === 401 || status === 403)
+        return "discord_authentication";
+    if (status === 429)
+        return "discord_rate_limited";
+    return "discord_transient";
+}
+//# sourceMappingURL=hosted-server-moderation.js.map

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

package/dist/index.js

@@ -1,7 +1,7 @@
 import { parseBotEnvironment } from "@helyx/config";
 import { StatusHeartbeatReporter } from "@helyx/status-client";
 import { safeError, ServiceRegistry } from "@helyx/core";
-import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, InteractionSessionRepository, PremiumAllocationRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
+import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, HostedServerSafetyRepository, InteractionSessionRepository, EckoOperationsRepository, PremiumAllocationRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
 import { createPlatformServices, gamingStatisticsRecordOwner, achievementContributionRecordOwner, PostgresPrivacyProviderExecutor, PlatformMemberRoleGrantOwnershipService, PostgresMemberRoleGrantOwnershipStore, } from "@helyx/platform";
 import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
@@ -19,9 +19,10 @@ import { loadConfiguredModulePackages, platformServiceOptions, } from "./modules
 import { resolveModulePackageSpecifiers } from "./module-configuration.js";
 import { createPermissionsModule } from "./permissions-module.js";
 import { createManagementModule } from "./management-module.js";
-import { DiscordMessageDeliveryService, DiscordMemberEnforcementService, DiscordMemberRoleService, DiscordVerificationMemberService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
+import { DiscordMessageDeliveryService, DiscordMemberRoleService, DiscordVerificationMemberService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
+import { DiscordModerationMemberEnforcementAdapter } from "./discord-member-enforcement-service.js";
 import { DiscordModuleLoggingService } from "./module-logging.js";
-import { BotControlService, createBotControlServer, DiscordGuildResourceDirectory, } from "./control-server.js";
+import { BotControlService, BotControlTransportError, createBotControlServer, DiscordGuildResourceDirectory, } from "./control-server.js";
 import { HttpVerificationService } from "./verification-service.js";
 import { startShardSupervisor } from "./shard-supervisor.js";
 import { parseShardWorkerLaunchContract, startShardWorker, } from "./shard-worker.js";
@@ -30,6 +31,9 @@ import { shardHealthSnapshotSchema, } from "./shard-contracts.js";
 import { createSupportModule } from "./support-module.js";
 import { createOAuthModule } from "./oauth-module.js";
 import { createPrivacyModule } from "./privacy-module.js";
+import { installModerationPlatformServices } from "./moderation-platform-services.js";
+import { EckoEvidenceReceiver } from "./ecko-evidence-receiver.js";
+import { EckoTransportAuthenticator } from "./ecko-transport-auth.js";
 import { REVIEWED_PREMIUM_MODULE_IDS } from "@helyx/module-manifest";
 import { createPremiumActivationModule } from "./premium-activation-module.js";
 import { DiscordPremiumGuildAuthority } from "./premium-guild-authority.js";
@@ -50,6 +54,7 @@ import { discordRestOptions } from "./discord-rest.js";
 import { discordBotStatusService } from "./status-producer.js";
 import { assertReviewedPremiumCatalogue, requirePremiumProviderEnvironment, } from "./premium-access.js";
 import { enforcePremiumCatalogue, PREMIUM_CATALOGUE_ENFORCEMENT_INTERVAL_MS, } from "./premium-catalogue-enforcement.js";
+import { HostedBotInviteGateClient, HostedServerLeaveWorker, HostedServerModerationClient, PostgresHostedGuildSafety, } from "./hosted-server-moderation.js";
 export { loadConfiguredModulePackages } from "./modules.js";
 export { resolveModulePackageSpecifiers } from "./module-configuration.js";
 export * from "./control-server.js";
@@ -119,6 +124,17 @@ async function startUnshardedBot(processEnvironment) {
         sslMode: environment.DATABASE_SSL,
         applicationName: "helyx-bot",
     });
+    const hostedOwnerObserver = new PostgresHostedGuildSafety(database);
+    const eckoOperations = new EckoOperationsRepository(database);
+    const hostedSafety = environment.HELYX_HOSTED_MODERATION_ENABLED
+        ? hostedOwnerObserver
+        : undefined;
+    const developerModeration = environment.HELYX_HOSTED_MODERATION_ENABLED
+        ? new HostedServerModerationClient(environment.HELYX_CLOUD_API_URL, environment.HELYX_BOT_CONTROL_SECRET)
+        : undefined;
+    const hostedInviteGate = environment.HELYX_HOSTED_MODERATION_ENABLED
+        ? new HostedBotInviteGateClient(environment.HELYX_CLOUD_API_URL, environment.HELYX_BOT_CONTROL_SECRET)
+        : undefined;
     const privacyDatabase = environment.HELYX_PRIVACY_ENABLED &&
         environment.HELYX_PRIVACY_EXECUTOR_DATABASE_URL &&
         environment.HELYX_PRIVACY_EXECUTOR_DATABASE_SSL
@@ -153,11 +169,12 @@ async function startUnshardedBot(processEnvironment) {
             verifiedMigrationCount: migrationResult.verified.length,
         }, "Core database ready");
         const cleanupExpiredCoreRecords = async () => {
-            const [sessions, rateLimits, verificationAudit, commandRecords] = await Promise.all([
+            const [sessions, rateLimits, verificationAudit, commandRecords, hostedLeaveDeliveries,] = await Promise.all([
                 new InteractionSessionRepository(database).deleteExpired(),
                 new RateLimitRepository(database).deleteExpired(),
                 new AuditRepository(database).deleteModuleEventsOlderThanMonths("helyx.verification", 12),
                 new GuildCommandRepository(database).deleteExpired(12),
+                new HostedServerSafetyRepository(database).deleteTerminalLeaveDeliveriesOlderThanMonths(24),
             ]);
             const commandRecordCount = commandRecords.history +
                 commandRecords.idempotencyKeys +
@@ -166,13 +183,15 @@ async function startUnshardedBot(processEnvironment) {
             if (sessions > 0 ||
                 rateLimits > 0 ||
                 verificationAudit > 0 ||
-                commandRecordCount > 0) {
+                commandRecordCount > 0 ||
+                hostedLeaveDeliveries > 0) {
                 bootstrapLogger.info({
                     event: "database.retention_cleaned",
                     interactionSessions: sessions,
                     rateLimitWindows: rateLimits,
                     verificationAuditEvents: verificationAudit,
                     commandRecords: commandRecordCount,
+                    hostedLeaveDeliveries,
                 }, "Expired core records removed");
             }
         };
@@ -213,7 +232,7 @@ async function startUnshardedBot(processEnvironment) {
         premiumCatalogueTimer.unref();
         const client = new Client({
             rest: discordRestOptions,
-            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED),
+            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED, environment.HELYX_RUNTIME_PROFILE),
             partials: [Partials.Message, Partials.Channel, Partials.Reaction],
             allowedMentions: { parse: [] },
         });
@@ -339,6 +358,7 @@ async function startUnshardedBot(processEnvironment) {
                 health: {
                     getHealth: buildHealth,
                 },
+                ...(developerModeration ? { moderation: developerModeration } : {}),
             })
             : undefined;
         const modules = [
@@ -376,11 +396,26 @@ async function startUnshardedBot(processEnvironment) {
         platformServices.set(HELYX_SERVICE_NAMES.resourceAuthorization, new CoreResourceAuthorizationService(platformServices.get(HELYX_SERVICE_NAMES.permissions)));
         platformServices.set(HELYX_SERVICE_NAMES.discordMessages, new DiscordMessageDeliveryService(client));
         platformServices.set(HELYX_SERVICE_NAMES.discordOwnedMessages, new DiscordOwnedMessageDeletionService(client));
-        platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordMemberEnforcementService(client));
+        platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordModerationMemberEnforcementAdapter(client));
         const memberRoles = new DiscordMemberRoleService(client);
         platformServices.set(HELYX_SERVICE_NAMES.memberRoles, memberRoles);
         platformServices.set(HELYX_SERVICE_NAMES.memberRoleGrants, new PlatformMemberRoleGrantOwnershipService(new PostgresMemberRoleGrantOwnershipStore(database), memberRoles));
         platformServices.set(HELYX_SERVICE_NAMES.discordResources, new DiscordResourceInspection(client));
+        const moderationPlatformServices = installModerationPlatformServices({
+            services: platformServices,
+            serviceAccess,
+            client,
+            modules: publicModules,
+            runtimeProfile: environment.HELYX_RUNTIME_PROFILE,
+            deploymentEnvironment: environment.HELYX_DEPLOYMENT_ENVIRONMENT,
+            embedded: {
+                workers: environment.HELYX_AUTOMOD_EMBEDDED_WORKERS,
+                maximumItems: environment.HELYX_AUTOMOD_EMBEDDED_QUEUE_ITEMS,
+                maximumBytes: environment.HELYX_AUTOMOD_EMBEDDED_QUEUE_BYTES,
+                maximumItemsPerGuild: environment.HELYX_AUTOMOD_EMBEDDED_QUEUE_ITEMS_PER_GUILD,
+                refreshIntervalMs: environment.HELYX_AUTOMOD_EMBEDDED_REFRESH_SECONDS * 1_000,
+            },
+        });
         platformServices.set(HELYX_SERVICE_NAMES.discordGuildHealth, new DiscordGuildHealthInspection(client, publicModules, serviceAccess));
         platformServices.set(HELYX_SERVICE_NAMES.discordAnalytics, new DiscordAnalyticsInspection(client));
         if (serviceOptions.inviteFingerprintKey)
@@ -402,7 +437,8 @@ async function startUnshardedBot(processEnvironment) {
             ...(cloudManagementModule ? [cloudManagementModule.manifest.id] : []),
             ...(operationsModule ? [operationsModule.manifest.id] : []),
         ]);
-        const prepareGuilds = installGuildTracking(client, database, publicModules, bootstrapLogger, enabledCoreModuleIds, undefined, environment.HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS * 1_000, undefined, environment.DISCORD_CLIENT_ID);
+        const prepareGuilds = installGuildTracking(client, database, publicModules, bootstrapLogger, enabledCoreModuleIds, undefined, environment.HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS * 1_000, undefined, environment.DISCORD_CLIENT_ID, hostedSafety, hostedInviteGate, hostedOwnerObserver);
+        const hostedLeaveWorker = new HostedServerLeaveWorker(database, client, bootstrapLogger);
         const commandsReady = installInteractions(client, modules, {
             globalCommandMode: environment.HELYX_GLOBAL_COMMAND_MODE,
             ...(environment.DISCORD_INTERNAL_GUILD_ID
@@ -419,7 +455,10 @@ async function startUnshardedBot(processEnvironment) {
                 ...(operationsModule ? [operationsModule.manifest.id] : []),
             ]),
         }, bootstrapLogger, serviceAccess);
-        const moduleEvents = installModuleEvents(client, publicModules, bootstrapLogger, serviceAccess);
+        const moduleEvents = installModuleEvents(client, publicModules, bootstrapLogger, serviceAccess, {
+            runtimeProfile: environment.HELYX_RUNTIME_PROFILE,
+            evidenceStore: moderationPlatformServices.evidenceStore,
+        });
         const controlService = new BotControlService(database, [
             ...publicModules,
             gamingStatisticsRecordOwner,
@@ -449,6 +488,7 @@ async function startUnshardedBot(processEnvironment) {
                 return;
             shuttingDown = true;
             prepareGuilds.stop();
+            await hostedLeaveWorker?.stop();
             process.off("SIGINT", onSigint);
             process.off("SIGTERM", onSigterm);
             if (retentionCleanupTimer)
@@ -480,6 +520,12 @@ async function startUnshardedBot(processEnvironment) {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "module_events.stop_failed", error: safeError(error) }, "Module event shutdown failed");
             });
+            await moderationPlatformServices.embeddedScanner
+                ?.stop()
+                .catch((error) => {
+                process.exitCode = 1;
+                bootstrapLogger.error({ event: "automod.embedded_stop_failed", error: safeError(error) }, "Embedded Auto Moderation scanner shutdown failed");
+            });
             await runtime.stop().catch((error) => {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "runtime.stop_failed", error: safeError(error) }, "Runtime shutdown failed");
@@ -511,8 +557,14 @@ async function startUnshardedBot(processEnvironment) {
         process.once("SIGTERM", onSigterm);
         try {
             await runtime.start();
+            await moderationPlatformServices.embeddedScanner
+                ?.synchronize()
+                .catch((error) => {
+                bootstrapLogger.warn({ event: "automod.embedded_sync_failed", error: safeError(error) }, "Embedded Auto Moderation scanner started in Standard fallback");
+            });
             await client.login(environment.DISCORD_TOKEN);
             await commandsReady;
+            hostedLeaveWorker?.start();
             scheduledTasks = createScheduledTaskRunner({
                 database,
                 modules: publicModules,
@@ -565,11 +617,38 @@ async function startUnshardedBot(processEnvironment) {
             }
             await cloudConnector.start();
             if (environment.HELYX_BOT_CONTROL_SECRET) {
+                const ecko = environment.HELYX_ECKO_TRANSPORT_SECRET
+                    ? {
+                        authenticator: new EckoTransportAuthenticator(environment.HELYX_DEPLOYMENT_ENVIRONMENT, [
+                            environment.HELYX_ECKO_TRANSPORT_SECRET,
+                            ...(environment.HELYX_ECKO_TRANSPORT_PREVIOUS_SECRET
+                                ? [environment.HELYX_ECKO_TRANSPORT_PREVIOUS_SECRET]
+                                : []),
+                        ]),
+                        registry: moderationPlatformServices.scannerRegistry,
+                        evidence: new EckoEvidenceReceiver(moderationPlatformServices.evidenceStore, environment.HELYX_DEPLOYMENT_ENVIRONMENT, Buffer.from(environment.HELYX_ECKO_TRANSPORT_SECRET, "base64")),
+                        gateState: () => eckoOperations.readGate(),
+                        telemetry: {
+                            accept: (batch) => eckoOperations.acceptTelemetry(batch),
+                        },
+                    }
+                    : undefined;
                 controlServer = await createBotControlServer({
                     service: controlService,
                     secret: environment.HELYX_BOT_CONTROL_SECRET,
+                    deliverHostedServerLeave: (input) => hostedLeaveWorker.deliverOperation(input),
+                    refreshHostedServerOwner: async (guildId) => {
+                        const guild = client.guilds.cache.get(guildId);
+                        if (!guild)
+                            throw new BotControlTransportError(404, "The hosted server is not installed");
+                        return hostedOwnerObserver.refreshOwner(guild);
+                    },
                     logger: { level: environment.LOG_LEVEL },
+                    runtimeConfiguration: {
+                        hostedModerationEnabled: environment.HELYX_HOSTED_MODERATION_ENABLED,
+                    },
                     guildCommands: new GuildCommandReadService(database, environment.DISCORD_CLIENT_ID, () => guildCommandWorker?.getHealth(), environment.DISCORD_TOKEN, environment.HELYX_GUILD_COMMAND_WRITES_ENABLED, environment.HELYX_GUILD_COMMAND_WRITE_GUILD_IDS, environment.HELYX_GUILD_COMMAND_WRITE_SCOPE === "all", modules),
+                    ...(ecko ? { ecko } : {}),
                 });
                 await controlServer.listen({
                     host: "::",
@@ -648,7 +727,7 @@ function deploymentReference(processEnvironment) {
         processEnvironment.GIT_COMMIT_SHA;
     return value?.trim().slice(0, 12) || undefined;
 }
-export function gatewayIntentsForModules(modules, messageContentEnabled = false, guildMembersEnabled = false) {
+export function gatewayIntentsForModules(modules, messageContentEnabled = false, guildMembersEnabled = false, runtimeProfile = "hosted") {
     const intents = [GatewayIntentBits.Guilds];
     if (modules.some((module) => module.events?.messageReactionAdd?.length ||
         module.events?.messageReactionRemove?.length ||
@@ -656,8 +735,12 @@ export function gatewayIntentsForModules(modules, messageContentEnabled = false,
         module.events?.messageReactionRemoveEmoji?.length)) {
         intents.push(GatewayIntentBits.GuildMessageReactions);
     }
-    const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.length);
-    const requiresMessageContent = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content"));
+    const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.some(({ featureId }) => !featureId || runtimeProfile === "self-hosted") ||
+        module.events?.privilegedMessageUpdate?.some(({ featureId }) => !featureId || runtimeProfile === "self-hosted"));
+    const requiresMessageContent = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content") ||
+        (runtimeProfile === "self-hosted" &&
+            module.manifest.manifestVersion === "0.5" &&
+            module.manifest.features.some((feature) => feature.requiredDiscordCapabilities.includes("message-content"))));
     if (((hasPrivilegedMessageCreate || requiresMessageContent) &&
         messageContentEnabled) ||
         modules.some((module) => module.events?.guildMessageCreate?.length ||
@@ -679,6 +762,12 @@ export function gatewayIntentsForModules(modules, messageContentEnabled = false,
     if (modules.some((module) => module.events?.guildVoiceSession?.length)) {
         intents.push(GatewayIntentBits.GuildVoiceStates);
     }
+    if (modules.some((module) => module.events?.discordAutoModerationRuleCreate?.length ||
+        module.events?.discordAutoModerationRuleUpdate?.length ||
+        module.events?.discordAutoModerationRuleDelete?.length))
+        intents.push(GatewayIntentBits.AutoModerationConfiguration);
+    if (modules.some((module) => module.events?.discordAutoModerationActionExecution?.length))
+        intents.push(GatewayIntentBits.AutoModerationExecution);
     if (modules.some((module) => module.events?.guildEmojiDelete?.length ||
         module.events?.guildEmojiUpdate?.length)) {
         intents.push(GatewayIntentBits.GuildExpressions);

package/dist/moderation-action-registry.d.ts

@@ -0,0 +1,11 @@
+import type { ModerationActionRegistryService, ModerationActionResultV2, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
+import type { DiscordViolationEvidenceDeliveryAdapter } from "./discord-violation-thread-service.js";
+/** Local closed registry. In sharded mode it is instantiated in each guild owner. */
+export declare class BotModerationActionRegistry implements ModerationActionRegistryService {
+    #private;
+    private readonly services;
+    private readonly evidenceDelivery?;
+    constructor(modules: readonly ModuleDefinition[], services: ServiceAccess, evidenceDelivery?: DiscordViolationEvidenceDeliveryAdapter | undefined);
+    execute(input: Parameters<ModerationActionRegistryService["execute"]>[0]): Promise<ModerationActionResultV2>;
+}
+//# sourceMappingURL=moderation-action-registry.d.ts.map