@helyx/bot 0.3.1 → 0.4.1

package/dist/shard-worker.d.ts

@@ -0,0 +1,62 @@
+import { type CommandRegistration } from "./interactions.js";
+import { type ShardIdentity } from "./shard-contracts.js";
+import { type BotHandle } from "./index.js";
+export declare const WORKER_ORPHAN_TERMINATION_BOUND_MS: number;
+export declare function createLeaseHeartbeatWatchdog(onExpired: () => void, timeoutMs?: number): {
+    heartbeat(): void;
+    stop(): void;
+};
+export declare function startShardWorker(processEnvironment?: NodeJS.ProcessEnv, identity?: {
+    version: 1;
+    mode: "auto" | "fixed";
+    scope: "local" | "coordinated";
+    generation: string;
+    supervisorId: string;
+    shardId: number;
+    shardCount: number;
+    fencingToken: number;
+    deploymentOrder?: number | undefined;
+}): Promise<BotHandle>;
+export declare function parseShardWorkerLaunchContract(value: string | undefined): ShardIdentity;
+export declare function parseShardWorkerEnvironment(processEnvironment: NodeJS.ProcessEnv, identity: ShardIdentity): {
+    HELYX_SHARD_WORKERS_PER_REPLICA: number;
+    HELYX_SHARD_SUPERVISOR_DATABASE_POOL_MAX: number | undefined;
+    HELYX_SHARD_WORKER_DATABASE_POOL_MAX: number | undefined;
+    DATABASE_URL: string;
+    DATABASE_SSL: "disable" | "require" | "verify-full";
+    DISCORD_TOKEN: string;
+    DISCORD_CLIENT_ID: string;
+    DISCORD_INTERNAL_GUILD_ID: string | undefined;
+    APPROVED_ROLES: string[];
+    HELYX_MODULE_PACKAGES: string[];
+    HELYX_MODULE_CATALOGUE_PATH: string | undefined;
+    HELYX_BOT_CONTROL_PORT: number;
+    HELYX_PRIVACY_ENABLED: boolean;
+    HELYX_CLOUD_CONNECT_ENABLED: boolean;
+    HELYX_CLOUD_ENROLMENT_TOKEN: string | undefined;
+    HELYX_CLOUD_ENROLMENT_FILE: string;
+    HELYX_CLOUD_API_URL: string;
+    HELYX_CLOUD_ENDPOINT: string;
+    HELYX_OWNER_USER_IDS: string[];
+    HELYX_SHARD_MODE: "off" | "auto" | "fixed";
+    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_BOT_CONTROL_SECRET?: string | undefined;
+    HELYX_PRIVACY_EXECUTOR_DATABASE_URL?: string | undefined;
+    HELYX_PRIVACY_EXECUTOR_DATABASE_SSL?: "disable" | "require" | "verify-full" | undefined;
+    HELYX_DATA_ENCRYPTION_KEY?: string | undefined;
+    HELYX_SHARD_COUNT?: number | undefined;
+    HELYX_SHARD_REDIS_URL?: string | undefined;
+    HELYX_SHARD_REDIS_NAMESPACE?: string | undefined;
+    HELYX_SHARD_GENERATION?: string | undefined;
+    HELYX_SHARD_DATABASE_CONNECTION_BUDGET?: number | undefined;
+};
+export declare function shardWorkerCommandRegistration(input: {
+    internalGuildId?: string;
+    prepare: NonNullable<CommandRegistration["prepare"]>;
+    operationsModuleId?: string;
+}): CommandRegistration;
+//# sourceMappingURL=shard-worker.d.ts.map

package/dist/shard-worker.js

