@rama_nigg/open-cursor 2.3.20 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rama_nigg/open-cursor",
-  "version": "2.3.20",
+  "version": "2.4.1",
   "description": "No prompt limits. No broken streams. Full thinking + tool support. Your Cursor subscription, properly integrated.",
   "type": "module",
   "main": "dist/plugin-entry.js",
@@ -11,8 +11,10 @@
     "test": "bun test",
     "test:unit": "bun test tests/unit",
     "test:integration": "bun test tests/integration",
-    "test:ci:unit": "bun test tests/tools/defaults.test.ts tests/tools/executor-chain.test.ts tests/tools/sdk-executor.test.ts tests/tools/mcp-executor.test.ts tests/tools/skills.test.ts tests/tools/registry.test.ts tests/unit/cli/model-discovery.test.ts tests/unit/proxy/prompt-builder.test.ts tests/unit/proxy/tool-loop.test.ts tests/unit/provider-boundary.test.ts tests/unit/provider-runtime-interception.test.ts tests/unit/provider-tool-schema-compat.test.ts tests/unit/provider-tool-loop-guard.test.ts tests/unit/plugin.test.ts tests/unit/plugin-tools-hook.test.ts tests/unit/plugin-tool-resolution.test.ts tests/unit/plugin-config.test.ts tests/unit/auth.test.ts tests/unit/streaming/line-buffer.test.ts tests/unit/streaming/parser.test.ts tests/unit/streaming/types.test.ts tests/unit/streaming/delta-tracker.test.ts tests/competitive/edge.test.ts",
+    "test:ci:unit": "bun test tests/tools/defaults.test.ts tests/tools/executor-chain.test.ts tests/tools/sdk-executor.test.ts tests/tools/mcp-executor.test.ts tests/tools/skills.test.ts tests/tools/registry.test.ts tests/unit/cli/model-discovery.test.ts tests/unit/proxy/prompt-builder.test.ts tests/unit/proxy/tool-loop.test.ts tests/unit/provider-boundary.test.ts tests/unit/provider-runtime-interception.test.ts tests/unit/provider-tool-schema-compat.test.ts tests/unit/provider-tool-loop-guard.test.ts tests/unit/plugin.test.ts tests/unit/plugin-tools-hook.test.ts tests/unit/plugin-tool-resolution.test.ts tests/unit/plugin-config.test.ts tests/unit/plugin-stream-extraction.test.ts tests/unit/auth.test.ts tests/unit/streaming/line-buffer.test.ts tests/unit/streaming/parser.test.ts tests/unit/streaming/types.test.ts tests/unit/streaming/delta-tracker.test.ts tests/unit/streaming/openai-sse.test.ts tests/unit/streaming/ai-sdk-parts.test.ts tests/competitive/edge.test.ts",
     "test:ci:integration": "bun test tests/integration/comprehensive.test.ts tests/integration/tools-router.integration.test.ts tests/integration/stream-router.integration.test.ts tests/integration/opencode-loop.integration.test.ts",
+    "check:pricing": "bun run scripts/check-cursor-pricing-coverage.ts",
+    "check:pricing:fixture": "bun run scripts/check-cursor-pricing-coverage.ts --models-file tests/fixtures/cursor-pricing-models.txt --skip-doc-fetch",
     "discover": "bun run src/cli/discover.ts",
     "prepublishOnly": "bun run build"
   },

package/src/auth.ts

@@ -6,6 +6,7 @@ import { homedir, platform } from "os";
 import { join } from "path";
 import { createLogger } from "./utils/logger";
 import { stripAnsi } from "./utils/errors";
+import { resolveCursorAgentBinary } from "./utils/binary.js";
 
 const log = createLogger("auth");
 
