@rama_nigg/open-cursor 2.3.15 → 2.3.17

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.3.15",
+  "version": "2.3.17",
   "description": "No prompt limits. No broken streams. Full thinking + tool support. Your Cursor subscription, properly integrated.",
   "type": "module",
   "main": "dist/plugin-entry.js",
   "module": "src/plugin-entry.ts",
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/plugin-entry.ts ./src/cli/discover.ts ./src/cli/opencode-cursor.ts --outdir ./dist --target node",
-    "dev": "bun build ./src/index.ts ./src/plugin-entry.ts ./src/cli/discover.ts ./src/cli/opencode-cursor.ts --outdir ./dist --target node --watch",
+    "build": "bun build ./src/index.ts ./src/plugin-entry.ts ./src/cli/discover.ts ./src/cli/opencode-cursor.ts ./src/cli/mcptool.ts --outdir ./dist --target node",
+    "dev": "bun build ./src/index.ts ./src/plugin-entry.ts ./src/cli/discover.ts ./src/cli/opencode-cursor.ts ./src/cli/mcptool.ts --outdir ./dist --target node --watch",
     "test": "bun test",
     "test:unit": "bun test tests/unit",
     "test:integration": "bun test tests/integration",
@@ -18,7 +18,8 @@
   },
   "bin": {
     "open-cursor": "dist/cli/opencode-cursor.js",
-    "cursor-discover": "dist/cli/discover.js"
+    "cursor-discover": "dist/cli/discover.js",
+    "mcptool": "dist/cli/mcptool.js"
   },
   "exports": {
     ".": {
@@ -37,9 +38,10 @@
     "src"
   ],
   "dependencies": {
-    "ai": "^6.0.55",
+    "@modelcontextprotocol/sdk": "^1.12.0",
     "@opencode-ai/plugin": "1.1.53",
     "@opencode-ai/sdk": "1.1.53",
+    "ai": "^6.0.55",
     "strip-ansi": "^7.1.0"
   },
   "devDependencies": {

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/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,98 @@
+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;
+}
+
+function isStringRecord(v: unknown): v is Record<string, string> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}

package/src/mcp/tool-bridge.ts

@@ -0,0 +1,131 @@
+import { tool } from "@opencode-ai/plugin";
+import { createLogger } from "../utils/logger.js";
+import type { McpClientManager } from "./client-manager.js";
+
+const log = createLogger("mcp:tool-bridge");
+
+interface DiscoveredMcpTool {
+  name: string;
+  serverName: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+/**
+ * Build plugin `tool()` hook entries for discovered MCP tools.
+ *
+ * Each MCP tool is namespaced as `mcp__<server_name>__<tool_name>`
+ * to avoid collision with local tools and to make the source clear.
+ */
+export function buildMcpToolHookEntries(
+  tools: DiscoveredMcpTool[],
+  manager: McpClientManager,
+): Record<string, any> {
+  const z = tool.schema;
+  const entries: Record<string, any> = {};
+
+  for (const t of tools) {
+    const hookName = namespaceMcpTool(t.serverName, t.name);
+
+    if (entries[hookName]) {
+      log.debug("Duplicate MCP tool name, skipping", { hookName });
+      continue;
+    }
+
+    const zodArgs = mcpSchemaToZod(t.inputSchema, z);
+    const serverName = t.serverName;
+    const toolName = t.name;
+
+    entries[hookName] = tool({
+      description: t.description || `MCP tool: ${t.name} (server: ${t.serverName})`,
+      args: zodArgs,
+      async execute(args: any) {
+        log.debug("Executing MCP tool", { server: serverName, tool: toolName });
+        const result = await manager.callTool(serverName, toolName, args ?? {});
+        if (result.startsWith("Error:")) {
+          throw new Error(result);
+        }
+        return result;
+      },
+    });
+  }
+
+  log.debug("Built MCP tool hook entries", { count: Object.keys(entries).length });
+  return entries;
+}
+
+/**
+ * Build OpenAI-format tool definitions for discovered MCP tools.
+ * These are injected into chat.params so the model sees the tools.
+ */
+export function buildMcpToolDefinitions(tools: DiscoveredMcpTool[]): any[] {
+  const defs: any[] = [];
+
+  for (const t of tools) {
+    const name = namespaceMcpTool(t.serverName, t.name);
+    defs.push({
+      type: "function",
+      function: {
+        name,
+        description: t.description || `MCP tool: ${t.name} (server: ${t.serverName})`,
+        parameters: t.inputSchema ?? { type: "object", properties: {} },
+      },
+    });
+  }
+
+  return defs;
+}
+
+function namespaceMcpTool(serverName: string, toolName: string): string {
+  const sanitizedServer = serverName.replace(/[^a-zA-Z0-9]/g, "_");
+  const sanitizedTool = toolName.replace(/[^a-zA-Z0-9]/g, "_");
+  return `mcp__${sanitizedServer}__${sanitizedTool}`;
+}
+
+function mcpSchemaToZod(inputSchema: Record<string, unknown> | undefined, z: any): any {
+  if (!inputSchema || typeof inputSchema !== "object") {
+    return {};
+  }
+
+  const properties = (inputSchema.properties ?? {}) as Record<string, any>;
+  const required = (inputSchema.required ?? []) as string[];
+  const shape: any = {};
+
+  for (const [key, prop] of Object.entries(properties)) {
+    let zodType: any;
+
+    switch (prop?.type) {
+      case "string":
+        zodType = z.string();
+        break;
+      case "number":
+      case "integer":
+        zodType = z.number();
+        break;
+      case "boolean":
+        zodType = z.boolean();
+        break;
+      case "array":
+        zodType = z.array(z.any());
+        break;
+      case "object":
+        zodType = z.record(z.any());
+        break;
+      default:
+        zodType = z.any();
+        break;
+    }
+
+    if (prop?.description) {
+      zodType = zodType.describe(prop.description);
+    }
+
+    if (!required.includes(key)) {
+      zodType = zodType.optional();
+    }
+
+    shape[key] = zodType;
+  }
+
+  return shape;
+}