claude-overnight 1.25.12 → 1.25.13

package/dist/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.25.12";
+export declare const VERSION = "1.25.13";

package/dist/_version.js

@@ -1,2 +1,2 @@
 // Auto-generated by build — do not edit manually.
-export const VERSION = "1.25.12";
+export const VERSION = "1.25.13";

package/dist/index.js

@@ -806,32 +806,19 @@ async function main() {
             }
         }
         process.stdout.write(`  ${chalk.dim(`◆ Pinging ${pending.map(([r, p]) => `${r} (${p.displayName})`).join(", ")}…`)}\n`);
-        // Cursor proxy: each saved model is a distinct provider id (`cursor-composer-2`, etc.), so
-        // planner + executor + fast can schedule multiple preflights. The bundled proxy typically
-        // handles one agent query at a time — parallel preflights starve each other and hit the
-        // 20s timeout. Run non-proxy checks in parallel, then cursor proxy checks one at a time
-        // (preserve original `pending` order for messages).
+        // All preflights run in parallel. Cursor proxy preflights now go through a
+        // plain HTTP POST /v1/messages (see preflightCursorProxyViaHttp) instead of
+        // spawning the claude CLI, and the bundled proxy has no internal queue —
+        // each request spawns its own cursor-agent subprocess (request-listener.js
+        // → handleAnthropicMessages → runAgentStream).
         const progress = (msg) => process.stdout.write(chalk.dim(`    ${msg}\n`));
-        /** Cursor agent cold start + model variance can exceed 20s; API providers stay tight. */
+        /** Cursor agent cold start + thinking-variant model latency can exceed 20s; API providers stay tight. */
         const preflightMs = (p) => isCursorProxyProvider(p) ? 60_000 : 20_000;
-        const nonCursorIdx = [];
-        const cursorIdx = [];
-        for (let i = 0; i < pending.length; i++) {
-            if (isCursorProxyProvider(pending[i][1]))
-                cursorIdx.push(i);
-            else
-                nonCursorIdx.push(i);
-        }
-        const slot = Array.from({ length: pending.length });
-        await Promise.all(nonCursorIdx.map(async (i) => {
-            const [role, p] = pending[i];
-            slot[i] = { role, provider: p, result: await preflightProvider(p, cwd, preflightMs(p), { onProgress: progress }) };
-        }));
-        for (const i of cursorIdx) {
-            const [role, p] = pending[i];
-            slot[i] = { role, provider: p, result: await preflightProvider(p, cwd, preflightMs(p), { onProgress: progress }) };
-        }
-        const results = slot;
+        const results = await Promise.all(pending.map(async ([role, p]) => ({
+            role,
+            provider: p,
+            result: await preflightProvider(p, cwd, preflightMs(p), { onProgress: progress }),
+        })));
         for (const { role, provider, result } of results) {
             if (!result.ok) {
                 console.error(chalk.red(`  ✗ ${role} preflight failed: ${chalk.dim(result.error)}`));

package/dist/providers.js

@@ -256,6 +256,12 @@ function normalizeBaseURL(raw) {
  * so misconfig doesn't delay the main run.
  */
 export async function preflightProvider(p, cwd, timeoutMs = 20_000, opts) {
+    // Cursor proxy path: direct HTTP POST /v1/messages instead of spawning a
+    // full `claude` CLI subprocess. Same end-to-end validation (proxy + auth +
+    // cursor-agent + model) without per-check 1-3s of CLI spawn overhead.
+    if (isCursorProxyProvider(p)) {
+        return preflightCursorProxyViaHttp(p, timeoutMs, opts);
+    }
     let env;
     try {
         env = envFor(p);
@@ -264,11 +270,7 @@ export async function preflightProvider(p, cwd, timeoutMs = 20_000, opts) {
         return { ok: false, error: err.message };
     }
     // Show what we're checking
-    const keyInfo = p.cursorProxy
-        ? `proxy auth`
-        : p.keyEnv
-            ? `env ${p.keyEnv}`
-            : "stored key";
+    const keyInfo = p.keyEnv ? `env ${p.keyEnv}` : "stored key";
     opts?.onProgress?.(`checking ${p.model} (${keyInfo})…`);
     let pq;
     try {
@@ -327,6 +329,57 @@ export async function preflightProvider(p, cwd, timeoutMs = 20_000, opts) {
         catch { }
     }
 }
+/**
+ * Cursor-proxy-only preflight: HTTP POST /v1/messages instead of spawning the
+ * `claude` CLI. The proxy spawns its own cursor-agent subprocess per request
+ * (see cursor-composer-in-claude agent-runner.js) with no internal queue —
+ * callers can safely run these in parallel.
+ */
+async function preflightCursorProxyViaHttp(p, timeoutMs, opts) {
+    opts?.onProgress?.(`checking ${p.model} (proxy auth)…`);
+    const baseURL = (p.baseURL || PROXY_DEFAULT_URL).replace(/\/$/, "");
+    const key = resolveCursorProxyKey();
+    const headers = { "content-type": "application/json" };
+    if (key)
+        headers["authorization"] = `Bearer ${key}`;
+    const controller = new AbortController();
+    let elapsed = 0;
+    const PROGRESS_INTERVAL_MS = 3_000;
+    const progressTimer = setInterval(() => {
+        elapsed += PROGRESS_INTERVAL_MS;
+        opts?.onProgress?.(`still waiting… (${(elapsed / 1000).toFixed(1)}s)`);
+    }, PROGRESS_INTERVAL_MS);
+    const deadline = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(`${baseURL}/v1/messages`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model: p.model,
+                max_tokens: 1,
+                messages: [{ role: "user", content: "ok" }],
+            }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            return { ok: false, error: `HTTP ${res.status}: ${text.slice(0, 200)}` };
+        }
+        // Drain body so the connection closes cleanly; we don't care about content.
+        await res.text().catch(() => "");
+        return { ok: true };
+    }
+    catch (err) {
+        if (err?.name === "AbortError") {
+            return { ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s` };
+        }
+        return { ok: false, error: String(err?.message || err).slice(0, 200) };
+    }
+    finally {
+        clearTimeout(deadline);
+        clearInterval(progressTimer);
+    }
+}
 // ── Cursor API Proxy ──
 export const PROXY_DEFAULT_URL = "http://127.0.0.1:8765";
 /** Check if a provider routes through cursor-composer-in-claude. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.12",
+  "version": "1.25.13",
   "description": "Parallel Claude agents in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Provider-agnostic model catalog (Anthropic, Cursor, OpenAI, Gemini, DeepSeek, Llama, Qwen) with capability-based task scoping.",
   "type": "module",
   "bin": {

package/plugins/claude-overnight/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.12",
+  "version": "1.25.13",
   "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs  -- parallel Claude agents in git worktrees with thinking waves, multi-wave steering, and crash-safe resume. Supports Cursor API Proxy, Qwen, OpenRouter.",
   "author": {
     "name": "Francesco Fornace"