@evanovation/open-cursor 2.4.15

package/src/client/simple.ts

@@ -0,0 +1,293 @@
+import { spawn } from 'child_process';
+import { LineBuffer } from '../streaming/line-buffer.js';
+import { parseStreamJsonLine } from '../streaming/parser.js';
+import {
+  extractText,
+  isAssistantText,
+  type StreamJsonEvent,
+} from '../streaming/types.js';
+import { createLogger } from '../utils/logger.js';
+import { formatShellCommandForPlatform, resolveCursorAgentBinary } from '../utils/binary.js';
+
+export interface CursorClientConfig {
+  timeout?: number;
+  maxRetries?: number;
+  streamOutput?: boolean;
+  cursorAgentPath?: string;
+}
+
+export interface CursorResponse {
+  content: string;
+  done: boolean;
+  error?: string;
+}
+
+export class SimpleCursorClient {
+  private config: Required<CursorClientConfig>;
+  private log: ReturnType<typeof createLogger>;
+
+  constructor(config: CursorClientConfig = {}) {
+    this.config = {
+      timeout: 30000,
+      maxRetries: 3,
+      streamOutput: true,
+      cursorAgentPath: resolveCursorAgentBinary(),
+      ...config
+    };
+
+    this.log = createLogger('cursor-client');
+  }
+
+  async *executePromptStream(prompt: string, options: {
+    cwd?: string;
+    model?: string;
+    mode?: 'default' | 'plan' | 'ask';
+    resumeId?: string;
+  } = {}): AsyncGenerator<StreamJsonEvent, void, unknown> {
+    // Input validation
+    if (!prompt || typeof prompt !== 'string') {
+      throw new Error('Invalid prompt: must be a non-empty string');
+    }
+
+    const {
+      cwd = process.cwd(),
+      model = 'auto',
+      mode = 'default',
+      resumeId
+    } = options;
+
+    const args = [
+      '--print',
+      '--output-format',
+      'stream-json',
+      '--stream-partial-output',
+      '--model',
+      model
+    ];
+
+    if (mode === 'plan') {
+      args.push('--plan');
+    } else if (mode === 'ask') {
+      args.push('--mode', 'ask');
+    }
+
+    if (resumeId) {
+      args.push('--resume', resumeId);
+    }
+
+    this.log.debug('Executing prompt stream', { promptLength: prompt.length, mode, model });
+
+    const child = spawn(formatShellCommandForPlatform(this.config.cursorAgentPath), args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: process.platform === 'win32',
+    });
+
+    if (prompt) {
+      child.stdin.write(prompt);
+      child.stdin.end();
+    }
+
+    let processError: Error | null = null;
+    const lineBuffer = new LineBuffer();
+
+    // Add stderr handling
+    child.stderr.on('data', (data) => {
+      const errorMsg = data.toString();
+      this.log.error('cursor-agent stderr', { error: errorMsg });
+      processError = new Error(errorMsg);
+    });
+
+    // Add timeout
+    const timeoutId = setTimeout(() => {
+      child.kill('SIGTERM');
+      processError = new Error(`Timeout after ${this.config.timeout}ms`);
+    }, this.config.timeout);
+
+    const streamEnded = new Promise<number | null>((resolve) => {
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        if (code !== 0 && !processError) {
+          this.log.error('cursor-agent exited with non-zero code', { code });
+          processError = new Error(`cursor-agent exited with code ${code}`);
+        }
+        resolve(code);
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        this.log.error('cursor-agent process error', { error: error.message });
+        processError = error;
+        resolve(null);
+      });
+    });
+
+    for await (const chunk of child.stdout) {
+      for (const line of lineBuffer.push(chunk)) {
+        const event = parseStreamJsonLine(line);
+        if (event) {
+          yield event;
+        } else {
+          this.log.warn('Invalid JSON from cursor-agent', { line: line.substring(0, 100) });
+        }
+      }
+    }
+
+    for (const line of lineBuffer.flush()) {
+      const event = parseStreamJsonLine(line);
+      if (event) {
+        yield event;
+      } else {
+        this.log.warn('Invalid JSON from cursor-agent', { line: line.substring(0, 100) });
+      }
+    }
+
+    await streamEnded;
+
+    if (processError) {
+      throw processError;
+    }
+  }
+
+  async executePrompt(prompt: string, options: {
+    cwd?: string;
+    model?: string;
+    mode?: 'default' | 'plan' | 'ask';
+    resumeId?: string;
+  } = {}): Promise<CursorResponse> {
+    // Input validation
+    if (!prompt || typeof prompt !== 'string') {
+      throw new Error('Invalid prompt: must be a non-empty string');
+    }
+
+    const {
+      cwd = process.cwd(),
+      model = 'auto',
+      mode = 'default',
+      resumeId
+    } = options;
+
+    const args = [
+      '--print',
+      '--output-format',
+      'stream-json',
+      '--stream-partial-output',
+      '--model',
+      model
+    ];
+
+    if (mode === 'plan') {
+      args.push('--plan');
+    } else if (mode === 'ask') {
+      args.push('--mode', 'ask');
+    }
+
+    if (resumeId) {
+      args.push('--resume', resumeId);
+    }
+
+    this.log.debug('Executing prompt', { promptLength: prompt.length, mode, model });
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(formatShellCommandForPlatform(this.config.cursorAgentPath), args, {
+        cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
+      });
+
+      let stdoutBuffer = '';
+      let stderrBuffer = '';
+
+      if (prompt) {
+        child.stdin.write(prompt);
+        child.stdin.end();
+      }
+
+      const timeout = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Timeout after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+
+      child.stdout.on('data', (data) => {
+        stdoutBuffer += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderrBuffer += data.toString();
+      });
+
+      child.on('close', (code) => {
+        clearTimeout(timeout);
+        
+        if (code !== 0) {
+          reject(new Error(`cursor-agent exited with code ${code}: ${stderrBuffer}`));
+          return;
+        }
+
+        try {
+          const lines = stdoutBuffer.trim().split('\n');
+          let content = '';
+          
+          for (const line of lines) {
+            if (line.trim()) {
+              const event = parseStreamJsonLine(line);
+              if (event && isAssistantText(event)) {
+                content = extractText(event);
+              }
+            }
+          }
+
+          resolve({
+            content,
+            done: true
+          });
+        } catch (error) {
+          reject(new Error(`Failed to parse cursor-agent output: ${error}`));
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+  }
+
+  async getAvailableModels(): Promise<Array<{ id: string; name: string }>> {
+    return [
+      { id: 'auto', name: 'Cursor Agent Auto' },
+      { id: 'composer-1.5', name: 'Composer 1.5' },
+      { 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' },
+    ];
+  }
+
+  async validateInstallation(): Promise<boolean> {
+    try {
+      const testResponse = await this.executePrompt('test', { model: 'auto' });
+      return !!testResponse.content;
+    } catch (error) {
+      this.log.error('Cursor installation validation failed:', error);
+      return false;
+    }
+  }
+}
+
+export const createSimpleCursorClient = (config: CursorClientConfig = {}) => {
+  return new SimpleCursorClient(config);
+};

package/src/commands/status.ts

@@ -0,0 +1,39 @@
+// src/commands/status.ts
+
+import { existsSync, readFileSync } from "fs";
+import { getAuthFilePath } from "../auth";
+import { createLogger } from "../utils/logger";
+
+const log = createLogger("status");
+
+export interface AuthStatus {
+  authenticated: boolean;
+  authFilePath: string;
+  message: string;
+}
+
+export function checkAuthStatus(): AuthStatus {
+  const authFilePath = getAuthFilePath();
+  const exists = existsSync(authFilePath);
+
+  log.debug("Checking auth status", { path: authFilePath });
+
+  if (exists) {
+    return {
+      authenticated: true,
+      authFilePath,
+      message: `✓ Cursor: Authenticated\n  Auth file: ${authFilePath}`,
+    };
+  }
+
+  return {
+    authenticated: false,
+    authFilePath,
+    message: `✗ Cursor: Not authenticated\n  Run: opencode auth login cursor-acp`,
+  };
+}
+
+export function formatStatusOutput(): string {
+  const status = checkAuthStatus();
+  return status.message;
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+export { CursorPlugin } from "./plugin.js";
+export { createCursorProvider, cursor } from "./provider.js";
+export type { ProviderOptions } from "./provider.js";
+export { createProxyServer, findAvailablePort } from "./proxy/server.js";
+export { parseOpenAIRequest } from "./proxy/handler.js";
+export type { ParsedRequest } from "./proxy/handler.js";
+export { createChatCompletionResponse, createChatCompletionChunk } from "./proxy/formatter.js";
+export { verifyCursorAuth } from "./auth.js";
+export type { AuthResult } from "./auth.js";
+export { checkAuthStatus, formatStatusOutput } from "./commands/status";
+export type { AuthStatus } from "./commands/status";
+
+// Utilities
+export { createLogger } from "./utils/logger";
+export type { Logger } from "./utils/logger";
+export { parseAgentError, formatErrorForUser, stripAnsi } from "./utils/errors";
+export type { ParsedError, ErrorType } from "./utils/errors";
+
+// Streaming utilities
+export { LineBuffer } from "./streaming/line-buffer.js";
+export { parseStreamJsonLine } from "./streaming/parser.js";
+export { DeltaTracker } from "./streaming/delta-tracker.js";
+export { StreamToSseConverter, formatSseChunk, formatSseDone } from "./streaming/openai-sse.js";
+export { StreamToAiSdkParts } from "./streaming/ai-sdk-parts.js";
+export type {
+  StreamJsonAssistantEvent,
+  StreamJsonEvent,
+  StreamJsonResultEvent,
+  StreamJsonSystemEvent,
+  StreamJsonThinkingEvent,
+  StreamJsonToolCallEvent,
+  StreamJsonUserEvent,
+} from "./streaming/types.js";
+
+// Default export for OpenCode plugin usage
+export { CursorPlugin as default } from "./plugin.js";
+
+// Backward compatibility
+export { default as createCursorProviderCompat } from "./provider.js";

package/src/mcp/client-manager.ts

@@ -0,0 +1,166 @@
+import { createLogger } from "../utils/logger.js";
+import type { McpServerConfig } from "./config.js";
+
+const log = createLogger("mcp:client-manager");
+
+export interface McpToolInfo {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+interface DiscoveredTool extends McpToolInfo {
+  serverName: string;
+}
+
+interface ServerConnection {
+  client: any;
+  tools: McpToolInfo[];
+}
+
+interface McpClientManagerDeps {
+  createClient: () => any;
+  createTransport: (config: McpServerConfig) => any;
+}
+
+let defaultDeps: McpClientManagerDeps | null = null;
+
+async function loadDefaultDeps(): Promise<McpClientManagerDeps> {
+  if (defaultDeps) return defaultDeps;
+  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+
+  defaultDeps = {
+    createClient: () =>
+      new Client({ name: "open-cursor", version: "1.0.0" }, { capabilities: {} }),
+    createTransport: (config: McpServerConfig) => {
+      if (config.type === "local") {
+        return new StdioClientTransport({
+          command: config.command[0],
+          args: config.command.slice(1),
+          env: { ...process.env, ...(config.environment ?? {}) },
+          stderr: "pipe",
+        });
+      }
+      // Remote servers: StreamableHTTPClientTransport can be added later.
+      throw new Error(`Remote MCP transport not yet implemented for ${config.name}`);
+    },
+  };
+  return defaultDeps;
+}
+
+export class McpClientManager {
+  private connections = new Map<string, ServerConnection>();
+  private deps: McpClientManagerDeps | null;
+
+  constructor(deps?: McpClientManagerDeps) {
+    this.deps = deps ?? null;
+  }
+
+  async connectServer(config: McpServerConfig): Promise<void> {
+    if (this.connections.has(config.name)) {
+      log.debug("Server already connected, skipping", { server: config.name });
+      return;
+    }
+
+    // Lazy-load MCP SDK if no deps were injected
+    if (!this.deps) {
+      try {
+        this.deps = await loadDefaultDeps();
+      } catch (err) {
+        log.warn("Failed to load MCP SDK", { error: String(err) });
+        return;
+      }
+    }
+
+    const deps = this.deps;
+    let client: any;
+    try {
+      client = deps.createClient();
+      const transport = deps.createTransport(config);
+      await client.connect(transport);
+    } catch (err) {
+      log.warn("MCP server connection failed", {
+        server: config.name,
+        error: String(err),
+      });
+      return;
+    }
+
+    let tools: McpToolInfo[] = [];
+    try {
+      const result = await client.listTools();
+      tools = result?.tools ?? [];
+      log.info("MCP server connected", {
+        server: config.name,
+        tools: tools.length,
+      });
+    } catch (err) {
+      log.warn("MCP tool discovery failed", {
+        server: config.name,
+        error: String(err),
+      });
+    }
+
+    this.connections.set(config.name, { client, tools });
+  }
+
+  listTools(): DiscoveredTool[] {
+    const all: DiscoveredTool[] = [];
+    for (const [serverName, conn] of this.connections) {
+      for (const tool of conn.tools) {
+        all.push({ ...tool, serverName });
+      }
+    }
+    return all;
+  }
+
+  async callTool(
+    serverName: string,
+    toolName: string,
+    args: Record<string, unknown>,
+  ): Promise<string> {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      return `Error: MCP server "${serverName}" not connected`;
+    }
+
+    try {
+      const result = await conn.client.callTool({
+        name: toolName,
+        arguments: args,
+      });
+
+      // MCP callTool returns { content: Array<{ type, text }> }
+      if (Array.isArray(result?.content)) {
+        return result.content
+          .map((c: any) => (c.type === "text" ? c.text : JSON.stringify(c)))
+          .join("\n");
+      }
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (err: any) {
+      log.warn("MCP tool call failed", {
+        server: serverName,
+        tool: toolName,
+        error: String(err?.message || err),
+      });
+      return `Error: MCP tool "${toolName}" failed: ${err?.message || err}`;
+    }
+  }
+
+  async disconnectAll(): Promise<void> {
+    for (const [name, conn] of this.connections) {
+      try {
+        await conn.client.close();
+        log.debug("MCP server disconnected", { server: name });
+      } catch (err) {
+        log.debug("MCP server disconnect failed", { server: name, error: String(err) });
+      }
+    }
+    this.connections.clear();
+  }
+
+  get connectedServers(): string[] {
+    return Array.from(this.connections.keys());
+  }
+}

package/src/mcp/config.ts

@@ -0,0 +1,169 @@
+import {
+  existsSync as nodeExistsSync,
+  readFileSync as nodeReadFileSync,
+} from "node:fs";
+import { resolveOpenCodeConfigPath } from "../plugin-toggle.js";
+import { createLogger } from "../utils/logger.js";
+
+const log = createLogger("mcp:config");
+
+export type McpLocalServerConfig = {
+  name: string;
+  type: "local";
+  command: string[];
+  environment?: Record<string, string>;
+  timeout?: number;
+};
+
+export type McpRemoteServerConfig = {
+  name: string;
+  type: "remote";
+  url: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+};
+
+export type McpServerConfig = McpLocalServerConfig | McpRemoteServerConfig;
+
+interface ReadMcpConfigsDeps {
+  configJson?: string;
+  existsSync?: (path: string) => boolean;
+  readFileSync?: (path: string, enc: BufferEncoding) => string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function readMcpConfigs(deps: ReadMcpConfigsDeps = {}): McpServerConfig[] {
+  let raw: string;
+
+  if (deps.configJson != null) {
+    raw = deps.configJson;
+  } else {
+    const exists = deps.existsSync ?? nodeExistsSync;
+    const readFile = deps.readFileSync ?? nodeReadFileSync;
+    const configPath = resolveOpenCodeConfigPath(deps.env ?? process.env);
+    if (!exists(configPath)) return [];
+    try {
+      raw = readFile(configPath, "utf8");
+    } catch {
+      return [];
+    }
+  }
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+
+  const mcpSection = parsed.mcp;
+  if (!mcpSection || typeof mcpSection !== "object" || Array.isArray(mcpSection)) {
+    return [];
+  }
+
+  const configs: McpServerConfig[] = [];
+
+  for (const [name, entry] of Object.entries(mcpSection as Record<string, unknown>)) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const e = entry as Record<string, unknown>;
+
+    if (e.enabled === false) continue;
+
+    if (e.type === "local" && Array.isArray(e.command) && e.command.length > 0) {
+      configs.push({
+        name,
+        type: "local",
+        command: e.command as string[],
+        environment: isStringRecord(e.environment) ? e.environment : undefined,
+        timeout: typeof e.timeout === "number" ? e.timeout : undefined,
+      });
+    } else if (e.type === "remote" && typeof e.url === "string") {
+      configs.push({
+        name,
+        type: "remote",
+        url: e.url,
+        headers: isStringRecord(e.headers) ? e.headers : undefined,
+        timeout: typeof e.timeout === "number" ? e.timeout : undefined,
+      });
+    } else {
+      log.debug("Skipping unrecognised MCP config entry", { name, type: e.type });
+    }
+  }
+
+  return configs;
+}
+
+let _subagentCache: { names: string[]; expiry: number } | null = null;
+const SUBAGENT_CACHE_TTL_MS = 60_000;
+
+/** Clear cached subagent names (for testing only). */
+export function _resetSubagentCache(): void {
+  _subagentCache = null;
+}
+
+interface ReadSubagentNamesDeps {
+  configJson?: string;
+  existsSync?: (path: string) => boolean;
+  readFileSync?: (path: string, enc: BufferEncoding) => string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function readSubagentNames(deps: ReadSubagentNamesDeps = {}): string[] {
+  const useCache = deps.configJson == null;
+  if (useCache && _subagentCache && Date.now() < _subagentCache.expiry) {
+    return _subagentCache.names;
+  }
+
+  const result = readSubagentNamesUncached(deps);
+
+  if (useCache) {
+    _subagentCache = { names: result, expiry: Date.now() + SUBAGENT_CACHE_TTL_MS };
+  }
+  return result;
+}
+
+function readSubagentNamesUncached(deps: ReadSubagentNamesDeps): string[] {
+  let raw: string;
+
+  if (deps.configJson != null) {
+    raw = deps.configJson;
+  } else {
+    const exists = deps.existsSync ?? nodeExistsSync;
+    const readFile = deps.readFileSync ?? nodeReadFileSync;
+    const configPath = resolveOpenCodeConfigPath(deps.env ?? process.env);
+    if (!exists(configPath)) return ["general-purpose"];
+    try {
+      raw = readFile(configPath, "utf8");
+    } catch {
+      return ["general-purpose"];
+    }
+  }
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return ["general-purpose"];
+  }
+
+  const agentSection = parsed.agent;
+  if (!agentSection || typeof agentSection !== "object" || Array.isArray(agentSection)) {
+    return ["general-purpose"];
+  }
+
+  const agents = agentSection as Record<string, unknown>;
+  const names = Object.keys(agents);
+  if (names.length === 0) return ["general-purpose"];
+
+  const subagentNames = names.filter((name) => {
+    const entry = agents[name];
+    return entry && typeof entry === "object" && !Array.isArray(entry)
+      && (entry as Record<string, unknown>).mode === "subagent";
+  });
+
+  return subagentNames.length > 0 ? subagentNames : names;
+}
+
+function isStringRecord(v: unknown): v is Record<string, string> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}