cursor-oauth-opencode 0.1.1

package/README.md

@@ -0,0 +1,126 @@
+# cursor-oauth-opencode
+
+OpenCode plugin that connects to Cursor's API, giving you access to Cursor
+models inside OpenCode with full tool-calling support.
+
+## Install
+
+```sh
+npx cursor-oauth-opencode setup --global
+opencode auth login --provider cursor
+```
+
+For project-local setup:
+
+```sh
+npx cursor-oauth-opencode setup --project
+opencode auth login --provider cursor
+```
+
+The setup command is idempotent. It adds the npm plugin entry and a fallback
+`provider.cursor` model registry to `opencode.json`, preserving existing user
+model overrides.
+
+## Manual config
+
+If you do not want to use the setup command, add this to
+`~/.config/opencode/opencode.json`:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "cursor-oauth-opencode@latest"
+  ],
+  "provider": {
+    "cursor": {
+      "name": "Cursor",
+      "npm": "@ai-sdk/openai-compatible",
+      "api": "http://127.0.0.1:65535/v1",
+      "models": {
+        "composer-2-fast": {
+          "name": "Composer 2 Fast",
+          "reasoning": true,
+          "temperature": true,
+          "attachment": false,
+          "tool_call": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+The fallback API URL is only a placeholder so OpenCode can list the provider
+before login. After auth, the plugin starts a local proxy and replaces Cursor
+models with live Cursor model discovery.
+
+## Authenticate
+
+```sh
+opencode auth login --provider cursor
+```
+
+This opens Cursor OAuth in the browser. Tokens are stored in
+`~/.local/share/opencode/auth.json` and refreshed automatically.
+
+## Use
+
+Start OpenCode and select any Cursor model. The plugin starts a local
+OpenAI-compatible proxy on demand and routes requests through Cursor's gRPC API.
+
+## How it works
+
+1. OAuth — browser-based login to Cursor via PKCE.
+2. Model discovery — queries Cursor's gRPC API for all available models.
+3. Local proxy — translates `POST /v1/chat/completions` into Cursor's
+   protobuf/HTTP/2 Connect protocol.
+4. Native tool routing — rejects Cursor's built-in filesystem/shell tools and
+   exposes OpenCode's tool surface via Cursor MCP instead.
+
+HTTP/2 transport runs through a Node child process (`h2-bridge.mjs`) because
+Bun's `node:http2` support is not reliable against Cursor's API.
+
+## Architecture
+
+```
+OpenCode  -->  /v1/chat/completions  -->  Bun.serve (proxy)
+                                              |
+                                    Node child process (h2-bridge.mjs)
+                                              |
+                                     HTTP/2 Connect stream
+                                              |
+                                    api2.cursor.sh gRPC
+                                      /agent.v1.AgentService/Run
+```
+
+### Tool call flow
+
+```
+1. Cursor model receives OpenAI tools via RequestContext (as MCP tool defs)
+2. Model tries native tools (readArgs, shellArgs, etc.)
+3. Proxy rejects each with typed error (ReadRejected, ShellRejected, etc.)
+4. Model falls back to MCP tool -> mcpArgs exec message
+5. Proxy emits OpenAI tool_calls SSE chunk, pauses H2 stream
+6. OpenCode executes tool, sends result in follow-up request
+7. Proxy resumes H2 stream with mcpResult, streams continuation
+```
+
+## Develop locally
+
+```sh
+bun install
+bun run build
+bun test/smoke.ts
+```
+
+## Requirements
+
+- [OpenCode](https://opencode.ai)
+- [Bun](https://bun.sh)
+- [Node.js](https://nodejs.org) >= 18 for the HTTP/2 bridge process
+- Active [Cursor](https://cursor.com) subscription

package/bin/setup.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+// bin/setup.ts
+import { realpathSync } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { applyEdits, format, modify, parse } from "jsonc-parser";
+var DEFAULT_PLUGIN_SPEC = "cursor-oauth-opencode@latest";
+var PACKAGE_NAME = "cursor-oauth-opencode";
+var SCHEMA = "https://opencode.ai/config.json";
+var PROVIDER_ID = "cursor";
+var PROVIDER_API = "http://127.0.0.1:65535/v1";
+var PROVIDER_NPM = "@ai-sdk/openai-compatible";
+var CURSOR_MODELS = {
+  "composer-2-fast": {
+    name: "Composer 2 Fast",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, output: 64000 }
+  },
+  "composer-2": {
+    name: "Composer 2",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, output: 64000 }
+  },
+  "claude-4.6-sonnet": {
+    name: "Claude 4.6 Sonnet",
+    reasoning: true,
+    temperature: true,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 200000, output: 64000 }
+  },
+  "gpt-5.3-codex": {
+    name: "GPT-5.3 Codex",
+    reasoning: true,
+    temperature: false,
+    attachment: false,
+    tool_call: true,
+    limit: { context: 400000, output: 128000 }
+  }
+};
+function globalConfigPath() {
+  const configHome = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(configHome, "opencode", "opencode.json");
+}
+function projectConfigPath(cwd) {
+  return path.join(cwd, "opencode.json");
+}
+function targetPath(options) {
+  if (options.configPath)
+    return path.resolve(options.configPath);
+  if (options.mode === "project")
+    return projectConfigPath(options.cwd ?? process.cwd());
+  return globalConfigPath();
+}
+function applyJsonPatch(text, jsonPath, value) {
+  return applyEdits(text, modify(text, jsonPath, value, {
+    formattingOptions: { insertSpaces: true, tabSize: 2, eol: `
+` }
+  }));
+}
+function pluginPackageName(specifier) {
+  const normalized = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
+  if (normalized.startsWith("file://")) {
+    return path.basename(new URL(normalized).pathname).replace(/\.[cm]?[jt]s$/, "");
+  }
+  const lastAt = normalized.lastIndexOf("@");
+  return lastAt > 0 ? normalized.slice(0, lastAt) : normalized;
+}
+function patchConfigText(input, pluginSpec = DEFAULT_PLUGIN_SPEC) {
+  let text = input.trim() ? input : "{}";
+  const initial = parse(text) ?? {};
+  if (!initial.$schema)
+    text = applyJsonPatch(text, ["$schema"], SCHEMA);
+  const currentPlugins = (parse(text) ?? {}).plugin;
+  const plugins = Array.isArray(currentPlugins) ? [...currentPlugins] : [];
+  if (!plugins.some((plugin) => typeof plugin === "string" && pluginPackageName(plugin) === PACKAGE_NAME)) {
+    plugins.push(pluginSpec);
+  }
+  text = applyJsonPatch(text, ["plugin"], plugins);
+  const next = parse(text) ?? {};
+  const existingProvider = next.provider?.[PROVIDER_ID] ?? {};
+  const existingModels = existingProvider.models ?? {};
+  text = applyJsonPatch(text, ["provider", PROVIDER_ID], {
+    ...existingProvider,
+    name: existingProvider.name ?? "Cursor",
+    npm: existingProvider.npm ?? PROVIDER_NPM,
+    api: existingProvider.api ?? PROVIDER_API,
+    models: {
+      ...CURSOR_MODELS,
+      ...existingModels
+    }
+  });
+  return applyEdits(text, format(text, undefined, {
+    insertSpaces: true,
+    tabSize: 2,
+    eol: `
+`
+  }));
+}
+async function setupOpenCodeConfig(options = {}) {
+  const file = targetPath(options);
+  let existing = "";
+  try {
+    existing = await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw error;
+  }
+  const updated = patchConfigText(existing, options.pluginSpec ?? DEFAULT_PLUGIN_SPEC);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, updated.endsWith(`
+`) ? updated : `${updated}
+`, "utf8");
+  return file;
+}
+function parseArgs(argv) {
+  const options = { mode: "global" };
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "setup")
+      continue;
+    if (arg === "--project")
+      options.mode = "project";
+    else if (arg === "--global")
+      options.mode = "global";
+    else if (arg === "--path")
+      options.configPath = argv[++index];
+    else if (arg === "--plugin")
+      options.pluginSpec = argv[++index];
+    else if (arg === "--help" || arg === "-h") {
+      console.log("Usage: cursor-oauth-opencode setup [--global|--project] [--path <opencode.json>] [--plugin <specifier>]");
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function isDirectExecution(moduleUrl = import.meta.url, argvPath = process.argv[1]) {
+  if (!argvPath)
+    return false;
+  const modulePath = fileURLToPath(moduleUrl);
+  try {
+    return realpathSync(modulePath) === realpathSync(argvPath);
+  } catch {
+    return path.resolve(modulePath) === path.resolve(argvPath);
+  }
+}
+if (isDirectExecution()) {
+  setupOpenCodeConfig(parseArgs(process.argv.slice(2))).then((file) => {
+    console.log(`Updated OpenCode config: ${file}`);
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  setupOpenCodeConfig,
+  patchConfigText,
+  isDirectExecution
+};

package/dist/auth.d.ts

@@ -0,0 +1,22 @@
+export interface CursorAuthParams {
+    verifier: string;
+    challenge: string;
+    uuid: string;
+    loginUrl: string;
+}
+export interface CursorCredentials {
+    access: string;
+    refresh: string;
+    expires: number;
+}
+export declare function generateCursorAuthParams(): Promise<CursorAuthParams>;
+export declare function pollCursorAuth(uuid: string, verifier: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+}>;
+export declare function refreshCursorToken(refreshToken: string): Promise<CursorCredentials>;
+/**
+ * Extract JWT expiry with 5-minute safety margin.
+ * Falls back to 1 hour from now if token can't be parsed.
+ */
+export declare function getTokenExpiry(token: string): number;

package/dist/auth.js

@@ -0,0 +1,92 @@
+import { generatePKCE } from "./pkce";
+const CURSOR_LOGIN_URL = "https://cursor.com/loginDeepControl";
+const CURSOR_POLL_URL = "https://api2.cursor.sh/auth/poll";
+const CURSOR_REFRESH_URL = process.env.CURSOR_REFRESH_URL ??
+    "https://api2.cursor.sh/auth/exchange_user_api_key";
+const POLL_MAX_ATTEMPTS = 150;
+const POLL_BASE_DELAY = 1000;
+const POLL_MAX_DELAY = 10_000;
+const POLL_BACKOFF_MULTIPLIER = 1.2;
+export async function generateCursorAuthParams() {
+    const { verifier, challenge } = await generatePKCE();
+    const uuid = crypto.randomUUID();
+    const params = new URLSearchParams({
+        challenge,
+        uuid,
+        mode: "login",
+        redirectTarget: "cli",
+    });
+    const loginUrl = `${CURSOR_LOGIN_URL}?${params.toString()}`;
+    return { verifier, challenge, uuid, loginUrl };
+}
+export async function pollCursorAuth(uuid, verifier) {
+    let delay = POLL_BASE_DELAY;
+    let consecutiveErrors = 0;
+    for (let attempt = 0; attempt < POLL_MAX_ATTEMPTS; attempt++) {
+        await Bun.sleep(delay);
+        try {
+            const response = await fetch(`${CURSOR_POLL_URL}?uuid=${uuid}&verifier=${verifier}`);
+            if (response.status === 404) {
+                consecutiveErrors = 0;
+                delay = Math.min(delay * POLL_BACKOFF_MULTIPLIER, POLL_MAX_DELAY);
+                continue;
+            }
+            if (response.ok) {
+                const data = (await response.json());
+                return {
+                    accessToken: data.accessToken,
+                    refreshToken: data.refreshToken,
+                };
+            }
+            throw new Error(`Poll failed: ${response.status}`);
+        }
+        catch {
+            consecutiveErrors++;
+            if (consecutiveErrors >= 3) {
+                throw new Error("Too many consecutive errors during Cursor auth polling");
+            }
+        }
+    }
+    throw new Error("Cursor authentication polling timeout");
+}
+export async function refreshCursorToken(refreshToken) {
+    const response = await fetch(CURSOR_REFRESH_URL, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${refreshToken}`,
+            "Content-Type": "application/json",
+        },
+        body: "{}",
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Cursor token refresh failed: ${error}`);
+    }
+    const data = (await response.json());
+    return {
+        access: data.accessToken,
+        refresh: data.refreshToken || refreshToken,
+        expires: getTokenExpiry(data.accessToken),
+    };
+}
+/**
+ * Extract JWT expiry with 5-minute safety margin.
+ * Falls back to 1 hour from now if token can't be parsed.
+ */
+export function getTokenExpiry(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3 || !parts[1]) {
+            return Date.now() + 3600 * 1000;
+        }
+        const decoded = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
+        if (decoded &&
+            typeof decoded === "object" &&
+            typeof decoded.exp === "number") {
+            return decoded.exp * 1000 - 5 * 60 * 1000;
+        }
+    }
+    catch {
+    }
+    return Date.now() + 3600 * 1000;
+}

package/dist/h2-bridge.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Dumb HTTP/2 bidirectional pipe for Cursor gRPC.
+ *
+ * Bun's node:http2 is broken. This Node script acts as a transparent
+ * HTTP/2 proxy: it opens a single bidirectional stream and ferries
+ * raw bytes between the parent process (via stdin/stdout) and Cursor.
+ *
+ * Protocol (length-prefixed framing over stdin/stdout):
+ *   [4 bytes big-endian length][payload]
+ *
+ * First message on stdin is JSON config:
+ *   { "accessToken": "...", "url": "...", "path": "...", "unary": false }
+ *
+ * When unary=true, the bridge uses application/proto (raw protobuf) instead
+ * of application/connect+proto (Connect streaming). The single stdin message
+ * is written as the request body and the stream is ended immediately.
+ * After config, subsequent stdin messages are raw bytes to write to the H2 stream.
+ * H2 response data is written to stdout using the same length-prefixed framing.
+ */
+import http2 from "node:http2";
+import crypto from "node:crypto";
+
+const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+
+/** Write one length-prefixed message to stdout. */
+function writeMessage(data) {
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(data.length, 0);
+  process.stdout.write(lenBuf);
+  process.stdout.write(data);
+}
+
+// --- Buffered stdin reader ---
+
+let stdinBuf = Buffer.alloc(0);
+let stdinResolve = null;
+let stdinEnded = false;
+
+process.stdin.on("data", (chunk) => {
+  stdinBuf = Buffer.concat([stdinBuf, chunk]);
+  if (stdinResolve) {
+    const r = stdinResolve;
+    stdinResolve = null;
+    r();
+  }
+});
+
+process.stdin.on("end", () => {
+  stdinEnded = true;
+  if (stdinResolve) {
+    const r = stdinResolve;
+    stdinResolve = null;
+    r();
+  }
+});
+
+function waitForData() {
+  return new Promise((resolve) => { stdinResolve = resolve; });
+}
+
+async function readExact(n) {
+  while (stdinBuf.length < n) {
+    if (stdinEnded) return null;
+    await waitForData();
+  }
+  const result = stdinBuf.subarray(0, n);
+  stdinBuf = stdinBuf.subarray(n);
+  return Buffer.from(result);
+}
+
+async function readMessage() {
+  const lenBuf = await readExact(4);
+  if (!lenBuf) return null;
+  const len = lenBuf.readUInt32BE(0);
+  if (len === 0) return Buffer.alloc(0);
+  return readExact(len);
+}
+
+// --- Main ---
+
+const configBuf = await readMessage();
+if (!configBuf) process.exit(1);
+
+const config = JSON.parse(configBuf.toString("utf8"));
+const { accessToken, url, path: rpcPath, unary } = config;
+
+const client = http2.connect(url || "https://api2.cursor.sh");
+
+// Guard against initial connection failure. Reset on any h2 activity
+// so long-running agent conversations (with tool call round-trips) survive.
+let timeout = setTimeout(killBridge, 30_000);
+
+function resetTimeout() {
+  clearTimeout(timeout);
+  timeout = setTimeout(killBridge, 120_000);
+}
+
+function killBridge() {
+  clearTimeout(timeout);
+  client.destroy();
+  process.exit(1);
+}
+
+client.on("error", () => {
+  clearTimeout(timeout);
+  process.exit(1);
+});
+
+const headers = {
+  ":method": "POST",
+  ":path": rpcPath || "/agent.v1.AgentService/Run",
+  "content-type": unary ? "application/proto" : "application/connect+proto",
+  te: "trailers",
+  authorization: `Bearer ${accessToken}`,
+  "x-ghost-mode": "true",
+  "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+  "x-cursor-client-type": "cli",
+  "x-request-id": crypto.randomUUID(),
+};
+if (!unary) {
+  headers["connect-protocol-version"] = "1";
+}
+const h2Stream = client.request(headers);
+
+// Forward H2 response data → stdout (length-prefixed)
+h2Stream.on("data", (chunk) => {
+  resetTimeout();
+  writeMessage(chunk);
+});
+
+h2Stream.on("end", () => {
+  clearTimeout(timeout);
+  client.close();
+  // Give stdout time to flush
+  setTimeout(() => process.exit(0), 100);
+});
+
+h2Stream.on("error", () => {
+  clearTimeout(timeout);
+  client.close();
+  process.exit(1);
+});
+
+// Forward stdin → H2 stream (after config message)
+if (unary) {
+  // Unary mode: read a single body message, write it, and end the stream.
+  const body = await readMessage();
+  if (body && body.length > 0 && !h2Stream.closed && !h2Stream.destroyed) {
+    h2Stream.end(body);
+  } else {
+    h2Stream.end();
+  }
+} else {
+  // Streaming mode: forward all stdin messages as Connect frames.
+  (async () => {
+    while (true) {
+      const msg = await readMessage();
+      if (!msg || msg.length === 0) {
+        // EOF or zero-length = done writing
+        break;
+      }
+      if (!h2Stream.closed && !h2Stream.destroyed) {
+        resetTimeout();
+        h2Stream.write(msg);
+      }
+    }
+
+    if (!h2Stream.closed && !h2Stream.destroyed) {
+      h2Stream.end();
+    }
+  })();
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenCode Cursor Auth Plugin
+ *
+ * Enables using Cursor models (Claude, GPT, etc.) inside OpenCode via:
+ * 1. Browser-based OAuth login to Cursor
+ * 2. Local proxy translating OpenAI format → Cursor gRPC protocol
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode plugin that provides Cursor authentication and model access.
+ * Register in opencode.json: { "plugin": ["cursor-oauth-opencode"] }
+ */
+export declare const CursorAuthPlugin: Plugin;
+export default CursorAuthPlugin;