bunqueue 2.8.53 → 2.8.56

package/dist/application/types/contexts.d.ts

@@ -0,0 +1,110 @@
+import type { Shard } from '../../domain/queue/shard';
+import type { FailureReason } from '../../domain/types/dlq';
+import type { Job, JobId, JobLock } from '../../domain/types/job';
+import type { JobLocation } from '../../domain/types/queue';
+import type { JobLogEntry } from '../../domain/types/worker';
+import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import type { RWLock } from '../../shared/lock';
+import type { BoundedMap, BoundedSet, LRUMap, MapLike, SetLike } from '../../shared/lru';
+import type { DependencyCompletionTracker } from '../dependencyCompletions';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
+import type { EventsManager } from '../eventsManager';
+import type { MonitoringState } from '../monitoringChecks';
+import type { WebhookManager } from '../webhookManager';
+import type { WorkerManager } from '../workerManager';
+import type { DEFAULT_CONFIG } from './config';
+import type { JobTimeoutScheduler } from '../background/timeouts';
+import type { RetiredTimeoutGeneration } from './background';
+export interface QueueManagerState {
+    readonly config: typeof DEFAULT_CONFIG & {
+        dataPath?: string;
+    };
+    readonly storage: SqliteStorage | null;
+    readonly shards: Shard[];
+    readonly shardLocks: RWLock[];
+    readonly processingShards: Map<JobId, Job>[];
+    readonly processingLocks: RWLock[];
+    readonly jobIndex: Map<JobId, JobLocation>;
+    readonly completedJobs: BoundedSet<JobId>;
+    readonly jobResults: LRUMap<JobId, unknown>;
+    readonly dependencyResults: DependencyResultTracker;
+    readonly customIdMap: LRUMap<string, JobId>;
+    readonly jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    readonly jobLocks: Map<JobId, JobLock>;
+    readonly timedOutJobs: MapLike<JobId, RetiredTimeoutGeneration>;
+    readonly retiredTimeoutLeaseTokens: MapLike<string, RetiredTimeoutGeneration>;
+    readonly retiredCronLeaseTokens: MapLike<JobId, string>;
+    readonly timeoutScheduler: JobTimeoutScheduler;
+    readonly clientJobs: Map<string, Set<JobId>>;
+    readonly stalledCandidates: Set<JobId>;
+    readonly pendingDepChecks: Set<JobId>;
+    readonly queueNamesCache: Set<string>;
+    readonly eventsManager: EventsManager;
+    readonly webhookManager: WebhookManager;
+    readonly metrics: QueueManagerMetrics;
+    readonly startTime: number;
+    readonly perQueueMetrics: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+}
+export interface QueueManagerMetrics {
+    totalPushed: {
+        value: bigint;
+    };
+    totalPulled: {
+        value: bigint;
+    };
+    totalCompleted: {
+        value: bigint;
+    };
+    totalFailed: {
+        value: bigint;
+    };
+}
+export interface LockContext {
+    jobIndex: Map<JobId, JobLocation>;
+    jobLocks: Map<JobId, JobLock>;
+    retiredCronLeaseTokens: MapLike<JobId, string>;
+    clientJobs: Map<string, Set<JobId>>;
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    shards: Shard[];
+    shardLocks: RWLock[];
+    eventsManager: EventsManager;
+    dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
+    storage: SqliteStorage | null;
+    timeoutScheduler: JobTimeoutScheduler;
+}
+export interface BackgroundContext extends QueueManagerState {
+    fail: (jobId: JobId, error?: string, failureReason?: FailureReason) => Promise<void>;
+    registerQueueName: (queue: string) => void;
+    unregisterQueueName: (queue: string) => void;
+    dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
+    workerManager: WorkerManager;
+    monitoringState: MonitoringState;
+    completedJobsData: BoundedMap<JobId, Job>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
+    timedOutJobs: BoundedMap<JobId, RetiredTimeoutGeneration>;
+    retiredTimeoutLeaseTokens: BoundedMap<string, RetiredTimeoutGeneration>;
+}
+export interface StatsContext {
+    shards: Shard[];
+    processingShards: Map<JobId, Job>[];
+    completedJobs: SetLike<JobId>;
+    jobIndex: Map<JobId, JobLocation>;
+    jobResults: LRUMap<JobId, unknown>;
+    jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    customIdMap: LRUMap<string, JobId>;
+    jobLocks: Map<JobId, JobLock>;
+    clientJobs: Map<string, Set<JobId>>;
+    pendingDepChecks: Set<JobId>;
+    stalledCandidates: Set<JobId>;
+    metrics: QueueManagerMetrics;
+    startTime: number;
+    perQueueMetrics?: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+}

