@rama_nigg/open-cursor 2.4.3 → 2.4.5

package/src/plugin.ts

@@ -8,6 +8,7 @@ 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";
@@ -57,7 +58,7 @@ 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");
 
@@ -444,6 +445,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 +459,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 +471,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;
         }
@@ -1238,7 +1240,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 +1417,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 +1469,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) {
@@ -1843,11 +1791,15 @@ function applyToolContextDefaults(
 /**
  * Build tool hook entries from local registry
  */
+const NATIVE_TOOL_HOOK_EXCLUSIONS = new Set(["grep"]);
+
 function buildToolHookEntries(registry: CoreRegistry, fallbackBaseDir?: string): Record<string, any> {
   const entries: Record<string, any> = {};
   const sessionWorkspaceBySession = new Map<string, string>();
   const tools = registry.list();
   for (const t of tools) {
+    if (NATIVE_TOOL_HOOK_EXCLUSIONS.has(t.name)) continue;
+
     const handler = registry.getHandler(t.name);
     if (!handler) continue;
 

package/src/streaming/ai-sdk-parts.ts

@@ -8,7 +8,7 @@ import {
   type StreamJsonEvent,
   type StreamJsonToolCallEvent,
 } from "./types.js";
-import { DeltaTracker } from "./delta-tracker.js";
+import { MixedDeltaTracker } from "./delta-tracker.js";
 
 export type AiSdkStreamPart =
   | {
@@ -34,44 +34,22 @@ export type AiSdkStreamPart =
     };
 
 export class StreamToAiSdkParts {
-  private readonly tracker = new DeltaTracker();
   private readonly toolArgsById = new Map<string, string>();
   private readonly startedToolIds = new Set<string>();
-  private sawAssistantPartials = false;
-  private sawThinkingPartials = false;
+  private readonly tracker = new MixedDeltaTracker();
 
   handleEvent(event: StreamJsonEvent): AiSdkStreamPart[] {
     if (isAssistantText(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractText(event);
-        if (text) {
-          this.sawAssistantPartials = true;
-          return [{ type: "text-delta", textDelta: text }];
-        }
-        return [];
-      }
-      if (this.sawAssistantPartials) {
-        return [];
-      }
-      const delta = this.tracker.nextText(extractText(event));
+      const text = extractText(event);
+      if (!text) return [];
+      const delta = this.tracker.nextText(text);
       return delta ? [{ type: "text-delta", textDelta: delta }] : [];
     }
 
     if (isThinking(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractThinking(event);
-        if (text) {
-          this.sawThinkingPartials = true;
-          return [{ type: "text-delta", textDelta: text }];
-        }
-        return [];
-      }
-      if (this.sawThinkingPartials) {
-        return [];
-      }
-      const delta = this.tracker.nextThinking(extractThinking(event));
+      const text = extractThinking(event);
+      if (!text) return [];
+      const delta = this.tracker.nextThinking(text);
       return delta ? [{ type: "text-delta", textDelta: delta }] : [];
     }
 

package/src/streaming/delta-tracker.ts

@@ -45,3 +45,45 @@ export class DeltaTracker {
     return current.slice(i);
   }
 }
+
+export class MixedDeltaTracker {
+  private emittedText = "";
+  private emittedThinking = "";
+
+  nextText(value: string): string {
+    const delta = this.diff(this.emittedText, value);
+    if (delta) {
+      this.emittedText += delta;
+    }
+    return delta;
+  }
+
+  nextThinking(value: string): string {
+    const delta = this.diff(this.emittedThinking, value);
+    if (delta) {
+      this.emittedThinking += delta;
+    }
+    return delta;
+  }
+
+  reset(): void {
+    this.emittedText = "";
+    this.emittedThinking = "";
+  }
+
+  private diff(emitted: string, current: string): string {
+    if (!emitted) {
+      return current;
+    }
+
+    if (current.startsWith(emitted)) {
+      return current.slice(emitted.length);
+    }
+
+    if (emitted.startsWith(current)) {
+      return "";
+    }
+
+    return current;
+  }
+}

package/src/streaming/openai-sse.ts

@@ -8,7 +8,7 @@ import {
   type StreamJsonEvent,
   type StreamJsonToolCallEvent,
 } from "./types.js";
-import { DeltaTracker } from "./delta-tracker.js";
+import { MixedDeltaTracker } from "./delta-tracker.js";
 
 type OpenAiToolCall = {
   index: number;
@@ -60,12 +60,7 @@ export class StreamToSseConverter {
   private readonly id: string;
   private readonly created: number;
   private readonly model: string;
-  private readonly tracker = new DeltaTracker();
-  // Events with timestamp_ms carry delta text; events without carry accumulated text.
-  // DeltaTracker handles accumulated text only. When partials (delta) were seen,
-  // the final accumulated event must be skipped to prevent 2x duplication.
-  private sawAssistantPartials = false;
-  private sawThinkingPartials = false;
+  private readonly tracker = new MixedDeltaTracker();
 
   constructor(model: string, options?: { id?: string; created?: number }) {
     this.model = model;
@@ -75,36 +70,16 @@ export class StreamToSseConverter {
 
   handleEvent(event: StreamJsonEvent): string[] {
     if (isAssistantText(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractText(event);
-        if (text) {
-          this.sawAssistantPartials = true;
-          return [this.chunkWith({ content: text })];
-        }
-        return [];
-      }
-      if (this.sawAssistantPartials) {
-        return [];
-      }
-      const delta = this.tracker.nextText(extractText(event));
+      const text = extractText(event);
+      if (!text) return [];
+      const delta = this.tracker.nextText(text);
       return delta ? [this.chunkWith({ content: delta })] : [];
     }
 
     if (isThinking(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractThinking(event);
-        if (text) {
-          this.sawThinkingPartials = true;
-          return [this.chunkWith({ reasoning_content: text })];
-        }
-        return [];
-      }
-      if (this.sawThinkingPartials) {
-        return [];
-      }
-      const delta = this.tracker.nextThinking(extractThinking(event));
+      const text = extractThinking(event);
+      if (!text) return [];
+      const delta = this.tracker.nextThinking(text);
       return delta ? [this.chunkWith({ reasoning_content: delta })] : [];
     }
 

package/src/tools/defaults.ts

@@ -274,7 +274,7 @@ export function registerDefaultTools(registry: ToolRegistry): void {
     if (include) {
       grepArgs.push(`--include=${include}`);
     }
-    grepArgs.push(pattern, path);
+    grepArgs.push("-e", pattern, path);
 
     const runGrep = async (extraArgs: string[] = []) => {
       return execFileAsync("grep", [...extraArgs, ...grepArgs], { timeout: 30000 });

package/src/utils/binary.ts

@@ -3,9 +3,10 @@
 // Resolves the cursor-agent executable path. On Windows the binary is a `.cmd`
 // shim, which Node's spawn cannot execute directly without `shell: true` —
 // callers therefore pair this resolver with `shell: process.platform === "win32"`
-// at every spawn site. That re-enables shell metacharacter interpretation, so
-// any user-controlled string passed as an argument on Windows must be treated
-// as untrusted; never concatenate user input into argv on win32.
+// and `formatShellCommandForPlatform()` at every Node spawn site. That re-enables
+// shell metacharacter interpretation, so any user-controlled string passed as an
+// argument on Windows must be treated as untrusted; never concatenate user input
+// into argv on win32.
 import { existsSync as fsExistsSync } from "fs";
 import * as pathModule from "path";
 import { homedir as osHomedir } from "os";
@@ -55,3 +56,16 @@ export function resolveCursorAgentBinary(deps: BinaryDeps = {}): string {
   log.warn("cursor-agent not found at known paths, falling back to PATH", { checkedPaths: knownPaths });
   return "cursor-agent";
 }
+
+export function formatShellCommandForPlatform(
+  command: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (platform !== "win32") {
+    return command;
+  }
+  if (command.startsWith("\"") && command.endsWith("\"")) {
+    return command;
+  }
+  return `"${command}"`;
+}