cursor-route 0.1.1 → 0.1.5

package/src/cli.test.ts

@@ -3,10 +3,13 @@ import { resolveWorker } from "./jobs.ts";
 import { config } from "./config.ts";
 import { shellQuote, newJobId } from "./util.ts";
 import { runHealth } from "./health.ts";
-import { looksLikeSecretMaterial } from "./secrets.ts";
-import { isDeepSeekRouted } from "./adapters/claude-ds.ts";
+import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
+import { isDeepSeekRouted, isDeepSeekBaseUrl } from "./adapters/claude-ds.ts";
 
 describe("resolveWorker", () => {
+  test("lane easy → openrouter", () => {
+    expect(resolveWorker({ prompt: "x", lane: "easy" })).toBe("openrouter");
+  });
   test("lane mid → claude-ds", () => {
     expect(resolveWorker({ prompt: "x", lane: "mid" })).toBe("claude-ds");
   });
@@ -17,6 +20,9 @@ describe("resolveWorker", () => {
     expect(resolveWorker({ prompt: "x", lane: "hard", worker: "claude-ds" })).toBe(
       "claude-ds",
     );
+    expect(resolveWorker({ prompt: "x", lane: "mid", worker: "openrouter" })).toBe(
+      "openrouter",
+    );
   });
   test("default worker", () => {
     expect(resolveWorker({ prompt: "x" })).toBe(config.defaultWorker);
@@ -40,8 +46,24 @@ describe("secrets", () => {
   test("blocks sk- material", () => {
     expect(looksLikeSecretMaterial("token sk-abcdefghijklmnopqrstuvwxyz1234")).toBe(true);
   });
-  test("blocks ghp_ material", () => {
+  test("blocks sk-proj and sk-ant", () => {
+    expect(
+      looksLikeSecretMaterial("sk-proj-abcdefghijklmnopqrstuvwxyz123456"),
+    ).toBe(true);
+    expect(
+      looksLikeSecretMaterial("sk-ant-api03-abcdefghijklmnopqrstuvwxyz"),
+    ).toBe(true);
+  });
+  test("blocks ghp_ and github_pat", () => {
     expect(looksLikeSecretMaterial("ghp_abcdefghijklmnopqrstuvwx")).toBe(true);
+    expect(
+      looksLikeSecretMaterial("github_pat_11AAAAAAAAabcdefghijklmnopqrstuvwxyz"),
+    ).toBe(true);
+  });
+  test("redactSecrets strips material", () => {
+    const out = redactSecrets("see sk-abcdefghijklmnopqrstuvwxyz1234 end");
+    expect(out).toContain("[REDACTED]");
+    expect(out).not.toContain("sk-abcd");
   });
 });
 
@@ -51,6 +73,8 @@ describe("deepseek routing", () => {
     process.env.ANTHROPIC_BASE_URL = "https://api.deepseek.com/anthropic";
     try {
       expect(isDeepSeekRouted()).toBe(true);
+      expect(isDeepSeekBaseUrl("https://api.deepseek.com/anthropic")).toBe(true);
+      expect(isDeepSeekBaseUrl("https://evil-deepseek.com.attacker.tld")).toBe(false);
     } finally {
       if (prev === undefined) delete process.env.ANTHROPIC_BASE_URL;
       else process.env.ANTHROPIC_BASE_URL = prev;
@@ -67,16 +91,13 @@ describe("health", () => {
     expect(r.checks.some((c) => c.name === "cursor_cli")).toBe(true);
   });
 
-  test("relaxed env can pass without tmux", () => {
+  test("relaxed env can pass without workers", () => {
     const prev = process.env.CURSOR_ROUTE_RELAXED;
     process.env.CURSOR_ROUTE_RELAXED = "1";
     try {
       const r = runHealth();
-      const tmux = r.checks.find((c) => c.name === "tmux");
-      if (tmux && !tmux.ok) {
-        expect(r.ok).toBe(true);
-        expect(r.checks.some((c) => c.name === "relaxed")).toBe(true);
-      }
+      expect(r.ok).toBe(true);
+      expect(r.checks.some((c) => c.name === "relaxed")).toBe(true);
     } finally {
       if (prev === undefined) delete process.env.CURSOR_ROUTE_RELAXED;
       else process.env.CURSOR_ROUTE_RELAXED = prev;

package/src/cli.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 /**
- * cursor-route CLI — Cursor brain, Grok + DeepSeek workers in tmux.
+ * cursor-route CLI — Cursor brain, Grok + DeepSeek + OpenRouter (easy) workers in tmux.
  */
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
 import { config, WORKERS, LANES, type WorkerKind, type Lane } from "./config.ts";
 import { runHealth, printHealth } from "./health.ts";
@@ -22,12 +22,12 @@ import {
   listManagedSessions,
   sessionExists,
 } from "./tmux.ts";
-import { looksLikeSecretMaterial } from "./secrets.ts";
+import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
 
 function usage(exitCode = 0): never {
   console.log(`cursor-route v${config.version}
 
-Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army.
+Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are the parallel army.
 
 Usage:
   cursor-route --version
@@ -44,19 +44,25 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds>   Worker adapter (default: grok)
-  --lane <mid|hard>           Lane → worker (mid=claude-ds, hard=grok)
-  --dir <path>                Working directory (default: cwd)
-  --ask                       Disable always-approve for this job
-  --dry-run                   Print launch command; do not start
-  --no-tmux                   Headless background process (no attach/send)
-  --json                      JSON output where supported
+  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok)
+  --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
+  --dir <path>                          Working directory (default: cwd)
+  --ask                                 Disable always-approve for this job
+  --dry-run                             Print launch command; do not start
+  --no-tmux                             Headless background process (no attach/send)
+  --json                                JSON output where supported
 
 Env:
   CURSOR_ROUTE_ASK=1                 Opt out of always-approve
   CURSOR_ROUTE_JOBS_DIR              Override jobs dir (default: ~/.local/share/cursor-route/jobs)
-  CURSOR_ROUTE_RELAXED=1             health OK without tmux (headless CI)
+  CURSOR_ROUTE_MAX_JOBS              Max active jobs (default: 50)
+  CURSOR_ROUTE_RELAXED=1             health OK without tmux/workers (CI / infra smoke)
   CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default)
+  CURSOR_ROUTE_GROK_BIN              Override the grok binary path (tests / power users)
+  CURSOR_ROUTE_CLAUDE_DS_BIN         Override the claude-ds binary path (tests / power users)
+  OPENROUTER_API_KEY                 OpenRouter key (required for --worker openrouter / --lane easy)
+  CURSOR_ROUTE_OPENROUTER_MODEL      OpenRouter model (default: openrouter/free)
+  OPENROUTER_BASE_URL                OpenRouter API base (default: https://openrouter.ai/api/v1)
 `);
   process.exit(exitCode);
 }
@@ -66,6 +72,10 @@ function parseArgs(argv: string[]) {
   const positional: string[] = [];
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
+    if (a === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
     if (
       a === "--json" ||
       a === "--ask" ||
@@ -106,6 +116,30 @@ function parseArgs(argv: string[]) {
   return { flags, positional };
 }
 
+/** Require a string value for flags that must not be bare booleans. */
+function requireStringFlag(
+  flags: Record<string, string | boolean>,
+  key: string,
+): string | undefined {
+  if (!(key in flags)) return undefined;
+  const v = flags[key];
+  if (typeof v !== "string" || !v.trim()) {
+    console.error(`--${key} requires a value`);
+    process.exit(2);
+  }
+  return v;
+}
+
+function requireNonNegNumber(raw: string | undefined, label: string, fallback: number): number {
+  if (raw === undefined) return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) {
+    console.error(`${label} must be a non-negative number`);
+    process.exit(2);
+  }
+  return n;
+}
+
 function asWorker(v: unknown): WorkerKind | undefined {
   if (typeof v !== "string") return undefined;
   if ((WORKERS as string[]).includes(v)) return v as WorkerKind;
@@ -128,14 +162,31 @@ function refuseSecrets(text: string, context: string): void {
 }
 
 function refuseDangerousPromptFile(path: string): void {
-  const base = basename(path);
-  const resolved = resolve(path);
+  let resolved: string;
+  try {
+    resolved = realpathSync(path);
+  } catch {
+    resolved = resolve(path);
+  }
+  const base = basename(resolved);
+  const lower = resolved.toLowerCase();
   if (
     base.startsWith(".env") ||
-    resolved.includes("/.ssh/") ||
+    lower.includes("/.ssh/") ||
+    lower.includes("/.aws/") ||
+    lower.includes("/.kube/") ||
+    base === ".npmrc" ||
+    base === ".git-credentials" ||
+    base === ".pgpass" ||
     base === "id_rsa" ||
     base === "id_ed25519" ||
-    base.endsWith(".pem")
+    base === "id_ecdsa" ||
+    base === "id_dsa" ||
+    base === "credentials" ||
+    base.endsWith(".pem") ||
+    base.endsWith(".key") ||
+    base.endsWith(".p12") ||
+    base.endsWith(".pfx")
   ) {
     console.error(`Refusing --prompt-file path that looks credential-related: ${path}`);
     process.exit(3);
@@ -163,9 +214,14 @@ async function main() {
   }
 
   if (cmd === "start") {
+    requireStringFlag(f, "worker");
+    requireStringFlag(f, "lane");
+    const promptFile = requireStringFlag(f, "prompt-file");
+    const dirFlag = requireStringFlag(f, "dir");
+
     let prompt = "";
-    if (f["prompt-file"]) {
-      const p = resolve(String(f["prompt-file"]));
+    if (promptFile) {
+      const p = resolve(promptFile);
       refuseDangerousPromptFile(p);
       if (!existsSync(p)) {
         console.error(`prompt file not found: ${p}`);
@@ -181,11 +237,25 @@ async function main() {
     }
     refuseSecrets(prompt, "to start");
 
+    let cwd = process.cwd();
+    if (dirFlag) {
+      cwd = resolve(dirFlag);
+      try {
+        if (!statSync(cwd).isDirectory()) {
+          console.error(`--dir is not a directory: ${cwd}`);
+          process.exit(2);
+        }
+      } catch {
+        console.error(`--dir does not exist: ${cwd}`);
+        process.exit(2);
+      }
+    }
+
     const result = startJob({
       prompt,
       worker: asWorker(f.worker),
       lane: asLane(f.lane),
-      cwd: f.dir ? resolve(String(f.dir)) : process.cwd(),
+      cwd,
       alwaysApprove: !f.ask,
       dryRun: Boolean(f.dryRun),
       noTmux: Boolean(f.noTmux),
@@ -197,11 +267,20 @@ async function main() {
     }
 
     if (json) {
-      console.log(JSON.stringify({ ...result.job, command: result.command }, null, 2));
+      console.log(
+        JSON.stringify(
+          {
+            ...result.job,
+            command: result.command ? redactSecrets(result.command) : result.command,
+          },
+          null,
+          2,
+        ),
+      );
     } else if (result.dryRun) {
       console.log(`dry-run job ${result.job.id}`);
       console.log(`worker: ${result.job.worker}`);
-      console.log(`command: ${result.command}`);
+      console.log(`command: ${redactSecrets(result.command || "")}`);
     } else {
       console.log(`started ${result.job.id} (${result.job.worker})`);
       console.log(`session: ${result.job.tmuxSession}`);
@@ -217,7 +296,8 @@ async function main() {
   }
 
   if (cmd === "jobs") {
-    const limit = f.limit ? Number(f.limit) : config.jobsListLimit;
+    const limitRaw = requireStringFlag(f, "limit");
+    const limit = requireNonNegNumber(limitRaw, "--limit", config.jobsListLimit);
     const jobs = listJobs(limit);
     if (json) {
       console.log(JSON.stringify(jobs, null, 2));
@@ -267,7 +347,10 @@ async function main() {
 
   if (cmd === "capture") {
     const id = pos[0];
-    const lines = pos[1] ? Number(pos[1]) : 50;
+    const linesRaw = pos[1];
+    const lines = linesRaw
+      ? requireNonNegNumber(linesRaw, "capture lines", 50)
+      : 50;
     if (!id) {
       console.error("capture requires <jobId>");
       process.exit(2);
@@ -326,6 +409,15 @@ async function main() {
       console.error("attach requires <jobId>");
       process.exit(2);
     }
+    const job = readJob(id);
+    if (!job) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    if (job.tmuxSession.startsWith("headless-")) {
+      console.error("headless job — use capture/status (no tmux attach)");
+      process.exit(1);
+    }
     console.log(attachHint(id));
     return;
   }
@@ -354,7 +446,8 @@ async function main() {
   }
 
   if (cmd === "clean") {
-    const days = f.days ? Number(f.days) : 7;
+    const daysRaw = requireStringFlag(f, "days");
+    const days = requireNonNegNumber(daysRaw, "--days", 7);
     const n = cleanJobs(days);
     console.log(`cleaned ${n} job(s) older than ${days}d`);
     return;

package/src/config.ts

@@ -2,24 +2,55 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.ts";
 
-export type WorkerKind = "grok" | "claude-ds";
-export type Lane = "mid" | "hard";
+export type WorkerKind = "grok" | "claude-ds" | "openrouter";
+export type Lane = "easy" | "mid" | "hard";
 
-export const WORKERS: WorkerKind[] = ["grok", "claude-ds"];
-export const LANES: Lane[] = ["mid", "hard"];
+export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter"];
+export const LANES: Lane[] = ["easy", "mid", "hard"];
 
+/** OpenRouter model for the easy lane (env CURSOR_ROUTE_OPENROUTER_MODEL). */
+export function openRouterModel(): string {
+  return process.env.CURSOR_ROUTE_OPENROUTER_MODEL || "openrouter/free";
+}
+
+/** OpenRouter API base URL (env OPENROUTER_BASE_URL). */
+export function openRouterBaseUrl(): string {
+  return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+}
+
+function maxConcurrentJobsFromEnv(): number {
+  const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
+  if (raw) {
+    const n = Number(raw);
+    if (Number.isInteger(n) && n > 0) return n;
+  }
+  return 50;
+}
+
+/**
+ * Live getters for env-derived paths/limits so tests can set
+ * CURSOR_ROUTE_JOBS_DIR / CURSOR_ROUTE_MAX_JOBS before exercising jobs
+ * even if another module imported config earlier.
+ */
 export const config = {
   product: "cursor-route",
-  version: "0.1.1",
-  jobsDir: defaultJobsDir(),
+  version: "0.1.5",
+  get jobsDir(): string {
+    return defaultJobsDir();
+  },
   tmuxPrefix: "cursor-route",
   defaultWorker: "grok" as WorkerKind,
   /** Lane → default worker (Cemini /route public core). */
   laneWorkers: {
+    easy: "openrouter" as WorkerKind,
     mid: "claude-ds" as WorkerKind,
     hard: "grok" as WorkerKind,
   },
   jobsListLimit: 20,
+  /** Max simultaneously active (running|pending) jobs. Override: CURSOR_ROUTE_MAX_JOBS. */
+  get maxConcurrentJobs(): number {
+    return maxConcurrentJobsFromEnv();
+  },
 };
 
 export function sessionName(jobId: string): string {

package/src/health.ts

@@ -32,7 +32,7 @@ export function runHealth(): HealthReport {
   checks.push({
     name: "runtime",
     ok: bunOk || nodeOk,
-    detail: bunOk ? "bun ok" : nodeOk ? "node ok (tsx via npx for TS)" : "need bun or node 20+",
+    detail: bunOk ? "bun ok" : nodeOk ? "node ok (compiled dist)" : "need bun or node 20+",
   });
 
   const scriptOk = (() => {
@@ -71,18 +71,20 @@ export function runHealth(): HealthReport {
       : "optional — Cursor CLI agent not on PATH (skill-only supervisor is fine for v0)",
   });
 
-  // At least one worker must be healthy; tmux is hard-required for attach/send product path.
-  // Set CURSOR_ROUTE_RELAXED=1 to pass health without tmux (headless/--no-tmux CI).
+  // At least one worker must be healthy for a green health gate.
+  // CURSOR_ROUTE_RELAXED=1: pass without tmux and without workers (CI / infra smoke).
   const workerOk = checks.some((c) => c.name.startsWith("worker:") && c.ok);
   const relaxed = process.env.CURSOR_ROUTE_RELAXED === "1";
   const hardOk = (tmuxOk || relaxed) && (bunOk || nodeOk) && scriptOk;
-  const ok = hardOk && workerOk;
+  const ok = hardOk && (workerOk || relaxed);
 
-  if (relaxed && !tmuxOk) {
+  if (relaxed) {
     checks.push({
       name: "relaxed",
       ok: true,
-      detail: "CURSOR_ROUTE_RELAXED=1 — tmux not required (headless only)",
+      detail: workerOk
+        ? "CURSOR_ROUTE_RELAXED=1 — tmux optional (headless OK)"
+        : "CURSOR_ROUTE_RELAXED=1 — tmux/workers optional (CI / infra smoke)",
     });
   }
 

package/src/integration.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Fake-worker integration tests (headless, no tmux needed).
+ *
+ * Env (set before importing config/jobs so jobsDir + limit take effect):
+ *   CURSOR_ROUTE_JOBS_DIR  → unique tmpdir
+ *   CURSOR_ROUTE_MAX_JOBS  → 2 (so the concurrency refusal is cheap to test)
+ *   CURSOR_ROUTE_GROK_BIN  → absolute path to the fake grok shim (read in-process
+ *                            by the adapter; PATH shadowing alone is unreliable
+ *                            under bun, which snapshots env for child processes)
+ */
+import { describe, expect, test, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, chmodSync, rmSync, readdirSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Job } from "./jobs.ts";
+
+const tmp = mkdtempSync(join(tmpdir(), "cursor-route-int-"));
+const jobsDir = join(tmp, "jobs");
+const shimDir = join(tmp, "bin");
+const shimLog = join(tmp, "shim.log");
+
+process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+process.env.CURSOR_ROUTE_MAX_JOBS = "2";
+
+mkdirSync(jobsDir, { recursive: true });
+mkdirSync(shimDir, { recursive: true });
+
+function writeShim(name: string): void {
+  const body = `#!/usr/bin/env sh
+{
+  echo "argv=$*"
+  echo "pwd=$PWD"
+} >> '${shimLog}'
+sleep "\${FAKE_WORKER_SLEEP:-1}"
+exit "\${FAKE_WORKER_EXIT:-0}"
+`;
+  const p = join(shimDir, name);
+  writeFileSync(p, body);
+  chmodSync(p, 0o755);
+}
+writeShim("grok");
+writeShim("claude-ds");
+process.env.CURSOR_ROUTE_GROK_BIN = join(shimDir, "grok");
+process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = join(shimDir, "claude-ds");
+
+const { startJob, readJob, killJob, refreshStatus, countActiveJobs } = await import("./jobs.ts");
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForTerminal(jobId: string, timeoutMs = 15000): Promise<Job> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const job = readJob(jobId);
+    if (!job) {
+      await sleep(100);
+      continue;
+    }
+    const fresh = refreshStatus(job);
+    if (fresh.status === "completed" || fresh.status === "failed" || fresh.status === "killed") {
+      return fresh;
+    }
+    await sleep(200);
+  }
+  throw new Error(`timed out waiting for job ${jobId} to reach terminal state`);
+}
+
+afterAll(() => {
+  try {
+    rmSync(tmp, { recursive: true, force: true });
+  } catch {
+    /* ignore */
+  }
+});
+
+describe("fake-worker integration (headless, no tmux)", () => {
+  test(
+    "start → completed with exitCode 0",
+    async () => {
+      delete process.env.FAKE_WORKER_EXIT;
+      delete process.env.FAKE_WORKER_SLEEP;
+      const r = startJob({ prompt: "say ok", worker: "grok", noTmux: true });
+      expect(r.ok).toBe(true);
+      if (!r.ok) return;
+      const job = await waitForTerminal(r.job.id);
+      expect(job.status).toBe("completed");
+      expect(job.exitCode).toBe(0);
+    },
+    20000,
+  );
+
+  test(
+    "FAKE_WORKER_EXIT=7 → failed with exitCode 7",
+    async () => {
+      process.env.FAKE_WORKER_EXIT = "7";
+      delete process.env.FAKE_WORKER_SLEEP;
+      try {
+        const r = startJob({ prompt: "say fail", worker: "grok", noTmux: true });
+        expect(r.ok).toBe(true);
+        if (!r.ok) return;
+        const job = await waitForTerminal(r.job.id);
+        expect(job.status).toBe("failed");
+        expect(job.exitCode).toBe(7);
+      } finally {
+        delete process.env.FAKE_WORKER_EXIT;
+      }
+    },
+    20000,
+  );
+
+  test(
+    "kill running job → killed; second kill refused as terminal",
+    async () => {
+      process.env.FAKE_WORKER_SLEEP = "30";
+      delete process.env.FAKE_WORKER_EXIT;
+      try {
+        const r = startJob({ prompt: "long job", worker: "grok", noTmux: true });
+        expect(r.ok).toBe(true);
+        if (!r.ok) return;
+        // Give the detached spawn a beat so the pid is recorded and the shim is alive.
+        await sleep(300);
+        const k = killJob(r.job.id);
+        expect(k.ok).toBe(true);
+        if (k.ok) expect(k.job.status).toBe("killed");
+
+        const again = killJob(r.job.id);
+        expect(again.ok).toBe(false);
+        if (!again.ok) expect(again.error).toContain("terminal");
+      } finally {
+        delete process.env.FAKE_WORKER_SLEEP;
+      }
+    },
+    20000,
+  );
+
+  test("openrouter worker without key refuses start (preflight)", () => {
+    delete process.env.OPENROUTER_API_KEY;
+    const r = startJob({ prompt: "say ok", worker: "openrouter", noTmux: true });
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.error).toContain("openrouter");
+  });
+
+  test(
+    "concurrent limit: refuses start once active jobs reach CURSOR_ROUTE_MAX_JOBS",
+    async () => {
+      process.env.FAKE_WORKER_SLEEP = "30";
+      delete process.env.FAKE_WORKER_EXIT;
+      try {
+        const a = startJob({ prompt: "job a", worker: "grok", noTmux: true });
+        const b = startJob({ prompt: "job b", worker: "grok", noTmux: true });
+        expect(a.ok).toBe(true);
+        expect(b.ok).toBe(true);
+        if (!a.ok || !b.ok) return;
+        expect(countActiveJobs()).toBe(2);
+
+        const c = startJob({ prompt: "job c", worker: "grok", noTmux: true });
+        expect(c.ok).toBe(false);
+        if (!c.ok) expect(c.error).toContain("Too many active jobs");
+      } finally {
+        delete process.env.FAKE_WORKER_SLEEP;
+        // Cleanup any running jobs so the tmpdir can be removed.
+        if (existsSync(jobsDir)) {
+          for (const f of readdirSync(jobsDir)) {
+            if (!f.endsWith(".json")) continue;
+            const job = readJob(f.replace(/\.json$/, ""));
+            if (job && (job.status === "running" || job.status === "pending")) killJob(job.id);
+          }
+        }
+      }
+    },
+    20000,
+  );
+});