bunqueue 2.8.53 → 2.8.56

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

@@ -1,9 +1,6 @@
-/**
- * Core Command Handlers
- * Push, Pull, Ack, Fail operations
- */
+/** Core command handlers for push, pull, acknowledgement, and failure. */
 import * as resp from '../../../domain/types/response';
-import { jobId } from '../../../domain/types/job';
+import { jobId, normalizeLegacyJobPayload } from '../../../domain/types/job';
 import { validateQueueName, validateJobData, validateJobOptions, validateNumericField, } from '../protocol';
 import { validatePushBatchJobs } from './pushBatchValidation';
 /** Handle PUSH command */
@@ -42,8 +39,10 @@ export async function handlePush(cmd, ctx, reqId) {
         }
     }
     try {
+        const payload = normalizeLegacyJobPayload(cmd);
         const job = await ctx.queueManager.push(cmd.queue, {
-            data: cmd.data,
+            name: payload.name,
+            data: payload.data,
             priority: cmd.priority,
             delay: cmd.delay,
             maxAttempts: cmd.maxAttempts,
@@ -92,7 +91,11 @@ export async function handlePushBatch(cmd, ctx, reqId) {
     const jobsError = validatePushBatchJobs(cmd.jobs, ctx);
     if (jobsError)
         return resp.error(jobsError, reqId);
-    const ids = await ctx.queueManager.pushBatch(cmd.queue, cmd.jobs);
+    const inputs = cmd.jobs.map((job) => {
+        const payload = normalizeLegacyJobPayload(job);
+        return { ...job, name: payload.name, data: payload.data };
+    });
+    const ids = await ctx.queueManager.pushBatch(cmd.queue, inputs);
     return resp.batch(ids, reqId);
 }
 /** Handle PULL command */
@@ -158,10 +161,12 @@ export async function handlePullBatch(cmd, ctx, reqId) {
 export async function handleAck(cmd, ctx, reqId) {
     try {
         const jid = jobId(cmd.id);
-        await ctx.queueManager.ack(jid, cmd.result, cmd.token);
-        // Unregister job from client tracking
-        ctx.queueManager.unregisterClientJob(ctx.clientId, jid);
-        return resp.ok(undefined, reqId);
+        const outcome = await ctx.queueManager.ack(jid, cmd.result, cmd.token, {
+            removeOnComplete: cmd.removeOnComplete,
+        });
+        if (!outcome)
+            ctx.queueManager.unregisterClientJob(ctx.clientId, jid);
+        return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
         return resp.error(err instanceof Error ? err.message : String(err), reqId);
@@ -169,9 +174,19 @@ export async function handleAck(cmd, ctx, reqId) {
 }
 /** Handle ACKB (batch ack) command - supports optional results and tokens */
 export async function handleAckBatch(cmd, ctx, reqId) {
+    if (cmd.tokens && cmd.tokens.length !== cmd.ids.length) {
+        return resp.error('ACKB tokens length must match ids length', reqId);
+    }
+    if (cmd.results && cmd.results.length !== cmd.ids.length) {
+        return resp.error('ACKB results length must match ids length', reqId);
+    }
+    if (cmd.removeOnCompletes && cmd.removeOnCompletes.length !== cmd.ids.length) {
+        return resp.error('ACKB removeOnCompletes length must match ids length', reqId);
+    }
     const ids = cmd.ids.map((id) => jobId(id));
     try {
         // If results provided, use ackBatchWithResults
+        let outcome;
         if (cmd.results?.length === cmd.ids.length) {
             const results = cmd.results;
             const tokens = cmd.tokens;
@@ -179,18 +194,20 @@ export async function handleAckBatch(cmd, ctx, reqId) {
                 id,
                 result: results[i],
                 token: tokens?.[i],
+                removeOnComplete: cmd.removeOnCompletes?.[i] === true ? true : undefined,
             }));
-            await ctx.queueManager.ackBatchWithResults(items);
+            outcome = await ctx.queueManager.ackBatchWithResults(items);
         }
         else {
             // Use optimized batch ack without results
-            await ctx.queueManager.ackBatch(ids, cmd.tokens);
+            outcome = await ctx.queueManager.ackBatch(ids, cmd.tokens);
         }
-        // Unregister all jobs from client tracking
+        const ignoredIds = new Set(outcome?.ignoredIds ?? []);
         for (const id of ids) {
-            ctx.queueManager.unregisterClientJob(ctx.clientId, id);
+            if (!ignoredIds.has(id))
+                ctx.queueManager.unregisterClientJob(ctx.clientId, id);
         }
-        return resp.ok(undefined, reqId);
+        return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
         return resp.error(err instanceof Error ? err.message : String(err), reqId);
@@ -206,10 +223,10 @@ export async function handleFail(cmd, ctx, reqId) {
         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);
+        const outcome = await ctx.queueManager.fail(jid, cmd.error, cmd.token, cmd.unrecoverable, stack && stack.length > 0 ? stack : undefined, cmd.removeOnFail);
+        if (!outcome)
+            ctx.queueManager.unregisterClientJob(ctx.clientId, jid);
+        return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
         return resp.error(err instanceof Error ? err.message : String(err), reqId);

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

@@ -3,14 +3,17 @@
  * Cron, CronGet, CronDelete, CronList
  */
 import * as resp from '../../../domain/types/response';
+import { normalizeLegacyJobPayload } from '../../../domain/types/job';
 /** Handle Cron command - add cron job */
 export function handleCron(cmd, ctx, reqId) {
     try {
+        const payload = normalizeLegacyJobPayload({ name: cmd.jobName, data: cmd.data });
         const existing = ctx.queueManager.getCron(cmd.name);
         const cron = ctx.queueManager.addCron({
             name: cmd.name,
+            jobName: payload.name,
             queue: cmd.queue,
-            data: cmd.data,
+            data: payload.data,
             schedule: cmd.schedule,
             repeatEvery: cmd.repeatEvery,
             priority: cmd.priority,
@@ -35,10 +38,13 @@ export function handleCron(cmd, ctx, reqId) {
             ok: true,
             cron: {
                 name: cron.name,
+                jobName: cron.jobName,
                 queue: cron.queue,
                 schedule: cron.schedule,
                 repeatEvery: cron.repeatEvery,
                 nextRun: cron.nextRun,
+                executions: cron.executions,
+                maxLimit: cron.maxLimit,
                 timezone: cron.timezone,
                 priority: cron.priority,
             },
@@ -59,6 +65,7 @@ export function handleCronGet(cmd, ctx, reqId) {
         ok: true,
         cron: {
             name: cron.name,
+            jobName: cron.jobName,
             queue: cron.queue,
             schedule: cron.schedule,
             repeatEvery: cron.repeatEvery,
@@ -84,6 +91,7 @@ export function handleCronList(_cmd, ctx, reqId) {
         ok: true,
         crons: crons.map((c) => ({
             name: c.name,
+            jobName: c.jobName,
             queue: c.queue,
             schedule: c.schedule,
             repeatEvery: c.repeatEvery,

package/dist/infrastructure/server/handlers/dlq.d.ts

@@ -9,6 +9,9 @@ import type { HandlerContext } from '../types';
 export declare function handleDlq(cmd: Extract<Command, {
     cmd: 'Dlq';
 }>, ctx: HandlerContext, reqId?: string): Response;
+export declare function handleGetDlqStats(cmd: Extract<Command, {
+    cmd: 'GetDlqStats';
+}>, ctx: HandlerContext, reqId?: string): Response;
 /** Handle RetryDlq command - retry DLQ jobs */
 export declare function handleRetryDlq(cmd: Extract<Command, {
     cmd: 'RetryDlq';

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

@@ -6,14 +6,25 @@ import * as resp from '../../../domain/types/response';
 import { jobId } from '../../../domain/types/job';
 /** Handle Dlq command - get DLQ jobs */
 export function handleDlq(cmd, ctx, reqId) {
-    const jobs = ctx.queueManager.getDlq(cmd.queue, cmd.count);
-    return resp.jobs(jobs, reqId);
+    const entries = ctx.queueManager.getDlqEntries(cmd.queue, cmd.filter);
+    const selected = cmd.count === undefined ? entries : entries.slice(0, Math.max(0, cmd.count));
+    return {
+        ok: true,
+        jobs: selected.map((entry) => entry.job),
+        entries: selected,
+        reqId,
+    };
+}
+export function handleGetDlqStats(cmd, ctx, reqId) {
+    return resp.data({ stats: ctx.queueManager.getDlqStats(cmd.queue) }, reqId);
 }
 /** Handle RetryDlq command - retry DLQ jobs */
 export function handleRetryDlq(cmd, ctx, reqId) {
     const jid = cmd.jobId ? jobId(cmd.jobId) : undefined;
     // #111-class: honour the caller's `count` cap instead of retrying the whole DLQ.
-    const count = ctx.queueManager.retryDlq(cmd.queue, jid, cmd.count);
+    const count = cmd.filter
+        ? ctx.queueManager.retryDlqByFilter(cmd.queue, cmd.filter)
+        : ctx.queueManager.retryDlq(cmd.queue, jid, cmd.count);
     if (count > 0) {
         const event = jid ? 'dlq:retried' : 'dlq:retry-all';
         const data = { queue: cmd.queue, count };
@@ -33,6 +44,9 @@ export function handlePurgeDlq(cmd, ctx, reqId) {
 /** Handle RetryCompleted command - retry completed jobs */
 export function handleRetryCompleted(cmd, ctx, reqId) {
     const jid = cmd.id ? jobId(cmd.id) : undefined;
-    const count = ctx.queueManager.retryCompleted(cmd.queue, jid);
+    const count = ctx.queueManager.retryCompleted(cmd.queue, jid, {
+        limit: cmd.count,
+        timestamp: cmd.timestamp,
+    });
     return { ok: true, count, reqId };
 }

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

@@ -1,8 +1,13 @@
 import * as resp from '../../../domain/types/response';
+import { normalizeLegacyJobPayload } from '../../../domain/types/job';
 /** Commit the whole graph in one broker operation; validation happens pre-mutation. */
 export async function handlePushFlow(cmd, ctx, reqId) {
     try {
-        const result = await ctx.queueManager.pushFlow({ jobs: cmd.jobs });
+        const jobs = cmd.jobs.map((job) => {
+            const payload = normalizeLegacyJobPayload(job.input);
+            return { ...job, input: { ...job.input, name: payload.name, data: payload.data } };
+        });
+        const result = await ctx.queueManager.pushFlow({ jobs });
         return resp.data(result, reqId);
     }
     catch (error) {

package/dist/infrastructure/server/handlers/introspection.d.ts

@@ -0,0 +1,19 @@
+/** Queue limit and deduplication introspection handlers. */
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { HandlerContext } from '../types';
+export declare function handleGetQueueLimits(cmd: Extract<Command, {
+    cmd: 'GetQueueLimits';
+}>, ctx: HandlerContext, reqId?: string): Response;
+export declare function handleGetDeduplicationJobId(cmd: Extract<Command, {
+    cmd: 'GetDeduplicationJobId';
+}>, ctx: HandlerContext, reqId?: string): Response;
+export declare function handleRemoveDeduplicationKey(cmd: Extract<Command, {
+    cmd: 'RemoveDeduplicationKey';
+}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
+export declare function handleRemoveJobDeduplicationKey(cmd: Extract<Command, {
+    cmd: 'RemoveJobDeduplicationKey';
+}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
+export declare function handleMoveToWaitingChildren(cmd: Extract<Command, {
+    cmd: 'MoveToWaitingChildren';
+}>, ctx: HandlerContext, reqId?: string): Promise<Response>;

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

@@ -0,0 +1,21 @@
+/** Queue limit and deduplication introspection handlers. */
+import * as resp from '../../../domain/types/response';
+import { jobId } from '../../../domain/types/job';
+export function handleGetQueueLimits(cmd, ctx, reqId) {
+    return resp.data({ limits: ctx.queueManager.getQueueLimitStatus(cmd.queue, cmd.maxJobs) }, reqId);
+}
+export function handleGetDeduplicationJobId(cmd, ctx, reqId) {
+    return resp.data({ jobId: ctx.queueManager.getDeduplicationJobId(cmd.queue, cmd.deduplicationId) }, reqId);
+}
+export async function handleRemoveDeduplicationKey(cmd, ctx, reqId) {
+    const count = await ctx.queueManager.removeDeduplicationKey(cmd.queue, cmd.deduplicationId);
+    return resp.data({ count }, reqId);
+}
+export async function handleRemoveJobDeduplicationKey(cmd, ctx, reqId) {
+    const removed = await ctx.queueManager.removeJobDeduplicationKey(cmd.id);
+    return resp.data({ removed }, reqId);
+}
+export async function handleMoveToWaitingChildren(cmd, ctx, reqId) {
+    const moved = await ctx.queueManager.moveToWaitingChildren(jobId(cmd.id), cmd.token);
+    return moved ? resp.data({ moved: true }, reqId) : resp.error('Job is not active', reqId);
+}

package/dist/infrastructure/server/handlers/management.d.ts

@@ -37,3 +37,11 @@ export declare function handleStorageStatus(_cmd: Extract<Command, {
 }>, ctx: HandlerContext, reqId?: string): Response;
 /** Handle Metrics command */
 export declare function handleMetrics(ctx: HandlerContext, reqId?: string): Response;
+/** Handle the queue-scoped Metrics form. */
+export declare function handleQueueMetrics(cmd: Extract<Command, {
+    cmd: 'Metrics';
+}>, ctx: HandlerContext, reqId?: string): Response;
+/** Trim one queue's durable lifecycle-event journal. */
+export declare function handleTrimEvents(cmd: Extract<Command, {
+    cmd: 'TrimEvents';
+}>, ctx: HandlerContext, reqId?: string): Response;

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

@@ -6,6 +6,7 @@ import * as resp from '../../../domain/types/response';
 import { jobId } from '../../../domain/types/job';
 import { throughputTracker } from '../../../application/throughputTracker';
 import { latencyTracker } from '../../../application/latencyTracker';
+import { validateQueueName } from '../protocol/validation';
 /** Handle Cancel command */
 export async function handleCancel(cmd, ctx, reqId) {
     const success = await ctx.queueManager.cancel(jobId(cmd.id));
@@ -97,3 +98,32 @@ export function handleMetrics(ctx, reqId) {
         activeConnections: 0,
     }, reqId);
 }
+/** Handle the queue-scoped Metrics form. */
+export function handleQueueMetrics(cmd, ctx, reqId) {
+    if (typeof cmd.queue !== 'string')
+        return resp.error('Metrics queue is required', reqId);
+    const queueError = validateQueueName(cmd.queue);
+    if (queueError)
+        return resp.error(queueError, reqId);
+    if (cmd.type !== 'completed' && cmd.type !== 'failed') {
+        return resp.error("Metrics type must be 'completed' or 'failed'", reqId);
+    }
+    try {
+        return resp.data(ctx.queueManager.getQueueMetrics(cmd.queue, cmd.type, cmd.start ?? 0, cmd.end ?? -1), reqId);
+    }
+    catch (error) {
+        return resp.error(error instanceof Error ? error.message : String(error), reqId);
+    }
+}
+/** Trim one queue's durable lifecycle-event journal. */
+export function handleTrimEvents(cmd, ctx, reqId) {
+    const queueError = validateQueueName(cmd.queue);
+    if (queueError)
+        return resp.error(queueError, reqId);
+    try {
+        return resp.data({ removed: ctx.queueManager.trimQueueEvents(cmd.queue, cmd.maxLength) }, reqId);
+    }
+    catch (error) {
+        return resp.error(error instanceof Error ? error.message : String(error), reqId);
+    }
+}

package/dist/infrastructure/server/handlers/monitoring/health.d.ts

@@ -0,0 +1,13 @@
+import type { AddLogCommand, GetLogsCommand, HeartbeatCommand, HelloCommand, JobHeartbeatBatchCommand, JobHeartbeatCommand, PingCommand } from '../../../../domain/types/command';
+import { PROTOCOL_VERSION, type ProtocolCapability } from '../../../../domain/types/protocol';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export { PROTOCOL_VERSION };
+export declare const SUPPORTED_CAPABILITIES: ProtocolCapability[];
+export declare function handleAddLog(command: AddLogCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleGetLogs(command: GetLogsCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleHeartbeat(command: HeartbeatCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleJobHeartbeat(command: JobHeartbeatCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleJobHeartbeatBatch(command: JobHeartbeatBatchCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handlePing(_command: PingCommand, _context: HandlerContext, requestId?: string): Response;
+export declare function handleHello(_command: HelloCommand, _context: HandlerContext, requestId?: string): Response;

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

@@ -0,0 +1,61 @@
+import { jobId } from '../../../../domain/types/job';
+import { PROTOCOL_CAPABILITIES, PROTOCOL_VERSION, } from '../../../../domain/types/protocol';
+import * as response from '../../../../domain/types/response';
+import { VERSION } from '../../../../shared/version';
+export { PROTOCOL_VERSION };
+export const SUPPORTED_CAPABILITIES = [...PROTOCOL_CAPABILITIES];
+export function handleAddLog(command, context, requestId) {
+    const success = context.queueManager.addLog(jobId(command.id), command.message, command.level ?? 'info');
+    return success
+        ? response.data({ added: true }, requestId)
+        : response.error('Job not found', requestId);
+}
+export function handleGetLogs(command, context, requestId) {
+    const all = context.queueManager.getLogs(jobId(command.id));
+    const total = all.length;
+    const logs = command.start === undefined && command.end === undefined
+        ? all
+        : all.slice(command.start ?? 0, (command.end ?? total - 1) + 1);
+    return response.data({ logs, count: total }, requestId);
+}
+export function handleHeartbeat(command, context, requestId) {
+    const stats = command.activeJobs !== undefined ||
+        command.processed !== undefined ||
+        command.failed !== undefined
+        ? {
+            activeJobs: command.activeJobs,
+            processed: command.processed,
+            failed: command.failed,
+        }
+        : undefined;
+    const success = context.queueManager.workerManager.heartbeat(command.id, stats);
+    if (success) {
+        context.queueManager.emitDashboardEvent('worker:heartbeat', { workerId: command.id });
+        return response.data({ ok: true }, requestId);
+    }
+    return response.error('Worker not found', requestId);
+}
+export function handleJobHeartbeat(command, context, requestId) {
+    const id = jobId(command.id);
+    if (command.duration && command.token) {
+        const success = context.queueManager.renewJobLock(id, command.token, command.duration);
+        return success
+            ? response.data({ ok: true }, requestId)
+            : response.error('Job not found or not active (or invalid token)', requestId);
+    }
+    const success = context.queueManager.jobHeartbeat(id, command.token);
+    return success
+        ? response.data({ ok: true }, requestId)
+        : response.error('Job not found or not active (or invalid token)', requestId);
+}
+export function handleJobHeartbeatBatch(command, context, requestId) {
+    const ids = command.ids.map((id) => jobId(id));
+    const count = context.queueManager.jobHeartbeatBatch(ids, command.tokens);
+    return response.data({ ok: true, count }, requestId);
+}
+export function handlePing(_command, _context, requestId) {
+    return response.data({ pong: true, time: Date.now() }, requestId);
+}
+export function handleHello(_command, _context, requestId) {
+    return response.hello(PROTOCOL_VERSION, SUPPORTED_CAPABILITIES, 'bunqueue', VERSION, requestId);
+}

package/dist/infrastructure/server/handlers/monitoring/operations.d.ts

@@ -0,0 +1,8 @@
+import type { ClearLogsCommand, CompactMemoryCommand, ExtendLockCommand, ExtendLocksCommand, PrometheusCommand } from '../../../../domain/types/command';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export declare function handlePrometheus(_command: PrometheusCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleClearLogs(command: ClearLogsCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleExtendLock(command: ExtendLockCommand, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleExtendLocks(command: ExtendLocksCommand, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleCompactMemory(_command: CompactMemoryCommand, context: HandlerContext, requestId?: string): Response;

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

@@ -0,0 +1,28 @@
+import { jobId } from '../../../../domain/types/job';
+import * as response from '../../../../domain/types/response';
+export function handlePrometheus(_command, context, requestId) {
+    return response.data({ metrics: context.queueManager.getPrometheusMetrics() }, requestId);
+}
+export function handleClearLogs(command, context, requestId) {
+    context.queueManager.clearLogs(jobId(command.id), command.keepLogs);
+    return response.ok(undefined, requestId);
+}
+export async function handleExtendLock(command, context, requestId) {
+    const success = await context.queueManager.extendLock(jobId(command.id), command.token ?? null, command.duration);
+    return success
+        ? response.ok(undefined, requestId)
+        : response.error('Lock not found or invalid token', requestId);
+}
+export async function handleExtendLocks(command, context, requestId) {
+    let count = 0;
+    for (let index = 0; index < command.ids.length; index++) {
+        const success = await context.queueManager.extendLock(jobId(command.ids[index]), command.tokens[index] ?? null, command.durations[index]);
+        if (success)
+            count++;
+    }
+    return { ok: true, count, reqId: requestId };
+}
+export function handleCompactMemory(_command, context, requestId) {
+    context.queueManager.compactMemory();
+    return response.ok(undefined, requestId);
+}

package/dist/infrastructure/server/handlers/monitoring/webhooks.d.ts

@@ -0,0 +1,7 @@
+import type { AddWebhookCommand, ListWebhooksCommand, RemoveWebhookCommand, SetWebhookEnabledCommand } from '../../../../domain/types/command';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export declare function handleAddWebhook(command: AddWebhookCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleRemoveWebhook(command: RemoveWebhookCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleListWebhooks(_command: ListWebhooksCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleSetWebhookEnabled(command: SetWebhookEnabledCommand, context: HandlerContext, requestId?: string): Response;

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

@@ -0,0 +1,56 @@
+import * as response from '../../../../domain/types/response';
+import { WEBHOOK_EVENTS } from '../../../../domain/types/webhook';
+import { validateWebhookUrl } from '../../protocol';
+export function handleAddWebhook(command, context, requestId) {
+    const urlError = validateWebhookUrl(command.url);
+    if (urlError)
+        return response.error(urlError, requestId);
+    const invalidEvents = command.events.filter((event) => !WEBHOOK_EVENTS.includes(event));
+    if (invalidEvents.length > 0) {
+        return response.error(`Invalid webhook event(s): ${invalidEvents.join(', ')}. Valid: ${WEBHOOK_EVENTS.join(', ')}`, requestId);
+    }
+    const webhook = context.queueManager.webhookManager.add(command.url, command.events, command.queue, command.secret);
+    context.queueManager.emitDashboardEvent('webhook:added', {
+        id: webhook.id,
+        url: webhook.url,
+        events: webhook.events,
+    });
+    return response.data({
+        webhookId: webhook.id,
+        url: webhook.url,
+        events: webhook.events,
+        queue: webhook.queue,
+        createdAt: webhook.createdAt,
+    }, requestId);
+}
+export function handleRemoveWebhook(command, context, requestId) {
+    const success = context.queueManager.webhookManager.remove(command.webhookId);
+    if (success) {
+        context.queueManager.emitDashboardEvent('webhook:removed', { id: command.webhookId });
+        return response.data({ removed: true }, requestId);
+    }
+    return response.error('Webhook not found', requestId);
+}
+export function handleListWebhooks(_command, context, requestId) {
+    const webhooks = context.queueManager.webhookManager.list();
+    return response.data({
+        webhooks: webhooks.map((webhook) => ({
+            id: webhook.id,
+            url: webhook.url,
+            events: webhook.events,
+            queue: webhook.queue,
+            createdAt: webhook.createdAt,
+            lastTriggered: webhook.lastTriggered,
+            successCount: webhook.successCount,
+            failureCount: webhook.failureCount,
+            enabled: webhook.enabled,
+        })),
+        stats: context.queueManager.webhookManager.getStats(),
+    }, requestId);
+}
+export function handleSetWebhookEnabled(command, context, requestId) {
+    const success = context.queueManager.webhookManager.setEnabled(command.id, command.enabled);
+    return success
+        ? response.ok(undefined, requestId)
+        : response.error('Webhook not found', requestId);
+}

package/dist/infrastructure/server/handlers/monitoring/workers.d.ts

@@ -0,0 +1,6 @@
+import type { ListWorkersCommand, RegisterWorkerCommand, UnregisterWorkerCommand } from '../../../../domain/types/command';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export declare function handleRegisterWorker(command: RegisterWorkerCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleUnregisterWorker(command: UnregisterWorkerCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleListWorkers(_command: ListWorkersCommand, context: HandlerContext, requestId?: string): Response;

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

@@ -0,0 +1,57 @@
+import * as response from '../../../../domain/types/response';
+const WORKER_TIMEOUT_MS = parseInt(Bun.env.WORKER_TIMEOUT_MS ?? '30000', 10);
+function computeWorkerStatus(lastSeen, now) {
+    return now - lastSeen < WORKER_TIMEOUT_MS ? 'active' : 'stale';
+}
+export function handleRegisterWorker(command, context, requestId) {
+    const worker = context.queueManager.registerWorker(command.name, command.queues, command.concurrency, {
+        workerId: command.workerId,
+        hostname: command.hostname,
+        pid: command.pid,
+        startedAt: command.startedAt,
+        clientId: context.clientId,
+    });
+    return response.data({
+        workerId: worker.id,
+        name: worker.name,
+        queues: worker.queues,
+        concurrency: worker.concurrency,
+        hostname: worker.hostname,
+        pid: worker.pid,
+        status: 'active',
+        registeredAt: worker.registeredAt,
+        lastSeen: worker.lastSeen,
+        activeJobs: worker.activeJobs,
+        processedJobs: worker.processedJobs,
+        failedJobs: worker.failedJobs,
+        currentJob: worker.currentJob,
+    }, requestId);
+}
+export function handleUnregisterWorker(command, context, requestId) {
+    return context.queueManager.unregisterWorker(command.workerId)
+        ? response.data({ removed: true }, requestId)
+        : response.error('Worker not found', requestId);
+}
+export function handleListWorkers(_command, context, requestId) {
+    const workers = context.queueManager.workerManager.list();
+    const now = Date.now();
+    return response.data({
+        workers: workers.map((worker) => ({
+            id: worker.id,
+            name: worker.name,
+            queues: worker.queues,
+            concurrency: worker.concurrency,
+            hostname: worker.hostname,
+            pid: worker.pid,
+            status: computeWorkerStatus(worker.lastSeen, now),
+            registeredAt: worker.registeredAt,
+            lastSeen: worker.lastSeen,
+            activeJobs: worker.activeJobs,
+            processedJobs: worker.processedJobs,
+            failedJobs: worker.failedJobs,
+            currentJob: worker.currentJob,
+            uptime: now - worker.registeredAt,
+        })),
+        stats: context.queueManager.workerManager.getStats(),
+    }, requestId);
+}

package/dist/infrastructure/server/handlers/monitoring.d.ts

@@ -1,30 +1,4 @@
-/**
- * Monitoring Handlers
- * Handles logs, workers, webhooks, and prometheus metrics
- */
-import type { AddLogCommand, GetLogsCommand, HeartbeatCommand, JobHeartbeatCommand, JobHeartbeatBatchCommand, PingCommand, HelloCommand, RegisterWorkerCommand, UnregisterWorkerCommand, ListWorkersCommand, AddWebhookCommand, RemoveWebhookCommand, ListWebhooksCommand, PrometheusCommand, ClearLogsCommand, ExtendLockCommand, ExtendLocksCommand, SetWebhookEnabledCommand, CompactMemoryCommand } from '../../../domain/types/command';
-import type { Response } from '../../../domain/types/response';
-import type { HandlerContext } from '../types';
-export declare function handleAddLog(cmd: AddLogCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleGetLogs(cmd: GetLogsCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleHeartbeat(cmd: HeartbeatCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleJobHeartbeat(cmd: JobHeartbeatCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleJobHeartbeatBatch(cmd: JobHeartbeatBatchCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handlePing(_cmd: PingCommand, _ctx: HandlerContext, reqId?: string): Response;
-/** Current protocol version */
-export declare const PROTOCOL_VERSION = 2;
-/** Supported capabilities */
-export declare const SUPPORTED_CAPABILITIES: 'pipelining'[];
-export declare function handleHello(_cmd: HelloCommand, _ctx: HandlerContext, reqId?: string): Response;
-export declare function handleRegisterWorker(cmd: RegisterWorkerCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleUnregisterWorker(cmd: UnregisterWorkerCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleListWorkers(_cmd: ListWorkersCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleAddWebhook(cmd: AddWebhookCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleRemoveWebhook(cmd: RemoveWebhookCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleListWebhooks(_cmd: ListWebhooksCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handlePrometheus(_cmd: PrometheusCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleClearLogs(cmd: ClearLogsCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleExtendLock(cmd: ExtendLockCommand, ctx: HandlerContext, reqId?: string): Promise<Response>;
-export declare function handleExtendLocks(cmd: ExtendLocksCommand, ctx: HandlerContext, reqId?: string): Promise<Response>;
-export declare function handleSetWebhookEnabled(cmd: SetWebhookEnabledCommand, ctx: HandlerContext, reqId?: string): Response;
-export declare function handleCompactMemory(_cmd: CompactMemoryCommand, ctx: HandlerContext, reqId?: string): Response;
+export { handleAddLog, handleGetLogs, handleHeartbeat, handleHello, handleJobHeartbeat, handleJobHeartbeatBatch, handlePing, PROTOCOL_VERSION, SUPPORTED_CAPABILITIES, } from './monitoring/health';
+export { handleClearLogs, handleCompactMemory, handleExtendLock, handleExtendLocks, handlePrometheus, } from './monitoring/operations';
+export { handleAddWebhook, handleListWebhooks, handleRemoveWebhook, handleSetWebhookEnabled, } from './monitoring/webhooks';
+export { handleListWorkers, handleRegisterWorker, handleUnregisterWorker, } from './monitoring/workers';