@evanovation/open-cursor 2.4.15

package/src/acp/tools.ts

@@ -0,0 +1,209 @@
+export interface ToolUpdate {
+  sessionId: string;
+  toolCallId: string;
+  title?: string;
+  kind?: 'read' | 'write' | 'edit' | 'search' | 'execute' | 'other';
+  status?: 'pending' | 'in_progress' | 'completed' | 'failed';
+  locations?: Array<{ path: string; line?: number }>;
+  content?: Array<{ type: string; [key: string]: unknown }>;
+  rawOutput?: string;
+  startTime?: number;
+  endTime?: number;
+}
+
+interface CursorEvent {
+  type: string;
+  call_id?: string;
+  tool_call_id?: string;
+  subtype?: string;
+  tool_call?: {
+    [key: string]: {
+      args?: Record<string, unknown>;
+      result?: Record<string, unknown>;
+    };
+  };
+}
+
+export class ToolMapper {
+  async mapCursorEventToAcp(event: CursorEvent, sessionId: string): Promise<ToolUpdate[]> {
+    if (event.type !== 'tool_call') {
+      return [];
+    }
+
+    const updates: ToolUpdate[] = [];
+    const toolCallId = event.call_id || event.tool_call_id || 'unknown';
+    const subtype = event.subtype || 'started';
+
+    // Completed/failed events return 1 update with results
+    if (subtype === 'completed' || subtype === 'failed') {
+      const result = this.extractResult(event.tool_call || {});
+      const locations = result.locations?.length ? result.locations : this.extractLocations(event.tool_call || {});
+
+      updates.push({
+        sessionId,
+        toolCallId,
+        title: this.buildToolTitle(event.tool_call || {}),
+        kind: this.inferToolType(event.tool_call || {}),
+        status: result.error ? 'failed' : 'completed',
+        content: result.content,
+        locations,
+        rawOutput: result.rawOutput,
+        endTime: Date.now()
+      });
+    } else {
+      // Started events return 2 updates: pending and in_progress
+      updates.push({
+        sessionId,
+        toolCallId,
+        title: this.buildToolTitle(event.tool_call || {}),
+        kind: this.inferToolType(event.tool_call || {}),
+        status: 'pending',
+        locations: this.extractLocations(event.tool_call || {}),
+        startTime: Date.now()
+      });
+
+      updates.push({
+        sessionId,
+        toolCallId,
+        status: 'in_progress'
+      });
+    }
+
+    return updates;
+  }
+
+  private inferToolType(toolCall: Record<string, unknown>): ToolUpdate['kind'] {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      if (key.includes('read')) return 'read';
+      if (key.includes('write')) return 'edit';
+      if (key.includes('grep') || key.includes('glob')) return 'search';
+      if (key.includes('bash') || key.includes('shell')) return 'execute';
+    }
+    return 'other';
+  }
+
+  private buildToolTitle(toolCall: Record<string, unknown>): string {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      const tool = toolCall[key] as { args?: Record<string, unknown> } | undefined;
+      const args = tool?.args || {};
+
+      if (key.includes('read') && args.path) return `Read ${args.path}`;
+      if (key.includes('write') && args.path) return `Write ${args.path}`;
+      if (key.includes('grep')) {
+        const pattern = args.pattern || 'pattern';
+        const path = args.path;
+        return path ? `Search ${path} for ${pattern}` : `Search for ${pattern}`;
+      }
+      if (key.includes('glob') && args.pattern) return `Glob ${args.pattern}`;
+      if ((key.includes('bash') || key.includes('shell')) && (args.command || args.cmd)) {
+        return `\`${args.command || args.cmd}\``;
+      }
+      if ((key.includes('bash') || key.includes('shell')) && args.commands && Array.isArray(args.commands)) {
+        return `\`${args.commands.join(' && ')}\``;
+      }
+    }
+    return 'other';
+  }
+
+  private extractLocations(toolCall: Record<string, unknown>): ToolUpdate['locations'] {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      const tool = toolCall[key] as { args?: Record<string, unknown> } | undefined;
+      const args = tool?.args || {};
+
+      if (args.path) {
+        if (typeof args.path === 'string') {
+          return [{ path: args.path, line: args.line as number | undefined }];
+        }
+        if (Array.isArray(args.path)) {
+          return args.path.map((p: string | { path: string; line?: number }) =>
+            typeof p === 'string' ? { path: p } : { path: p.path, line: p.line }
+          );
+        }
+      }
+
+      if (args.paths && Array.isArray(args.paths)) {
+        return args.paths.map((p: string | { path: string; line?: number }) =>
+          typeof p === 'string' ? { path: p } : { path: p.path, line: p.line }
+        );
+      }
+    }
+    return undefined;
+  }
+
+  private extractResult(toolCall: Record<string, unknown>): {
+    error?: string;
+    content?: ToolUpdate['content'];
+    locations?: ToolUpdate['locations'];
+    rawOutput?: string;
+  } {
+    const keys = Object.keys(toolCall);
+    for (const key of keys) {
+      const tool = toolCall[key] as {
+        result?: Record<string, unknown>;
+        args?: Record<string, unknown>;
+      } | undefined;
+      const result = tool?.result || {};
+
+      if (result.error) {
+        return { error: result.error as string };
+      }
+
+      const locations: ToolUpdate['locations'] = [];
+      if (result.matches && Array.isArray(result.matches)) {
+        locations.push(...result.matches.map((m: { path: string; line?: number }) => ({
+          path: m.path,
+          line: m.line
+        })));
+      }
+      if (result.files && Array.isArray(result.files)) {
+        locations.push(...result.files.map((f: string) => ({ path: f })));
+      }
+      if (result.path) {
+        locations.push({ path: result.path as string, line: result.line as number | undefined });
+      }
+
+      const content: ToolUpdate['content'] = [];
+
+      // Handle write operations with diff generation
+      if (key.includes('write')) {
+        const oldText = result.oldText ?? null;
+        const newText = result.newText as string | undefined;
+        const path = (tool?.args?.path as string) || (result.path as string);
+        if (newText !== undefined || oldText !== undefined) {
+          content.push({
+            type: 'diff',
+            path,
+            oldText,
+            newText
+          });
+        }
+      }
+
+      if (result.content) {
+        content.push({
+          type: 'content',
+          content: { text: result.content as string }
+        });
+      }
+
+      if (result.output !== undefined || result.exitCode !== undefined) {
+        content.push({
+          type: 'content',
+          content: {
+            text: `Exit code: ${result.exitCode ?? 0}\n${result.output || '(no output)'}`
+          }
+        });
+      }
+
+      return {
+        content: content.length > 0 ? content : undefined,
+        locations: locations.length > 0 ? locations : undefined,
+        rawOutput: JSON.stringify(result)
+      };
+    }
+    return {};
+  }
+}