@@ -0,0 +1,380 @@
+import { parseBotEnvironment } from "@helyx/config";
+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 { Client, Events, Partials } from "discord.js";
+import { monitorEventLoopDelay } from "node:perf_hooks";
+import pino from "pino";
+import { createCloudManagementModule } from "./cloud-management-module.js";
+import { BotControlService, DiscordGuildResourceDirectory, mapBotControlError, } from "./control-server.js";
+import { installModuleEvents } from "./events.js";
+import { installGuildTracking } from "./guilds.js";
+import { installInteractions, } from "./interactions.js";
+import { createManagementModule } from "./management-module.js";
+import { DiscordModuleLoggingService } from "./module-logging.js";
+import { resolveModulePackageSpecifiers } from "./module-configuration.js";
+import { loadConfiguredModulePackages } from "./modules.js";
+import { createPermissionsModule } from "./permissions-module.js";
+import { WorkerCloudConnectorProxy } from "./shard-cloud-proxy.js";
+import { createDeveloperOperationsModule, WorkerShardHealthProvider, } from "./developer-operations-module.js";
+import { assertShardMessageSize, controlOperationGuildId, executeShardControlOperation, guildIdToShardId, SHARD_LEASE_HEARTBEAT_TIMEOUT_MS, shardIdentitySchema, supervisorMessageSchema, } from "./shard-contracts.js";
+import { gatewayIntentsForModules, readBotVersion, } from "./index.js";
+const HEALTH_INTERVAL_MS = 5_000;
+export const WORKER_ORPHAN_TERMINATION_BOUND_MS = SHARD_LEASE_HEARTBEAT_TIMEOUT_MS + 5_000;
+export function createLeaseHeartbeatWatchdog(onExpired, timeoutMs = SHARD_LEASE_HEARTBEAT_TIMEOUT_MS) {
+    let timer;
+    const heartbeat = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(onExpired, timeoutMs);
+        timer.unref();
+    };
+    return {
+        heartbeat,
+        stop: () => {
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}
+export async function startShardWorker(processEnvironment = process.env, identity = parseShardWorkerLaunchContract(processEnvironment.HELYX_SHARD_WORKER_CONTRACT)) {
+    const environment = parseShardWorkerEnvironment(processEnvironment, identity);
+    const logger = pino({
+        level: environment.LOG_LEVEL,
+        base: {
+            component: "bot-worker",
+            shardId: identity.shardId,
+            shardCount: identity.shardCount,
+            supervisorId: identity.supervisorId,
+            generation: identity.generation,
+        },
+    });
+    const database = createDatabasePool({
+        connectionString: environment.DATABASE_URL,
+        sslMode: environment.DATABASE_SSL,
+        applicationName: `helyx-bot-shard-${String(identity.shardId)}`,
+        ...(environment.HELYX_SHARD_WORKER_DATABASE_POOL_MAX === undefined
+            ? {}
+            : { maxConnections: environment.HELYX_SHARD_WORKER_DATABASE_POOL_MAX }),
+    });
+    const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
+    eventLoopDelay.enable();
+    let status = "starting";
+    let healthTimer;
+    let shuttingDown = false;
+    let runtimeStarted = false;
+    let moduleEvents;
+    let client;
+    let cloudProxy;
+    let shardHealthProvider;
+    let leaseHeartbeatWatchdog;
+    let forcedLeaseExit;
+    async function shutdown(reason = "programmatic") {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        status = "stopped";
+        if (healthTimer)
+            clearInterval(healthTimer);
+        leaseHeartbeatWatchdog?.stop();
+        if (forcedLeaseExit)
+            clearTimeout(forcedLeaseExit);
+        sendHealth(identity, health(identity, client, status, eventLoopDelay.mean, moduleEvents?.queueDepth() ?? 0));
+        await cloudProxy?.stop().catch(() => undefined);
+        shardHealthProvider?.stop();
+        await moduleEvents?.stop().catch(() => undefined);
+        if (runtimeStarted)
+            await runtime?.stop().catch(() => undefined);
+        await client?.destroy();
+        eventLoopDelay.disable();
+        await database.end();
+        logger.info({ event: "shard.stopped", reason }, "Shard worker stopped");
+    }
+    let runtime;
+    try {
+        await checkDatabaseConnection(database);
+        const moduleSpecifiers = await resolveModulePackageSpecifiers(environment.HELYX_MODULE_PACKAGES, undefined, undefined, environment.HELYX_MODULE_CATALOGUE_PATH);
+        const modulePackages = await loadConfiguredModulePackages(moduleSpecifiers);
+        const featureModules = modulePackages.map(({ definition }) => definition);
+        client = new Client({
+            intents: gatewayIntentsForModules(featureModules),
+            partials: [Partials.Message, Partials.Channel, Partials.Reaction],
+            allowedMentions: { parse: [] },
+            shards: [identity.shardId],
+            shardCount: identity.shardCount,
+        });
+        const guildResources = new DiscordGuildResourceDirectory(client);
+        const permissionsModule = createPermissionsModule(featureModules);
+        const managementModule = createManagementModule(featureModules, guildResources);
+        cloudProxy = environment.HELYX_CLOUD_CONNECT_ENABLED
+            ? new WorkerCloudConnectorProxy()
+            : undefined;
+        const cloudManagementModule = cloudProxy
+            ? createCloudManagementModule({
+                connector: cloudProxy,
+                client,
+                configuredOwnerUserIds: environment.HELYX_OWNER_USER_IDS,
+                periodicOwnerRefresh: false,
+            })
+            : undefined;
+        const publicModules = [
+            managementModule,
+            permissionsModule,
+            ...(cloudManagementModule ? [cloudManagementModule] : []),
+            ...featureModules,
+        ];
+        shardHealthProvider = new WorkerShardHealthProvider();
+        const operationsModule = environment.DISCORD_INTERNAL_GUILD_ID
+            ? createDeveloperOperationsModule({
+                internalGuildId: environment.DISCORD_INTERNAL_GUILD_ID,
+                approvedRoleIds: environment.APPROVED_ROLES,
+                botVersion: readBotVersion(),
+                ...(processEnvironment.RAILWAY_GIT_COMMIT_SHA
+                    ? {
+                        deploymentReference: processEnvironment.RAILWAY_GIT_COMMIT_SHA.slice(0, 12),
+                    }
+                    : {}),
+                coreFunctions: [
+                    managementModule,
+                    permissionsModule,
+                    ...(cloudManagementModule ? [cloudManagementModule] : []),
+                ].map(({ manifest }) => manifest),
+                modules: featureModules.map(({ manifest }) => manifest),
+                processLabel: `shard worker ${identity.shardId}`,
+                health: shardHealthProvider,
+            })
+            : undefined;
+        const modules = [
+            ...publicModules,
+            ...(operationsModule ? [operationsModule] : []),
+        ];
+        const platformServices = new Map(createPlatformServices(database, publicModules));
+        if (featureModules.some(({ manifest }) => manifest.id === "helyx.logging"))
+            platformServices.set(HELYX_SERVICE_NAMES.moduleLogging, new DiscordModuleLoggingService(client, database, publicModules, logger));
+        const serviceAccess = new ServiceRegistry(platformServices);
+        runtime = createRuntime({ modules, logger, services: platformServices });
+        const enabledCoreModuleIds = new Set([
+            managementModule.manifest.id,
+            permissionsModule.manifest.id,
+            ...(cloudManagementModule ? [cloudManagementModule.manifest.id] : []),
+            ...(operationsModule ? [operationsModule.manifest.id] : []),
+        ]);
+        const prepareGuilds = installGuildTracking(client, database, publicModules, logger, enabledCoreModuleIds, {
+            generation: identity.generation,
+            deploymentOrder: BigInt(identity.deploymentOrder ?? 1),
+            supervisorId: identity.supervisorId,
+            shardId: identity.shardId,
+            fencingToken: BigInt(identity.fencingToken),
+        });
+        const commandsReady = installInteractions(client, modules, shardWorkerCommandRegistration({
+            ...(environment.DISCORD_INTERNAL_GUILD_ID
+                ? { internalGuildId: environment.DISCORD_INTERNAL_GUILD_ID }
+                : {}),
+            prepare: prepareGuilds,
+            ...(operationsModule
+                ? { operationsModuleId: operationsModule.manifest.id }
+                : {}),
+        }), logger, serviceAccess);
+        moduleEvents = installModuleEvents(client, publicModules, logger, serviceAccess);
+        const controlService = new BotControlService(database, publicModules, guildResources, serviceAccess);
+        process.on("message", (raw) => {
+            const parsed = supervisorMessageSchema.safeParse(raw);
+            if (!parsed.success)
+                return;
+            if (parsed.data.type === "helyx.control.request") {
+                void handleControl(identity, controlService, parsed.data);
+            }
+            else if (parsed.data.type === "helyx.lease.heartbeat") {
+                if (sameShardIdentity(parsed.data.identity, identity))
+                    leaseHeartbeatWatchdog?.heartbeat();
+            }
+            else if (parsed.data.type === "helyx.cloud.response") {
+                cloudProxy?.accept(parsed.data);
+            }
+            else if (parsed.data.type === "helyx.health.request") {
+                sendHealth(identity, health(identity, client, status, eventLoopDelay.mean, moduleEvents?.queueDepth() ?? 0));
+            }
+            else if (parsed.data.type === "helyx.operations.health.response") {
+                shardHealthProvider?.accept(parsed.data);
+            }
+            else if (parsed.data.type === "helyx.shutdown") {
+                void shutdown(parsed.data.reason).finally(() => {
+                    if (process.connected)
+                        process.disconnect?.();
+                });
+            }
+        });
+        if (identity.scope === "coordinated") {
+            leaseHeartbeatWatchdog = createLeaseHeartbeatWatchdog(() => {
+                logger.error({ event: "shard.supervisor_heartbeat_lost" }, "Supervisor liveness heartbeat was lost; stopping shard worker");
+                void shutdown("supervisor-heartbeat-lost").finally(() => {
+                    if (process.connected)
+                        process.disconnect?.();
+                });
+                forcedLeaseExit = setTimeout(() => process.exit(1), 5_000);
+                forcedLeaseExit.unref();
+            });
+            leaseHeartbeatWatchdog.heartbeat();
+        }
+        client.on(Events.ShardReady, () => {
+            status = "ready";
+            sendHealth(identity, health(identity, client, status, eventLoopDelay.mean, moduleEvents?.queueDepth() ?? 0));
+        });
+        client.on(Events.ShardDisconnect, () => {
+            status = "disconnected";
+            sendHealth(identity, health(identity, client, status, eventLoopDelay.mean, moduleEvents?.queueDepth() ?? 0));
+        });
+        client.on(Events.ShardReconnecting, () => {
+            status = "reconnecting";
+        });
+        client.on(Events.ShardResume, () => {
+            status = "ready";
+        });
+        client.on(Events.Error, (error) => {
+            logger.error({ event: "discord.error", error: safeError(error) }, "Discord shard error");
+        });
+        await cloudProxy?.start();
+        await runtime.start();
+        runtimeStarted = true;
+        await client.login(environment.DISCORD_TOKEN);
+        await commandsReady;
+        healthTimer = setInterval(() => sendHealth(identity, health(identity, client, status, eventLoopDelay.mean, moduleEvents?.queueDepth() ?? 0)), HEALTH_INTERVAL_MS);
+        healthTimer.unref();
+        process.once("SIGTERM", () => void shutdown("SIGTERM"));
+        process.once("SIGINT", () => void shutdown("SIGINT"));
+        return { shutdown };
+    }
+    catch (error) {
+        logger.error({ event: "shard.start_failed", error: safeError(error) }, "Shard worker failed to start");
+        await shutdown("startup-failed");
+        throw error;
+    }
+}
+function sameShardIdentity(left, right) {
+    return (left.generation === right.generation &&
+        left.deploymentOrder === right.deploymentOrder &&
+        left.supervisorId === right.supervisorId &&
+        left.shardId === right.shardId &&
+        left.shardCount === right.shardCount &&
+        left.fencingToken === right.fencingToken);
+}
+export function parseShardWorkerLaunchContract(value) {
+    if (!value)
+        throw new Error("Shard worker launch contract is missing");
+    try {
+        return shardIdentitySchema.parse(JSON.parse(value));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error("Shard worker launch contract is invalid JSON", {
+                cause: error,
+            });
+        throw error;
+    }
+}
+export function parseShardWorkerEnvironment(processEnvironment, identity) {
+    const cloudEnabled = processEnvironment.HELYX_CLOUD_CONNECT_ENABLED === "true";
+    const environment = parseBotEnvironment({
+        ...processEnvironment,
+        ...(cloudEnabled
+            ? {
+                HELYX_BOT_CONTROL_SECRET: Buffer.alloc(32).toString("base64"),
+                HELYX_DATA_ENCRYPTION_KEY: Buffer.alloc(32).toString("base64"),
+            }
+            : {}),
+        ...(identity.scope === "coordinated"
+            ? { HELYX_SHARD_REDIS_URL: "redis://worker-validation.invalid" }
+            : {}),
+    });
+    if (environment.HELYX_SHARD_MODE === "off" ||
+        environment.HELYX_SHARD_MODE !== identity.mode ||
+        environment.HELYX_SHARD_SCOPE !== identity.scope)
+        throw new Error("Shard worker launch contract conflicts with configuration");
+    return environment;
+}
+export function shardWorkerCommandRegistration(input) {
+    return {
+        ...(input.internalGuildId
+            ? { internalGuildId: input.internalGuildId }
+            : {}),
+        prepare: input.prepare,
+        synchronise: false,
+        ...(input.operationsModuleId
+            ? {
+                selfAuthorizingGuildModuleIds: new Set([input.operationsModuleId]),
+            }
+            : {}),
+    };
+}
+async function handleControl(identity, service, request) {
+    let response;
+    const guildId = controlOperationGuildId(request.operation);
+    if (request.generation !== identity.generation ||
+        request.fencingToken !== identity.fencingToken ||
+        !guildId ||
+        guildIdToShardId(guildId, identity.shardCount) !== identity.shardId ||
+        new Date(request.deadlineAt).getTime() <= Date.now()) {
+        response = {
+            version: 1,
+            type: "helyx.control.response",
+            requestId: request.requestId,
+            ok: false,
+            status: 503,
+            message: "Shard ownership changed or the request expired",
+        };
+    }
+    else {
+        try {
+            response = {
+                version: 1,
+                type: "helyx.control.response",
+                requestId: request.requestId,
+                ok: true,
+                result: await executeShardControlOperation(service, request.operation),
+            };
+        }
+        catch (error) {
+            const mapped = mapBotControlError(error);
+            response = {
+                version: 1,
+                type: "helyx.control.response",
+                requestId: request.requestId,
+                ok: false,
+                status: mapped?.status ?? 500,
+                message: mapped?.message ?? "The owning shard rejected the request",
+            };
+        }
+    }
+    assertShardMessageSize(response);
+    process.send?.(response);
+}
+function health(identity, client, status, eventLoopDelayNanoseconds, queueDepth) {
+    return {
+        shardId: identity.shardId,
+        status,
+        guildCount: client?.guilds.cache.size ?? 0,
+        gatewayPingMs: client?.ws.ping ?? -1,
+        uptimeSeconds: process.uptime(),
+        restartCount: Number(process.env.HELYX_SHARD_RESTART_COUNT ?? "0"),
+        eventLoopDelayMs: Number.isFinite(eventLoopDelayNanoseconds)
+            ? eventLoopDelayNanoseconds / 1_000_000
+            : 0,
+        memoryRssBytes: process.memoryUsage().rss,
+        queueDepth,
+        observedAt: new Date().toISOString(),
+    };
+}
+function sendHealth(identity, workerHealth) {
+    const message = {
+        version: 1,
+        type: "helyx.health.update",
+        identity,
+        health: workerHealth,
+    };
+    assertShardMessageSize(message);
+    process.send?.(message);
+}
+//# sourceMappingURL=shard-worker.js.map

package/dist/supervisor-cloud-directory.d.ts

@@ -0,0 +1,11 @@
+import type { DatabasePool } from "@helyx/database";
+import type { CloudDiscordDirectory, CloudDiscordSnapshot } from "./cloud-connector.js";
+export declare const CLOUD_HELLO_GUILD_LIMIT = 10000;
+export declare class SupervisorCloudDiscordDirectory implements CloudDiscordDirectory {
+    #private;
+    private readonly database;
+    private readonly configuredOwnerUserIds;
+    constructor(token: string, database: DatabasePool, configuredOwnerUserIds: readonly string[]);
+    snapshot(): Promise<CloudDiscordSnapshot>;
+}
+//# sourceMappingURL=supervisor-cloud-directory.d.ts.map

package/dist/supervisor-cloud-directory.js

@@ -0,0 +1,66 @@
+import { CONNECTOR_HELLO_MAX_GUILDS } from "@helyx/control-protocol";
+import { REST, Routes } from "discord.js";
+import { z } from "zod";
+const snowflake = z.string().regex(/^\d{17,20}$/u);
+export const CLOUD_HELLO_GUILD_LIMIT = CONNECTOR_HELLO_MAX_GUILDS;
+const applicationSchema = z
+    .object({
+    id: snowflake,
+    owner: z
+        .union([
+        z.object({ id: snowflake }).passthrough(),
+        z
+            .object({
+            members: z
+                .array(z.object({ user: z.object({ id: snowflake }) }))
+                .optional(),
+        })
+            .passthrough(),
+    ])
+        .nullable()
+        .optional(),
+})
+    .passthrough();
+const userSchema = z
+    .object({ id: snowflake, username: z.string().min(1).max(100) })
+    .passthrough();
+export class SupervisorCloudDiscordDirectory {
+    database;
+    configuredOwnerUserIds;
+    #rest;
+    constructor(token, database, configuredOwnerUserIds) {
+        this.database = database;
+        this.configuredOwnerUserIds = configuredOwnerUserIds;
+        this.#rest = new REST({ version: "10" }).setToken(token);
+    }
+    async snapshot() {
+        const [applicationValue, botValue, guildResult] = await Promise.all([
+            this.#rest.get(Routes.oauth2CurrentApplication()),
+            this.#rest.get(Routes.user("@me")),
+            this.database.query(`SELECT guild_id, name, owner_user_id
+           FROM discord_guilds
+          WHERE active = true
+          ORDER BY guild_id
+           LIMIT ${String(CLOUD_HELLO_GUILD_LIMIT)}`),
+        ]);
+        const application = applicationSchema.parse(applicationValue);
+        const bot = userSchema.parse(botValue);
+        const applicationOwnerIds = application.owner && "id" in application.owner
+            ? [snowflake.parse(application.owner.id)]
+            : (application.owner?.members?.map((member) => snowflake.parse(member.user.id)) ?? []);
+        return {
+            applicationId: application.id,
+            botUserId: bot.id,
+            botUsername: bot.username,
+            ownerUserIds: [
+                ...new Set([...this.configuredOwnerUserIds, ...applicationOwnerIds]),
+            ],
+            guilds: guildResult.rows.map((guild) => ({
+                guildId: guild.guild_id,
+                name: guild.name ?? "Unknown server",
+                ownerUserId: guild.owner_user_id,
+            })),
+        };
+    }
+}
+//# sourceMappingURL=supervisor-cloud-directory.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/bot",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Production Discord runtime for the modular Helyx platform.",
   "keywords": [
     "helyx",
@@ -48,17 +48,18 @@
     "start": "node --env-file-if-exists=../../.env dist/index.js"
   },
   "dependencies": {
-    "@helyx/config": "0.3.0",
-    "@helyx/control-protocol": "0.1.1",
-    "@helyx/core": "0.1.5",
-    "@helyx/database": "0.3.1",
-    "@helyx/framework": "0.1.5",
+    "@helyx/config": "0.4.1",
+    "@helyx/control-protocol": "0.1.2",
+    "@helyx/core": "0.1.7",
+    "@helyx/database": "0.4.0",
+    "@helyx/framework": "0.1.7",
     "@helyx/module-manifest": "0.4.0",
-    "@helyx/platform": "0.2.1",
-    "@helyx/sdk": "0.3.0",
+    "@helyx/platform": "0.2.3",
+    "@helyx/sdk": "0.3.2",
     "discord.js": "14.27.0",
     "fastify": "5.10.0",
     "pino": "10.3.1",
+    "redis": "6.1.0",
     "ws": "8.21.1",
     "zod": "4.4.3"
   },