bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/server/tcp.js

@@ -1,282 +1,96 @@
-/**
- * TCP Server
- * Handles TCP connections with msgpack binary protocol
- * Supports pipelining with parallel command processing
- */
-import { handleCommand } from './handler';
-import { FrameParser, FrameSizeError, createConnectionState, } from './protocol';
-import { uuid } from '../../shared/hash';
 import { tcpLog } from '../../shared/logger';
+import { decodeMessagePack } from '../../shared/msgpack';
+import { withSemaphore } from '../../shared/semaphore';
+import { handleCommand } from './handler';
+import { FrameSizeError } from './protocol';
 import { getRateLimiter } from './rateLimiter';
-import { Semaphore, withSemaphore } from '../../shared/semaphore';
-import { SocketWriteQueue } from './socketWriteQueue';
+import { TcpConnectionRegistry } from './tcp/connections';
+import { MAX_WRITE_QUEUE_BYTES, TCP_IDLE_TIMEOUT_MS } from './tcp/constants';
+import { handleEventSubscription } from './tcp/eventSubscriptions';
+import { serializeTcpResponse, tcpErrorResponse } from './tcp/responses';
 import { loadTlsOptions } from './tls';
-import { decodeMessagePack, encodeMessagePack } from '../../shared/msgpack';
-/** Max concurrent commands per connection for pipelining */
-const MAX_CONCURRENT_PER_CONNECTION = 50;
-/**
- * Idle/read stall timeout (ms) for the slowloris mitigation. A connection that
- * has STARTED a frame (partial bytes buffered) but makes no further progress
- * toward completing it within this window is closed. Healthy connections that
- * are simply idle (no partial frame buffered) are never affected, so long-lived
- * idle-but-healthy clients are not disturbed. 0 disables the timeout.
- *
- * Implemented with a manual per-connection timer (Bun.listen has no
- * `idleTimeout` socket option as of Bun 1.3.x, and `socket.timeout()` resets on
- * every byte — so a slowloris that trickles one byte per window would defeat
- * it). The manual timer is armed only while a partial frame is in progress.
- */
-const TCP_IDLE_TIMEOUT_MS = Math.max(0, parseInt(Bun.env.TCP_IDLE_TIMEOUT_MS ?? '60000', 10) || 0);
-/**
- * Maximum bytes that may be buffered in a connection's outbound write queue
- * before the connection is dropped. A client that stops reading while the
- * server keeps producing responses would otherwise grow the pending queue
- * without bound (write-side memory DoS). Generous default (64MB). 0 disables.
- */
-const MAX_WRITE_QUEUE_BYTES = Math.max(0, parseInt(Bun.env.TCP_MAX_WRITE_QUEUE_BYTES ?? String(64 * 1024 * 1024), 10) || 0);
-/**
- * Release client jobs with retry logic and exponential backoff.
- * Ensures jobs are not left in an inconsistent state if release fails.
- */
-async function releaseClientJobsWithRetry(queueManager, clientId, maxRetries = 3) {
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await queueManager.releaseClientJobs(clientId);
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err : new Error(String(err));
-            // Exponential backoff: 100ms, 200ms, 400ms
-            await Bun.sleep(100 * Math.pow(2, attempt));
-        }
-    }
-    tcpLog.error('Failed to release client jobs after retries', {
-        clientId,
-        error: lastError?.message,
-    });
-    throw lastError ?? new Error('Failed to release client jobs after retries');
-}
-/** Serialize response to framed msgpack */
-function serializeResponse(response) {
-    return FrameParser.frame(encodeMessagePack(response));
-}
-/** Error response as framed msgpack */
-function errorResponse(message, reqId) {
-    return FrameParser.frame(encodeMessagePack({ ok: false, error: message, reqId }));
-}
-/**
- * Create and start TCP server
- */
+/** Create and start the MessagePack TCP server. */
 export function createTcpServer(queueManager, config) {
     const authTokens = new Set(config.authTokens ?? []);
-    const connections = new Map();
-    const idleTimeoutMs = config.idleTimeoutMs ?? TCP_IDLE_TIMEOUT_MS;
-    const maxWriteQueueBytes = config.maxWriteQueueBytes ?? MAX_WRITE_QUEUE_BYTES;
-    /** Cancel any pending stall timer for a connection. */
-    function clearStallTimer(socket) {
-        if (socket.data.stallTimer !== null) {
-            clearTimeout(socket.data.stallTimer);
-            socket.data.stallTimer = null;
-        }
-    }
-    /**
-     * (Re)arm the slowloris stall timer based on parser state. The timer runs
-     * ONLY while a partial frame is buffered (a frame was started but not yet
-     * completed). It is reset on every data event that still leaves a partial
-     * frame, and cleared once the buffer drains to empty (frame completed). If it
-     * fires, the peer started a frame and then stalled -> terminate.
-     */
-    function updateStallTimer(socket) {
-        if (idleTimeoutMs <= 0)
-            return;
-        clearStallTimer(socket);
-        if (!socket.data.frameParser.hasPartialFrame)
-            return;
-        socket.data.stallTimer = setTimeout(() => {
-            socket.data.stallTimer = null;
-            tcpLog.warn('Closing stalled connection (incomplete frame)', {
-                clientId: socket.data.state.clientId,
-                bufferedBytes: socket.data.frameParser.bufferedBytes,
-                idleTimeoutMs,
-            });
-            socket.data.writeQueue.clear();
-            socket.terminate();
-        }, idleTimeoutMs);
-    }
-    /**
-     * Initialise the per-socket state. Idempotent: safe to call from both `open`
-     * and lazily from `data`. Under native TLS, Bun can deliver a `data` event
-     * BEFORE `open` has run (observed near-deterministically when a Worker boots
-     * its connections concurrently) — the handler would then destructure a null
-     * `socket.data` and the resulting TypeError escalates to the process-level
-     * unhandledRejection handler, taking the whole server down (a pre-auth remote
-     * DoS on an exposed TLS port). Initialising lazily preserves that first frame
-     * instead of dropping it; the guard makes a second `open` a no-op. See #108.
-     */
-    function initConnection(socket) {
-        if (socket.data)
-            return;
-        const clientId = uuid();
-        const state = createConnectionState(clientId);
-        const abortController = new AbortController();
-        const ctx = {
-            queueManager,
-            authTokens,
-            authenticated: authTokens.size === 0, // Auto-auth if no tokens
-            clientId, // For job ownership tracking
-            signal: abortController.signal,
-        };
-        socket.data = {
-            state,
-            abortController,
-            frameParser: new FrameParser(),
-            ctx,
-            semaphore: new Semaphore(MAX_CONCURRENT_PER_CONNECTION),
-            writeQueue: new SocketWriteQueue(maxWriteQueueBytes),
-            stallTimer: null,
-        };
-        connections.set(clientId, socket);
-        queueManager.emitDashboardEvent('client:connected', { clientId, transport: 'tcp' });
-    }
+    const registry = new TcpConnectionRegistry(queueManager, authTokens, config.idleTimeoutMs ?? TCP_IDLE_TIMEOUT_MS, config.maxWriteQueueBytes ?? MAX_WRITE_QUEUE_BYTES);
     const socketHandlers = {
         open(socket) {
-            initConnection(socket);
+            registry.init(socket);
         },
         async data(socket, data) {
-            // TLS may deliver `data` before `open` — ensure per-socket state exists. #108
-            initConnection(socket);
+            registry.init(socket);
             const { frameParser, ctx, state, semaphore, writeQueue } = socket.data;
             const rateLimiter = getRateLimiter();
             let frames;
             try {
-                // `data` is a Bun Buffer (a Uint8Array). addData copies it into its own
-                // buffer synchronously and never retains it, so the previous defensive
-                // `new Uint8Array(data)` wrapper was a redundant full copy per read.
                 frames = frameParser.addData(data);
             }
-            catch (err) {
-                if (err instanceof FrameSizeError) {
-                    clearStallTimer(socket);
-                    writeQueue.write(socket, errorResponse(`Frame too large: ${err.requestedSize} bytes exceeds maximum ${err.maxSize}`));
+            catch (error) {
+                if (error instanceof FrameSizeError) {
+                    registry.clearStallTimer(socket);
+                    writeQueue.write(socket, tcpErrorResponse(`Frame too large: ${error.requestedSize} bytes exceeds maximum ${error.maxSize}`));
                     socket.end();
                     return;
                 }
-                throw err;
+                throw error;
             }
-            // Slowloris mitigation: (re)arm the stall timer based on whether a partial
-            // frame is now buffered. Progress (a completed frame draining the buffer)
-            // disarms it; a started-but-unfinished frame arms it. This bounds memory
-            // held by a peer that declares a large (legal) frame then never finishes.
-            updateStallTimer(socket);
-            // Drop a connection whose outbound queue grew unbounded (client stopped
-            // reading while we keep producing responses) — bounds write-side memory.
-            const dropForWriteOverflow = () => {
-                if (writeQueue.isOverBudget) {
-                    tcpLog.warn('Closing connection: write queue exceeded budget', {
-                        clientId: state.clientId,
-                        queuedBytes: writeQueue.bytesQueued,
-                    });
-                    clearStallTimer(socket);
-                    writeQueue.clear();
-                    socket.terminate();
-                    return true;
-                }
-                return false;
-            };
-            // Process frames in parallel for pipelining support
-            // Each command is processed with semaphore-controlled concurrency
+            registry.updateStallTimer(socket);
             const processFrame = async (frame) => {
-                let cmd;
+                let command;
                 try {
-                    cmd = decodeMessagePack(frame);
+                    command = decodeMessagePack(frame);
                 }
                 catch {
-                    // Invalid complete frames still consume protocol quota. They cannot
-                    // carry a trustworthy reqId because msgpack decoding failed.
+                    // Invalid frames still consume protocol quota.
                 }
-                const reqId = typeof cmd?.reqId === 'string' ? cmd.reqId : undefined;
+                const requestId = typeof command?.reqId === 'string' ? command.reqId : undefined;
                 if (!rateLimiter.isAllowed(state.clientId)) {
                     ctx.queueManager.emitDashboardEvent('ratelimit:hit', { clientId: state.clientId });
-                    writeQueue.write(socket, errorResponse('Rate limit exceeded', reqId));
-                    dropForWriteOverflow();
+                    writeQueue.write(socket, tcpErrorResponse('Rate limit exceeded', requestId));
+                    registry.dropForWriteOverflow(socket);
                     return;
                 }
-                if (!cmd) {
-                    writeQueue.write(socket, errorResponse('Invalid command format'));
-                    dropForWriteOverflow();
+                if (!command) {
+                    writeQueue.write(socket, tcpErrorResponse('Invalid command format'));
+                    registry.dropForWriteOverflow(socket);
                     return;
                 }
-                if (!cmd?.cmd) {
-                    writeQueue.write(socket, errorResponse('Invalid command', reqId));
-                    dropForWriteOverflow();
+                if (!command.cmd) {
+                    writeQueue.write(socket, tcpErrorResponse('Invalid command', requestId));
+                    registry.dropForWriteOverflow(socket);
                     return;
                 }
-                // Process with concurrency limit
                 await withSemaphore(semaphore, async () => {
                     try {
-                        const response = await handleCommand(cmd, ctx);
-                        writeQueue.write(socket, serializeResponse(response));
-                        dropForWriteOverflow();
+                        const response = command.cmd === 'SubscribeEvents' || command.cmd === 'UnsubscribeEvents'
+                            ? handleEventSubscription(command, socket, registry)
+                            : await handleCommand(command, ctx);
+                        writeQueue.write(socket, serializeTcpResponse(response));
+                        registry.dropForWriteOverflow(socket);
                     }
-                    catch (err) {
-                        const raw = err instanceof Error ? err.message : 'Unknown error';
+                    catch (error) {
+                        const raw = error instanceof Error ? error.message : 'Unknown error';
                         const message = raw.includes('SQLITE') || raw.includes('database') ? 'Internal server error' : raw;
-                        writeQueue.write(socket, errorResponse(message, cmd.reqId));
-                        dropForWriteOverflow();
+                        writeQueue.write(socket, tcpErrorResponse(message, command.reqId));
+                        registry.dropForWriteOverflow(socket);
                     }
                 });
             };
-            // Process all frames in parallel (client uses reqId to match responses)
             await Promise.all(frames.map(processFrame));
         },
         close(socket) {
-            // A socket can close before `open`/`data` ever initialised its state
-            // (e.g. TLS handshake aborted) — nothing to release. #108
-            if (!socket.data)
-                return;
-            socket.data.abortController.abort();
-            const clientId = socket.data.state.clientId;
-            // Cancel the slowloris stall timer and drop any buffered-but-unwritten
-            // bytes; the socket is gone.
-            clearStallTimer(socket);
-            socket.data.writeQueue.clear();
-            connections.delete(clientId);
-            getRateLimiter().removeClient(clientId);
-            queueManager.unregisterWorkersByClientId(clientId);
-            queueManager.emitDashboardEvent('client:disconnected', { clientId, transport: 'tcp' });
-            // Release all jobs owned by this client back to queue with retry logic
-            releaseClientJobsWithRetry(queueManager, clientId)
-                .then(() => {
-                // Jobs released successfully
-            })
-                .catch((err) => {
-                // After all retries failed, fall back to a force-release that
-                // unconditionally clears client tracking (prevents Map leak) and
-                // resets heartbeats so the stall detector recovers any orphaned
-                // 'active' jobs on its next tick.
-                const touched = queueManager.forceReleaseClientJobs(clientId);
-                tcpLog.error('Client jobs release failed; fell back to force-release', {
-                    clientId,
-                    error: String(err),
-                    forcedJobs: touched,
-                    note: 'Stall detector will recover orphaned active jobs on next tick',
-                });
-            });
+            registry.close(socket);
         },
         error(_socket, error) {
             tcpLog.error('Connection error', { error: error.message });
         },
         drain(socket) {
-            // Can fire before per-socket state is initialised under TLS. #108
             if (!socket.data)
                 return;
-            // Socket is ready for more writes after backpressure: flush any unwritten
-            // tail bytes buffered by short writes, preserving frame order.
-            socket.data.writeQueue.flush(socket);
+            if (!socket.data.writeQueue.flush(socket))
+                socket.terminate();
         },
     };
-    // Create TCP server (validate TLS files BEFORE binding the port, so a bad
-    // path doesn't leave a half-started listener behind)
     const tlsOptions = config.tls ? loadTlsOptions(config.tls) : undefined;
     const server = Bun.listen({
         hostname: config.hostname ?? '0.0.0.0',
@@ -286,40 +100,17 @@ export function createTcpServer(queueManager, config) {
     });
     return {
         server,
-        connections,
-        /**
-         * Raw Bun socket handlers. Exposed for tests that need to drive the socket
-         * lifecycle directly (e.g. a `data` event arriving before `open` under TLS,
-         * #108) — production code goes through Bun.listen above.
-         */
+        connections: registry.connections,
         _socketHandlers: socketHandlers,
-        /** Get connection count */
         getConnectionCount() {
-            return connections.size;
+            return registry.connections.size;
         },
-        /** Broadcast to all connections */
         broadcast(message) {
-            const frame = FrameParser.frame(encodeMessagePack(message));
-            for (const socket of connections.values()) {
-                // Each connection writes through its own backpressure-aware queue so a
-                // slow reader buffers (in order) instead of dropping frame tail bytes.
-                socket.data.writeQueue.write(socket, frame);
-                // Drop any reader that has fallen too far behind (write-side bound).
-                if (socket.data.writeQueue.isOverBudget) {
-                    clearStallTimer(socket);
-                    socket.data.writeQueue.clear();
-                    socket.terminate();
-                }
-            }
+            registry.broadcast(message);
         },
-        /** Stop the server */
         stop() {
-            server.stop();
-            for (const socket of connections.values()) {
-                clearStallTimer(socket);
-                socket.end();
-            }
-            connections.clear();
+            registry.closeAll();
+            server.stop(true);
         },
     };
 }

package/dist/infrastructure/server/types/protocol.d.ts

@@ -0,0 +1,4 @@
+export interface ConnectionState {
+    authenticated: boolean;
+    clientId: string;
+}

package/dist/infrastructure/server/types/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/server/types/sse.d.ts

@@ -0,0 +1,11 @@
+export interface SseClient {
+    id: string;
+    controller: ReadableStreamDefaultController;
+    queueFilter: string | null;
+}
+export interface BufferedSseEvent {
+    id: number;
+    event: string;
+    data: string;
+    queue: string;
+}

package/dist/infrastructure/server/types/sse.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/server/types/tcpServer.d.ts

@@ -0,0 +1,25 @@
+import type { FrameParser } from '../protocol';
+import type { ConnectionState } from './protocol';
+import type { HandlerContext } from '../types';
+import type { Semaphore } from '../../../shared/semaphore';
+import type { SocketWriteQueue } from '../socketWriteQueue';
+import type { TlsServerOptions } from '../tls';
+export interface TcpServerConfig {
+    port?: number;
+    hostname?: string;
+    authTokens?: string[];
+    idleTimeoutMs?: number;
+    maxWriteQueueBytes?: number;
+    tls?: TlsServerOptions;
+}
+export interface TcpConnectionData {
+    state: ConnectionState;
+    abortController: AbortController;
+    frameParser: FrameParser;
+    ctx: HandlerContext;
+    semaphore: Semaphore;
+    writeQueue: SocketWriteQueue;
+    stallTimer: ReturnType<typeof setTimeout> | null;
+    /** A dedicated event connection may own exactly one queue subscription. */
+    eventQueue: string | null;
+}

package/dist/infrastructure/server/types/tcpServer.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/server/types/ws.d.ts

@@ -0,0 +1,6 @@
+export interface WsData {
+    id: string;
+    authenticated: boolean;
+    queueFilter: string | null;
+    subscriptions: Set<string> | null;
+}

package/dist/infrastructure/server/types/ws.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/server/ws/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const textDecoder: TextDecoder;
+export declare const MAX_WS_CLIENTS = 1000;
+export declare const WS_BACKPRESSURE_BYTES: number;
+export declare const WS_EVENT_MAP: Record<string, string>;
+export declare const VALID_WS_PATTERNS: Set<string>;
+export declare function matchesWsSubscription(event: string, subscriptions: Set<string>): boolean;

package/dist/infrastructure/server/ws/constants.js

@@ -0,0 +1,130 @@
+export const textDecoder = new TextDecoder();
+export const MAX_WS_CLIENTS = 1000;
+export const WS_BACKPRESSURE_BYTES = 1024 * 1024;
+export const WS_EVENT_MAP = {
+    pushed: 'job:pushed',
+    pulled: 'job:active',
+    completed: 'job:completed',
+    failed: 'job:failed',
+    progress: 'job:progress',
+    stalled: 'job:stalled',
+    removed: 'job:removed',
+    delayed: 'job:delayed',
+    duplicated: 'job:duplicated',
+    retried: 'job:retried',
+    'waiting-children': 'job:waiting-children',
+    drained: 'queue:drained',
+};
+export const VALID_WS_PATTERNS = new Set([
+    '*',
+    'job:pushed',
+    'job:active',
+    'job:completed',
+    'job:failed',
+    'job:removed',
+    'job:promoted',
+    'job:progress',
+    'job:delayed',
+    'job:stalled',
+    'job:retried',
+    'job:discarded',
+    'job:priority-changed',
+    'job:data-updated',
+    'job:delay-changed',
+    'job:timeout',
+    'job:lock-expired',
+    'job:deduplicated',
+    'job:waiting-children',
+    'job:dependencies-resolved',
+    'job:moved-to-delayed',
+    'job:expired',
+    'job:*',
+    'queue:created',
+    'queue:removed',
+    'queue:paused',
+    'queue:resumed',
+    'queue:drained',
+    'queue:cleaned',
+    'queue:obliterated',
+    'queue:counts',
+    'queue:idle',
+    'queue:threshold',
+    'queue:*',
+    'dlq:added',
+    'dlq:retried',
+    'dlq:retry-all',
+    'dlq:purged',
+    'dlq:auto-retried',
+    'dlq:expired',
+    'dlq:*',
+    'flow:completed',
+    'flow:failed',
+    'flow:*',
+    'cron:created',
+    'cron:updated',
+    'cron:deleted',
+    'cron:fired',
+    'cron:missed',
+    'cron:skipped',
+    'cron:*',
+    'worker:connected',
+    'worker:disconnected',
+    'worker:heartbeat',
+    'worker:idle',
+    'worker:removed-stale',
+    'worker:overloaded',
+    'worker:error',
+    'worker:*',
+    'ratelimit:set',
+    'ratelimit:cleared',
+    'ratelimit:hit',
+    'ratelimit:rejected',
+    'concurrency:set',
+    'concurrency:cleared',
+    'concurrency:rejected',
+    'ratelimit:*',
+    'concurrency:*',
+    'webhook:added',
+    'webhook:removed',
+    'webhook:fired',
+    'webhook:failed',
+    'webhook:enabled',
+    'webhook:disabled',
+    'webhook:*',
+    'batch:pushed',
+    'batch:pulled',
+    'batch:*',
+    'client:connected',
+    'client:disconnected',
+    'client:*',
+    'auth:failed',
+    'auth:*',
+    'cleanup:orphans-removed',
+    'cleanup:stale-deps-removed',
+    'cleanup:*',
+    'health:status',
+    'health:*',
+    'stats:snapshot',
+    'stats:*',
+    'storage:status',
+    'storage:backup-started',
+    'storage:backup-completed',
+    'storage:backup-failed',
+    'storage:size-warning',
+    'storage:*',
+    'server:started',
+    'server:shutdown',
+    'server:recovered',
+    'server:memory-warning',
+    'server:*',
+    'memory:compacted',
+    'memory:*',
+    'config:stall-changed',
+    'config:dlq-changed',
+    'config:*',
+]);
+export function matchesWsSubscription(event, subscriptions) {
+    if (subscriptions.has('*') || subscriptions.has(event))
+        return true;
+    return subscriptions.has(`${event.split(':')[0]}:*`);
+}

package/dist/infrastructure/server/ws/snapshots.d.ts

@@ -0,0 +1,4 @@
+import type { QueueManager } from '../../../application/queueManager';
+export declare function buildStatsSnapshot(queueManager: QueueManager): Record<string, unknown>;
+export declare function buildHealthSnapshot(queueManager: QueueManager, connectionCount: number, connectionType?: 'ws' | 'sse'): Record<string, unknown>;
+export declare function buildStorageSnapshot(queueManager: QueueManager): Record<string, unknown>;

package/dist/infrastructure/server/ws/snapshots.js

@@ -0,0 +1,52 @@
+import { throughputTracker } from '../../../application/throughputTracker';
+export function buildStatsSnapshot(queueManager) {
+    const stats = queueManager.getStats();
+    const rates = throughputTracker.getRates();
+    const perQueue = queueManager.getPerQueueStats();
+    const workerStats = queueManager.workerManager.getStats();
+    const queues = {};
+    for (const [name, value] of perQueue) {
+        queues[name] = {
+            waiting: value.waiting ?? 0,
+            active: value.active ?? 0,
+            delayed: value.delayed ?? 0,
+            dlq: value.dlq ?? 0,
+            paused: queueManager.isPaused(name),
+        };
+    }
+    return {
+        waiting: stats.waiting,
+        active: stats.active,
+        delayed: stats.delayed,
+        completed: stats.completed,
+        dlq: stats.dlq,
+        totalPushed: Number(stats.totalPushed),
+        totalCompleted: Number(stats.totalCompleted),
+        totalFailed: Number(stats.totalFailed),
+        pushPerSec: rates.pushPerSec,
+        pullPerSec: rates.pullPerSec,
+        uptime: stats.uptime,
+        queues,
+        workers: { total: workerStats.total, active: workerStats.active },
+        cronJobs: queueManager.listCrons().length,
+    };
+}
+export function buildHealthSnapshot(queueManager, connectionCount, connectionType = 'ws') {
+    const memory = process.memoryUsage();
+    const storage = queueManager.getStorageStatus();
+    return {
+        ok: !storage.diskFull,
+        uptime: Math.floor(process.uptime()),
+        memory: {
+            rss: Math.round(memory.rss / 1024 / 1024),
+            heapUsed: Math.round(memory.heapUsed / 1024 / 1024),
+        },
+        connections: { [connectionType]: connectionCount },
+    };
+}
+export function buildStorageSnapshot(queueManager) {
+    return {
+        collections: queueManager.getMemoryStats(),
+        diskFull: queueManager.getStorageStatus().diskFull,
+    };
+}

package/dist/infrastructure/server/ws/subscriptions.d.ts

@@ -0,0 +1,10 @@
+import type { ServerWebSocket } from 'bun';
+import type { WsData } from '../types/ws';
+export declare function handleWsSubscribe(websocket: ServerWebSocket<WsData>, command: {
+    events?: string[];
+    reqId?: string;
+}): void;
+export declare function handleWsUnsubscribe(websocket: ServerWebSocket<WsData>, command: {
+    events?: string[];
+    reqId?: string;
+}): void;