@helyx/bot 0.4.33 → 0.4.35

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.4.35
+
+### Patch Changes
+
+- 26b4c3e: Add versioned hidden module dependencies, automatic installation lifecycle,
+  delegated customer health, and transitive self-host build composition for the
+  Nexus foundation while preserving legacy manifest and catalogue behavior. Add
+  closed, owner-aware composition for the shared `/nexus` command namespace and
+  bounded Core reads for terminology, member history and confirmed member value
+  changes. Add resumable, idempotent role and server bulk-award jobs.
+  Add bounded Nexus privacy capture, a durable hashed erasure fence and atomic
+  member detachment that journals any remaining balance as a privacy burn before
+  removing account and bulk-recipient identifiers.
+  Generalise the durable Achievement contribution bus as member contributions
+  while retaining the existing service names as compatibility aliases.
+  Add the private Nexus Rewards Testing package, complete initial record schema
+  and an atomic timezone-aware Daily Claim path backed by the shared ledger.
+  Add reviewed, default-off Nexus eligibility metadata to existing contribution
+  catalogues and atomically apply configured fixed rewards with source, role,
+  rate-cap, replay, balance-cap and privacy safeguards.
+  Add definition-owned Achievement reward amounts and live repeatable-award
+  high-water processing so retries credit only newly committed occurrences.
+  Add the private Nexus Economy Testing package and its complete initial Exchange,
+  item, redemption, inventory, role-grant and durable fulfilment record schema.
+  Add a typed atomic Economy redemption path with exact replay, finite stock,
+  member limits, role eligibility, collectible inventory and durable fulfilment.
+  Add coalesced leased role fulfilment with reviewed Discord safety, observed
+  delivery reconciliation, bounded retries and Core-linked automatic refunds.
+- Updated dependencies [26b4c3e]
+  - @helyx/module-manifest@0.7.0
+  - @helyx/platform@0.6.0
+  - @helyx/sdk@0.8.0
+
+## 0.4.34
+
+### Patch Changes
+
+- Add fail-open production status heartbeat configuration and reporting support.
+
 ## 0.4.33
 
 ### Patch Changes

package/dist/cloud-management-module.js

@@ -106,6 +106,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "connect",
                             description: "Connect this deployment using a one-use code",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -136,6 +137,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "status",
                             description: "Show this deployment's Cloud Connect status",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 20, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -146,6 +148,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "disconnect",
                             description: "Revoke this deployment's Cloud Connect identity",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -185,6 +188,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "rotate",
                             description: "Replace the saved Cloud Connect credential",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 3, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -224,6 +228,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "support",
                             description: "Choose what Helyx support may inspect",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))

package/dist/control-server.d.ts

@@ -4,13 +4,9 @@ import { type ActionReceipt, type SignedAssessmentEnvelope } from "@helyx/verifi
 import { type Client } from "discord.js";
 import { type FastifyInstance } from "fastify";
 import { type ShardHealthSnapshot } from "./shard-contracts.js";
