claude-overnight 1.23.4 → 1.24.3

package/dist/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.23.4";
+export declare const VERSION = "1.24.3";

package/dist/_version.js

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

package/dist/index.js

@@ -223,7 +223,7 @@ async function main() {
         const proxyUp = await healthCheckCursorProxy();
         if (!proxyUp) {
             console.warn(chalk.yellow(`\n  ⚠ ${savedCursorProviders.length} Cursor provider(s) saved but proxy is not running at ${PROXY_DEFAULT_URL}`));
-            console.warn(chalk.yellow(`    Start it: npx @claude-overnight/cursor-api-proxy`));
+            console.warn(chalk.yellow(`    Start it: npx cursor-composer-in-claude`));
             console.warn(chalk.dim(`    (Continuing — you can still use Anthropic models)\n`));
         }
     }
@@ -764,13 +764,19 @@ async function main() {
         if (cursorProxies.length > 0) {
             await ensureCursorProxyRunning();
         }
-        process.stdout.write(`  ${chalk.dim(`◆ Pinging ${pending.map(([r, p]) => `${r} (${p.displayName})`).join(", ")}...`)}\n`);
-        const results = await Promise.all(pending.map(async ([role, p]) => ({ role, provider: p, result: await preflightProvider(p, cwd) })));
+        process.stdout.write(`  ${chalk.dim(`◆ Pinging ${pending.map(([r, p]) => `${r} (${p.displayName})`).join(", ")}…`)}\n`);
+        const results = await Promise.all(pending.map(async ([role, p]) => ({
+            role,
+            provider: p,
+            result: await preflightProvider(p, cwd, 20_000, {
+                onProgress: (msg) => process.stdout.write(chalk.dim(`    ${msg}\n`)),
+            }),
+        })));
         for (const { role, provider, result } of results) {
             if (!result.ok) {
                 console.error(chalk.red(`  ✗ ${role} preflight failed: ${chalk.dim(result.error)}`));
                 if (isCursorProxyProvider(provider)) {
-                    console.error(chalk.yellow(`  The proxy at ${PROXY_DEFAULT_URL} may have crashed. Start it: npx @claude-overnight/cursor-api-proxy`));
+                    console.error(chalk.yellow(`  The proxy at ${PROXY_DEFAULT_URL} may have crashed. Start it: npx cursor-composer-in-claude`));
                 }
                 else {
                     console.error(chalk.red(`  Fix the provider at ~/.claude/claude-overnight/providers.json and retry.`));

package/dist/providers.d.ts

@@ -15,9 +15,9 @@ export interface ProviderConfig {
     key?: string;
     /** When true, use JWT token auth instead of raw API keys. The bearer token is embedded in a short-lived JWT. */
     useJWT?: boolean;
-    /** When true, this provider routes through cursor-api-proxy (special env/health-check handling). */
+    /** When true, this provider routes through cursor-composer-in-claude (special env/health-check handling). */
     cursorProxy?: boolean;
-    /** API key for cursor-api-proxy. Stored in providers.json (0600), used as fallback when CURSOR_BRIDGE_API_KEY env is not set. */
+    /** API key for cursor-composer-in-claude. Stored in providers.json (0600), used as fallback when CURSOR_BRIDGE_API_KEY env is not set. */
     cursorApiKey?: string;
 }
 export declare function getStorePath(): string;
@@ -47,14 +47,16 @@ export declare function pickModel(label: string, anthropicModels: ModelInfo[], c
  * if the key is wrong or the endpoint is unreachable. Timeout is aggressive
  * so misconfig doesn't delay the main run.
  */
-export declare function preflightProvider(p: ProviderConfig, cwd: string, timeoutMs?: number): Promise<{
+export declare function preflightProvider(p: ProviderConfig, cwd: string, timeoutMs?: number, opts?: {
+    onProgress?: (msg: string) => void;
+}): Promise<{
     ok: true;
 } | {
     ok: false;
     error: string;
 }>;
 export declare const PROXY_DEFAULT_URL = "http://127.0.0.1:8765";
-/** Check if a provider routes through cursor-api-proxy. */
+/** Check if a provider routes through cursor-composer-in-claude. */
 export declare function isCursorProxyProvider(p: ProviderConfig): boolean;
 /**
  * Health check: GET /health on the proxy. Returns true if proxy is reachable.
@@ -67,7 +69,7 @@ export declare function healthCheckCursorProxy(baseUrl?: string): Promise<boolea
  */
 export declare function fetchCursorModels(baseUrl?: string): Promise<string[]>;
 /**
- * Auto-start the cursor-api-proxy as a detached background process.
+ * Auto-start the cursor-composer-in-claude as a detached background process.
  *
  * Passes CURSOR_AGENT_NODE/SCRIPT so the fork uses system Node.js for the
  * agent subprocess (avoids segfaults with --list-models on macOS).
@@ -85,7 +87,7 @@ export declare function fetchCursorModels(baseUrl?: string): Promise<string[]>;
  */
 export declare function ensureCursorProxyRunning(baseUrl?: string, forceRestart?: boolean): Promise<boolean>;
 /**
- * Full install + configure flow for cursor-api-proxy.
+ * Full install + configure flow for cursor-composer-in-claude.
  * Walks through CLI install, API key config, and proxy start.
  * Only needed when the quick auto-start (`ensureCursorProxyRunning`) fails —
  * e.g. npx can't find the package or the user has no API key yet.

package/dist/providers.js

@@ -1,4 +1,5 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, realpathSync } from "fs";
+import { createRequire } from "node:module";
 import { homedir } from "os";
 import { join, dirname } from "path";
 import { execSync, spawn } from "child_process";
@@ -8,6 +9,19 @@ import { ask, select, selectKey } from "./cli.js";
 import { getBearerToken, clearTokenCache } from "./auth.js";
 import { DEFAULT_MODEL } from "./models.js";
 import { CURSOR_PRIORITY_MODELS, CURSOR_KNOWN_MODELS, KNOWN_CURSOR_MODEL_IDS, cursorModelHint, } from "./cursor-models.js";
+/** Run the installed package CLI with `node` (avoids npx/npm invoking extra tooling on macOS). */
+function resolveCursorComposerCli() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgJson = require.resolve("cursor-composer-in-claude/package.json");
+        const root = dirname(pkgJson);
+        const cli = join(root, "dist", "cli.js");
+        return existsSync(cli) ? cli : null;
+    }
+    catch {
+        return null;
+    }
+}
 // ── Store ──
 const STORE_PATH = join(homedir(), ".claude", "claude-overnight", "providers.json");
 export function getStorePath() { return STORE_PATH; }
@@ -201,7 +215,7 @@ function normalizeBaseURL(raw) {
  * if the key is wrong or the endpoint is unreachable. Timeout is aggressive
  * so misconfig doesn't delay the main run.
  */
-export async function preflightProvider(p, cwd, timeoutMs = 20_000) {
+export async function preflightProvider(p, cwd, timeoutMs = 20_000, opts) {
     let env;
     try {
         env = envFor(p);
@@ -209,6 +223,13 @@ export async function preflightProvider(p, cwd, timeoutMs = 20_000) {
     catch (err) {
         return { ok: false, error: err.message };
     }
+    // Show what we're checking
+    const keyInfo = p.cursorProxy
+        ? `proxy auth`
+        : p.keyEnv
+            ? `env ${p.keyEnv}`
+            : "stored key";
+    opts?.onProgress?.(`checking ${p.model} (${keyInfo})…`);
     let pq;
     try {
         pq = query({
@@ -224,19 +245,29 @@ export async function preflightProvider(p, cwd, timeoutMs = 20_000) {
             },
         });
         const stream = pq;
+        // Progress ticker during the wait
+        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 consume = (async () => {
             for await (const msg of stream) {
                 if (msg.type === "result") {
+                    clearInterval(progressTimer);
                     if (msg.subtype !== "success") {
                         return { ok: false, error: String(msg.result || msg.subtype || "unknown error").slice(0, 200) };
                     }
                     return { ok: true };
                 }
             }
+            clearInterval(progressTimer);
             return { ok: false, error: "no result received" };
         })();
         const timeout = new Promise((resolve) => {
             setTimeout(() => {
+                clearInterval(progressTimer);
                 try {
                     stream.interrupt().catch(() => stream.close());
                 }
@@ -258,11 +289,11 @@ export async function preflightProvider(p, cwd, timeoutMs = 20_000) {
 }
 // ── Cursor API Proxy ──
 export const PROXY_DEFAULT_URL = "http://127.0.0.1:8765";
-/** Check if a provider routes through cursor-api-proxy. */
+/** Check if a provider routes through cursor-composer-in-claude. */
 export function isCursorProxyProvider(p) {
     return p.cursorProxy === true || p.baseURL === PROXY_DEFAULT_URL;
 }
-/** Resolve the cursor-api-proxy API key from env or providers.json. */
+/** Resolve the cursor-composer-in-claude API key from env or providers.json. */
 function resolveCursorProxyKey() {
     if (process.env.CURSOR_BRIDGE_API_KEY?.trim())
         return process.env.CURSOR_BRIDGE_API_KEY.trim();
@@ -350,7 +381,7 @@ async function fetchLiveCursorModels() {
     return [];
 }
 /**
- * Verify something is actually cursor-api-proxy (not just any HTTP service on the port).
+ * Verify something is actually cursor-composer-in-claude (not just any HTTP service on the port).
  * Tries /health first (proxy identity), then falls back to /v1/models shape check.
  * Returns true if it looks like the proxy.
  */
@@ -414,7 +445,7 @@ async function isPortInUse(port, host = "127.0.0.1") {
     }
 }
 /**
- * Auto-start the cursor-api-proxy as a detached background process.
+ * Auto-start the cursor-composer-in-claude as a detached background process.
  *
  * Passes CURSOR_AGENT_NODE/SCRIPT so the fork uses system Node.js for the
  * agent subprocess (avoids segfaults with --list-models on macOS).
@@ -446,7 +477,7 @@ export async function ensureCursorProxyRunning(baseUrl = PROXY_DEFAULT_URL, forc
         }
         // Stale process on the port — kill it if forceRestart, or try automatically
         if (!forceRestart) {
-            console.log(chalk.yellow(`  ⚠ Something is on port ${port} but it's not cursor-api-proxy — killing stale process…`));
+            console.log(chalk.yellow(`  ⚠ Something is on port ${port} but it's not cursor-composer-in-claude — killing stale process…`));
         }
         const killedPid = killProcessOnPort(port, url.hostname);
         if (killedPid) {
@@ -481,34 +512,79 @@ async function startProxyProcess(baseUrl, url, port) {
         }
     }
     catch { }
+    // Resolve the API key source for logging
+    const apiKeyEnv = process.env.CURSOR_BRIDGE_API_KEY;
+    const apiKeyStored = loadProviders().find(p => p.cursorProxy)?.cursorApiKey;
+    const keySource = apiKeyEnv ? "env CURSOR_BRIDGE_API_KEY" : (apiKeyStored ? "providers.json (stored)" : "none — using 'unused'");
+    // Log the installed proxy version
+    let proxyVersion = "unknown";
+    try {
+        const pkgPath = execSync("node -e \"try{console.log(require('cursor-composer-in-claude/package.json').version)}catch(e){}\" 2>/dev/null", {
+            timeout: 3_000, encoding: "utf-8", shell: "bash",
+        }).trim();
+        if (pkgPath)
+            proxyVersion = pkgPath;
+    }
+    catch {
+        // Fallback: try resolving from npx cache location
+        try {
+            const out = execSync("npm ls cursor-composer-in-claude --depth=0 2>/dev/null | grep cursor-composer", {
+                timeout: 5_000, encoding: "utf-8", shell: "bash",
+            }).trim();
+            const verMatch = out.match(/@(\d+\.\d+\.\d+)/);
+            if (verMatch)
+                proxyVersion = verMatch[1];
+        }
+        catch { }
+    }
+    console.log(chalk.dim(`  cursor-composer-in-claude v${proxyVersion}`));
+    console.log(chalk.dim(`  API key: ${keySource}`));
+    console.log(chalk.dim(`  CI=true (skips Cursor agent keychain probe on startup)`));
+    console.log(chalk.dim(`  CURSOR_SKIP_KEYCHAIN=1 (proxy-side keychain access disabled)`));
+    if (sysNode)
+        console.log(chalk.dim(`  System node: ${sysNode}`));
+    if (agentJs)
+        console.log(chalk.dim(`  Agent script: ${agentJs}`));
+    const composerCli = resolveCursorComposerCli();
+    if (!composerCli) {
+        console.log(chalk.yellow(`  ⚠ cursor-composer-in-claude is not installed (missing from node_modules). Run: npm install`));
+        return false;
+    }
+    console.log(chalk.dim(`  Command: ${process.execPath} ${composerCli}`));
     const proxyEnv = {
         ...Object.fromEntries(Object.entries(process.env).filter(([, v]) => v !== undefined)),
-        CURSOR_BRIDGE_API_KEY: process.env.CURSOR_BRIDGE_API_KEY
-            || loadProviders().find(p => p.cursorProxy)?.cursorApiKey
-            || "unused",
+        CI: "true",
+        CURSOR_BRIDGE_API_KEY: apiKeyEnv || apiKeyStored || "unused",
         CURSOR_SKIP_KEYCHAIN: "1",
     };
     if (sysNode && agentJs) {
         proxyEnv.CURSOR_AGENT_NODE = sysNode;
         proxyEnv.CURSOR_AGENT_SCRIPT = agentJs;
-        console.log(chalk.dim(`  Using system node for agent subprocess: ${sysNode}`));
     }
     try {
-        const child = spawn("npx", ["@claude-overnight/cursor-api-proxy"], {
+        console.log(chalk.dim(`  Spawning proxy…`));
+        const child = spawn(process.execPath, [composerCli], {
             detached: true,
             stdio: "ignore",
             env: proxyEnv,
         });
         child.unref(); // let it outlive this process
-        // Wait up to 15s for the proxy to become healthy
-        for (let i = 0; i < 30; i++) {
-            await new Promise(r => setTimeout(r, 500));
+        // Wait up to 15s for the proxy to become healthy, showing progress
+        const HEALTH_POLL_MS = 500;
+        const HEALTH_MAX_POLLS = 30;
+        for (let i = 0; i < HEALTH_MAX_POLLS; i++) {
+            await new Promise(r => setTimeout(r, HEALTH_POLL_MS));
+            const elapsed = ((i + 1) * HEALTH_POLL_MS / 1000).toFixed(1);
             if (await healthCheckCursorProxy(baseUrl)) {
-                console.log(chalk.green(`  ✓ Proxy started (PID ${child.pid}) and healthy`));
+                console.log(chalk.green(`  ✓ Proxy started (PID ${child.pid}) and healthy after ${elapsed}s`));
                 return true;
             }
+            // Show a dot every 2s to indicate we're still waiting
+            if ((i + 1) % 4 === 0) {
+                process.stdout.write(chalk.dim(`  · still waiting… (${elapsed}s)\n`));
+            }
         }
-        console.log(chalk.yellow(`  ⚠ Proxy process spawned but not responding after 15s`));
+        console.log(chalk.yellow(`  ⚠ Proxy process spawned (PID ${child.pid}) but not responding after 15s`));
         console.log(chalk.dim(`  It may still be initializing. You can check with: curl ${baseUrl}/health`));
         return false;
     }
@@ -545,19 +621,19 @@ function setupSteps() {
             successMsg: "Cursor API key configured",
         },
         {
-            label: "cursor-api-proxy server",
+            label: "cursor-composer-in-claude server",
             check: () => {
                 try {
-                    execSync("npx @claude-overnight/cursor-api-proxy --help", { stdio: "pipe", timeout: 10_000 });
+                    execSync("npx cursor-composer-in-claude --help", { stdio: "pipe", timeout: 10_000 });
                     return true;
                 }
                 catch {
                     return false;
                 }
             },
-            autoCmd: "npx @claude-overnight/cursor-api-proxy",
-            manualCmd: "npx @claude-overnight/cursor-api-proxy",
-            successMsg: "cursor-api-proxy available",
+            autoCmd: "npx cursor-composer-in-claude",
+            manualCmd: "npx cursor-composer-in-claude",
+            successMsg: "cursor-composer-in-claude available",
         },
     ];
 }
@@ -598,14 +674,14 @@ async function promptAndSaveCursorKey() {
     return false;
 }
 /**
- * Full install + configure flow for cursor-api-proxy.
+ * Full install + configure flow for cursor-composer-in-claude.
  * Walks through CLI install, API key config, and proxy start.
  * Only needed when the quick auto-start (`ensureCursorProxyRunning`) fails —
  * e.g. npx can't find the package or the user has no API key yet.
  * Returns true when proxy is running and healthy.
  */
 export async function setupCursorProxy() {
-    console.log(chalk.dim("\n  Configure cursor-api-proxy"));
+    console.log(chalk.dim("\n  Configure cursor-composer-in-claude"));
     console.log(chalk.dim("  " + "─".repeat(40)));
     console.log(chalk.dim("  We need three things: Cursor CLI, an API key, and the proxy server.\n"));
     const steps = setupSteps();
@@ -671,24 +747,24 @@ export async function setupCursorProxy() {
         if (choice === "a") {
             console.log(chalk.dim(`  Checking install…`));
             try {
-                execSync("npx @claude-overnight/cursor-api-proxy --help", { stdio: "pipe", timeout: 15_000 });
-                console.log(chalk.green(`  ✓ cursor-api-proxy is installed`));
+                execSync("npx cursor-composer-in-claude --help", { stdio: "pipe", timeout: 15_000 });
+                console.log(chalk.green(`  ✓ cursor-composer-in-claude is installed`));
             }
             catch {
                 console.log(chalk.dim(`  Installing…`));
                 try {
-                    execSync("npm install -g @claude-overnight/cursor-api-proxy", { stdio: "inherit", timeout: 120_000 });
+                    execSync("npm install -g cursor-composer-in-claude", { stdio: "inherit", timeout: 120_000 });
                     console.log(chalk.green(`  ✓ Installed`));
                 }
                 catch {
-                    console.log(chalk.yellow("  Install failed — try manual: npm install -g @claude-overnight/cursor-api-proxy"));
+                    console.log(chalk.yellow("  Install failed — try manual: npm install -g cursor-composer-in-claude"));
                     return false;
                 }
             }
         }
         else if (choice === "m") {
-            console.log(chalk.cyan(`\n  Install:  ${chalk.bold("npm install -g @claude-overnight/cursor-api-proxy")}`));
-            console.log(chalk.cyan(`  Start:    ${chalk.bold("npx @claude-overnight/cursor-api-proxy")}\n`));
+            console.log(chalk.cyan(`\n  Install:  ${chalk.bold("npm install -g cursor-composer-in-claude")}`));
+            console.log(chalk.cyan(`  Start:    ${chalk.bold("npx cursor-composer-in-claude")}\n`));
             const ok = await selectKey(`  Started it?`, [
                 { key: "r", desc: "eady" },
                 { key: "c", desc: "ancel" },
@@ -706,7 +782,7 @@ export async function setupCursorProxy() {
         return true;
     // Auto-start failed or not responding — offer manual fallback
     console.log(chalk.yellow(`\n  Couldn't start the proxy automatically. Start it manually:`));
-    console.log(chalk.white(`    ${chalk.bold("npx @claude-overnight/cursor-api-proxy")}`));
+    console.log(chalk.white(`    ${chalk.bold("npx cursor-composer-in-claude")}`));
     for (;;) {
         const choice = await selectKey(`  Proxy started?`, [
             { key: "r", desc: "etry (re-attempt auto-start + kill stale)" },

package/dist/swarm.d.ts

@@ -17,7 +17,7 @@ export interface SwarmConfig {
     baseCostUsd?: number;
     /** Per-task env overrides: given a model id, return the env to pass to `query()` (or undefined for Anthropic default). */
     envForModel?: (model?: string) => Record<string, string> | undefined;
-    /** When true, the run uses cursor-api-proxy. The swarm will attempt to restart it if it crashes mid-run. */
+    /** When true, the run uses cursor-composer-in-claude. The swarm will attempt to restart it if it crashes mid-run. */
     cursorProxy?: boolean;
 }
 export declare class Swarm {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.23.4",
+  "version": "1.24.3",
   "description": "Background lane for your Claude Max plan. Parallel Claude Agent SDK sessions in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Provider-agnostic model catalog with capability-based planning.",
   "type": "module",
   "bin": {
@@ -15,16 +15,16 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.92",
-    "@claude-overnight/cursor-api-proxy": "github:Fornace/cursor-api-proxy",
     "chalk": "^5.4.1",
+    "cursor-composer-in-claude": "^0.7.5",
     "jsonwebtoken": "^9.0.2"
   },
   "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.7",
     "@types/node": "^22.0.0",
     "node-pty": "^1.1.0",
     "strip-ansi": "^7.1.0",
-    "typescript": "^5.7.0",
-    "@types/jsonwebtoken": "^9.0.7"
+    "typescript": "^5.7.0"
   },
   "license": "MIT",
   "author": "Francesco Fornace",

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

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.23.4",
+  "version": "1.24.3",
   "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"