cursor-route 0.1.5 → 0.1.7

package/src/cli.ts

@@ -4,7 +4,15 @@
  */
 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,
+  resolveDsModel,
+  type WorkerKind,
+  type Lane,
+  type DsModelAlias,
+} from "./config.ts";
 import { runHealth, printHealth } from "./health.ts";
 import {
   startJob,
@@ -44,8 +52,9 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok)
+  --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 only (default: flash / CURSOR_ROUTE_DS_MODEL). Parsed only for claude-ds
   --dir <path>                          Working directory (default: cwd)
   --ask                                 Disable always-approve for this job
   --dry-run                             Print launch command; do not start
@@ -57,7 +66,8 @@ Env:
   CURSOR_ROUTE_JOBS_DIR              Override jobs dir (default: ~/.local/share/cursor-route/jobs)
   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_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default; --model ignored)
+  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro (or deepseek-v4-pro[1m]); 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)
@@ -152,6 +162,12 @@ function asLane(v: unknown): Lane | undefined {
   throw new Error(`Invalid --lane ${v}; expected ${LANES.join("|")}`);
 }
 
+function asDsModelChoice(v: unknown): { alias: DsModelAlias; id: string } | undefined {
+  if (v === undefined || v === true) return undefined;
+  if (typeof v !== "string") throw new Error(`Invalid --model; expected flash|pro`);
+  return resolveDsModel(v);
+}
+
 function refuseSecrets(text: string, context: string): void {
   if (looksLikeSecretMaterial(text)) {
     console.error(
@@ -216,9 +232,38 @@ 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 worker: WorkerKind | undefined;
+    let lane: Lane | undefined;
+    try {
+      worker = asWorker(f.worker);
+      lane = asLane(f.lane);
+    } catch (e) {
+      console.error((e as Error).message);
+      process.exit(2);
+    }
+    const resolvedWorker =
+      worker ?? (lane ? config.laneWorkers[lane] : config.defaultWorker);
+
+    let model: DsModelAlias | undefined;
+    let modelId: string | undefined;
+    // --model is DeepSeek/claude-ds only; ignore (do not validate) for other workers
+    if (f.model !== undefined && resolvedWorker === "claude-ds") {
+      try {
+        const choice = asDsModelChoice(f.model);
+        if (choice) {
+          model = choice.alias;
+          modelId = choice.id;
+        }
+      } catch (e) {
+        console.error((e as Error).message);
+        process.exit(2);
+      }
+    }
+
     let prompt = "";
     if (promptFile) {
       const p = resolve(promptFile);
@@ -253,8 +298,10 @@ async function main() {
 
     const result = startJob({
       prompt,
-      worker: asWorker(f.worker),
-      lane: asLane(f.lane),
+      worker,
+      lane,
+      model,
+      modelId,
       cwd,
       alwaysApprove: !f.ask,
       dryRun: Boolean(f.dryRun),
@@ -280,9 +327,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)`);
@@ -306,8 +355,9 @@ async function main() {
     } else {
       for (const j of jobs) {
         const age = j.startedAt || j.createdAt;
+        const modelCol = j.model ? j.model.padEnd(6) : "".padEnd(6);
         console.log(
-          `${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`,
+          `${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${modelCol}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`,
         );
       }
     }
@@ -339,7 +389,9 @@ async function main() {
     const view = { ...job, sessionAlive: alive };
     if (json) console.log(JSON.stringify(view, null, 2));
     else {
-      console.log(`${job.id}  ${job.status}  worker=${job.worker}  sessionAlive=${alive}`);
+      console.log(
+        `${job.id}  ${job.status}  worker=${job.worker}${job.model ? `  model=${job.model}` : ""}  sessionAlive=${alive}`,
+      );
       if (job.error) console.log(`error: ${job.error}`);
     }
     return;

package/src/config.ts

@@ -2,11 +2,63 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.ts";
 
-export type WorkerKind = "grok" | "claude-ds" | "openrouter";
+/** 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", "openrouter"];
+/** Public CLI aliases for mid-lane DeepSeek models. */
+export type DsModelAlias = "flash" | "pro";
+
+export interface DsModelChoice {
+  alias: DsModelAlias;
+  /** Exact id passed to claude-ds `-Model` / stock `claude --model`. */
+  id: string;
+}
+
+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 / env to alias + concrete model id.
+ * Preserves `deepseek-v4-pro[1m]` (does not silently strip the SKU).
+ * Empty → Flash.
+ */
+export function resolveDsModel(raw?: string | null): DsModelChoice {
+  if (!raw || !raw.trim()) {
+    return { alias: "flash", id: DS_MODEL_IDS.flash };
+  }
+  const v = raw.trim().toLowerCase();
+  if (v === "flash" || v === "deepseek-v4-flash") {
+    return { alias: "flash", id: DS_MODEL_IDS.flash };
+  }
+  if (v === "pro" || v === "deepseek-v4-pro") {
+    return { alias: "pro", id: DS_MODEL_IDS.pro };
+  }
+  if (v === "deepseek-v4-pro[1m]") {
+    return { alias: "pro", id: "deepseek-v4-pro[1m]" };
+  }
+  throw new Error(`Invalid --model ${raw}; expected flash|pro`);
+}
+
+/** Alias-only helper (tests / callers that do not need the concrete id). */
+export function resolveDsModelAlias(raw?: string | null): DsModelAlias {
+  return resolveDsModel(raw).alias;
+}
+
+/**
+ * Mid default from env: CURSOR_ROUTE_DS_MODEL, else ANTHROPIC_MODEL, else flash.
+ * Throws if the env value is set but invalid (fail loud on start).
+ */
+export function defaultDsModelFromEnv(): DsModelChoice {
+  const raw = process.env.CURSOR_ROUTE_DS_MODEL || process.env.ANTHROPIC_MODEL;
+  return resolveDsModel(raw);
+}
 
 /** OpenRouter model for the easy lane (env CURSOR_ROUTE_OPENROUTER_MODEL). */
 export function openRouterModel(): string {
@@ -34,7 +86,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.5",
+  version: "0.1.7",
   get jobsDir(): string {
     return defaultJobsDir();
   },
@@ -46,6 +98,18 @@ export const config = {
     mid: "claude-ds" as WorkerKind,
     hard: "grok" as WorkerKind,
   },
+  /**
+   * Default mid DeepSeek model (Flash = cheap execute).
+   * Live: CURSOR_ROUTE_DS_MODEL / ANTHROPIC_MODEL; invalid env → flash (health-safe).
+   * Override on start: --model. startJob uses defaultDsModelFromEnv() and fails on invalid env.
+   */
+  get defaultDsModel(): DsModelAlias {
+    try {
+      return defaultDsModelFromEnv().alias;
+    } catch {
+      return "flash";
+    }
+  },
   jobsListLimit: 20,
   /** Max simultaneously active (running|pending) jobs. Override: CURSOR_ROUTE_MAX_JOBS. */
   get maxConcurrentJobs(): number {

package/src/jobs.ts

@@ -12,7 +12,15 @@ 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,
+  defaultDsModelFromEnv,
+  DS_MODEL_IDS,
+  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 +37,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 +231,10 @@ export interface StartOptions {
   prompt: string;
   worker?: WorkerKind;
   lane?: Lane;
+  /** Mid-lane DeepSeek: flash (default) | pro. Ignored by grok/openrouter. */
+  model?: DsModelAlias;
+  /** Concrete DeepSeek id (preserves pro[1m]). Derived from --model / env when unset. */
+  modelId?: string;
   cwd?: string;
   alwaysApprove?: boolean;
   dryRun?: boolean;
@@ -268,12 +282,36 @@ export function startJob(opts: StartOptions): {
   const paths = jobPaths(id);
   writeSecure(paths.prompt, opts.prompt);
 
+  let model: DsModelAlias | undefined;
+  let modelId: string | undefined;
+  if (worker === "claude-ds") {
+    if (opts.model) {
+      model = opts.model;
+      modelId = opts.modelId ?? DS_MODEL_IDS[opts.model];
+    } else {
+      try {
+        const choice = defaultDsModelFromEnv();
+        model = choice.alias;
+        modelId = opts.modelId ?? choice.id;
+      } catch (e) {
+        try {
+          unlinkSync(paths.prompt);
+        } catch {
+          /* ignore */
+        }
+        return { ok: false, error: (e as Error).message };
+      }
+    }
+  }
+
   let plan;
   try {
     plan = adapter.buildLaunch({
       promptFile: paths.prompt,
       cwd,
       alwaysApprove,
+      model,
+      modelId,
     });
   } catch (e) {
     try {
@@ -290,6 +328,7 @@ export function startJob(opts: StartOptions): {
     status: "pending",
     worker,
     lane: opts.lane,
+    model,
     prompt: opts.prompt,
     cwd,
     alwaysApprove: plan.alwaysApprove,