@@ -75,8 +76,9 @@ export async function startCursorOAuth(): Promise<{
   return new Promise((resolve, reject) => {
     log.info("Starting cursor-cli login process");
 
-    const proc = spawn("cursor-agent", ["login"], {
+    const proc = spawn(resolveCursorAgentBinary(), ["login"], {
       stdio: ["pipe", "pipe", "pipe"],
+      shell: process.platform === "win32",
     });
 
     let stdout = "";

package/src/cli/model-discovery.ts

@@ -1,5 +1,6 @@
 import { execFileSync } from "child_process";
 import { stripAnsi } from "../utils/errors.js";
+import { resolveCursorAgentBinary } from "../utils/binary.js";
 
 const MODEL_DISCOVERY_TIMEOUT_MS = 5000;
 
@@ -31,9 +32,9 @@ export function parseCursorModelsOutput(output: string): DiscoveredModel[] {
 }
 
 export function discoverModelsFromCursorAgent(): DiscoveredModel[] {
-  const raw = execFileSync("cursor-agent", ["models"], {
+  const raw = execFileSync(resolveCursorAgentBinary(), ["models"], {
     encoding: "utf8",
-    killSignal: "SIGTERM",
+    ...(process.platform !== "win32" && { killSignal: "SIGTERM" as const }),
     stdio: ["ignore", "pipe", "pipe"],
     timeout: MODEL_DISCOVERY_TIMEOUT_MS,
   });

package/src/cli/opencode-cursor.ts

@@ -18,6 +18,9 @@ import {
   discoverModelsFromCursorAgent,
   fallbackModels,
 } from "./model-discovery.js";
+import { resolveCursorAgentBinary } from "../utils/binary.js";
+import { groupCursorModels, mergeCursorModelEntries } from "../models/variants.js";
+import type { DiscoveredModel } from "./model-discovery.js";
 
 const BRANDING_HEADER = `
  ▄▄▄  ▄▄▄▄  ▄▄▄▄▄ ▄▄  ▄▄      ▄▄▄  ▄▄ ▄▄ ▄▄▄▄   ▄▄▄▄   ▄▄▄   ▄▄▄▄
@@ -55,6 +58,20 @@ type StatusResult = {
   };
 };
 
+type ModelExplanation = {
+  modelCount: number;
+  groupedCount: number;
+  directCount: number;
+  groups: Array<{
+    id: string;
+    name: string;
+    defaultCursorModel: string;
+    memberCount: number;
+    variants: Record<string, string>;
+  }>;
+  direct: string[];
+};
+
 export function checkBun(): CheckResult {
   try {
     const version = execFileSync("bun", ["--version"], { encoding: "utf8" }).trim();
@@ -70,7 +87,7 @@ export function checkBun(): CheckResult {
 
 export function checkCursorAgent(): CheckResult {
   try {
-    const output = execFileSync("cursor-agent", ["--version"], { encoding: "utf8" }).trim();
+    const output = execFileSync(resolveCursorAgentBinary(), ["--version"], { encoding: "utf8" }).trim();
     const version = output.split("\n")[0] || "installed";
     return { name: "cursor-agent", passed: true, message: version };
   } catch {
@@ -86,7 +103,11 @@ export function checkCursorAgentLogin(): CheckResult {
   try {
     // cursor-agent stores credentials in ~/.cursor-agent or similar
     // Try running a command that requires auth
-    execFileSync("cursor-agent", ["models"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync(resolveCursorAgentBinary(), ["models"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 3000,
+    });
     return { name: "cursor-agent login", passed: true, message: "logged in" };
   } catch {
     return {
@@ -217,7 +238,7 @@ export function runDoctorChecks(configPath: string, pluginPath: string): CheckRe
   ];
 }
 
-type Command = "install" | "sync-models" | "uninstall" | "status" | "doctor" | "help";
+type Command = "install" | "sync-models" | "models" | "uninstall" | "status" | "doctor" | "help";
 
 type Options = {
   config?: string;
@@ -226,9 +247,36 @@ type Options = {
   copy?: boolean;
   skipModels?: boolean;
   noBackup?: boolean;
+  variants?: boolean;
+  compact?: boolean;
+  dryRun?: boolean;
+  deep?: boolean;
+  explain?: boolean;
   json?: boolean;
 };
 
+type SyncSummary = {
+  added: number;
+  updated: number;
+  removed: number;
+  priced: number;
+  skipped: number;
+};
+
+type SyncModelsResult = {
+  syncedCount: number;
+  groupedCount: number;
+  removedCount: number;
+  summary: SyncSummary;
+};
+
+type SyncModelsJsonResult = SyncModelsResult & {
+  configPath: string;
+  dryRun: boolean;
+  variants: boolean;
+  compact: boolean;
+};
+
 const PROVIDER_ID = "cursor-acp";
 const NPM_PACKAGE_PREFIX = "@rama_nigg/open-cursor";
 const DEFAULT_BASE_URL = "http://127.0.0.1:32124/v1";
@@ -241,6 +289,7 @@ function printHelp() {
 Commands:
   install     Configure OpenCode for Cursor (idempotent, safe to re-run)
   sync-models Refresh model list from cursor-agent
+  models      Explain discovered Cursor model groups and variants
   status      Show current configuration state
   doctor      Diagnose common issues
   uninstall   Remove cursor-acp from OpenCode config
@@ -252,8 +301,13 @@ Options:
   --base-url <url>      Proxy base URL (default: http://127.0.0.1:32124/v1)
   --copy                Copy plugin instead of symlink
   --skip-models         Skip model sync during install
+  --variants            Generate compact OpenCode model variants from Cursor models
+  --compact             With --variants, remove raw grouped Cursor model entries
+  --dry-run             Preview sync/install config changes without writing files
+  --deep                Run extra doctor checks for models and variant config
+  --explain             Show model grouping explanation (models command)
   --no-backup           Don't create config backup
-  --json                Output in JSON format (status command only)
+  --json                Output in JSON format where supported
 `);
 }
 
@@ -268,6 +322,16 @@ function parseArgs(argv: string[]): { command: Command; options: Options } {
       options.copy = true;
     } else if (arg === "--skip-models") {
       options.skipModels = true;
+    } else if (arg === "--variants") {
+      options.variants = true;
+    } else if (arg === "--compact") {
+      options.compact = true;
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--deep") {
+      options.deep = true;
+    } else if (arg === "--explain") {
+      options.explain = true;
     } else if (arg === "--no-backup") {
       options.noBackup = true;
     } else if (arg === "--config" && rest[i + 1]) {
@@ -293,6 +357,7 @@ function normalizeCommand(value: string | undefined): Command {
   switch ((value || "help").toLowerCase()) {
     case "install":
     case "sync-models":
+    case "models":
     case "uninstall":
     case "status":
     case "doctor":
@@ -356,12 +421,14 @@ function readConfig(configPath: string): any {
   }
 }
 
-function writeConfig(configPath: string, config: any, noBackup: boolean) {
+function writeConfig(configPath: string, config: any, noBackup: boolean, silent = false) {
   mkdirSync(dirname(configPath), { recursive: true });
   if (!noBackup && existsSync(configPath)) {
     const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:]/g, "-")}`;
     copyFileSync(configPath, backupPath);
-    console.log(`Backup written: ${backupPath}`);
+    if (!silent) {
+      console.log(`Backup written: ${backupPath}`);
+    }
   }
   writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
 }
@@ -411,6 +478,127 @@ function discoverModelsSafe() {
   }
 }
 
+function syncModelsIntoProvider(config: any, options: Options): SyncModelsResult {
+  if (options.compact && !options.variants) {
+    throw new Error("--compact requires --variants");
+  }
+
+  const discoveredModels = discoverModelsSafe();
+  const provider = config.provider[PROVIDER_ID];
+  const existingModels = provider.models && typeof provider.models === "object"
+    ? provider.models
+    : {};
+  const beforeModels = snapshotModels(existingModels);
+  const result = mergeCursorModelEntries(existingModels, discoveredModels, {
+    variants: options.variants === true,
+    compact: options.compact === true,
+  });
+
+  provider.models = result.models;
+  return {
+    syncedCount: result.syncedCount,
+    groupedCount: result.groupedCount,
+    removedCount: result.removedCount,
+    summary: summarizeModelSync(beforeModels, result.models),
+  };
+}
+
+export function explainCursorModels(models: DiscoveredModel[]): ModelExplanation {
+  const grouped = groupCursorModels(models);
+  const groupedCount = grouped.groups.reduce((total, group) => total + group.members.length, 0);
+
+  return {
+    modelCount: models.length,
+    groupedCount,
+    directCount: grouped.direct.length,
+    groups: grouped.groups.map(group => ({
+      id: group.baseId,
+      name: group.name,
+      defaultCursorModel: group.defaultCursorModelId,
+      memberCount: group.members.length,
+      variants: group.variants,
+    })),
+    direct: grouped.direct.map(model => model.id),
+  };
+}
+
+function createSyncJsonResult(
+  result: SyncModelsResult,
+  options: Options,
+  configPath: string,
+): SyncModelsJsonResult {
+  return {
+    ...result,
+    configPath,
+    dryRun: options.dryRun === true,
+    variants: options.variants === true,
+    compact: options.compact === true,
+  };
+}
+
+function snapshotModels(models: Record<string, unknown>): Record<string, unknown> {
+  return JSON.parse(JSON.stringify(models));
+}
+
+export function summarizeModelSync(
+  beforeModels: Record<string, unknown>,
+  afterModels: Record<string, unknown>,
+): SyncSummary {
+  let added = 0;
+  let updated = 0;
+  let removed = 0;
+  let skipped = 0;
+
+  for (const [modelId, afterEntry] of Object.entries(afterModels)) {
+    if (!Object.prototype.hasOwnProperty.call(beforeModels, modelId)) {
+      added++;
+      continue;
+    }
+
+    if (JSON.stringify(beforeModels[modelId]) === JSON.stringify(afterEntry)) {
+      skipped++;
+    } else {
+      updated++;
+    }
+  }
+
+  for (const modelId of Object.keys(beforeModels)) {
+    if (!Object.prototype.hasOwnProperty.call(afterModels, modelId)) {
+      removed++;
+    }
+  }
+
+  return {
+    added,
+    updated,
+    removed,
+    priced: countPricedModelEntries(afterModels),
+    skipped,
+  };
+}
+
+function countPricedModelEntries(models: Record<string, unknown>): number {
+  let priced = 0;
+
+  for (const entry of Object.values(models)) {
+    if (!isRecord(entry)) continue;
+    if (isRecord(entry.cost)) priced++;
+
+    if (!isRecord(entry.variants)) continue;
+    for (const variantEntry of Object.values(entry.variants)) {
+      if (isRecord(variantEntry) && isRecord(variantEntry.cost)) {
+        priced++;
+      }
+    }
+  }
+
+  return priced;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 function installAiSdk(opencodeDir: string) {
   try {
     execFileSync("bun", ["install", "@ai-sdk/openai-compatible"], {
@@ -429,23 +617,26 @@ function commandInstall(options: Options) {
   const copyMode = options.copy === true;
   const pluginSource = resolvePluginSource();
 
-  mkdirSync(opencodeDir, { recursive: true });
-  ensurePluginLink(pluginSource, pluginPath, copyMode);
+  if (!options.dryRun) {
+    mkdirSync(opencodeDir, { recursive: true });
+    ensurePluginLink(pluginSource, pluginPath, copyMode);
+  }
   const config = readConfig(configPath);
   ensureProvider(config, baseUrl);
 
   if (!options.skipModels) {
-    const models = discoverModelsSafe();
-    for (const model of models) {
-      config.provider[PROVIDER_ID].models[model.id] = { name: model.name };
-    }
-    console.log(`Models synced: ${models.length}`);
+    const result = syncModelsIntoProvider(config, options);
+    printSyncResult(result, options);
   }
 
-  writeConfig(configPath, config, options.noBackup === true);
-  installAiSdk(opencodeDir);
+  if (options.dryRun) {
+    console.log("Dry run: no files changed.");
+  } else {
+    writeConfig(configPath, config, options.noBackup === true);
+    installAiSdk(opencodeDir);
+  }
 
-  console.log(`Installed ${PROVIDER_ID}`);
+  console.log(`${options.dryRun ? "Would install" : "Installed"} ${PROVIDER_ID}`);
   console.log(`Plugin path: ${pluginPath}${copyMode ? " (copy)" : " (symlink)"}`);
   console.log(`Config path: ${configPath}`);
 }
@@ -455,16 +646,81 @@ function commandSyncModels(options: Options) {
   const config = readConfig(configPath);
   ensureProvider(config, options.baseUrl || DEFAULT_BASE_URL);
 
-  const models = discoverModelsSafe();
-  for (const model of models) {
-    config.provider[PROVIDER_ID].models[model.id] = { name: model.name };
+  const result = syncModelsIntoProvider(config, options);
+
+  if (!options.dryRun) {
+    writeConfig(configPath, config, options.noBackup === true, options.json === true);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(createSyncJsonResult(result, options, configPath), null, 2));
+    return;
   }
 
-  writeConfig(configPath, config, options.noBackup === true);
-  console.log(`Models synced: ${models.length}`);
+  printSyncResult(result, options);
+  if (options.dryRun) {
+    console.log("Dry run: no changes written.");
+  }
   console.log(`Config path: ${configPath}`);
 }
 
+function commandModels(options: Options) {
+  const models = discoverModelsSafe();
+  const explanation = explainCursorModels(models);
+
+  if (options.json) {
+    console.log(JSON.stringify(explanation, null, 2));
+    return;
+  }
+
+  console.log(`Cursor models discovered: ${explanation.modelCount}`);
+  console.log(`Grouped Cursor models: ${explanation.groupedCount}`);
+  console.log(`Direct models: ${explanation.directCount}`);
+
+  if (!options.explain) {
+    return;
+  }
+
+  console.log("");
+  console.log("Model groups:");
+  for (const group of explanation.groups) {
+    console.log(`  ${group.id}`);
+    console.log(`    Default: ${group.defaultCursorModel}`);
+    const variants = Object.entries(group.variants);
+    if (variants.length === 0) {
+      console.log("    Variants: none");
+      continue;
+    }
+    console.log("    Variants:");
+    for (const [variant, cursorModel] of variants) {
+      console.log(`      ${variant}: ${cursorModel}`);
+    }
+  }
+
+  console.log("");
+  console.log("Direct models:");
+  for (const modelId of explanation.direct) {
+    console.log(`  ${modelId}`);
+  }
+}
+
+function printSyncResult(result: SyncModelsResult, options: Options) {
+  console.log(`Models synced: ${result.syncedCount}`);
+  if (options.variants) {
+    console.log(`Grouped Cursor models: ${result.groupedCount}`);
+  }
+  if (result.removedCount > 0) {
+    console.log(`Raw grouped models removed: ${result.removedCount}`);
+  }
+
+  console.log("Sync summary:");
+  console.log(`  Added: ${result.summary.added}`);
+  console.log(`  Updated: ${result.summary.updated}`);
+  console.log(`  Removed: ${result.summary.removed}`);
+  console.log(`  Priced: ${result.summary.priced}`);
+  console.log(`  Skipped: ${result.summary.skipped}`);
+}
+
 const NPM_PACKAGE = "@rama_nigg/open-cursor";
 
 function commandUninstall(options: Options) {
@@ -564,6 +820,115 @@ export function getStatusResult(configPath: string, pluginPath: string): StatusR
   };
 }
 
+export function runDeepDoctorChecks(configPath: string): CheckResult[] {
+  const checks: CheckResult[] = [];
+  let config: any;
+
+  try {
+    config = readConfig(configPath);
+  } catch (error) {
+    return [{
+      name: "Deep config read",
+      passed: false,
+      message: error instanceof Error ? error.message : String(error),
+    }];
+  }
+
+  const provider = config.provider?.[PROVIDER_ID];
+  const models = isRecord(provider?.models) ? provider.models : {};
+  const baseUrl = typeof provider?.options?.baseURL === "string" ? provider.options.baseURL : "";
+
+  checks.push({
+    name: "Provider base URL",
+    passed: baseUrl.startsWith("http://") || baseUrl.startsWith("https://"),
+    message: baseUrl || "missing - run: open-cursor install",
+  });
+
+  checks.push({
+    name: "Provider models",
+    passed: Object.keys(models).length > 0,
+    message: `${Object.keys(models).length} configured model(s)`,
+  });
+
+  const variantEntryCount = countVariantModelEntries(models);
+  checks.push({
+    name: "Compact variants",
+    passed: variantEntryCount > 0,
+    warning: variantEntryCount === 0,
+    message: variantEntryCount > 0
+      ? `${variantEntryCount} model entr${variantEntryCount === 1 ? "y" : "ies"} with variants`
+      : "no compact variants found - run: open-cursor sync-models --variants --compact",
+  });
+
+  let discoveredModels: DiscoveredModel[];
+  try {
+    discoveredModels = discoverModelsFromCursorAgent();
+    checks.push({
+      name: "Cursor model discovery",
+      passed: true,
+      message: `${discoveredModels.length} model(s) from cursor-agent`,
+    });
+  } catch (error) {
+    checks.push({
+      name: "Cursor model discovery",
+      passed: false,
+      message: error instanceof Error ? error.message : String(error),
+      warning: true,
+    });
+    return checks;
+  }
+
+  const knownModelIds = new Set(discoveredModels.map(model => model.id));
+  const unknownTargets = collectConfiguredCursorModels(models)
+    .filter(modelId => !knownModelIds.has(modelId));
+  checks.push({
+    name: "Configured Cursor model targets",
+    passed: unknownTargets.length === 0,
+    warning: unknownTargets.length > 0,
+    message: unknownTargets.length === 0
+      ? "all configured targets exist in cursor-agent models"
+      : `${unknownTargets.length} target(s) not found: ${unknownTargets.slice(0, 5).join(", ")}`,
+  });
+
+  return checks;
+}
+
+function countVariantModelEntries(models: Record<string, unknown>): number {
+  return Object.values(models).filter(entry => {
+    return isRecord(entry) && isRecord(entry.variants) && Object.keys(entry.variants).length > 0;
+  }).length;
+}
+
+function collectConfiguredCursorModels(models: Record<string, unknown>): string[] {
+  const targets: string[] = [];
+
+  for (const [modelId, entry] of Object.entries(models)) {
+    if (!isRecord(entry)) {
+      targets.push(modelId);
+      continue;
+    }
+
+    const optionTarget = readCursorModel(entry.options);
+    targets.push(optionTarget || modelId);
+
+    if (!isRecord(entry.variants)) continue;
+    for (const variantEntry of Object.values(entry.variants)) {
+      const variantTarget = readCursorModel(variantEntry);
+      if (variantTarget) targets.push(variantTarget);
+    }
+  }
+
+  return [...new Set(targets)];
+}
+
+function readCursorModel(value: unknown): string | undefined {
+  if (!isRecord(value)) return undefined;
+  const cursorModel = value.cursorModel;
+  return typeof cursorModel === "string" && cursorModel.trim().length > 0
+    ? cursorModel.trim()
+    : undefined;
+}
+
 function commandStatus(options: Options) {
   const { configPath, pluginPath } = resolvePaths(options);
   const result = getStatusResult(configPath, pluginPath);
@@ -600,7 +965,16 @@ function commandStatus(options: Options) {
 
 function commandDoctor(options: Options) {
   const { configPath, pluginPath } = resolvePaths(options);
-  const checks = runDoctorChecks(configPath, pluginPath);
+  const checks = [
+    ...runDoctorChecks(configPath, pluginPath),
+    ...(options.deep ? runDeepDoctorChecks(configPath) : []),
+  ];
+
+  if (options.json) {
+    const failed = checks.filter(c => !c.passed && !c.warning);
+    console.log(JSON.stringify({ deep: options.deep === true, checks, failed: failed.length }, null, 2));
+    return;
+  }
 
   console.log("");
   for (const check of checks) {
@@ -638,6 +1012,9 @@ function main() {
       case "sync-models":
         commandSyncModels(parsed.options);
         return;
+      case "models":
+        commandModels(parsed.options);
+        return;
       case "uninstall":
         commandUninstall(parsed.options);
         return;
@@ -658,4 +1035,6 @@ function main() {
   }
 }
 
-main();
+if (process.env.NODE_ENV !== "test" && fileURLToPath(import.meta.url) === resolve(process.argv[1] || "")) {
+  main();
+}

package/src/client/simple.ts

@@ -7,6 +7,7 @@ import {
   type StreamJsonEvent,
 } from '../streaming/types.js';
 import { createLogger } from '../utils/logger.js';
+import { resolveCursorAgentBinary } from '../utils/binary.js';
 
 export interface CursorClientConfig {
   timeout?: number;
@@ -30,7 +31,7 @@ export class SimpleCursorClient {
       timeout: 30000,
       maxRetries: 3,
       streamOutput: true,
-      cursorAgentPath: process.env.CURSOR_AGENT_EXECUTABLE || 'cursor-agent',
+      cursorAgentPath: resolveCursorAgentBinary(),
       ...config
     };
 
@@ -78,7 +79,8 @@ export class SimpleCursorClient {
 
     const child = spawn(this.config.cursorAgentPath, args, {
       cwd,
-      stdio: ['pipe', 'pipe', 'pipe']
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: process.platform === 'win32',
     });
 
     if (prompt) {
@@ -189,7 +191,8 @@ export class SimpleCursorClient {
     return new Promise((resolve, reject) => {
       const child = spawn(this.config.cursorAgentPath, args, {
         cwd,
-        stdio: ['pipe', 'pipe', 'pipe']
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
       });
 
       let stdoutBuffer = '';

package/src/mcp/tool-bridge.ts

@@ -109,7 +109,7 @@ function mcpSchemaToZod(inputSchema: Record<string, unknown> | undefined, z: any
         zodType = z.array(z.any());
         break;
       case "object":
-        zodType = z.record(z.any());
+        zodType = z.record(z.string(), z.any());
         break;
       default:
         zodType = z.any();

package/src/models/discovery.ts

@@ -1,4 +1,5 @@
 import type { ModelInfo, DiscoveryConfig } from "./types.js";
+import { resolveCursorAgentBinary } from "../utils/binary.js";
 
 interface CacheEntry {
   models: ModelInfo[];
@@ -51,7 +52,7 @@ export class ModelDiscoveryService {
   private async queryViaCLI(): Promise<ModelInfo[]> {
     try {
       const bunAny = (globalThis as any).Bun;
-      const proc = bunAny.spawn(["cursor-agent", "models", "--json"], {
+      const proc = bunAny.spawn([resolveCursorAgentBinary(), "models", "--json"], {
         timeout: 5000,
         stdout: "pipe",
         stderr: "pipe"
@@ -78,7 +79,7 @@ export class ModelDiscoveryService {
   private async queryViaHelp(): Promise<ModelInfo[]> {
     try {
       const bunAny = (globalThis as any).Bun;
-      const proc = bunAny.spawn(["cursor-agent", "--help"], {
+      const proc = bunAny.spawn([resolveCursorAgentBinary(), "--help"], {
         timeout: 5000,
         stdout: "pipe",
         stderr: "pipe"