@rama_nigg/open-cursor 2.3.19 → 2.4.0

package/src/tools/defaults.ts

@@ -1,4 +1,5 @@
 import type { ToolRegistry } from "./core/registry.js";
+import { createLogger } from "../utils/logger.js";
 
 /**
  * Register default OpenCode tools in the registry
@@ -265,6 +266,10 @@ export function registerDefaultTools(registry: ToolRegistry): void {
     const path = args.path as string;
     const include = args.include as string | undefined;
 
+    if (process.platform === "win32") {
+      return nodeFallbackGrep(pattern, path, include);
+    }
+
     const grepArgs = ["-r", "-n"];
     if (include) {
       grepArgs.push(`--include=${include}`);
@@ -374,6 +379,11 @@ export function registerDefaultTools(registry: ToolRegistry): void {
     const path = resolvePathArg(args, "glob");
     const cwd = path || ".";
     const normalizedPattern = pattern.replace(/\\/g, "/");
+
+    if (process.platform === "win32") {
+      return nodeFallbackGlob(normalizedPattern, cwd);
+    }
+
     const isPathPattern = normalizedPattern.includes("/");
     const findArgs = [cwd, "-type", "f"];
     if (isPathPattern) {
@@ -703,3 +713,159 @@ function coerceToString(value: unknown): string | null {
 export function getDefaultToolNames(): string[] {
   return ["bash", "read", "write", "edit", "grep", "ls", "glob", "mkdir", "rm", "stat"];
 }
+
+const FALLBACK_SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build"]);
+const fallbackLog = createLogger("tools:fallback");
+
+export async function nodeFallbackGrep(
+  pattern: string,
+  searchPath: string,
+  include?: string,
+): Promise<string> {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+
+  let regex: RegExp;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    return "Invalid regex pattern";
+  }
+
+  let includeRegex: RegExp | undefined;
+  if (include) {
+    const incPattern = include.replace(/\./g, "\\.").replace(/\?/g, ".").replace(/\*/g, ".*");
+    includeRegex = new RegExp(`^${incPattern}$`);
+  }
+
+  const results: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    if (results.length >= 100) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch (err: any) {
+      if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+        fallbackLog.error("Unexpected error reading directory", { dir, code: err?.code, message: err?.message });
+      }
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= 100) return;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!FALLBACK_SKIP_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (includeRegex && !includeRegex.test(entry.name)) continue;
+        let content: string;
+        try {
+          content = await fs.readFile(fullPath, "utf-8");
+        } catch (err: any) {
+          if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+            fallbackLog.error("Unexpected error reading file", { path: fullPath, code: err?.code, message: err?.message });
+          }
+          continue;
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push(`${fullPath}:${i + 1}:${lines[i]}`);
+            if (results.length >= 100) break;
+          }
+        }
+      }
+    }
+  }
+
+  let stat;
+  try {
+    stat = await fs.stat(searchPath);
+  } catch {
+    return "Path not found";
+  }
+
+  if (stat.isFile()) {
+    let content: string;
+    try {
+      content = await fs.readFile(searchPath, "utf-8");
+    } catch (err: any) {
+      if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+        fallbackLog.error("Unexpected error reading file", { path: searchPath, code: err?.code, message: err?.message });
+      }
+      return "Path not found";
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        results.push(`${searchPath}:${i + 1}:${lines[i]}`);
+        if (results.length >= 100) break;
+      }
+    }
+  } else {
+    await walk(searchPath);
+  }
+
+  return results.join("\n") || "No matches found";
+}
+
+export async function nodeFallbackGlob(
+  pattern: string,
+  searchPath: string,
+): Promise<string> {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+
+  const results: string[] = [];
+  const isPathPattern = pattern.includes("/");
+
+  // Handle ** before * so double-star → .* and single-star → [^/]*
+  let regexPattern = pattern
+    .replace(/\./g, "\\.")
+    .replace(/\*\*/g, "\x00") // placeholder for **
+    .replace(/\*/g, "[^/]*")
+    .replace(/\x00/g, ".*"); // restore ** as .*
+
+  let regex: RegExp;
+  try {
+    regex = isPathPattern
+      ? new RegExp(`${regexPattern}$`)
+      : new RegExp(`^${regexPattern}$`);
+  } catch {
+    return "No files found";
+  }
+
+  async function walk(dir: string): Promise<void> {
+    if (results.length >= 50) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch (err: any) {
+      if (err?.code !== "ENOENT" && err?.code !== "EACCES") {
+        fallbackLog.error("Unexpected error reading directory", { dir, code: err?.code, message: err?.message });
+      }
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= 50) return;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!FALLBACK_SKIP_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        const matchTarget = isPathPattern
+          ? fullPath.replace(/\\/g, "/")
+          : entry.name;
+        if (regex.test(matchTarget)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  }
+
+  await walk(searchPath);
+  return results.join("\n") || "No files found";
+}

package/src/tools/executors/cli.ts

@@ -16,6 +16,7 @@ export class CliExecutor implements IToolExecutor {
       const { spawn } = await import("node:child_process");
       const child = spawn("opencode", ["tool", "run", toolId, "--json", JSON.stringify(args)], {
         stdio: ["ignore", "pipe", "pipe"],
+        shell: process.platform === "win32",
       });
 
       const stdoutChunks: Buffer[] = [];

package/src/usage.ts

@@ -0,0 +1,112 @@
+import type { StreamJsonResultEvent } from "./streaming/types.js";
+
+export type CursorUsageMetrics = {
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  cost?: number;
+};
+
+export type OpenAiUsage = {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  prompt_tokens_details: {
+    cached_tokens: number;
+    cache_write_tokens: number;
+  };
+  completion_tokens_details: {
+    reasoning_tokens: number;
+  };
+  cost?: number;
+};
+
+function readTokenCount(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return 0;
+  }
+  return Math.floor(value);
+}
+
+function readOptionalCost(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return undefined;
+  }
+  return value;
+}
+
+export function normalizeCursorUsage(value: unknown): CursorUsageMetrics | undefined {
+  if (!value || typeof value !== "object") {
+    return undefined;
+  }
+
+  const usage = value as Record<string, unknown>;
+  const metrics: CursorUsageMetrics = {
+    inputTokens: readTokenCount(usage.inputTokens ?? usage.input_tokens ?? usage.prompt_tokens),
+    outputTokens: readTokenCount(usage.outputTokens ?? usage.output_tokens ?? usage.completion_tokens),
+    reasoningTokens: readTokenCount(usage.reasoningTokens ?? usage.reasoning_tokens),
+    cacheReadTokens: readTokenCount(usage.cacheReadTokens ?? usage.cache_read_tokens),
+    cacheWriteTokens: readTokenCount(usage.cacheWriteTokens ?? usage.cache_write_tokens),
+  };
+
+  const cost = readOptionalCost(usage.cost ?? usage.totalCost ?? usage.total_cost);
+  if (cost !== undefined) {
+    metrics.cost = cost;
+  }
+
+  const hasUsage =
+    metrics.inputTokens > 0
+    || metrics.outputTokens > 0
+    || metrics.reasoningTokens > 0
+    || metrics.cacheReadTokens > 0
+    || metrics.cacheWriteTokens > 0
+    || cost !== undefined;
+
+  return hasUsage ? metrics : undefined;
+}
+
+export function createOpenAiUsage(metrics: CursorUsageMetrics): OpenAiUsage {
+  const promptTokens = metrics.inputTokens + metrics.cacheReadTokens + metrics.cacheWriteTokens;
+  const totalTokens = promptTokens + metrics.outputTokens + metrics.reasoningTokens;
+  const usage: OpenAiUsage = {
+    prompt_tokens: promptTokens,
+    completion_tokens: metrics.outputTokens,
+    total_tokens: totalTokens,
+    prompt_tokens_details: {
+      cached_tokens: metrics.cacheReadTokens,
+      cache_write_tokens: metrics.cacheWriteTokens,
+    },
+    completion_tokens_details: {
+      reasoning_tokens: metrics.reasoningTokens,
+    },
+  };
+
+  if (metrics.cost !== undefined) {
+    usage.cost = metrics.cost;
+  }
+
+  return usage;
+}
+
+export function extractOpenAiUsageFromResult(event: StreamJsonResultEvent): OpenAiUsage | undefined {
+  const metrics = normalizeCursorUsage(event.usage);
+  return metrics ? createOpenAiUsage(metrics) : undefined;
+}
+
+export function createChatCompletionUsageChunk(
+  id: string,
+  created: number,
+  model: string,
+  usage: OpenAiUsage,
+) {
+  return {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [],
+    usage,
+  };
+}

