@rama_nigg/open-cursor 2.4.4 → 2.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "No prompt limits. No broken streams. Full thinking + tool support. Your Cursor subscription, properly integrated.",
   "type": "module",
   "main": "dist/plugin-entry.js",

package/src/auth.ts

@@ -6,7 +6,7 @@ import { homedir, platform } from "os";
 import { join } from "path";
 import { createLogger } from "./utils/logger";
 import { stripAnsi } from "./utils/errors";
-import { resolveCursorAgentBinary } from "./utils/binary.js";
+import { formatShellCommandForPlatform, resolveCursorAgentBinary } from "./utils/binary.js";
 
 const log = createLogger("auth");
 
@@ -76,7 +76,7 @@ export async function startCursorOAuth(): Promise<{
   return new Promise((resolve, reject) => {
     log.info("Starting cursor-cli login process");
 
-    const proc = spawn(resolveCursorAgentBinary(), ["login"], {
+    const proc = spawn(formatShellCommandForPlatform(resolveCursorAgentBinary()), ["login"], {
       stdio: ["pipe", "pipe", "pipe"],
       shell: process.platform === "win32",
     });

package/src/client/simple.ts

@@ -7,7 +7,7 @@ import {
   type StreamJsonEvent,
 } from '../streaming/types.js';
 import { createLogger } from '../utils/logger.js';
-import { resolveCursorAgentBinary } from '../utils/binary.js';
+import { formatShellCommandForPlatform, resolveCursorAgentBinary } from '../utils/binary.js';
 
 export interface CursorClientConfig {
   timeout?: number;
@@ -77,7 +77,7 @@ export class SimpleCursorClient {
 
     this.log.debug('Executing prompt stream', { promptLength: prompt.length, mode, model });
 
-    const child = spawn(this.config.cursorAgentPath, args, {
+    const child = spawn(formatShellCommandForPlatform(this.config.cursorAgentPath), args, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
       shell: process.platform === 'win32',
@@ -189,7 +189,7 @@ export class SimpleCursorClient {
     this.log.debug('Executing prompt', { promptLength: prompt.length, mode, model });
 
     return new Promise((resolve, reject) => {
-      const child = spawn(this.config.cursorAgentPath, args, {
+      const child = spawn(formatShellCommandForPlatform(this.config.cursorAgentPath), args, {
         cwd,
         stdio: ['pipe', 'pipe', 'pipe'],
         shell: process.platform === 'win32',

package/src/mcp/tool-bridge.ts

@@ -4,6 +4,8 @@ import type { McpClientManager } from "./client-manager.js";
 
 const log = createLogger("mcp:tool-bridge");
 
+export const MCP_TOOL_PREFIX = "mcp__";
+
 interface DiscoveredMcpTool {
   name: string;
   serverName: string;
@@ -76,10 +78,10 @@ export function buildMcpToolDefinitions(tools: DiscoveredMcpTool[]): any[] {
   return defs;
 }
 
-function namespaceMcpTool(serverName: string, toolName: string): string {
+export function namespaceMcpTool(serverName: string, toolName: string): string {
   const sanitizedServer = serverName.replace(/[^a-zA-Z0-9]/g, "_");
   const sanitizedTool = toolName.replace(/[^a-zA-Z0-9]/g, "_");
-  return `mcp__${sanitizedServer}__${sanitizedTool}`;
+  return `${MCP_TOOL_PREFIX}${sanitizedServer}__${sanitizedTool}`;
 }
 
 function mcpSchemaToZod(inputSchema: Record<string, unknown> | undefined, z: any): any {

package/src/plugin.ts

@@ -1,13 +1,14 @@
 import type { Plugin, PluginInput } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin";
 import type { Auth } from "@opencode-ai/sdk";
-import { appendFileSync, existsSync, mkdirSync, realpathSync } from "fs";
+import { realpathSync } from "fs";
 import { mkdir } from "fs/promises";
 import { homedir } from "os";
 import { isAbsolute, join, relative, resolve } from "path";
 import { ToolMapper, type ToolUpdate } from "./acp/tools.js";
 import { startCursorOAuth } from "./auth";
 import { LineBuffer } from "./streaming/line-buffer.js";
+import { MixedDeltaTracker } from "./streaming/delta-tracker.js";
 import { StreamToSseConverter, formatSseDone } from "./streaming/openai-sse.js";
 import { parseStreamJsonLine } from "./streaming/parser.js";
 import { extractText, extractThinking, isAssistantText, isResult, isThinking } from "./streaming/types.js";
@@ -32,7 +33,12 @@ import { SkillResolver } from "./tools/skills/resolver.js";
 import { autoRefreshModels } from "./models/sync.js";
 import { readMcpConfigs, readSubagentNames } from "./mcp/config.js";
 import { McpClientManager } from "./mcp/client-manager.js";
-import { buildMcpToolHookEntries, buildMcpToolDefinitions } from "./mcp/tool-bridge.js";
+import {
+  MCP_TOOL_PREFIX,
+  buildMcpToolHookEntries,
+  buildMcpToolDefinitions,
+  namespaceMcpTool,
+} from "./mcp/tool-bridge.js";
 import { createOpencodeClient } from "@opencode-ai/sdk";
 import { ToolRegistry as CoreRegistry } from "./tools/core/registry.js";
 import { LocalExecutor } from "./tools/executors/local.js";
@@ -57,42 +63,23 @@ import {
   parseToolLoopMaxRepeat,
   type ToolLoopGuard,
 } from "./provider/tool-loop-guard.js";
-import { resolveCursorAgentBinary } from "./utils/binary.js";
+import { formatShellCommandForPlatform, resolveCursorAgentBinary } from "./utils/binary.js";
 
 const log = createLogger("plugin");
 
-// Debug log file for tool-loop investigation
-const DEBUG_LOG_DIR = join(homedir(), ".config", "opencode", "logs");
-const DEBUG_LOG_FILE = join(DEBUG_LOG_DIR, "tool-loop-debug.log");
-
-function ensureDebugLogDir(): void {
-  try {
-    if (!existsSync(DEBUG_LOG_DIR)) {
-      mkdir(DEBUG_LOG_DIR, { recursive: true }).catch(() => {});
-    }
-  } catch {
-    // Ignore errors creating log directory
-  }
-}
-
-function debugLogToFile(message: string, data: any): void {
-  try {
-    ensureDebugLogDir();
-    const timestamp = new Date().toISOString();
-    const logLine = `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}\n`;
-    appendFileSync(DEBUG_LOG_FILE, logLine);
-  } catch {
-    // Ignore errors
-  }
-}
-
 interface McpToolSummary {
   serverName: string;
   toolName: string;
+  callName?: string;
   description?: string;
   params?: string[];
 }
 
+function getMcpToolDefinitionName(mcpToolDefs: any[], index: number): string | undefined {
+  const name = mcpToolDefs[index]?.function?.name;
+  return typeof name === "string" && name.length > 0 ? name : undefined;
+}
+
 export function buildAvailableToolsSystemMessage(
   lastToolNames: string[],
   lastToolMap: Array<{ id: string; name: string }>,
@@ -109,16 +96,23 @@ export function buildAvailableToolsSystemMessage(
   }
 
   if (mcpToolSummaries && mcpToolSummaries.length > 0) {
-    const servers = new Map<string, McpToolSummary[]>();
-    for (const s of mcpToolSummaries) {
+    const summariesWithCallNames = mcpToolSummaries.map((summary, index) => ({
+      ...summary,
+      callName: summary.callName
+        ?? getMcpToolDefinitionName(mcpToolDefs, index)
+        ?? namespaceMcpTool(summary.serverName, summary.toolName),
+    }));
+
+    const servers = new Map<string, Array<McpToolSummary & { callName: string }>>();
+    for (const s of summariesWithCallNames) {
       const list = servers.get(s.serverName) ?? [];
       list.push(s);
       servers.set(s.serverName, list);
     }
 
     const lines: string[] = [
-      "MCP TOOLS — Use via Shell with the `mcptool` CLI.",
-      "Syntax: mcptool call <server> <tool> [json-args]",
+      `MCP TOOLS — Use via direct tool calls (\`${MCP_TOOL_PREFIX}<server>__<tool>\`).`,
+      "These tools are exposed as first-class tool calls (e.g. mcp__filesystem__read_file).",
       "",
     ];
 
@@ -126,12 +120,8 @@ export function buildAvailableToolsSystemMessage(
       lines.push(`Server: ${server}`);
       for (const t of tools) {
         const paramHint = t.params?.length ? ` (params: ${t.params.join(", ")})` : "";
-        lines.push(`  - ${t.toolName}${paramHint}${t.description ? " — " + t.description : ""}`);
-      }
-      if (tools.length > 0) {
-        const ex = tools[0];
-        const exArgs = ex.params?.length ? ` '{"${ex.params[0]}":"..."}'` : "";
-        lines.push(`  Example: mcptool call ${server} ${ex.toolName}${exArgs}`);
+        const sourceHint = t.callName === t.toolName ? "" : ` (server: ${t.serverName}; tool: ${t.toolName})`;
+        lines.push(`  - ${t.callName}${paramHint}${t.description ? " — " + t.description : ""}${sourceHint}`);
       }
       lines.push("");
     }
@@ -444,6 +434,7 @@ export function extractCompletionFromStream(output: string): {
   let usage: OpenAiUsage | undefined;
   let sawAssistantPartials = false;
   let sawThinkingPartials = false;
+  const tracker = new MixedDeltaTracker();
 
   for (const line of lines) {
     const event = parseStreamJsonLine(line);
@@ -457,8 +448,8 @@ export function extractCompletionFromStream(output: string): {
 
       const isPartial = typeof (event as any).timestamp_ms === "number";
       if (isPartial) {
-        assistantText += text;
         sawAssistantPartials = true;
+        assistantText += tracker.nextText(text);
       } else if (!sawAssistantPartials) {
         assistantText = text;
       }
@@ -469,8 +460,8 @@ export function extractCompletionFromStream(output: string): {
       if (thinking) {
         const isPartial = typeof (event as any).timestamp_ms === "number";
         if (isPartial) {
-          reasoningText += thinking;
           sawThinkingPartials = true;
+          reasoningText += tracker.nextThinking(thinking);
         } else if (!sawThinkingPartials) {
           reasoningText = thinking;
         }
@@ -705,8 +696,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
       const stream = body?.stream === true;
       const tools = Array.isArray(body?.tools) ? body.tools : [];
 
-      // DEBUG: Log raw request structure for tool-loop investigation
-      debugLogToFile("raw_request_body", {
+      log.debug("raw request body", {
         model: body?.model,
         cursorModel: body?.cursorModel,
         stream,
@@ -1238,7 +1228,7 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
         cmd.push("--force");
       }
 
-      const child = spawn(cmd[0], cmd.slice(1), {
+      const child = spawn(formatShellCommandForPlatform(cmd[0]), cmd.slice(1), {
         stdio: ["pipe", "pipe", "pipe"],
         shell: process.platform === "win32",
       });
@@ -1415,19 +1405,17 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
           }
         };
 
-        child.stdout.on("data", async (chunk) => {
-          if (streamTerminated || res.writableEnded) {
-            return;
-          }
-          if (!firstTokenReceived) { perf.mark("first-token"); firstTokenReceived = true; }
-          for (const line of lineBuffer.push(chunk)) {
-            if (streamTerminated || res.writableEnded) {
-              break;
-            }
+        const chunkQueue: Buffer[] = [];
+        let draining = false;
+        let childClosed = false;
+        let childCloseHandled = false;
+        let childExitCode: number | null = null;
+
+        const processLines = async (lines: string[]) => {
+          for (const line of lines) {
+            if (streamTerminated || res.writableEnded) break;
             const event = parseStreamJsonLine(line);
-            if (!event) {
-              continue;
-            }
+            if (!event) continue;
 
             if (isResult(event)) {
               usage = extractOpenAiUsageFromResult(event) ?? usage;
@@ -1469,156 +1457,104 @@ async function ensureCursorProxyServer(workspaceDirectory: string, toolRouter?:
                 if (!result.terminate.silent) {
                   emitTerminalAssistantErrorAndTerminate(result.terminate.message);
                 } else {
-                  // Silent termination: just end the stream without an error message
                   streamTerminated = true;
                   try { child.kill(); } catch { /* ignore */ }
                 }
                 break;
               }
-              if (result.intercepted) {
-                break;
-              }
-              if (result.skipConverter) {
-                continue;
-              }
+              if (result.intercepted) break;
+              if (result.skipConverter) continue;
             }
 
-            if (streamTerminated || res.writableEnded) {
-              break;
-            }
+            if (streamTerminated || res.writableEnded) break;
             for (const sse of converter.handleEvent(event)) {
               res.write(sse);
             }
           }
-        });
-
-        child.on("close", async (code) => {
-          if (streamTerminated || res.writableEnded) {
-            return;
-          }
-          for (const line of lineBuffer.flush()) {
-            if (streamTerminated || res.writableEnded) {
-              break;
-            }
-            const event = parseStreamJsonLine(line);
-            if (!event) {
-              continue;
-            }
+        };
 
-            if (isResult(event)) {
-              usage = extractOpenAiUsageFromResult(event) ?? usage;
+        const drainQueue = async () => {
+          if (draining) return;
+          draining = true;
+          try {
+            while (chunkQueue.length > 0) {
+              if (streamTerminated || res.writableEnded) break;
+              const chunk = chunkQueue.shift()!;
+              if (!firstTokenReceived) { perf.mark("first-token"); firstTokenReceived = true; }
+              await processLines(lineBuffer.push(chunk));
             }
 
-            if (event.type === "tool_call") {
-              const result = await handleToolLoopEventWithFallback({
-                event: event as any,
-                boundary: boundaryContext.getBoundary(),
-                boundaryMode: boundaryContext.getBoundary().mode,
-                autoFallbackToLegacy: ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK,
-                toolLoopMode: TOOL_LOOP_MODE,
-                allowedToolNames,
-                toolSchemaMap,
-                toolLoopGuard,
-                toolMapper,
-                toolSessionId,
-                shouldEmitToolUpdates: SHOULD_EMIT_TOOL_UPDATES,
-                proxyExecuteToolCalls: PROXY_EXECUTE_TOOL_CALLS,
-                suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
-                toolRouter,
-                responseMeta: { id, created, model },
-                passThroughTracker,
-                onToolUpdate: (update) => {
-                  res.write(formatToolUpdateEvent(update));
-                },
-                onToolResult: (toolResult) => {
-                  res.write(`data: ${JSON.stringify(toolResult)}\n\n`);
-                },
-                onInterceptedToolCall: (toolCall) => {
-                  emitToolCallAndTerminate(toolCall);
-                },
-                onFallbackToLegacy: (error) => {
-                  boundaryContext.activateLegacyFallback("handleToolLoopEvent.close", error);
-                },
+            if (childClosed && !childCloseHandled && !streamTerminated && !res.writableEnded) {
+              childCloseHandled = true;
+              await processLines(lineBuffer.flush());
+              if (streamTerminated || res.writableEnded) return;
+
+              perf.mark("request:done");
+              perf.summarize();
+              const stderrText = Buffer.concat(stderrChunks).toString().trim();
+              log.debug("cursor-agent completed (node stream)", {
+                code: childExitCode,
+                stderrChars: stderrText.length,
               });
-              if (result.terminate) {
-                if (!result.terminate.silent) {
-                  emitTerminalAssistantErrorAndTerminate(result.terminate.message);
-                } else {
-                  // Silent termination: just end the stream without an error message
-                  streamTerminated = true;
-                  try { child.kill(); } catch { /* ignore */ }
-                }
-                break;
+              if (childExitCode !== 0) {
+                const errSource =
+                  stderrText
+                  || `cursor-agent exited with code ${String(childExitCode ?? "unknown")} and no output`;
+                const parsed = parseAgentError(errSource);
+                const msg = formatErrorForUser(parsed);
+                const errChunk = createChatCompletionChunk(id, created, model, msg, true);
+                res.write(`data: ${JSON.stringify(errChunk)}\n\n`);
+                res.write(formatSseDone());
+                streamTerminated = true;
+                res.end();
+                return;
               }
-              if (result.intercepted) {
-                break;
+
+              const passThroughSummary = passThroughTracker.getSummary();
+              if (passThroughSummary.hasActivity) {
+                await toastService.showPassThroughSummary(passThroughSummary.tools);
               }
-              if (result.skipConverter) {
-                continue;
+              if (passThroughSummary.errors.length > 0) {
+                await toastService.showErrorSummary(passThroughSummary.errors);
               }
-            }
 
-            if (streamTerminated || res.writableEnded) {
-              break;
+              const doneChunk = {
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+              };
+              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());
+              streamTerminated = true;
+              res.end();
             }
-            for (const sse of converter.handleEvent(event)) {
-              res.write(sse);
+          } finally {
+            draining = false;
+            if (
+              !streamTerminated
+              && !res.writableEnded
+              && (chunkQueue.length > 0 || (childClosed && !childCloseHandled))
+            ) {
+              drainQueue();
             }
           }
-          if (streamTerminated || res.writableEnded) {
-            return;
-          }
-
-          perf.mark("request:done");
-          perf.summarize();
-          const stderrText = Buffer.concat(stderrChunks).toString().trim();
-          log.debug("cursor-agent completed (node stream)", {
-            code,
-            stderrChars: stderrText.length,
-          });
-          if (code !== 0) {
-            const errSource =
-              stderrText
-              || `cursor-agent exited with code ${String(code ?? "unknown")} and no output`;
-            const parsed = parseAgentError(errSource);
-            const msg = formatErrorForUser(parsed);
-            const errChunk = createChatCompletionChunk(id, created, model, msg, true);
-            res.write(`data: ${JSON.stringify(errChunk)}\n\n`);
-            res.write(formatSseDone());
-            streamTerminated = true;
-            res.end();
-            return;
-          }
+        };
 
-          // Emit toast for passed-through MCP tools
-          const passThroughSummary = passThroughTracker.getSummary();
-          if (passThroughSummary.hasActivity) {
-            await toastService.showPassThroughSummary(passThroughSummary.tools);
-          }
-          if (passThroughSummary.errors.length > 0) {
-            await toastService.showErrorSummary(passThroughSummary.errors);
-          }
+        child.stdout.on("data", (chunk) => {
+          chunkQueue.push(Buffer.from(chunk));
+          drainQueue();
+        });
 
-          const doneChunk = {
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [
-              {
-                index: 0,
-                delta: {},
-                finish_reason: "stop",
-              },
-            ],
-          };
-          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();
+        child.on("close", (code) => {
+          childClosed = true;
+          childExitCode = code;
+          drainQueue();
         });
       }
     } catch (error) {
@@ -1955,6 +1891,7 @@ export const CursorPlugin: Plugin = async ({ $, directory, worktree, client, ser
           mcpToolSummaries = tools.map((t) => ({
             serverName: t.serverName,
             toolName: t.name,
+            callName: namespaceMcpTool(t.serverName, t.name),
             description: t.description,
             params: t.inputSchema
               ? Object.keys((t.inputSchema as any).properties ?? {})

package/src/provider/runtime-interception.ts

@@ -3,7 +3,11 @@ import { extractOpenAiToolCall, type OpenAiToolCall, type ToolCallExtractionResu
 import type { StreamJsonToolCallEvent } from "../streaming/types.js";
 import type { ToolRouter } from "../tools/router.js";
 import { createLogger } from "../utils/logger.js";
-import { applyToolSchemaCompat, type ToolSchemaValidationResult } from "./tool-schema-compat.js";
+import {
+  applyToolSchemaCompat,
+  tryRerouteEditToWrite,
+  type ToolSchemaValidationResult,
+} from "./tool-schema-compat.js";
 import type { ToolLoopGuard } from "./tool-loop-guard.js";
 import type { ProviderBoundaryMode, ToolLoopMode } from "./boundary.js";
 import type { ProviderBoundary } from "./boundary.js";
@@ -190,6 +194,20 @@ export async function handleToolLoopEventLegacy(
         return { intercepted: false, skipConverter: true, terminate: validationTermination };
       }
 
+      const reroutedWrite = tryRerouteEditToWrite(
+        normalizedToolCall,
+        compat,
+        allowedToolNames,
+        toolSchemaMap,
+      );
+      if (reroutedWrite) {
+        log.debug("Rerouting malformed edit call to write (legacy)", {
+          missing: compat.validation.missing,
+        });
+        await onInterceptedToolCall(reroutedWrite);
+        return { intercepted: true, skipConverter: true };
+      }
+
       if (shouldEmitNonFatalSchemaValidationHint(normalizedToolCall, compat.validation)) {
         const hintChunk = createNonFatalSchemaValidationHintChunk(
           responseMeta,
@@ -383,6 +401,23 @@ export async function handleToolLoopEventV1(
         terminate: createSchemaValidationTermination(normalizedToolCall, compat.validation),
       };
     }
+    const reroutedWrite = tryRerouteEditToWrite(
+      normalizedToolCall,
+      compat,
+      allowedToolNames,
+      toolSchemaMap,
+    );
+    if (reroutedWrite) {
+      log.debug("Rerouting malformed edit call to write", {
+        missing: compat.validation.missing,
+        typeErrors: compat.validation.typeErrors,
+      });
+      await onInterceptedToolCall(reroutedWrite);
+      return {
+        intercepted: true,
+        skipConverter: true,
+      };
+    }
     if (
       schemaValidationFailureMode === "pass_through"
       && shouldEmitNonFatalSchemaValidationHint(normalizedToolCall, compat.validation)
@@ -668,11 +703,11 @@ function createNonFatalSchemaValidationHintChunk(
   validation: ToolSchemaValidationResult,
 ): NonFatalSchemaValidationResultChunk {
   const termination = createSchemaValidationTermination(toolCall, validation);
-  const hint =
-    termination.repairHint
-    || "Use write for full-file replacement, or provide path, old_string, and new_string for edit.";
+  const fallbackHint =
+    "Use write for full-file replacement, or provide path, old_string, and new_string for edit.";
+  const suffix = termination.repairHint ? "" : ` ${fallbackHint}`;
   const content =
-    `Skipped malformed tool call "${toolCall.function.name}": ${termination.message} ${hint}`.trim();
+    `Skipped malformed tool call "${toolCall.function.name}": ${termination.message}${suffix}`.trim();
   return {
     id: meta.id,
     object: "chat.completion.chunk",