@rama_nigg/open-cursor 2.3.14 → 2.3.16

package/src/models/sync.ts

@@ -0,0 +1,153 @@
+/**
+ * Non-blocking model auto-refresh for plugin startup.
+ *
+ * Discovers currently available models from cursor-agent and merges them
+ * into the opencode.json config. Only adds new models — never removes
+ * user-configured ones. Safe to call fire-and-forget; all errors are
+ * caught and logged silently.
+ */
+import {
+  existsSync as nodeExistsSync,
+  readFileSync as nodeReadFileSync,
+  writeFileSync as nodeWriteFileSync,
+} from "node:fs";
+import { discoverModelsFromCursorAgent, type DiscoveredModel } from "../cli/model-discovery.js";
+import { resolveOpenCodeConfigPath } from "../plugin-toggle.js";
+import { createLogger, type Logger } from "../utils/logger.js";
+
+const log = createLogger("model-sync");
+const PROVIDER_ID = "cursor-acp";
+
+type ModelConfigEntry = { name: string };
+type ProviderConfig = { models?: Record<string, unknown> } & Record<string, unknown>;
+type OpenCodeConfig = {
+  provider?: Record<string, ProviderConfig | undefined>;
+} & Record<string, unknown>;
+type AutoRefreshModelsDeps = {
+  defer: () => Promise<void>;
+  discoverModels: () => DiscoveredModel[];
+  env: NodeJS.ProcessEnv;
+  existsSync: (path: string) => boolean;
+  log: Logger;
+  readFileSync: (path: string, encoding: BufferEncoding) => string;
+  writeFileSync: (path: string, data: string, encoding: BufferEncoding) => void;
+};
+
+const defaultDeps: AutoRefreshModelsDeps = {
+  defer: () => Promise.resolve(),
+  discoverModels: discoverModelsFromCursorAgent,
+  env: process.env,
+  existsSync: nodeExistsSync,
+  log,
+  readFileSync: nodeReadFileSync,
+  writeFileSync: nodeWriteFileSync,
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseConfig(raw: string): OpenCodeConfig | null {
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? (parsed as OpenCodeConfig) : null;
+  } catch {
+    return null;
+  }
+}
+
+function getProviderConfig(config: OpenCodeConfig): ProviderConfig | null {
+  if (!isRecord(config.provider)) {
+    return null;
+  }
+
+  const provider = config.provider[PROVIDER_ID];
+  return isRecord(provider) ? (provider as ProviderConfig) : null;
+}
+
+function getExistingModels(provider: ProviderConfig): Record<string, unknown> {
+  return isRecord(provider.models) ? { ...provider.models } : {};
+}
+
+function yieldForFireAndForget(): Promise<void> {
+  return Promise.resolve();
+}
+
+/**
+ * Auto-refresh models at plugin startup.
+ *
+ * - Reads the current opencode.json config
+ * - Queries cursor-agent for available models
+ * - Merges discovered models into the provider config (additive only)
+ * - Writes back if any new models were added
+ *
+ * This function never throws. All failures are logged at debug level
+ * and silently ignored so plugin startup is never blocked.
+ */
+export async function autoRefreshModels(
+  deps: Partial<AutoRefreshModelsDeps> = {},
+): Promise<void> {
+  const resolvedDeps: AutoRefreshModelsDeps = {
+    ...defaultDeps,
+    defer: yieldForFireAndForget,
+    ...deps,
+  };
+
+  await resolvedDeps.defer();
+
+  try {
+    const configPath = resolveOpenCodeConfigPath(resolvedDeps.env);
+    if (!resolvedDeps.existsSync(configPath)) {
+      resolvedDeps.log.debug("Config file not found, skipping model auto-refresh", { configPath });
+      return;
+    }
+
+    const raw = resolvedDeps.readFileSync(configPath, "utf8");
+    const config = parseConfig(raw);
+    if (!config) {
+      resolvedDeps.log.debug("Config file is not valid JSON, skipping model auto-refresh");
+      return;
+    }
+
+    const provider = getProviderConfig(config);
+    if (!provider) {
+      resolvedDeps.log.debug("Provider section not found in config, skipping model auto-refresh");
+      return;
+    }
+
+    const existingModels = getExistingModels(provider);
+    let discovered: DiscoveredModel[];
+    try {
+      discovered = resolvedDeps.discoverModels();
+    } catch (err) {
+      resolvedDeps.log.debug("cursor-agent model discovery failed, skipping auto-refresh", {
+        error: String(err),
+      });
+      return;
+    }
+
+    let addedCount = 0;
+    for (const model of discovered) {
+      if (Object.prototype.hasOwnProperty.call(existingModels, model.id)) continue;
+      existingModels[model.id] = { name: model.name } satisfies ModelConfigEntry;
+      addedCount++;
+    }
+
+    if (addedCount === 0) {
+      resolvedDeps.log.debug("Model auto-refresh: no new models found", {
+        existing: Object.keys(existingModels).length,
+        discovered: discovered.length,
+      });
+      return;
+    }
+
+    provider.models = existingModels;
+    resolvedDeps.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    resolvedDeps.log.info("Model auto-refresh: added new models", {
+      added: addedCount,
+      total: Object.keys(existingModels).length,
+    });
+  } catch (err) {
+    resolvedDeps.log.debug("Model auto-refresh failed", { error: String(err) });
+  }
+}

