@offbynan/pi-cursor-provider 0.5.1 → 0.5.2

package/h2-bridge.mjs

@@ -105,12 +105,14 @@ function resetTimeout() {
 
 function killBridge() {
   clearTimeout(timeout);
+  process.stderr.write(JSON.stringify({ type: "exit_reason", reason: "timeout" }) + "\n");
   client.destroy();
-  process.exit(1);
+  process.exit(2);
 }
 
 client.on("error", () => {
   clearTimeout(timeout);
+  process.stderr.write(JSON.stringify({ type: "exit_reason", reason: "connection_error" }) + "\n");
   process.exit(1);
 });
 
@@ -130,6 +132,20 @@ if (!unary) {
 }
 const h2Stream = client.request(headers);
 
+// Read response headers: switch to activity timeout and forward status to stderr
+h2Stream.on("response", (headers) => {
+  resetTimeout();
+  const status = headers[":status"] ?? null;
+  const grpcStatus = headers["grpc-status"] ?? null;
+  process.stderr.write(
+    JSON.stringify({
+      type: "response_headers",
+      status: status !== null ? Number(status) : null,
+      grpcStatus: grpcStatus !== null ? Number(grpcStatus) : null,
+    }) + "\n",
+  );
+});
+
 // Forward H2 response data → stdout (length-prefixed)
 h2Stream.on("data", (chunk) => {
   resetTimeout();
@@ -145,6 +161,7 @@ h2Stream.on("end", () => {
 
 h2Stream.on("error", () => {
   clearTimeout(timeout);
+  process.stderr.write(JSON.stringify({ type: "exit_reason", reason: "stream_error" }) + "\n");
   client.close();
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offbynan/pi-cursor-provider",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Pi extension providing access to Cursor models via OAuth and a local OpenAI-compatible gRPC proxy",
   "type": "module",
   "license": "MIT",

package/proxy.ts

@@ -154,6 +154,11 @@ interface PendingExec {
   decodedArgs: string;
 }
 
+interface StderrData {
+  responseHeaders?: { status: number; grpcStatus: number | null };
+  exitReason?: "timeout" | "connection_error" | "stream_error";
+}
+
 interface BridgeHandle {
   proc: Pick<ChildProcess, "kill">;
   readonly alive: boolean;
@@ -162,6 +167,7 @@ interface BridgeHandle {
   unref(): void;
   onData(cb: (chunk: Buffer) => void): void;
   onClose(cb: (code: number) => void): void;
+  getStderr(): StderrData;
 }
 
 export type BridgeFactory = (options: SpawnBridgeOptions) => BridgeHandle;
@@ -263,6 +269,7 @@ interface ParsedMessages {
 // ── State ──
 
 const activeBridges = new Map<string, ActiveBridge>();
+const sessionBridges = new Map<string, BridgeHandle>();
 const conversationStates = new Map<string, StoredConversation>();
 let bridgeFactory: BridgeFactory = spawnBridge;
 let debugRequestCounter = 0;
@@ -353,6 +360,7 @@ function nextDebugRequestId(): string {
 
 export const __testInternals = {
   activeBridges,
+  sessionBridges,
   conversationStates,
 };
 
@@ -395,7 +403,33 @@ function spawnBridge(options: SpawnBridgeOptions): BridgeHandle {
     unary: options.unary ?? false,
   });
   const proc = spawn("node", [BRIDGE_PATH], {
-    stdio: ["pipe", "pipe", "ignore"],
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  const stderrData: StderrData = {};
+  let stderrBuf = "";
+  proc.stderr!.on("data", (chunk: Buffer) => {
+    stderrBuf += chunk.toString("utf8");
+    let nl: number;
+    while ((nl = stderrBuf.indexOf("\n")) !== -1) {
+      const line = stderrBuf.slice(0, nl).trim();
+      stderrBuf = stderrBuf.slice(nl + 1);
+      if (!line) continue;
+      debugLog("bridge.stderr", { rpcPath: options.rpcPath, line });
+      try {
+        const parsed = JSON.parse(line) as Record<string, unknown>;
+        if (parsed["type"] === "response_headers") {
+          stderrData.responseHeaders = {
+            status: parsed["status"] as number,
+            grpcStatus: parsed["grpcStatus"] as number | null,
+          };
+        } else if (parsed["type"] === "exit_reason") {
+          stderrData.exitReason = parsed["reason"] as StderrData["exitReason"];
+        }
+      } catch {
+        // not structured JSON — ignore
+      }
+    }
   });
 
   const config = JSON.stringify({
@@ -433,6 +467,7 @@ function spawnBridge(options: SpawnBridgeOptions): BridgeHandle {
     // loop alive after the bridge exits (critical for `pi -p` to exit cleanly).
     try { proc.stdout!.destroy(); } catch {}
     try { proc.stdin!.destroy(); } catch {}
+    try { proc.stderr!.destroy(); } catch {}
     debugLog("bridge.exit", { rpcPath: options.rpcPath, exitCode });
     cbs.close?.(exitCode);
   });
@@ -469,9 +504,43 @@ function spawnBridge(options: SpawnBridgeOptions): BridgeHandle {
         cbs.close = cb;
       }
     },
+    getStderr() {
+      return stderrData;
+    },
   };
 }
 
+// ── Bridge failure classification ──
+
+function classifyBridgeFailure(code: number, stderr: StderrData): string {
+  const hadHeaders = !!stderr.responseHeaders;
+  const status = stderr.responseHeaders?.status;
+  const reason = stderr.exitReason;
+
+  // Timeout (exit 2 or explicit reason)
+  if (code === 2 || reason === "timeout") {
+    return hadHeaders
+      ? "Cursor did not respond within 5 minutes — try again"
+      : "Could not reach Cursor's API within 2 minutes — check your network";
+  }
+
+  // Connection or stream error (exit 1)
+  if (status === 401 || status === 403) {
+    return "Cursor authentication expired — run /login cursor to re-authenticate";
+  }
+  if (status === 429) {
+    return "Cursor rate limited — try again shortly";
+  }
+  if (status !== undefined && status >= 500 && status < 600) {
+    return `Cursor server error (${status}) — try again`;
+  }
+  if (!hadHeaders) {
+    return "Could not connect to Cursor's API — check your network";
+  }
+
+  return `Cursor bridge terminated (exit ${code}) before response — try again or shorten the conversation`;
+}
+
 // ── Unary RPC (for model discovery) ──
 
 export async function callCursorUnaryRpc(options: {
@@ -758,6 +827,7 @@ export function cleanupAllSessionState(): void {
   for (const [bridgeKey, active] of activeBridges) {
     cleanupBridge(active.bridge, active.heartbeatTimer, bridgeKey);
   }
+  sessionBridges.clear();
   conversationStates.clear();
 }
 
@@ -886,9 +956,7 @@ async function handleChatCompletion(
   }
 
   if (activeBridge && activeBridges.has(bridgeKey)) {
-    clearInterval(activeBridge.heartbeatTimer);
-    activeBridge.bridge.end();
-    activeBridges.delete(bridgeKey);
+    cleanupBridge(activeBridge.bridge, activeBridge.heartbeatTimer, bridgeKey);
   }
 
   let stored = conversationStates.get(convKey);
@@ -942,11 +1010,12 @@ async function handleChatCompletion(
   };
 
   if (body.stream === false) {
-    debugLog("chat.dispatch_nonstream", { requestId, convKey });
+    debugLog("chat.dispatch_nonstream", { requestId, bridgeKey, convKey });
     await handleNonStreamingResponse(
       payload,
       accessToken,
       modelId,
+      bridgeKey,
       convKey,
       turns,
       currentTurn,
@@ -2165,15 +2234,42 @@ function createConnectFrameParser(
   };
 }
 
+const CONTEXT_OVERFLOW_MSG =
+  "context length exceeded — Cursor rejected the request as too large";
+
+function isContextOverflowMessage(msg: string): boolean {
+  return /context|token|length|overflow|too.?long|too.?large/i.test(msg);
+}
+
+function mapConnectErrorCode(code: string, message: string): string {
+  switch (code) {
+    case "unauthenticated":
+      return "Cursor authentication expired — run /login cursor";
+    case "resource_exhausted":
+      return CONTEXT_OVERFLOW_MSG;
+    case "deadline_exceeded":
+      return "Cursor request timed out server-side — try again";
+    case "unavailable":
+      return "Cursor service unavailable — try again";
+    case "internal":
+      return "Cursor internal error — try again";
+    case "invalid_argument":
+      return isContextOverflowMessage(message) ? CONTEXT_OVERFLOW_MSG : message;
+    default:
+      return message;
+  }
+}
+
 function parseConnectEndStream(data: Uint8Array): Error | null {
   if (data.length === 0) return null;
   try {
     const payload = JSON.parse(new TextDecoder().decode(data));
     const error = payload?.error;
-    if (error)
-      return new Error(
-        `Connect error ${error.code ?? "unknown"}: ${error.message ?? "Unknown error"}`,
-      );
+    if (error) {
+      const code = String(error.code ?? "unknown");
+      const rawMessage = String(error.message ?? "Unknown error");
+      return new Error(mapConnectErrorCode(code, rawMessage));
+    }
     return null;
   } catch {
     return null;
@@ -2285,12 +2381,25 @@ function respondWithPendingToolCalls(
 
 // ── Streaming response ──
 
-function startBridge(accessToken: string, requestBytes: Uint8Array) {
+function startBridge(accessToken: string, requestBytes: Uint8Array, bridgeKey: string) {
+  let staleBridgeKilled = false;
+  const existing = sessionBridges.get(bridgeKey);
+  if (existing) {
+    if (existing.alive) {
+      console.error(
+        `[cursor-provider] Stale bridge detected for session ${bridgeKey} — force-killing and replacing`,
+      );
+      staleBridgeKilled = true;
+      try { existing.proc.kill(); } catch {}
+    }
+    sessionBridges.delete(bridgeKey);
+  }
+
   const bridge = bridgeFactory({
     accessToken,
     rpcPath: "/agent.v1.AgentService/Run",
   });
-  debugLog("bridge.start_run", { requestBytes });
+  debugLog("bridge.start_run", { requestBytes, bridgeKey, staleBridgeKilled });
   bridge.write(frameConnectMessage(requestBytes));
   const heartbeatTimer = setInterval(
     () => bridge.write(makeHeartbeatBytes()),
@@ -2298,7 +2407,8 @@ function startBridge(accessToken: string, requestBytes: Uint8Array) {
   );
   // Don't hold the event loop open between heartbeats.
   heartbeatTimer.unref();
-  return { bridge, heartbeatTimer };
+  sessionBridges.set(bridgeKey, bridge);
+  return { bridge, heartbeatTimer, staleBridgeKilled };
 }
 
 function handleStreamingResponse(
@@ -2314,9 +2424,10 @@ function handleStreamingResponse(
   requestId: string,
 ): void {
   debugLog("stream.start", { requestId, bridgeKey, convKey, modelId });
-  const { bridge, heartbeatTimer } = startBridge(
+  const { bridge, heartbeatTimer, staleBridgeKilled } = startBridge(
     accessToken,
     payload.requestBytes,
+    bridgeKey,
   );
   writeSSEStream(
     bridge,
@@ -2331,6 +2442,7 @@ function handleStreamingResponse(
     req,
     res,
     requestId,
+    staleBridgeKilled,
   );
 }
 
@@ -2357,7 +2469,9 @@ function cleanupBridge(
   if (bridge.alive) {
     sendCancelAction(bridge);
     bridge.end();
+    setTimeout(() => { try { bridge.proc.kill(); } catch {} }, 10_000);
   }
+  if (sessionBridges.get(bridgeKey) === bridge) sessionBridges.delete(bridgeKey);
   activeBridges.delete(bridgeKey);
 }
 
@@ -2374,6 +2488,7 @@ function writeSSEStream(
   req: IncomingMessage,
   res: ServerResponse,
   requestId?: string,
+  staleBridgeKilled = false,
 ): void {
   debugLog("stream.writer_start", {
     requestId,
@@ -2391,6 +2506,17 @@ function writeSSEStream(
     "Cache-Control": "no-cache",
     Connection: "close",
   });
+  if (staleBridgeKilled) {
+    res.write(
+      `data: ${JSON.stringify({
+        id: completionId,
+        object: "chat.completion.chunk",
+        created,
+        model: modelId,
+        choices: [{ index: 0, delta: { content: "\u26a0 A previous request for this session was still running and has been cancelled.\n" }, finish_reason: null }],
+      })}\n\n`,
+    );
+  }
 
   let closed = false;
   let keepAliveTimer: ReturnType<typeof setInterval> | undefined;
@@ -2620,6 +2746,7 @@ function writeSSEStream(
       latestCheckpoint,
     });
     clearInterval(heartbeatTimer);
+    if (sessionBridges.get(bridgeKey) === bridge) sessionBridges.delete(bridgeKey);
     req.removeListener("close", onClientClose);
     res.removeListener("close", onClientClose);
     const stored = conversationStates.get(convKey);
@@ -2643,7 +2770,8 @@ function writeSSEStream(
         console.error(
           `[cursor-provider] Bridge exited (code ${code}) before receiving response (${modelId})`,
         );
-        sendSSE(makeChunk({ content: `Cursor bridge terminated (exit ${code}) before response — try again or shorten the conversation` }, "error"));
+        const failureMsg = classifyBridgeFailure(code, bridge.getStderr());
+        sendSSE(makeChunk({ content: failureMsg }, "error"));
         sendSSE(makeUsageChunk());
         sendDone();
         closeResponse();
@@ -2828,6 +2956,7 @@ async function handleNonStreamingResponse(
   payload: CursorRequestPayload,
   accessToken: string,
   modelId: string,
+  bridgeKey: string,
   convKey: string,
   completedTurns: ParsedTurn[],
   currentTurn: ParsedTurn,
@@ -2837,6 +2966,7 @@ async function handleNonStreamingResponse(
 ): Promise<void> {
   debugLog("nonstream.start", {
     requestId,
+    bridgeKey,
     convKey,
     modelId,
     currentTurn,
@@ -2848,6 +2978,7 @@ async function handleNonStreamingResponse(
   const { bridge, heartbeatTimer } = startBridge(
     accessToken,
     payload.requestBytes,
+    bridgeKey,
   );
   let cancelled = false;
 
@@ -2973,6 +3104,7 @@ async function handleNonStreamingResponse(
     bridge.onClose((code) => {
       debugLog("nonstream.bridge_close", {
         requestId,
+        bridgeKey,
         convKey,
         code,
         cancelled,
@@ -2981,6 +3113,7 @@ async function handleNonStreamingResponse(
         latestCheckpoint,
       });
       clearInterval(heartbeatTimer);
+      if (sessionBridges.get(bridgeKey) === bridge) sessionBridges.delete(bridgeKey);
       req.removeListener("close", onClientClose);
       res.removeListener("close", onClientClose);
       const stored = conversationStates.get(convKey);
@@ -3035,11 +3168,12 @@ async function handleNonStreamingResponse(
         console.error(
           `[cursor-provider] Bridge exited (code ${code}) before non-stream response (${modelId})`,
         );
+        const failureMsg = classifyBridgeFailure(code, bridge.getStderr());
         res.writeHead(502, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
             error: {
-              message: `Cursor bridge terminated (exit ${code}) before response — try again or shorten the conversation`,
+              message: failureMsg,
               type: "upstream_error",
               code: "bridge_terminated",
             },