package/dist/application/types/contexts.js

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

package/dist/application/types/index.d.ts

@@ -0,0 +1,7 @@
+export { DEFAULT_CONFIG } from './config';
+export type { AckContext, BatchContext, ExtractedJob, FinalizeContext } from './ack';
+export type { BackgroundTaskHandles } from './background';
+export type { QueueManagerConfig } from './config';
+export type { BackgroundContext, LockContext, QueueManagerMetrics, QueueManagerState, StatsContext, } from './contexts';
+export type { QueueManagerRuntime, QueueManagerRuntimeApi, QueueManagerStateView, } from './queueManager';
+export type { GetJobsContext, QueryContext } from './query';

package/dist/application/types/index.js

@@ -0,0 +1 @@
+export { DEFAULT_CONFIG } from './config';

package/dist/application/types/query.d.ts

@@ -0,0 +1,23 @@
+import type { Shard } from '../../domain/queue/shard';
+import type { JobLocation } from '../../domain/types/queue';
+import type { Job, JobId } from '../../domain/types/job';
+import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import type { RWLock } from '../../shared/lock';
+import type { MapLike, SetLike } from '../../shared/lru';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
+export interface QueryContext {
+    storage: SqliteStorage | null;
+    shards: Shard[];
+    shardLocks: RWLock[];
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    jobIndex: Map<JobId, JobLocation>;
+    completedJobs: SetLike<JobId>;
+    completedJobsData: MapLike<JobId, Job>;
+    jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
+    customIdMap: MapLike<string, JobId>;
+}
+export interface GetJobsContext extends QueryContext {
+    shardCount: number;
+}

package/dist/application/types/query.js

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

package/dist/application/types/queueManager.d.ts

