bunqueue 2.8.8 → 2.8.10

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.8",
+  "version": "2.8.10",
   "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",