package/src/auth.ts

@@ -0,0 +1,175 @@
+// src/auth.ts
+
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { createLogger } from "./utils/logger";
+
+const log = createLogger("auth");
+
+// Polling configuration for auth file detection
+const AUTH_POLL_INTERVAL = 2000; // Check every 2 seconds
+const AUTH_POLL_TIMEOUT = 5 * 60 * 1000; // 5 minutes total timeout
+const URL_EXTRACTION_TIMEOUT = 10000; // Wait up to 10 seconds for URL
+
+export interface AuthResult {
+  type: "success" | "failed";
+  provider?: string;
+  key?: string;
+  error?: string;
+}
+
+export interface ResolveSdkApiKeyInput {
+  env?: Pick<NodeJS.ProcessEnv, "CURSOR_API_KEY">;
+  storedApiKey?: string;
+  authorizationHeader?: string | null;
+}
+
+const PLACEHOLDER_API_KEYS = new Set(["cursor-agent"]);
+
+function getHomeDir(): string {
+  const override = process.env.CURSOR_ACP_HOME_DIR;
+  if (override && override.length > 0) {
+    return override;
+  }
+  return homedir();
+}
+
+export async function pollForAuthFile(
+  timeoutMs: number = AUTH_POLL_TIMEOUT,
+  intervalMs: number = AUTH_POLL_INTERVAL
+): Promise<boolean> {
+  const startTime = Date.now();
+  const possiblePaths = getPossibleAuthPaths();
+
+  return new Promise((resolve) => {
+    const check = () => {
+      const elapsed = Date.now() - startTime;
+      
+      for (const authPath of possiblePaths) {
+        if (existsSync(authPath)) {
+          log.debug("Auth file detected", { path: authPath });
+          resolve(true);
+          return;
+        }
+      }
+
+      log.debug("Polling for auth file", {
+        checkedPaths: possiblePaths,
+        elapsed: `${elapsed}ms`,
+        timeout: `${timeoutMs}ms`,
+      });
+
+      if (elapsed >= timeoutMs) {
+        log.debug("Auth file polling timed out");
+        resolve(false);
+        return;
+      }
+
+      setTimeout(check, intervalMs);
+    };
+
+    check();
+  });
+}
+
+export function verifyCursorAuth(): boolean {
+  // API key takes priority over auth file
+  const apiKey = process.env.CURSOR_API_KEY;
+  if (apiKey && apiKey.trim().length > 0) {
+    log.debug("CURSOR_API_KEY found, auth verified");
+    return true;
+  }
+
+  const possiblePaths = getPossibleAuthPaths();
+  for (const authPath of possiblePaths) {
+    if (existsSync(authPath)) {
+      log.debug("Auth file found", { path: authPath });
+      return true;
+    }
+  }
+
+  log.debug("No auth found (no CURSOR_API_KEY, no auth file)", { checkedPaths: possiblePaths });
+  return false;
+}
+
+export function isUsableSdkApiKey(value: string | undefined | null): value is string {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return false;
+  }
+
+  return !PLACEHOLDER_API_KEYS.has(trimmed.toLowerCase());
+}
+
+export function normalizeAuthorizationHeader(value: string | null | undefined): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const bearerMatch = /^bearer\s+(.+)$/i.exec(trimmed);
+  return bearerMatch?.[1]?.trim() ?? trimmed;
+}
+
+export function resolveSdkApiKey(input: ResolveSdkApiKeyInput): string | undefined {
+  const candidates = [
+    input.env?.CURSOR_API_KEY,
+    input.storedApiKey,
+    normalizeAuthorizationHeader(input.authorizationHeader),
+  ];
+
+  return candidates.find(isUsableSdkApiKey)?.trim();
+}
+
+/**
+ * Returns all possible auth file paths in priority order.
+ * Checks both auth.json (legacy) and cli-config.json (current cursor-agent format).
+ * - macOS: ~/.cursor/ (primary), ~/.config/cursor/ (fallback)
+ * - Linux: ~/.config/cursor/ (XDG), XDG_CONFIG_HOME/cursor/, ~/.cursor/
+ */
+export function getPossibleAuthPaths(): string[] {
+  const home = getHomeDir();
+  const paths: string[] = [];
+  const isDarwin = platform() === "darwin";
+
+  const authFiles = ["cli-config.json", "auth.json"];
+
+  if (isDarwin) {
+    for (const file of authFiles) {
+      paths.push(join(home, ".cursor", file));
+    }
+    for (const file of authFiles) {
+      paths.push(join(home, ".config", "cursor", file));
+    }
+  } else {
+    for (const file of authFiles) {
+      paths.push(join(home, ".config", "cursor", file));
+    }
+
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    if (xdgConfig && xdgConfig !== join(home, ".config")) {
+      for (const file of authFiles) {
+        paths.push(join(xdgConfig, "cursor", file));
+      }
+    }
+
+    for (const file of authFiles) {
+      paths.push(join(home, ".cursor", file));
+    }
+  }
+
+  return paths;
+}
+
+export function getAuthFilePath(): string {
+  const possiblePaths = getPossibleAuthPaths();
+  
+  for (const authPath of possiblePaths) {
+    if (existsSync(authPath)) {
+      return authPath;
+    }
+  }
+  
+  return possiblePaths[0];
+}

