@helyx/bot 0.4.32 → 0.4.35

package/dist/modules.js

@@ -1,4 +1,5 @@
 import { orderModuleManifests, parseModuleManifest, } from "@helyx/module-manifest";
+import { NEXUS_COMMAND_SPECS, NEXUS_ROOT_MODULE_ID } from "@helyx/sdk";
 import { createHmac } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
@@ -102,6 +103,28 @@ export function validateContributionParity(definition) {
         throw new Error("Module requests an unsupported or duplicate Discord capability");
     }
     const executableCommands = (definition.interactions?.commands ?? []).map(({ name }) => name);
+    const nexusCommandPaths = new Set();
+    for (const command of definition.nexusCommands ?? []) {
+        const spec = NEXUS_COMMAND_SPECS.find(({ path }) => path === command.path);
+        if (!spec || spec.ownerModuleId !== definition.manifest.id) {
+            throw new Error(`Module ${definition.manifest.id} cannot contribute Nexus command ${command.path}`);
+        }
+        if (nexusCommandPaths.has(command.path)) {
+            throw new Error(`Duplicate Nexus command path for ${definition.manifest.id}: ${command.path}`);
+        }
+        nexusCommandPaths.add(command.path);
+    }
+    if (definition.manifest.id !== NEXUS_ROOT_MODULE_ID) {
+        executableCommands.push(...[...nexusCommandPaths].map((path) => `nexus.${path}`));
+        if (nexusCommandPaths.size > 0 &&
+            !definition.manifest.dependencies.some(({ id }) => id === NEXUS_ROOT_MODULE_ID)) {
+            throw new Error(`Module ${definition.manifest.id} contributes Nexus commands without depending on Nexus Core`);
+        }
+    }
+    if (definition.manifest.id !== NEXUS_ROOT_MODULE_ID &&
+        definition.interactions?.commands?.some(({ name }) => name === "nexus")) {
+        throw new Error("Nexus Core must be the sole owner of /nexus");
+    }
     const executableEvents = [
         ...(definition.events?.privilegedMessageCreate ?? []),
         ...(definition.events?.guildMessageCreate ?? []),
@@ -135,7 +158,7 @@ export function validateContributionParity(definition) {
 function validatePrivacyParity(definition) {
     if (definition.manifest.manifestVersion === "0.1") {
         if (definition.privacy !== undefined) {
-            throw new Error("Module executable privacy provider requires manifest version 0.2");
+            throw new Error("Module executable privacy provider requires manifest version 0.2 or later");
         }
         return;
     }

package/dist/nexus-commands.d.ts

@@ -0,0 +1,13 @@
+import { type CommandContribution, type ModuleDefinition } from "@helyx/sdk";
+export interface CommandRouteOwner {
+    moduleId: string;
+    moduleName: string;
+}
+export interface RegisteredCommand {
+    moduleId: string;
+    moduleName: string;
+    contribution: CommandContribution;
+    routeOwners?: ReadonlyMap<string, CommandRouteOwner>;
+}
+export declare function collectCommandRegistrations(modules: readonly ModuleDefinition[]): Map<string, RegisteredCommand>;
+//# sourceMappingURL=nexus-commands.d.ts.map

package/dist/nexus-commands.js

@@ -0,0 +1,100 @@
+import { NEXUS_COMMAND_SPECS, NEXUS_ROOT_MODULE_ID, } from "@helyx/sdk";
+export function collectCommandRegistrations(modules) {
+    const registrations = modules.flatMap((module) => (module.interactions?.commands ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        moduleName: module.manifest.name,
+        contribution,
+    })));
+    const nexusContributions = modules.flatMap((module) => (module.nexusCommands ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        moduleName: module.manifest.name,
+        contribution,
+    })));
+    if (nexusContributions.length > 0) {
+        const roots = registrations.filter(({ contribution }) => contribution.name === "nexus");
+        if (roots.length !== 1 || roots[0].moduleId !== NEXUS_ROOT_MODULE_ID) {
+            throw new Error("Nexus Core must be the sole owner of /nexus");
+        }
+        const root = roots[0];
+        if (root.contribution.execute ||
+            root.contribution.options?.length ||
+            root.contribution.subcommands?.length ||
+            root.contribution.subcommandGroups?.length) {
+            throw new Error("Nexus Core /nexus must be composed from Nexus commands");
+        }
+        const composed = composeNexusCommand(root, nexusContributions);
+        registrations.splice(registrations.indexOf(root), 1, composed);
+    }
+    return uniqueRegistrations(registrations);
+}
+function composeNexusCommand(root, contributions) {
+    const byPath = new Map(contributions.map((item) => {
+        const spec = NEXUS_COMMAND_SPECS.find(({ path }) => path === item.contribution.path);
+        if (!spec || spec.ownerModuleId !== item.moduleId) {
+            throw new Error(`Module ${item.moduleId} cannot contribute Nexus command ${item.contribution.path}`);
+        }
+        return [item.contribution.path, item];
+    }));
+    if (byPath.size !== contributions.length) {
+        throw new Error("Duplicate Nexus command path");
+    }
+    const subcommands = [];
+    const groups = new Map();
+    const routeOwners = new Map();
+    for (const spec of NEXUS_COMMAND_SPECS) {
+        const item = byPath.get(spec.path);
+        if (!item)
+            continue;
+        routeOwners.set(spec.path, {
+            moduleId: item.moduleId,
+            moduleName: item.moduleName,
+        });
+        const [first, second] = spec.path.split(".");
+        const command = toSubcommand(item.contribution, second ?? first);
+        if (!second) {
+            subcommands.push(command);
+            continue;
+        }
+        const current = groups.get(first);
+        const group = current ?? {
+            name: first,
+            description: "groupDescription" in spec
+                ? spec.groupDescription
+                : `Manage Nexus ${first}`,
+            subcommands: [],
+        };
+        groups.set(first, {
+            ...group,
+            subcommands: [...group.subcommands, command],
+        });
+    }
+    return {
+        ...root,
+        contribution: {
+            ...root.contribution,
+            subcommands,
+            subcommandGroups: [...groups.values()],
+        },
+        routeOwners,
+    };
+}
+function toSubcommand(contribution, name) {
+    const subcommand = {
+        ...contribution,
+        name,
+        permissionId: `nexus.${contribution.path}`,
+    };
+    delete subcommand.path;
+    return subcommand;
+}
+function uniqueRegistrations(items) {
+    const result = new Map();
+    for (const item of items) {
+        const key = item.contribution.name;
+        if (result.has(key))
+            throw new Error(`Duplicate command name: ${key}`);
+        result.set(key, item);
+    }
+    return result;
+}
+//# sourceMappingURL=nexus-commands.js.map

