workmatic 1.0.7 → 1.1.1

package/dist/cli.js

@@ -1,12 +1,751 @@
 #!/usr/bin/env node
 
-// src/cli.ts
-import Database from "better-sqlite3";
+// src/cli/handlers.ts
+import Database2 from "better-sqlite3";
 import { createReadStream, createWriteStream } from "fs";
+import { finished } from "stream/promises";
 import { createInterface } from "readline";
 import Table from "cli-table3";
-var args = process.argv.slice(2);
-var command = args[0];
+
+// src/database.ts
+import Database from "better-sqlite3";
+import { Kysely, SqliteDialect } from "kysely";
+var kyselyToSqlite = /* @__PURE__ */ new WeakMap();
+function createDatabase(options = {}) {
+  let sqliteDb;
+  if (options.db) {
+    sqliteDb = options.db;
+  } else {
+    const filename = options.filename ?? ":memory:";
+    sqliteDb = new Database(filename);
+  }
+  sqliteDb.pragma("journal_mode = WAL");
+  sqliteDb.pragma("synchronous = NORMAL");
+  sqliteDb.pragma("busy_timeout = 5000");
+  const db = new Kysely({
+    dialect: new SqliteDialect({
+      database: sqliteDb
+    })
+  });
+  createSchema(sqliteDb);
+  kyselyToSqlite.set(db, sqliteDb);
+  return db;
+}
+function createSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workmatic_jobs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      public_id TEXT UNIQUE NOT NULL,
+      queue TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'ready',
+      priority INTEGER NOT NULL DEFAULT 0,
+      run_at INTEGER NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      max_attempts INTEGER NOT NULL DEFAULT 3,
+      lease_until INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      last_error TEXT
+    )
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workmatic_jobs_claim 
+    ON workmatic_jobs (queue, status, run_at, priority, id)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workmatic_jobs_lease 
+    ON workmatic_jobs (status, lease_until)
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workmatic_settings (
+      queue TEXT PRIMARY KEY,
+      paused INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db.exec(`
+    UPDATE workmatic_jobs SET status = 'dead' WHERE status = 'failed'
+  `);
+}
+
+// src/orchestrator.ts
+import { sql as sql3 } from "kysely";
+
+// src/client.ts
+import { nanoid } from "nanoid";
+import { sql } from "kysely";
+
+// src/utils.ts
+var defaultBackoff = (attempts) => {
+  return 1e3 * Math.pow(2, attempts);
+};
+function validatePayload(payload) {
+  try {
+    return JSON.stringify(payload);
+  } catch (error) {
+    throw new Error(
+      `Payload is not JSON-serializable: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function parsePayload(json) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON payload: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function now() {
+  return Date.now();
+}
+
+// src/client.ts
+function createClient(options) {
+  const { db, queue = "default" } = options;
+  if (!db) {
+    throw new Error("Database instance is required");
+  }
+  return {
+    /**
+     * Add a job to the queue
+     */
+    async add(payload, opts = {}) {
+      const {
+        priority = 0,
+        delayMs = 0,
+        maxAttempts = 3
+      } = opts;
+      const payloadJson = validatePayload(payload);
+      const publicId = nanoid();
+      const timestamp = now();
+      const runAt = timestamp + delayMs;
+      await db.insertInto("workmatic_jobs").values({
+        public_id: publicId,
+        queue,
+        payload: payloadJson,
+        status: "ready",
+        priority,
+        run_at: runAt,
+        attempts: 0,
+        max_attempts: maxAttempts,
+        lease_until: 0,
+        created_at: timestamp,
+        updated_at: timestamp,
+        last_error: null
+      }).execute();
+      return { ok: true, id: publicId };
+    },
+    async addMany(payloads, opts = {}) {
+      const {
+        priority = 0,
+        delayMs = 0,
+        maxAttempts = 3
+      } = opts;
+      if (payloads.length === 0) {
+        return { ok: true, ids: [] };
+      }
+      const timestamp = now();
+      const runAt = timestamp + delayMs;
+      return await db.transaction().execute(async (trx) => {
+        const ids = [];
+        const rows = payloads.map((payload) => {
+          const payloadJson = validatePayload(payload);
+          const publicId = nanoid();
+          ids.push(publicId);
+          return {
+            public_id: publicId,
+            queue,
+            payload: payloadJson,
+            status: "ready",
+            priority,
+            run_at: runAt,
+            attempts: 0,
+            max_attempts: maxAttempts,
+            lease_until: 0,
+            created_at: timestamp,
+            updated_at: timestamp,
+            last_error: null
+          };
+        });
+        await trx.insertInto("workmatic_jobs").values(rows).execute();
+        return { ok: true, ids };
+      });
+    },
+    /**
+     * Get job statistics for the queue
+     */
+    async stats() {
+      const result = await db.selectFrom("workmatic_jobs").select([
+        "status",
+        sql`count(*)`.as("count")
+      ]).where("queue", "=", queue).groupBy("status").execute();
+      const stats = {
+        ready: 0,
+        running: 0,
+        done: 0,
+        dead: 0,
+        total: 0
+      };
+      for (const row of result) {
+        const status = row.status;
+        const count = Number(row.count);
+        if (status in stats) {
+          stats[status] = count;
+        }
+        stats.total += count;
+      }
+      return stats;
+    },
+    /**
+     * Clear all jobs from the queue
+     */
+    async clear(options2 = {}) {
+      let query = db.deleteFrom("workmatic_jobs").where("queue", "=", queue);
+      if (options2.status) {
+        query = query.where("status", "=", options2.status);
+      }
+      const result = await query.execute();
+      return Number(result[0]?.numDeletedRows ?? 0);
+    }
+  };
+}
+
+// src/worker.ts
+import fastq from "fastq";
+import { sql as sql2 } from "kysely";
+var DEFAULT_WORKER_TIMEOUT_MS = 6e4;
+function parseClaimedRows(result) {
+  const rows = result.rows;
+  if (!rows || !Array.isArray(rows)) {
+    return [];
+  }
+  return rows.map((row) => ({
+    id: row.id,
+    public_id: row.public_id,
+    queue: row.queue,
+    payload: row.payload,
+    attempts: row.attempts,
+    max_attempts: row.max_attempts,
+    priority: row.priority,
+    created_at: row.created_at,
+    last_error: row.last_error
+  }));
+}
+function requireProcessor(processor) {
+  if (!processor) {
+    throw new Error("No processor set");
+  }
+  return processor;
+}
+function createWorker(options) {
+  const {
+    db,
+    queue = "default",
+    concurrency = 1,
+    leaseMs = 3e4,
+    pollMs = 1e3,
+    timeoutMs = DEFAULT_WORKER_TIMEOUT_MS,
+    backoff = defaultBackoff,
+    persistState = false,
+    autoRestore = true,
+    pauseCheckIntervalMs = 300,
+    requeueExpiredIntervalMs = 0,
+    onPumpError
+  } = options;
+  if (!db) {
+    throw new Error("Database instance is required");
+  }
+  let running = false;
+  let paused = false;
+  let processor = null;
+  let pumpTimeout = null;
+  let fastqQueue = null;
+  let lastPauseCheckAt = 0;
+  let cachedDbPaused = false;
+  let lastRequeueAt = 0;
+  function notifyPumpError(error) {
+    console.error("[workmatic] Pump error:", error);
+    onPumpError?.(error);
+  }
+  function getStateKey() {
+    return `worker_state_${queue}`;
+  }
+  async function saveState(state) {
+    if (!persistState) return;
+    const timestamp = now();
+    const key = getStateKey();
+    await sql2`
+      INSERT INTO workmatic_settings (queue, paused, updated_at)
+      VALUES (${key}, ${state === "paused" ? 1 : state === "running" ? 2 : 0}, ${timestamp})
+      ON CONFLICT(queue) DO UPDATE SET 
+        paused = ${state === "paused" ? 1 : state === "running" ? 2 : 0},
+        updated_at = ${timestamp}
+    `.execute(db);
+  }
+  async function loadState() {
+    if (!persistState) return null;
+    try {
+      const key = getStateKey();
+      const result = await db.selectFrom("workmatic_settings").select("paused").where("queue", "=", key).executeTakeFirst();
+      if (!result) return null;
+      if (result.paused === 2) return "running";
+      if (result.paused === 1) return "paused";
+      return "stopped";
+    } catch {
+      return null;
+    }
+  }
+  async function requeueExpiredLeases() {
+    const timestamp = now();
+    const result = await db.updateTable("workmatic_jobs").set({
+      status: "ready",
+      lease_until: 0,
+      updated_at: timestamp
+    }).where("status", "=", "running").where("lease_until", "<", timestamp).where("lease_until", ">", 0).execute();
+    return Number(result[0]?.numUpdatedRows ?? 0);
+  }
+  async function claimBatch(limit) {
+    const timestamp = now();
+    const leaseUntil = timestamp + leaseMs;
+    return await db.transaction().execute(async (trx) => {
+      const result = await sql2`
+        UPDATE workmatic_jobs
+        SET status = 'running', lease_until = ${leaseUntil}, updated_at = ${timestamp}
+        WHERE rowid IN (
+          SELECT rowid FROM workmatic_jobs
+          WHERE queue = ${queue}
+            AND status = 'ready'
+            AND run_at <= ${timestamp}
+          ORDER BY priority ASC, id ASC
+          LIMIT ${limit}
+        )
+        RETURNING id, public_id, queue, payload, attempts, max_attempts, priority, created_at, last_error
+      `.execute(trx);
+      return parseClaimedRows(result);
+    });
+  }
+  async function markDone(jobId) {
+    await db.updateTable("workmatic_jobs").set({
+      status: "done",
+      lease_until: 0,
+      updated_at: now()
+    }).where("id", "=", jobId).execute();
+  }
+  async function markFailed(jobId, attempts, maxAttempts, error) {
+    const timestamp = now();
+    const newAttempts = attempts + 1;
+    const errorMessage = error.message || String(error);
+    if (newAttempts < maxAttempts) {
+      const runAt = timestamp + backoff(newAttempts);
+      await db.updateTable("workmatic_jobs").set({
+        status: "ready",
+        attempts: newAttempts,
+        run_at: runAt,
+        lease_until: 0,
+        last_error: errorMessage,
+        updated_at: timestamp
+      }).where("id", "=", jobId).execute();
+    } else {
+      await db.updateTable("workmatic_jobs").set({
+        status: "dead",
+        attempts: newAttempts,
+        lease_until: 0,
+        last_error: errorMessage,
+        updated_at: timestamp
+      }).where("id", "=", jobId).execute();
+    }
+  }
+  async function withTimeout(promise, ms, jobId) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error(`Job ${jobId} timed out after ${ms}ms`));
+      }, ms);
+    });
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async function processJob(claimedJob) {
+    const fn = requireProcessor(processor);
+    const payload = parsePayload(claimedJob.payload);
+    const job = {
+      id: claimedJob.public_id,
+      queue: claimedJob.queue,
+      payload,
+      status: "running",
+      priority: claimedJob.priority,
+      attempts: claimedJob.attempts,
+      maxAttempts: claimedJob.max_attempts,
+      createdAt: claimedJob.created_at,
+      lastError: claimedJob.last_error
+    };
+    try {
+      if (timeoutMs) {
+        await withTimeout(fn(job), timeoutMs, job.id);
+      } else {
+        await fn(job);
+      }
+      await markDone(claimedJob.id);
+    } catch (error) {
+      await markFailed(
+        claimedJob.id,
+        claimedJob.attempts,
+        claimedJob.max_attempts,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  async function isQueuePausedInDb() {
+    const setting = await db.selectFrom("workmatic_settings").select("paused").where("queue", "=", queue).executeTakeFirst();
+    return setting?.paused === 1;
+  }
+  async function pump() {
+    if (!running) {
+      return;
+    }
+    if (paused) {
+      pumpTimeout = setTimeout(pump, pollMs);
+      return;
+    }
+    try {
+      const t = now();
+      if (t - lastPauseCheckAt >= pauseCheckIntervalMs) {
+        lastPauseCheckAt = t;
+        cachedDbPaused = await isQueuePausedInDb();
+      }
+      if (cachedDbPaused) {
+        pumpTimeout = setTimeout(pump, pollMs);
+        return;
+      }
+      if (requeueExpiredIntervalMs <= 0 || t - lastRequeueAt >= requeueExpiredIntervalMs) {
+        if (requeueExpiredIntervalMs > 0) {
+          lastRequeueAt = t;
+        }
+        await requeueExpiredLeases();
+      }
+      const batchSize = concurrency * 2;
+      const jobs = await claimBatch(batchSize);
+      if (jobs.length > 0) {
+        for (const job of jobs) {
+          fastqQueue.push(job);
+        }
+        pumpTimeout = setTimeout(pump, 0);
+      } else {
+        pumpTimeout = setTimeout(pump, pollMs);
+      }
+    } catch (error) {
+      notifyPumpError(error);
+      pumpTimeout = setTimeout(pump, pollMs);
+    }
+  }
+  const worker = {
+    process(fn) {
+      processor = fn;
+    },
+    start() {
+      if (running) {
+        return;
+      }
+      if (!processor) {
+        throw new Error("No processor set. Call process() before start()");
+      }
+      running = true;
+      paused = false;
+      fastqQueue = fastq.promise(processJob, concurrency);
+      saveState("running").catch(() => {
+      });
+      pump();
+    },
+    async stop() {
+      if (!running) {
+        return;
+      }
+      running = false;
+      if (pumpTimeout) {
+        clearTimeout(pumpTimeout);
+        pumpTimeout = null;
+      }
+      if (fastqQueue) {
+        await fastqQueue.drained();
+        fastqQueue = null;
+      }
+      await saveState("stopped");
+    },
+    pause() {
+      paused = true;
+      saveState("paused").catch(() => {
+      });
+    },
+    resume() {
+      paused = false;
+      saveState("running").catch(() => {
+      });
+    },
+    async stats() {
+      const result = await db.selectFrom("workmatic_jobs").select([
+        "status",
+        sql2`count(*)`.as("count")
+      ]).where("queue", "=", queue).groupBy("status").execute();
+      const stats = {
+        ready: 0,
+        running: 0,
+        done: 0,
+        dead: 0,
+        total: 0
+      };
+      for (const row of result) {
+        const status = row.status;
+        const count = Number(row.count);
+        if (status in stats) {
+          stats[status] = count;
+        }
+        stats.total += count;
+      }
+      return stats;
+    },
+    get isRunning() {
+      return running;
+    },
+    get isPaused() {
+      return paused;
+    },
+    get queue() {
+      return queue;
+    },
+    async restoreState() {
+      const state = await loadState();
+      if (state === "running" && processor) {
+        this.start();
+      } else if (state === "paused" && processor) {
+        this.start();
+        this.pause();
+      }
+      return state;
+    },
+    async clear(options2 = {}) {
+      let query = db.deleteFrom("workmatic_jobs").where("queue", "=", queue);
+      if (options2.status) {
+        query = query.where("status", "=", options2.status);
+      }
+      const result = await query.execute();
+      return Number(result[0]?.numDeletedRows ?? 0);
+    }
+  };
+  if (persistState && autoRestore) {
+    setImmediate(async () => {
+      if (processor) {
+        await worker.restoreState();
+      }
+    });
+  }
+  return worker;
+}
+
+// src/orchestrator.ts
+var DEFAULT_TRANSFER_STATUSES = ["ready", "dead"];
+var DEFAULT_TRANSFER_LIMIT = 1e4;
+function rowsUpdated(result) {
+  const row = result[0];
+  return Number(row?.numUpdatedRows ?? 0);
+}
+function normalizeStatuses(status) {
+  if (!status) return [...DEFAULT_TRANSFER_STATUSES];
+  return Array.isArray(status) ? status : [status];
+}
+function createOrchestrator(options) {
+  const { db } = options;
+  if (!db) {
+    throw new Error("Database instance is required");
+  }
+  const registry = /* @__PURE__ */ new Map();
+  function ensureEntry(queue) {
+    let entry = registry.get(queue);
+    if (!entry) {
+      entry = { client: createClient({ db, queue }) };
+      registry.set(queue, entry);
+    }
+    return entry;
+  }
+  async function setQueuePaused(queue, paused) {
+    const timestamp = now();
+    const value = paused ? 1 : 0;
+    await sql3`
+      INSERT INTO workmatic_settings (queue, paused, updated_at)
+      VALUES (${queue}, ${value}, ${timestamp})
+      ON CONFLICT(queue) DO UPDATE SET
+        paused = ${value},
+        updated_at = ${timestamp}
+    `.execute(db);
+  }
+  async function selectJobIds(from, status, limit) {
+    const rows = await db.selectFrom("workmatic_jobs").select("id").where("queue", "=", from).where("status", "=", status).orderBy("priority", "asc").orderBy("id", "asc").limit(limit).execute();
+    return rows.map((r) => r.id);
+  }
+  async function transferReady(from, to, limit) {
+    const ids = await selectJobIds(from, "ready", limit);
+    if (ids.length === 0) return 0;
+    const timestamp = now();
+    const result = await db.updateTable("workmatic_jobs").set({ queue: to, updated_at: timestamp }).where("id", "in", ids).execute();
+    return rowsUpdated(result);
+  }
+  async function transferDead(from, to, limit, resetForRetry) {
+    const ids = await selectJobIds(from, "dead", limit);
+    if (ids.length === 0) return 0;
+    const timestamp = now();
+    if (resetForRetry) {
+      const result2 = await db.updateTable("workmatic_jobs").set({
+        queue: to,
+        status: "ready",
+        attempts: 0,
+        lease_until: 0,
+        last_error: null,
+        updated_at: timestamp,
+        run_at: timestamp
+      }).where("id", "in", ids).execute();
+      return rowsUpdated(result2);
+    }
+    const result = await db.updateTable("workmatic_jobs").set({ queue: to, updated_at: timestamp }).where("id", "in", ids).execute();
+    return rowsUpdated(result);
+  }
+  async function transferOtherStatus(from, to, status, limit) {
+    const ids = await selectJobIds(from, status, limit);
+    if (ids.length === 0) return 0;
+    const timestamp = now();
+    const result = await db.updateTable("workmatic_jobs").set({ queue: to, updated_at: timestamp }).where("id", "in", ids).execute();
+    return rowsUpdated(result);
+  }
+  const orchestrator = {
+    register(queue, opts = {}) {
+      const client = createClient({ db, queue });
+      let worker;
+      if (opts.worker) {
+        worker = createWorker({ db, queue, ...opts.worker });
+      }
+      registry.set(queue, { client, worker });
+      return client;
+    },
+    client(queue) {
+      return ensureEntry(queue).client;
+    },
+    worker(queue) {
+      const entry = registry.get(queue);
+      if (!entry?.worker) {
+        throw new Error(`No worker registered for queue "${queue}"`);
+      }
+      return entry.worker;
+    },
+    workers() {
+      return [...registry.values()].map((e) => e.worker).filter((w) => w !== void 0);
+    },
+    async queues() {
+      const rows = await db.selectFrom("workmatic_jobs").select("queue").distinct().execute();
+      const names = new Set(rows.map((r) => r.queue));
+      for (const name of registry.keys()) {
+        names.add(name);
+      }
+      return [...names].sort();
+    },
+    process(queue, fn) {
+      this.worker(queue).process(fn);
+    },
+    startAll() {
+      for (const entry of registry.values()) {
+        entry.worker?.start();
+      }
+    },
+    async stopAll() {
+      const stops = [...registry.values()].map((e) => e.worker?.stop()).filter((p) => p !== void 0);
+      await Promise.all(stops);
+    },
+    async pause(queue) {
+      const entry = registry.get(queue);
+      entry?.worker?.pause();
+      await setQueuePaused(queue, true);
+    },
+    async resume(queue) {
+      const entry = registry.get(queue);
+      entry?.worker?.resume();
+      await setQueuePaused(queue, false);
+    },
+    async isPaused(queue) {
+      const setting = await db.selectFrom("workmatic_settings").select("paused").where("queue", "=", queue).executeTakeFirst();
+      return setting?.paused === 1;
+    },
+    async stats(queueName) {
+      const names = queueName ? [queueName] : await this.queues();
+      const result = {};
+      for (const name of names) {
+        result[name] = await ensureEntry(name).client.stats();
+      }
+      return result;
+    },
+    async transfer(opts) {
+      const { from, to, resetForRetry = false } = opts;
+      if (from === to) {
+        return { moved: 0 };
+      }
+      const statuses = normalizeStatuses(opts.status);
+      let remaining = opts.limit ?? DEFAULT_TRANSFER_LIMIT;
+      let moved = 0;
+      if (statuses.includes("ready") && remaining > 0) {
+        const n = await transferReady(from, to, remaining);
+        moved += n;
+        remaining -= n;
+      }
+      if (statuses.includes("dead") && remaining > 0) {
+        const n = await transferDead(from, to, remaining, resetForRetry);
+        moved += n;
+        remaining -= n;
+      }
+      for (const status of statuses) {
+        if (status === "ready" || status === "dead" || remaining <= 0) continue;
+        const n = await transferOtherStatus(from, to, status, remaining);
+        moved += n;
+        remaining -= n;
+      }
+      return { moved };
+    },
+    async moveJob(publicId, toQueue, opts = {}) {
+      const allowed = normalizeStatuses(opts.status);
+      const row = await db.selectFrom("workmatic_jobs").select(["id", "queue", "status"]).where("public_id", "=", publicId).executeTakeFirst();
+      if (!row) {
+        throw new Error(`Job not found: ${publicId}`);
+      }
+      if (row.queue === toQueue) {
+        return;
+      }
+      if (!allowed.includes(row.status)) {
+        throw new Error(
+          `Job ${publicId} has status "${row.status}" and cannot be moved (allowed: ${allowed.join(", ")})`
+        );
+      }
+      const timestamp = now();
+      const resetForRetry = opts.resetForRetry ?? false;
+      if (row.status === "dead" && resetForRetry) {
+        await db.updateTable("workmatic_jobs").set({
+          queue: toQueue,
+          status: "ready",
+          attempts: 0,
+          lease_until: 0,
+          last_error: null,
+          updated_at: timestamp,
+          run_at: timestamp
+        }).where("public_id", "=", publicId).execute();
+        return;
+      }
+      await db.updateTable("workmatic_jobs").set({ queue: toQueue, updated_at: timestamp }).where("public_id", "=", publicId).execute();
+    }
+  };
+  return orchestrator;
+}
+
+// src/cli/handlers.ts
 function printUsage() {
   console.log(`
 Workmatic CLI - Job Queue Management
@@ -24,20 +763,18 @@ Commands:
   retry <db> [--status=dead]     Retry dead jobs (reset to ready)
   pause <db> <queue>             Pause a queue (running workers stop claiming)
   resume <db> <queue>            Resume a paused queue
+  transfer <db> <from> <to>      Move jobs between queues
 
 Options:
-  --status=<status>   Filter by status (ready|running|done|dead)
+  --status=<status>   Filter by status (ready|running|done|dead), comma-separated for transfer
   --queue=<queue>     Filter by queue name
-  --limit=<n>         Limit number of results (default: 100)
+  --limit=<n>         Limit number of results or jobs to transfer (default: 100 / 10000)
+  --retry             When transferring dead jobs, reset them to ready for retry
 
 Examples:
   workmatic stats ./jobs.db
   workmatic list ./jobs.db --status=dead --limit=10
-  workmatic export ./jobs.db backup.csv
-  workmatic export ./jobs.db --status=dead > dead-jobs.csv
-  workmatic import ./jobs.db backup.csv
-  workmatic purge ./jobs.db --status=done
-  workmatic retry ./jobs.db --status=dead
+  workmatic transfer ./jobs.db emails retry-emails --status=dead --retry
   workmatic pause ./jobs.db emails
   workmatic resume ./jobs.db emails
 `);
@@ -95,27 +832,25 @@ function parseCSVLine(line) {
   return result;
 }
 async function cmdStats(dbPath) {
-  const db = new Database(dbPath, { readonly: true });
+  const db = new Database2(dbPath, { readonly: true });
   try {
-    const stats = db.prepare(`
+    const stats = db.prepare(
+      `
       SELECT status, COUNT(*) as count 
       FROM workmatic_jobs 
       GROUP BY status
-    `).all();
-    const queues = db.prepare(`
+    `
+    ).all();
+    const queues = db.prepare(
+      `
       SELECT queue, COUNT(*) as count 
       FROM workmatic_jobs 
       GROUP BY queue
-    `).all();
+    `
+    ).all();
     const total = stats.reduce((sum, s) => sum + s.count, 0);
     console.log("\n\u{1F4CA} Job Statistics\n");
     const statusOrder = ["ready", "running", "done", "dead"];
-    const statusEmoji = {
-      ready: "\u23F3",
-      running: "\u25B6\uFE0F",
-      done: "\u2705",
-      dead: "\u{1F480}"
-    };
     const statusTable = new Table({
       head: ["", "Status", "Count"],
       style: { head: ["cyan"], border: ["gray"] },
@@ -124,7 +859,7 @@ async function cmdStats(dbPath) {
     for (const status of statusOrder) {
       const stat = stats.find((s) => s.status === status);
       const count = stat?.count ?? 0;
-      const emoji = statusEmoji[status] || "";
+      const emoji = jobStatusEmoji(status);
       statusTable.push([emoji, status, count.toLocaleString()]);
     }
     statusTable.push([{ colSpan: 2, content: "Total", hAlign: "right" }, total.toLocaleString()]);
@@ -147,7 +882,7 @@ async function cmdStats(dbPath) {
   }
 }
 async function cmdList(dbPath, options) {
-  const db = new Database(dbPath, { readonly: true });
+  const db = new Database2(dbPath, { readonly: true });
   try {
     let query = "SELECT public_id, queue, status, priority, attempts, max_attempts, created_at, last_error FROM workmatic_jobs WHERE 1=1";
     const params = [];
@@ -166,12 +901,6 @@ async function cmdList(dbPath, options) {
       console.log("No jobs found.");
       return;
     }
-    const statusEmoji = {
-      ready: "\u23F3",
-      running: "\u25B6\uFE0F",
-      done: "\u2705",
-      dead: "\u{1F480}"
-    };
     const table = new Table({
       head: ["ID", "Queue", "Status", "Pri", "Attempts", "Created"],
       style: { head: ["cyan"], border: ["gray"] },
@@ -180,7 +909,7 @@ async function cmdList(dbPath, options) {
       wordWrap: true
     });
     for (const job of jobs) {
-      const emoji = statusEmoji[job.status] || "";
+      const emoji = jobStatusEmoji(job.status);
       table.push([
         job.public_id.slice(0, 21),
         job.queue.slice(0, 14),
@@ -200,7 +929,7 @@ async function cmdList(dbPath, options) {
   }
 }
 async function cmdExport(dbPath, outputPath, options) {
-  const db = new Database(dbPath, { readonly: true });
+  const db = new Database2(dbPath, { readonly: true });
   try {
     let query = "SELECT * FROM workmatic_jobs WHERE 1=1";
     const params = [];
@@ -243,7 +972,9 @@ async function cmdExport(dbPath, outputPath, options) {
       }
     }
     if (outputPath) {
-      output.end();
+      const stream = output;
+      stream.end();
+      await finished(stream);
       console.error(`\u2705 Exported ${jobs.length} jobs to ${outputPath}`);
     }
   } finally {
@@ -251,7 +982,7 @@ async function cmdExport(dbPath, outputPath, options) {
   }
 }
 async function cmdImport(dbPath, inputPath) {
-  const db = new Database(dbPath);
+  const db = new Database2(dbPath);
   db.exec(`
     CREATE TABLE IF NOT EXISTS workmatic_jobs (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -332,11 +1063,9 @@ async function cmdImport(dbPath, inputPath) {
 }
 async function cmdPurge(dbPath, options) {
   if (!options.status) {
-    console.error("Error: --status is required for purge command");
-    console.error("Example: workmatic purge ./jobs.db --status=done");
-    process.exit(1);
+    throw new Error("--status is required for purge command");
   }
-  const db = new Database(dbPath);
+  const db = new Database2(dbPath);
   try {
     const result = db.prepare("DELETE FROM workmatic_jobs WHERE status = ?").run(options.status);
     console.log(`\u{1F5D1}\uFE0F  Deleted ${result.changes} jobs with status '${options.status}'`);
@@ -346,10 +1075,11 @@ async function cmdPurge(dbPath, options) {
 }
 async function cmdRetry(dbPath, options) {
   const status = options.status || "dead";
-  const db = new Database(dbPath);
+  const db = new Database2(dbPath);
   try {
-    const now = Date.now();
-    const result = db.prepare(`
+    const ts = Date.now();
+    const result = db.prepare(
+      `
       UPDATE workmatic_jobs 
       SET status = 'ready', 
           attempts = 0, 
@@ -357,14 +1087,15 @@ async function cmdRetry(dbPath, options) {
           lease_until = 0,
           updated_at = ?
       WHERE status = ?
-    `).run(now, now, status);
+    `
+    ).run(ts, ts, status);
     console.log(`\u{1F504} Reset ${result.changes} jobs from '${status}' to 'ready'`);
   } finally {
     db.close();
   }
 }
 async function cmdPause(dbPath, queueName) {
-  const db = new Database(dbPath);
+  const db = new Database2(dbPath);
   try {
     db.exec(`
       CREATE TABLE IF NOT EXISTS workmatic_settings (
@@ -373,12 +1104,14 @@ async function cmdPause(dbPath, queueName) {
         updated_at INTEGER NOT NULL
       )
     `);
-    const now = Date.now();
-    db.prepare(`
+    const ts = Date.now();
+    db.prepare(
+      `
       INSERT INTO workmatic_settings (queue, paused, updated_at)
       VALUES (?, 1, ?)
       ON CONFLICT(queue) DO UPDATE SET paused = 1, updated_at = ?
-    `).run(queueName, now, now);
+    `
+    ).run(queueName, ts, ts);
     console.log(`\u23F8\uFE0F  Paused queue '${queueName}'`);
     console.log(`   Running workers will stop claiming new jobs.`);
   } finally {
@@ -386,7 +1119,7 @@ async function cmdPause(dbPath, queueName) {
   }
 }
 async function cmdResume(dbPath, queueName) {
-  const db = new Database(dbPath);
+  const db = new Database2(dbPath);
   try {
     db.exec(`
       CREATE TABLE IF NOT EXISTS workmatic_settings (
@@ -395,12 +1128,14 @@ async function cmdResume(dbPath, queueName) {
         updated_at INTEGER NOT NULL
       )
     `);
-    const now = Date.now();
-    db.prepare(`
+    const ts = Date.now();
+    db.prepare(
+      `
       INSERT INTO workmatic_settings (queue, paused, updated_at)
       VALUES (?, 0, ?)
       ON CONFLICT(queue) DO UPDATE SET paused = 0, updated_at = ?
-    `).run(queueName, now, now);
+    `
+    ).run(queueName, ts, ts);
     console.log(`\u25B6\uFE0F  Resumed queue '${queueName}'`);
     console.log(`   Workers will start claiming jobs again.`);
   } finally {
@@ -408,14 +1143,17 @@ async function cmdResume(dbPath, queueName) {
   }
 }
 async function cmdQueues(dbPath) {
-  const db = new Database(dbPath, { readonly: true });
+  const db = new Database2(dbPath, { readonly: true });
   try {
-    const settingsExists = db.prepare(`
+    const settingsExists = db.prepare(
+      `
       SELECT name FROM sqlite_master WHERE type='table' AND name='workmatic_settings'
-    `).get();
+    `
+    ).get();
     let queues;
     if (settingsExists) {
-      queues = db.prepare(`
+      queues = db.prepare(
+        `
         SELECT 
           j.queue,
           COUNT(*) as total,
@@ -425,9 +1163,11 @@ async function cmdQueues(dbPath) {
         FROM workmatic_jobs j
         LEFT JOIN workmatic_settings s ON j.queue = s.queue
         GROUP BY j.queue
-      `).all();
+      `
+      ).all();
     } else {
-      queues = db.prepare(`
+      queues = db.prepare(
+        `
         SELECT 
           queue,
           COUNT(*) as total,
@@ -436,7 +1176,8 @@ async function cmdQueues(dbPath) {
           0 as paused
         FROM workmatic_jobs
         GROUP BY queue
-      `).all();
+      `
+      ).all();
     }
     if (queues.length === 0) {
       console.log("No queues found.");
@@ -464,11 +1205,115 @@ async function cmdQueues(dbPath) {
     db.close();
   }
 }
+var JOB_STATUS_EMOJI = {
+  ready: "\u23F3",
+  running: "\u25B6\uFE0F",
+  done: "\u2705",
+  dead: "\u{1F480}"
+};
+function jobStatusEmoji(status) {
+  return JOB_STATUS_EMOJI[status] || "";
+}
+function parseTransferStatuses(raw) {
+  if (!raw) return ["ready", "dead"];
+  return raw.split(",").map((s) => s.trim());
+}
+async function cmdTransfer(dbPath, from, to, options) {
+  const db = createDatabase({ filename: dbPath });
+  try {
+    const orch = createOrchestrator({ db });
+    const status = parseTransferStatuses(options.status);
+    const limit = options.limit ? parseInt(options.limit, 10) : void 0;
+    const resetForRetry = options.retry === "true";
+    const { moved } = await orch.transfer({
+      from,
+      to,
+      status,
+      limit,
+      resetForRetry
+    });
+    console.log(`\u2194\uFE0F  Moved ${moved} job(s) from '${from}' to '${to}'`);
+  } finally {
+    await db.destroy();
+  }
+}
+async function runCommand(command2, dbPath, positionalArgs, options) {
+  switch (command2) {
+    case "stats":
+      await cmdStats(dbPath);
+      break;
+    case "list":
+      await cmdList(dbPath, options);
+      break;
+    case "export":
+      await cmdExport(dbPath, positionalArgs[1], options);
+      break;
+    case "import":
+      if (!positionalArgs[1]) {
+        throw new Error("Input CSV file is required");
+      }
+      await cmdImport(dbPath, positionalArgs[1]);
+      break;
+    case "purge":
+      await cmdPurge(dbPath, options);
+      break;
+    case "retry":
+      await cmdRetry(dbPath, options);
+      break;
+    case "pause":
+      if (!positionalArgs[1]) {
+        throw new Error("Queue name is required");
+      }
+      await cmdPause(dbPath, positionalArgs[1]);
+      break;
+    case "resume":
+      if (!positionalArgs[1]) {
+        throw new Error("Queue name is required");
+      }
+      await cmdResume(dbPath, positionalArgs[1]);
+      break;
+    case "queues":
+      await cmdQueues(dbPath);
+      break;
+    case "transfer":
+      if (!positionalArgs[1] || !positionalArgs[2]) {
+        throw new Error("Source and target queue names are required");
+      }
+      await cmdTransfer(dbPath, positionalArgs[1], positionalArgs[2], options);
+      break;
+    default:
+      throw new Error(`Unknown command: ${command2}`);
+  }
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+var KNOWN_COMMANDS = [
+  "stats",
+  "list",
+  "export",
+  "import",
+  "purge",
+  "retry",
+  "pause",
+  "resume",
+  "queues",
+  "transfer"
+];
+function isCliCommand(value) {
+  return KNOWN_COMMANDS.includes(value);
+}
 async function main() {
   if (!command || command === "--help" || command === "-h") {
     printUsage();
     process.exit(0);
   }
+  if (!isCliCommand(command)) {
+    console.error(`Unknown command: ${command}`);
+    printUsage();
+    process.exit(1);
+  }
   const positionalArgs = getPositionalArgs(args.slice(1));
   const options = parseOptions(args);
   const dbPath = positionalArgs[0];
@@ -478,53 +1323,7 @@ async function main() {
     process.exit(1);
   }
   try {
-    switch (command) {
-      case "stats":
-        await cmdStats(dbPath);
-        break;
-      case "list":
-        await cmdList(dbPath, options);
-        break;
-      case "export":
-        await cmdExport(dbPath, positionalArgs[1], options);
-        break;
-      case "import":
-        if (!positionalArgs[1]) {
-          console.error("Error: Input CSV file is required");
-          process.exit(1);
-        }
-        await cmdImport(dbPath, positionalArgs[1]);
-        break;
-      case "purge":
-        await cmdPurge(dbPath, options);
-        break;
-      case "retry":
-        await cmdRetry(dbPath, options);
-        break;
-      case "pause":
-        if (!positionalArgs[1]) {
-          console.error("Error: Queue name is required");
-          console.error("Example: workmatic pause ./jobs.db emails");
-          process.exit(1);
-        }
-        await cmdPause(dbPath, positionalArgs[1]);
-        break;
-      case "resume":
-        if (!positionalArgs[1]) {
-          console.error("Error: Queue name is required");
-          console.error("Example: workmatic resume ./jobs.db emails");
-          process.exit(1);
-        }
-        await cmdResume(dbPath, positionalArgs[1]);
-        break;
-      case "queues":
-        await cmdQueues(dbPath);
-        break;
-      default:
-        console.error(`Unknown command: ${command}`);
-        printUsage();
-        process.exit(1);
-    }
+    await runCommand(command, dbPath, positionalArgs, options);
   } catch (error) {
     console.error("Error:", error instanceof Error ? error.message : error);
     process.exit(1);