cursor-oauth-opencode 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,12 +1,50 @@
 import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
-import { getCursorModels } from "./models";
-import { startProxy } from "./proxy";
+import { getCachedCursorModels, getCursorModels } from "./models";
+import { startProxy, updateProxyModels } from "./proxy";
 const CURSOR_PROVIDER_ID = "cursor";
 /**
  * OpenCode plugin that provides Cursor authentication and model access.
  * Register in opencode.json: { "plugin": ["cursor-oauth-opencode"] }
  */
 export const CursorAuthPlugin = async (input) => {
+    async function persistRefreshedAuth(refreshed) {
+        await input.client.auth.set({
+            path: { id: CURSOR_PROVIDER_ID },
+            body: {
+                type: "oauth",
+                refresh: refreshed.refresh,
+                access: refreshed.access,
+                expires: refreshed.expires,
+            },
+        });
+    }
+    async function refreshCursorTokenWithTimeout(refreshToken, timeoutMs) {
+        let timeout;
+        try {
+            return await Promise.race([
+                refreshCursorToken(refreshToken),
+                new Promise((_, reject) => {
+                    timeout = setTimeout(() => reject(new Error("Cursor token refresh timed out")), timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    }
+    function refreshModelsInBackground(provider, port, accessToken) {
+        if (!accessToken)
+            return;
+        void getCursorModels(accessToken, { timeoutMs: 2_000 })
+            .then((models) => {
+            updateProxyModels(models);
+            if (provider) {
+                provider.models = buildCursorProviderModels(models, port);
+            }
+        })
+            .catch(() => { });
+    }
     return {
         auth: {
             provider: CURSOR_PROVIDER_ID,
@@ -14,22 +52,8 @@ export const CursorAuthPlugin = async (input) => {
                 const auth = await getAuth();
                 if (!auth || auth.type !== "oauth")
                     return {};
-                // Ensure we have a valid access token, refreshing if expired
-                let accessToken = auth.access;
-                if (!accessToken || auth.expires < Date.now()) {
-                    const refreshed = await refreshCursorToken(auth.refresh);
-                    await input.client.auth.set({
-                        path: { id: CURSOR_PROVIDER_ID },
-                        body: {
-                            type: "oauth",
-                            refresh: refreshed.refresh,
-                            access: refreshed.access,
-                            expires: refreshed.expires,
-                        },
-                    });
-                    accessToken = refreshed.access;
-                }
-                const models = await getCursorModels(accessToken);
+                const accessToken = auth.access;
+                const models = getCachedCursorModels(accessToken);
                 const port = await startProxy(async () => {
                     const currentAuth = await getAuth();
                     if (currentAuth.type !== "oauth") {
@@ -37,15 +61,7 @@ export const CursorAuthPlugin = async (input) => {
                     }
                     if (!currentAuth.access || currentAuth.expires < Date.now()) {
                         const refreshed = await refreshCursorToken(currentAuth.refresh);
-                        await input.client.auth.set({
-                            path: { id: CURSOR_PROVIDER_ID },
-                            body: {
-                                type: "oauth",
-                                refresh: refreshed.refresh,
-                                access: refreshed.access,
-                                expires: refreshed.expires,
-                            },
-                        });
+                        await persistRefreshedAuth(refreshed);
                         return refreshed.access;
                     }
                     return currentAuth.access;
@@ -53,6 +69,17 @@ export const CursorAuthPlugin = async (input) => {
                 if (provider) {
                     provider.models = buildCursorProviderModels(models, port);
                 }
+                if (accessToken && auth.expires >= Date.now()) {
+                    refreshModelsInBackground(provider, port, accessToken);
+                }
+                else if (auth.refresh) {
+                    void refreshCursorTokenWithTimeout(auth.refresh, 1_500)
+                        .then(async (refreshed) => {
+                        await persistRefreshedAuth(refreshed);
+                        refreshModelsInBackground(provider, port, refreshed.access);
+                    })
+                        .catch(() => { });
+                }
                 return {
                     baseURL: `http://localhost:${port}/v1`,
                     apiKey: "cursor-proxy",

package/dist/models.d.ts

@@ -5,6 +5,10 @@ export interface CursorModel {
     contextWindow: number;
     maxTokens: number;
 }
-export declare function getCursorModels(apiKey: string): Promise<CursorModel[]>;
+export declare function getCachedCursorModels(apiKey?: string): CursorModel[];
+export declare function getCursorModels(apiKey: string, options?: {
+    timeoutMs?: number;
+    allowStale?: boolean;
+}): Promise<CursorModel[]>;
 /** @internal Test-only. */
 export declare function clearModelCache(): void;

package/dist/models.js

@@ -4,12 +4,15 @@
  * when discovery fails.
  */
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import { callCursorUnaryRpc } from "./proxy";
 import { GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, } from "./proto/agent_pb";
 const GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const DEFAULT_MAX_TOKENS = 64_000;
+const MODEL_CACHE_TTL_MS = 10 * 60_000;
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 2_000;
 const CursorModelDetailsSchema = z.object({
     modelId: z.string(),
     displayName: z.string().optional().catch(undefined),
@@ -40,7 +43,7 @@ const FALLBACK_MODELS = [
     { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro", reasoning: true, contextWindow: 1_000_000, maxTokens: 64_000 },
     { id: "grok-code-fast-1", name: "Grok Code Fast 1", reasoning: false, contextWindow: 128_000, maxTokens: 64_000 },
 ];
-async function fetchCursorUsableModels(apiKey) {
+async function fetchCursorUsableModels(apiKey, timeoutMs = DEFAULT_DISCOVERY_TIMEOUT_MS) {
     try {
         const requestPayload = create(GetUsableModelsRequestSchema, {});
         const requestBody = toBinary(GetUsableModelsRequestSchema, requestPayload);
@@ -48,6 +51,7 @@ async function fetchCursorUsableModels(apiKey) {
             accessToken: apiKey,
             rpcPath: GET_USABLE_MODELS_PATH,
             requestBody,
+            timeoutMs,
         });
         if (response.timedOut || response.exitCode !== 0 || response.body.length === 0) {
             return null;
@@ -63,16 +67,60 @@ async function fetchCursorUsableModels(apiKey) {
     }
 }
 let cachedModels = null;
-export async function getCursorModels(apiKey) {
-    if (cachedModels)
+let cachedModelKey = "";
+let cachedModelTime = 0;
+let inFlightModelKey = "";
+let inFlightModels = null;
+function modelCacheKey(apiKey) {
+    return createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
+}
+function isCacheFresh(cacheKey, now = Date.now()) {
+    return Boolean(cachedModels && cachedModelKey === cacheKey && now - cachedModelTime < MODEL_CACHE_TTL_MS);
+}
+export function getCachedCursorModels(apiKey) {
+    if (!apiKey)
+        return FALLBACK_MODELS;
+    const cacheKey = modelCacheKey(apiKey);
+    if (cachedModels && cachedModelKey === cacheKey)
+        return cachedModels;
+    return FALLBACK_MODELS;
+}
+export async function getCursorModels(apiKey, options = {}) {
+    const cacheKey = modelCacheKey(apiKey);
+    if (isCacheFresh(cacheKey))
+        return cachedModels;
+    if (inFlightModels && inFlightModelKey === cacheKey)
+        return inFlightModels;
+    inFlightModelKey = cacheKey;
+    inFlightModels = (async () => {
+        try {
+            const discovered = await fetchCursorUsableModels(apiKey, options.timeoutMs);
+            cachedModels = discovered && discovered.length > 0 ? discovered : FALLBACK_MODELS;
+            cachedModelKey = cacheKey;
+            cachedModelTime = Date.now();
+        }
+        catch {
+            if (!(options.allowStale ?? true) || cachedModelKey !== cacheKey || !cachedModels) {
+                cachedModels = FALLBACK_MODELS;
+                cachedModelKey = cacheKey;
+                cachedModelTime = Date.now();
+            }
+        }
+        finally {
+            inFlightModelKey = "";
+            inFlightModels = null;
+        }
         return cachedModels;
-    const discovered = await fetchCursorUsableModels(apiKey);
-    cachedModels = discovered && discovered.length > 0 ? discovered : FALLBACK_MODELS;
-    return cachedModels;
+    })();
+    return inFlightModels;
 }
 /** @internal Test-only. */
 export function clearModelCache() {
     cachedModels = null;
+    cachedModelKey = "";
+    cachedModelTime = 0;
+    inFlightModelKey = "";
+    inFlightModels = null;
 }
 function decodeGetUsableModelsResponse(payload) {
     try {

package/dist/proxy.d.ts

@@ -11,9 +11,17 @@ export declare function callCursorUnaryRpc(options: CursorUnaryRpcOptions): Prom
     timedOut: boolean;
 }>;
 export declare function getProxyPort(): number | undefined;
+export declare function updateProxyModels(models: ReadonlyArray<{
+    id: string;
+    name: string;
+}>): void;
 export declare function startProxy(getAccessToken: () => Promise<string>, models?: ReadonlyArray<{
     id: string;
     name: string;
 }>): Promise<number>;
 export declare function stopProxy(): void;
+declare function normalizeMcpArgsForOpenCode(toolName: string, args: Record<string, unknown>): Record<string, unknown>;
+export declare const __test: {
+    normalizeMcpArgsForOpenCode: typeof normalizeMcpArgsForOpenCode;
+};
 export {};

package/dist/proxy.js

@@ -170,6 +170,7 @@ export async function callCursorUnaryRpc(options) {
 }
 let proxyServer;
 let proxyPort;
+let proxyStartPromise;
 let proxyAccessTokenProvider;
 let proxyModels = [];
 function buildOpenAIModelList(models) {
@@ -183,14 +184,25 @@ function buildOpenAIModelList(models) {
 export function getProxyPort() {
     return proxyPort;
 }
-export async function startProxy(getAccessToken, models = []) {
-    proxyAccessTokenProvider = getAccessToken;
+export function updateProxyModels(models) {
     proxyModels = models.map((model) => ({
         id: model.id,
         name: model.name,
     }));
+}
+export async function startProxy(getAccessToken, models = []) {
+    proxyAccessTokenProvider = getAccessToken;
+    updateProxyModels(models);
     if (proxyServer && proxyPort)
         return proxyPort;
+    if (proxyStartPromise)
+        return proxyStartPromise;
+    proxyStartPromise = startProxyInner().finally(() => {
+        proxyStartPromise = undefined;
+    });
+    return proxyStartPromise;
+}
+async function startProxyInner() {
     proxyServer = Bun.serve({
         port: 0,
         idleTimeout: 255, // max — Cursor responses can take 30s+
@@ -231,6 +243,7 @@ export function stopProxy() {
         proxyServer.stop();
         proxyServer = undefined;
         proxyPort = undefined;
+        proxyStartPromise = undefined;
         proxyAccessTokenProvider = undefined;
         proxyModels = [];
     }
@@ -392,6 +405,14 @@ function decodeMcpArgsMap(args) {
     }
     return decoded;
 }
+function normalizeMcpArgsForOpenCode(toolName, args) {
+    if (toolName !== "read" || typeof args.filePath === "string")
+        return args;
+    if (typeof args.path !== "string")
+        return args;
+    const { path, ...rest } = args;
+    return { ...rest, filePath: path };
+}
 function blobKey(blobId) {
     return Buffer.from(blobId).toString("hex");
 }
@@ -731,12 +752,13 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec) {
     }
     if (execCase === "mcpArgs") {
         const mcpArgs = execMsg.message.value;
-        const decoded = decodeMcpArgsMap(mcpArgs.args ?? {});
+        const toolName = mcpArgs.toolName || mcpArgs.name;
+        const decoded = normalizeMcpArgsForOpenCode(toolName, decodeMcpArgsMap(mcpArgs.args ?? {}));
         onMcpExec({
             execId: execMsg.execId,
             execMsgId: execMsg.id,
             toolCallId: mcpArgs.toolCallId || crypto.randomUUID(),
-            toolName: mcpArgs.toolName || mcpArgs.name,
+            toolName,
             decodedArgs: JSON.stringify(decoded),
         });
         return;
@@ -851,6 +873,9 @@ function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec) {
     // Unknown exec type — log and ignore
     console.error(`[proxy] unhandled exec: ${execCase}`);
 }
+export const __test = {
+    normalizeMcpArgsForOpenCode,
+};
 /** Send an exec client message back to Cursor. */
 function sendExecResult(execMsg, messageCase, value, sendFrame) {
     const execClientMessage = create(ExecClientMessageSchema, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-oauth-opencode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/copy-runtime.mjs && bun build ./bin/setup.ts --target=node --format=esm --outfile=bin/setup.js --external=jsonc-parser",
+    "bench": "bun scripts/bench.ts",
     "test": "bun test/smoke.ts",
     "prepack": "npm run build",
     "prepublishOnly": "npm run build"