cursor-route 0.1.1 → 0.1.5

package/README.md

@@ -1,6 +1,6 @@
 # cursor-route
 
-**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.**
 
 Lane-aware `/route` orchestration in tmux — not another multi-provider fleet, not a Codex clone.
 
@@ -17,7 +17,7 @@ cursor-route capture <jobId>
 |---------|-------|---------|------|
 | [codex-orchestrator](https://github.com/kingbootoshi/codex-orchestrator) | Claude Code | Codex | Viral tmux panes |
 | [CAO](https://github.com/awslabs/cli-agent-orchestrator) | Supervisor CLI | Many (incl. Cursor CLI) | Enterprise MCP + Web UI |
-| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds** | Cost-aware lanes you already pay for |
+| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds + OpenRouter (easy)** | Cost-aware lanes you already pay for |
 
 If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop paying a third coding agent just to parallelize.
 
@@ -28,6 +28,7 @@ If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop payin
 | Cursor | Premium plan | Plan / synthesize / verify (orchestrator) |
 | Grok CLI | X Premium | `--lane hard` implement |
 | DeepSeek via claude-ds | DeepSeek API / plan | `--lane mid` implement |
+| OpenRouter free models | OpenRouter API (free tier) | `--lane easy` wording/drafts — non-secret prompts only (see Security) |
 | Codex / extra Claude | Optional | Not required for v0 |
 
 Exact dollars vary — the point is **reuse subscriptions you already have**.
@@ -41,12 +42,13 @@ Exact dollars vary — the point is **reuse subscriptions you already have**.
 | [tmux](https://github.com/tmux/tmux) | Worker panes |
 | [Bun](https://bun.sh) *(or Node 20+)* | Runs the CLI |
 | [Grok CLI](https://x.ai/cli) and/or Claude Code + DeepSeek (`claude-ds`) | Workers |
+| OpenRouter API key (`OPENROUTER_API_KEY`) | Easy lane (`--lane easy` / `--worker openrouter`) |
 | `script(1)` | Job logs (macOS/Linux) |
 
 ```bash
 # Prerequisites
 brew install tmux          # or build tmux into ~/.local
-# Bun optional — Node 20+ works via pinned tsx
+# Bun or Node 20+ — npm package ships compiled dist/ (Node runs it directly)
 
 # Preferred install
 npm i -g cursor-route
@@ -54,9 +56,10 @@ npm i -g cursor-route
 # Auth workers
 grok login                 # if using Grok
 # configure claude-ds — see DeepSeek setup below
+export OPENROUTER_API_KEY=...   # if using the easy lane (see OpenRouter setup below)
 
 cursor-route health
-# without tmux (CI / headless):
+# without tmux / workers (CI / headless infra smoke):
 CURSOR_ROUTE_RELAXED=1 cursor-route health
 ```
 
@@ -98,6 +101,7 @@ Then say **`/route-orch`** or **spawn workers** in Cursor — the skill delegate
 
 | Lane | Worker | Intent |
 |------|--------|--------|
+| `easy` | `openrouter` | Wording / drafts on OpenRouter free models (non-secret prompts only — see Security) |
 | `mid` | `claude-ds` | Default implement on DeepSeek |
 | `hard` | `grok` | Hard implement on Grok CLI |
 
@@ -130,6 +134,25 @@ Persist the same vars under `~/.claude/settings.json` → `"env": { … }` if yo
 
 No DeepSeek yet? Use `--lane hard` / `--worker grok` (X Premium).
 
+## OpenRouter setup (the free easy lane)
+
+`--lane easy` / `--worker openrouter` sends wording/draft prompts to OpenRouter's
+free model route (`openrouter/free`). Get a key at [openrouter.ai/keys](https://openrouter.ai/keys).
+
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...        # from openrouter.ai/keys
+# optional:
+export CURSOR_ROUTE_OPENROUTER_MODEL=openrouter/free   # default
+export OPENROUTER_BASE_URL=https://openrouter.ai/api/v1  # default
+
+cursor-route health          # worker:openrouter should be ✓
+cursor-route start --lane easy "Rewrite this FAQ answer in 3 sentences"
+```
+
+**Non-secret prompts only:** free OpenRouter models may log prompts, so the easy lane is for
+**wording/drafts without credentials**. The same refuse gate as every lane blocks
+key-shaped material in `start` / `send`, and the runner re-checks the prompt file.
+
 ## Jobs directory
 
 Jobs default to `~/.local/share/cursor-route/jobs` (override with `CURSOR_ROUTE_JOBS_DIR`).
@@ -141,21 +164,65 @@ This is **not** inside a git clone of this repo.
 - See [SECURITY.md](./SECURITY.md)
 - Local orchestration only — no LIVE Discord / trading egress demos
 
-## Also from Cemini
+## FAQ
+
+**What is cursor-route?**  
+cursor-route is a public MIT CLI and Cursor skill that runs parallel coding workers in tmux while Cursor remains the planner. DeepSeek handles the mid lane, Grok CLI handles the hard lane, and OpenRouter free models handle the easy lane for wording/drafts.
+
+**How is this different from Codex orchestrator?**  
+It uses the familiar strategist and worker-pane shape, but it is not a Codex clone. cursor-route uses Cursor as the planner and DeepSeek plus Grok CLI as workers. Codex is not required.
+
+**Does mid lane use Anthropic Claude?**  
+No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic` and a DeepSeek key in `ANTHROPIC_AUTH_TOKEN`.
+
+**How do I install?**  
+Run `npm i -g cursor-route`, install tmux if needed, then run `cursor-route health`. The package is available at https://www.npmjs.com/package/cursor-route, and the source is at https://github.com/cemini23/cursor-route.
+
+**Is it free?**  
+The cursor-route code is open source under MIT. It does not make the worker services free. Your costs depend on Cursor, DeepSeek API usage, and the Grok access or balance available to you. The easy lane can be free on OpenRouter's free-model route (`openrouter/free`).
+
+## Related
+
+- Newsletter: [Outlier Weekly](https://outlierweekly.substack.com)
+- YouTube: [@Cemini23](https://www.youtube.com/@Cemini23)
+- Agent meta-wiki: [cemini-claude-code-CCC](https://github.com/cemini23/cemini-claude-code-CCC)
+- Products: [Atto](https://youratto.com) · [GuruWatcher](https://guruwatcher.com)
+- Agent toolkit: [vet](https://github.com/cemini23/vet) · [wikilint](https://github.com/cemini23/wikilint) · [phase0](https://github.com/cemini23/phase0) · [agent-toolkit-demo](https://github.com/cemini23/agent-toolkit-demo) · [ara-schema](https://github.com/cemini23/ara-schema) · [cursor-audit](https://github.com/cemini23/agent-toolkit-demo/tree/main/skills/cursor-audit) · [super-audit](https://github.com/cemini23/agent-toolkit-demo/tree/main/skills/super-audit)
+- Public wikis: [Gambling](https://github.com/cemini23/Gambling-wiki) · [Game Dev](https://github.com/cemini23/Game-Dev-wiki) · [SEO/GEO](https://github.com/cemini23/SEO-GEO-B-M-Wiki) · [Cybersecurity](https://github.com/cemini23/Cybersecurity-wiki) · [3D Printing](https://github.com/cemini23/3D-Printing-Wiki) · [Image Gen](https://github.com/cemini23/uncensored-image-gen-wiki)
+- Trading: [world-cup-bot](https://github.com/cemini23/world-cup-bot)
+- Donation wallets (canonical): [SUPPORT.md](SUPPORT.md)
+
+## Support
+
+Thank you for your support — stars, issues, shares, and tips all help keep this CLI and the broader Cemini open-research stack alive.
+
+If you’d like to tip, use the **donation-only** addresses below (not trading or production wallets). Prefer following the work? These are the best places to start:
+
+| Project | Link |
+|---------|------|
+| **Outlier Weekly** (methodology newsletter) | [outlierweekly.substack.com](https://outlierweekly.substack.com) |
+| **Atto** — organize Italian family documents on your computer | [youratto.com](https://youratto.com) |
+| **GuruWatcher** — Discord alerts for your newsletter’s price levels | [guruwatcher.com](https://guruwatcher.com) |
+| **YouTube** | [@Cemini23](https://www.youtube.com/@Cemini23) |
+
+| Chain family | Address |
+|--------------|---------|
+| **EVM** (Ethereum, Polygon, Base, Arbitrum, …) | `0x444C5C2eC439E0382aa5a17F70313c536BcC5D58` |
+| **Solana / SVM** | `J4zNn4hK9jTrKBFY8sbAGJHLoZvXvQf4B9pQSbSrocZE` |
+| **Polymarket** (referral) | [polymarket.com/?r=Cemini23](https://polymarket.com/?r=Cemini23) |
+
+Full wallet note: [SUPPORT.md](SUPPORT.md) · canon also in [CCC SUPPORT.md](https://github.com/cemini23/cemini-claude-code-CCC/blob/main/SUPPORT.md).
 
-- [Atto](https://youratto.com) — genealogy / archival agents  
-- [GuruWatcher](https://guruwatcher.com) — alert workflows  
-- Cemini research & trading tooling (private)
+We’re grateful you’re here. Thank you for your support.
 
 ## License
 
-MIT © Cemini
+MIT © Cemini — see [LICENSE](LICENSE).
 
 ## Roadmap (explicitly later)
 
-- npm publish + Homebrew tap  
+- Homebrew tap  
 - Native DeepSeek harness adapter  
 - Codebase map injection (`--map`)  
 - Cursor CLI `agent` as alternate supervisor  
-- Web UI / CAO-style MCP supervisor  
-- OpenRouter easy lane (secrets-safe)
+- Web UI / CAO-style MCP supervisor

package/SECURITY.md

@@ -14,13 +14,16 @@ Do **not** open a public issue for credential leaks or RCE-class bugs.
 ## Hard rules for users and agents
 
 1. **No secrets in prompts or job files.** Do not paste API keys, SSH private keys, Discord tokens, or `.env` contents into `cursor-route start` / `send` prompts.
-2. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
-3. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
-4. **Workers inherit your auth.** Grok CLI and Claude Code / claude-ds use *your* local login. Treat worker panes like you would treat your own shell.
-5. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
+2. **Free OpenRouter easy-lane models may log prompts.** `--lane easy` / `--worker openrouter` is for **non-secret** wording/drafts only. The refuse gate (`start` / `send`, plus the runner's re-check) applies to every lane — never send key-shaped material to the easy lane.
+3. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
+4. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
+5. **Workers inherit your auth.** Grok CLI and Claude Code / claude-ds use *your* local login. Treat worker panes like you would treat your own shell.
+6. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
 
 ## Supply chain
 
-- Runtime dependencies: **none** (Node/Bun + system `tmux` + worker CLIs).
+- Declared runtime npm dependencies: **none**. System needs: Node ≥20 or Bun, `tmux`, worker CLIs (Grok / claude-ds), and an OpenRouter API key for the easy lane.
+- The npm package ships a compiled `dist/` (plain JS, no loader). The bin shim and the completion hook run the compiled JS via `node`; there is **no network fetch of `tsx` on the happy path**.
+- Running from a git clone without a build uses Bun to execute `src/` directly (Bun runs TypeScript natively) — also offline-friendly.
 - Review `package.json` before upgrading.
 - Prefer pinned git tags for production installs.

package/SUPPORT.md

@@ -0,0 +1,24 @@
+# Support Cemini open research
+
+Thank you for your interest — and for any support, large or small. Tips and kind words both help keep Cemini research and tooling open.
+
+Voluntary tips fund wikis, OSS tooling, and public research. **Donation-only addresses** — not trading or production wallets.
+
+| Chain family | Address |
+|--------------|---------|
+| **EVM** (Ethereum, Polygon, Base, Arbitrum, …) | `0x444C5C2eC439E0382aa5a17F70313c536BcC5D58` |
+| **Solana / SVM** | `J4zNn4hK9jTrKBFY8sbAGJHLoZvXvQf4B9pQSbSrocZE` |
+| **Polymarket** (referral) | [polymarket.com/?r=Cemini23](https://polymarket.com/?r=Cemini23) |
+
+If you’d rather follow along or try something we ship:
+
+- Newsletter — [Outlier Weekly](https://outlierweekly.substack.com) (Substack)
+- Genealogy kit — [youratto.com](https://youratto.com)
+- Newsletter parameter alerts — [guruwatcher.com](https://guruwatcher.com)
+- YouTube — [@Cemini23](https://www.youtube.com/@Cemini23)
+- Agent meta-wiki — [cemini-claude-code-CCC](https://github.com/cemini23/cemini-claude-code-CCC)
+- This CLI — [cursor-route](https://github.com/cemini23/cursor-route)
+
+Canonical federation copy: [CCC SUPPORT.md](https://github.com/cemini23/cemini-claude-code-CCC/blob/main/SUPPORT.md).
+
+We’re grateful you’re here. Thank you for your support.

package/bin/cursor-route

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# cursor-route — thin launcher (Bun preferred, Node+tsx fallback)
+# cursor-route — thin launcher (compiled dist via node, else Bun on src)
 set -euo pipefail
 SOURCE="${BASH_SOURCE[0]}"
 while [ -L "$SOURCE" ]; do
@@ -9,16 +9,14 @@ while [ -L "$SOURCE" ]; do
 done
 SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-CLI="$ROOT/src/cli.ts"
 
-if command -v bun >/dev/null 2>&1; then
-  exec bun "$CLI" "$@"
+if [ -f "$ROOT/dist/cli.js" ] && command -v node >/dev/null 2>&1; then
+  exec node "$ROOT/dist/cli.js" "$@"
 fi
 
-if command -v npx >/dev/null 2>&1; then
-  # Pin tsx for supply-chain predictability (no floating --yes latest)
-  exec npx --yes tsx@4.19.4 "$CLI" "$@"
+if command -v bun >/dev/null 2>&1; then
+  exec bun "$ROOT/src/cli.ts" "$@"
 fi
 
-echo "cursor-route: need Bun (https://bun.sh) or Node 20+ with npx" >&2
+echo "cursor-route: no compiled build (run 'bun run build') and no Bun — need Node 20+ or Bun (https://bun.sh)" >&2
 exit 127

package/bin/cursor-route.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 /**
- * npm bin entry — prefers Bun, falls back to pinned tsx.
+ * npm bin redirect — prefers compiled dist (node), else Bun on src.
+ * The shell launcher (bin/cursor-route) is the primary npm bin entry;
+ * this file keeps direct `node bin/cursor-route.js` working the same way.
  */
 import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
-const cli = join(root, "src", "cli.ts");
 const args = process.argv.slice(2);
 
 function run(cmd, cmdArgs) {
@@ -16,11 +18,12 @@ function run(cmd, cmdArgs) {
   process.exit(r.status ?? 1);
 }
 
-const bun = spawnSync("bun", ["--version"], { encoding: "utf8" });
-if (bun.status === 0) {
-  run("bun", [cli, ...args]);
+function main() {
+  const distCli = join(root, "dist", "cli.js");
+  if (existsSync(distCli) && run("node", [distCli, ...args]) !== null) return;
+  if (run("bun", [join(root, "src", "cli.ts"), ...args]) !== null) return;
+  console.error("cursor-route: no compiled build (run 'bun run build') and no Bun — need Node 20+ or Bun (https://bun.sh)");
+  process.exit(127);
 }
 
-run("npx", ["--yes", "tsx@4.19.4", cli, ...args]);
-console.error("cursor-route: need Bun (https://bun.sh) or Node 20+ with npx");
-process.exit(127);
+main();

package/dist/adapters/claude-ds.js

@@ -0,0 +1,189 @@
+import { execSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { shellQuote } from "../util.js";
+/**
+ * Mid-lane = DeepSeek (cheap). The Claude Code binary is only a harness —
+ * requests must hit DeepSeek, not Anthropic.
+ *
+ * Resolution order:
+ * 1. claude-ds / deepseek-claude shims
+ * 2. stock `claude` when ANTHROPIC_BASE_URL (env or ~/.claude/settings.json)
+ *    points at api.deepseek.com — auto-ok, no opt-in
+ * 3. stock `claude` on Anthropic only if CURSOR_ROUTE_ALLOW_ANTHROPIC=1
+ *    (explicit expensive escape hatch — not the product default)
+ */
+function which(cmd) {
+    try {
+        return (execSync(`command -v ${shellQuote(cmd)}`, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+/** True when URL hostname is deepseek.com (or a subdomain). */
+export function isDeepSeekBaseUrl(url) {
+    try {
+        const u = new URL(url);
+        const host = u.hostname.toLowerCase();
+        return host === "deepseek.com" || host.endsWith(".deepseek.com");
+    }
+    catch {
+        return false;
+    }
+}
+function deepseekBaseFromSettings() {
+    // Home settings only — do not trust cwd/.claude/settings.json (spoof / exfil risk)
+    const p = join(homedir(), ".claude", "settings.json");
+    if (!existsSync(p))
+        return null;
+    try {
+        const j = JSON.parse(readFileSync(p, "utf8"));
+        const url = j.env?.ANTHROPIC_BASE_URL;
+        if (url && isDeepSeekBaseUrl(url))
+            return url;
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+/** Resolved DeepSeek base URL for the mid-lane harness, or null. */
+export function resolvedDeepSeekBaseUrl() {
+    for (const candidate of [
+        process.env.ANTHROPIC_BASE_URL,
+        process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL,
+        deepseekBaseFromSettings(),
+    ]) {
+        if (candidate && isDeepSeekBaseUrl(candidate))
+            return candidate;
+    }
+    return null;
+}
+/** True when Claude Code harness is routed to DeepSeek (cheap path). */
+export function isDeepSeekRouted() {
+    return Boolean(resolvedDeepSeekBaseUrl());
+}
+function resolveClaudeDs() {
+    // Env override lets tests pin a fake claude-ds (and power users pick a specific binary).
+    if (process.env.CURSOR_ROUTE_CLAUDE_DS_BIN) {
+        return {
+            binary: process.env.CURSOR_ROUTE_CLAUDE_DS_BIN,
+            mode: "claude-ds (CURSOR_ROUTE_CLAUDE_DS_BIN override)",
+        };
+    }
+    for (const c of [
+        { cmd: "claude-ds", mode: "claude-ds (DeepSeek shim)" },
+        { cmd: "deepseek-claude", mode: "deepseek-claude" },
+    ]) {
+        const path = which(c.cmd);
+        if (path)
+            return { binary: path, mode: c.mode };
+    }
+    const claude = which("claude");
+    if (!claude)
+        return null;
+    if (isDeepSeekRouted()) {
+        return {
+            binary: claude,
+            mode: "claude → DeepSeek (ANTHROPIC_BASE_URL)",
+        };
+    }
+    // Expensive Anthropic path — opt-in only so we never silently bill frontier rates
+    if (process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC === "1" ||
+        process.env.CURSOR_ROUTE_ALLOW_STOCK_CLAUDE === "1" // legacy alias
+    ) {
+        return {
+            binary: claude,
+            mode: "claude → Anthropic (CURSOR_ROUTE_ALLOW_ANTHROPIC=1)",
+        };
+    }
+    return null;
+}
+/**
+ * Env that must reach stock `claude` for DeepSeek routing.
+ * Passed via process/tmux env — never interpolated into the printed command.
+ */
+function deepSeekWorkerEnv() {
+    const base = resolvedDeepSeekBaseUrl();
+    if (!base)
+        return undefined;
+    const env = { ANTHROPIC_BASE_URL: base };
+    const token = process.env.ANTHROPIC_AUTH_TOKEN ||
+        process.env.ANTHROPIC_API_KEY ||
+        process.env.DEEPSEEK_API_KEY ||
+        "";
+    if (token)
+        env.ANTHROPIC_AUTH_TOKEN = token;
+    const model = process.env.ANTHROPIC_MODEL;
+    if (model)
+        env.ANTHROPIC_MODEL = model;
+    return env;
+}
+export const claudeDsAdapter = {
+    kind: "claude-ds",
+    label: "DeepSeek (via Claude Code harness)",
+    health() {
+        const resolved = resolveClaudeDs();
+        if (!resolved) {
+            const hasClaude = Boolean(which("claude"));
+            return {
+                worker: "claude-ds",
+                ok: false,
+                binary: null,
+                detail: hasClaude
+                    ? "claude on PATH but ANTHROPIC_BASE_URL is not DeepSeek — set https://api.deepseek.com/anthropic (see README). Refusing Anthropic default so mid-lane stays cheap."
+                    : "need claude-ds, deepseek-claude, or claude + DeepSeek ANTHROPIC_BASE_URL — see README DeepSeek setup",
+            };
+        }
+        return {
+            worker: "claude-ds",
+            ok: true,
+            binary: resolved.binary,
+            detail: `ok (${resolved.mode})`,
+        };
+    },
+    buildLaunch({ promptFile, cwd, alwaysApprove }) {
+        const resolved = resolveClaudeDs();
+        if (!resolved) {
+            throw new Error("DeepSeek worker not available — run: cursor-route health");
+        }
+        const ask = process.env.CURSOR_ROUTE_ASK === "1" || process.env.CLAUDE_DS_ASK === "1";
+        const skip = alwaysApprove && !ask;
+        // Stock `claude` needs DeepSeek env injected into the worker process
+        // (tmux panes may not inherit client env from a long-lived server).
+        const env = resolved.mode.startsWith("claude → DeepSeek") ? deepSeekWorkerEnv() : undefined;
+        if (resolved.mode.startsWith("claude-ds")) {
+            const parts = [
+                shellQuote(resolved.binary),
+                "-PromptFile",
+                shellQuote(promptFile),
+            ];
+            if (skip)
+                parts.push("--dangerously-skip-permissions");
+            return {
+                worker: "claude-ds",
+                command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
+                alwaysApprove: skip,
+                env,
+            };
+        }
+        const parts = [
+            shellQuote(resolved.binary),
+            "-p",
+            `"$(cat ${shellQuote(promptFile)})"`,
+        ];
+        if (skip)
+            parts.push("--dangerously-skip-permissions");
+        return {
+            worker: "claude-ds",
+            command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
+            alwaysApprove: skip,
+            env,
+        };
+    },
+};

package/dist/adapters/grok.js

@@ -0,0 +1,57 @@
+import { execSync } from "node:child_process";
+import { shellQuote } from "../util.js";
+function findGrok() {
+    // Env override lets tests pin a fake grok (and power users pick a specific binary).
+    if (process.env.CURSOR_ROUTE_GROK_BIN)
+        return process.env.CURSOR_ROUTE_GROK_BIN;
+    try {
+        return (execSync("command -v grok", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+export const grokAdapter = {
+    kind: "grok",
+    label: "Grok CLI (xAI)",
+    health() {
+        const binary = findGrok();
+        if (!binary) {
+            return {
+                worker: "grok",
+                ok: false,
+                binary: null,
+                detail: "grok not on PATH — install from https://x.ai/cli then run: grok login",
+            };
+        }
+        return {
+            worker: "grok",
+            ok: true,
+            binary,
+            detail: "ok (auth checked at first start — run grok login if jobs fail)",
+        };
+    },
+    buildLaunch({ promptFile, cwd, alwaysApprove }) {
+        const binary = findGrok() || "grok";
+        const parts = [
+            shellQuote(binary),
+            "-p",
+            `"$(cat ${shellQuote(promptFile)})"`,
+            "--cwd",
+            shellQuote(cwd),
+            "--no-auto-update",
+            "--output-format",
+            "plain",
+        ];
+        if (alwaysApprove)
+            parts.push("--always-approve");
+        return {
+            worker: "grok",
+            command: parts.join(" "),
+            alwaysApprove,
+        };
+    },
+};

package/dist/adapters/index.js

@@ -0,0 +1,17 @@
+import { grokAdapter } from "./grok.js";
+import { claudeDsAdapter } from "./claude-ds.js";
+import { openRouterAdapter } from "./openrouter.js";
+const registry = {
+    grok: grokAdapter,
+    "claude-ds": claudeDsAdapter,
+    openrouter: openRouterAdapter,
+};
+export function getAdapter(worker) {
+    const a = registry[worker];
+    if (!a)
+        throw new Error(`Unknown worker: ${worker}`);
+    return a;
+}
+export function allAdapters() {
+    return Object.values(registry);
+}

package/dist/adapters/openrouter.js

@@ -0,0 +1,78 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { shellQuote } from "../util.js";
+import { openRouterModel, openRouterBaseUrl } from "../config.js";
+/**
+ * Resolve how to invoke the one-shot runner. Prefer the compiled dist via node
+ * (no loader); else Bun on src. No npx/tsx — same policy as mark-complete.
+ */
+function resolveRunner() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const compiled = join(here, "..", "..", "dist", "openrouter-run.js");
+    if (existsSync(compiled)) {
+        return { command: `node ${shellQuote(compiled)}` };
+    }
+    const srcFile = join(here, "..", "openrouter-run.ts");
+    if (existsSync(srcFile)) {
+        return { command: `bun ${shellQuote(srcFile)}` };
+    }
+    return null;
+}
+function openRouterEnv() {
+    const key = process.env.OPENROUTER_API_KEY;
+    if (!key)
+        return undefined;
+    const env = { OPENROUTER_API_KEY: key };
+    const model = process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+    if (model)
+        env.CURSOR_ROUTE_OPENROUTER_MODEL = model;
+    const base = process.env.OPENROUTER_BASE_URL;
+    if (base)
+        env.OPENROUTER_BASE_URL = base;
+    return env;
+}
+export const openRouterAdapter = {
+    kind: "openrouter",
+    label: "OpenRouter (free easy lane)",
+    health() {
+        const runner = resolveRunner();
+        if (!process.env.OPENROUTER_API_KEY) {
+            return {
+                worker: "openrouter",
+                ok: false,
+                binary: runner?.command ?? null,
+                detail: "OPENROUTER_API_KEY not set — export your OpenRouter key (easy lane model defaults to openrouter/free)",
+            };
+        }
+        if (!runner) {
+            return {
+                worker: "openrouter",
+                ok: false,
+                binary: null,
+                detail: "openrouter-run not found — run bun run build (or use Bun from a source clone)",
+            };
+        }
+        return {
+            worker: "openrouter",
+            ok: true,
+            binary: runner.command,
+            detail: `ok (model ${openRouterModel()} @ ${openRouterBaseUrl()})`,
+        };
+    },
+    buildLaunch({ promptFile }) {
+        const runner = resolveRunner();
+        if (!runner)
+            throw new Error("openrouter runner not available — run: bun run build");
+        // Missing key is tolerated here so `--dry-run` can still print the command;
+        // real starts are gated by the health preflight (which requires the key).
+        const env = openRouterEnv();
+        // No interactive approval concept for a pure HTTP call — nothing to auto-approve.
+        return {
+            worker: "openrouter",
+            command: `${runner.command} --prompt-file ${shellQuote(promptFile)}`,
+            alwaysApprove: false,
+            env,
+        };
+    },
+};

package/dist/adapters/types.js

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