cursor-route 0.1.4 → 0.1.6

package/src/cli.test.ts

@@ -1,12 +1,16 @@
 import { describe, expect, test } from "bun:test";
 import { resolveWorker } from "./jobs.ts";
-import { config } from "./config.ts";
+import { config, resolveDsModelAlias } from "./config.ts";
 import { shellQuote, newJobId } from "./util.ts";
 import { runHealth } from "./health.ts";
 import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
-import { isDeepSeekRouted, isDeepSeekBaseUrl } from "./adapters/claude-ds.ts";
+import { isDeepSeekRouted, isDeepSeekBaseUrl, claudeDsAdapter } from "./adapters/claude-ds.ts";
+import { deepseekAdapter } from "./adapters/deepseek.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,12 +21,81 @@ 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);
   });
 });
 
+describe("resolveDsModelAlias", () => {
+  test("defaults to flash", () => {
+    expect(resolveDsModelAlias()).toBe("flash");
+    expect(resolveDsModelAlias("")).toBe("flash");
+  });
+  test("accepts aliases and full ids", () => {
+    expect(resolveDsModelAlias("flash")).toBe("flash");
+    expect(resolveDsModelAlias("pro")).toBe("pro");
+    expect(resolveDsModelAlias("deepseek-v4-flash")).toBe("flash");
+    expect(resolveDsModelAlias("deepseek-v4-pro")).toBe("pro");
+    expect(resolveDsModelAlias("deepseek-v4-pro[1m]")).toBe("pro");
+  });
+  test("rejects unknown", () => {
+    expect(() => resolveDsModelAlias("opus")).toThrow(/flash\|pro/);
+  });
+});
+
+describe("claude-ds -Model", () => {
+  test("shim path passes -Model deepseek-v4-flash by default", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    try {
+      const plan = claudeDsAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+      });
+      expect(plan.command).toContain("-Model");
+      expect(plan.command).toContain("deepseek-v4-flash");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+    }
+  });
+  test("pro alias maps to deepseek-v4-pro", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    try {
+      const plan = claudeDsAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+        model: "pro",
+      });
+      expect(plan.command).toContain("deepseek-v4-pro");
+      expect(plan.command).not.toContain("deepseek-v4-flash");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+    }
+  });
+});
+
+describe("deepseek adapter slot", () => {
+  test("health is not ok and buildLaunch throws", () => {
+    expect(deepseekAdapter.health().ok).toBe(false);
+    expect(() =>
+      deepseekAdapter.buildLaunch({
+        promptFile: "/tmp/p",
+        cwd: "/tmp",
+        alwaysApprove: true,
+      }),
+    ).toThrow(/not available/);
+  });
+});
+
 describe("util", () => {
   test("shellQuote", () => {
     expect(shellQuote("a b")).toBe("'a b'");

package/src/cli.ts

@@ -1,10 +1,18 @@
 #!/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, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
-import { config, WORKERS, LANES, type WorkerKind, type Lane } from "./config.ts";
+import {
+  config,
+  WORKERS,
+  LANES,
+  resolveDsModelAlias,
+  type WorkerKind,
+  type Lane,
+  type DsModelAlias,
+} from "./config.ts";
 import { runHealth, printHealth } from "./health.ts";
 import {
   startJob,
@@ -27,7 +35,7 @@ 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,13 +52,14 @@ 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; deepseek = reserved slot)
+  --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
+  --model <flash|pro>                   Mid DeepSeek model (default: flash). Ignored by grok/openrouter
+  --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
@@ -58,8 +67,12 @@ Env:
   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_DS_MODEL              Default mid model flash|pro (overridden by --model)
   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);
 }
@@ -149,6 +162,12 @@ function asLane(v: unknown): Lane | undefined {
   throw new Error(`Invalid --lane ${v}; expected ${LANES.join("|")}`);
 }
 
+function asDsModel(v: unknown): DsModelAlias | undefined {
+  if (v === undefined || v === true) return undefined;
+  if (typeof v !== "string") throw new Error(`Invalid --model; expected flash|pro`);
+  return resolveDsModelAlias(v);
+}
+
 function refuseSecrets(text: string, context: string): void {
   if (looksLikeSecretMaterial(text)) {
     console.error(
@@ -213,8 +232,16 @@ async function main() {
   if (cmd === "start") {
     requireStringFlag(f, "worker");
     requireStringFlag(f, "lane");
+    requireStringFlag(f, "model");
     const promptFile = requireStringFlag(f, "prompt-file");
     const dirFlag = requireStringFlag(f, "dir");
+    let model: DsModelAlias | undefined;
+    try {
+      model = asDsModel(f.model);
+    } catch (e) {
+      console.error((e as Error).message);
+      process.exit(2);
+    }
 
     let prompt = "";
     if (promptFile) {
@@ -252,6 +279,7 @@ async function main() {
       prompt,
       worker: asWorker(f.worker),
       lane: asLane(f.lane),
+      model,
       cwd,
       alwaysApprove: !f.ask,
       dryRun: Boolean(f.dryRun),
@@ -277,9 +305,11 @@ async function main() {
     } else if (result.dryRun) {
       console.log(`dry-run job ${result.job.id}`);
       console.log(`worker: ${result.job.worker}`);
+      if (result.job.model) console.log(`model:  ${result.job.model}`);
       console.log(`command: ${redactSecrets(result.command || "")}`);
     } else {
-      console.log(`started ${result.job.id} (${result.job.worker})`);
+      const modelNote = result.job.model ? `/${result.job.model}` : "";
+      console.log(`started ${result.job.id} (${result.job.worker}${modelNote})`);
       console.log(`session: ${result.job.tmuxSession}`);
       if (String(result.job.tmuxSession).startsWith("headless-")) {
         console.log(`mode:    headless (--no-tmux); use capture/status (no attach/send)`);

package/src/config.ts

@@ -2,11 +2,40 @@ 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";
+/** Workers with a live adapter. `deepseek` is a reserved slot (unreleased harness). */
+export type WorkerKind = "grok" | "claude-ds" | "openrouter" | "deepseek";
+export type Lane = "easy" | "mid" | "hard";
 
-export const WORKERS: WorkerKind[] = ["grok", "claude-ds"];
-export const LANES: Lane[] = ["mid", "hard"];
+/** Public CLI aliases for mid-lane DeepSeek models. */
+export type DsModelAlias = "flash" | "pro";
+
+export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter", "deepseek"];
+export const LANES: Lane[] = ["easy", "mid", "hard"];
+export const DS_MODELS: DsModelAlias[] = ["flash", "pro"];
+
+export const DS_MODEL_IDS: Record<DsModelAlias, string> = {
+  flash: "deepseek-v4-flash",
+  pro: "deepseek-v4-pro",
+};
+
+/** Resolve --model flash|pro (or full deepseek-v4-* id) to a CLI alias. Default: flash. */
+export function resolveDsModelAlias(raw?: string | null): DsModelAlias {
+  if (!raw || !raw.trim()) return "flash";
+  const v = raw.trim().toLowerCase();
+  if (v === "flash" || v === "deepseek-v4-flash") return "flash";
+  if (v === "pro" || v === "deepseek-v4-pro" || v === "deepseek-v4-pro[1m]") return "pro";
+  throw new Error(`Invalid --model ${raw}; expected flash|pro`);
+}
+
+/** 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;
@@ -24,7 +53,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.4",
+  version: "0.1.6",
   get jobsDir(): string {
     return defaultJobsDir();
   },
@@ -32,9 +61,12 @@ export const config = {
   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,
   },
+  /** Default mid DeepSeek model (Flash = cheap execute). Override: --model pro */
+  defaultDsModel: "flash" as DsModelAlias,
   jobsListLimit: 20,
   /** Max simultaneously active (running|pending) jobs. Override: CURSOR_ROUTE_MAX_JOBS. */
   get maxConcurrentJobs(): number {

package/src/integration.test.ts

@@ -134,6 +134,13 @@ describe("fake-worker integration (headless, no tmux)", () => {
     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 () => {

package/src/jobs.ts

@@ -12,7 +12,13 @@ import {
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
-import { config, sessionName, type Lane, type WorkerKind } from "./config.ts";
+import {
+  config,
+  sessionName,
+  type Lane,
+  type WorkerKind,
+  type DsModelAlias,
+} from "./config.ts";
 import { getAdapter } from "./adapters/index.ts";
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
@@ -29,6 +35,8 @@ export interface Job {
   status: JobStatus;
   worker: WorkerKind;
   lane?: Lane;
+  /** Mid-lane DeepSeek model alias (flash|pro). Only set for claude-ds. */
+  model?: DsModelAlias;
   prompt: string;
   cwd: string;
   alwaysApprove: boolean;
@@ -221,6 +229,8 @@ export interface StartOptions {
   prompt: string;
   worker?: WorkerKind;
   lane?: Lane;
+  /** Mid-lane DeepSeek: flash (default) | pro. Ignored by grok/openrouter. */
+  model?: DsModelAlias;
   cwd?: string;
   alwaysApprove?: boolean;
   dryRun?: boolean;
@@ -268,12 +278,16 @@ export function startJob(opts: StartOptions): {
   const paths = jobPaths(id);
   writeSecure(paths.prompt, opts.prompt);
 
+  const model =
+    worker === "claude-ds" ? opts.model ?? config.defaultDsModel : undefined;
+
   let plan;
   try {
     plan = adapter.buildLaunch({
       promptFile: paths.prompt,
       cwd,
       alwaysApprove,
+      model,
     });
   } catch (e) {
     try {
@@ -290,6 +304,7 @@ export function startJob(opts: StartOptions): {
     status: "pending",
     worker,
     lane: opts.lane,
+    model,
     prompt: opts.prompt,
     cwd,
     alwaysApprove: plan.alwaysApprove,

package/src/openrouter-run.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+/**
+ * One-shot OpenRouter easy-lane runner — reads a prompt file and POSTs it to
+ * OpenRouter's chat/completions, printing the assistant reply to stdout.
+ * No runtime npm deps (Node 20+ global fetch). Invoked by the openrouter
+ * adapter (dist via node, else src via bun). Never echoes OPENROUTER_API_KEY.
+ */
+import { readFileSync } from "node:fs";
+import { openRouterModel, openRouterBaseUrl } from "./config.ts";
+import { looksLikeSecretMaterial } from "./secrets.ts";
+
+const SYSTEM_PROMPT =
+  "You are a drafting/rewrite helper for cursor-route. Never invent credentials, API keys, or secrets; if asked for secret material, refuse. Provide educational, general-purpose help.";
+
+function fail(msg: string, code: number): never {
+  console.error(`cursor-route/openrouter-run: ${msg}`);
+  process.exit(code);
+}
+
+function parseArgs(argv: string[]): { promptFile?: string } {
+  const flags: { promptFile?: string } = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      console.log(
+        "usage: cursor-route/openrouter-run --prompt-file <path>\n" +
+          "env: OPENROUTER_API_KEY (required), CURSOR_ROUTE_OPENROUTER_MODEL, OPENROUTER_BASE_URL",
+      );
+      process.exit(0);
+    }
+    if (a === "--prompt-file") {
+      const v = argv[i + 1];
+      if (!v || v.startsWith("--")) fail("--prompt-file requires a value", 2);
+      flags.promptFile = v;
+      i++;
+    } else if (a.startsWith("--prompt-file=")) {
+      flags.promptFile = a.slice("--prompt-file=".length);
+    } else {
+      fail(`unknown argument: ${a}`, 2);
+    }
+  }
+  return flags;
+}
+
+async function main(): Promise<void> {
+  const { promptFile } = parseArgs(process.argv.slice(2));
+  if (!promptFile) fail("--prompt-file <path> is required", 2);
+
+  let prompt: string;
+  try {
+    prompt = readFileSync(promptFile, "utf8");
+  } catch (e) {
+    fail(`cannot read prompt file: ${(e as Error).message}`, 2);
+  }
+  if (!prompt.trim()) fail("prompt file is empty", 2);
+  if (looksLikeSecretMaterial(prompt)) {
+    fail("refusing prompt: looks like secret key material — easy lane is for non-secret drafts", 3);
+  }
+
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) fail("OPENROUTER_API_KEY is not set", 2);
+
+  const base = openRouterBaseUrl().replace(/\/+$/, "");
+  const url = `${base}/chat/completions`;
+
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        // OpenRouter etiquette: identify the app so the provider can see usage source.
+        "HTTP-Referer": "https://github.com/cemini23/cursor-route",
+        "X-Title": "cursor-route",
+      },
+      body: JSON.stringify({
+        model: openRouterModel(),
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+  } catch (e) {
+    fail(`network error calling ${url}: ${(e as Error).message}`, 1);
+  }
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    fail(`OpenRouter API ${res.status}: ${body.slice(0, 500)}`, 1);
+  }
+
+  const json = (await res.json()) as {
+    choices?: Array<{ message?: { content?: string } }>;
+  };
+  const content = json.choices?.[0]?.message?.content ?? "";
+  if (!content) fail("OpenRouter returned no assistant content", 1);
+  process.stdout.write(content.endsWith("\n") ? content : content + "\n");
+}
+
+main().catch((e) => fail(e instanceof Error ? e.message : String(e), 1));