-import { type DashboardPermissionPolicy, type DashboardPermissionState } from "./control-permissions.js";
-interface DashboardCommandDefinition {
-    id: string;
-    name: string;
-    description: string;
-    defaultPreset: DashboardPermissionPolicy["preset"];
-}
+import { type DashboardPermissionState } from "./control-permissions.js";
+import { type DashboardCommandDefinition } from "./dashboard-commands.js";
+import { type AvailabilityModuleCatalogue } from "./module-availability-control.js";
 interface DashboardLogEventDefinition {
     id: string;
     name: string;
@@ -127,6 +123,7 @@ export interface BotControlState {
     roles: BotControlGuildResources["roles"];
     modules: DashboardModuleDefinition[];
     moduleStatuses: Record<string, "enabled" | "disabled" | "unavailable">;
+    globallyDisabledModuleIds: string[];
     configurations: Record<string, {
         version: number;
         value: Record<string, unknown>;
@@ -155,6 +152,7 @@ export interface BotControlHandler {
         correlationId: string;
     }): Promise<OAuthConsumerCleanupResult>;
     sendSupportNotification(input: SupportNotificationInput): Promise<void>;
+    listAvailabilityModules(): Promise<AvailabilityModuleCatalogue>;
     listGuildPresence(input: {
         guildIds: readonly string[];
         correlationId: string;
@@ -541,6 +539,7 @@ export declare class BotControlService implements BotControlHandler {
         correlationId: string;
         actorAuthenticatedAt?: string;
     }): Promise<ManagedResourceDetail | null>;
+    listAvailabilityModules(): Promise<AvailabilityModuleCatalogue>;
 }
 export declare function createBotControlServer(input: {
     service: BotControlHandler;

package/dist/control-server.js

@@ -9,7 +9,9 @@ import { z, ZodError } from "zod";
 import { addChannelMessageReaction as addDiscordChannelMessageReaction, deleteChannelMessage as deleteDiscordChannelMessage, editChannelMessage as editDiscordChannelMessage, normalizeDiscordPermission, sendToChannel as sendDiscordMessageToChannel, } from "./interactions.js";
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.js";
 import { dashboardCategoryLabel } from "./dashboard-category.js";
-import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, emptyPolicy, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
+import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
+import { dashboardCommands, } from "./dashboard-commands.js";
+import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, } from "./module-availability-control.js";
 const snowflake = z.string().regex(/^\d{17,20}$/u);
 const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
 const MAX_DISCORD_SETTING_SELECTIONS = 25;
@@ -258,6 +260,7 @@ export class BotControlService {
     presenceShardCount;
     #modules;
     #dashboardModules;
+    #availabilityModules;
     #configurations;
     #installations;
     #permissions;
@@ -273,6 +276,7 @@ export class BotControlService {
         this.#dashboardModules = modules
             .filter((module) => module.manifest.dashboard !== undefined)
             .map(mapDashboardModule);
+        this.#availabilityModules = availabilityCatalogueDefinitions(modules);
         this.#configurations = services.get(HELYX_SERVICE_NAMES.configuration);
         this.#installations = services.get(HELYX_SERVICE_NAMES.installations);
         this.#permissions = services.get(HELYX_SERVICE_NAMES.permissions);
@@ -423,14 +427,16 @@ export class BotControlService {
                 commandId: id,
             })),
         ]);
-        const [resources, installedModules, storedLoggingPolicies, runtime, storedConfigurations, storedPermissions,] = await Promise.all([
+        const [resources, installedModules, storedLoggingPolicies, runtime, storedConfigurations, storedPermissions, availabilityStates,] = await Promise.all([
             this.resources.getGuildResources(guildId),
             new InstallationRepository(this.database).listModules(guildId),
             new ModuleLoggingPolicyRepository(this.database).listForGuild(guildId),
             this.#inspectRuntimeCapabilities(),
             this.#readConfigurations(guildId, moduleIds),
             this.#readPermissionPolicies(guildId, permissionTargets),
+            moduleAvailabilityStates(this.#services, moduleIds),
         ]);
+        const disabledModules = disabledModuleSummary(availabilityStates);
         const installed = new Map(installedModules.map((module) => [module.moduleId, module]));
         const moduleStatuses = {};
         const configurations = {};
@@ -442,11 +448,7 @@ export class BotControlService {
         ]));
         for (const { dashboardModule, module } of dashboardEntries) {
             const installation = installed.get(dashboardModule.id);
-            moduleStatuses[dashboardModule.id] = installation
-                ? installation.enabled
-                    ? "enabled"
-                    : "disabled"
-                : "unavailable";
+            moduleStatuses[dashboardModule.id] = dashboardModuleStatus(disabledModules.set, dashboardModule.id, installation);
             const configuration = storedConfigurations.get(dashboardModule.id);
             if (configuration)
                 configurations[dashboardModule.id] = {
@@ -470,6 +472,7 @@ export class BotControlService {
             ...resources,
             modules: structuredClone(this.#dashboardModules),
             moduleStatuses,
+            globallyDisabledModuleIds: disabledModules.ids,
             configurations,
             permissions,
             logging,
@@ -624,6 +627,7 @@ export class BotControlService {
     }
     async setModuleStatus(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         const scopes = Object.entries(module.records ?? {})
             .filter(([, collection]) => (collection.incrementableFields?.length ?? 0) > 0)
             .map(([collection]) => ({
@@ -677,6 +681,7 @@ export class BotControlService {
     }
     async updateConfiguration(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         await this.#validateDiscordSettings(input.guildId, module, input.value);
         if (module.configuration?.validateUpdate) {
             try {
@@ -710,6 +715,7 @@ export class BotControlService {
     }
     async updatePermissions(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         const commands = dashboardCommands(module);
         const supplied = new Map(input.state.commands.map((command) => [command.commandId, command]));
         if (supplied.size !== input.state.commands.length ||
@@ -833,6 +839,10 @@ export class BotControlService {
         return this.#getPermissionState(input.guildId, module);
     }
     async updateLoggingPolicy(input) {
+        await Promise.all([
+            this.#requireModuleAvailable(input.moduleId),
+            this.#requireModuleAvailable("helyx.logging"),
+        ]);
         if (!this.#modules.has("helyx.logging")) {
             throw new BotControlNotFoundError("Logging is not installed");
         }
@@ -877,6 +887,7 @@ export class BotControlService {
     }
     async executeDashboardAction(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         const declared = module.manifest.dashboard?.actions?.find(({ id }) => id === input.actionId);
         const action = module.dashboardActions?.find(({ id }) => id === input.actionId);
         if (!declared || !action) {
@@ -935,11 +946,13 @@ export class BotControlService {
         })), relation.columns.map(({ key }) => key));
     }
     async previewManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "preview");
         return resource.preview(await this.#managedResourceContext(input, module, "preview"), input.value);
     }
     async createManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "create");
         const context = await this.#managedResourceContext(input, module, "create");
@@ -949,6 +962,7 @@ export class BotControlService {
         return normalizeManagedResourceDetail(managedResourceDetailSchema.parse(await resource.create(context, input.value, input.intent)), managedResourceColumnKeys(module, input.resourceType));
     }
     async updateManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "update");
         return normalizeManagedResourceDetail(managedResourceDetailSchema.parse(await resource.update(await this.#managedResourceContext(input, module, "update"), {
@@ -958,6 +972,7 @@ export class BotControlService {
         })), managedResourceColumnKeys(module, input.resourceType));
     }
     async deleteManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "delete");
         return managedResourceDeleteResultSchema.parse(await resource.delete(await this.#managedResourceContext(input, module, "delete"), {
@@ -966,6 +981,7 @@ export class BotControlService {
         }));
     }
     async executeManagedResourceAction(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         const declared = module.manifest.dashboard?.resources
             ?.find(({ id }) => id === input.resourceType)
@@ -1061,6 +1077,14 @@ export class BotControlService {
             throw new BotControlNotFoundError("Module is not installed");
         return module;
     }
+    listAvailabilityModules() {
+        return availabilityCatalogue(this.#availabilityModules);
+    }
+    async #requireModuleAvailable(moduleIdValue) {
+        const availability = moduleAvailabilityService(this.#services);
+        if (availability && !(await availability.isAvailable(moduleIdValue)))
+            throw new BotControlValidationError("This module is temporarily unavailable for all hosted servers.");
+    }
     #requireDashboardModule(moduleIdValue) {
         const module = this.#requireModule(moduleIdValue);
         if (!module.manifest.dashboard)
@@ -1368,6 +1392,7 @@ export async function createBotControlServer(input) {
         const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
         return input.service.getGuildState(guildId);
     });
+    server.get("/v1/modules/availability-catalogue", () => input.service.listAvailabilityModules());
     server.post("/v1/guilds/:guildId/dashboard-access", async (request) => {
         const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
         const { actorUserId } = z
@@ -1897,35 +1922,6 @@ function mapDashboardModule(module) {
             : undefined,
     };
 }
-function dashboardCommands(module) {
-    const commands = (module.interactions?.commands ?? []).flatMap((command) => command.subcommands?.length
-        ? command.subcommands.map((subcommand) => {
-            const id = subcommand.permissionId ??
-                command.permissionId ??
-                `${command.name}.${subcommand.name}`;
-            return {
-                id,
-                name: `/${command.name} ${subcommand.name}`,
-                description: subcommand.description,
-                defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[id] ??
-                    module.defaultPermissions?.module ??
-                    emptyPolicy()).preset,
-            };
-        })
-        : [
-            {
-                id: command.permissionId ?? command.name,
-                name: `/${command.name}`,
-                description: command.description,
-                defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[command.name] ??
-                    module.defaultPermissions?.module ??
-                    emptyPolicy()).preset,
-            },
-        ]);
-    return [
-        ...new Map(commands.map((command) => [command.id, command])).values(),
-    ];
-}
 function assertPermissionMutationAllowed(decision) {
     if (decision.allowed)
         return;

package/dist/dashboard-commands.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleDefinition } from "@helyx/sdk";
+import { type DashboardPermissionPolicy } from "./control-permissions.js";
+export interface DashboardCommandDefinition {
+    id: string;
+    name: string;
+    description: string;
+    defaultPreset: DashboardPermissionPolicy["preset"];
+}
+export declare function dashboardCommands(module: ModuleDefinition): DashboardCommandDefinition[];
+//# sourceMappingURL=dashboard-commands.d.ts.map

package/dist/dashboard-commands.js

@@ -0,0 +1,47 @@
+import { emptyPolicy, toDashboardPolicy, } from "./control-permissions.js";
+export function dashboardCommands(module) {
+    const commands = (module.interactions?.commands ?? []).flatMap((command) => {
+        const nested = [
+            ...(command.subcommands ?? []).map((subcommand) => dashboardCommand(module, {
+                id: subcommand.permissionId ??
+                    command.permissionId ??
+                    `${command.name}.${subcommand.name}`,
+                name: `/${command.name} ${subcommand.name}`,
+                description: subcommand.description,
+            })),
+            ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.map((subcommand) => dashboardCommand(module, {
+                id: subcommand.permissionId ??
+                    command.permissionId ??
+                    `${command.name}.${group.name}.${subcommand.name}`,
+                name: `/${command.name} ${group.name} ${subcommand.name}`,
+                description: subcommand.description,
+            }))),
+        ];
+        if (nested.length > 0)
+            return nested;
+        return [
+            dashboardCommand(module, {
+                id: command.permissionId ?? command.name,
+                name: `/${command.name}`,
+                description: command.description,
+            }),
+        ];
+    });
+    commands.push(...(module.nexusCommands ?? []).map((command) => dashboardCommand(module, {
+        id: `nexus.${command.path}`,
+        name: `/nexus ${command.path.replace(".", " ")}`,
+        description: command.description,
+    })));
+    return [
+        ...new Map(commands.map((command) => [command.id, command])).values(),
+    ];
+}
+function dashboardCommand(module, command) {
+    return {
+        ...command,
+        defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[command.id] ??
+            module.defaultPermissions?.module ??
+            emptyPolicy()).preset,
+    };
+}
+//# sourceMappingURL=dashboard-commands.js.map

package/dist/developer-operations-module.js

@@ -33,6 +33,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "shards",
                             description: "Show bounded read-only shard health",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await authorizeDeveloperCommand(context)))
@@ -81,6 +82,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "bot",
                             description: "Show the bot build and installed module versions",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await authorizeDeveloperCommand(context)))
@@ -134,6 +136,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "proc",
                             description: "Show safe process resource and uptime information",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await authorizeDeveloperCommand(context)))

