@rama_nigg/open-cursor 2.3.20 → 2.4.1

package/src/plugin.ts

@@ -10,7 +10,12 @@ import { startCursorOAuth } from "./auth";
 import { LineBuffer } from "./streaming/line-buffer.js";
 import { StreamToSseConverter, formatSseDone } from "./streaming/openai-sse.js";
 import { parseStreamJsonLine } from "./streaming/parser.js";
-import { extractText, extractThinking, isAssistantText, isThinking } from "./streaming/types.js";
+import { extractText, extractThinking, isAssistantText, isResult, isThinking } from "./streaming/types.js";
+import {
+  createChatCompletionUsageChunk,
+  extractOpenAiUsageFromResult,
+  type OpenAiUsage,
+} from "./usage.js";
 import { createLogger } from "./utils/logger";
 import { RequestPerf } from "./utils/perf";
 import { parseAgentError, formatErrorForUser, stripAnsi } from "./utils/errors";
@@ -52,6 +57,7 @@ import {
   parseToolLoopMaxRepeat,
   type ToolLoopGuard,
 } from "./provider/tool-loop-guard.js";
+import { resolveCursorAgentBinary } from "./utils/binary.js";
 
 const log = createLogger("plugin");
 
@@ -191,7 +197,7 @@ function canonicalizePathForCompare(pathValue: string): string {
     normalizedPath = resolvedPath;
   }
 
