bunqueue 2.8.53 → 2.8.56

package/dist/mcp/adapter.js

@@ -1,782 +1,10 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-condition, @typescript-eslint/no-unnecessary-type-conversion, @typescript-eslint/no-base-to-string, @typescript-eslint/prefer-readonly */
-/**
- * MCP Backend Adapter
- * Abstraction layer for embedded (SQLite direct) and TCP (remote server) modes.
- */
-import { jobId as toJobId } from '../domain/types/job';
-/** Serialize a Job to a plain object */
-function serializeJob(job) {
-    return {
-        id: String(job.id),
-        queue: job.queue,
-        data: job.data,
-        priority: job.priority,
-        progress: job.progress,
-        attempts: job.attempts,
-        maxAttempts: job.maxAttempts,
-        createdAt: new Date(job.createdAt).toISOString(),
-        startedAt: job.startedAt ? new Date(job.startedAt).toISOString() : undefined,
-    };
-}
-function serializeCron(c) {
-    return {
-        name: c.name,
-        queue: c.queue,
-        schedule: c.schedule ?? undefined,
-        repeatEvery: c.repeatEvery ?? undefined,
-        nextRun: c.nextRun ? new Date(c.nextRun).toISOString() : null,
-        executions: c.executions,
-    };
-}
-// ============ Embedded Backend ============
-import { getSharedManager, shutdownManager } from '../client/manager';
-import { FlowProducer } from '../client/flow';
-/** Convert a JobNode tree to FlowNodeResult */
-function toFlowNodeResult(node) {
-    return {
-        jobId: node.job.id,
-        name: node.job.name,
-        queueName: node.job.queueName,
-        children: node.children?.map(toFlowNodeResult),
-    };
-}
-export class EmbeddedBackend {
-    flowProducer = null;
-    getFlowProducer() {
-        this.flowProducer ??= new FlowProducer({ embedded: true });
-        return this.flowProducer;
-    }
-    get manager() {
-        return getSharedManager();
-    }
-    async addJob(queue, name, data, opts) {
-        const job = await this.manager.push(queue, {
-            data: { name, ...data },
-            priority: opts?.priority,
-            delay: opts?.delay,
-            maxAttempts: opts?.attempts,
-        });
-        return { jobId: String(job.id) };
-    }
-    async addJobsBulk(queue, jobs) {
-        const inputs = jobs.map((j) => ({
-            data: { name: j.name, ...j.data },
-            priority: j.priority,
-            delay: j.delay,
-        }));
-        const ids = await this.manager.pushBatch(queue, inputs);
-        return { jobIds: ids.map(String) };
-    }
-    async getJob(id) {
-        const job = await this.manager.getJob(toJobId(id));
-        return job ? serializeJob(job) : null;
-    }
-    getJobState(id) {
-        return Promise.resolve(this.manager.getJobState(toJobId(id)));
-    }
-    getJobResult(id) {
-        return Promise.resolve(this.manager.getResult(toJobId(id)));
-    }
-    cancelJob(id) {
-        return Promise.resolve(this.manager.cancel(toJobId(id)));
-    }
-    promoteJob(id) {
-        return Promise.resolve(this.manager.promote(toJobId(id)));
-    }
-    updateProgress(id, progress, message) {
-        return Promise.resolve(this.manager.updateProgress(toJobId(id), progress, message));
-    }
-    updateJobData(id, data) {
-        return Promise.resolve(this.manager.updateJobData(toJobId(id), data));
-    }
-    changeJobPriority(id, priority) {
-        return Promise.resolve(this.manager.changePriority(toJobId(id), priority));
-    }
-    moveToDelayed(id, delay) {
-        return Promise.resolve(this.manager.moveToDelayed(toJobId(id), delay));
-    }
-    discardJob(id) {
-        return Promise.resolve(this.manager.discard(toJobId(id)));
-    }
-    getChildrenValues(parentJobId) {
-        return Promise.resolve(this.manager.getChildrenValues(toJobId(parentJobId)));
-    }
-    getJobByCustomId(customId) {
-        const job = this.manager.getJobByCustomId(customId);
-        return Promise.resolve(job ? serializeJob(job) : null);
-    }
-    waitForJobCompletion(id, timeoutMs) {
-        return this.manager.waitForJobCompletion(toJobId(id), timeoutMs);
-    }
-    async pullJob(queue, timeoutMs) {
-        const job = await this.manager.pull(queue, timeoutMs);
-        return job ? serializeJob(job) : null;
-    }
-    async pullJobBatch(queue, count, timeoutMs) {
-        const jobs = await this.manager.pullBatch(queue, count, timeoutMs);
-        return jobs.map(serializeJob);
-    }
-    async ackJob(id, result) {
-        await this.manager.ack(toJobId(id), result);
-    }
-    async ackJobBatch(ids) {
-        await this.manager.ackBatch(ids.map(toJobId));
-    }
-    async failJob(id, error) {
-        await this.manager.fail(toJobId(id), error);
-    }
-    jobHeartbeat(id) {
-        return Promise.resolve(this.manager.jobHeartbeat(toJobId(id)));
-    }
-    jobHeartbeatBatch(ids) {
-        return Promise.resolve(this.manager.jobHeartbeatBatch(ids.map(toJobId)));
-    }
-    getProgress(id) {
-        return Promise.resolve(this.manager.getProgress(toJobId(id)));
-    }
-    changeDelay(id, delay) {
-        return Promise.resolve(this.manager.changeDelay(toJobId(id), delay));
-    }
-    extendLock(id, token, duration) {
-        return Promise.resolve(this.manager.extendLock(toJobId(id), token, duration));
-    }
-    getJobs(queue, opts) {
-        const jobs = this.manager.getJobs(queue, {
-            state: opts?.state,
-            start: opts?.start,
-            end: opts?.end,
-        });
-        return Promise.resolve(jobs.map(serializeJob));
-    }
-    getJobCounts(queue) {
-        const counts = this.manager.getQueueJobCounts(queue);
-        const isPaused = this.manager.isPaused(queue);
-        return Promise.resolve({
-            waiting: counts.waiting,
-            prioritized: counts.prioritized,
-            delayed: counts.delayed,
-            active: counts.active,
-            completed: counts.completed,
-            failed: counts.failed,
-            paused: isPaused ? counts.waiting : 0,
-        });
-    }
-    pauseQueue(queue) {
-        this.manager.pause(queue);
-        return Promise.resolve();
-    }
-    resumeQueue(queue) {
-        this.manager.resume(queue);
-        return Promise.resolve();
-    }
-    drainQueue(queue) {
-        return Promise.resolve(this.manager.drain(queue));
-    }
-    obliterateQueue(queue) {
-        this.manager.obliterate(queue);
-        return Promise.resolve();
-    }
-    listQueues() {
-        return Promise.resolve(this.manager.listQueues());
-    }
-    countJobs(queue) {
-        return Promise.resolve(this.manager.count(queue));
-    }
-    cleanQueue(queue, graceMs, state, limit) {
-        return Promise.resolve(this.manager.clean(queue, graceMs, state, limit));
-    }
-    isPaused(queue) {
-        return Promise.resolve(this.manager.isPaused(queue));
-    }
-    getCountsPerPriority(queue) {
-        return Promise.resolve(this.manager.getCountsPerPriority(queue));
-    }
-    getDlq(queue, limit) {
-        return Promise.resolve(this.manager.getDlq(queue, limit).map(serializeJob));
-    }
-    retryDlq(queue, id) {
-        return Promise.resolve(this.manager.retryDlq(queue, id ? toJobId(id) : undefined));
-    }
-    purgeDlq(queue) {
-        return Promise.resolve(this.manager.purgeDlq(queue));
-    }
-    retryCompleted(queue, id) {
-        return Promise.resolve(this.manager.retryCompleted(queue, id ? toJobId(id) : undefined));
-    }
-    setRateLimit(queue, limit) {
-        this.manager.setRateLimit(queue, limit);
-        return Promise.resolve();
-    }
-    clearRateLimit(queue) {
-        this.manager.clearRateLimit(queue);
-        return Promise.resolve();
-    }
-    setConcurrency(queue, limit) {
-        this.manager.setConcurrency(queue, limit);
-        return Promise.resolve();
-    }
-    clearConcurrency(queue) {
-        this.manager.clearConcurrency(queue);
-        return Promise.resolve();
-    }
-    addCron(input) {
-        const cron = this.manager.addCron(input);
-        return Promise.resolve(serializeCron(cron));
-    }
-    listCrons() {
-        return Promise.resolve(this.manager.listCrons().map(serializeCron));
-    }
-    getCron(name) {
-        const cron = this.manager.getCron(name);
-        return Promise.resolve(cron ? serializeCron(cron) : null);
-    }
-    deleteCron(name) {
-        return Promise.resolve(this.manager.removeCron(name));
-    }
-    addWebhook(url, events, queue) {
-        const wh = this.manager.webhookManager.add(url, events, queue);
-        return Promise.resolve({
-            id: String(wh.id),
-            url: wh.url,
-            events: wh.events,
-            queue: wh.queue ?? undefined,
-            enabled: wh.enabled,
-        });
-    }
-    removeWebhook(id) {
-        return Promise.resolve(this.manager.webhookManager.remove(id));
-    }
-    listWebhooks() {
-        return Promise.resolve(this.manager.webhookManager.list().map((wh) => ({
-            id: String(wh.id),
-            url: wh.url,
-            events: wh.events,
-            queue: wh.queue ?? undefined,
-            enabled: wh.enabled,
-        })));
-    }
-    setWebhookEnabled(id, enabled) {
-        return Promise.resolve(this.manager.webhookManager.setEnabled(id, enabled));
-    }
-    registerWorker(name, queues) {
-        const w = this.manager.workerManager.register(name, queues);
-        return Promise.resolve({
-            id: String(w.id),
-            name: w.name,
-            queues: w.queues,
-            active: w.activeJobs,
-            processed: w.processedJobs,
-            failed: w.failedJobs,
-            lastHeartbeat: w.lastSeen,
-        });
-    }
-    unregisterWorker(id) {
-        return Promise.resolve(this.manager.workerManager.unregister(id));
-    }
-    workerHeartbeat(id) {
-        return Promise.resolve(this.manager.workerManager.heartbeat(id));
-    }
-    getStats() {
-        const stats = this.manager.getStats();
-        return Promise.resolve(JSON.parse(JSON.stringify(stats, (_key, value) => typeof value === 'bigint' ? Number(value) : value)));
-    }
-    listWorkers() {
-        return Promise.resolve(this.manager.workerManager.list().map((w) => ({
-            id: String(w.id),
-            name: w.name,
-            queues: w.queues,
-            active: w.activeJobs,
-            processed: w.processedJobs,
-            failed: w.failedJobs,
-            lastHeartbeat: w.lastSeen,
-        })));
-    }
-    getJobLogs(id) {
-        return Promise.resolve(this.manager.getLogs(toJobId(id)));
-    }
-    addJobLog(id, message, level) {
-        return Promise.resolve(this.manager.addLog(toJobId(id), message, level));
-    }
-    getPerQueueStats() {
-        const stats = this.manager.getPerQueueStats();
-        const result = {};
-        for (const [k, v] of stats)
-            result[k] = v;
-        return Promise.resolve(result);
-    }
-    getMemoryStats() {
-        return Promise.resolve(this.manager.getMemoryStats());
-    }
-    getPrometheusMetrics() {
-        return Promise.resolve(this.manager.getPrometheusMetrics());
-    }
-    getStorageStatus() {
-        const status = this.manager.getStorageStatus();
-        return Promise.resolve({ diskFull: status.diskFull, error: status.error });
-    }
-    clearJobLogs(id, keepLogs) {
-        this.manager.clearLogs(toJobId(id), keepLogs);
-        return Promise.resolve();
-    }
-    compactMemory() {
-        this.manager.compactMemory();
-        return Promise.resolve();
-    }
-    async addFlow(flow) {
-        const node = await this.getFlowProducer().add(flow);
-        return toFlowNodeResult(node);
-    }
-    async addFlowChain(steps) {
-        return this.getFlowProducer().addChain(steps);
-    }
-    async addFlowBulkThen(parallel, final) {
-        return this.getFlowProducer().addBulkThen(parallel, final);
-    }
-    async getFlow(id, queueName, depth, maxChildren) {
-        const node = await this.getFlowProducer().getFlow({ id, queueName, depth, maxChildren });
-        return node ? toFlowNodeResult(node) : null;
-    }
-    shutdown() {
-        this.flowProducer?.close();
-        shutdownManager();
-    }
-}
-// ============ TCP Backend ============
-import { TcpConnectionPool } from '../client/tcpPool';
-export class TcpBackend {
-    pool;
-    flowProducer = null;
-    connOpts;
-    constructor(opts) {
-        this.connOpts = opts;
-        this.pool = new TcpConnectionPool({
-            host: opts.host ?? 'localhost',
-            port: opts.port ?? 6789,
-            token: opts.token,
-            poolSize: Number(process.env.BUNQUEUE_POOL_SIZE) || 2,
-        });
-    }
-    async connect() {
-        await this.pool.connect();
-    }
-    getFlowProducer() {
-        this.flowProducer ??= new FlowProducer({
-            connection: {
-                host: this.connOpts.host,
-                port: this.connOpts.port,
-                token: this.connOpts.token,
-            },
-        });
-        return this.flowProducer;
-    }
-    async send(cmd) {
-        return this.pool.send(cmd);
-    }
-    parseJob(j) {
-        return {
-            id: String(j.id),
-            queue: j.queue ?? '',
-            data: j.data,
-            priority: j.priority ?? 0,
-            progress: j.progress ?? 0,
-            attempts: j.attempts ?? 0,
-            maxAttempts: j.maxAttempts ?? 3,
-            createdAt: j.createdAt
-                ? new Date(j.createdAt).toISOString()
-                : new Date().toISOString(),
-            startedAt: j.startedAt ? new Date(j.startedAt).toISOString() : undefined,
-        };
-    }
-    async addJob(queue, name, data, opts) {
-        const res = await this.send({
-            cmd: 'PUSH',
-            queue,
-            data: { name, ...data },
-            priority: opts?.priority,
-            delay: opts?.delay,
-            maxAttempts: opts?.attempts,
-        });
-        return { jobId: String(res.id) };
-    }
-    async addJobsBulk(queue, jobs) {
-        const res = await this.send({
-            cmd: 'PUSHB',
-            queue,
-            jobs: jobs.map((j) => ({
-                data: { name: j.name, ...j.data },
-                priority: j.priority,
-                delay: j.delay,
-            })),
-        });
-        return { jobIds: (res.ids ?? []).map(String) };
-    }
-    async getJob(id) {
-        const res = await this.send({ cmd: 'GetJob', id });
-        if (!res.job)
-            return null;
-        return this.parseJob(res.job);
-    }
-    async getJobState(id) {
-        const res = await this.send({ cmd: 'GetState', id });
-        return res.state ?? 'unknown';
-    }
-    async getJobResult(id) {
-        const res = await this.send({ cmd: 'GetResult', id });
-        return res.result;
-    }
-    async cancelJob(id) {
-        const res = await this.send({ cmd: 'Cancel', id });
-        return res.ok ?? false;
-    }
-    async promoteJob(id) {
-        const res = await this.send({ cmd: 'Promote', id });
-        return res.ok ?? false;
-    }
-    async updateProgress(id, progress, message) {
-        const res = await this.send({ cmd: 'Progress', id, progress, message });
-        return res.ok ?? false;
-    }
-    async updateJobData(id, data) {
-        const res = await this.send({ cmd: 'Update', id, data });
-        return res.ok ?? false;
-    }
-    async changeJobPriority(id, priority) {
-        const res = await this.send({ cmd: 'ChangePriority', id, priority });
-        return res.ok ?? false;
-    }
-    async moveToDelayed(id, delay) {
-        const res = await this.send({ cmd: 'MoveToDelayed', id, delay });
-        return res.ok ?? false;
-    }
-    async discardJob(id) {
-        const res = await this.send({ cmd: 'Discard', id });
-        return res.ok ?? false;
-    }
-    async getChildrenValues(parentJobId) {
-        const res = await this.send({ cmd: 'GetChildrenValues', id: parentJobId });
-        const data = res.data;
-        return (data?.values ?? {});
-    }
-    async getJobByCustomId(customId) {
-        const res = await this.send({ cmd: 'GetJobByCustomId', customId });
-        if (!res.job)
-            return null;
-        return this.parseJob(res.job);
-    }
-    async waitForJobCompletion(id, timeoutMs) {
-        const res = await this.send({ cmd: 'WaitJob', id, timeout: timeoutMs });
-        return res.ok ?? false;
-    }
-    async getProgress(id) {
-        const res = await this.send({ cmd: 'GetProgress', id });
-        if (res.progress === undefined)
-            return null;
-        return {
-            progress: res.progress ?? 0,
-            message: res.message ?? null,
-        };
-    }
-    async changeDelay(id, delay) {
-        const res = await this.send({ cmd: 'MoveToDelayed', id, delay });
-        return res.ok ?? false;
-    }
-    async extendLock(id, token, duration) {
-        const res = await this.send({ cmd: 'JobHeartbeat', id, token, duration });
-        return res.ok ?? false;
-    }
-    async pullJob(queue, timeoutMs) {
-        const res = await this.send({ cmd: 'PULL', queue, timeout: timeoutMs });
-        if (!res.job)
-            return null;
-        return this.parseJob(res.job);
-    }
-    async pullJobBatch(queue, count, timeoutMs) {
-        const res = await this.send({ cmd: 'PULLB', queue, count, timeout: timeoutMs });
-        return (res.jobs ?? []).map((j) => this.parseJob(j));
-    }
-    async ackJob(id, result) {
-        await this.send({ cmd: 'ACK', id, result });
-    }
-    async ackJobBatch(ids) {
-        await this.send({ cmd: 'ACKB', ids });
-    }
-    async failJob(id, error) {
-        await this.send({ cmd: 'FAIL', id, error });
-    }
-    async jobHeartbeat(id) {
-        const res = await this.send({ cmd: 'JobHeartbeat', id });
-        return res.ok ?? false;
-    }
-    async jobHeartbeatBatch(ids) {
-        const res = await this.send({ cmd: 'JobHeartbeatB', ids });
-        return res.count ?? 0;
-    }
-    async getJobs(queue, opts) {
-        // The TCP protocol uses offset/limit; the MCP tool exposes start/end.
-        // Translate so pagination actually takes effect (issue #87).
-        const start = opts?.start ?? 0;
-        const hasEnd = opts?.end !== undefined && opts.end >= 0;
-        const res = await this.send({
-            cmd: 'GetJobs',
-            queue,
-            state: opts?.state,
-            offset: start,
-            limit: hasEnd ? Math.max(0, opts.end - start) : undefined,
-        });
-        return (res.jobs ?? []).map((j) => this.parseJob(j));
-    }
-    async getJobCounts(queue) {
-        const res = await this.send({ cmd: 'GetJobCounts', queue });
-        // Server nests the counts under `counts` (resp.counts envelope).
-        const c = res.counts ?? {};
-        return {
-            waiting: c.waiting ?? 0,
-            prioritized: c.prioritized ?? 0,
-            delayed: c.delayed ?? 0,
-            active: c.active ?? 0,
-            completed: c.completed ?? 0,
-            failed: c.failed ?? 0,
-            paused: c.paused ?? 0,
-        };
-    }
-    async pauseQueue(queue) {
-        await this.send({ cmd: 'Pause', queue });
-    }
-    async resumeQueue(queue) {
-        await this.send({ cmd: 'Resume', queue });
-    }
-    async drainQueue(queue) {
-        const res = await this.send({ cmd: 'Drain', queue });
-        return res.removed ?? 0;
-    }
-    async obliterateQueue(queue) {
-        await this.send({ cmd: 'Obliterate', queue });
-    }
-    async listQueues() {
-        const res = await this.send({ cmd: 'ListQueues' });
-        return res.queues ?? [];
-    }
-    async countJobs(queue) {
-        const res = await this.send({ cmd: 'Count', queue });
-        return res.count ?? 0;
-    }
-    async cleanQueue(queue, graceMs, state, limit) {
-        const res = await this.send({ cmd: 'Clean', queue, grace: graceMs, state, limit });
-        return res.ids ?? [];
-    }
-    async isPaused(queue) {
-        const res = await this.send({ cmd: 'IsPaused', queue });
-        return res.paused ?? false;
-    }
-    async getCountsPerPriority(queue) {
-        const res = await this.send({ cmd: 'GetCountsPerPriority', queue });
-        return res.counts ?? {};
-    }
-    async getDlq(queue, limit) {
-        const res = await this.send({ cmd: 'Dlq', queue, count: limit });
-        return (res.jobs ?? []).map((j) => this.parseJob(j));
-    }
-    async retryDlq(queue, id) {
-        const res = await this.send({ cmd: 'RetryDlq', queue, id });
-        return res.retried ?? 0;
-    }
-    async purgeDlq(queue) {
-        const res = await this.send({ cmd: 'PurgeDlq', queue });
-        return res.purged ?? 0;
-    }
-    async retryCompleted(queue, id) {
-        const res = await this.send({ cmd: 'RetryCompleted', queue, id });
-        return res.retried ?? 0;
-    }
-    async setRateLimit(queue, limit) {
-        await this.send({ cmd: 'RateLimit', queue, limit });
-    }
-    async clearRateLimit(queue) {
-        await this.send({ cmd: 'RateLimitClear', queue });
-    }
-    async setConcurrency(queue, limit) {
-        await this.send({ cmd: 'SetConcurrency', queue, limit });
-    }
-    async clearConcurrency(queue) {
-        await this.send({ cmd: 'ClearConcurrency', queue });
-    }
-    async addCron(input) {
-        const res = await this.send({ cmd: 'Cron', ...input });
-        return {
-            name: input.name,
-            queue: input.queue,
-            schedule: input.schedule ?? undefined,
-            repeatEvery: input.repeatEvery ?? undefined,
-            nextRun: res.nextRun ? new Date(res.nextRun).toISOString() : null,
-            executions: 0,
-        };
-    }
-    async listCrons() {
-        const res = await this.send({ cmd: 'CronList' });
-        return (res.crons ?? []).map((c) => ({
-            name: c.name,
-            queue: c.queue,
-            schedule: c.schedule,
-            repeatEvery: c.repeatEvery,
-            nextRun: c.nextRun ? new Date(c.nextRun).toISOString() : null,
-            executions: c.executions ?? 0,
-        }));
-    }
-    async getCron(name) {
-        const res = await this.send({ cmd: 'CronGet', name });
-        if (!res.ok)
-            return null;
-        const c = res.cron;
-        if (!c)
-            return null;
-        return {
-            name: c.name,
-            queue: c.queue,
-            schedule: c.schedule,
-            repeatEvery: c.repeatEvery,
-            nextRun: c.nextRun ? new Date(c.nextRun).toISOString() : null,
-            executions: c.executions ?? 0,
-        };
-    }
-    async deleteCron(name) {
-        const res = await this.send({ cmd: 'CronDelete', name });
-        return res.ok ?? true;
-    }
-    async addWebhook(url, events, queue) {
-        const res = await this.send({ cmd: 'AddWebhook', url, events, queue });
-        return { id: String(res.id ?? '0'), url, events, queue, enabled: true };
-    }
-    async removeWebhook(id) {
-        const res = await this.send({ cmd: 'RemoveWebhook', id });
-        return res.ok ?? true;
-    }
-    async listWebhooks() {
-        const res = await this.send({ cmd: 'ListWebhooks' });
-        return (res.webhooks ?? []).map((wh) => ({
-            id: String(wh.id),
-            url: wh.url,
-            events: wh.events ?? [],
-            queue: wh.queue,
-            enabled: wh.enabled ?? true,
-        }));
-    }
-    async getStats() {
-        return this.send({ cmd: 'Stats' });
-    }
-    async listWorkers() {
-        const res = await this.send({ cmd: 'ListWorkers' });
-        // Server nests workers under `data` (resp.data envelope).
-        const data = res.data;
-        const workers = data?.workers ?? res.workers ?? [];
-        return workers.map((w) => ({
-            id: String(w.id),
-            name: w.name,
-            queues: w.queues ?? [],
-            active: w.activeJobs ?? 0,
-            processed: w.processedJobs ?? w.processed ?? 0,
-            failed: w.failedJobs ?? w.failed ?? 0,
-            lastHeartbeat: w.lastSeen ?? w.lastHeartbeat ?? 0,
-        }));
-    }
-    async getJobLogs(id) {
-        const res = await this.send({ cmd: 'GetLogs', id });
-        return res.logs ?? [];
-    }
-    async addJobLog(id, message, level) {
-        const res = await this.send({ cmd: 'AddLog', id, message, level });
-        return res.ok ?? true;
-    }
-    async setWebhookEnabled(id, enabled) {
-        const res = await this.send({ cmd: 'SetWebhookEnabled', id, enabled });
-        return res.ok ?? true;
-    }
-    async registerWorker(name, queues) {
-        const res = await this.send({ cmd: 'RegisterWorker', name, queues });
-        return {
-            id: String(res.id ?? '0'),
-            name,
-            queues,
-            active: 0,
-            processed: 0,
-            failed: 0,
-            lastHeartbeat: Date.now(),
-        };
-    }
-    async unregisterWorker(id) {
-        const res = await this.send({ cmd: 'UnregisterWorker', workerId: id });
-        return res.ok ?? true;
-    }
-    async workerHeartbeat(id) {
-        const res = await this.send({ cmd: 'Heartbeat', id });
-        return res.ok ?? true;
-    }
-    async getPerQueueStats() {
-        // `Metrics` returns global aggregates, not a per-queue breakdown.
-        // Use `DashboardQueues`, which carries real per-queue stats (issue #87).
-        const res = await this.send({ cmd: 'DashboardQueues' });
-        const data = res.data;
-        const queues = data?.queues ?? [];
-        const result = {};
-        for (const q of queues) {
-            const name = q.name;
-            if (typeof name !== 'string')
-                continue;
-            // Match EmbeddedBackend shape: { waiting, prioritized, delayed, active, dlq }
-            result[name] = {
-                waiting: q.waiting ?? 0,
-                prioritized: q.prioritized ?? 0,
-                delayed: q.delayed ?? 0,
-                active: q.active ?? 0,
-                dlq: q.dlq ?? 0,
-            };
-        }
-        return result;
-    }
-    async getMemoryStats() {
-        const res = await this.send({ cmd: 'Stats' });
-        return res.memory ?? {};
-    }
-    async getPrometheusMetrics() {
-        const res = await this.send({ cmd: 'Prometheus' });
-        return res.metrics ?? '';
-    }
-    async clearJobLogs(id, _keepLogs) {
-        await this.send({ cmd: 'ClearLogs', id });
-    }
-    async compactMemory() {
-        await this.send({ cmd: 'CompactMemory' });
-    }
-    async getStorageStatus() {
-        const res = await this.send({ cmd: 'StorageStatus' });
-        const data = res.data;
-        return {
-            diskFull: data?.diskFull ?? false,
-            error: data?.error ?? null,
-        };
-    }
-    async addFlow(flow) {
-        const node = await this.getFlowProducer().add(flow);
-        return toFlowNodeResult(node);
-    }
-    async addFlowChain(steps) {
-        return this.getFlowProducer().addChain(steps);
-    }
-    async addFlowBulkThen(parallel, final) {
-        return this.getFlowProducer().addBulkThen(parallel, final);
-    }
-    async getFlow(id, queueName, depth, maxChildren) {
-        const node = await this.getFlowProducer().getFlow({ id, queueName, depth, maxChildren });
-        return node ? toFlowNodeResult(node) : null;
-    }
-    shutdown() {
-        this.flowProducer?.close();
-        this.pool.close();
-    }
-}
-/** Create backend based on environment configuration */
+/** MCP backend selection and public adapter API. */
+import { EmbeddedBackend } from './backend/embedded';
+import { TcpBackend } from './backend/tcp';
+export { EmbeddedBackend } from './backend/embedded';
+export { TcpBackend } from './backend/tcp';
 export async function createBackend() {
-    const mode = process.env.BUNQUEUE_MODE ?? 'embedded';
-    if (mode === 'tcp') {
+    if ((process.env.BUNQUEUE_MODE ?? 'embedded') === 'tcp') {
         const backend = new TcpBackend({
             host: process.env.BUNQUEUE_HOST,
             port: process.env.BUNQUEUE_PORT ? parseInt(process.env.BUNQUEUE_PORT, 10) : undefined,