@helyx/bot 1.0.1 → 1.2.0

package/dist/shard-contracts.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { CLOUD_MAX_RESOURCE_IMPORT_BYTES } from "@helyx/control-protocol";
+import { AUTOMOD_SCANNER_LIMITS } from "@helyx/sdk";
 import { signedAssessmentEnvelopeSchema } from "@helyx/verification-contracts";
 export const SHARD_CONTRACT_VERSION = 1;
 // Guild dashboard state includes the bounded module catalogue as well as the
@@ -9,8 +11,30 @@ export const SHARD_CONTROL_TIMEOUT_MS = 30_000;
 export const SHARD_HEALTH_STALE_MS = 30_000;
 export const SHARD_LEASE_HEARTBEAT_TIMEOUT_MS = 20_000;
 const snowflake = z.string().regex(/^\d{17,20}$/u);
+const operationId = z.uuid();
 const safeIdentifier = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u);
 const dateTime = z.iso.datetime({ offset: true });
+const boundedEnhancedResult = z
+    .unknown()
+    .refine((value) => value !== null &&
+    typeof value === "object" &&
+    boundedJsonBytes(value, AUTOMOD_SCANNER_LIMITS.resultBytes), "Enhanced Auto Moderation result exceeds the transport limit");
+const enhancedEvidence = z
+    .object({
+    sourceEventId: z.string().regex(/^[a-f0-9]{64}$/u),
+    configurationRevision: z.string().min(1).max(160),
+    guildId: snowflake,
+    channelId: snowflake,
+    messageId: snowflake,
+    authorUserId: snowflake,
+    content: z
+        .string()
+        .min(1)
+        .max(AUTOMOD_SCANNER_LIMITS.messageCharacters)
+        .refine((value) => Buffer.byteLength(value, "utf8") <=
+        AUTOMOD_SCANNER_LIMITS.messageUtf8Bytes, "Enhanced Auto Moderation evidence exceeds the transport limit"),
+})
+    .strict();
 const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
 const mutationContext = z
     .object({
@@ -230,6 +254,39 @@ export const shardHealthSnapshotSchema = z
         });
 });
 export const shardControlOperationSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("automod.enhanced.configuration.page"),
+        cursor: z.string().min(1).max(512).optional(),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(AUTOMOD_SCANNER_LIMITS.configurationPageServers),
+        knownFingerprint: z.string().min(1).max(128).optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("automod.enhanced.result.accept"),
+        guildId: snowflake,
+        result: boundedEnhancedResult,
+        evidence: enhancedEvidence.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("hosted-server.leave.deliver"),
+        guildId: snowflake,
+        operationId,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("hosted-server.owner.refresh"),
+        guildId: snowflake,
+    })
+        .strict(),
     z.object({ kind: z.literal("guild.state.get"), guildId: snowflake }).strict(),
     z
         .object({
@@ -300,6 +357,16 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.configuration.preview"),
+        guildId: snowflake,
+        moduleId,
+        value: configurationValue,
+        input: managedResourceObject,
+        ...mutationContext.shape,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.permissions.update"),
@@ -326,6 +393,16 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         guildId: snowflake,
         moduleId,
         actionId: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+        inspectionRevision: z.string().min(1).max(200).optional(),
+        ...mutationContext.shape,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.action.preview"),
+        guildId: snowflake,
+        moduleId,
+        actionId: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
         ...mutationContext.shape,
     })
         .strict(),