package/dist/oauth-module.js

@@ -43,6 +43,7 @@ export function createOAuthModule() {
                         {
                             name: "revoke",
                             description: "Revoke a service and delete the OAuth details Helyx stores for you.",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             execute: async (context) => {
                                 const oauth = context.services.get(HELYX_SERVICE_NAMES.oauth);
@@ -155,9 +156,13 @@ export function createOAuthModule() {
                                 componentsV2: {
                                     text: [
                                         {
-                                            content: result.providerRevocation === "completed"
-                                                ? `${providerName(result.provider)} access has been removed from Helyx. Local credentials were deleted.`
-                                                : `${providerName(result.provider)} access has been removed from Helyx and local credentials were deleted. Helyx could not confirm provider-side revocation, so you may also remove Helyx from your ${providerName(result.provider)} connected-app settings.`,
+                                            content: result.outcome === "processing"
+                                                ? `${providerName(result.provider)} access removal is already in progress. Helyx will finish it automatically.`
+                                                : result.outcome === "cleanup_pending"
+                                                    ? `${providerName(result.provider)} credentials were deleted. Helyx is still removing related roles and connection records.`
+                                                    : result.providerRevocation === "completed"
+                                                        ? `${providerName(result.provider)} access has been removed from Helyx. Local credentials were deleted.`
+                                                        : `${providerName(result.provider)} access has been removed from Helyx and local credentials were deleted. Helyx could not confirm provider-side revocation, so you may also remove Helyx from your ${providerName(result.provider)} connected-app settings.`,
                                         },
                                     ],
                                 },

package/dist/oauth-service.js

@@ -30,7 +30,7 @@ export class HttpOAuthService {
                 "content-type": "application/json",
             },
             body: JSON.stringify(body),
-            signal: AbortSignal.timeout(6_000),
+            signal: AbortSignal.timeout(15_000),
         });
         if (!response.ok)
             throw new Error(`oauth_service_http_${response.status}`);

package/dist/permissions-module.js

@@ -1,4 +1,5 @@
 import { defineModule, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { isCustomerSelectableModule } from "@helyx/module-manifest";
 import { PermissionFlagsBits } from "discord.js";
 import { canMutatePermissionPolicy, permissionMutationDenialMessage, } from "@helyx/core";
 const MODULE_SELECT_ID = "helyx.permissions.module";
@@ -17,7 +18,9 @@ const MODULE_PAGE_SIZE = 25;
 const TARGET_PAGE_SIZE = 24;
 const VIOLET = 0x7c3aed;
 export function createPermissionsModule(configurableModules) {
-    const modules = new Map(configurableModules.map((module) => [module.manifest.id, module]));
+    const modules = new Map(configurableModules
+        .filter((module) => isCustomerSelectableModule(module.manifest))
+        .map((module) => [module.manifest.id, module]));
     const commandModules = [...modules.values()]
         .filter((module) => commandTargets(module).length > 0)
         .sort((left, right) => left.manifest.name.localeCompare(right.manifest.name, "en-GB"));
@@ -46,6 +49,7 @@ export function createPermissionsModule(configurableModules) {
                 {
                     name: "permissions",
                     description: "Configure access to Helyx modules and commands",
+                    acknowledgement: "deferred-ephemeral",
                     registration: "global",
                     contexts: ["guild"],
                     integrationTypes: ["guild_install"],
@@ -359,9 +363,17 @@ function restrictedPolicy() {
     };
 }
 function commandTargets(module) {
-    return (module.interactions?.commands ?? []).flatMap((command) => command.subcommands?.length
-        ? command.subcommands.map((subcommand) => `${command.name}.${subcommand.name}`)
-        : [command.name]);
+    const targets = (module.interactions?.commands ?? []).flatMap((command) => {
+        const nested = [
+            ...(command.subcommands ?? []).map((subcommand) => `${command.name}.${subcommand.name}`),
+            ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.map((subcommand) => `${command.name}.${group.name}.${subcommand.name}`)),
+        ];
+        if (nested.length > 0)
+            return nested;
+        return [command.name];
+    });
+    targets.push(...(module.nexusCommands ?? []).map((command) => `nexus.${command.path}`));
+    return [...new Set(targets)];
 }
 function modulePickerResponse(modules, requestedPage) {
     const pages = pageCount(modules.length, MODULE_PAGE_SIZE);

package/dist/scheduled-task-runner.js

@@ -321,6 +321,13 @@ export function createLocalScheduledTaskRoute(input) {
         const module = modules.get(task.moduleId);
         if (!module)
             return deferred("module_unavailable", DEFAULT_POLL_INTERVAL_MS * 30);
+        if (typeof input.services.has === "function" &&
+            input.services.has(HELYX_SERVICE_NAMES.moduleAvailability)) {
+            const availability = input.services.get(HELYX_SERVICE_NAMES.moduleAvailability);
+            if (typeof availability?.isAvailable === "function" &&
+                !(await availability.isAvailable(task.moduleId)))
+                return deferred("module_globally_disabled", DEFAULT_POLL_INTERVAL_MS * 30);
+        }
         if (task.guildId) {
             const enabled = await input.services
                 .get(HELYX_SERVICE_NAMES.installations)

package/dist/shard-contracts.d.ts

@@ -359,6 +359,20 @@ export declare const shardControlOperationSchema: z.ZodDiscriminatedUnion<[z.Zod
     expectedRevision: z.ZodNumber;
     value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
     actorAuthenticatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"oauth.consumer.cleanup">;
+    consumerBindingId: z.ZodUUID;
+    moduleId: z.ZodString;
+    provider: z.ZodEnum<{
+        youtube: "youtube";
+        twitch: "twitch";
+    }>;
+    guildId: z.ZodString;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
+    subjectUserId: z.ZodString;
+    contractVersion: z.ZodNumber;
+    correlationId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"support.notification.send">;
     guildId: z.ZodString;
@@ -698,6 +712,20 @@ export declare const shardControlRequestSchema: z.ZodObject<{
         expectedRevision: z.ZodNumber;
         value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
         actorAuthenticatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"oauth.consumer.cleanup">;
+        consumerBindingId: z.ZodUUID;
+        moduleId: z.ZodString;
+        provider: z.ZodEnum<{
+            youtube: "youtube";
+            twitch: "twitch";
+        }>;
+        guildId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        subjectUserId: z.ZodString;
+        contractVersion: z.ZodNumber;
+        correlationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"support.notification.send">;
         guildId: z.ZodString;
@@ -1542,6 +1570,20 @@ export declare const supervisorMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         expectedRevision: z.ZodNumber;
         value: z.ZodRecord<z.ZodString, z.ZodCustom<ManagedResourceValue, ManagedResourceValue>>;
         actorAuthenticatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"oauth.consumer.cleanup">;
+        consumerBindingId: z.ZodUUID;
+        moduleId: z.ZodString;
+        provider: z.ZodEnum<{
+            youtube: "youtube";
+            twitch: "twitch";
+        }>;
+        guildId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        subjectUserId: z.ZodString;
+        contractVersion: z.ZodNumber;
+        correlationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"support.notification.send">;
         guildId: z.ZodString;

package/dist/shard-contracts.js

@@ -425,6 +425,20 @@ export const shardControlOperationSchema = z.discriminatedUnion("kind", [
         ...mutationContext.shape,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("oauth.consumer.cleanup"),
+        consumerBindingId: z.uuid(),
+        moduleId,
+        provider: z.enum(["youtube", "twitch"]),
+        guildId: snowflake,
+        resourceType,
+        resourceId,
+        subjectUserId: snowflake,
+        contractVersion: z.number().int().min(1).max(32_767),
+        correlationId: z.string().trim().min(1).max(200),
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("support.notification.send"),
@@ -1111,6 +1125,18 @@ export async function executeShardControlOperation(handler, operation) {
                     ? { actorAuthenticatedAt: operation.actorAuthenticatedAt }
                     : {}),
             });
+        case "oauth.consumer.cleanup":
+            return handler.cleanupOAuthConsumer({
+                consumerBindingId: operation.consumerBindingId,
+                moduleId: operation.moduleId,
+                provider: operation.provider,
+                guildId: operation.guildId,
+                resourceType: operation.resourceType,
+                resourceId: operation.resourceId,
+                subjectUserId: operation.subjectUserId,
+                contractVersion: operation.contractVersion,
+                correlationId: operation.correlationId,
+            });
         case "support.notification.send": {
             return handler.sendSupportNotification({
                 notificationId: operation.notificationId,

package/dist/shard-router.d.ts

@@ -11,10 +11,13 @@ export declare class ShardControlRouter implements BotControlHandler {
         localLeases: ReadonlyMap<number, ShardLease>;
         dispatchLocal: LocalDispatcher;
         privacy?: Pick<BotControlHandler, "listPrivacyProviders" | "capturePrivacy" | "erasePrivacy">;
+        availability?: Pick<BotControlHandler, "listAvailabilityModules">;
         localLeaderLease?: ShardLeaderLease;
         coordinator?: ShardCoordinator;
         notificationGuildId?: string;
     });
+    cleanupOAuthConsumer(input: Parameters<BotControlHandler["cleanupOAuthConsumer"]>[0]): ReturnType<BotControlHandler["cleanupOAuthConsumer"]>;
+    listAvailabilityModules(): ReturnType<BotControlHandler["listAvailabilityModules"]>;
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     canAccessDashboard(input: Parameters<BotControlHandler["canAccessDashboard"]>[0]): ReturnType<BotControlHandler["canAccessDashboard"]>;
     getGuildAccessPolicy(input: Parameters<BotControlHandler["getGuildAccessPolicy"]>[0]): ReturnType<BotControlHandler["getGuildAccessPolicy"]>;

package/dist/shard-router.js

@@ -12,6 +12,14 @@ export class ShardControlRouter {
     constructor(input) {
         this.input = input;
     }
+    cleanupOAuthConsumer(input) {
+        return this.#route({ kind: "oauth.consumer.cleanup", ...input });
+    }
+    listAvailabilityModules() {
+        if (!this.input.availability)
+            return Promise.reject(new BotControlTransportError(503, "Module availability catalogue is unavailable"));
+        return this.input.availability.listAvailabilityModules();
+    }
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }

package/dist/shard-supervisor.js

@@ -23,6 +23,7 @@ import { createDeveloperOperationsModule } from "./developer-operations-module.j
 import { SupervisorCloudDiscordDirectory } from "./supervisor-cloud-directory.js";
 import { createSupportModule } from "./support-module.js";
 import { createOAuthModule } from "./oauth-module.js";
+import { availabilityCatalogue, availabilityCatalogueDefinitions, } from "./module-availability-control.js";
 import { createScheduledTaskRunner, schedulerOperationalHealth, } from "./scheduled-task-runner.js";
 import { numericWriteBehindRegistrations } from "./numeric-write-behind.js";
 import { executeRedisNumericOperation, RedisNumericWriteBehindService, } from "./numeric-write-behind-redis.js";
@@ -229,6 +230,10 @@ export async function startShardSupervisor(environment, processEnvironment, work
             ...publicModules,
             ...(operationsModule ? [operationsModule] : []),
         ];
+        const availabilityModules = availabilityCatalogueDefinitions(modules);
+        const availabilityService = {
+            listAvailabilityModules: () => availabilityCatalogue(availabilityModules),
+        };
         const initialiseLeader = async () => {
             await runLeaderStartup(database, environment, modulePackages, modules, logger);
             assertStartupLeaseHealthy();
@@ -258,6 +263,7 @@ export async function startShardSupervisor(environment, processEnvironment, work
                 localLeases,
                 dispatchLocal,
                 privacy: privacyService,
+                availability: availabilityService,
                 localLeaderLease: leaderLease,
                 ...(coordinator ? { coordinator } : {}),
                 ...(environment.DISCORD_INTERNAL_GUILD_ID
@@ -351,6 +357,7 @@ export async function startShardSupervisor(environment, processEnvironment, work
             localLeases,
             dispatchLocal,
             ...(privacyService ? { privacy: privacyService } : {}),
+            availability: availabilityService,
             ...(leaderLease ? { localLeaderLease: leaderLease } : {}),
             ...(coordinator ? { coordinator } : {}),
             ...(environment.DISCORD_INTERNAL_GUILD_ID
@@ -651,7 +658,22 @@ export async function startShardSupervisor(environment, processEnvironment, work
             }
         }
         assertShardMessageSize(response);
-        await workers.get(shardId)?.send(response);
+        await sendWorkerResponse(shardId, response);
+    }
+    async function sendWorkerResponse(shardId, response) {
+        if (shuttingDown)
+            return;
+        const worker = workers.get(shardId);
+        if (!worker?.process)
+            return;
+        try {
+            await worker.send(response);
+        }
+        catch (error) {
+            if (shuttingDown || !worker.process)
+                return;
+            throw error;
+        }
     }
     async function handleWorkerMessage(shardId, raw) {
         if (serializedBytes(raw) > SHARD_CONTROL_MAX_BYTES)
@@ -709,7 +731,7 @@ export async function startShardSupervisor(environment, processEnvironment, work
             const response = leaderLease
                 ? await executeLeaderCloud(message.data)
                 : await routeCloudToLeader(message.data);
-            await workers.get(shardId)?.send(response);
+            await sendWorkerResponse(shardId, response);
             return;
         }
         if (message.data.type === "helyx.operations.health.request") {
@@ -720,7 +742,7 @@ export async function startShardSupervisor(environment, processEnvironment, work
                 health: boundedOperationalHealth(await buildHealth()),
             };
             assertShardMessageSize(response);
-            await workers.get(shardId)?.send(response);
+            await sendWorkerResponse(shardId, response);
         }
     }
     function dispatchLocal(shardId, request) {
@@ -1392,9 +1414,14 @@ export function buildShardWorkerEnvironment(source, identity, restartCount) {
         "HELYX_SUPPORT_STAFF_CHANNEL_ID",
         "HELYX_MODULE_PACKAGES",
         "HELYX_MESSAGE_CONTENT_ENABLED",
+        "HELYX_GUILD_MEMBERS_ENABLED",
+        "HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS",
         "HELYX_MODULE_CATALOGUE_PATH",
         "HELYX_CLOUD_CONNECT_ENABLED",
+        "HELYX_CLOUD_API_URL",
         "HELYX_OWNER_USER_IDS",
+        "HELYX_OAUTH_ENABLED",
+        "HELYX_OAUTH_INTERNAL_SECRET",
         "HELYX_VERIFICATION_ENABLED",
         "HELYX_VERIFICATION_INSTALLATION_ID",
         "HELYX_VERIFICATION_URL",

package/dist/shard-worker.d.ts

@@ -9,7 +9,7 @@ export declare function createLeaseHeartbeatWatchdog(onExpired: () => void, time
 };
 export declare function startShardWorker(processEnvironment?: NodeJS.ProcessEnv, identity?: {
     version: 1;
-    mode: "auto" | "fixed";
+    mode: "fixed" | "auto";
     scope: "local" | "coordinated";
     generation: string;
     supervisorId: string;
@@ -50,12 +50,15 @@ export declare function parseShardWorkerEnvironment(processEnvironment: NodeJS.P
     HELYX_OAUTH_ENABLED: boolean;
     HELYX_CLOUD_ENDPOINT: string;
     HELYX_OWNER_USER_IDS: string[];
-    HELYX_SHARD_MODE: "off" | "auto" | "fixed";
+    HELYX_SHARD_MODE: "fixed" | "off" | "auto";
     HELYX_SHARD_SCOPE: "local" | "coordinated";
     HELYX_CLOUD_AUDIT_RETENTION_DAYS: number;
     HELYX_CLOUD_CREDENTIAL_AUDIT_RETENTION_DAYS: number;
     LOG_LEVEL: "error" | "fatal" | "warn" | "info" | "debug" | "trace" | "silent";
     NODE_ENV: "development" | "test" | "production";
+    HELYX_STATUS_ENABLED: boolean;
+    HELYX_STATUS_URL: string;
+    HELYX_STATUS_HEARTBEAT_INTERVAL_SECONDS: number;
     HELYX_BOT_CONTROL_SECRET?: string | undefined;
     HELYX_SUPPORT_SERVICE_SECRET?: string | undefined;
     HELYX_VERIFICATION_INSTALLATION_ID?: string | undefined;
@@ -69,6 +72,9 @@ export declare function parseShardWorkerEnvironment(processEnvironment: NodeJS.P
     HELYX_SHARD_REDIS_NAMESPACE?: string | undefined;
     HELYX_SHARD_GENERATION?: string | undefined;
     HELYX_SHARD_DATABASE_CONNECTION_BUDGET?: number | undefined;
+    HELYX_STATUS_HEARTBEAT_SECRET?: string | undefined;
+    CF_ACCESS_CLIENT_ID?: string | undefined;
+    CF_ACCESS_CLIENT_SECRET?: string | undefined;
 };
 export declare function shardWorkerCommandRegistration(input: {
     internalGuildId?: string;

package/dist/shard-worker.js

@@ -3,7 +3,7 @@ import { safeError, ServiceRegistry } from "@helyx/core";
 import { checkDatabaseConnection, createDatabasePool } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
 import { createPlatformServices } from "@helyx/platform";
-import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
 import { Client, Events, Partials } from "discord.js";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import pino from "pino";
@@ -179,6 +179,9 @@ export async function startShardWorker(processEnvironment = process.env, identit
         })) {
             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) {

package/dist/support-module.js

@@ -28,6 +28,7 @@ export function createSupportModule(transport) {
                 {
                     name: "bug",
                     description: "Report a Helyx bug to the support team",
+                    acknowledgement: "immediate-modal",
                     registration: "global",
                     contexts: ["guild"],
                     integrationTypes: ["guild_install"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/bot",
-  "version": "0.4.32",
+  "version": "0.4.35",
   "description": "Production Discord runtime for the modular Helyx platform.",
   "keywords": [
     "helyx",
@@ -53,9 +53,10 @@
     "@helyx/core": ">=0.1.0 <0.2.0",
     "@helyx/database": ">=0.8.0 <0.9.0",
     "@helyx/framework": ">=0.1.0 <0.2.0",
-    "@helyx/module-manifest": ">=0.6.0 <0.7.0",
-    "@helyx/platform": ">=0.5.0 <0.6.0",
-    "@helyx/sdk": ">=0.7.0 <0.8.0",
+    "@helyx/module-manifest": ">=0.7.0 <0.8.0",
+    "@helyx/platform": ">=0.6.0 <0.7.0",
+    "@helyx/sdk": ">=0.8.0 <0.9.0",
+    "@helyx/status-client": ">=0.1.0 <0.2.0",
     "@helyx/verification-contracts": ">=0.3.0 <0.4.0",
     "discord.js": "14.27.0",
     "fastify": "5.10.0",