@playwo/opencode-cursor-oauth 0.0.0-dev.a9d6c62f0dd9 → 0.0.0-dev.b8e6dd72a8b6

package/README.md

@@ -44,7 +44,7 @@ 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 and fails plugin loading visibly if discovery does not succeed.
+2. Model discovery — queries Cursor's gRPC API for all available models; if discovery fails, the plugin disables the Cursor provider for that load and shows a visible error toast instead of crashing OpenCode.
 3. Local proxy — translates `POST /v1/chat/completions` into Cursor's
    protobuf/Connect protocol.
 4. Native tool routing — rejects Cursor's built-in filesystem/shell tools and

package/dist/index.js

@@ -1,7 +1,8 @@
 import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
 import { getCursorModels } from "./models";
-import { startProxy } from "./proxy";
+import { startProxy, stopProxy } from "./proxy";
 const CURSOR_PROVIDER_ID = "cursor";
+let lastModelDiscoveryError = null;
 /**
  * OpenCode plugin that provides Cursor authentication and model access.
  * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
@@ -29,7 +30,25 @@ export const CursorAuthPlugin = async (input) => {
                     });
                     accessToken = refreshed.access;
                 }
-                const models = await getCursorModels(accessToken);
+                let models;
+                try {
+                    models = await getCursorModels(accessToken);
+                    lastModelDiscoveryError = null;
+                }
+                catch (error) {
+                    const message = error instanceof Error
+                        ? error.message
+                        : "Cursor model discovery failed.";
+                    stopProxy();
+                    if (provider) {
+                        provider.models = {};
+                    }
+                    if (message !== lastModelDiscoveryError) {
+                        lastModelDiscoveryError = message;
+                        await showDiscoveryFailureToast(input, message);
+                    }
+                    return buildDisabledProviderConfig(message);
+                }
                 const port = await startProxy(async () => {
                     const currentAuth = await getAuth();
                     if (currentAuth.type !== "oauth") {
@@ -145,6 +164,37 @@ function buildCursorProviderModels(models, port) {
         },
     ]));
 }
+async function showDiscoveryFailureToast(input, message) {
+    try {
+        await input.client.tui.showToast({
+            body: {
+                title: "Cursor plugin disabled",
+                message,
+                variant: "error",
+                duration: 8_000,
+            },
+        });
+    }
+    catch { }
+}
+function buildDisabledProviderConfig(message) {
+    return {
+        baseURL: "http://127.0.0.1/cursor-disabled/v1",
+        apiKey: "cursor-disabled",
+        async fetch() {
+            return new Response(JSON.stringify({
+                error: {
+                    message,
+                    type: "server_error",
+                    code: "cursor_model_discovery_failed",
+                },
+            }), {
+                status: 503,
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+    };
+}
 // $/M token rates from cursor.com/docs/models-and-pricing
 const MODEL_COST_TABLE = {
     // Anthropic

package/dist/models.js

@@ -73,10 +73,13 @@ export function clearModelCache() {
 }
 function buildDiscoveryHttpError(exitCode, body) {
     const detail = extractDiscoveryErrorDetail(body);
+    const protocolHint = exitCode === 464
+        ? " Likely protocol mismatch: Cursor appears to expect an HTTP/2 Connect unary request."
+        : "";
     if (!detail) {
-        return `Cursor model discovery failed with HTTP ${exitCode}.`;
+        return `Cursor model discovery failed with HTTP ${exitCode}.${protocolHint}`;
     }
-    return `Cursor model discovery failed with HTTP ${exitCode}: ${detail}`;
+    return `Cursor model discovery failed with HTTP ${exitCode}: ${detail}.${protocolHint}`;
 }
 function extractDiscoveryErrorDetail(body) {
     if (body.length === 0)

package/dist/proxy.d.ts

@@ -4,6 +4,7 @@ interface CursorUnaryRpcOptions {
     requestBody: Uint8Array;
     url?: string;
     timeoutMs?: number;
+    transport?: "auto" | "fetch" | "http2";
 }
 export declare function callCursorUnaryRpc(options: CursorUnaryRpcOptions): Promise<{
     body: Uint8Array;

package/dist/proxy.js

@@ -16,8 +16,10 @@ import { create, fromBinary, fromJson, toBinary, toJson } from "@bufbuild/protob
 import { ValueSchema } from "@bufbuild/protobuf/wkt";
 import { AgentClientMessageSchema, AgentRunRequestSchema, AgentServerMessageSchema, BidiRequestIdSchema, ClientHeartbeatSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolDefinitionSchema, McpToolResultContentItemSchema, ModelDetailsSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, UserMessageActionSchema, UserMessageSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "./proto/agent_pb";
 import { createHash } from "node:crypto";
+import { connect as connectHttp2 } from "node:http2";
 const CURSOR_API_URL = process.env.CURSOR_API_URL ?? "https://api2.cursor.sh";
 const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+const CURSOR_CONNECT_PROTOCOL_VERSION = "1";
 const CONNECT_END_STREAM_FLAG = 0b00000010;
 const SSE_HEADERS = {
     "Content-Type": "text/event-stream",
@@ -47,18 +49,19 @@ function frameConnectMessage(data, flags = 0) {
     return frame;
 }
 function buildCursorHeaders(options, contentType, extra = {}) {
-    const headers = new Headers({
+    const headers = new Headers(buildCursorHeaderValues(options, contentType, extra));
+    return headers;
+}
+function buildCursorHeaderValues(options, contentType, extra = {}) {
+    return {
         authorization: `Bearer ${options.accessToken}`,
         "content-type": contentType,
         "x-ghost-mode": "true",
         "x-cursor-client-version": CURSOR_CLIENT_VERSION,
         "x-cursor-client-type": "cli",
         "x-request-id": crypto.randomUUID(),
-    });
-    for (const [key, value] of Object.entries(extra)) {
-        headers.set(key, value);
-    }
-    return headers;
+        ...extra,
+    };
 }
 function encodeVarint(value) {
     if (!Number.isSafeInteger(value) || value < 0) {
@@ -236,6 +239,17 @@ async function createCursorSession(options) {
     };
 }
 export async function callCursorUnaryRpc(options) {
+    const target = new URL(options.rpcPath, options.url ?? CURSOR_API_URL);
+    const transport = options.transport ?? "auto";
+    if (transport === "http2" || (transport === "auto" && target.protocol === "https:")) {
+        const http2Result = await callCursorUnaryRpcOverHttp2(options, target);
+        if (transport === "http2" || http2Result.timedOut || http2Result.exitCode !== 1) {
+            return http2Result;
+        }
+    }
+    return callCursorUnaryRpcOverFetch(options, target);
+}
+async function callCursorUnaryRpcOverFetch(options, target) {
     let timedOut = false;
     const timeoutMs = options.timeoutMs ?? 5_000;
     const controller = new AbortController();
@@ -246,9 +260,13 @@ export async function callCursorUnaryRpc(options) {
         }, timeoutMs)
         : undefined;
     try {
-        const response = await fetch(new URL(options.rpcPath, options.url ?? CURSOR_API_URL), {
+        const response = await fetch(target, {
             method: "POST",
-            headers: buildCursorHeaders(options, "application/proto"),
+            headers: buildCursorHeaders(options, "application/proto", {
+                accept: "application/proto, application/json",
+                "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
+                "connect-timeout-ms": String(timeoutMs),
+            }),
             body: toFetchBody(options.requestBody),
             signal: controller.signal,
         });
@@ -271,6 +289,96 @@ export async function callCursorUnaryRpc(options) {
             clearTimeout(timeout);
     }
 }
+async function callCursorUnaryRpcOverHttp2(options, target) {
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const authority = `${target.protocol}//${target.host}`;
+    return new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let session;
+        let stream;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            try {
+                stream?.close();
+            }
+            catch { }
+            try {
+                session?.close();
+            }
+            catch { }
+            resolve(result);
+        };
+        const timeout = timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: 124,
+                    timedOut: true,
+                });
+            }, timeoutMs)
+            : undefined;
+        try {
+            session = connectHttp2(authority);
+            session.once("error", () => {
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            const headers = {
+                ":method": "POST",
+                ":path": `${target.pathname}${target.search}`,
+                ...buildCursorHeaderValues(options, "application/proto", {
+                    accept: "application/proto, application/json",
+                    "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
+                    "connect-timeout-ms": String(timeoutMs),
+                }),
+            };
+            stream = session.request(headers);
+            let statusCode = 0;
+            const chunks = [];
+            stream.once("response", (responseHeaders) => {
+                const statusHeader = responseHeaders[":status"];
+                statusCode = typeof statusHeader === "number"
+                    ? statusHeader
+                    : Number(statusHeader ?? 0);
+            });
+            stream.on("data", (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            stream.once("end", () => {
+                const body = new Uint8Array(Buffer.concat(chunks));
+                finish({
+                    body,
+                    exitCode: statusCode >= 200 && statusCode < 300 ? 0 : (statusCode || 1),
+                    timedOut,
+                });
+            });
+            stream.once("error", () => {
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            stream.end(Buffer.from(options.requestBody));
+        }
+        catch {
+            finish({
+                body: new Uint8Array(),
+                exitCode: timedOut ? 124 : 1,
+                timedOut,
+            });
+        }
+    });
+}
 let proxyServer;
 let proxyPort;
 let proxyAccessTokenProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwo/opencode-cursor-oauth",
-  "version": "0.0.0-dev.a9d6c62f0dd9",
+  "version": "0.0.0-dev.b8e6dd72a8b6",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",