package/src/utils/binary.ts

@@ -0,0 +1,57 @@
+// src/utils/binary.ts
+//
+// 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.
+import { existsSync as fsExistsSync } from "fs";
+import * as pathModule from "path";
+import { homedir as osHomedir } from "os";
+import { createLogger } from "./logger.js";
+
+const log = createLogger("binary");
+
+export type BinaryDeps = {
+  platform?: NodeJS.Platform;
+  env?: Record<string, string | undefined>;
+  existsSync?: (path: string) => boolean;
+  homedir?: () => string;
+};
+
+export function resolveCursorAgentBinary(deps: BinaryDeps = {}): string {
+  const platform = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const checkExists = deps.existsSync ?? fsExistsSync;
+  const home = (deps.homedir ?? osHomedir)();
+
+  const envOverride = env.CURSOR_AGENT_EXECUTABLE;
+  if (envOverride && envOverride.length > 0) {
+    return envOverride;
+  }
+
+  if (platform === "win32") {
+    const pathJoin = pathModule.win32.join;
+    const localAppData = env.LOCALAPPDATA ?? pathJoin(home, "AppData", "Local");
+    const knownPath = pathJoin(localAppData, "cursor-agent", "cursor-agent.cmd");
+    if (checkExists(knownPath)) {
+      return knownPath;
+    }
+    log.warn("cursor-agent not found at known Windows path, falling back to PATH", { checkedPath: knownPath });
+    return "cursor-agent.cmd";
+  }
+
+  const knownPaths = [
+    pathModule.join(home, ".cursor-agent", "cursor-agent"),
+    "/usr/local/bin/cursor-agent",
+  ];
+  for (const p of knownPaths) {
+    if (checkExists(p)) {
+      return p;
+    }
+  }
+
+  log.warn("cursor-agent not found at known paths, falling back to PATH", { checkedPaths: knownPaths });
+  return "cursor-agent";
+}