@@ -0,0 +1,94 @@
+import type { Shard } from '../../domain/queue/shard';
+import type { DlqEntry } from '../../domain/types/dlq';
+import type { FailureReason } from '../../domain/types/dlq';
+import type { Job, JobId, JobInput, JobLock } from '../../domain/types/job';
+import type { JobLocation } from '../../domain/types/queue';
+import type { JobLogEntry } from '../../domain/types/worker';
+import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import type { CronScheduler } from '../../infrastructure/scheduler/cronScheduler';
+import type { RWLock } from '../../shared/lock';
+import type { BoundedMap, BoundedSet, LRUMap } from '../../shared/lru';
+import type { DependencyCompletionTracker } from '../dependencyCompletions';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
+import type { EventsManager } from '../eventsManager';
+import type { OperationalMetrics } from '../metricsExporter';
+import type { MonitoringState } from '../monitoringChecks';
+import type { WebhookManager } from '../webhookManager';
+import type { WorkerManager } from '../workerManager';
+import type { DEFAULT_CONFIG } from './config';
+import type { JobTimeoutScheduler } from '../background/timeouts';
+import type { RetiredTimeoutGeneration } from './background';
+import type { AckOutcome } from './ack';
+export interface QueueManagerStateView {
+    config: typeof DEFAULT_CONFIG & {
+        dataPath?: string;
+    };
+    storage: SqliteStorage | null;
+    shards: Shard[];
+    shardLocks: RWLock[];
+    customIdLock: RWLock;
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    jobIndex: Map<JobId, JobLocation>;
+    completedJobs: BoundedSet<JobId>;
+    completedJobsData: BoundedMap<JobId, Job>;
+    depCompletions: DependencyCompletionTracker;
+    timedOutJobs: BoundedMap<JobId, RetiredTimeoutGeneration>;
+    retiredTimeoutLeaseTokens: BoundedMap<string, RetiredTimeoutGeneration>;
+    retiredCronLeaseTokens: BoundedMap<JobId, string>;
+    timeoutScheduler: JobTimeoutScheduler;
+    jobResults: LRUMap<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
+    customIdMap: LRUMap<string, JobId>;
+    jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    pendingDepChecks: Set<JobId>;
+    stalledCandidates: Set<JobId>;
+    jobLocks: Map<JobId, JobLock>;
+    clientJobs: Map<string, Set<JobId>>;
+    repeatChain: Map<JobId, JobId>;
+    queueNamesCache: Set<string>;
+    eventsManager: EventsManager;
+    webhookManager: WebhookManager;
+    workerManager: WorkerManager;
+    monitoringState: MonitoringState;
+    metrics: {
+        totalPushed: {
+            value: bigint;
+        };
+        totalPulled: {
+            value: bigint;
+        };
+        totalCompleted: {
+            value: bigint;
+        };
+        totalFailed: {
+            value: bigint;
+        };
+    };
+    startTime: number;
+    maxLogsPerJob: number;
+    perQueueMetrics: LRUMap<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+    failedChildrenValues: Map<JobId, Record<string, string>>;
+    ignoredChildrenFailures: Map<JobId, Record<string, string>>;
+    cronScheduler: CronScheduler;
+    operationalMetricsProvider: (() => OperationalMetrics) | null;
+}
+export interface QueueManagerRuntimeApi {
+    push(queue: string, input: JobInput): Promise<Job>;
+    fail(jobId: JobId, error?: string): Promise<AckOutcome>;
+    failWithReason(jobId: JobId, error: string | undefined, reason: FailureReason): Promise<AckOutcome>;
+    registerQueueName(queue: string): void;
+    unregisterQueueName(queue: string): void;
+    onJobCompleted(jobId: JobId): void;
+    onJobFailed(jobId: JobId): void;
+    onJobsCompleted(jobIds: JobId[]): void;
+    hasPendingDeps(): boolean;
+    emitDashboardEvent(event: string, data: Record<string, unknown>): void;
+    failParentOnChildFailure(job: Job, error: string | undefined): Promise<void>;
+    onChildDependencyOption(job: Job, error: string | undefined): Promise<void>;
+    onDlqEvicted(entry: DlqEntry): void;
+}
+export type QueueManagerRuntime = QueueManagerStateView & QueueManagerRuntimeApi;

package/dist/application/types/queueManager.js

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

package/dist/cli/commandRouter.d.ts

@@ -1,3 +1,3 @@
-export declare const CLI_NETWORK_COMMANDS: readonly ("push" | "fail" | "queue" | "dlq" | "job" | "cron" | "worker" | "concurrency" | "ping" | "stats" | "metrics" | "pull" | "ack" | "rate-limit" | "health" | "webhook")[];
+export declare const CLI_NETWORK_COMMANDS: readonly ("push" | "queue" | "cron" | "dlq" | "job" | "fail" | "worker" | "concurrency" | "stats" | "ping" | "metrics" | "pull" | "ack" | "rate-limit" | "health" | "webhook")[];
 /** Build the protocol command for a routed network CLI command. */
 export declare function buildCommand(command: string, args: string[]): Promise<Record<string, unknown> | null>;

package/dist/cli/commands/core.js

