bunqueue 2.8.60 → 2.9.2

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

@@ -1,12 +1,13 @@
 import { jobId } from '../../../../domain/types/job';
 import * as response from '../../../../domain/types/response';
+import { sanitizeServerError } from '../../errors';
 export async function handleGetFailedChildrenValues(command, context, requestId) {
     try {
         const values = await context.queueManager.getFailedChildrenValues(jobId(command.id));
         return { ok: true, values, reqId: requestId };
     }
-    catch {
-        return { ok: true, values: {}, reqId: requestId };
+    catch (error) {
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleGetIgnoredChildrenFailures(command, context, requestId) {
@@ -14,8 +15,8 @@ export async function handleGetIgnoredChildrenFailures(command, context, request
         const values = await context.queueManager.getIgnoredChildrenFailures(jobId(command.id));
         return { ok: true, values, reqId: requestId };
     }
-    catch {
-        return { ok: true, values: {}, reqId: requestId };
+    catch (error) {
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleRemoveChildDependency(command, context, requestId) {
@@ -24,7 +25,7 @@ export async function handleRemoveChildDependency(command, context, requestId) {
         return { ok: true, removed, reqId: requestId };
     }
     catch (error) {
-        return response.error(error instanceof Error ? error.message : String(error), requestId);
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleRemoveUnprocessedChildren(command, context, requestId) {
@@ -33,6 +34,6 @@ export async function handleRemoveUnprocessedChildren(command, context, requestI
         return response.ok(undefined, requestId);
     }
     catch (error) {
-        return response.error(error instanceof Error ? error.message : String(error), requestId);
+        return response.error(sanitizeServerError(error), requestId);
     }
 }

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

@@ -1,6 +1,7 @@
 import { jobId } from '../../../../domain/types/job';
 import * as response from '../../../../domain/types/response';
 import { validateNumericField } from '../../protocol';
+import { sanitizeServerError } from '../../errors';
 export async function handleUpdate(command, context, requestId) {
     const success = await context.queueManager.updateJobData(jobId(command.id), command.data);
     if (success)
@@ -35,7 +36,7 @@ export async function handleUpdateParent(command, context, requestId) {
         return response.ok(undefined, requestId);
     }
     catch (error) {
-        return response.error(error instanceof Error ? error.message : 'Failed to update parent', requestId);
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleMoveToDelayed(command, context, requestId) {
@@ -69,13 +70,22 @@ export async function handleWaitJob(command, context, requestId) {
         return response.error(timeoutError, requestId);
     const timeout = command.timeout ?? 30000;
     const job = await context.queueManager.getJob(id);
-    if (!job)
-        return response.error('Job not found', requestId);
+    if (!job) {
+        const completion = await context.queueManager.getCompletionAsync(id);
+        if (!completion.found)
+            return response.error('Job not found', requestId);
+        return {
+            ok: true,
+            completed: true,
+            result: completion.result,
+            reqId: requestId,
+        };
+    }
     if (job.completedAt) {
         return {
             ok: true,
             completed: true,
-            result: context.queueManager.getResult(id),
+            result: await context.queueManager.getResultAsync(id),
             reqId: requestId,
         };
     }
@@ -84,7 +94,7 @@ export async function handleWaitJob(command, context, requestId) {
         return {
             ok: true,
             completed: true,
-            result: context.queueManager.getResult(id),
+            result: await context.queueManager.getResultAsync(id),
             reqId: requestId,
         };
     }
@@ -121,7 +131,10 @@ export async function handleMoveToWait(command, context, requestId) {
         const job = await context.queueManager.getJob(id);
         if (!job)
             return response.error('Job not found', requestId);
-        const count = context.queueManager.retryDlq(job.queue, id);
+        const manager = context.queueManager;
+        const count = manager.retryDlqDurable
+            ? await manager.retryDlqDurable(job.queue, id)
+            : manager.retryDlq(job.queue, id);
         return count > 0
             ? response.ok(undefined, requestId)
             : response.error('Failed job not in DLQ', requestId);

package/dist/infrastructure/server/handlers/advanced/queue.d.ts

@@ -3,40 +3,40 @@ import type { Response } from '../../../../domain/types/response';
 import type { HandlerContext } from '../../types';
 export declare function handleIsPaused(command: Extract<Command, {
     cmd: 'IsPaused';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleObliterate(command: Extract<Command, {
     cmd: 'Obliterate';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleListQueues(_command: Extract<Command, {
     cmd: 'ListQueues';
 }>, context: HandlerContext, requestId?: string): Response;
 export declare function handleClean(command: Extract<Command, {
     cmd: 'Clean';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleCount(command: Extract<Command, {
     cmd: 'Count';
 }>, context: HandlerContext, requestId?: string): Response;
 export declare function handleRateLimit(command: Extract<Command, {
     cmd: 'RateLimit';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleRateLimitClear(command: Extract<Command, {
     cmd: 'RateLimitClear';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleSetConcurrency(command: Extract<Command, {
     cmd: 'SetConcurrency';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleClearConcurrency(command: Extract<Command, {
     cmd: 'ClearConcurrency';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleSetStallConfig(command: Extract<Command, {
     cmd: 'SetStallConfig';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleGetStallConfig(command: Extract<Command, {
     cmd: 'GetStallConfig';
 }>, context: HandlerContext, requestId?: string): Response;
 export declare function handleSetDlqConfig(command: Extract<Command, {
     cmd: 'SetDlqConfig';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleGetDlqConfig(command: Extract<Command, {
     cmd: 'GetDlqConfig';
 }>, context: HandlerContext, requestId?: string): Response;

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

@@ -1,14 +1,26 @@
 import * as response from '../../../../domain/types/response';
 import { sanitizeConfigNumbers, toFiniteNumber } from './configNumbers';
 export function handleIsPaused(command, context, requestId) {
+    const manager = context.queueManager;
+    if (manager.isPausedDurable) {
+        return manager.isPausedDurable(command.queue).then((paused) => ({
+            ok: true,
+            paused,
+            reqId: requestId,
+        }));
+    }
     return {
         ok: true,
-        paused: context.queueManager.isPaused(command.queue),
+        paused: manager.isPaused(command.queue),
         reqId: requestId,
     };
 }
 export function handleObliterate(command, context, requestId) {
-    context.queueManager.obliterate(command.queue);
+    const manager = context.queueManager;
+    if (manager.obliterateDurable) {
+        return manager.obliterateDurable(command.queue).then(() => response.ok(undefined, requestId));
+    }
+    manager.obliterate(command.queue);
     return response.ok(undefined, requestId);
 }
 export function handleListQueues(_command, context, requestId) {
@@ -19,15 +31,24 @@ export function handleListQueues(_command, context, requestId) {
     };
 }
 export function handleClean(command, context, requestId) {
-    const ids = context.queueManager.clean(command.queue, command.grace, command.state, command.limit);
+    const manager = context.queueManager;
+    if (manager.cleanDurable) {
+        return manager
+            .cleanDurable(command.queue, command.grace, command.state, command.limit)
+            .then((ids) => cleanResponse(manager, command.queue, command.state, ids, requestId));
+    }
+    const ids = manager.clean(command.queue, command.grace, command.state, command.limit);
+    return cleanResponse(manager, command.queue, command.state, ids, requestId);
+}
+function cleanResponse(manager, queue, state, ids, requestId) {
     if (ids.length > 0) {
-        context.queueManager.emitDashboardEvent('queue:cleaned', {
-            queue: command.queue,
-            state: command.state,
+        manager.emitDashboardEvent('queue:cleaned', {
+            queue,
+            state,
             count: ids.length,
         });
     }
-    return { ok: true, count: ids.length, ids, reqId: requestId };
+    return { ok: true, count: ids.length, ids: [...ids], reqId: requestId };
 }
 export function handleCount(command, context, requestId) {
     return { ok: true, count: context.queueManager.count(command.queue), reqId: requestId };
@@ -38,8 +59,19 @@ export function handleRateLimit(command, context, requestId) {
         return response.error('limit must be a finite number', requestId);
     const duration = toFiniteNumber(command.duration);
     const ttl = toFiniteNumber(command.ttl);
-    context.queueManager.setRateLimit(command.queue, limit, duration, ttl);
-    context.queueManager.emitDashboardEvent('ratelimit:set', {
+    const manager = context.queueManager;
+    if (manager.setRateLimitDurable) {
+        return manager.setRateLimitDurable(command.queue, limit, duration ?? 1000, ttl).then(() => {
+            manager.emitDashboardEvent('ratelimit:set', {
+                queue: command.queue,
+                max: limit,
+                duration: duration ?? 1000,
+            });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.setRateLimit(command.queue, limit, duration, ttl);
+    manager.emitDashboardEvent('ratelimit:set', {
         queue: command.queue,
         max: limit,
         ...(duration !== undefined && { duration }),
@@ -48,24 +80,48 @@ export function handleRateLimit(command, context, requestId) {
     return response.ok(undefined, requestId);
 }
 export function handleRateLimitClear(command, context, requestId) {
-    context.queueManager.clearRateLimit(command.queue);
-    context.queueManager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
+    const manager = context.queueManager;
+    if (manager.setRateLimitDurable) {
+        return manager.setRateLimitDurable(command.queue, null, null).then(() => {
+            manager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.clearRateLimit(command.queue);
+    manager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
     return response.ok(undefined, requestId);
 }
 export function handleSetConcurrency(command, context, requestId) {
     const limit = toFiniteNumber(command.limit);
     if (limit === undefined)
         return response.error('limit must be a finite number', requestId);
-    context.queueManager.setConcurrency(command.queue, limit);
-    context.queueManager.emitDashboardEvent('concurrency:set', {
+    const manager = context.queueManager;
+    if (manager.setConcurrencyDurable) {
+        return manager.setConcurrencyDurable(command.queue, limit).then(() => {
+            manager.emitDashboardEvent('concurrency:set', {
+                queue: command.queue,
+                concurrency: limit,
+            });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.setConcurrency(command.queue, limit);
+    manager.emitDashboardEvent('concurrency:set', {
         queue: command.queue,
         concurrency: limit,
     });
     return response.ok(undefined, requestId);
 }
 export function handleClearConcurrency(command, context, requestId) {
-    context.queueManager.clearConcurrency(command.queue);
-    context.queueManager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
+    const manager = context.queueManager;
+    if (manager.setConcurrencyDurable) {
+        return manager.setConcurrencyDurable(command.queue, null).then(() => {
+            manager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.clearConcurrency(command.queue);
+    manager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
     return response.ok(undefined, requestId);
 }
 export function handleSetStallConfig(command, context, requestId) {
@@ -74,12 +130,16 @@ export function handleSetStallConfig(command, context, requestId) {
         'maxStalls',
         'gracePeriod',
     ]);
-    context.queueManager.setStallConfig(command.queue, config);
-    context.queueManager.emitDashboardEvent('config:stall-changed', {
-        queue: command.queue,
-        config,
-    });
-    return response.ok(undefined, requestId);
+    const manager = context.queueManager;
+    const complete = () => {
+        manager.emitDashboardEvent('config:stall-changed', { queue: command.queue, config });
+        return response.ok(undefined, requestId);
+    };
+    if (manager.setStallConfigDurable) {
+        return manager.setStallConfigDurable(command.queue, config).then(complete);
+    }
+    manager.setStallConfig(command.queue, config);
+    return complete();
 }
 export function handleGetStallConfig(command, context, requestId) {
     return {
@@ -95,12 +155,16 @@ export function handleSetDlqConfig(command, context, requestId) {
         'maxAge',
         'maxEntries',
     ]);
-    context.queueManager.setDlqConfig(command.queue, config);
-    context.queueManager.emitDashboardEvent('config:dlq-changed', {
-        queue: command.queue,
-        config,
-    });
-    return response.ok(undefined, requestId);
+    const manager = context.queueManager;
+    const complete = () => {
+        manager.emitDashboardEvent('config:dlq-changed', { queue: command.queue, config });
+        return response.ok(undefined, requestId);
+    };
+    if (manager.setDlqConfigDurable) {
+        return manager.setDlqConfigDurable(command.queue, config).then(complete);
+    }
+    manager.setDlqConfig(command.queue, config);
+    return complete();
 }
 export function handleGetDlqConfig(command, context, requestId) {
     return {

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

@@ -1,20 +1,15 @@
-/** Core command handlers for push, pull, acknowledgement, and failure. */
 import type { Command } from '../../../domain/types/command';
 import type { Response } from '../../../domain/types/response';
 import type { HandlerContext } from '../types';
-/** Handle PUSH command */
 export declare function handlePush(cmd: Extract<Command, {
     cmd: 'PUSH';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PUSHB (batch push) command */
 export declare function handlePushBatch(cmd: Extract<Command, {
     cmd: 'PUSHB';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PULL command */
 export declare function handlePull(cmd: Extract<Command, {
     cmd: 'PULL';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PULLB (batch pull) command - uses optimized single-lock batch pull */
 export declare function handlePullBatch(cmd: Extract<Command, {
     cmd: 'PULLB';
 }>, ctx: HandlerContext, reqId?: string): Promise<Response>;

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

@@ -1,9 +1,10 @@
-/** Core command handlers for push, pull, acknowledgement, and failure. */
 import * as resp from '../../../domain/types/response';
+import { validateGroupPullOptions } from '../../../domain/types/group';
 import { jobId, normalizeLegacyJobPayload } from '../../../domain/types/job';
-import { validateQueueName, validateJobData, validateJobOptions, validateNumericField, } from '../protocol';
-import { validatePushBatchJobs } from './pushBatchValidation';
-/** Handle PUSH command */
+import { tcpLog } from '../../../shared/logger';
+import { sanitizeServerError, serverErrorDiagnostics } from '../errors';
+import { validateQueueName, validateGroupId, validateJobData, validateJobOptions, validateNumericField, } from '../protocol';
+import { validatePushBatchJobs, validatePushDependencies } from './pushBatchValidation';
 export async function handlePush(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
@@ -11,7 +12,9 @@ export async function handlePush(cmd, ctx, reqId) {
     const dataError = validateJobData(cmd.data);
     if (dataError)
         return resp.error(dataError, reqId);
-    // Validate numeric fields
+    const groupError = validateGroupId(cmd.groupId);
+    if (groupError)
+        return resp.error(groupError, reqId);
     const optionsError = validateJobOptions({
         priority: cmd.priority,
         delay: cmd.delay,
@@ -22,23 +25,10 @@ export async function handlePush(cmd, ctx, reqId) {
     });
     if (optionsError)
         return resp.error(optionsError, reqId);
-    // Validate dependsOn references exist
-    if (cmd.dependsOn && cmd.dependsOn.length > 0) {
-        for (const depId of cmd.dependsOn) {
-            const depJobId = jobId(depId);
-            const exists = ctx.queueManager.getJobIndex().has(depJobId) ||
-                ctx.queueManager.getCompletedJobs().has(depJobId) ||
-                // A removeOnComplete parent that completed is recorded only here (its row
-                // is deleted and it leaves jobIndex/completedJobs). The readiness path and
-                // dependency processor already honor depCompletions; the gate must too, or
-                // a late dependent is wrongly rejected with "Dependency job not found".
-                ctx.queueManager.getDepCompletions().has(depJobId);
-            if (!exists) {
-                return resp.error(`Dependency job not found: ${depId}`, reqId);
-            }
-        }
-    }
     try {
+        const dependencyError = await validatePushDependencies(cmd.dependsOn, ctx);
+        if (dependencyError)
+            return resp.error(dependencyError, reqId);
         const payload = normalizeLegacyJobPayload(cmd);
         const job = await ctx.queueManager.push(cmd.queue, {
             name: payload.name,
@@ -77,69 +67,69 @@ export async function handlePush(cmd, ctx, reqId) {
         return resp.ok(job.id, reqId);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return resp.error(message, reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }
-/** Handle PUSHB (batch push) command */
 export async function handlePushBatch(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
         return resp.error(queueError, reqId);
     // PUSH parity: per-job data/option bounds + dependsOn existence gate
     // (extended to earlier same-batch custom ids for intra-batch chains).
-    const jobsError = validatePushBatchJobs(cmd.jobs, ctx);
-    if (jobsError)
-        return resp.error(jobsError, reqId);
-    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);
+    try {
+        const jobsError = await validatePushBatchJobs(cmd.jobs, ctx);
+        if (jobsError)
+            return resp.error(jobsError, reqId);
+        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);
+    }
+    catch (error) {
+        return resp.error(sanitizeServerError(error), reqId);
+    }
 }
-/** Handle PULL command */
 export async function handlePull(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
         return resp.error(queueError, reqId);
-    // Validate timeout
     const timeoutError = validateNumericField(cmd.timeout, 'timeout', { min: 0, max: 60000 });
     if (timeoutError)
         return resp.error(timeoutError, reqId);
-    // If owner is provided, use lock-based pull
+    const groupError = validateGroupPullOptions(cmd.group);
+    if (groupError)
+        return resp.error(groupError, reqId);
     if (cmd.owner) {
-        const { job, token } = await ctx.queueManager.pullWithLock(cmd.queue, cmd.owner, cmd.timeout, cmd.lockTtl, ctx.signal);
-        // Register job with client for connection-based release
+        const { job, token } = await ctx.queueManager.pullWithLock(cmd.queue, cmd.owner, cmd.timeout, cmd.lockTtl, ctx.signal, cmd.group);
         if (job && ctx.clientId) {
             ctx.queueManager.registerClientJob(ctx.clientId, job.id);
         }
         return resp.pulledJob(job, token, reqId);
     }
     // Standard pull (no lock, but still track for client release unless detached)
-    const job = await ctx.queueManager.pull(cmd.queue, cmd.timeout, ctx.signal);
+    const job = await ctx.queueManager.pull(cmd.queue, cmd.timeout, ctx.signal, cmd.group);
     if (job && ctx.clientId && !cmd.detach) {
         ctx.queueManager.registerClientJob(ctx.clientId, job.id);
     }
     return resp.nullableJob(job, reqId);
 }
-/** Handle PULLB (batch pull) command - uses optimized single-lock batch pull */
 export async function handlePullBatch(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
         return resp.error(queueError, reqId);
-    // Validate count
     const countError = validateNumericField(cmd.count, 'count', { min: 1, max: 1000 });
     if (countError)
         return resp.error(countError, reqId);
-    // Validate timeout (same bound as PULL)
     const timeoutError = validateNumericField(cmd.timeout, 'timeout', { min: 0, max: 60000 });
     if (timeoutError)
         return resp.error(timeoutError, reqId);
-    // If owner is provided, use lock-based pull
+    const groupError = validateGroupPullOptions(cmd.group);
+    if (groupError)
+        return resp.error(groupError, reqId);
     if (cmd.owner) {
-        const { jobs, tokens } = await ctx.queueManager.pullBatchWithLock(cmd.queue, cmd.count, cmd.owner, cmd.timeout ?? 0, cmd.lockTtl, ctx.signal);
-        // Register all jobs with client for connection-based release
+        const { jobs, tokens } = await ctx.queueManager.pullBatchWithLock(cmd.queue, cmd.count, cmd.owner, cmd.timeout ?? 0, cmd.lockTtl, ctx.signal, cmd.group);
         if (ctx.clientId) {
             for (const job of jobs) {
                 ctx.queueManager.registerClientJob(ctx.clientId, job.id);
@@ -149,7 +139,7 @@ export async function handlePullBatch(cmd, ctx, reqId) {
     }
     // Standard pull (no locks, but still track for client release) — the
     // non-owner branch honors cmd.timeout exactly like the owner branch and PULL.
-    const jobs = await ctx.queueManager.pullBatch(cmd.queue, cmd.count, cmd.timeout ?? 0, ctx.signal);
+    const jobs = await ctx.queueManager.pullBatch(cmd.queue, cmd.count, cmd.timeout ?? 0, ctx.signal, cmd.group);
     if (ctx.clientId) {
         for (const job of jobs) {
             ctx.queueManager.registerClientJob(ctx.clientId, job.id);
@@ -169,7 +159,7 @@ export async function handleAck(cmd, ctx, reqId) {
         return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }
 /** Handle ACKB (batch ack) command - supports optional results and tokens */
@@ -210,7 +200,15 @@ export async function handleAckBatch(cmd, ctx, reqId) {
         return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
+        const message = sanitizeServerError(err);
+        if (message === 'Internal server error') {
+            tcpLog.error('ACKB failed', {
+                ...serverErrorDiagnostics(err),
+                batchSize: ids.length,
+                ...(reqId && { reqId }),
+            });
+        }
+        return resp.error(message, reqId);
     }
 }
 /** Handle FAIL command */
@@ -229,6 +227,6 @@ export async function handleFail(cmd, ctx, reqId) {
         return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }

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

@@ -8,16 +8,16 @@ import type { HandlerContext } from '../types';
 /** Handle Cron command - add cron job */
 export declare function handleCron(cmd: Extract<Command, {
     cmd: 'Cron';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle CronGet command - get single cron job by name */
 export declare function handleCronGet(cmd: Extract<Command, {
     cmd: 'CronGet';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle CronDelete command - delete cron job */
 export declare function handleCronDelete(cmd: Extract<Command, {
     cmd: 'CronDelete';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle CronList command - list cron jobs */
 export declare function handleCronList(_cmd: Extract<Command, {
     cmd: 'CronList';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;