package/dist/discord-guild-health.d.ts

@@ -1,9 +1,10 @@
+import { type ModuleManifest } from "@helyx/module-manifest";
 import type { DiscordGuildHealthInspectionService, DiscordGuildHealthUnavailable, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
 import { type Client } from "discord.js";
 export declare function moduleCatalogueMatches(packagedManifest: unknown, executableManifest: unknown): boolean;
 export declare function missingRequiredPermissions(grantedPermissions: readonly string[], requiredPermissions: readonly string[]): string[];
 export declare function hasRequiredModuleConfiguration(exposesConfiguration: boolean, savedConfiguration: unknown): boolean;
-export declare function isHealthInspectableModule(moduleId: string): boolean;
+export declare function isHealthInspectableModule(module: ModuleManifest | string): boolean;
 export declare class DiscordGuildHealthInspection implements DiscordGuildHealthInspectionService {
     #private;
     private readonly client;

package/dist/discord-guild-health.js

@@ -1,3 +1,4 @@
+import { hasDirectModuleHealthExposure, } from "@helyx/module-manifest";
 import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
 import { AuditLogEvent, GatewayIntentBits, } from "discord.js";
 import { isDeepStrictEqual } from "node:util";
@@ -21,8 +22,10 @@ export function missingRequiredPermissions(grantedPermissions, requiredPermissio
 export function hasRequiredModuleConfiguration(exposesConfiguration, savedConfiguration) {
     return !exposesConfiguration || savedConfiguration !== null;
 }
-export function isHealthInspectableModule(moduleId) {
-    return !INTERNAL_HELYX_MODULE_IDS.has(moduleId);
+export function isHealthInspectableModule(module) {
+    const moduleId = typeof module === "string" ? module : module.id;
+    return (!INTERNAL_HELYX_MODULE_IDS.has(moduleId) &&
+        (typeof module === "string" || hasDirectModuleHealthExposure(module)));
 }
 export class DiscordGuildHealthInspection {
     client;
@@ -270,7 +273,7 @@ export class DiscordGuildHealthInspection {
                 return overview;
             const items = [];
             const batchSize = Math.min(20, Math.max(1, input.batchSize ?? 20));
-            const inspectableModules = this.modules.filter((module) => isHealthInspectableModule(module.manifest.id));
+            const inspectableModules = this.modules.filter((module) => isHealthInspectableModule(module.manifest));
             for (let index = 0; index < inspectableModules.length; index += 1) {
                 const module = inspectableModules[index];
                 const state = await installations.getModuleState(input.guildId, module.manifest.id);

package/dist/events.js

@@ -3,6 +3,20 @@ import { ChannelType, Events, GatewayIntentBits, GuildMemberFlags, PermissionFla
 import { toReplyOptions } from "./interactions.js";
 import { createHash } from "node:crypto";
 import { classifyGuildMessage, unavailableGuildMessageClassification, } from "./message-classification.js";
+function availabilityAwareInstallations(services) {
+    const installations = services.get(HELYX_SERVICE_NAMES.installations);
+    const candidate = typeof services.has === "function" &&
+        services.has(HELYX_SERVICE_NAMES.moduleAvailability)
+        ? services.get(HELYX_SERVICE_NAMES.moduleAvailability)
+        : null;
+    const availability = typeof candidate?.isAvailable === "function" ? candidate : null;
+    return {
+        async isModuleEnabled(guildId, moduleId) {
+            return ((!availability || (await availability.isAvailable(moduleId))) &&
+                installations.isModuleEnabled(guildId, moduleId));
+        },
+    };
+}
 export function installModuleEvents(client, modules, logger, services) {
     const privilegedMessageContributions = modules.flatMap((module) => (module.events?.privilegedMessageCreate ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
@@ -113,7 +127,7 @@ export function installModuleEvents(client, modules, logger, services) {
             if (!message.guildId || !privilegedEligibilityQueue)
                 return;
             privilegedEligibilityQueue.enqueue(message.guildId, async () => {
-                const installations = services.get(HELYX_SERVICE_NAMES.installations);
+                const installations = availabilityAwareInstallations(services);
                 const eligible = [];
                 for (const item of privilegedMessageContributions) {
                     try {
@@ -260,7 +274,7 @@ export function installModuleEvents(client, modules, logger, services) {
         });
     }
     async function handleResourceLifecycle(contributions, serverId, identifier, resourceId, eventName) {
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of contributions) {
             try {
                 if (!(await installations.isModuleEnabled(serverId, moduleId))) {
@@ -316,7 +330,7 @@ export function installModuleEvents(client, modules, logger, services) {
     async function handleGuildMessageCreate(message) {
         if (!message.guildId || !message.channelId)
             return;
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         const parentChannelId = message.channel.isThread()
             ? (message.channel.parentId ?? undefined)
             : undefined;
@@ -410,7 +424,7 @@ export function installModuleEvents(client, modules, logger, services) {
                 : reaction.message;
             if (!message.guildId || !message.channelId)
                 return;
-            const installations = services.get(HELYX_SERVICE_NAMES.installations);
+            const installations = availabilityAwareInstallations(services);
             const member = await message.guild?.members.fetch(user.id);
             const userRoleIds = member ? [...member.roles.cache.keys()] : [];
             const parentChannelId = messageParentChannelId(message);
@@ -467,7 +481,7 @@ export function installModuleEvents(client, modules, logger, services) {
     async function handleMemberAdd(member) {
         if (!member.joinedAt)
             throw new Error("Discord member join timestamp is unavailable");
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of memberAddContributions) {
             try {
                 if (!(await installations.isModuleEnabled(member.guild.id, moduleId))) {
@@ -498,7 +512,7 @@ export function installModuleEvents(client, modules, logger, services) {
         }
     }
     async function handleMemberRemove(member) {
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of memberRemoveContributions) {
             try {
                 if (!(await installations.isModuleEnabled(member.guild.id, moduleId))) {
@@ -536,7 +550,7 @@ export function installModuleEvents(client, modules, logger, services) {
                 : reaction.message;
             if (!message.guildId || !message.channelId)
                 return;
-            const installations = services.get(HELYX_SERVICE_NAMES.installations);
+            const installations = availabilityAwareInstallations(services);
             const parentChannelId = messageParentChannelId(message);
             for (const { moduleId, contribution } of reactionRemoveContributions) {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
@@ -580,7 +594,7 @@ export function installModuleEvents(client, modules, logger, services) {
             : receivedMessage;
         if (!message.guildId || !message.channelId)
             return;
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of reactionRemoveAllContributions) {
             try {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId)))
@@ -610,7 +624,7 @@ export function installModuleEvents(client, modules, logger, services) {
         const message = reaction.message;
         if (!message.guildId || !message.channelId)
             return;
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of reactionRemoveEmojiContributions) {
             try {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId)))
@@ -638,7 +652,7 @@ export function installModuleEvents(client, modules, logger, services) {
     async function handleMessageUpdate(receivedMessage) {
         if (!receivedMessage.guildId || !receivedMessage.channelId)
             return;
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of messageUpdateContributions) {
             try {
                 if (!(await installations.isModuleEnabled(receivedMessage.guildId, moduleId)))
@@ -672,7 +686,7 @@ export function installModuleEvents(client, modules, logger, services) {
     async function handleMessageDelete(message) {
         if (!message.guildId || !message.channelId)
             return;
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         for (const { moduleId, contribution } of messageDeleteContributions) {
             try {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
@@ -699,7 +713,7 @@ export function installModuleEvents(client, modules, logger, services) {
     async function handleMessageDeleteBulk(guildId, channelId, messageIds) {
         if (messageIds.length === 0)
             return;
-        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const installations = availabilityAwareInstallations(services);
         const boundedIds = messageIds.slice(0, 100);
         for (const { moduleId, contribution } of messageDeleteBulkContributions) {
             try {
@@ -733,7 +747,7 @@ export function installModuleEvents(client, modules, logger, services) {
             voiceSessions.delete(key);
             const endedAt = new Date();
             const durationSeconds = Math.max(1, Math.floor((endedAt.getTime() - previous.startedAt.getTime()) / 1_000));
-            const installations = services.get(HELYX_SERVICE_NAMES.installations);
+            const installations = availabilityAwareInstallations(services);
             for (const { moduleId, contribution } of guildVoiceSessionContributions) {
                 try {
                     if (!(await installations.isModuleEnabled(previous.guildId, moduleId)))

package/dist/index.js

@@ -1,4 +1,5 @@
 import { parseBotEnvironment } from "@helyx/config";
+import { StatusHeartbeatReporter } from "@helyx/status-client";
 import { safeError, ServiceRegistry } from "@helyx/core";
 import { checkDatabaseConnection, createDatabasePool, AuditRepository, InteractionSessionRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
@@ -44,9 +45,45 @@ export async function startBot(processEnvironment = process.env) {
         return startShardWorker(processEnvironment, parseShardWorkerLaunchContract(processEnvironment.HELYX_SHARD_WORKER_CONTRACT));
     const environment = parseBotEnvironment(processEnvironment);
     bootstrapLogger.level = environment.LOG_LEVEL;
-    if (environment.HELYX_SHARD_MODE !== "off")
-        return startShardSupervisor(environment, processEnvironment, resolveBotWorkerEntryPoint());
-    return startUnshardedBot(processEnvironment);
+    const handle = environment.HELYX_SHARD_MODE !== "off"
+        ? await startShardSupervisor(environment, processEnvironment, resolveBotWorkerEntryPoint())
+        : await startUnshardedBot(processEnvironment);
+    if (!environment.HELYX_STATUS_ENABLED)
+        return handle;
+    const processStartedAt = new Date().toISOString();
+    const reporter = new StatusHeartbeatReporter({
+        producer: "bot",
+        baseUrl: environment.HELYX_STATUS_URL,
+        secret: environment.HELYX_STATUS_HEARTBEAT_SECRET,
+        accessClientId: environment.CF_ACCESS_CLIENT_ID,
+        accessClientSecret: environment.CF_ACCESS_CLIENT_SECRET,
+        intervalSeconds: environment.HELYX_STATUS_HEARTBEAT_INTERVAL_SECONDS,
+        services: () => [
+            {
+                key: "discord-bot",
+                state: "operational",
+                processStartedAt,
+                release: readBotVersion(),
+            },
+            {
+                key: "creator-connections",
+                state: environment.HELYX_OAUTH_ENABLED ? "operational" : "major_outage",
+                reasonCode: environment.HELYX_OAUTH_ENABLED ? null : "feature_disabled",
+                processStartedAt,
+                release: readBotVersion(),
+            },
+        ],
+        onError(error) {
+            bootstrapLogger.warn({ event: "status.heartbeat_failed", reason: error.message }, "Status heartbeat could not be delivered");
+        },
+    });
+    reporter.start();
+    return {
+        async shutdown(reason) {
+            await reporter.stop();
+            await handle.shutdown(reason);
+        },
+    };
 }
 export function resolveBotWorkerEntryPoint(entryUrl = import.meta.url) {
     return fileURLToPath(entryUrl);
@@ -254,6 +291,9 @@ async function startUnshardedBot(processEnvironment) {
         })) {
             platformServices.set(name, service);
         }
+        await serviceAccess
+            .get(HELYX_SERVICE_NAMES.moduleAvailability)
+            .refresh();
         if (environment.HELYX_VERIFICATION_ENABLED &&
             environment.HELYX_VERIFICATION_URL &&
             environment.HELYX_VERIFICATION_INTERNAL_SECRET) {