@@ -99,6 +99,7 @@ function buildPush(args) {
     const cmd = {
         cmd: 'PUSH',
         queue,
+        name: 'default',
         data,
     };
     // Add optional fields only if provided

package/dist/cli/output/collections.d.ts

@@ -0,0 +1,8 @@
+export declare function formatStats(stats: Record<string, unknown>): string;
+export declare function formatCounts(counts: Record<string, number>): string;
+export declare function formatQueues(queues: string[]): string;
+export declare function formatCronJobs(jobs: Record<string, unknown>[]): string;
+export declare function formatWorkers(workers: Record<string, unknown>[]): string;
+export declare function formatWebhooks(webhooks: Record<string, unknown>[]): string;
+export declare function formatDlqJobs(jobs: Record<string, unknown>[]): string;
+export declare function formatLogs(logs: Record<string, unknown>[]): string;

package/dist/cli/output/collections.js

@@ -0,0 +1,131 @@
+import { color, colors, stringifyValue as str } from './style';
+export function formatStats(stats) {
+    const lines = [
+        color('Server Statistics:', colors.bold),
+        '',
+        `  ${color('Waiting:', colors.cyan)}     ${str(stats.waiting, '0')}`,
+        `  ${color('Active:', colors.green)}      ${str(stats.active, '0')}`,
+        `  ${color('Delayed:', colors.yellow)}     ${str(stats.delayed, '0')}`,
+        `  ${color('Completed:', colors.dim)}   ${str(stats.completed, '0')}`,
+        `  ${color('Failed:', colors.red)}      ${str(stats.failed, '0')}`,
+        `  ${color('DLQ:', colors.red)}         ${str(stats.dlq, '0')}`,
+    ];
+    if (stats.totalPushed !== undefined) {
+        lines.push('', `  Total Pushed:    ${str(stats.totalPushed)}`);
+        lines.push(`  Total Pulled:    ${str(stats.totalPulled)}`);
+        lines.push(`  Total Completed: ${str(stats.totalCompleted)}`);
+        lines.push(`  Total Failed:    ${str(stats.totalFailed)}`);
+    }
+    if (stats.uptime !== undefined) {
+        const uptimeSeconds = typeof stats.uptime === 'number' ? Math.floor(stats.uptime / 1000) : stats.uptime;
+        lines.push('', `  ${color('Uptime:', colors.cyan)}      ${str(uptimeSeconds)}s`);
+    }
+    if (stats.pushPerSec !== undefined)
+        lines.push(`  Push/sec:    ${str(stats.pushPerSec)}`);
+    if (stats.pullPerSec !== undefined)
+        lines.push(`  Pull/sec:    ${str(stats.pullPerSec)}`);
+    return lines.join('\n');
+}
+export function formatCounts(counts) {
+    return Object.entries(counts)
+        .map(([key, value]) => `  ${key}: ${value}`)
+        .join('\n');
+}
+export function formatQueues(queues) {
+    if (queues.length === 0)
+        return color('No queues found', colors.yellow);
+    return queues.map((queue) => `  - ${queue}`).join('\n');
+}
+export function formatCronJobs(jobs) {
+    if (jobs.length === 0)
+        return color('No cron jobs found', colors.yellow);
+    return jobs
+        .map((job) => {
+        const schedule = job.schedule !== null && job.schedule !== undefined
+            ? str(job.schedule)
+            : `every ${str(job.repeatEvery)}ms`;
+        let output = `  ${color(str(job.name), colors.bold)}\n    Queue: ${str(job.queue)}\n    Schedule: ${schedule}\n    Executions: ${str(job.executions)}`;
+        if (typeof job.nextRun === 'number') {
+            output += `\n    Next run: ${new Date(job.nextRun).toISOString()}`;
+        }
+        if (job.maxLimit !== null && job.maxLimit !== undefined) {
+            output += `\n    Max: ${str(job.maxLimit)}`;
+        }
+        if (job.timezone !== null && job.timezone !== undefined) {
+            output += `\n    Timezone: ${str(job.timezone)}`;
+        }
+        return output;
+    })
+        .join('\n\n');
+}
+export function formatWorkers(workers) {
+    if (workers.length === 0)
+        return color('No workers registered', colors.yellow);
+    return workers
+        .map((worker) => {
+        const queues = Array.isArray(worker.queues) ? worker.queues.join(', ') : 'none';
+        const status = worker.status === 'stale'
+            ? color('[stale]', colors.red)
+            : worker.status !== undefined
+                ? color(`[${str(worker.status)}]`, colors.green)
+                : '';
+        const extra = [];
+        if (worker.concurrency !== undefined)
+            extra.push(`concurrency=${str(worker.concurrency)}`);
+        if (worker.activeJobs !== undefined)
+            extra.push(`active=${str(worker.activeJobs)}`);
+        if (worker.processedJobs !== undefined) {
+            extra.push(`processed=${str(worker.processedJobs)}/failed=${str(worker.failedJobs, '0')}`);
+        }
+        const extraText = extra.length > 0 ? `\n    ${extra.join(' ')}` : '';
+        return `  ${color(str(worker.id), colors.bold)}: ${str(worker.name)} ${status} (${queues})${extraText}`;
+    })
+        .join('\n');
+}
+export function formatWebhooks(webhooks) {
+    if (webhooks.length === 0)
+        return color('No webhooks registered', colors.yellow);
+    return webhooks
+        .map((webhook) => {
+        const events = Array.isArray(webhook.events)
+            ? webhook.events.join(', ')
+            : 'none';
+        const enabled = webhook.enabled === false ? ` ${color('[disabled]', colors.yellow)}` : '';
+        const queue = webhook.queue !== null && webhook.queue !== undefined
+            ? `\n    Queue: ${str(webhook.queue)}`
+            : '';
+        const counters = webhook.successCount !== undefined || webhook.failureCount !== undefined
+            ? `\n    Delivered: ${str(webhook.successCount, '0')} ok / ${str(webhook.failureCount, '0')} failed`
+            : '';
+        return `  ${color(str(webhook.id), colors.bold)}: ${str(webhook.url)}${enabled}\n    Events: ${events}${queue}${counters}`;
+    })
+        .join('\n\n');
+}
+export function formatDlqJobs(jobs) {
+    if (jobs.length === 0)
+        return color('DLQ is empty', colors.green);
+    return jobs
+        .map((job) => {
+        const id = str(job.jobId ?? job.id);
+        const failedAt = job.failedAt !== null && job.failedAt !== undefined
+            ? new Date(job.failedAt).toISOString()
+            : job.createdAt
+                ? new Date(job.createdAt).toISOString()
+                : 'unknown';
+        return `  ${color(id, colors.bold)}\n    Queue: ${str(job.queue)}\n    Error: ${color(str(job.error, 'Unknown'), colors.red)}\n    Failed: ${failedAt}`;
+    })
+        .join('\n\n');
+}
+export function formatLogs(logs) {
+    if (logs.length === 0)
+        return color('No logs found', colors.yellow);
+    return logs
+        .map((log) => {
+        const levelColor = log.level === 'error' ? colors.red : log.level === 'warn' ? colors.yellow : colors.dim;
+        const timestamp = log.timestamp !== null && log.timestamp !== undefined
+            ? new Date(log.timestamp).toISOString()
+            : 'unknown';
+        return `  [${timestamp}] ${color(str(log.level).toUpperCase(), levelColor)}: ${str(log.message)}`;
+    })
+        .join('\n');
+}

package/dist/cli/output/jobs.d.ts

@@ -0,0 +1,2 @@
+export declare function formatJob(job: Record<string, unknown>): string;
+export declare function formatJobsTable(jobs: Record<string, unknown>[]): string;

package/dist/cli/output/jobs.js

@@ -0,0 +1,61 @@
+import { color, colors, pad, stringifyValue as str } from './style';
+/** Infer a display state when the response does not include one. */
+function deriveJobState(job) {
+    if (typeof job.state === 'string' && job.state.length > 0)
+        return job.state;
+    const completedAt = typeof job.completedAt === 'number' ? job.completedAt : 0;
+    const startedAt = typeof job.startedAt === 'number' ? job.startedAt : 0;
+    const attempts = typeof job.attempts === 'number' ? job.attempts : 0;
+    const maxAttempts = typeof job.maxAttempts === 'number' ? job.maxAttempts : 0;
+    const runAt = typeof job.runAt === 'number' ? job.runAt : 0;
+    if (completedAt > 0)
+        return 'completed';
+    if (maxAttempts > 0 && attempts >= maxAttempts && startedAt > 0)
+        return 'unknown';
+    if (startedAt > 0)
+        return 'active';
+    if (runAt > Date.now())
+        return 'delayed';
+    if (runAt === 0 && startedAt === 0 && completedAt === 0)
+        return 'unknown';
+    return 'waiting';
+}
+export function formatJob(job) {
+    const lines = [
+        `${color('Job:', colors.bold)} ${str(job.id)}`,
+        `  Queue:      ${str(job.queue)}`,
+        `  State:      ${deriveJobState(job)}`,
+        `  Priority:   ${str(job.priority)}`,
+        `  Attempts:   ${str(job.attempts)}/${str(job.maxAttempts)}`,
+        `  Data:       ${JSON.stringify(job.data)}`,
+    ];
+    if (job.progress !== undefined && job.progress !== 0) {
+        lines.push(`  Progress:   ${str(job.progress)}%`);
+    }
+    if (job.createdAt)
+        lines.push(`  Created:    ${new Date(job.createdAt).toISOString()}`);
+    if (job.startedAt)
+        lines.push(`  Started:    ${new Date(job.startedAt).toISOString()}`);
+    if (job.error)
+        lines.push(`  Error:      ${color(str(job.error), colors.red)}`);
+    return lines.join('\n');
+}
+export function formatJobsTable(jobs) {
+    if (jobs.length === 0)
+        return color('No jobs found', colors.yellow);
+    const header = [
+        pad(color('ID', colors.bold), 20),
+        pad(color('Queue', colors.bold), 15),
+        pad(color('State', colors.bold), 12),
+        pad(color('Priority', colors.bold), 10),
+        color('Attempts', colors.bold),
+    ].join(' ');
+    const rows = jobs.map((job) => [
+        pad(str(job.id), 20),
+        pad(str(job.queue), 15),
+        pad(str(job.state, '-'), 12),
+        pad(str(job.priority), 10),
+        `${str(job.attempts)}/${str(job.maxAttempts)}`,
+    ].join(' '));
+    return [header, '-'.repeat(75), ...rows].join('\n');
+}

package/dist/cli/output/style.d.ts

@@ -0,0 +1,14 @@
+/** ANSI color codes used by CLI output. */
+export declare const colors: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly cyan: "\u001B[36m";
+};
+export declare function color(text: string, colorCode: string): string;
+export declare function stringifyValue(value: unknown, fallback?: string): string;
+export declare function pad(text: string, width: number): string;