package/src/plugin.ts

@@ -24,6 +24,10 @@ import { toOpenAiParameters, describeTool } from "./tools/schema.js";
 import { ToolRouter } from "./tools/router.js";
 import { SkillLoader } from "./tools/skills/loader.js";
 import { SkillResolver } from "./tools/skills/resolver.js";
+import { autoRefreshModels } from "./models/sync.js";
+import { readMcpConfigs } from "./mcp/config.js";
+import { McpClientManager } from "./mcp/client-manager.js";
+import { buildMcpToolHookEntries, buildMcpToolDefinitions } from "./mcp/tool-bridge.js";
 import { createOpencodeClient } from "@opencode-ai/sdk";
 import { ToolRegistry as CoreRegistry } from "./tools/core/registry.js";
 import { LocalExecutor } from "./tools/executors/local.js";
@@ -76,6 +80,61 @@ function debugLogToFile(message: string, data: any): void {
   }
 }
 
+interface McpToolSummary {
+  serverName: string;
+  toolName: string;
+  description?: string;
+  params?: string[];
+}
+
+export function buildAvailableToolsSystemMessage(
+  lastToolNames: string[],
+  lastToolMap: Array<{ id: string; name: string }>,
+  mcpToolDefs: any[],
+  mcpToolSummaries?: McpToolSummary[],
+): string | null {
+  const parts: string[] = [];
+
+  if (lastToolNames.length > 0 || lastToolMap.length > 0) {
+    const names = lastToolNames.join(", ");
+    const mapping = lastToolMap.map((m) => `${m.id} -> ${m.name}`).join("; ");
+    parts.push(`Available OpenCode tools (use via tool calls): ${names}. Original skill ids mapped as: ${mapping}. Aliases include oc_skill_* and oc_superskill_* when applicable.`);
+  }
+
+  if (mcpToolSummaries && mcpToolSummaries.length > 0) {
+    const servers = new Map<string, McpToolSummary[]>();
+    for (const s of mcpToolSummaries) {
+      const list = servers.get(s.serverName) ?? [];
+      list.push(s);
+      servers.set(s.serverName, list);
+    }
+
+    const lines: string[] = [
+      "MCP TOOLS — Use via Shell with the `mcptool` CLI.",
+      "Syntax: mcptool call <server> <tool> [json-args]",
+      "",
+    ];
+
+    for (const [server, tools] of servers) {
+      lines.push(`Server: ${server}`);
+      for (const t of tools) {
+        const paramHint = t.params?.length ? ` (params: ${t.params.join(", ")})` : "";
+        lines.push(`  - ${t.toolName}${paramHint}${t.description ? " — " + t.description : ""}`);
+      }
+      if (tools.length > 0) {
+        const ex = tools[0];
+        const exArgs = ex.params?.length ? ` '{"${ex.params[0]}":"..."}'` : "";
+        lines.push(`  Example: mcptool call ${server} ${ex.toolName}${exArgs}`);
+      }
+      lines.push("");
+    }
+
+    parts.push(lines.join("\n"));
+  }
+
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}
+
 export async function ensurePluginDirectory(): Promise<void> {
   const configHome = process.env.XDG_CONFIG_HOME
     ? resolve(process.env.XDG_CONFIG_HOME)
@@ -1735,8 +1794,51 @@ export const CursorPlugin: Plugin = async ({ $, directory, worktree, client, ser
   });
   await ensurePluginDirectory();
 
-  // Initialize toast service for MCP pass-through notifications
-  toastService.setClient(client);
+  // Auto-refresh model list from cursor-agent (non-blocking, fire-and-forget)
+  autoRefreshModels().catch(() => {});
+
+  // MCP tool bridge: connect to MCP servers and register their tools.
+  // We await init so tools are available before the plugin returns its tool hook.
+  const mcpManager = new McpClientManager();
+  let mcpToolEntries: Record<string, any> = {};
+  let mcpToolDefs: any[] = [];
+  let mcpToolSummaries: McpToolSummary[] = [];
+  const mcpEnabled = process.env.CURSOR_ACP_MCP_BRIDGE !== "false"; // default ON
+
+  if (mcpEnabled) {
+    try {
+      const configs = readMcpConfigs();
+      if (configs.length === 0) {
+        log.debug("No MCP servers configured, skipping MCP bridge");
+      } else {
+        log.debug("MCP bridge: connecting to servers", { count: configs.length });
+
+        await Promise.allSettled(configs.map((c) => mcpManager.connectServer(c)));
+
+        const tools = mcpManager.listTools();
+        if (tools.length === 0) {
+          log.debug("MCP bridge: no tools discovered");
+        } else {
+          mcpToolEntries = buildMcpToolHookEntries(tools, mcpManager);
+          mcpToolDefs = buildMcpToolDefinitions(tools);
+          mcpToolSummaries = tools.map((t) => ({
+            serverName: t.serverName,
+            toolName: t.name,
+            description: t.description,
+            params: t.inputSchema
+              ? Object.keys((t.inputSchema as any).properties ?? {})
+              : undefined,
+          }));
+          log.info("MCP bridge: registered tools", {
+            servers: mcpManager.connectedServers.length,
+            tools: Object.keys(mcpToolEntries).length,
+          });
+        }
+      }
+    } catch (err) {
+      log.debug("MCP bridge init failed", { error: String(err) });
+    }
+  }
 
   // Initialize toast service for MCP pass-through notifications
   toastService.setClient(client);
@@ -1861,7 +1963,7 @@ export const CursorPlugin: Plugin = async ({ $, directory, worktree, client, ser
   const toolHookEntries = buildToolHookEntries(localRegistry, workspaceDirectory);
 
   return {
-    tool: toolHookEntries,
+    tool: { ...toolHookEntries, ...mcpToolEntries },
     auth: {
       provider: CURSOR_PROVIDER_ID,
       async loader(_getAuth: () => Promise<Auth>) {
@@ -1934,16 +2036,32 @@ export const CursorPlugin: Plugin = async ({ $, directory, worktree, client, ser
           log.debug("Failed to refresh tools", { error: String(err) });
         }
       }
+
+      // Append MCP bridge tool definitions so the model can call them
+      if (mcpToolDefs.length > 0) {
+        const beforeTools = Array.isArray(output.options.tools) ? output.options.tools : [];
+        if (Array.isArray(output.options.tools)) {
+          output.options.tools = [...output.options.tools, ...mcpToolDefs];
+        } else {
+          output.options.tools = mcpToolDefs;
+        }
+        const afterTools = Array.isArray(output.options.tools) ? output.options.tools : [];
+        log.debug("Injected MCP tool definitions into chat.params", {
+          injectedCount: mcpToolDefs.length,
+          beforeCount: beforeTools.length,
+          afterCount: afterTools.length,
+          mcpNames: mcpToolDefs.slice(0, 10).map((t: any) => t?.function?.name ?? t?.name ?? "unknown"),
+          tailNames: afterTools.slice(-10).map((t: any) => t?.function?.name ?? t?.name ?? "unknown"),
+        });
+      }
     },
 
     async "experimental.chat.system.transform"(input: any, output: { system: string[] }) {
-      if (!toolsEnabled || lastToolNames.length === 0) return;
-      const names = lastToolNames.join(", ");
-      const mapping = lastToolMap.map((m) => `${m.id} -> ${m.name}`).join("; ");
+      if (!toolsEnabled) return;
+      const systemMessage = buildAvailableToolsSystemMessage(lastToolNames, lastToolMap, mcpToolDefs, mcpToolSummaries);
+      if (!systemMessage) return;
       output.system = output.system || [];
-      output.system.push(
-        `Available OpenCode tools (use via tool calls): ${names}. Original skill ids mapped as: ${mapping}. Aliases include oc_skill_* and oc_superskill_* when applicable.`
-      );
+      output.system.push(systemMessage);
     },
   };
 };