@rama_nigg/open-cursor 2.3.20 → 2.4.0

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";
+}