-  if (process.platform === "darwin") {
+  if (process.platform === "darwin" || process.platform === "win32") {
     return normalizedPath.toLowerCase();
   }
 
@@ -219,37 +225,76 @@ function isNonConfigPath(pathValue: string): boolean {
   return !isWithinPath(getOpenCodeConfigPrefix(), pathValue);
 }
 
-const SESSION_WORKSPACE_CACHE_LIMIT = 200;
-
-function resolveWorkspaceDirectory(worktree: string | undefined, directory: string | undefined): string {
-  const envWorkspace = process.env.CURSOR_ACP_WORKSPACE?.trim();
-  if (envWorkspace) {
-    return resolve(envWorkspace);
+// Filesystem roots are never a meaningful workspace: accepting "/" (or a bare
+// Windows drive root like "C:\") makes every tool treat the whole machine as
+// the project, which is both unsafe and a common symptom of a daemon that
+// was launched without a real cwd (e.g. systemd unit without WorkingDirectory).
+export function isRootPath(pathValue: string): boolean {
+  if (!pathValue) {
+    return false;
   }
+  const resolved = resolve(pathValue);
+  if (resolved === "/") {
+    return true;
+  }
+  return /^[A-Za-z]:[\\/]?$/.test(resolved);
+}
 
-  const envProjectDir = process.env.OPENCODE_CURSOR_PROJECT_DIR?.trim();
-  if (envProjectDir) {
-    return resolve(envProjectDir);
+function isAcceptableWorkspace(pathValue: string, configPrefix: string): boolean {
+  if (!pathValue) {
+    return false;
   }
+  if (isRootPath(pathValue)) {
+    return false;
+  }
+  if (isWithinPath(configPrefix, pathValue)) {
+    return false;
+  }
+  return true;
+}
+
+const SESSION_WORKSPACE_CACHE_LIMIT = 200;
 
+export function resolveWorkspaceDirectory(
+  worktree: string | undefined,
+  directory: string | undefined,
+): string {
   const configPrefix = getOpenCodeConfigPrefix();
 
+  const envWorkspace = resolveCandidate(process.env.CURSOR_ACP_WORKSPACE);
+  if (envWorkspace && !isRootPath(envWorkspace)) {
+    return envWorkspace;
+  }
+
+  const envProjectDir = resolveCandidate(process.env.OPENCODE_CURSOR_PROJECT_DIR);
+  if (envProjectDir && !isRootPath(envProjectDir)) {
+    return envProjectDir;
+  }
+
   const worktreeCandidate = resolveCandidate(worktree);
-  if (worktreeCandidate && !isWithinPath(configPrefix, worktreeCandidate)) {
+  if (isAcceptableWorkspace(worktreeCandidate, configPrefix)) {
     return worktreeCandidate;
   }
 
   const dirCandidate = resolveCandidate(directory);
-  if (dirCandidate && !isWithinPath(configPrefix, dirCandidate)) {
+  if (isAcceptableWorkspace(dirCandidate, configPrefix)) {
     return dirCandidate;
   }
 
   const cwd = resolve(process.cwd());
-  if (cwd && !isWithinPath(configPrefix, cwd)) {
+  if (isAcceptableWorkspace(cwd, configPrefix)) {
     return cwd;
   }
 
-  return dirCandidate || cwd || configPrefix;
+  // Fall back to the user's home directory rather than "/" when every other
+  // signal is unusable. $HOME is always writable for the current user and
+  // keeps tool scopes sane even when the daemon was spawned from root.
+  const home = resolveCandidate(homedir());
+  if (home && !isRootPath(home)) {
+    return home;
+  }
+
+  return configPrefix;
 }
 
 type ProxyRuntimeState = {
@@ -258,7 +303,11 @@ type ProxyRuntimeState = {
 };
 
 export function normalizeWorkspaceForCompare(pathValue: string): string {
-  return resolve(pathValue);
+  const resolved = resolve(pathValue);
+  if (process.platform === "darwin" || process.platform === "win32") {
+    return resolved.toLowerCase();
+  }
+  return resolved;
 }
 
 export function isReusableProxyHealthPayload(payload: any, workspaceDirectory: string): boolean {
@@ -321,7 +370,12 @@ export function resolveChatParamTools(
   return PROVIDER_BOUNDARY.resolveChatParamTools(mode, existingTools, refreshedTools);
 }
 
-function createChatCompletionResponse(model: string, content: string, reasoningContent?: string) {
+function createChatCompletionResponse(
+  model: string,
+  content: string,
+  reasoningContent?: string,
+  usage?: OpenAiUsage,
+) {
   const message: { role: "assistant"; content: string; reasoning_content?: string } = {
     role: "assistant",
     content,
@@ -331,7 +385,18 @@ function createChatCompletionResponse(model: string, content: string, reasoningC
     message.reasoning_content = reasoningContent;
   }
 
-  return {
+  const response: {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+      index: number;
+      message: typeof message;
+      finish_reason: string;
+    }>;
+    usage?: OpenAiUsage;
+  } = {
     id: `cursor-acp-${Date.now()}`,
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
@@ -344,6 +409,12 @@ function createChatCompletionResponse(model: string, content: string, reasoningC
       },
     ],
   };
+
+  if (usage) {
+    response.usage = usage;
+  }
+
+  return response;
 }
 
 function createChatCompletionChunk(id: string, created: number, model: string, deltaContent: string, done = false) {
@@ -362,11 +433,17 @@ function createChatCompletionChunk(id: string, created: number, model: string, d
   };
 }
 
-function extractCompletionFromStream(output: string): { assistantText: string; reasoningText: string } {
+export function extractCompletionFromStream(output: string): {
+  assistantText: string;
+  reasoningText: string;
+  usage?: OpenAiUsage;
+} {
   const lines = output.split("\n");
   let assistantText = "";
   let reasoningText = "";
+  let usage: OpenAiUsage | undefined;
   let sawAssistantPartials = false;
+  let sawThinkingPartials = false;
 
   for (const line of lines) {
     const event = parseStreamJsonLine(line);
@@ -390,12 +467,22 @@ function extractCompletionFromStream(output: string): { assistantText: string; r
     if (isThinking(event)) {
       const thinking = extractThinking(event);
       if (thinking) {
-        reasoningText += thinking;
+        const isPartial = typeof (event as any).timestamp_ms === "number";
+        if (isPartial) {
+          reasoningText += thinking;
+          sawThinkingPartials = true;
+        } else if (!sawThinkingPartials) {
+          reasoningText = thinking;
+        }
       }
     }
+
+    if (isResult(event)) {
+      usage = extractOpenAiUsageFromResult(event) ?? usage;
+    }
   }
 
-  return { assistantText, reasoningText };
+  return { assistantText, reasoningText, usage };
 }
 
 function formatToolUpdateEvent(update: ToolUpdate): string {
@@ -570,7 +657,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       if (url.pathname === "/v1/models" || url.pathname === "/models") {
         try {
           const bunAny = globalThis as any;
-          const proc = bunAny.Bun.spawn(["cursor-agent", "models"], {
+          const proc = bunAny.Bun.spawn([resolveCursorAgentBinary(), "models"], {
             stdout: "pipe",
             stderr: "pipe",
           });
@@ -621,6 +708,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       // DEBUG: Log raw request structure for tool-loop investigation
       debugLogToFile("raw_request_body", {
         model: body?.model,
+        cursorModel: body?.cursorModel,
         stream,
         toolCount: tools.length,
         toolNames: tools.map((t: any) => t?.function?.name ?? t?.name ?? "unknown"),
@@ -637,8 +725,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
 
       const subagentNames = readSubagentNames();
       const prompt = buildPromptFromMessages(messages, tools, subagentNames);
-      const model = boundaryContext.run("normalizeRuntimeModel", (boundary) =>
-        boundary.normalizeRuntimeModel(body?.model),
+      const model = boundaryContext.run("resolveRuntimeModel", (boundary) =>
+        boundary.resolveRuntimeModel(body?.model, body?.cursorModel),
       );
       const msgSummaryBun = messages.map((m: any, i: number) => {
         const role = m?.role ?? "?";
@@ -664,7 +752,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       }
 
       const cmd = [
-        "cursor-agent",
+        resolveCursorAgentBinary(),
         "--print",
         "--output-format",
         "stream-json",
@@ -765,6 +853,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
           model,
           completion.assistantText || stdout || stderr,
           completion.reasoningText || undefined,
+          completion.usage,
         );
         return new Response(JSON.stringify(payload), {
           status: 200,
@@ -786,6 +875,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         async start(controller) {
           let streamTerminated = false;
           let firstTokenReceived = false;
+          let usage: OpenAiUsage | undefined;
           try {
             const reader = (child.stdout as ReadableStream<Uint8Array>).getReader();
             const converter = new StreamToSseConverter(model, { id, created });
@@ -840,6 +930,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
                   continue;
                 }
 
+                if (isResult(event)) {
+                  usage = extractOpenAiUsageFromResult(event) ?? usage;
+                }
+
                 if (event.type === "tool_call") {
                   perf.mark("tool-call");
                   const result = await handleToolLoopEventWithFallback({
@@ -906,6 +1000,9 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
               if (!event) {
                 continue;
               }
+              if (isResult(event)) {
+                usage = extractOpenAiUsageFromResult(event) ?? usage;
+              }
               if (event.type === "tool_call") {
                 const result = await handleToolLoopEventWithFallback({
                   event: event as any,
@@ -994,6 +1091,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
 
             const doneChunk = createChatCompletionChunk(id, created, model, "", true);
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunk)}\n\n`));
+            if (usage) {
+              const usageChunk = createChatCompletionUsageChunk(id, created, model, usage);
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(usageChunk)}\n\n`));
+            }
             controller.enqueue(encoder.encode(formatSseDone()));
           } finally {
             perf.mark("request:done");
@@ -1054,8 +1155,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       // Dynamic model discovery via cursor-agent models (Node.js handler)
       if (url.pathname === "/v1/models" || url.pathname === "/models") {
         try {
-          const { execSync } = await import("child_process");
-          const output = execSync("cursor-agent models", { encoding: "utf-8", timeout: 30000 });
+          const { execFileSync } = await import("child_process");
+          const output = execFileSync(resolveCursorAgentBinary(), ["models"], { encoding: "utf-8", timeout: 30000 });
           const clean = stripAnsi(output);
           const models: Array<{ id: string; object: string; created: number; owned_by: string }> = [];
           for (const line of clean.split("\n")) {
@@ -1102,8 +1203,8 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
 
       const subagentNames = readSubagentNames();
       const prompt = buildPromptFromMessages(messages, tools, subagentNames);
-      const model = boundaryContext.run("normalizeRuntimeModel", (boundary) =>
-        boundary.normalizeRuntimeModel(bodyData?.model),
+      const model = boundaryContext.run("resolveRuntimeModel", (boundary) =>
+        boundary.resolveRuntimeModel(bodyData?.model, bodyData?.cursorModel),
       );
       const msgSummary = messages.map((m: any, i: number) => {
         const role = m?.role ?? "?";
@@ -1123,7 +1224,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       });
 
       const cmd = [
-        "cursor-agent",
+        resolveCursorAgentBinary(),
         "--print",
         "--output-format",
         "stream-json",
@@ -1137,7 +1238,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         cmd.push("--force");
       }
 
-      const child = spawn(cmd[0], cmd.slice(1), { stdio: ["pipe", "pipe", "pipe"] });
+      const child = spawn(cmd[0], cmd.slice(1), {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: process.platform === "win32",
+      });
 
       // Write prompt to stdin to avoid E2BIG error
       child.stdin.write(prompt);
@@ -1225,6 +1329,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
             model,
             completion.assistantText || stdout || stderr,
             completion.reasoningText || undefined,
+            completion.usage,
           );
 
           res.writeHead(200, { "Content-Type": "application/json" });
@@ -1251,6 +1356,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         const stderrChunks: Buffer[] = [];
         let streamTerminated = false;
         let firstTokenReceived = false;
+        let usage: OpenAiUsage | undefined;
         child.stderr.on("data", (chunk) => {
           stderrChunks.push(Buffer.from(chunk));
         });
@@ -1323,6 +1429,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
               continue;
             }
 
+            if (isResult(event)) {
+              usage = extractOpenAiUsageFromResult(event) ?? usage;
+            }
+
             if (event.type === "tool_call") {
               perf.mark("tool-call");
               const result = await handleToolLoopEventWithFallback({
@@ -1395,6 +1505,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
               continue;
             }
 
+            if (isResult(event)) {
+              usage = extractOpenAiUsageFromResult(event) ?? usage;
+            }
+
             if (event.type === "tool_call") {
               const result = await handleToolLoopEventWithFallback({
                 event: event as any,
@@ -1499,6 +1613,10 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
             ],
           };
           res.write(`data: ${JSON.stringify(doneChunk)}\n\n`);
+          if (usage) {
+            const usageChunk = createChatCompletionUsageChunk(id, created, model, usage);
+            res.write(`data: ${JSON.stringify(usageChunk)}\n\n`);
+          }
           res.write(formatSseDone());
           res.end();
         });
@@ -1594,7 +1712,7 @@ function jsonSchemaToZod(jsonSchema: any): any {
         }
         break;
       case "object":
-        zodType = z.record(z.any());
+        zodType = z.record(z.string(), z.any());
         if (p.description) {
           zodType = zodType.describe(p.description);
         }

package/src/provider/boundary.ts

@@ -36,6 +36,7 @@ export interface ProviderBoundary {
   ): ToolLoopFlags;
   matchesProvider(inputModel: any): boolean;
   normalizeRuntimeModel(model: unknown): string;
+  resolveRuntimeModel(model: unknown, cursorModel: unknown): string;
   applyChatParamDefaults(
     output: any,
     proxyBaseURL: string | undefined,
@@ -137,6 +138,15 @@ function createSharedBoundary(
       return raw;
     },
 
+    resolveRuntimeModel(model, cursorModel) {
+      const rawCursorModel = typeof cursorModel === "string" ? cursorModel.trim() : "";
+      if (rawCursorModel.length > 0) {
+        return this.normalizeRuntimeModel(rawCursorModel);
+      }
+
+      return this.normalizeRuntimeModel(model);
+    },
+
     applyChatParamDefaults(output, proxyBaseURL, defaultBaseURL, defaultApiKey) {
       output.options = output.options || {};
       output.options.baseURL = proxyBaseURL || defaultBaseURL;

package/src/proxy/formatter.ts

@@ -1,5 +1,22 @@
-export function createChatCompletionResponse(model: string, content: string) {
-  return {
+import type { OpenAiUsage } from "../usage.js";
+
+export function createChatCompletionResponse(
+  model: string,
+  content: string,
+  usage?: OpenAiUsage,
+) {
+  const response: {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+      index: number;
+      message: { role: string; content: string };
+      finish_reason: string;
+    }>;
+    usage?: OpenAiUsage;
+  } = {
     id: `cursor-acp-${Date.now()}`,
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
@@ -8,15 +25,16 @@ export function createChatCompletionResponse(model: string, content: string) {
       {
         index: 0,
         message: { role: "assistant", content },
-        finish_reason: "stop"
+        finish_reason: "stop",
       }
     ],
-    usage: {
-      prompt_tokens: 0,
-      completion_tokens: 0,
-      total_tokens: 0
-    }
   };
+
+  if (usage) {
+    response.usage = usage;
+  }
+
+  return response;
 }
 
 export function createChatCompletionChunk(
@@ -24,7 +42,7 @@ export function createChatCompletionChunk(
   created: number,
   model: string,
   deltaContent: string,
-  done = false
+  done = false,
 ) {
   return {
     id,
@@ -35,8 +53,8 @@ export function createChatCompletionChunk(
       {
         index: 0,
         delta: deltaContent ? { content: deltaContent } : {},
-        finish_reason: done ? "stop" : null
+        finish_reason: done ? "stop" : null,
       }
-    ]
+    ],
   };
-}
+}

package/src/streaming/types.ts

@@ -75,8 +75,13 @@ export type StreamJsonResultEvent = {
   type: "result";
   subtype?: "success" | "error" | string;
   timestamp?: number;
+  duration_ms?: number;
+  duration_api_ms?: number;
   session_id?: string;
+  request_id?: string;
+  result?: string;
   is_error?: boolean;
+  usage?: Record<string, unknown>;
   error?: {
     message?: string;
     code?: number | string;