package/src/cli/discover.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import {
+  discoverModelsFromCursorAgent,
+  fallbackModels,
+} from "./model-discovery.js";
+
+async function main() {
+  console.log("Discovering Cursor models...");
+  let models = fallbackModels();
+  try {
+    models = discoverModelsFromCursorAgent();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: cursor-agent model discovery failed, using fallback list (${message})`);
+  }
+
+  console.log(`Found ${models.length} models:`);
+  for (const model of models) {
+    console.log(`  - ${model.id}: ${model.name}`);
+  }
+
+  // Update config
+  const configPath = join(homedir(), ".config/opencode/opencode.json");
+
+  if (!existsSync(configPath)) {
+    console.error(`Config not found: ${configPath}`);
+    process.exit(1);
+  }
+
+  const existingConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+
+  // Update cursor-acp provider models
+  if (existingConfig.provider?.["cursor-acp"]) {
+    const formatted = Object.fromEntries(models.map((model) => [model.id, { name: model.name }]));
+    existingConfig.provider["cursor-acp"].models = {
+      ...existingConfig.provider["cursor-acp"].models,
+      ...formatted
+    };
+
+    writeFileSync(configPath, JSON.stringify(existingConfig, null, 2));
+    console.log(`Updated ${configPath}`);
+  } else {
+    console.error("cursor-acp provider not found in config");
+    process.exit(1);
+  }
+
+  console.log("Done!");
+}
+
+main().catch(console.error);

package/src/cli/mcptool.ts

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+/**
+ * mcptool — CLI for calling MCP server tools from the shell.
+ *
+ * Usage:
+ *   mcptool servers                          List configured MCP servers
+ *   mcptool tools [server]                   List tools (optionally filter by server)
+ *   mcptool call <server> <tool> [json-args] Call a tool
+ *
+ * Reads MCP server configuration from opencode.json (same config the plugin uses).
+ */
+
+import { readMcpConfigs } from "../mcp/config.js";
+import { McpClientManager } from "../mcp/client-manager.js";
+
+const USAGE = `mcptool — call MCP server tools from the shell
+
+Usage:
+  mcptool servers                          List configured servers
+  mcptool tools [server]                   List available tools
+  mcptool call <server> <tool> [json-args] Call a tool
+
+Examples:
+  mcptool servers
+  mcptool tools
+  mcptool tools hybrid-memory
+  mcptool call hybrid-memory memory_stats
+  mcptool call hybrid-memory memory_search '{"query":"auth"}'
+  mcptool call test-filesystem list_directory '{"path":"/tmp"}'`;
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  const command = args[0];
+  const configs = readMcpConfigs();
+
+  if (configs.length === 0) {
+    console.error("No MCP servers configured in opencode.json");
+    process.exit(1);
+  }
+
+  const manager = new McpClientManager();
+
+  if (command === "servers") {
+    for (const c of configs) {
+      const detail =
+        c.type === "local" ? c.command.join(" ") : (c as any).url ?? "";
+      console.log(`${c.name}  (${c.type})  ${detail}`);
+    }
+    process.exit(0);
+  }
+
+  if (command === "tools") {
+    const filter = args[1];
+    const toConnect = filter
+      ? configs.filter((c) => c.name === filter)
+      : configs;
+
+    if (filter && toConnect.length === 0) {
+      console.error(`Unknown server: ${filter}`);
+      console.error(`Available: ${configs.map((c) => c.name).join(", ")}`);
+      process.exit(1);
+    }
+
+    await Promise.allSettled(toConnect.map((c) => manager.connectServer(c)));
+    const tools = manager.listTools();
+
+    if (tools.length === 0) {
+      console.log("No tools discovered.");
+    } else {
+      for (const t of tools) {
+        const params = t.inputSchema
+          ? Object.keys((t.inputSchema as any).properties ?? {}).join(", ")
+          : "";
+        console.log(`${t.serverName}/${t.name}  ${t.description ?? ""}`);
+        if (params) console.log(`  params: ${params}`);
+      }
+    }
+
+    await manager.disconnectAll();
+    process.exit(0);
+  }
+
+  if (command === "call") {
+    const serverName = args[1];
+    const toolName = args[2];
+    const rawArgs = args[3];
+
+    if (!serverName || !toolName) {
+      console.error("Usage: mcptool call <server> <tool> [json-args]");
+      process.exit(1);
+    }
+
+    const config = configs.find((c) => c.name === serverName);
+    if (!config) {
+      console.error(`Unknown server: ${serverName}`);
+      console.error(`Available: ${configs.map((c) => c.name).join(", ")}`);
+      process.exit(1);
+    }
+
+    let toolArgs: Record<string, unknown> = {};
+    if (rawArgs) {
+      try {
+        toolArgs = JSON.parse(rawArgs);
+      } catch {
+        console.error(`Invalid JSON args: ${rawArgs}`);
+        process.exit(1);
+      }
+    }
+
+    await manager.connectServer(config);
+    const result = await manager.callTool(serverName, toolName, toolArgs);
+    console.log(result);
+
+    await manager.disconnectAll();
+    process.exit(0);
+  }
+
+  console.error(`Unknown command: ${command}`);
+  console.log(USAGE);
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error(`mcptool error: ${err.message || err}`);
+  process.exit(1);
+});

package/src/cli/model-discovery.ts

@@ -0,0 +1,71 @@
+import { execFileSync } from "child_process";
+import { stripAnsi } from "../utils/errors.js";
+import { resolveCursorAgentBinary } from "../utils/binary.js";
+
+const MODEL_DISCOVERY_TIMEOUT_MS = 5000;
+
+export type DiscoveredModel = {
+  id: string;
+  name: string;
+};
+
+export function parseCursorModelsOutput(output: string): DiscoveredModel[] {
+  const clean = stripAnsi(output);
+  const models: DiscoveredModel[] = [];
+  const seen = new Set<string>();
+
+  for (const line of clean.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(
+      /^([a-zA-Z0-9._-]+)\s+-\s+(.+?)(?:\s+\((?:current|default)\))*\s*$/,
+    );
+    if (!match) continue;
+
+    const id = match[1];
+    if (seen.has(id)) continue;
+    seen.add(id);
+    models.push({ id, name: match[2].trim() });
+  }
+
+  return models;
+}
+
+export function discoverModelsFromCursorAgent(): DiscoveredModel[] {
+  const raw = execFileSync(resolveCursorAgentBinary(), ["models"], {
+    encoding: "utf8",
+    ...(process.platform !== "win32" && { killSignal: "SIGTERM" as const }),
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: MODEL_DISCOVERY_TIMEOUT_MS,
+  });
+  const models = parseCursorModelsOutput(raw);
+  if (models.length === 0) {
+    throw new Error("No models parsed from cursor-agent output");
+  }
+  return models;
+}
+
+export function fallbackModels(): DiscoveredModel[] {
+  return [
+    { id: "auto", name: "Auto" },
+    { id: "composer-1.5", name: "Composer 1.5" },
+    { id: "composer-1", name: "Composer 1" },
+    { id: "opus-4.6-thinking", name: "Claude 4.6 Opus (Thinking)" },
+    { id: "opus-4.6", name: "Claude 4.6 Opus" },
+    { id: "sonnet-4.6", name: "Claude 4.6 Sonnet" },
+    { id: "sonnet-4.6-thinking", name: "Claude 4.6 Sonnet (Thinking)" },
+    { id: "opus-4.5", name: "Claude 4.5 Opus" },
+    { id: "opus-4.5-thinking", name: "Claude 4.5 Opus (Thinking)" },
+    { id: "sonnet-4.5", name: "Claude 4.5 Sonnet" },
+    { id: "sonnet-4.5-thinking", name: "Claude 4.5 Sonnet (Thinking)" },
+    { id: "gpt-5.4-high", name: "GPT-5.4 High" },
+    { id: "gpt-5.4-medium", name: "GPT-5.4" },
+    { id: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
+    { id: "gpt-5.2", name: "GPT-5.2" },
+    { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro" },
+    { id: "gemini-3-pro", name: "Gemini 3 Pro" },
+    { id: "gemini-3-flash", name: "Gemini 3 Flash" },
+    { id: "grok", name: "Grok" },
+    { id: "kimi-k2.5", name: "Kimi K2.5" },
+  ];
+}