@rely-ai/caliber 1.23.0-dev.1773793983 → 1.23.0

package/dist/bin.js

@@ -169,6 +169,22 @@ var init_config = __esm({
   }
 });
 
+// src/llm/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isSeatBased: () => isSeatBased
+});
+function isSeatBased(provider) {
+  return SEAT_BASED_PROVIDERS.has(provider);
+}
+var SEAT_BASED_PROVIDERS;
+var init_types = __esm({
+  "src/llm/types.ts"() {
+    "use strict";
+    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
+  }
+});
+
 // src/constants.ts
 var constants_exports = {};
 __export(constants_exports, {
@@ -1036,8 +1052,8 @@ var AnthropicProvider = class {
         cacheWriteTokens: u.cache_creation_input_tokens
       });
     }
-    const block = response.content[0];
-    return block.type === "text" ? block.text : "";
+    const block = response.content?.[0];
+    return block?.type === "text" ? block.text : "";
   }
   async listModels() {
     const models = [];
@@ -1140,8 +1156,8 @@ var VertexProvider = class {
         cacheWriteTokens: u.cache_creation_input_tokens
       });
     }
-    const block = response.content[0];
-    return block.type === "text" ? block.text : "";
+    const block = response.content?.[0];
+    return block?.type === "text" ? block.text : "";
   }
   async stream(options, callbacks) {
     const messages = options.messages ? [
@@ -1261,14 +1277,44 @@ var OpenAICompatProvider = class {
 // src/llm/cursor-acp.ts
 import { spawn, execSync as execSync3 } from "child_process";
 import os2 from "os";
+
+// src/llm/seat-based-errors.ts
+var ERROR_PATTERNS = [
+  { pattern: /not logged in|not authenticated|login required|unauthorized/i, message: "Authentication required. Run the login command for your provider to re-authenticate." },
+  { pattern: /rate limit|too many requests|429/i, message: "Rate limit exceeded. Retrying..." },
+  { pattern: /model.*not found|invalid model|model.*unavailable/i, message: "The requested model is not available. Run `caliber config` to select a different model." }
+];
+function parseSeatBasedError(stderr, exitCode) {
+  if (!stderr && exitCode === 0) return null;
+  for (const { pattern, message } of ERROR_PATTERNS) {
+    if (pattern.test(stderr)) return message;
+  }
+  return null;
+}
+function isRateLimitError(stderr) {
+  return /rate limit|too many requests|429/i.test(stderr);
+}
+
+// src/llm/cursor-acp.ts
 var AGENT_BIN = "agent";
 var IS_WINDOWS = process.platform === "win32";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var SIGKILL_DELAY_MS = 5e3;
+var STDERR_MAX_BYTES = 10 * 1024;
 var CursorAcpProvider = class {
   defaultModel;
   cursorApiKey;
+  timeoutMs;
+  warmProcess = null;
+  warmModel = null;
   constructor(config) {
     this.defaultModel = config.model || "sonnet-4.6";
     this.cursorApiKey = process.env.CURSOR_API_KEY ?? process.env.CURSOR_AUTH_TOKEN;
+    const envTimeout = process.env.CALIBER_CURSOR_TIMEOUT_MS;
+    this.timeoutMs = envTimeout ? parseInt(envTimeout, 10) : DEFAULT_TIMEOUT_MS;
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 1e3) {
+      this.timeoutMs = DEFAULT_TIMEOUT_MS;
+    }
   }
   async call(options) {
     const prompt = this.buildPrompt(options);
@@ -1280,6 +1326,29 @@ var CursorAcpProvider = class {
     const model = options.model || this.defaultModel;
     return this.runPrintStream(model, prompt, callbacks);
   }
+  /**
+   * Pre-spawn an agent process so it's ready when the first call comes.
+   * Call this during fingerprint collection to hide spawn latency.
+   */
+  prewarm(model) {
+    const targetModel = model || this.defaultModel;
+    if (this.warmProcess && !this.warmProcess.killed && this.warmModel === targetModel) return;
+    const args = this.buildArgs(targetModel, false);
+    this.warmProcess = spawn(AGENT_BIN, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
+      ...IS_WINDOWS && { shell: true }
+    });
+    this.warmModel = targetModel;
+    this.warmProcess.on("error", () => {
+      this.warmProcess = null;
+      this.warmModel = null;
+    });
+    this.warmProcess.on("close", () => {
+      this.warmProcess = null;
+      this.warmModel = null;
+    });
+  }
   buildArgs(model, streaming) {
     const args = ["--print", "--trust", "--workspace", os2.tmpdir()];
     if (model && model !== "auto" && model !== "default") {
@@ -1293,23 +1362,78 @@ var CursorAcpProvider = class {
     }
     return args;
   }
+  takeWarmProcess(model, streaming) {
+    if (!streaming && this.warmProcess && !this.warmProcess.killed && this.warmModel === model) {
+      const proc = this.warmProcess;
+      this.warmProcess = null;
+      this.warmModel = null;
+      return proc;
+    }
+    return null;
+  }
+  spawnAgent(model, streaming) {
+    const warm = this.takeWarmProcess(model, streaming);
+    if (warm) {
+      const stderrChunks2 = [];
+      warm.stderr?.on("data", (chunk) => {
+        if (Buffer.concat(stderrChunks2).length < STDERR_MAX_BYTES) stderrChunks2.push(chunk);
+      });
+      return { child: warm, stderrChunks: stderrChunks2 };
+    }
+    const args = this.buildArgs(model, streaming);
+    const child = spawn(AGENT_BIN, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
+      ...IS_WINDOWS && { shell: true }
+    });
+    const stderrChunks = [];
+    child.stderr.on("data", (chunk) => {
+      if (Buffer.concat(stderrChunks).length < STDERR_MAX_BYTES) stderrChunks.push(chunk);
+    });
+    return { child, stderrChunks };
+  }
+  killWithEscalation(child) {
+    child.kill("SIGTERM");
+    const killTimer = setTimeout(() => {
+      if (!child.killed) child.kill("SIGKILL");
+    }, SIGKILL_DELAY_MS);
+    killTimer.unref();
+  }
+  buildErrorMessage(code, stderrChunks) {
+    const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+    const parsed = parseSeatBasedError(stderr, code);
+    if (parsed) return parsed;
+    const base = `Cursor agent exited with code ${code}`;
+    return stderr ? `${base}: ${stderr.slice(0, 200)}` : base;
+  }
   runPrint(model, prompt) {
     return new Promise((resolve2, reject) => {
-      const args = this.buildArgs(model, false);
-      const child = spawn(AGENT_BIN, args, {
-        stdio: ["pipe", "pipe", "ignore"],
-        env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
-        ...IS_WINDOWS && { shell: true }
-      });
+      const { child, stderrChunks } = this.spawnAgent(model, false);
+      let settled = false;
       const chunks = [];
-      child.stdout.on("data", (data) => {
-        chunks.push(data);
+      child.stdout.on("data", (data) => chunks.push(data));
+      const timer = setTimeout(() => {
+        this.killWithEscalation(child);
+        if (!settled) {
+          settled = true;
+          reject(new Error(`Cursor agent timed out after ${this.timeoutMs / 1e3}s. Set CALIBER_CURSOR_TIMEOUT_MS to increase.`));
+        }
+      }, this.timeoutMs);
+      timer.unref();
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        if (!settled) {
+          settled = true;
+          reject(err);
+        }
       });
-      child.on("error", reject);
       child.on("close", (code) => {
+        clearTimeout(timer);
+        if (settled) return;
+        settled = true;
         const output = Buffer.concat(chunks).toString("utf-8").trim();
         if (code !== 0 && !output) {
-          reject(new Error(`Cursor agent exited with code ${code}`));
+          reject(new Error(this.buildErrorMessage(code, stderrChunks)));
         } else {
           resolve2(output);
         }
@@ -1320,14 +1444,20 @@ var CursorAcpProvider = class {
   }
   runPrintStream(model, prompt, callbacks) {
     return new Promise((resolve2, reject) => {
-      const args = this.buildArgs(model, true);
-      const child = spawn(AGENT_BIN, args, {
-        stdio: ["pipe", "pipe", "ignore"],
-        env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
-        ...IS_WINDOWS && { shell: true }
-      });
+      const { child, stderrChunks } = this.spawnAgent(model, true);
       let buffer = "";
       let endCalled = false;
+      let settled = false;
+      const timer = setTimeout(() => {
+        this.killWithEscalation(child);
+        if (!settled) {
+          settled = true;
+          const err = new Error(`Cursor agent timed out after ${this.timeoutMs / 1e3}s. Set CALIBER_CURSOR_TIMEOUT_MS to increase.`);
+          callbacks.onError(err);
+          reject(err);
+        }
+      }, this.timeoutMs);
+      timer.unref();
       child.stdout.on("data", (data) => {
         buffer += data.toString("utf-8");
         const lines = buffer.split("\n");
@@ -1352,16 +1482,26 @@ var CursorAcpProvider = class {
         }
       });
       child.on("error", (err) => {
-        callbacks.onError(err);
-        reject(err);
+        clearTimeout(timer);
+        if (!settled) {
+          settled = true;
+          callbacks.onError(err);
+          reject(err);
+        }
       });
       child.on("close", (code) => {
+        clearTimeout(timer);
+        if (settled) return;
+        settled = true;
         if (buffer.trim()) {
           try {
             const event = JSON.parse(buffer);
             if (event.type === "assistant") {
-              const text = event.message?.content?.[0]?.text || event.content;
-              if (text) callbacks.onText(text);
+              const isDelta = "timestamp_ms" in event;
+              if (isDelta) {
+                const text = event.message?.content?.[0]?.text || event.content;
+                if (text) callbacks.onText(text);
+              }
             } else if (event.type === "result") {
               endCalled = true;
               callbacks.onEnd({ stopReason: event.is_error ? "error" : "end_turn" });
@@ -1374,9 +1514,16 @@ var CursorAcpProvider = class {
           callbacks.onEnd({ stopReason: code === 0 ? "end_turn" : "error" });
         }
         if (code !== 0 && code !== null) {
-          const err = new Error(`Cursor agent exited with code ${code}`);
-          callbacks.onError(err);
-          reject(err);
+          const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+          if (isRateLimitError(stderr)) {
+            const err = new Error("Rate limit exceeded");
+            callbacks.onError(err);
+            reject(err);
+          } else {
+            const err = new Error(this.buildErrorMessage(code, stderrChunks));
+            callbacks.onError(err);
+            reject(err);
+          }
         } else {
           resolve2();
         }
@@ -1403,28 +1550,48 @@ var CursorAcpProvider = class {
 };
 function isCursorAgentAvailable() {
   try {
-    const cmd = process.platform === "win32" ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
+    const cmd = IS_WINDOWS ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
     execSync3(cmd, { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
+function isCursorLoggedIn() {
+  try {
+    const result = execSync3(`${AGENT_BIN} status`, { stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+    return !result.toString().includes("not logged in");
+  } catch {
+    return false;
+  }
+}
 
 // src/llm/claude-cli.ts
 import { spawn as spawn2, execSync as execSync4 } from "child_process";
 var CLAUDE_CLI_BIN = "claude";
-var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
 var IS_WINDOWS2 = process.platform === "win32";
+function spawnClaude(args) {
+  return IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
+    cwd: process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env,
+    shell: true
+  }) : spawn2(CLAUDE_CLI_BIN, args, {
+    cwd: process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env
+  });
+}
 var ClaudeCliProvider = class {
   defaultModel;
   timeoutMs;
   constructor(config) {
     this.defaultModel = config.model || "default";
     const envTimeout = process.env.CALIBER_CLAUDE_CLI_TIMEOUT_MS;
-    this.timeoutMs = envTimeout ? parseInt(envTimeout, 10) : DEFAULT_TIMEOUT_MS;
+    this.timeoutMs = envTimeout ? parseInt(envTimeout, 10) : DEFAULT_TIMEOUT_MS2;
     if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 1e3) {
-      this.timeoutMs = DEFAULT_TIMEOUT_MS;
+      this.timeoutMs = DEFAULT_TIMEOUT_MS2;
     }
   }
   async call(options) {
@@ -1435,23 +1602,16 @@ var ClaudeCliProvider = class {
     const combined = this.buildCombinedPrompt(options);
     const args = ["-p"];
     if (options.model) args.push("--model", options.model);
-    const child = IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
-      cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "inherit"],
-      env: process.env,
-      shell: true
-    }) : spawn2(CLAUDE_CLI_BIN, args, {
-      cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "inherit"],
-      env: process.env
-    });
+    const child = spawnClaude(args);
     child.stdin.end(combined);
     let settled = false;
     const chunks = [];
+    const stderrChunks = [];
     child.stdout.on("data", (chunk) => {
       chunks.push(chunk);
       callbacks.onText(chunk.toString("utf-8"));
     });
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
       if (!settled) {
@@ -1477,45 +1637,40 @@ var ClaudeCliProvider = class {
       if (code === 0) {
         callbacks.onEnd({ stopReason: "end_turn" });
       } else {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        const friendly = parseSeatBasedError(stderr, code);
         const stdout = Buffer.concat(chunks).toString("utf-8").trim();
-        const msg = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
-        callbacks.onError(new Error(stdout ? `${msg}. Output: ${stdout.slice(0, 200)}` : msg));
+        const base = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
+        const detail = friendly || stderr || (stdout ? stdout.slice(0, 200) : "");
+        callbacks.onError(new Error(detail ? `${base}. ${detail}` : base));
       }
     });
   }
   buildCombinedPrompt(options) {
     const streamOpts = options;
     const hasHistory = streamOpts.messages && streamOpts.messages.length > 0;
-    let combined = "";
-    combined += "[[System]]\n" + options.system + "\n\n";
+    let combined = options.system + "\n\n";
     if (hasHistory) {
       for (const msg of streamOpts.messages) {
-        combined += `[[${msg.role === "user" ? "User" : "Assistant"}]]
-${msg.content}
+        const label = msg.role === "user" ? "User" : "Assistant";
+        combined += `${label}: ${msg.content}
 
 `;
       }
     }
-    combined += "[[User]]\n" + options.prompt;
+    combined += options.prompt;
     return combined;
   }
   runClaudePrint(combinedPrompt, model) {
     return new Promise((resolve2, reject) => {
       const args = ["-p"];
       if (model) args.push("--model", model);
-      const child = IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "inherit"],
-        env: process.env,
-        shell: true
-      }) : spawn2(CLAUDE_CLI_BIN, args, {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "inherit"],
-        env: process.env
-      });
+      const child = spawnClaude(args);
       child.stdin.end(combinedPrompt);
       const chunks = [];
+      const stderrChunks = [];
       child.stdout.on("data", (chunk) => chunks.push(chunk));
+      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
       child.on("error", (err) => {
         clearTimeout(timer);
         reject(err);
@@ -1526,8 +1681,11 @@ ${msg.content}
         if (code === 0) {
           resolve2(stdout);
         } else {
-          const msg = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
-          reject(new Error(stdout ? `${msg}. Output: ${stdout.slice(0, 200)}` : msg));
+          const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+          const friendly = parseSeatBasedError(stderr, code);
+          const base = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
+          const detail = friendly || stderr || (stdout ? stdout.slice(0, 200) : "");
+          reject(new Error(detail ? `${base}. ${detail}` : base));
         }
       });
       const timer = setTimeout(() => {
@@ -1701,6 +1859,7 @@ async function handleModelNotAvailable(failedModel, provider, config) {
 }
 
 // src/llm/index.ts
+init_types();
 init_config();
 var cachedProvider = null;
 var cachedConfig = null;
@@ -1776,11 +1935,11 @@ async function llmCall(options) {
         throw error;
       }
       if (isOverloaded(error) && attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, 2e3));
+        await new Promise((r) => setTimeout(r, 1e3 * Math.pow(2, attempt - 1)));
         continue;
       }
       if (isTransientError(error) && attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, 2e3));
+        await new Promise((r) => setTimeout(r, 1e3 * Math.pow(2, attempt - 1)));
         continue;
       }
       throw error;
@@ -1796,7 +1955,8 @@ async function validateModel(options) {
   const provider = getProvider();
   const config = cachedConfig;
   if (!config) return;
-  if (config.provider === "cursor" || config.provider === "claude-cli") return;
+  const { isSeatBased: isSeatBased2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  if (isSeatBased2(config.provider)) return;
   const modelsToCheck = [config.model];
   if (options?.fast) {
     const { getFastModel: getFastModel2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -4196,8 +4356,11 @@ async function runInteractiveProviderSetup(options) {
         console.log(chalk5.dim("  Then run ") + chalk5.hex("#83D1EB")("agent login") + chalk5.dim(" to authenticate.\n"));
         const proceed = await confirm({ message: "Continue anyway?" });
         if (!proceed) throw new Error("__exit__");
-      } else {
-        console.log(chalk5.dim("  Run `agent login` if you haven't, or set CURSOR_API_KEY."));
+      } else if (!isCursorLoggedIn()) {
+        console.log(chalk5.yellow("\n  Cursor Agent CLI found but not logged in."));
+        console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("agent login") + chalk5.dim(" to authenticate.\n"));
+        const proceed = await confirm({ message: "Continue anyway?" });
+        if (!proceed) throw new Error("__exit__");
       }
       break;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.23.0-dev.1773793983",
+  "version": "1.23.0",
   "description": "Analyze your codebase and generate optimized AI agent configs (CLAUDE.md, .cursorrules, skills) — no API key needed",
   "type": "module",
   "bin": {