package/dist/cli/output/style.js

@@ -0,0 +1,28 @@
+/** ANSI color codes used by CLI output. */
+export const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+const supportsColor = process.stdout.isTTY && Bun.env.NO_COLOR !== '1';
+export function color(text, colorCode) {
+    return supportsColor ? `${colorCode}${text}${colors.reset}` : text;
+}
+export function stringifyValue(value, fallback = '') {
+    if (value === null || value === undefined)
+        return fallback;
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return value.toString();
+}
+export function pad(text, width) {
+    const visualWidth = Bun.stringWidth(text);
+    return text + ' '.repeat(Math.max(0, width - visualWidth));
+}

package/dist/cli/output/success.d.ts

@@ -0,0 +1 @@
+export declare function formatSuccess(rawResponse: Record<string, unknown>, command: string, subcommand?: string): string;

package/dist/cli/output/success.js

@@ -0,0 +1,108 @@
+import { formatCounts, formatCronJobs, formatDlqJobs, formatLogs, formatQueues, formatStats, formatWebhooks, formatWorkers, } from './collections';
+import { formatJob, formatJobsTable } from './jobs';
+import { color, colors, stringifyValue as str } from './style';
+function unwrap(response) {
+    if ('data' in response &&
+        response.data &&
+        typeof response.data === 'object' &&
+        !Array.isArray(response.data)) {
+        return { ...response, ...response.data };
+    }
+    return response;
+}
+function formatCollection(response, command) {
+    if ('job' in response) {
+        return response.job === null
+            ? color('No job available', colors.yellow)
+            : formatJob(response.job);
+    }
+    if ('jobs' in response && Array.isArray(response.jobs)) {
+        return command === 'dlq'
+            ? formatDlqJobs(response.jobs)
+            : formatJobsTable(response.jobs);
+    }
+    if ('workers' in response && Array.isArray(response.workers)) {
+        return formatWorkers(response.workers);
+    }
+    if ('webhooks' in response && Array.isArray(response.webhooks)) {
+        return formatWebhooks(response.webhooks);
+    }
+    if ('crons' in response && Array.isArray(response.crons)) {
+        return formatCronJobs(response.crons);
+    }
+    if ('cronJobs' in response && Array.isArray(response.cronJobs)) {
+        return formatCronJobs(response.cronJobs);
+    }
+    if ('dlqJobs' in response && Array.isArray(response.dlqJobs)) {
+        return formatDlqJobs(response.dlqJobs);
+    }
+    if ('logs' in response && Array.isArray(response.logs)) {
+        return formatLogs(response.logs);
+    }
+    if ('stats' in response && typeof response.stats === 'object' && !Array.isArray(response.stats)) {
+        return formatStats(response.stats);
+    }
+    if ('counts' in response)
+        return formatCounts(response.counts);
+    if ('queues' in response && Array.isArray(response.queues) && !('workerId' in response)) {
+        return formatQueues(response.queues);
+    }
+    return null;
+}
+export function formatSuccess(rawResponse, command, subcommand) {
+    const response = unwrap(rawResponse);
+    if ('id' in response && typeof response.id === 'string' && command === 'push') {
+        return color(`Job created: ${response.id}`, colors.green);
+    }
+    if ('ids' in response && Array.isArray(response.ids)) {
+        const count = response.ids.length;
+        const ids = response.ids.join(', ');
+        let verb = 'Affected';
+        if (command === 'push')
+            verb = 'Created';
+        else if (command === 'queue')
+            verb = subcommand === 'drain' ? 'Drained' : 'Cleaned';
+        else if (command === 'dlq') {
+            verb = subcommand === 'retry' ? 'Retried' : subcommand === 'purge' ? 'Purged' : 'Affected';
+        }
+        return color(`${verb} ${count} jobs${ids ? ': ' + ids : ''}`, colors.green);
+    }
+    const collection = formatCollection(response, command);
+    if (collection !== null)
+        return collection;
+    if ('workerId' in response) {
+        return color(`Worker registered: ${str(response.workerId)}`, colors.green);
+    }
+    if ('webhookId' in response) {
+        return color(`Webhook added: ${str(response.webhookId)}`, colors.green);
+    }
+    if ('cron' in response && response.cron !== null && typeof response.cron === 'object') {
+        const cron = response.cron;
+        const next = typeof cron.nextRun === 'number'
+            ? ` (next run: ${new Date(cron.nextRun).toISOString()})`
+            : '';
+        return color(`Cron scheduled: ${str(cron.name)}${next}`, colors.green);
+    }
+    if ('state' in response)
+        return `State: ${str(response.state)}`;
+    if ('result' in response) {
+        if (response.result === undefined || response.result === null) {
+            return color('No result available (job not completed or result was removed)', colors.yellow);
+        }
+        return `Result: ${JSON.stringify(response.result, null, 2)}`;
+    }
+    if ('progress' in response) {
+        const message = response.message ? ` - ${str(response.message)}` : '';
+        return `Progress: ${str(response.progress)}%${message}`;
+    }
+    if ('paused' in response) {
+        return response.paused
+            ? color('Queue is paused', colors.yellow)
+            : color('Queue is active', colors.green);
+    }
+    if ('count' in response)
+        return `Count: ${str(response.count)}`;
+    if ('metrics' in response && typeof response.metrics === 'string')
+        return response.metrics;
+    return color('OK', colors.green);
+}

package/dist/cli/output.d.ts

@@ -1,8 +1,3 @@
-/**
- * CLI Output Formatting
- * Formats command responses for terminal display
- */
-/** Main output formatter */
+/** Public CLI output formatting API. */
 export declare function formatOutput(response: Record<string, unknown>, command: string, asJson: boolean, subcommand?: string): string;
-/** Format error message */
 export declare function formatError(message: string, asJson: boolean): string;