@stablekernel/opencode-cursor 0.1.0-rc.1

package/dist/plugin/index.js

@@ -0,0 +1,572 @@
+import {
+  acquireAgent,
+  buildModelSelection,
+  fingerprintApiKey,
+  loadCursorSdk,
+  resolveControls,
+  resolveCursorApiKey,
+  streamAgentTurn
+} from "../chunk-YYO6O43T.js";
+
+// src/model-cache.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+function ttlMs() {
+  const raw = process.env.OPENCODE_CURSOR_MODEL_CACHE_TTL_MS;
+  const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TTL_MS;
+}
+function cacheDir() {
+  const base = process.env.XDG_CACHE_HOME?.trim() || (homedir() ? join(homedir(), ".cache") : tmpdir());
+  return join(base, "opencode-cursor");
+}
+function cacheFile(fingerprint) {
+  return join(cacheDir(), `models-${fingerprint}.json`);
+}
+function latestCacheFile() {
+  return join(cacheDir(), "models-latest.json");
+}
+var LATEST_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+function readCacheFile(file, maxAgeMs) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (!parsed?.savedAt || !Array.isArray(parsed.models)) return void 0;
+    if (Date.now() - parsed.savedAt > maxAgeMs) return void 0;
+    return parsed.models;
+  } catch {
+    return void 0;
+  }
+}
+function writeCacheFile(file, models) {
+  try {
+    mkdirSync(cacheDir(), { recursive: true });
+    const envelope = { savedAt: Date.now(), models };
+    writeFileSync(file, JSON.stringify(envelope), "utf8");
+  } catch {
+  }
+}
+function readModelCache(fingerprint) {
+  return readCacheFile(cacheFile(fingerprint), ttlMs());
+}
+function writeModelCache(fingerprint, models) {
+  writeCacheFile(cacheFile(fingerprint), models);
+  writeCacheFile(latestCacheFile(), models);
+}
+function readLatestModelCache() {
+  return readCacheFile(latestCacheFile(), LATEST_TTL_MS);
+}
+
+// src/fallback-models.ts
+var FALLBACK_MODELS = [
+  {
+    id: "composer-2.5",
+    displayName: "Composer 2.5",
+    description: "Cursor's default agent model (fallback entry).",
+    parameters: [
+      { id: "thinking", displayName: "Thinking", values: [{ value: "off" }, { value: "on" }] }
+    ]
+  },
+  { id: "claude-opus-4-8", displayName: "Claude Opus 4.8 (via Cursor)" },
+  { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6 (via Cursor)" },
+  { id: "gpt-5.5", displayName: "GPT-5.5 (via Cursor)" }
+];
+
+// src/model-discovery.ts
+async function discoverModels(options = {}) {
+  const apiKey = resolveCursorApiKey(options.apiKey);
+  if (!apiKey) {
+    const latest = readLatestModelCache();
+    if (latest && latest.length > 0) return { models: latest, source: "cache" };
+    return {
+      models: FALLBACK_MODELS,
+      source: "fallback",
+      warning: "No Cursor API key found. Run `opencode auth login` and choose Cursor, or set CURSOR_API_KEY. Showing fallback models."
+    };
+  }
+  const fingerprint = fingerprintApiKey(apiKey);
+  if (!options.forceRefresh) {
+    const cached = readModelCache(fingerprint);
+    if (cached && cached.length > 0) {
+      return { models: cached, source: "cache" };
+    }
+  }
+  try {
+    const { Cursor } = await loadCursorSdk();
+    const models = await Cursor.models.list({ apiKey });
+    if (models.length > 0) {
+      writeModelCache(fingerprint, models);
+      return { models, source: "live" };
+    }
+    return {
+      models: FALLBACK_MODELS,
+      source: "fallback",
+      warning: "Cursor.models.list() returned no models; showing fallback models."
+    };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    const stale = readModelCache(fingerprint);
+    if (stale && stale.length > 0) {
+      return { models: stale, source: "cache", warning: `Live discovery failed (${detail}); using cached models.` };
+    }
+    return {
+      models: FALLBACK_MODELS,
+      source: "fallback",
+      warning: `Live discovery failed (${detail}); showing fallback models.`
+    };
+  }
+}
+function modelSupportsReasoning(item) {
+  return (item.parameters ?? []).some((p) => /think|reason/i.test(p.id));
+}
+function toOpencodeModels(items) {
+  const out = {};
+  for (const item of items) {
+    out[item.id] = {
+      id: item.id,
+      name: item.displayName || item.id,
+      attachment: true,
+      reasoning: modelSupportsReasoning(item),
+      temperature: false,
+      tool_call: true
+    };
+  }
+  return out;
+}
+
+// src/model-variants.ts
+var REASONING_PARAM = /think|reason|effort/i;
+function buildModelVariants(item) {
+  const out = {};
+  for (const param of item.parameters ?? []) {
+    if (!REASONING_PARAM.test(param.id)) continue;
+    for (const { value } of param.values ?? []) {
+      const key = param.id.toLowerCase() === "thinking" ? value : `${param.id}-${value}`;
+      out[key] = { params: { [param.id]: value } };
+    }
+  }
+  out["plan"] = { mode: "plan" };
+  return out;
+}
+
+// src/plugin/model-v2.ts
+var PROVIDER_ID = "cursor";
+var NPM_PACKAGE = "@stablekernel/opencode-cursor";
+function providerNpm() {
+  return process.env.OPENCODE_CURSOR_PROVIDER_NPM?.trim() || NPM_PACKAGE;
+}
+function buildModelV2Map(items) {
+  const out = {};
+  for (const item of items) {
+    out[item.id] = {
+      id: item.id,
+      providerID: PROVIDER_ID,
+      api: { id: item.id, url: "", npm: providerNpm() },
+      name: item.displayName || item.id,
+      capabilities: {
+        temperature: false,
+        reasoning: modelSupportsReasoning(item),
+        attachment: true,
+        toolcall: true,
+        input: { text: true, audio: false, image: true, video: false, pdf: false },
+        output: { text: true, audio: false, image: false, video: false, pdf: false },
+        interleaved: false
+      },
+      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+      limit: { context: 2e5, output: 32e3 },
+      status: "active",
+      options: {},
+      headers: {},
+      release_date: "",
+      variants: buildModelVariants(item)
+    };
+  }
+  return out;
+}
+
+// src/plugin/mcp-config.ts
+function translateMcpServers(mcp) {
+  const out = {};
+  if (!mcp) return out;
+  for (const [name, entry] of Object.entries(mcp)) {
+    if (!entry || entry.enabled === false) continue;
+    if (entry.type === "local") {
+      const [command, ...args] = entry.command ?? [];
+      if (!command) continue;
+      out[name] = {
+        type: "stdio",
+        command,
+        ...args.length > 0 ? { args } : {},
+        ...entry.environment && Object.keys(entry.environment).length > 0 ? { env: entry.environment } : {}
+      };
+    } else if (entry.type === "remote") {
+      if (!entry.url) continue;
+      out[name] = {
+        type: "http",
+        url: entry.url,
+        ...entry.headers && Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {}
+      };
+    }
+  }
+  return out;
+}
+
+// src/plugin/cursor-tools.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/provider/cloud-agent.ts
+async function runCloudAgent(params) {
+  const { Agent } = await loadCursorSdk();
+  const modelSelection = params.model ? buildModelSelection(params.model, params.thinking ? { thinking: params.thinking } : void 0) : void 0;
+  const mode = params.mode ?? "agent";
+  const createOptions = {
+    apiKey: params.apiKey,
+    ...modelSelection ? { model: modelSelection } : {},
+    mode,
+    cloud: {
+      repos: [
+        {
+          url: params.repoUrl,
+          ...params.startingRef ? { startingRef: params.startingRef } : {}
+        }
+      ],
+      ...params.autoCreatePR !== void 0 ? { autoCreatePR: params.autoCreatePR } : {},
+      ...params.workOnCurrentBranch !== void 0 ? { workOnCurrentBranch: params.workOnCurrentBranch } : {}
+    }
+  };
+  const progress = [];
+  const agent = await Agent.create(createOptions);
+  const onDelta = ({ update }) => {
+    if (update.type === "summary") progress.push(`summary: ${update.summary}`);
+  };
+  const onStep = ({ step }) => {
+    progress.push(`step: ${describeStep(step)}`);
+  };
+  try {
+    const run = await agent.send(params.prompt, { mode, onDelta, onStep });
+    const off = run.onDidChangeStatus?.((status) => {
+      progress.push(`status: ${status}`);
+    });
+    const onAbort = () => {
+      run.cancel().catch(() => {
+      });
+    };
+    params.abortSignal?.addEventListener("abort", onAbort);
+    try {
+      const result = await run.wait();
+      const branches = (result.git?.branches ?? []).map((b) => ({
+        repoUrl: b.repoUrl,
+        ...b.branch ? { branch: b.branch } : {},
+        ...b.prUrl ? { prUrl: b.prUrl } : {}
+      }));
+      const prUrl = branches.find((b) => b.prUrl)?.prUrl;
+      return {
+        agentId: agent.agentId,
+        status: result.status,
+        ...result.result !== void 0 ? { result: result.result } : {},
+        ...prUrl ? { prUrl } : {},
+        branches,
+        ...result.durationMs !== void 0 ? { durationMs: result.durationMs } : {},
+        progress
+      };
+    } finally {
+      off?.();
+      params.abortSignal?.removeEventListener("abort", onAbort);
+    }
+  } finally {
+    try {
+      agent.close();
+    } catch {
+    }
+  }
+}
+function describeStep(step) {
+  if (step.type === "toolCall") return `toolCall:${step.message.type}`;
+  return step.type;
+}
+
+// src/provider/delegate.ts
+async function runDelegate(params) {
+  const { mode, modelSelection } = resolveControls(
+    params.model,
+    {
+      mode: params.mode ?? "agent",
+      ...params.thinking ? { params: { thinking: params.thinking } } : {}
+    },
+    void 0
+  );
+  const acquired = await acquireAgent({
+    apiKey: params.apiKey,
+    modelSelection,
+    mode,
+    cwd: params.cwd,
+    ...params.sandbox !== void 0 ? { sandbox: params.sandbox } : {},
+    ...params.agentId ? { agentId: params.agentId } : {},
+    session: false
+  });
+  const text = [];
+  const reasoning = [];
+  const toolActivity = [];
+  let usage;
+  try {
+    for await (const event of streamAgentTurn(
+      acquired.agent,
+      { text: params.prompt },
+      { mode, ...params.abortSignal ? { abortSignal: params.abortSignal } : {} }
+    )) {
+      switch (event.type) {
+        case "text-delta":
+          text.push(event.text);
+          break;
+        case "reasoning-delta":
+          reasoning.push(event.text);
+          break;
+        case "tool-call":
+          toolActivity.push({ name: event.name, isError: false });
+          break;
+        case "tool-result":
+          if (event.isError) toolActivity.push({ name: event.name, isError: true });
+          break;
+        case "usage":
+          usage = event.usage;
+          break;
+        case "finish":
+          if (event.text && text.length === 0) text.push(event.text);
+          break;
+      }
+    }
+  } finally {
+    acquired.release();
+  }
+  return {
+    agentId: acquired.agent.agentId,
+    text: text.join(""),
+    reasoning: reasoning.join(""),
+    toolActivity,
+    ...usage ? { usage } : {}
+  };
+}
+
+// src/plugin/cursor-tools.ts
+var s = tool.schema;
+var NEEDS_AUTH = "No Cursor API key available. Run `opencode auth login` and choose Cursor, or set CURSOR_API_KEY.";
+async function requestApproval(context, permission, patterns, metadata) {
+  try {
+    await context.ask({ permission, patterns, always: patterns, metadata });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function buildCursorTools(deps) {
+  return {
+    cursor_cloud_agent: tool({
+      description: "Launch a Cursor background ('cloud') agent on a remote repository. Runs autonomously (may take minutes) and can open a pull request. Returns the cloud agent id, final status, result, and PR url when available.",
+      args: {
+        prompt: s.string().describe("The task/instruction for the background agent."),
+        repoUrl: s.string().describe("Target repository URL, e.g. https://github.com/owner/repo."),
+        startingRef: s.string().optional().describe("Branch or ref to start from (defaults to the repo default branch)."),
+        model: s.string().optional().describe("Cursor model id (optional for cloud)."),
+        mode: s.enum(["agent", "plan"]).optional().describe("Conversation mode."),
+        thinking: s.string().optional().describe("Thinking level, e.g. 'high'."),
+        autoCreatePR: s.boolean().optional().describe("Open a pull request automatically when finished."),
+        workOnCurrentBranch: s.boolean().optional().describe("Operate on the current branch instead of creating a new one.")
+      },
+      execute: async (args, context) => {
+        const apiKey = deps.resolveApiKey();
+        if (!apiKey) return NEEDS_AUTH;
+        const approval = await requestApproval(
+          context,
+          "cursor_cloud_agent",
+          [args.repoUrl],
+          { repoUrl: args.repoUrl, autoCreatePR: args.autoCreatePR ?? false }
+        );
+        if (!approval.ok) {
+          return `Cloud agent not approved for ${args.repoUrl}${approval.reason ? `: ${approval.reason}` : "."}`;
+        }
+        let result;
+        try {
+          result = await runCloudAgent({
+            apiKey,
+            prompt: args.prompt,
+            repoUrl: args.repoUrl,
+            ...args.startingRef ? { startingRef: args.startingRef } : {},
+            ...args.model ? { model: args.model } : {},
+            ...args.mode ? { mode: args.mode } : {},
+            ...args.thinking ? { thinking: args.thinking } : {},
+            ...args.autoCreatePR !== void 0 ? { autoCreatePR: args.autoCreatePR } : {},
+            ...args.workOnCurrentBranch !== void 0 ? { workOnCurrentBranch: args.workOnCurrentBranch } : {},
+            abortSignal: context.abort
+          });
+        } catch (err) {
+          return `Cloud agent failed: ${errorMessage(err)}`;
+        }
+        const lines = [
+          `Cloud agent ${result.agentId} \u2014 ${result.status}`,
+          ...result.prUrl ? [`PR: ${result.prUrl}`] : [],
+          ...result.branches.length > 0 ? [`Branches: ${result.branches.map((b) => b.branch ?? b.repoUrl).join(", ")}`] : [],
+          ...result.result ? ["", result.result] : [],
+          ...result.progress.length > 0 ? ["", "Progress:", ...result.progress] : []
+        ];
+        return {
+          title: `Cursor cloud agent (${result.status})`,
+          output: lines.join("\n"),
+          metadata: {
+            agentId: result.agentId,
+            status: result.status,
+            prUrl: result.prUrl ?? null,
+            durationMs: result.durationMs ?? null
+          }
+        };
+      }
+    }),
+    cursor_delegate: tool({
+      description: "Delegate a single subtask to a local Cursor agent and return its result. Use to hand off discrete work to Cursor while keeping your primary model in control. Permission-gated.",
+      args: {
+        prompt: s.string().describe("The subtask to delegate to Cursor."),
+        model: s.string().describe("Cursor model id to run the delegation on."),
+        mode: s.enum(["agent", "plan"]).optional().describe("Conversation mode."),
+        thinking: s.string().optional().describe("Thinking level, e.g. 'high'."),
+        cwd: s.string().optional().describe("Working directory (defaults to the session directory)."),
+        sandbox: s.boolean().optional().describe("Run the agent's tools in Cursor's sandbox."),
+        agentId: s.string().optional().describe("Resume a specific Cursor agent id instead of starting fresh.")
+      },
+      execute: async (args, context) => {
+        const apiKey = deps.resolveApiKey();
+        if (!apiKey) return NEEDS_AUTH;
+        const approval = await requestApproval(context, "cursor_delegate", [args.model], {
+          model: args.model,
+          prompt: args.prompt
+        });
+        if (!approval.ok) {
+          return `Delegation to ${args.model} not approved${approval.reason ? `: ${approval.reason}` : "."}`;
+        }
+        let result;
+        try {
+          result = await runDelegate({
+            apiKey,
+            prompt: args.prompt,
+            model: args.model,
+            cwd: args.cwd ?? context.directory ?? deps.defaultCwd(),
+            ...args.mode ? { mode: args.mode } : {},
+            ...args.thinking ? { thinking: args.thinking } : {},
+            ...args.sandbox !== void 0 ? { sandbox: args.sandbox } : {},
+            ...args.agentId ? { agentId: args.agentId } : {},
+            abortSignal: context.abort
+          });
+        } catch (err) {
+          return `Delegation failed: ${errorMessage(err)}`;
+        }
+        const toolNote = result.toolActivity.length > 0 ? `
+
+(${result.toolActivity.length} tool call(s)${result.toolActivity.some((t) => t.isError) ? ", some failed" : ""})` : "";
+        return {
+          title: `Cursor delegate (${args.model})`,
+          output: (result.text || "(no text output)") + toolNote,
+          metadata: {
+            agentId: result.agentId,
+            model: args.model,
+            toolCalls: result.toolActivity.length,
+            usage: result.usage ?? null
+          }
+        };
+      }
+    })
+  };
+}
+
+// src/plugin/index.ts
+function apiKeyFromAuth(auth) {
+  return auth?.type === "api" ? auth.key : void 0;
+}
+var CursorPlugin = async (input) => {
+  let capturedApiKey;
+  return {
+    auth: {
+      provider: PROVIDER_ID,
+      loader: async (getAuth) => {
+        const apiKey = resolveCursorApiKey(apiKeyFromAuth(await getAuth().catch(() => void 0)));
+        if (apiKey) {
+          capturedApiKey = apiKey;
+          void discoverModels({ apiKey });
+        }
+        return apiKey ? { apiKey } : {};
+      },
+      // A single API-key method. opencode always shows its built-in "Enter your
+      // API key" prompt for `type: "api"`, so we intentionally do NOT declare
+      // custom `prompts` (that asks for the key a second time) or an `authorize`
+      // callback. opencode only passes `authorize` the *custom-prompt* inputs —
+      // never the built-in key — so validating the key in `authorize` would
+      // force that redundant extra prompt. Instead the key is validated on first
+      // use (model discovery / the first call both surface a bad key clearly).
+      methods: [{ type: "api", label: "Cursor API Key" }]
+    },
+    config: async (config) => {
+      const { models } = await discoverModels({});
+      config.provider ??= {};
+      const existing = config.provider[PROVIDER_ID] ?? {};
+      const existingOptions = existing.options ?? {};
+      const forwardMcp = existingOptions["forwardMcp"] !== false;
+      const userMcp = existingOptions["mcpServers"] ?? {};
+      const mcpServers = forwardMcp ? { ...userMcp, ...translateMcpServers(config.mcp) } : userMcp;
+      config.provider[PROVIDER_ID] = {
+        name: "Cursor",
+        npm: providerNpm(),
+        ...existing,
+        options: {
+          ...existingOptions,
+          ...Object.keys(mcpServers).length > 0 ? { mcpServers } : {}
+        },
+        models: { ...toOpencodeModels(models), ...existing.models ?? {} }
+      };
+    },
+    provider: {
+      id: PROVIDER_ID,
+      models: async (_provider, ctx) => {
+        const apiKey = apiKeyFromAuth(ctx.auth);
+        const { models } = await discoverModels({ apiKey });
+        return buildModelV2Map(models);
+      }
+    },
+    // Bridge opencode's session id to the provider: it lands in
+    // providerOptions.cursor.sessionID, which the provider reads to pool/resume a
+    // Cursor agent per session (when the `session` option is enabled).
+    "chat.params": async (input2, output) => {
+      if (input2.model?.providerID !== PROVIDER_ID) return;
+      output.options = { ...output.options ?? {}, sessionID: input2.sessionID };
+    },
+    tool: {
+      cursor_refresh_models: {
+        description: "Refresh the live Cursor model catalog (bypasses the 24h cache) and report the available models.",
+        args: {},
+        execute: async () => {
+          const result = await discoverModels({ forceRefresh: true });
+          const lines = result.models.map((m) => `- ${m.id} \u2014 ${m.displayName}`);
+          const header = result.source === "live" ? `Refreshed ${result.models.length} Cursor models (live):` : `Could not fetch live models (${result.source}). ${result.warning ?? ""}`.trim();
+          return {
+            title: `Cursor models (${result.source})`,
+            output: [header, ...lines].join("\n"),
+            metadata: { source: result.source, count: result.models.length }
+          };
+        }
+      },
+      // Delegation tools that complement the provider: a cloud/background agent
+      // and a permission-gated local delegate. They resolve the Cursor key from
+      // the auth loader (captured above) or CURSOR_API_KEY.
+      ...buildCursorTools({
+        resolveApiKey: () => resolveCursorApiKey(capturedApiKey),
+        defaultCwd: () => input?.directory ?? process.cwd()
+      })
+    }
+  };
+};
+var plugin_default = CursorPlugin;
+export {
+  CursorPlugin,
+  plugin_default as default
+};
+//# sourceMappingURL=index.js.map