@@ -387,6 +464,19 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("guild.module.resource.import"),
+        guildId: snowflake,
+        moduleId,
+        resourceType,
+        format: z.literal("utf8_text"),
+        content: z
+            .string()
+            .refine((value) => Buffer.byteLength(value, "utf8") <= CLOUD_MAX_RESOURCE_IMPORT_BYTES, "Managed resource import exceeds the transport limit"),
+        ...mutationContext.shape,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("guild.module.resource.create"),
@@ -962,6 +1052,13 @@ export function assertShardMessageSize(value) {
 }
 export async function executeShardControlOperation(handler, operation) {
     switch (operation.kind) {
+        case "automod.enhanced.configuration.page":
+            throw new Error("Enhanced Auto Moderation configuration requires the shard leader");
+        case "automod.enhanced.result.accept":
+            throw new Error("Enhanced Auto Moderation result delivery requires the shard worker");
+        case "hosted-server.leave.deliver":
+        case "hosted-server.owner.refresh":
+            throw new Error("Hosted leave delivery requires the shard worker");
         case "guild.presence.list":
             return handler.listGuildPresence({
                 guildIds: operation.guildIds,
@@ -1022,6 +1119,15 @@ export async function executeShardControlOperation(handler, operation) {
                 correlationId: operation.correlationId,
             });
         }
+        case "guild.module.configuration.preview":
+            return handler.previewConfiguration({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                value: operation.value,
+                input: operation.input,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
         case "guild.module.permissions.update": {
             return handler.updatePermissions({
                 guildId: operation.guildId,
@@ -1044,6 +1150,18 @@ export async function executeShardControlOperation(handler, operation) {
         }
         case "guild.module.action.execute": {
             return handler.executeDashboardAction({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                actionId: operation.actionId,
+                ...(operation.inspectionRevision === undefined
+                    ? {}
+                    : { inspectionRevision: operation.inspectionRevision }),
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
+        }
+        case "guild.module.action.preview": {
+            return handler.previewDashboardAction({
                 guildId: operation.guildId,
                 moduleId: operation.moduleId,
                 actionId: operation.actionId,
@@ -1099,6 +1217,16 @@ export async function executeShardControlOperation(handler, operation) {
                 actorUserId: operation.actorUserId,
                 correlationId: operation.correlationId,
             });
+        case "guild.module.resource.import":
+            return handler.importManagedResource({
+                guildId: operation.guildId,
+                moduleId: operation.moduleId,
+                resourceType: operation.resourceType,
+                format: operation.format,
+                content: operation.content,
+                actorUserId: operation.actorUserId,
+                correlationId: operation.correlationId,
+            });
         case "guild.module.resource.create":
             return handler.createManagedResource({
                 guildId: operation.guildId,
@@ -1158,7 +1286,7 @@ export async function executeShardControlOperation(handler, operation) {
                 correlationId: operation.correlationId,
             });
         case "support.notification.send": {
-            return handler.sendSupportNotification({
+            await handler.sendSupportNotification({
                 notificationId: operation.notificationId,
                 reference: operation.reference,
                 caseType: operation.caseType,
@@ -1166,6 +1294,11 @@ export async function executeShardControlOperation(handler, operation) {
                 reportedSeverity: operation.reportedSeverity,
                 source: operation.source,
             });
+            // Child-process IPC uses JSON serialization. Returning the handler's void
+            // result would remove the required `result` property from the success
+            // envelope, causing the supervisor to discard a successful Discord send
+            // and retry it after a timeout.
+            return null;
         }
         case "verification.result.accept":
             return handler.acceptVerificationResult(operation.envelope);
@@ -1221,4 +1354,12 @@ function isBoundedManagedResourceValue(value, depth = 0, budget = { keys: 0 }) {
 function hasBoundedManagedResourceBytes(value) {
     return (new TextEncoder().encode(JSON.stringify(value)).byteLength <= 48 * 1_024);
 }
+function boundedJsonBytes(value, maximumBytes) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8") <= maximumBytes;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=shard-contracts.js.map

package/dist/shard-coordinator.d.ts

@@ -5,9 +5,9 @@ declare const generationDescriptorSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     applicationId: z.ZodString;
     environment: z.ZodEnum<{
+        production: "production";
         development: "development";
         test: "test";
-        production: "production";
     }>;
     generation: z.ZodString;
     shardCount: z.ZodNumber;

package/dist/shard-ecko-scanner-registry.d.ts

@@ -0,0 +1,38 @@
+import { type AutoModerationEnhancedResultOutcome, type AutoModerationScannerAdapterSelection, type AutoModerationScannerProviderRegistryService } from "@helyx/sdk";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+export interface ShardEckoResultRoute {
+    guildId: string;
+    result: unknown;
+    evidence?: {
+        sourceEventId: string;
+        configurationRevision: string;
+        guildId: string;
+        channelId: string;
+        messageId: string;
+        authorUserId: string;
+        content: string;
+    };
+}
+/**
+ * Supervisor-only Ecko facade. Configuration is read from the fenced leader's
+ * allowlisted provider. Results and one-use evidence are routed to the guild
+ * owner, where the worker registry performs all validation and actions.
+ */
+export declare class ShardEckoScannerRegistry implements AutoModerationScannerProviderRegistryService {
+    #private;
+    private readonly input;
+    constructor(input: {
+        configurationRegistry(): AutoModerationScannerProviderRegistryService | undefined;
+        routeConfiguration?(input: {
+            cursor?: string;
+            limit: number;
+            knownFingerprint?: string;
+        }): ReturnType<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>;
+        evidenceStore: TransientViolationEvidenceStore;
+        routeResult(input: ShardEckoResultRoute): Promise<AutoModerationEnhancedResultOutcome>;
+    });
+    select(): Promise<AutoModerationScannerAdapterSelection>;
+    getConfigurationPage(input: Parameters<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>[0]): Promise<import("@helyx/sdk").AutoModerationScannerConfigurationPageV1>;
+    acceptResult(input: Parameters<AutoModerationScannerProviderRegistryService["acceptResult"]>[0]): Promise<AutoModerationEnhancedResultOutcome>;
+}
+//# sourceMappingURL=shard-ecko-scanner-registry.d.ts.map

package/dist/shard-ecko-scanner-registry.js

@@ -0,0 +1,96 @@
+import { AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID, } from "@helyx/sdk";
+/**
+ * Supervisor-only Ecko facade. Configuration is read from the fenced leader's
+ * allowlisted provider. Results and one-use evidence are routed to the guild
+ * owner, where the worker registry performs all validation and actions.
+ */
+export class ShardEckoScannerRegistry {
+    input;
+    constructor(input) {
+        this.input = input;
+    }
+    select() {
+        return Promise.resolve({
+            adapter: "unavailable",
+            available: false,
+            reason: "dependency_unhealthy",
+        });
+    }
+    async getConfigurationPage(input) {
+        const registry = this.input.configurationRegistry();
+        if (registry)
+            return registry.getConfigurationPage(input);
+        if (!this.input.routeConfiguration)
+            throw new Error("Ecko configuration leader is unavailable");
+        return this.input.routeConfiguration({
+            limit: input.limit,
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            ...(input.knownFingerprint
+                ? { knownFingerprint: input.knownFingerprint }
+                : {}),
+        });
+    }
+    async acceptResult(input) {
+        if (input.adapter !== "hosted_ecko" ||
+            input.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+            input.contractVersion !== AUTOMOD_ENHANCED_CONTRACT_VERSION) {
+            this.#discard(input.evidenceReference);
+            return rejected("wrong_owner");
+        }
+        const guildId = resultGuildId(input.result);
+        if (!guildId) {
+            this.#discard(input.evidenceReference);
+            return rejected("invalid_envelope");
+        }
+        const evidence = input.evidenceReference
+            ? this.#takeEvidence(input.evidenceReference)
+            : undefined;
+        try {
+            return await this.input.routeResult({
+                guildId,
+                result: input.result,
+                ...(evidence ? { evidence } : {}),
+            });
+        }
+        catch (error) {
+            return rejected(isDeadlineError(error) ? "stale" : "wrong_owner");
+        }
+    }
+    #takeEvidence(reference) {
+        const read = this.input.evidenceStore.consume(reference);
+        if (read.outcome !== "available" ||
+            reference.source !== "enhanced_scanner" ||
+            reference.messageId === null)
+            return undefined;
+        return {
+            sourceEventId: reference.sourceEventId,
+            configurationRevision: reference.configurationRevision,
+            guildId: reference.guildId,
+            channelId: reference.channelId,
+            messageId: reference.messageId,
+            authorUserId: reference.authorUserId,
+            content: read.content,
+        };
+    }
+    #discard(reference) {
+        if (reference)
+            this.input.evidenceStore.discard(reference);
+    }
+}
+function resultGuildId(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const guildId = value["guildId"];
+    return typeof guildId === "string" && /^\d{17,20}$/u.test(guildId)
+        ? guildId
+        : undefined;
+}
+function isDeadlineError(error) {
+    return (error instanceof Error &&
+        (error.message.toLowerCase().includes("time") ||
+            error.message.toLowerCase().includes("expired")));
+}
+function rejected(code) {
+    return { outcome: "rejected", code };
+}
+//# sourceMappingURL=shard-ecko-scanner-registry.js.map

package/dist/shard-router.d.ts

@@ -1,6 +1,9 @@
+import { type AutoModerationEnhancedResultOutcome } from "@helyx/sdk";
 import { type BotControlHandler } from "./control-server.js";
 import { type ShardControlRequest, type ShardControlResponse } from "./shard-contracts.js";
 import type { ShardCoordinator, ShardLeaderLease, ShardLease } from "./shard-coordinator.js";
+import type { ShardEckoResultRoute } from "./shard-ecko-scanner-registry.js";
+import type { AutoModerationScannerProviderRegistryService } from "@helyx/sdk";
 type LocalDispatcher = (shardId: number, request: ShardControlRequest) => Promise<ShardControlResponse>;
 export declare class ShardControlRouter implements BotControlHandler {
     #private;
@@ -11,13 +14,30 @@ export declare class ShardControlRouter implements BotControlHandler {
         localLeases: ReadonlyMap<number, ShardLease>;
         dispatchLocal: LocalDispatcher;
         privacy?: Pick<BotControlHandler, "listPrivacyProviders" | "capturePrivacy" | "erasePrivacy">;
+        leaderScannerRegistry?: AutoModerationScannerProviderRegistryService;
         availability?: Pick<BotControlHandler, "listAvailabilityModules">;
         localLeaderLease?: ShardLeaderLease;
         coordinator?: ShardCoordinator;
         notificationGuildId?: string;
     });
     cleanupOAuthConsumer(input: Parameters<BotControlHandler["cleanupOAuthConsumer"]>[0]): ReturnType<BotControlHandler["cleanupOAuthConsumer"]>;
+    deliverHostedServerLeave(input: {
+        operationId: string;
+        guildId: string;
+    }): Promise<"queued" | "completed" | "not_currently_installed" | "accepted_for_retry" | "requires_review">;
+    refreshHostedServerOwner(guildId: string): Promise<{
+        username: string;
+        observedAt: string;
+    }>;
     listAvailabilityModules(): ReturnType<BotControlHandler["listAvailabilityModules"]>;
+    /** Routes an authenticated Ecko result to the current guild owner. */
+    acceptHostedEckoResult(input: ShardEckoResultRoute): Promise<AutoModerationEnhancedResultOutcome>;
+    /** Reads the fenced leader's current Enhanced configuration snapshot. */
+    getHostedEckoConfigurationPage(input: {
+        cursor?: string;
+        limit: number;
+        knownFingerprint?: string;
+    }): ReturnType<AutoModerationScannerProviderRegistryService["getConfigurationPage"]>;
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     canAccessDashboard(input: Parameters<BotControlHandler["canAccessDashboard"]>[0]): ReturnType<BotControlHandler["canAccessDashboard"]>;
     getGuildAccessPolicy(input: Parameters<BotControlHandler["getGuildAccessPolicy"]>[0]): ReturnType<BotControlHandler["getGuildAccessPolicy"]>;
@@ -28,13 +48,16 @@ export declare class ShardControlRouter implements BotControlHandler {
     setModuleStatus(input: Parameters<BotControlHandler["setModuleStatus"]>[0]): ReturnType<BotControlHandler["setModuleStatus"]>;
     completeFirstTimeCommandSetup(input: Parameters<BotControlHandler["completeFirstTimeCommandSetup"]>[0]): ReturnType<BotControlHandler["completeFirstTimeCommandSetup"]>;
     updateConfiguration(input: Parameters<BotControlHandler["updateConfiguration"]>[0]): ReturnType<BotControlHandler["updateConfiguration"]>;
+    previewConfiguration(input: Parameters<BotControlHandler["previewConfiguration"]>[0]): ReturnType<BotControlHandler["previewConfiguration"]>;
     updatePermissions(input: Parameters<BotControlHandler["updatePermissions"]>[0]): ReturnType<BotControlHandler["updatePermissions"]>;
     updateLoggingPolicy(input: Parameters<BotControlHandler["updateLoggingPolicy"]>[0]): ReturnType<BotControlHandler["updateLoggingPolicy"]>;
     executeDashboardAction(input: Parameters<BotControlHandler["executeDashboardAction"]>[0]): ReturnType<BotControlHandler["executeDashboardAction"]>;
+    previewDashboardAction(input: Parameters<BotControlHandler["previewDashboardAction"]>[0]): ReturnType<BotControlHandler["previewDashboardAction"]>;
     listManagedResources(input: Parameters<BotControlHandler["listManagedResources"]>[0]): ReturnType<BotControlHandler["listManagedResources"]>;
     readManagedResource(input: Parameters<BotControlHandler["readManagedResource"]>[0]): ReturnType<BotControlHandler["readManagedResource"]>;
     listManagedResourceRelation(input: Parameters<BotControlHandler["listManagedResourceRelation"]>[0]): ReturnType<BotControlHandler["listManagedResourceRelation"]>;
     previewManagedResource(input: Parameters<BotControlHandler["previewManagedResource"]>[0]): ReturnType<BotControlHandler["previewManagedResource"]>;
+    importManagedResource(input: Parameters<BotControlHandler["importManagedResource"]>[0]): ReturnType<BotControlHandler["importManagedResource"]>;
     createManagedResource(input: Parameters<BotControlHandler["createManagedResource"]>[0]): ReturnType<BotControlHandler["createManagedResource"]>;
     updateManagedResource(input: Parameters<BotControlHandler["updateManagedResource"]>[0]): ReturnType<BotControlHandler["updateManagedResource"]>;
     deleteManagedResource(input: Parameters<BotControlHandler["deleteManagedResource"]>[0]): ReturnType<BotControlHandler["deleteManagedResource"]>;

package/dist/shard-router.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID, AUTOMOD_SCANNER_LIMITS, } from "@helyx/sdk";
 import { BotControlTransportError, } from "./control-server.js";
 import { SHARD_CONTROL_TIMEOUT_MS, controlOperationGuildId, guildIdToShardId, shardControlOperationSchema, shardControlResponseSchema, } from "./shard-contracts.js";
 // Cross-region/public Redis connections used by local staging routinely take
@@ -7,6 +8,7 @@ import { SHARD_CONTROL_TIMEOUT_MS, controlOperationGuildId, guildIdToShardId, sh
 // deadline turned healthy leases into deterministic 503s. Keep the check
 // bounded while allowing normal network variance.
 const LEASE_VALIDATION_TIMEOUT_MS = 3_000;
+const ECKO_RESULT_TIMEOUT_MS = AUTOMOD_SCANNER_LIMITS.actionDeadlineSeconds * 1_000;
 export class ShardControlRouter {
     input;
     constructor(input) {
@@ -15,11 +17,28 @@ export class ShardControlRouter {
     cleanupOAuthConsumer(input) {
         return this.#route({ kind: "oauth.consumer.cleanup", ...input });
     }
+    deliverHostedServerLeave(input) {
+        return this.#route({ kind: "hosted-server.leave.deliver", ...input });
+    }
+    refreshHostedServerOwner(guildId) {
+        return this.#route({ kind: "hosted-server.owner.refresh", guildId });
+    }
     listAvailabilityModules() {
         if (!this.input.availability)
             return Promise.reject(new BotControlTransportError(503, "Module availability catalogue is unavailable"));
         return this.input.availability.listAvailabilityModules();
     }
+    /** Routes an authenticated Ecko result to the current guild owner. */
+    acceptHostedEckoResult(input) {
+        return this.#route({ kind: "automod.enhanced.result.accept", ...input }, remainingEnhancedDeadline(input.result));
+    }
+    /** Reads the fenced leader's current Enhanced configuration snapshot. */
+    getHostedEckoConfigurationPage(input) {
+        return this.#routeLeader({
+            kind: "automod.enhanced.configuration.page",
+            ...input,
+        });
+    }
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }
@@ -97,6 +116,12 @@ export class ShardControlRouter {
             ...input,
         }));
     }
+    previewConfiguration(input) {
+        return this.#route(shardControlOperationSchema.parse({
+            kind: "guild.module.configuration.preview",
+            ...input,
+        }));
+    }
     updatePermissions(input) {
         return this.#route({ kind: "guild.module.permissions.update", ...input });
     }
@@ -106,6 +131,9 @@ export class ShardControlRouter {
     executeDashboardAction(input) {
         return this.#route({ kind: "guild.module.action.execute", ...input });
     }
+    previewDashboardAction(input) {
+        return this.#route({ kind: "guild.module.action.preview", ...input });
+    }
     listManagedResources(input) {
         return this.#route(shardControlOperationSchema.parse({
             kind: "guild.module.resource.list",
@@ -130,6 +158,12 @@ export class ShardControlRouter {
             ...input,
         }));
     }
+    importManagedResource(input) {
+        return this.#route(shardControlOperationSchema.parse({
+            kind: "guild.module.resource.import",
+            ...input,
+        }));
+    }
     createManagedResource(input) {
         return this.#route(shardControlOperationSchema.parse({
             kind: "guild.module.resource.create",
@@ -188,7 +222,7 @@ export class ShardControlRouter {
             executeThrough: executeThrough.toISOString(),
         });
     }
-    async #route(operation) {
+    async #route(operation, timeoutMs = SHARD_CONTROL_TIMEOUT_MS) {
         const guildId = controlOperationGuildId(operation);
         if (!guildId)
             throw new BotControlTransportError(502, "The control operation has no shard route");
@@ -212,13 +246,13 @@ export class ShardControlRouter {
             requestId: randomUUID(),
             generation: this.input.generation,
             fencingToken: lease.fencingToken,
-            deadlineAt: new Date(Date.now() + SHARD_CONTROL_TIMEOUT_MS).toISOString(),
+            deadlineAt: new Date(Date.now() + timeoutMs).toISOString(),
             operation,
         };
         let response;
         try {
             response = localLease
-                ? await withDeadline(this.input.dispatchLocal(shardId, request), SHARD_CONTROL_TIMEOUT_MS)
+                ? await withDeadline(this.input.dispatchLocal(shardId, request), timeoutMs)
                 : await this.input.coordinator.routeRemote(lease, request);
         }
         catch (error) {
@@ -231,13 +265,13 @@ export class ShardControlRouter {
         return unwrapResponse(response);
     }
     async #routeLeader(operation) {
-        if (this.input.localLeaderLease && this.input.privacy) {
+        if (this.input.localLeaderLease) {
             if (this.input.coordinator) {
                 const current = await this.#currentLeaderLease();
                 if (!current || !sameLeaderLease(this.input.localLeaderLease, current))
                     throw new BotControlTransportError(503, "The shard leader is temporarily unavailable");
             }
-            return executePrivacy(this.input.privacy, operation);
+            return executeLeaderOperation(this.input, operation);
         }
         const coordinator = this.input.coordinator;
         const lease = await this.#currentLeaderLease();
@@ -283,6 +317,36 @@ export class ShardControlRouter {
         }
     }
 }
+async function executeLeaderOperation(input, operation) {
+    if (operation.kind === "automod.enhanced.configuration.page") {
+        if (!input.leaderScannerRegistry)
+            throw new BotControlTransportError(503, "The Enhanced configuration leader is unavailable");
+        return input.leaderScannerRegistry.getConfigurationPage({
+            adapter: "hosted_ecko",
+            providerId: AUTOMOD_ENHANCED_PROVIDER_ID,
+            contractVersion: AUTOMOD_ENHANCED_CONTRACT_VERSION,
+            limit: operation.limit,
+            ...(operation.cursor ? { cursor: operation.cursor } : {}),
+            ...(operation.knownFingerprint
+                ? { knownFingerprint: operation.knownFingerprint }
+                : {}),
+        });
+    }
+    if (!input.privacy)
+        throw new BotControlTransportError(503, "The shard leader is temporarily unavailable");
+    return executePrivacy(input.privacy, operation);
+}
+function remainingEnhancedDeadline(result) {
+    if (!result || typeof result !== "object")
+        return ECKO_RESULT_TIMEOUT_MS;
+    const deadlineAt = result["deadlineAt"];
+    if (typeof deadlineAt !== "string")
+        return ECKO_RESULT_TIMEOUT_MS;
+    const parsed = Date.parse(deadlineAt);
+    if (!Number.isFinite(parsed))
+        return ECKO_RESULT_TIMEOUT_MS;
+    return Math.max(1, Math.min(ECKO_RESULT_TIMEOUT_MS, parsed - Date.now()));
+}
 async function executePrivacy(privacy, operation) {
     if (operation.kind === "privacy.providers.list")
         return (await privacy.listPrivacyProviders());

package/dist/shard-supervisor.d.ts

@@ -4,6 +4,7 @@ import type { ModuleDefinition, NumericWriteBehindCommittedBatch, ScheduledTaskE
 import { buildApplicationCommandDefinitions } from "./interactions.js";
 import { type ShardCloudRequest, type ShardHealthSnapshot, type ShardIdentity, type ShardProcessHealth } from "./shard-contracts.js";
 import { type ShardCoordinator, type ShardGenerationDescriptor, type ShardLeaderLease, type ShardLease } from "./shard-coordinator.js";
+import { ShardControlRouter } from "./shard-router.js";
 import type { BotHandle } from "./index.js";
 export declare const STEADY_STATE_LEASE_LOSS_BOUND_MS: number;
 export declare function supervisorShutdownExitCode(reason: string): number | undefined;
@@ -17,6 +18,16 @@ export declare function relinquishRestartCircuitOwnership(input: {
 }): Promise<boolean>;
 export declare function deferScheduledRoutingFailures(route: () => Promise<ScheduledTaskExecutionResult>): Promise<ScheduledTaskExecutionResult>;
 export declare function startShardSupervisor(environment: BotEnvironment, processEnvironment: NodeJS.ProcessEnv, workerEntry: string): Promise<BotHandle>;
+export declare function shardHostedControlCallbacks(router: Pick<ShardControlRouter, "deliverHostedServerLeave" | "refreshHostedServerOwner">): {
+    deliverHostedServerLeave: (input: {
+        operationId: string;
+        guildId: string;
+    }) => Promise<"completed" | "requires_review" | "queued" | "not_currently_installed" | "accepted_for_retry">;
+    refreshHostedServerOwner: (guildId: string) => Promise<{
+        username: string;
+        observedAt: string;
+    }>;
+};
 export declare function splitNumericCommittedBatch(batch: NumericWriteBehindCommittedBatch, index: number): NumericWriteBehindCommittedBatch;
 export declare function buildShardWorkerEnvironment(source: NodeJS.ProcessEnv, identity: ShardIdentity, restartCount: number): NodeJS.ProcessEnv;
 export declare function shardRuntimeCompositionHash(modules: readonly ModuleDefinition[], internalGuildId?: string, globalCommandMode?: Parameters<typeof buildApplicationCommandDefinitions>[2]): string;