@helyx/bot 1.3.0 → 1.4.0

package/dist/index.js

@@ -1,8 +1,9 @@
 import { parseBotEnvironment } from "@helyx/config";
 import { StatusHeartbeatReporter } from "@helyx/status-client";
 import { safeError, ServiceRegistry } from "@helyx/core";
-import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, HostedServerSafetyRepository, InteractionSessionRepository, EckoOperationsRepository, PremiumAllocationRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
+import { checkDatabaseConnection, createDatabasePool, EckoOperationsRepository, inspectConfiguredModuleMigrations, inspectCoreMigrations, inspectCreatorOnboardingMigrations, runCreatorOnboardingMigrations, PremiumAllocationRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
+import { assertRepositoryEngineSupported } from "@helyx/database/adapters";
 import { createPlatformServices, gamingStatisticsRecordOwner, achievementContributionRecordOwner, PostgresPrivacyProviderExecutor, PlatformMemberRoleGrantOwnershipService, PostgresMemberRoleGrantOwnershipStore, } from "@helyx/platform";
 import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
 import { Client, Events, GatewayIntentBits, Partials } from "discord.js";
@@ -15,7 +16,7 @@ import { ClientCloudDiscordDirectory, CloudConnectorController, } from "./cloud-
 import { createCloudManagementModule } from "./cloud-management-module.js";
 import { installInteractions } from "./interactions.js";
 import { installGuildTracking } from "./guilds.js";
-import { loadConfiguredModulePackages, platformServiceOptions, } from "./modules.js";
+import { assertConfiguredModuleDatabaseCompatibility, loadConfiguredModulePackages, platformServiceOptions, } from "./modules.js";
 import { resolveModulePackageSpecifiers } from "./module-configuration.js";
 import { createPermissionsModule } from "./permissions-module.js";
 import { createManagementModule } from "./management-module.js";
@@ -42,12 +43,16 @@ import { DiscordOwnedMessageDeletionService } from "./discord-owned-message-serv
 import { DiscordGuildHealthInspection } from "./discord-guild-health.js";
 import { DiscordAnalyticsInspection } from "./discord-analytics.js";
 import { DiscordInviteInspection } from "./discord-invites.js";
+import { installCreatorInvitePlatform } from "./creator-onboarding-platform.js";
 import { GuildCommandWorker } from "./guild-command-worker.js";
 import { GuildCommandDiscordClient } from "./guild-command-discord-client.js";
 import { GuildCommandReadService } from "./guild-command-read-service.js";
 import { scheduleGuildCommandRelease } from "./guild-command-release.js";
 import { CoreResourceAuthorizationService } from "./resource-authorization.js";
 import { PostgresTriviaDataProvider } from "./trivia-data-provider.js";
+import { MysqlTriviaDataProvider } from "./trivia-data-provider.js";
+import { cleanupExpiredCoreRecords, createPostgresCoreRetentionRepositories, } from "./core-retention.js";
+import { openMysqlBotRuntimePersistence } from "./mysql-runtime-persistence.js";
 import { createLocalScheduledTaskRoute, createScheduledTaskRunner, schedulerOperationalHealth, } from "./scheduled-task-runner.js";
 import { createLocalNumericWriteBehind } from "./numeric-write-behind.js";
 import { discordRestOptions } from "./discord-rest.js";
@@ -56,6 +61,7 @@ import { assertReviewedPremiumCatalogue, requirePremiumProviderEnvironment, } fr
 import { enforcePremiumCatalogue, PREMIUM_CATALOGUE_ENFORCEMENT_INTERVAL_MS, } from "./premium-catalogue-enforcement.js";
 import { HostedBotInviteGateClient, HostedServerLeaveWorker, HostedServerModerationClient, PostgresHostedGuildSafety, } from "./hosted-server-moderation.js";
 export { loadConfiguredModulePackages } from "./modules.js";
+export { assertConfiguredModuleDatabaseCompatibility } from "./modules.js";
 export { resolveModulePackageSpecifiers } from "./module-configuration.js";
 export * from "./control-server.js";
 const bootstrapLogger = pino({ base: { component: "bot" } });
@@ -65,6 +71,11 @@ export async function startBot(processEnvironment = process.env) {
     if (processEnvironment.HELYX_SHARD_WORKER_CONTRACT !== undefined)
         return startShardWorker(processEnvironment, parseShardWorkerLaunchContract(processEnvironment.HELYX_SHARD_WORKER_CONTRACT));
     const environment = parseBotEnvironment(processEnvironment);
+    assertRepositoryEngineSupported(environment.DATABASE_ENGINE, ["postgresql", "mysql"], "Bot platform");
+    if (environment.DATABASE_ENGINE === "mysql" &&
+        environment.HELYX_SHARD_MODE !== "off") {
+        throw new Error("MySQL bot runtime does not support shard mode");
+    }
     bootstrapLogger.level = environment.LOG_LEVEL;
     const handle = environment.HELYX_SHARD_MODE !== "off"
         ? await startShardSupervisor(environment, processEnvironment, resolveBotWorkerEntryPoint())
@@ -117,15 +128,49 @@ export async function startBot(processEnvironment = process.env) {
 export function resolveBotWorkerEntryPoint(entryUrl = import.meta.url) {
     return fileURLToPath(entryUrl);
 }
+async function inspectRequiredCoreMigrations(database) {
+    const inspection = await inspectCoreMigrations(database);
+    assertNoPendingMigrations("core", inspection.pending);
+    return { applied: [], verified: inspection.verified };
+}
+async function inspectRequiredModuleMigrations(database, sources) {
+    const inspections = await inspectConfiguredModuleMigrations(database, sources);
+    for (const inspection of inspections)
+        assertNoPendingMigrations(`module ${inspection.moduleId}`, inspection.pending);
+    return inspections.map((inspection) => ({
+        moduleId: inspection.moduleId,
+        applied: [],
+        verified: inspection.verified,
+    }));
+}
+function assertNoPendingMigrations(scope, pending) {
+    if (pending.length > 0)
+        throw new Error(`Hosted ${scope} migrations must be applied by the dedicated primary migration identity before bot startup: ${pending.join(", ")}`);
+}
 async function startUnshardedBot(processEnvironment) {
     const environment = parseBotEnvironment(processEnvironment);
-    const database = createDatabasePool({
-        connectionString: environment.DATABASE_URL,
-        sslMode: environment.DATABASE_SSL,
-        applicationName: "helyx-bot",
-    });
-    const hostedOwnerObserver = new PostgresHostedGuildSafety(database);
-    const eckoOperations = new EckoOperationsRepository(database);
+    const mysqlModulePackages = environment.DATABASE_ENGINE === "mysql"
+        ? await loadConfiguredModulePackages(await resolveModulePackageSpecifiers(environment.HELYX_MODULE_PACKAGES, undefined, undefined, environment.HELYX_MODULE_CATALOGUE_PATH, environment.HELYX_RUNTIME_PROFILE))
+        : undefined;
+    const mysql = mysqlModulePackages
+        ? await openMysqlBotRuntimePersistence({
+            environment,
+            modulePackages: mysqlModulePackages,
+        })
+        : undefined;
+    const database = mysql
+        ? undefined
+        : createDatabasePool({
+            connectionString: environment.DATABASE_URL,
+            sslMode: environment.DATABASE_SSL,
+            applicationName: "helyx-bot",
+        });
+    const hostedOwnerObserver = database
+        ? new PostgresHostedGuildSafety(database)
+        : undefined;
+    const eckoOperations = database
+        ? new EckoOperationsRepository(database)
+        : undefined;
     const hostedSafety = environment.HELYX_HOSTED_MODERATION_ENABLED
         ? hostedOwnerObserver
         : undefined;
@@ -148,70 +193,77 @@ async function startUnshardedBot(processEnvironment) {
     let databaseClosed = false;
     let retentionCleanupTimer;
     let premiumCatalogueTimer;
+    let creatorInvitePlatform;
     async function closeDatabase() {
         if (databaseClosed)
             return;
         databaseClosed = true;
         if (privacyDatabase)
             await privacyDatabase.end();
-        await database.end();
+        if (database)
+            await database.end();
+        else
+            await mysql?.database.close();
     }
     try {
-        await checkDatabaseConnection(database);
+        if (database)
+            await checkDatabaseConnection(database);
         if (privacyDatabase) {
             await checkDatabaseConnection(privacyDatabase);
+            if (!database)
+                throw new Error("Privacy executor requires PostgreSQL");
             await assertDistinctDatabaseRoles(database, privacyDatabase);
         }
-        const migrationResult = await runCoreMigrations(database);
+        const migrationResult = database
+            ? environment.HELYX_DATABASE_STARTUP_MODE === "inspect"
+                ? await inspectRequiredCoreMigrations(database)
+                : await runCoreMigrations(database)
+            : mysql.database.migrations.core;
         bootstrapLogger.info({
             event: "database.ready",
             appliedMigrations: migrationResult.applied,
             verifiedMigrationCount: migrationResult.verified.length,
         }, "Core database ready");
-        const cleanupExpiredCoreRecords = async () => {
-            const [sessions, rateLimits, verificationAudit, commandRecords, hostedLeaveDeliveries,] = await Promise.all([
-                new InteractionSessionRepository(database).deleteExpired(),
-                new RateLimitRepository(database).deleteExpired(),
-                new AuditRepository(database).deleteModuleEventsOlderThanMonths("helyx.verification", 12),
-                new GuildCommandRepository(database).deleteExpired(12),
-                new HostedServerSafetyRepository(database).deleteTerminalLeaveDeliveriesOlderThanMonths(24),
-            ]);
-            const commandRecordCount = commandRecords.history +
-                commandRecords.idempotencyKeys +
-                commandRecords.creationLedger +
-                commandRecords.requests;
-            if (sessions > 0 ||
-                rateLimits > 0 ||
-                verificationAudit > 0 ||
-                commandRecordCount > 0 ||
-                hostedLeaveDeliveries > 0) {
-                bootstrapLogger.info({
-                    event: "database.retention_cleaned",
-                    interactionSessions: sessions,
-                    rateLimitWindows: rateLimits,
-                    verificationAuditEvents: verificationAudit,
-                    commandRecords: commandRecordCount,
-                    hostedLeaveDeliveries,
-                }, "Expired core records removed");
+        const modulePackages = mysqlModulePackages ??
+            (await loadConfiguredModulePackages(await resolveModulePackageSpecifiers(environment.HELYX_MODULE_PACKAGES, undefined, undefined, environment.HELYX_MODULE_CATALOGUE_PATH, environment.HELYX_RUNTIME_PROFILE)));
+        assertConfiguredModuleDatabaseCompatibility(modulePackages, environment.DATABASE_ENGINE);
+        const moduleMigrationSources = modulePackages.map(({ definition, packageRoot }) => ({
+            moduleId: definition.manifest.id,
+            moduleVersion: definition.manifest.version,
+            migrationsDirectory: join(packageRoot, "migrations"),
+        }));
+        if (database &&
+            environment.HELYX_RUNTIME_PROFILE === "hosted" &&
+            modulePackages.some(({ definition }) => definition.manifest.id === "helyx.creator-connections")) {
+            if (environment.HELYX_DATABASE_STARTUP_MODE === "inspect") {
+                const inspection = await inspectCreatorOnboardingMigrations(database);
+                assertNoPendingMigrations("hosted creator onboarding", inspection.pending);
             }
+            else
+                await runCreatorOnboardingMigrations(database);
+        }
+        const inspectedModuleMigrationResults = database && environment.HELYX_DATABASE_STARTUP_MODE === "inspect"
+            ? await inspectRequiredModuleMigrations(database, moduleMigrationSources)
+            : undefined;
+        const retentionRepositories = mysql?.coreRetention ??
+            createPostgresCoreRetentionRepositories(database);
+        const runRetentionCleanup = async () => {
+            await cleanupExpiredCoreRecords(retentionRepositories, bootstrapLogger);
         };
-        await cleanupExpiredCoreRecords().catch((error) => {
+        await runRetentionCleanup().catch((error) => {
             bootstrapLogger.warn({ event: "database.retention_cleanup_failed", error: safeError(error) }, "Expired core record cleanup failed");
         });
-        retentionCleanupTimer = setInterval(() => void cleanupExpiredCoreRecords().catch((error) => {
+        retentionCleanupTimer = setInterval(() => void runRetentionCleanup().catch((error) => {
             bootstrapLogger.warn({
                 event: "database.retention_cleanup_failed",
                 error: safeError(error),
             }, "Expired core record cleanup failed");
         }), RETENTION_CLEANUP_INTERVAL_MS);
         retentionCleanupTimer.unref();
-        const moduleSpecifiers = await resolveModulePackageSpecifiers(environment.HELYX_MODULE_PACKAGES, undefined, undefined, environment.HELYX_MODULE_CATALOGUE_PATH);
-        const modulePackages = await loadConfiguredModulePackages(moduleSpecifiers);
-        const moduleMigrationResults = await runConfiguredModuleMigrations(database, modulePackages.map(({ definition, packageRoot }) => ({
-            moduleId: definition.manifest.id,
-            moduleVersion: definition.manifest.version,
-            migrationsDirectory: join(packageRoot, "migrations"),
-        })));
+        const moduleMigrationResults = inspectedModuleMigrationResults ??
+            (database
+                ? await runConfiguredModuleMigrations(database, moduleMigrationSources)
+                : mysql.database.migrations.modules);
         bootstrapLogger.info({
             event: "database.modules_ready",
             modules: moduleMigrationResults.map((result) => ({
@@ -222,14 +274,16 @@ async function startUnshardedBot(processEnvironment) {
         }, "Module databases ready");
         const featureModules = modulePackages.map(({ definition }) => definition);
         assertReviewedPremiumCatalogue(featureModules);
-        await enforcePremiumCatalogue(database, bootstrapLogger);
-        premiumCatalogueTimer = setInterval(() => void enforcePremiumCatalogue(database, bootstrapLogger).catch((error) => {
-            bootstrapLogger.warn({
-                event: "premium.catalogue_enforcement_failed",
-                error: safeError(error),
-            }, "Premium module catalogue enforcement failed");
-        }), PREMIUM_CATALOGUE_ENFORCEMENT_INTERVAL_MS);
-        premiumCatalogueTimer.unref();
+        if (database) {
+            await enforcePremiumCatalogue(database, bootstrapLogger);
+            premiumCatalogueTimer = setInterval(() => void enforcePremiumCatalogue(database, bootstrapLogger).catch((error) => {
+                bootstrapLogger.warn({
+                    event: "premium.catalogue_enforcement_failed",
+                    error: safeError(error),
+                }, "Premium module catalogue enforcement failed");
+            }), PREMIUM_CATALOGUE_ENFORCEMENT_INTERVAL_MS);
+            premiumCatalogueTimer.unref();
+        }
         const client = new Client({
             rest: discordRestOptions,
             intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED, environment.HELYX_RUNTIME_PROFILE),
@@ -239,7 +293,9 @@ async function startUnshardedBot(processEnvironment) {
         const guildResources = new DiscordGuildResourceDirectory(client);
         const cloudConnector = new CloudConnectorController({
             environment,
-            database,
+            ...(mysql
+                ? { repository: mysql.cloudConnector }
+                : { database: database }),
             discord: new ClientCloudDiscordDirectory(client),
             modules: modulePackages,
             coreVersion: readBotVersion(),
@@ -257,7 +313,7 @@ async function startUnshardedBot(processEnvironment) {
         const supportModule = createSupportModule(cloudConnector);
         const privacyModule = createPrivacyModule();
         const premiumEnvironment = requirePremiumProviderEnvironment(featureModules, environment.STRIPE_ENVIRONMENT);
-        const premiumActivationModule = !premiumEnvironment
+        const premiumActivationModule = !premiumEnvironment || !database
             ? undefined
             : createPremiumActivationModule({
                 allocations: new PremiumAllocationRepository(database),
@@ -286,7 +342,10 @@ async function startUnshardedBot(processEnvironment) {
         const buildHealth = async () => {
             let databaseHealthy = true;
             try {
-                await checkDatabaseConnection(database);
+                if (database)
+                    await checkDatabaseConnection(database);
+                else
+                    await mysql.database.healthCheck();
             }
             catch {
                 databaseHealthy = false;
@@ -342,6 +401,7 @@ async function startUnshardedBot(processEnvironment) {
                 internalGuildId: environment.DISCORD_INTERNAL_GUILD_ID,
                 approvedRoleIds: environment.APPROVED_ROLES,
                 botVersion: readBotVersion(),
+                databaseEngine: environment.DATABASE_ENGINE,
                 ...(deployedCommit ? { deploymentReference: deployedCommit } : {}),
                 coreFunctions: [
                     managementModule,
@@ -354,7 +414,9 @@ async function startUnshardedBot(processEnvironment) {
                 ].map(({ manifest }) => manifest),
                 modules: featureModules.map(({ manifest }) => manifest),
                 processLabel: "unsharded bot process",
-                triviaData: new PostgresTriviaDataProvider(database),
+                triviaData: mysql
+                    ? new MysqlTriviaDataProvider((await import("@helyx/database-mysql")).createMysqlQueryExecutor(mysql.pool))
+                    : new PostgresTriviaDataProvider(database),
                 health: {
                     getHealth: buildHealth,
                 },
@@ -368,12 +430,29 @@ async function startUnshardedBot(processEnvironment) {
         const platformServices = new Map();
         const serviceAccess = new ServiceRegistry(platformServices);
         const serviceOptions = platformServiceOptions(environment, publicModules);
-        for (const [name, service] of createPlatformServices(database, publicModules, {
-            ...serviceOptions,
-            activationServices: serviceAccess,
-        })) {
+        const platformFactory = mysql
+            ? mysql.createPlatformServices(publicModules, {
+                ...serviceOptions,
+                recordRecoveryOwnership: { mode: "single-worker" },
+                activationServices: serviceAccess,
+            })
+            : createPlatformServices(database, publicModules, {
+                ...serviceOptions,
+                recordRecoveryOwnership: { mode: "single-worker" },
+                activationServices: serviceAccess,
+            });
+        for (const [name, service] of platformFactory) {
             platformServices.set(name, service);
         }
+        const applicationUrls = serviceAccess.get(HELYX_SERVICE_NAMES.applicationUrls);
+        platformServices.set(HELYX_SERVICE_NAMES.applicationUrls, {
+            dashboardBaseUrl: applicationUrls.dashboardBaseUrl,
+            get dashboardInstallationId() {
+                return environment.HELYX_RUNTIME_PROFILE === "self-hosted"
+                    ? cloudConnector.status().installationId
+                    : undefined;
+            },
+        });
         await serviceAccess
             .get(HELYX_SERVICE_NAMES.moduleAvailability)
             .refresh();
@@ -385,6 +464,10 @@ async function startUnshardedBot(processEnvironment) {
                 internalSecret: environment.HELYX_VERIFICATION_INTERNAL_SECRET,
                 installationId: environment.HELYX_VERIFICATION_INSTALLATION_ID,
                 publicSigningKeys: environment.HELYX_VERIFICATION_SIGNING_PUBLIC_KEYS,
+                runtimeEnvironment: environment.NODE_ENV,
+                ...(environment.HELYX_VERIFICATION_PUBLIC_URL === undefined
+                    ? {}
+                    : { publicOrigin: environment.HELYX_VERIFICATION_PUBLIC_URL }),
             }));
             platformServices.set(HELYX_SERVICE_NAMES.verificationMembers, new DiscordVerificationMemberService(client));
         }
@@ -399,8 +482,29 @@ async function startUnshardedBot(processEnvironment) {
         platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordModerationMemberEnforcementAdapter(client));
         const memberRoles = new DiscordMemberRoleService(client);
         platformServices.set(HELYX_SERVICE_NAMES.memberRoles, memberRoles);
-        platformServices.set(HELYX_SERVICE_NAMES.memberRoleGrants, new PlatformMemberRoleGrantOwnershipService(new PostgresMemberRoleGrantOwnershipStore(database), memberRoles));
+        platformServices.set(HELYX_SERVICE_NAMES.memberRoleGrants, new PlatformMemberRoleGrantOwnershipService(mysql
+            ? mysql.memberRoleOwnership
+            : new PostgresMemberRoleGrantOwnershipStore(database), memberRoles));
         platformServices.set(HELYX_SERVICE_NAMES.discordResources, new DiscordResourceInspection(client));
+        if (database && environment.HELYX_RUNTIME_PROFILE === "hosted")
+            creatorInvitePlatform = await installCreatorInvitePlatform({
+                client,
+                database,
+                services: serviceAccess,
+                modules: publicModules,
+                encryptionKey: environment.HELYX_DATA_ENCRYPTION_KEY,
+                ...(environment.HELYX_CLOUD_API_URL &&
+                    environment.HELYX_OAUTH_INTERNAL_SECRET
+                    ? {
+                        oauthBroker: {
+                            baseUrl: environment.HELYX_CLOUD_API_URL,
+                            secret: environment.HELYX_OAUTH_INTERNAL_SECRET,
+                        },
+                    }
+                    : {}),
+                register: (name, service) => platformServices.set(name, service),
+                warn: (event) => bootstrapLogger.warn({ event }, "Creator invite cleanup will retry"),
+            });
         const moderationPlatformServices = await installModerationPlatformServices({
             services: platformServices,
             serviceAccess,
@@ -421,7 +525,7 @@ async function startUnshardedBot(processEnvironment) {
         if (serviceOptions.inviteFingerprintKey)
             platformServices.set(HELYX_SERVICE_NAMES.discordInvites, new DiscordInviteInspection(client, serviceOptions.inviteFingerprintKey));
         if (featureModules.some(({ manifest }) => manifest.id === "helyx.logging")) {
-            platformServices.set(HELYX_SERVICE_NAMES.moduleLogging, new DiscordModuleLoggingService(client, database, publicModules, bootstrapLogger));
+            platformServices.set(HELYX_SERVICE_NAMES.moduleLogging, new DiscordModuleLoggingService(client, mysql?.logging ?? database, publicModules, bootstrapLogger));
         }
         const runtime = createRuntime({
             modules,
@@ -437,14 +541,18 @@ async function startUnshardedBot(processEnvironment) {
             ...(cloudManagementModule ? [cloudManagementModule.manifest.id] : []),
             ...(operationsModule ? [operationsModule.manifest.id] : []),
         ]);
-        const prepareGuilds = installGuildTracking(client, database, publicModules, bootstrapLogger, enabledCoreModuleIds, undefined, environment.HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS * 1_000, undefined, environment.DISCORD_CLIENT_ID, hostedSafety, hostedInviteGate, hostedOwnerObserver);
-        const hostedLeaveWorker = new HostedServerLeaveWorker(database, client, bootstrapLogger);
+        const prepareGuilds = installGuildTracking(client, mysql?.guildTracking ?? database, publicModules, bootstrapLogger, enabledCoreModuleIds, undefined, environment.HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS * 1_000, undefined, environment.DISCORD_CLIENT_ID, hostedSafety, hostedInviteGate, hostedOwnerObserver);
+        const hostedLeaveWorker = database && environment.HELYX_HOSTED_MODERATION_ENABLED
+            ? new HostedServerLeaveWorker(database, client, bootstrapLogger)
+            : undefined;
         const commandsReady = installInteractions(client, modules, {
             globalCommandMode: environment.HELYX_GLOBAL_COMMAND_MODE,
             ...(environment.DISCORD_INTERNAL_GUILD_ID
                 ? { internalGuildId: environment.DISCORD_INTERNAL_GUILD_ID }
                 : {}),
-            synchroniseInternalGuild: !environment.HELYX_GUILD_COMMAND_WRITES_ENABLED,
+            // The guild-command worker owns the complete collection. A write-disabled
+            // startup must not replace existing module commands with internal roots.
+            synchroniseInternalGuild: false,
             prepare: prepareGuilds,
             selfAuthorizingGuildModuleIds: new Set([
                 supportModule.manifest.id,
@@ -459,7 +567,7 @@ async function startUnshardedBot(processEnvironment) {
             runtimeProfile: environment.HELYX_RUNTIME_PROFILE,
             evidenceStore: moderationPlatformServices.evidenceStore,
         });
-        const controlService = new BotControlService(database, [
+        const controlService = new BotControlService(mysql?.control ?? database, [
             ...publicModules,
             gamingStatisticsRecordOwner,
             achievementContributionRecordOwner,
@@ -480,14 +588,15 @@ async function startUnshardedBot(processEnvironment) {
                 channelId: environment.HELYX_SUPPORT_STAFF_CHANNEL_ID,
             }
             : undefined, undefined, undefined, featureModules);
-        cloudConnector.setControlHandler(controlService);
+        const guildCommandReads = new GuildCommandReadService(mysql?.commandRead ?? database, environment.DISCORD_CLIENT_ID, () => guildCommandWorker?.getHealth(), environment.DISCORD_TOKEN, environment.HELYX_GUILD_COMMAND_WRITES_ENABLED, environment.HELYX_GUILD_COMMAND_WRITE_GUILD_IDS, environment.HELYX_GUILD_COMMAND_WRITE_SCOPE === "all", modules);
+        cloudConnector.setControlHandler(controlService, guildCommandReads);
         let controlServer;
         let shuttingDown = false;
         async function shutdown(reason = "programmatic") {
             if (shuttingDown)
                 return;
             shuttingDown = true;
-            prepareGuilds.stop();
+            await prepareGuilds.stop();
             await hostedLeaveWorker?.stop();
             process.off("SIGINT", onSigint);
             process.off("SIGTERM", onSigterm);
@@ -495,6 +604,7 @@ async function startUnshardedBot(processEnvironment) {
                 clearInterval(retentionCleanupTimer);
             if (premiumCatalogueTimer)
                 clearInterval(premiumCatalogueTimer);
+            await creatorInvitePlatform?.stop();
             await scheduledTasks?.stop().catch((error) => {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "scheduler.stop_failed", error: safeError(error) }, "Scheduled task runner shutdown failed");
@@ -566,7 +676,9 @@ async function startUnshardedBot(processEnvironment) {
             await commandsReady;
             hostedLeaveWorker?.start();
             scheduledTasks = createScheduledTaskRunner({
-                database,
+                ...(mysql
+                    ? { repository: mysql.scheduledTasks }
+                    : { database: database }),
                 modules: publicModules,
                 route: createLocalScheduledTaskRoute({
                     modules: publicModules,
@@ -578,7 +690,9 @@ async function startUnshardedBot(processEnvironment) {
             });
             scheduledTasks.start();
             guildCommandWorker = new GuildCommandWorker({
-                database,
+                ...(mysql
+                    ? { repositories: mysql.commandWorker }
+                    : { database: database }),
                 modules,
                 logger: bootstrapLogger,
                 workerId: `unsharded-command:${unshardedSupervisorId}`,
@@ -601,7 +715,7 @@ async function startUnshardedBot(processEnvironment) {
             if (environment.HELYX_GUILD_COMMAND_WRITES_ENABLED &&
                 environment.HELYX_GUILD_COMMAND_WRITE_SCOPE === "all") {
                 void scheduleGuildCommandRelease({
-                    database,
+                    ...(mysql ? mysql.commandRelease : { database: database }),
                     applicationId: environment.DISCORD_CLIENT_ID,
                     releaseId: environment.HELYX_GUILD_COMMAND_RELEASE_ID,
                 })
@@ -636,18 +750,22 @@ async function startUnshardedBot(processEnvironment) {
                 controlServer = await createBotControlServer({
                     service: controlService,
                     secret: environment.HELYX_BOT_CONTROL_SECRET,
-                    deliverHostedServerLeave: (input) => hostedLeaveWorker.deliverOperation(input),
-                    refreshHostedServerOwner: async (guildId) => {
-                        const guild = client.guilds.cache.get(guildId);
-                        if (!guild)
-                            throw new BotControlTransportError(404, "The hosted server is not installed");
-                        return hostedOwnerObserver.refreshOwner(guild);
-                    },
+                    ...(hostedLeaveWorker && hostedOwnerObserver
+                        ? {
+                            deliverHostedServerLeave: (input) => hostedLeaveWorker.deliverOperation(input),
+                            refreshHostedServerOwner: async (guildId) => {
+                                const guild = client.guilds.cache.get(guildId);
+                                if (!guild)
+                                    throw new BotControlTransportError(404, "The hosted server is not installed");
+                                return hostedOwnerObserver.refreshOwner(guild);
+                            },
+                        }
+                        : {}),
                     logger: { level: environment.LOG_LEVEL },
                     runtimeConfiguration: {
                         hostedModerationEnabled: environment.HELYX_HOSTED_MODERATION_ENABLED,
                     },
-                    guildCommands: new GuildCommandReadService(database, environment.DISCORD_CLIENT_ID, () => guildCommandWorker?.getHealth(), environment.DISCORD_TOKEN, environment.HELYX_GUILD_COMMAND_WRITES_ENABLED, environment.HELYX_GUILD_COMMAND_WRITE_GUILD_IDS, environment.HELYX_GUILD_COMMAND_WRITE_SCOPE === "all", modules),
+                    guildCommands: guildCommandReads,
                     ...(ecko ? { ecko } : {}),
                 });
                 await controlServer.listen({
@@ -664,6 +782,7 @@ async function startUnshardedBot(processEnvironment) {
             }
         }
         catch (error) {
+            await prepareGuilds.stop();
             await scheduledTasks?.stop().catch(() => undefined);
             await guildCommandWorker?.stop().catch(() => undefined);
             await cloudConnector.stop().catch(() => undefined);

package/dist/interactions.js

@@ -229,10 +229,16 @@ export function installInteractions(client, modules, registration, logger, servi
                     await interaction.reply(staleComponentResponse());
                     return;
                 }
-                if (modal?.contribution.acknowledgement === "deferred-ephemeral" &&
+                if (modal.contribution.acknowledgement !== undefined &&
                     !interaction.deferred &&
                     !interaction.replied) {
-                    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+                    if (modal.contribution.acknowledgement === "deferred-update" &&
+                        interaction.isFromMessage()) {
+                        await interaction.deferUpdate();
+                    }
+                    else {
+                        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+                    }
                 }
                 if (modal &&
                     (await authorizeComponent(interaction, modal.moduleId, services, undefined, isInstallationIndependentModule(modulesById, modal.moduleId), modulesById.get(modal.moduleId)))) {
@@ -727,7 +733,14 @@ function normalizeAutocompleteChoices(choices) {
 }
 function createModalContext(interaction, services) {
     const updateResponse = interaction.isFromMessage()
-        ? async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined)
+        ? async (response) => {
+            if (interaction.deferred || interaction.replied) {
+                await interaction.editReply(toUpdateOptions(response));
+            }
+            else {
+                await interaction.update(toUpdateOptions(response));
+            }
+        }
         : undefined;
     return {
         interactionId: interaction.id,

package/dist/module-configuration.d.ts

@@ -5,6 +5,6 @@ type CatalogueReader = (path: CatalogueLocation) => Promise<string>;
  * optional runtime allowlist. A package being installed is never sufficient
  * to make it executable: it must be named by one of these explicit sources.
  */
-export declare function resolveModulePackageSpecifiers(configuredPackages: readonly string[], bundledCatalogueUrl?: URL, reader?: CatalogueReader, selectedCataloguePath?: string): Promise<string[]>;
+export declare function resolveModulePackageSpecifiers(configuredPackages: readonly string[], bundledCatalogueUrl?: URL, reader?: CatalogueReader, selectedCataloguePath?: string, runtimeProfile?: "hosted" | "self-hosted"): Promise<string[]>;
 export {};
 //# sourceMappingURL=module-configuration.d.ts.map

package/dist/module-configuration.js

@@ -5,6 +5,7 @@ const officialModulePackage = /^@helyx\/module-[a-z0-9][a-z0-9-]*$/u;
 const modulePackageCatalogueSchema = z
     .object({
     schemaVersion: z.literal(1),
+    databaseEngine: z.enum(["postgresql", "mysql"]).optional(),
     packages: z
         .array(z.string().regex(officialModulePackage))
         .superRefine((packages, context) => {
@@ -23,8 +24,10 @@ const defaultCatalogueUrl = new URL("../hosted-modules.json", import.meta.url);
  * optional runtime allowlist. A package being installed is never sufficient
  * to make it executable: it must be named by one of these explicit sources.
  */
-export async function resolveModulePackageSpecifiers(configuredPackages, bundledCatalogueUrl = defaultCatalogueUrl, reader = (path) => readFile(path, "utf8"), selectedCataloguePath) {
-    const bundledPackages = await readModuleCatalogue(bundledCatalogueUrl, reader, true, "hosted");
+export async function resolveModulePackageSpecifiers(configuredPackages, bundledCatalogueUrl = defaultCatalogueUrl, reader = (path) => readFile(path, "utf8"), selectedCataloguePath, runtimeProfile = "hosted") {
+    const bundledPackages = runtimeProfile === "hosted"
+        ? await readModuleCatalogue(bundledCatalogueUrl, reader, true, "hosted")
+        : [];
     const selectedPackages = selectedCataloguePath
         ? await readModuleCatalogue(resolve(selectedCataloguePath), reader, false, "selected")
         : [];

package/dist/module-logging.d.ts

@@ -1,13 +1,18 @@
-import { type DatabasePool } from "@helyx/database";
+import { InstallationRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, type DatabasePool } from "@helyx/database";
+import type { InstallationRepository as MysqlInstallationRepository, ModuleConfigurationRepository as MysqlModuleConfigurationRepository, ModuleLoggingPolicyRepository as MysqlModuleLoggingPolicyRepository } from "@helyx/database-mysql";
 import type { ModuleDefinition, ModuleLogDetail, ModuleLoggingService } from "@helyx/sdk";
 import type { Client } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
+export interface ModuleLoggingRepositories {
+    installations: Pick<InstallationRepository, "isModuleEnabled"> & Pick<MysqlInstallationRepository, "isModuleEnabled">;
+    configuration: Pick<ModuleConfigurationRepository, "get"> & Pick<MysqlModuleConfigurationRepository, "get">;
+    policies: Pick<ModuleLoggingPolicyRepository, "get"> & Pick<MysqlModuleLoggingPolicyRepository, "get">;
+}
 export declare class DiscordModuleLoggingService implements ModuleLoggingService {
     #private;
     private readonly client;
-    private readonly database;
     private readonly logger;
-    constructor(client: Client, database: DatabasePool, modules: readonly ModuleDefinition[], logger: InteractionLogger);
+    constructor(client: Client, databaseOrRepositories: DatabasePool | ModuleLoggingRepositories, modules: readonly ModuleDefinition[], logger: InteractionLogger);
     emit(input: {
         guildId: string;
         moduleId: string;

package/dist/module-logging.js

@@ -6,14 +6,21 @@ const LOGGING_MODULE_ID = "helyx.logging";
 const VIOLET = 0x7c3aed;
 export class DiscordModuleLoggingService {
     client;
-    database;
     logger;
     #modules;
     #loggingInstalled;
-    constructor(client, database, modules, logger) {
+    #repositories;
+    constructor(client, databaseOrRepositories, modules, logger) {
         this.client = client;
-        this.database = database;
         this.logger = logger;
+        this.#repositories =
+            "installations" in databaseOrRepositories
+                ? databaseOrRepositories
+                : {
+                    installations: new InstallationRepository(databaseOrRepositories),
+                    configuration: new ModuleConfigurationRepository(databaseOrRepositories),
+                    policies: new ModuleLoggingPolicyRepository(databaseOrRepositories),
+                };
         this.#modules = new Map(modules.map((module) => [module.manifest.id, module]));
         this.#loggingInstalled = this.#modules.has(LOGGING_MODULE_ID);
     }
@@ -26,13 +33,12 @@ export class DiscordModuleLoggingService {
             if (!source || !event) {
                 throw new Error("Module emitted an undeclared logging event");
             }
-            const installations = new InstallationRepository(this.database);
-            if (!(await installations.isModuleEnabled(input.guildId, LOGGING_MODULE_ID))) {
+            if (!(await this.#repositories.installations.isModuleEnabled(input.guildId, LOGGING_MODULE_ID))) {
                 return { delivered: false, retryable: false };
             }
             const [configuration, policy] = await Promise.all([
-                new ModuleConfigurationRepository(this.database).get(input.guildId, LOGGING_MODULE_ID),
-                new ModuleLoggingPolicyRepository(this.database).get(input.guildId, input.moduleId, input.eventId),
+                this.#repositories.configuration.get(input.guildId, LOGGING_MODULE_ID),
+                this.#repositories.policies.get(input.guildId, input.moduleId, input.eventId),
             ]);
             if (!(policy?.enabled ?? event.defaultEnabled)) {
                 return { delivered: false, retryable: false };