bunqueue 2.8.9 → 2.8.11

package/dist/infrastructure/server/bootstrap.js

@@ -0,0 +1,217 @@
+/**
+ * Server bootstrap — the ONE place that boots a full bunqueue server.
+ * Used by both entry points (`bunqueue` bare via main.ts and
+ * `bunqueue start` via the CLI) so they cannot drift: S3 backup, cloud
+ * agent, stats interval, crash handlers and graceful shutdown are always on.
+ */
+import { QueueManager } from '../../application/queueManager';
+import { createTcpServer } from './tcp';
+import { createHttpServer } from './http';
+import { Logger, serverLog, statsLog } from '../../shared/logger';
+import { stopRateLimiter } from './rateLimiter';
+import { VERSION } from '../../shared/version';
+import { S3BackupManager } from '../backup';
+import { CloudAgent } from '../cloud';
+import { SHARD_COUNT } from '../../shared/hash';
+import { resolveCloudConfig, resolveBackupConfig, resolveTlsServerOptions, } from '../../config';
+/** Print startup banner */
+function printBanner(config, cloudUrl) {
+    const dim = '\x1b[2m';
+    const reset = '\x1b[0m';
+    const bold = '\x1b[1m';
+    const magenta = '\x1b[35m';
+    const green = '\x1b[32m';
+    const yellow = '\x1b[33m';
+    // Format TCP endpoint display
+    const tcpDisplay = config.tcpSocketPath
+        ? `${bold}${config.tcpSocketPath}${reset} ${dim}(unix)${reset}`
+        : `${bold}${config.hostname}:${config.tcpPort}${reset}`;
+    // Format HTTP endpoint display
+    const httpDisplay = config.httpSocketPath
+        ? `${bold}${config.httpSocketPath}${reset} ${dim}(unix)${reset}`
+        : `${bold}${config.hostname}:${config.httpPort}${reset}`;
+    // Socket mode display
+    const hasUnixSockets = config.tcpSocketPath !== undefined || config.httpSocketPath !== undefined;
+    const socketDisplay = hasUnixSockets
+        ? `${green}enabled${reset} ${dim}(${config.tcpSocketPath ? 'TCP' : ''}${config.tcpSocketPath && config.httpSocketPath ? '+' : ''}${config.httpSocketPath ? 'HTTP' : ''})${reset}`
+        : `${dim}disabled${reset}`;
+    console.log(`
+${magenta}        (\\(\\        ${reset}
+${magenta}        ( -.-)      ${bold}bunqueue${reset} ${dim}v${VERSION}${reset}
+${magenta}        o_(")(")    ${reset}${dim}High-performance job queue for Bun${reset}
+
+${dim}─────────────────────────────────────────────────${reset}
+
+  ${green}●${reset} TCP    ${tcpDisplay}
+  ${green}●${reset} HTTP   ${httpDisplay}
+  ${yellow}●${reset} Socket ${socketDisplay}
+  ${yellow}●${reset} Data   ${config.dataPath ?? 'in-memory'}
+  ${yellow}●${reset} TLS    ${config.tlsCertFile ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
+  ${yellow}●${reset} Auth   ${config.authTokens.length > 0 ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
+  ${yellow}●${reset} S3 Backup ${config.s3BackupEnabled ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
+  ${yellow}●${reset} Cloud  ${cloudUrl ? `${green}enabled${reset} ${dim}→ ${cloudUrl}${reset}` : `${dim}disabled${reset}`}
+  ${dim}●${reset} Shards ${bold}${SHARD_COUNT}${reset} ${dim}(${navigator.hardwareConcurrency} CPU cores)${reset}
+
+${dim}─────────────────────────────────────────────────${reset}
+
+`);
+}
+/** Boot the full server from resolved configuration. Runs until shutdown. */
+export function bootServer(fileConfig, config) {
+    // Apply logging config before anything else
+    const logFormat = fileConfig?.logging?.format ?? Bun.env.LOG_FORMAT;
+    const logLevel = fileConfig?.logging?.level ?? Bun.env.LOG_LEVEL?.toLowerCase();
+    if (logFormat === 'json')
+        Logger.enableJsonMode();
+    if (logLevel) {
+        const validLevels = ['debug', 'info', 'warn', 'error'];
+        if (validLevels.includes(logLevel))
+            Logger.setLevel(logLevel);
+    }
+    // Resolve cloud config
+    const cloudConfig = resolveCloudConfig(fileConfig, config.dataPath);
+    // Resolve TLS config — fail fast on partial cert/key before binding anything
+    let tlsConfig;
+    try {
+        tlsConfig = resolveTlsServerOptions(config);
+    }
+    catch (err) {
+        serverLog.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    printBanner(config, cloudConfig?.url);
+    // Create queue manager
+    const queueManager = new QueueManager({
+        dataPath: config.dataPath,
+    });
+    // Start TCP + HTTP servers; a bind failure must not leave a half-started process
+    let tcpServer;
+    let httpServer;
+    try {
+        tcpServer = createTcpServer(queueManager, {
+            port: config.tcpPort,
+            hostname: config.hostname,
+            authTokens: config.authTokens,
+            ...(tlsConfig && { tls: tlsConfig }),
+        });
+        httpServer = createHttpServer(queueManager, {
+            port: config.httpPort,
+            hostname: config.hostname,
+            socketPath: config.httpSocketPath,
+            authTokens: config.authTokens,
+            corsOrigins: config.corsOrigins,
+            requireAuthForMetrics: config.requireAuthForMetrics,
+            ...(tlsConfig && { tls: tlsConfig }),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`Failed to start server: ${msg}`);
+        queueManager.shutdown();
+        process.exit(1);
+    }
+    // Initialize S3 backup manager
+    let backupManager = null;
+    if (config.dataPath) {
+        const backupConfig = resolveBackupConfig(fileConfig, config.dataPath);
+        backupManager = new S3BackupManager(backupConfig);
+        backupManager.setDashboardEmit(queueManager.emitDashboardEvent.bind(queueManager));
+        backupManager.start();
+    }
+    // Initialize bunqueue Cloud agent (remote dashboard telemetry)
+    const cloudAgent = cloudConfig ? CloudAgent.createFromConfig(queueManager, cloudConfig) : null;
+    if (cloudAgent) {
+        cloudAgent.setServerHandles({
+            getConnectionCount: () => tcpServer.getConnectionCount(),
+            getWsClientCount: () => httpServer.getWsClientCount(),
+            getSseClientCount: () => httpServer.getSseClientCount(),
+            getBackupStatus: () => backupManager?.getStatus() ?? null,
+        });
+    }
+    queueManager.emitDashboardEvent('server:started', {
+        tcpPort: config.tcpPort,
+        httpPort: config.httpPort,
+        shards: SHARD_COUNT,
+    });
+    // Graceful shutdown
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        serverLog.info(`Received ${signal}, shutting down...`);
+        // Stop stats interval immediately
+        clearInterval(statsInterval);
+        tcpServer.stop();
+        httpServer.stop();
+        const shutdownTimeout = config.shutdownTimeoutMs;
+        const start = Date.now();
+        while (Date.now() - start < shutdownTimeout) {
+            const stats = queueManager.getStats();
+            if (stats.active === 0)
+                break;
+            serverLog.info(`Waiting for ${stats.active} active jobs...`);
+            await Bun.sleep(1000);
+        }
+        // Stop backup manager
+        if (backupManager) {
+            backupManager.stop();
+        }
+        // Stop Cloud agent (sends final shutdown snapshot)
+        if (cloudAgent) {
+            await cloudAgent.stop();
+        }
+        queueManager.emitDashboardEvent('server:shutdown', { signal });
+        queueManager.shutdown();
+        stopRateLimiter();
+        serverLog.info('Shutdown complete');
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.on('uncaughtException', (err) => {
+        serverLog.error('Uncaught exception - initiating shutdown', {
+            error: err.message,
+            stack: err.stack,
+        });
+        void shutdown('uncaughtException');
+    });
+    process.on('unhandledRejection', (reason) => {
+        serverLog.error('Unhandled promise rejection - initiating shutdown', {
+            reason: reason instanceof Error ? reason.message : String(reason),
+            stack: reason instanceof Error ? reason.stack : undefined,
+        });
+        void shutdown('unhandledRejection');
+    });
+    // Print stats periodically
+    const statsInterval = setInterval(() => {
+        const stats = queueManager.getStats();
+        const memStats = queueManager.getMemoryStats();
+        const workerStats = queueManager.workerManager.getStats();
+        const mem = process.memoryUsage();
+        const now = new Date();
+        const timestamp = now.toLocaleTimeString('en-GB', {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        statsLog.info('Queue statistics', {
+            time: timestamp,
+            waiting: stats.waiting,
+            active: stats.active,
+            delayed: stats.delayed,
+            completed: stats.completed,
+            dlq: stats.dlq,
+            tcp: tcpServer.getConnectionCount(),
+            ws: httpServer.getWsClientCount(),
+            sse: httpServer.getSseClientCount(),
+            workers: `${workerStats.active}/${workerStats.total}`,
+            mem: `${Math.round(mem.heapUsed / 1024 / 1024)}MB/${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
+            rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
+            // Internal collection sizes (for memory debugging)
+            idx: memStats.jobIndex,
+            locks: memStats.jobLocks,
+            clients: memStats.clientJobsTotal,
+        });
+    }, config.statsIntervalMs);
+}

package/dist/infrastructure/server/handlers/advanced.js

@@ -4,6 +4,7 @@
  */
 import * as resp from '../../../domain/types/response';
 import { jobId } from '../../../domain/types/job';
+import { validateNumericField } from '../protocol';
 /**
  * Coerce a value to a finite number, or return undefined if it can't be.
  * Guards config endpoints against non-numeric input (e.g. `"abc"`) that would
@@ -108,6 +109,13 @@ export async function handleDiscard(cmd, ctx, reqId) {
 /** Handle WaitJob command - wait for job completion (event-driven, no polling) */
 export async function handleWaitJob(cmd, ctx, reqId) {
     const jid = jobId(cmd.id);
+    // Bounded like PULL (which caps at 60s); waiting for completion is
+    // legitimately longer, so the cap here is 10 min. validateNumericField also
+    // rejects NaN/Infinity from hostile clients (a hand-rolled <0/>max check
+    // would let NaN through and resolve instantly as a false "not completed").
+    const timeoutError = validateNumericField(cmd.timeout, 'timeout', { min: 0, max: 600000 });
+    if (timeoutError)
+        return resp.error(timeoutError, reqId);
     const timeout = cmd.timeout ?? 30000;
     // First check if job exists and is already completed
     const job = await ctx.queueManager.getJob(jid);

package/dist/infrastructure/server/handlers/core.js

@@ -189,7 +189,13 @@ export async function handleAckBatch(cmd, ctx, reqId) {
 export async function handleFail(cmd, ctx, reqId) {
     try {
         const jid = jobId(cmd.id);
-        await ctx.queueManager.fail(jid, cmd.error, cmd.token, cmd.unrecoverable);
+        // #74: the wire is not type-safe — accept stack only as string[], cap at
+        // 100 elements before it reaches the domain (authoritative cap happens in
+        // failJob at job.stackTraceLimit).
+        const stack = Array.isArray(cmd.stack)
+            ? cmd.stack.filter((line) => typeof line === 'string').slice(0, 100)
+            : undefined;
+        await ctx.queueManager.fail(jid, cmd.error, cmd.token, cmd.unrecoverable, stack && stack.length > 0 ? stack : undefined);
         // Unregister job from client tracking
         ctx.queueManager.unregisterClientJob(ctx.clientId, jid);
         return resp.ok(undefined, reqId);

package/dist/infrastructure/server/handlers/monitoring.js

@@ -6,6 +6,7 @@ import { jobId } from '../../../domain/types/job';
 import { VERSION } from '../../../shared/version';
 import * as resp from '../../../domain/types/response';
 import { validateWebhookUrl } from '../protocol';
+import { WEBHOOK_EVENTS } from '../../../domain/types/webhook';
 // ============ Job Logs ============
 export function handleAddLog(cmd, ctx, reqId) {
     const jid = jobId(cmd.id);
@@ -140,6 +141,12 @@ export function handleAddWebhook(cmd, ctx, reqId) {
     const urlError = validateWebhookUrl(cmd.url);
     if (urlError)
         return resp.error(urlError, reqId);
+    // Reject events that are never triggered — a webhook subscribed to a dead
+    // event would be created "ok" and then never fire (silent failure).
+    const invalidEvents = cmd.events.filter((e) => !WEBHOOK_EVENTS.includes(e));
+    if (invalidEvents.length > 0) {
+        return resp.error(`Invalid webhook event(s): ${invalidEvents.join(', ')}. Valid: ${WEBHOOK_EVENTS.join(', ')}`, reqId);
+    }
     const webhook = ctx.queueManager.webhookManager.add(cmd.url, cmd.events, cmd.queue, cmd.secret);
     ctx.queueManager.emitDashboardEvent('webhook:added', {
         id: webhook.id,

package/dist/infrastructure/server/httpRouteJobs.js

@@ -271,6 +271,8 @@ export async function routeJobRoutes(req, path, method, ctx, cors) {
             error: body['error'],
             token: body['token'],
             unrecoverable: body['unrecoverable'],
+            // Validated (string[] only, capped) in handleFail (#74)
+            stack: body['stack'],
         }, ctx);
         return jsonResponse(r, r.ok ? 200 : 400, cors);
     }

package/dist/main.js

@@ -8,241 +8,29 @@
 // module; without this guard, the top-level dispatch would re-run the CLI/server
 // on every import and cause "Failed to listen at 0.0.0.0".
 if (import.meta.main) {
-    const clientCommands = [
-        'push',
-        'pull',
-        'ack',
-        'fail',
-        'job',
-        'queue',
-        'dlq',
-        'cron',
-        'worker',
-        'webhook',
-        'rate-limit',
-        'concurrency',
-        'stats',
-        'metrics',
-        'health',
-        'backup',
-    ];
     const firstArg = process.argv[2];
-    const isClientCommand = firstArg && clientCommands.includes(firstArg);
-    const isStartCommand = firstArg === 'start';
-    const hasHelpOrVersion = process.argv.includes('--help') || process.argv.includes('--version');
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- process.argv[2] can be undefined at runtime
-    const hasFlags = firstArg?.startsWith('-');
-    if (isClientCommand || hasHelpOrVersion || isStartCommand || hasFlags) {
-        void import('./cli/index').then(({ main }) => main());
+    // The server boots ONLY for a bare `bunqueue` invocation. `start` and
+    // flag-led argv go through the CLI, which detects server mode itself and
+    // boots the same full server (shared bootstrap). Every other first argument
+    // is a CLI command: known ones execute, unknown ones print
+    // "Unknown command: X" and exit 1 — a typo must never silently boot a server.
+    if (!firstArg) {
+        void startServer();
     }
     else {
-        void startServer();
+        void import('./cli/index').then(({ main }) => main());
     }
 }
-import { QueueManager } from './application/queueManager';
-import { createTcpServer } from './infrastructure/server/tcp';
-import { createHttpServer } from './infrastructure/server/http';
-import { Logger, serverLog, statsLog } from './shared/logger';
-import { stopRateLimiter } from './infrastructure/server/rateLimiter';
-import { VERSION } from './shared/version';
-import { S3BackupManager } from './infrastructure/backup';
-import { CloudAgent } from './infrastructure/cloud';
-import { SHARD_COUNT } from './shared/hash';
-import { loadConfigFile, resolveServerConfig, resolveCloudConfig, resolveBackupConfig, resolveTlsServerOptions, } from './config';
+import { Logger } from './shared/logger';
+import { loadConfigFile, resolveServerConfig } from './config';
+import { bootServer } from './infrastructure/server/bootstrap';
 export { defineConfig } from './config';
-/** Print startup banner */
-function printBanner(config, cloudUrl) {
-    const dim = '\x1b[2m';
-    const reset = '\x1b[0m';
-    const bold = '\x1b[1m';
-    const magenta = '\x1b[35m';
-    const green = '\x1b[32m';
-    const yellow = '\x1b[33m';
-    // Format TCP endpoint display
-    const tcpDisplay = config.tcpSocketPath
-        ? `${bold}${config.tcpSocketPath}${reset} ${dim}(unix)${reset}`
-        : `${bold}${config.hostname}:${config.tcpPort}${reset}`;
-    // Format HTTP endpoint display
-    const httpDisplay = config.httpSocketPath
-        ? `${bold}${config.httpSocketPath}${reset} ${dim}(unix)${reset}`
-        : `${bold}${config.hostname}:${config.httpPort}${reset}`;
-    // Socket mode display
-    const hasUnixSockets = config.tcpSocketPath !== undefined || config.httpSocketPath !== undefined;
-    const socketDisplay = hasUnixSockets
-        ? `${green}enabled${reset} ${dim}(${config.tcpSocketPath ? 'TCP' : ''}${config.tcpSocketPath && config.httpSocketPath ? '+' : ''}${config.httpSocketPath ? 'HTTP' : ''})${reset}`
-        : `${dim}disabled${reset}`;
-    console.log(`
-${magenta}        (\\(\\        ${reset}
-${magenta}        ( -.-)      ${bold}bunqueue${reset} ${dim}v${VERSION}${reset}
-${magenta}        o_(")(")    ${reset}${dim}High-performance job queue for Bun${reset}
-
-${dim}─────────────────────────────────────────────────${reset}
-
-  ${green}●${reset} TCP    ${tcpDisplay}
-  ${green}●${reset} HTTP   ${httpDisplay}
-  ${yellow}●${reset} Socket ${socketDisplay}
-  ${yellow}●${reset} Data   ${config.dataPath ?? 'in-memory'}
-  ${yellow}●${reset} TLS    ${config.tlsCertFile ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
-  ${yellow}●${reset} Auth   ${config.authTokens.length > 0 ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
-  ${yellow}●${reset} S3 Backup ${config.s3BackupEnabled ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
-  ${yellow}●${reset} Cloud  ${cloudUrl ? `${green}enabled${reset} ${dim}→ ${cloudUrl}${reset}` : `${dim}disabled${reset}`}
-  ${dim}●${reset} Shards ${bold}${SHARD_COUNT}${reset} ${dim}(${navigator.hardwareConcurrency} CPU cores)${reset}
-
-${dim}─────────────────────────────────────────────────${reset}
-
-`);
-}
 /** Start the server (direct mode) */
 async function startServer() {
     // Load config file (bunqueue.config.ts) if present, then merge with env vars
     const fileConfig = await loadConfigFile();
     const config = resolveServerConfig(fileConfig);
-    // Apply logging config before anything else
-    const logFormat = fileConfig?.logging?.format ?? Bun.env.LOG_FORMAT;
-    const logLevel = fileConfig?.logging?.level ?? Bun.env.LOG_LEVEL?.toLowerCase();
-    if (logFormat === 'json')
-        Logger.enableJsonMode();
-    if (logLevel) {
-        const validLevels = ['debug', 'info', 'warn', 'error'];
-        if (validLevels.includes(logLevel))
-            Logger.setLevel(logLevel);
-    }
-    // Resolve cloud config
-    const cloudConfig = resolveCloudConfig(fileConfig, config.dataPath);
-    // Resolve TLS config — fail fast on partial cert/key before binding anything
-    let tlsConfig;
-    try {
-        tlsConfig = resolveTlsServerOptions(config);
-    }
-    catch (err) {
-        serverLog.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    printBanner(config, cloudConfig?.url);
-    // Create queue manager
-    const queueManager = new QueueManager({
-        dataPath: config.dataPath,
-    });
-    // Start TCP server
-    const tcpServer = createTcpServer(queueManager, {
-        port: config.tcpPort,
-        hostname: config.hostname,
-        authTokens: config.authTokens,
-        ...(tlsConfig && { tls: tlsConfig }),
-    });
-    // Start HTTP server
-    const httpServer = createHttpServer(queueManager, {
-        port: config.httpPort,
-        hostname: config.hostname,
-        authTokens: config.authTokens,
-        corsOrigins: config.corsOrigins,
-        requireAuthForMetrics: config.requireAuthForMetrics,
-        ...(tlsConfig && { tls: tlsConfig }),
-    });
-    // Initialize S3 backup manager
-    let backupManager = null;
-    if (config.dataPath) {
-        const backupConfig = resolveBackupConfig(fileConfig, config.dataPath);
-        backupManager = new S3BackupManager(backupConfig);
-        backupManager.setDashboardEmit(queueManager.emitDashboardEvent.bind(queueManager));
-        backupManager.start();
-    }
-    // Initialize bunqueue Cloud agent (remote dashboard telemetry)
-    const cloudAgent = cloudConfig ? CloudAgent.createFromConfig(queueManager, cloudConfig) : null;
-    if (cloudAgent) {
-        cloudAgent.setServerHandles({
-            getConnectionCount: () => tcpServer.getConnectionCount(),
-            getWsClientCount: () => httpServer.getWsClientCount(),
-            getSseClientCount: () => httpServer.getSseClientCount(),
-            getBackupStatus: () => backupManager?.getStatus() ?? null,
-        });
-    }
-    queueManager.emitDashboardEvent('server:started', {
-        tcpPort: config.tcpPort,
-        httpPort: config.httpPort,
-        shards: SHARD_COUNT,
-    });
-    // Graceful shutdown
-    let shuttingDown = false;
-    const shutdown = async (signal) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        serverLog.info(`Received ${signal}, shutting down...`);
-        // Stop stats interval immediately
-        clearInterval(statsInterval);
-        tcpServer.stop();
-        httpServer.stop();
-        const shutdownTimeout = config.shutdownTimeoutMs;
-        const start = Date.now();
-        while (Date.now() - start < shutdownTimeout) {
-            const stats = queueManager.getStats();
-            if (stats.active === 0)
-                break;
-            serverLog.info(`Waiting for ${stats.active} active jobs...`);
-            await Bun.sleep(1000);
-        }
-        // Stop backup manager
-        if (backupManager) {
-            backupManager.stop();
-        }
-        // Stop Cloud agent (sends final shutdown snapshot)
-        if (cloudAgent) {
-            await cloudAgent.stop();
-        }
-        queueManager.emitDashboardEvent('server:shutdown', { signal });
-        queueManager.shutdown();
-        stopRateLimiter();
-        serverLog.info('Shutdown complete');
-        process.exit(0);
-    };
-    process.on('SIGINT', () => void shutdown('SIGINT'));
-    process.on('SIGTERM', () => void shutdown('SIGTERM'));
-    process.on('uncaughtException', (err) => {
-        serverLog.error('Uncaught exception - initiating shutdown', {
-            error: err.message,
-            stack: err.stack,
-        });
-        void shutdown('uncaughtException');
-    });
-    process.on('unhandledRejection', (reason) => {
-        serverLog.error('Unhandled promise rejection - initiating shutdown', {
-            reason: reason instanceof Error ? reason.message : String(reason),
-            stack: reason instanceof Error ? reason.stack : undefined,
-        });
-        void shutdown('unhandledRejection');
-    });
-    // Print stats periodically
-    const statsInterval = setInterval(() => {
-        const stats = queueManager.getStats();
-        const memStats = queueManager.getMemoryStats();
-        const workerStats = queueManager.workerManager.getStats();
-        const mem = process.memoryUsage();
-        const now = new Date();
-        const timestamp = now.toLocaleTimeString('en-GB', {
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit',
-        });
-        statsLog.info('Queue statistics', {
-            time: timestamp,
-            waiting: stats.waiting,
-            active: stats.active,
-            delayed: stats.delayed,
-            completed: stats.completed,
-            dlq: stats.dlq,
-            tcp: tcpServer.getConnectionCount(),
-            ws: httpServer.getWsClientCount(),
-            sse: httpServer.getSseClientCount(),
-            workers: `${workerStats.active}/${workerStats.total}`,
-            mem: `${Math.round(mem.heapUsed / 1024 / 1024)}MB/${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
-            rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
-            // Internal collection sizes (for memory debugging)
-            idx: memStats.jobIndex,
-            locks: memStats.jobLocks,
-            clients: memStats.clientJobsTotal,
-        });
-    }, config.statsIntervalMs);
+    bootServer(fileConfig, config);
 }
 // Logger env-var bootstrap only applies when this file is the entry point.
 // Imported consumers (e.g. user config files using `defineConfig`) must not

package/dist/mcp/tools/webhookTools.js

@@ -4,19 +4,11 @@
  */
 import { z } from 'zod';
 import { withErrorHandler } from './withErrorHandler';
+import { WEBHOOK_EVENTS } from '../../domain/types/webhook';
 export function registerWebhookTools(server, backend) {
     server.tool('bunqueue_add_webhook', 'Add a webhook to receive notifications for job events.', {
         url: z.string().url().describe('Webhook URL to receive POST requests'),
-        events: z
-            .array(z.enum([
-            'job.completed',
-            'job.failed',
-            'job.progress',
-            'job.active',
-            'job.waiting',
-            'job.delayed',
-        ]))
-            .describe('Events to subscribe to'),
+        events: z.array(z.enum(WEBHOOK_EVENTS)).describe('Events to subscribe to'),
         queue: z.string().optional().describe('Limit to a specific queue (omit for all queues)'),
     }, withErrorHandler('bunqueue_add_webhook', async ({ url, events, queue }) => {
         const webhook = await backend.addWebhook(url, events, queue);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.9",
+  "version": "2.8.11",
   "description": "High-performance job queue for Bun & AI agents. SQLite persistence, cron scheduling, priorities, retries, DLQ, webhooks, native MCP server. Zero external dependencies.",
   "type": "module",
   "main": "dist/main.js",