cursor-route 0.1.1 → 0.1.5

package/dist/jobs.js

@@ -0,0 +1,410 @@
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, unlinkSync, openSync, closeSync, chmodSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+import { config, sessionName } from "./config.js";
+import { getAdapter } from "./adapters/index.js";
+import { spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
+import { createWorkerSession, sessionExists, killSession } from "./tmux.js";
+import { newJobId, shellQuote } from "./util.js";
+import { markCompleteInvoker } from "./runtime.js";
+import { assertJobId, JOB_ID_RE } from "./secrets.js";
+function ensureJobsDir() {
+    mkdirSync(config.jobsDir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(config.jobsDir, 0o700);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function writeSecure(path, data) {
+    writeFileSync(path, data, { mode: 0o600 });
+}
+function underJobsDir(id, ext) {
+    assertJobId(id);
+    const base = resolve(config.jobsDir);
+    const full = resolve(join(base, `${id}${ext}`));
+    if (!full.startsWith(base + "/") && full !== base) {
+        throw new Error("Job path escapes jobsDir");
+    }
+    return full;
+}
+export function jobPaths(id) {
+    ensureJobsDir();
+    return {
+        json: underJobsDir(id, ".json"),
+        prompt: underJobsDir(id, ".prompt"),
+        log: underJobsDir(id, ".log"),
+    };
+}
+export function readJob(id) {
+    try {
+        assertJobId(id);
+    }
+    catch {
+        return null;
+    }
+    const p = jobPaths(id).json;
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJob(job) {
+    writeSecure(jobPaths(job.id).json, JSON.stringify(job, null, 2));
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        return false;
+    }
+    // kill(pid, 0) stays true for zombies, and terminatePid's sync waits block the
+    // event loop so children can sit unreaped as zombies — a zombie is not a worker.
+    try {
+        const r = spawnSync("ps", ["-o", "state=", "-p", String(pid)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const state = (r.stdout || "").trim();
+        return state !== "" && !state.startsWith("Z");
+    }
+    catch {
+        return true;
+    }
+}
+function sleepMs(ms) {
+    spawnSync("sleep", [String(ms / 1000)]);
+}
+function terminatePid(pid) {
+    const trySignal = (sig, group) => {
+        try {
+            process.kill(group ? -pid : pid, sig);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    trySignal("SIGTERM", true);
+    trySignal("SIGTERM", false);
+    for (let i = 0; i < 10; i++) {
+        if (!pidAlive(pid))
+            return true;
+        sleepMs(100);
+    }
+    trySignal("SIGKILL", true);
+    trySignal("SIGKILL", false);
+    for (let i = 0; i < 10; i++) {
+        if (!pidAlive(pid))
+            return true;
+        sleepMs(100);
+    }
+    return !pidAlive(pid);
+}
+/** Refresh running jobs without inventing success from "session gone". */
+export function refreshStatus(job) {
+    if (job.status !== "running")
+        return job;
+    // Prefer completion-hook result if already written.
+    const fresh = readJob(job.id);
+    if (fresh && fresh.status !== "running")
+        return fresh;
+    const headless = job.tmuxSession.startsWith("headless-");
+    if (headless) {
+        if (job.pid && pidAlive(job.pid))
+            return job;
+        if (job.pid && !pidAlive(job.pid)) {
+            // Process exited but hook may not have run — mark unknown failure, not success.
+            const again = readJob(job.id);
+            if (again && again.status !== "running")
+                return again;
+            job.status = "failed";
+            job.error = job.error || "Headless worker exited without completion marker";
+            job.completedAt = new Date().toISOString();
+            writeJob(job);
+            return job;
+        }
+        // No pid recorded (legacy) — do not flip to completed.
+        return job;
+    }
+    // tmux path: session gone → re-read; if still running, mark failed (unknown), not completed.
+    if (!sessionExists(job.tmuxSession)) {
+        const again = readJob(job.id);
+        if (again && again.status !== "running")
+            return again;
+        job.status = "failed";
+        job.error = job.error || "tmux session ended without completion marker";
+        job.completedAt = new Date().toISOString();
+        writeJob(job);
+    }
+    return job;
+}
+export function countActiveJobs() {
+    ensureJobsDir();
+    let n = 0;
+    for (const f of readdirSync(config.jobsDir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        const id = f.replace(/\.json$/, "");
+        if (!JOB_ID_RE.test(id))
+            continue;
+        try {
+            const job = JSON.parse(readFileSync(join(config.jobsDir, f), "utf8"));
+            if (job?.schema === "cursor-route.job.v1" && (job.status === "running" || job.status === "pending")) {
+                n++;
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return n;
+}
+export function listJobs(limit = config.jobsListLimit) {
+    ensureJobsDir();
+    const files = readdirSync(config.jobsDir).filter((f) => f.endsWith(".json") && JOB_ID_RE.test(f.replace(/\.json$/, "")));
+    const jobs = [];
+    for (const f of files) {
+        try {
+            const job = JSON.parse(readFileSync(join(config.jobsDir, f), "utf8"));
+            if (job?.schema === "cursor-route.job.v1")
+                jobs.push(refreshStatus(job));
+        }
+        catch {
+            /* skip */
+        }
+    }
+    jobs.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+    return jobs.slice(0, limit);
+}
+export function resolveWorker(opts) {
+    if (opts.worker)
+        return opts.worker;
+    if (opts.lane)
+        return config.laneWorkers[opts.lane];
+    return config.defaultWorker;
+}
+export function startJob(opts) {
+    const worker = resolveWorker(opts);
+    const cwd = opts.cwd || process.cwd();
+    // CURSOR_ROUTE_ASK applies to all workers; CLAUDE_DS_ASK is mid-lane only
+    const alwaysApprove = opts.alwaysApprove !== false &&
+        process.env.CURSOR_ROUTE_ASK !== "1" &&
+        !(worker === "claude-ds" && process.env.CLAUDE_DS_ASK === "1");
+    if (!opts.dryRun) {
+        const active = countActiveJobs();
+        if (active >= config.maxConcurrentJobs) {
+            return {
+                ok: false,
+                error: `Too many active jobs (${active} >= ${config.maxConcurrentJobs}) — wait for jobs to finish or raise CURSOR_ROUTE_MAX_JOBS`,
+            };
+        }
+    }
+    // Preflight: requested worker must be healthy
+    const adapter = getAdapter(worker);
+    const health = adapter.health();
+    if (!health.ok && !opts.dryRun) {
+        return { ok: false, error: `Worker ${worker} unavailable: ${health.detail}` };
+    }
+    const id = newJobId();
+    const paths = jobPaths(id);
+    writeSecure(paths.prompt, opts.prompt);
+    let plan;
+    try {
+        plan = adapter.buildLaunch({
+            promptFile: paths.prompt,
+            cwd,
+            alwaysApprove,
+        });
+    }
+    catch (e) {
+        try {
+            unlinkSync(paths.prompt);
+        }
+        catch {
+            /* ignore */
+        }
+        return { ok: false, error: e.message };
+    }
+    const job = {
+        id,
+        schema: "cursor-route.job.v1",
+        status: "pending",
+        worker,
+        lane: opts.lane,
+        prompt: opts.prompt,
+        cwd,
+        alwaysApprove: plan.alwaysApprove,
+        tmuxSession: opts.noTmux ? `headless-${id}` : sessionName(id),
+        createdAt: new Date().toISOString(),
+    };
+    if (opts.dryRun) {
+        // No durable prompt retention for dry-run
+        try {
+            unlinkSync(paths.prompt);
+        }
+        catch {
+            /* ignore */
+        }
+        const envNote = plan.env
+            ? ` (+env: ${Object.keys(plan.env).join(",")})`
+            : "";
+        return {
+            ok: true,
+            job,
+            dryRun: true,
+            command: plan.command + envNote,
+        };
+    }
+    const here = dirname(fileURLToPath(import.meta.url));
+    const markComplete = join(here, "mark-complete.ts");
+    const invoker = markCompleteInvoker(markComplete);
+    // Persist running BEFORE launch so fast workers cannot race completion overwrite.
+    job.status = "running";
+    job.startedAt = new Date().toISOString();
+    writeJob(job);
+    if (opts.noTmux) {
+        const wrapped = [
+            plan.command,
+            `exit_code=$?`,
+            `${invoker} ${shellQuote(paths.json)} "$exit_code" ${shellQuote(paths.log)}`,
+            `exit $exit_code`,
+        ].join("; ");
+        let logFd;
+        try {
+            logFd = openSync(paths.log, "a", 0o600);
+        }
+        catch (e) {
+            job.status = "failed";
+            job.error = `Cannot open log: ${e.message}`;
+            job.completedAt = new Date().toISOString();
+            writeJob(job);
+            return { ok: false, error: job.error };
+        }
+        const child = spawn("sh", ["-c", wrapped], {
+            cwd,
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            env: plan.env ? { ...process.env, ...plan.env } : process.env,
+        });
+        try {
+            closeSync(logFd);
+        }
+        catch {
+            /* ignore */
+        }
+        if (child.pid == null) {
+            job.status = "failed";
+            job.error = "Failed to spawn headless worker";
+            job.completedAt = new Date().toISOString();
+            writeJob(job);
+            return { ok: false, error: job.error };
+        }
+        // Merge-on-write: only set pid if still running (avoid clobbering mark-complete)
+        const latest = readJob(id) || job;
+        if (latest.status === "running" || latest.status === "pending") {
+            latest.pid = child.pid;
+            writeJob(latest);
+            Object.assign(job, latest);
+        }
+        child.unref();
+        return { ok: true, job };
+    }
+    const created = createWorkerSession({
+        jobId: id,
+        cwd,
+        workerCmd: plan.command,
+        logFile: paths.log,
+        jobFile: paths.json,
+        markCompleteScript: markComplete,
+        env: plan.env,
+    });
+    if (!created.ok) {
+        job.status = "failed";
+        job.error = created.error;
+        job.completedAt = new Date().toISOString();
+        writeJob(job);
+        return { ok: false, error: created.error };
+    }
+    // Re-read before final write — mark-complete may have already finished
+    const after = readJob(id) || job;
+    if (after.status === "running" || after.status === "pending") {
+        writeJob(after);
+    }
+    return { ok: true, job: after };
+}
+export function killJob(id) {
+    const job = readJob(id);
+    if (!job)
+        return { ok: false, error: `Job not found: ${id}` };
+    if (job.status === "completed" || job.status === "failed" || job.status === "killed") {
+        return { ok: false, error: `Job already terminal (${job.status}) — refuse kill rewrite` };
+    }
+    if (job.tmuxSession.startsWith("headless-")) {
+        if (job.pid) {
+            const ok = terminatePid(job.pid);
+            if (!ok) {
+                return { ok: false, error: `Failed to kill pid ${job.pid}` };
+            }
+        }
+        else {
+            return {
+                ok: false,
+                error: "Headless job has no pid — cannot kill (legacy job). Kill the worker process manually.",
+            };
+        }
+    }
+    else {
+        const killed = killSession(job.tmuxSession);
+        if (!killed && sessionExists(job.tmuxSession)) {
+            return { ok: false, error: `Failed to kill tmux session ${job.tmuxSession}` };
+        }
+    }
+    // Merge-on-write: do not clobber a completion that landed mid-kill
+    const latest = readJob(id) || job;
+    if (latest.status === "completed" || latest.status === "failed") {
+        return { ok: false, error: `Job finished during kill (${latest.status})` };
+    }
+    latest.status = "killed";
+    latest.completedAt = new Date().toISOString();
+    writeJob(latest);
+    return { ok: true, job: latest };
+}
+export function cleanJobs(olderThanDays = 7) {
+    ensureJobsDir();
+    const cutoff = Date.now() - olderThanDays * 86400000;
+    let n = 0;
+    for (const f of readdirSync(config.jobsDir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        const id = f.replace(/\.json$/, "");
+        if (!JOB_ID_RE.test(id))
+            continue;
+        try {
+            const job = JSON.parse(readFileSync(join(config.jobsDir, f), "utf8"));
+            const t = Date.parse(job.completedAt || job.createdAt);
+            if (Number.isFinite(t) &&
+                t < cutoff &&
+                (job.status === "completed" || job.status === "failed" || job.status === "killed")) {
+                for (const ext of [".json", ".prompt", ".log"]) {
+                    const fp = underJobsDir(id, ext);
+                    if (existsSync(fp))
+                        unlinkSync(fp);
+                }
+                n++;
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return n;
+}

package/dist/mark-complete.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+/**
+ * Marks a job completed/failed after the worker process exits.
+ * Invoked from tmux / headless completion hooks — keep dep-free.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { redactSecrets } from "./secrets.js";
+const jobPath = process.argv[2];
+const exitCode = Number(process.argv[3] ?? "1");
+const logPath = process.argv[4];
+if (!jobPath)
+    process.exit(0);
+try {
+    const job = JSON.parse(readFileSync(jobPath, "utf8"));
+    if (job.status === "running" || job.status === "pending") {
+        job.status = exitCode === 0 ? "completed" : "failed";
+        job.exitCode = exitCode;
+        job.completedAt = new Date().toISOString();
+        if (exitCode !== 0 && !job.error) {
+            job.error = `Worker exited with code ${exitCode}`;
+        }
+        if (logPath) {
+            try {
+                const log = readFileSync(logPath, "utf8");
+                job.logBytes = Buffer.byteLength(log);
+                job.logTail = redactSecrets(log).slice(-2000);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        writeFileSync(jobPath, JSON.stringify(job, null, 2), { mode: 0o600 });
+    }
+}
+catch {
+    /* never fail the shell hook hard */
+}
+process.exit(0);

package/dist/openrouter-run.js

@@ -0,0 +1,95 @@
+#!/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.js";
+import { looksLikeSecretMaterial } from "./secrets.js";
+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, code) {
+    console.error(`cursor-route/openrouter-run: ${msg}`);
+    process.exit(code);
+}
+function parseArgs(argv) {
+    const flags = {};
+    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() {
+    const { promptFile } = parseArgs(process.argv.slice(2));
+    if (!promptFile)
+        fail("--prompt-file <path> is required", 2);
+    let prompt;
+    try {
+        prompt = readFileSync(promptFile, "utf8");
+    }
+    catch (e) {
+        fail(`cannot read prompt file: ${e.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;
+    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.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());
+    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));

package/dist/runtime.js

@@ -0,0 +1,27 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { commandExists, shellQuote } from "./util.js";
+/**
+ * Resolve how to re-invoke the completion hook (mark-complete) from shell hooks.
+ * Prefer compiled dist via node (no loader); else Bun on src. No npx/tsx on the
+ * happy path — surface a clear failure if neither is available.
+ */
+export function markCompleteInvoker(scriptPath) {
+    const compiled = scriptPath.replace(/\.ts$/, ".js");
+    if (existsSync(compiled)) {
+        return `node ${shellQuote(compiled)}`;
+    }
+    if (commandExists("bun")) {
+        return `bun ${shellQuote(scriptPath)}`;
+    }
+    return `sh -c 'echo "cursor-route: completion hook needs a compiled dist or Bun (run bun run build)" >&2; exit 1'`;
+}
+/** XDG-ish default away from git-clone install dir (~/.cursor-route). */
+export function defaultJobsDir() {
+    if (process.env.CURSOR_ROUTE_JOBS_DIR)
+        return process.env.CURSOR_ROUTE_JOBS_DIR;
+    const home = process.env.HOME || homedir();
+    const xdg = process.env.XDG_DATA_HOME || join(home, ".local", "share");
+    return join(xdg, "cursor-route", "jobs");
+}

package/dist/secrets.js

@@ -0,0 +1,39 @@
+/**
+ * Secret material detectors — match key *contents*, not the phrase "API key".
+ * Applied to `start` and `send`, and reused for log-tail redaction.
+ */
+export const SECRET_PATTERNS = [
+    // OpenAI / DeepSeek legacy + project / Anthropic hyphenated keys
+    /\bsk-[a-zA-Z0-9]{20,}\b/,
+    /\bsk-(?:proj|ant|oai)-[A-Za-z0-9_-]{16,}\b/,
+    /\bsk-[a-zA-Z0-9-]{20,}\b/,
+    /\bghp_[A-Za-z0-9]{20,}\b/,
+    /\bgho_[A-Za-z0-9]{20,}\b/,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}\b/,
+    /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/i,
+    /\bxai-[A-Za-z0-9_-]{20,}\b/,
+    /\bAIza[0-9A-Za-z_-]{20,}\b/,
+    /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/,
+    /\bAKIA[0-9A-Z]{16}\b/,
+    /hooks\.slack\.com\/services\/[A-Za-z0-9/_-]+/i,
+];
+export function looksLikeSecretMaterial(text) {
+    return SECRET_PATTERNS.some((re) => re.test(text));
+}
+/** Redact secret-looking spans for job metadata / log tails. */
+export function redactSecrets(text) {
+    let out = text;
+    for (const re of SECRET_PATTERNS) {
+        // Clone with global flag so we replace all matches
+        const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`;
+        out = out.replace(new RegExp(re.source, flags), "[REDACTED]");
+    }
+    return out;
+}
+export const JOB_ID_RE = /^[a-f0-9]{8}$/;
+export function assertJobId(id) {
+    if (!JOB_ID_RE.test(id)) {
+        throw new Error(`Invalid job id: ${id} (expected 8 hex chars)`);
+    }
+    return id;
+}