@playwo/opencode-cursor-oauth 0.0.0-dev.c80ebcb27754 → 0.0.0-dev.d7836f7ad39f

package/dist/cursor/unary-rpc.js

@@ -0,0 +1,181 @@
+import { connect as connectHttp2, } from "node:http2";
+import { CURSOR_API_URL, CURSOR_CONNECT_PROTOCOL_VERSION } from "./config";
+import { toFetchBody } from "./connect-framing";
+import { buildCursorHeaders, buildCursorHeaderValues } from "./headers";
+import { errorDetails, logPluginError } from "../logger";
+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();
+    const timeout = timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs)
+        : undefined;
+    try {
+        const response = await fetch(target, {
+            method: "POST",
+            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,
+        });
+        const body = new Uint8Array(await response.arrayBuffer());
+        return {
+            body,
+            exitCode: response.ok ? 0 : response.status,
+            timedOut,
+        };
+    }
+    catch {
+        logPluginError("Cursor unary fetch transport failed", {
+            rpcPath: options.rpcPath,
+            url: target.toString(),
+            timeoutMs,
+            timedOut,
+        });
+        return {
+            body: new Uint8Array(),
+            exitCode: timedOut ? 124 : 1,
+            timedOut,
+        };
+    }
+    finally {
+        if (timeout)
+            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", (error) => {
+                logPluginError("Cursor unary HTTP/2 session failed", {
+                    rpcPath: options.rpcPath,
+                    url: target.toString(),
+                    timedOut,
+                    ...errorDetails(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", (error) => {
+                logPluginError("Cursor unary HTTP/2 stream failed", {
+                    rpcPath: options.rpcPath,
+                    url: target.toString(),
+                    timedOut,
+                    ...errorDetails(error),
+                });
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            // Bun's node:http2 client currently breaks on end(Buffer.alloc(0)) against
+            // Cursor's HTTPS endpoint, but a header-only end() succeeds for empty unary bodies.
+            if (options.requestBody.length > 0) {
+                stream.end(Buffer.from(options.requestBody));
+            }
+            else {
+                stream.end();
+            }
+        }
+        catch (error) {
+            logPluginError("Cursor unary HTTP/2 setup failed", {
+                rpcPath: options.rpcPath,
+                url: target.toString(),
+                timedOut,
+                ...errorDetails(error),
+            });
+            finish({
+                body: new Uint8Array(),
+                exitCode: timedOut ? 124 : 1,
+                timedOut,
+            });
+        }
+    });
+}

package/dist/index.d.ts

@@ -1,14 +1,2 @@
-/**
- * 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": ["opencode-cursor-oauth"] }
- */
-export declare const CursorAuthPlugin: Plugin;
-export default CursorAuthPlugin;
+export { CursorAuthPlugin } from "./plugin/cursor-auth-plugin";
+export { CursorAuthPlugin as default } from "./plugin/cursor-auth-plugin";

package/dist/index.js

@@ -1,229 +1,2 @@
-import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
-import { getCursorModels } from "./models";
-import { startProxy } from "./proxy";
-const CURSOR_PROVIDER_ID = "cursor";
-/**
- * OpenCode plugin that provides Cursor authentication and model access.
- * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
- */
-export const CursorAuthPlugin = async (input) => {
-    return {
-        auth: {
-            provider: CURSOR_PROVIDER_ID,
-            async loader(getAuth, provider) {
-                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 port = await startProxy(async () => {
-                    const currentAuth = await getAuth();
-                    if (currentAuth.type !== "oauth") {
-                        throw new Error("Cursor auth not configured");
-                    }
-                    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,
-                            },
-                        });
-                        return refreshed.access;
-                    }
-                    return currentAuth.access;
-                }, models);
-                if (provider) {
-                    provider.models = buildCursorProviderModels(models, port);
-                }
-                return {
-                    baseURL: `http://localhost:${port}/v1`,
-                    apiKey: "cursor-proxy",
-                    async fetch(requestInput, init) {
-                        if (init?.headers) {
-                            if (init.headers instanceof Headers) {
-                                init.headers.delete("authorization");
-                            }
-                            else if (Array.isArray(init.headers)) {
-                                init.headers = init.headers.filter(([key]) => key.toLowerCase() !== "authorization");
-                            }
-                            else {
-                                delete init.headers["authorization"];
-                                delete init.headers["Authorization"];
-                            }
-                        }
-                        return fetch(requestInput, init);
-                    },
-                };
-            },
-            methods: [
-                {
-                    type: "oauth",
-                    label: "Login with Cursor",
-                    async authorize() {
-                        const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
-                        return {
-                            url: loginUrl,
-                            instructions: "Complete login in your browser. This window will close automatically.",
-                            method: "auto",
-                            async callback() {
-                                const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier);
-                                return {
-                                    type: "success",
-                                    refresh: refreshToken,
-                                    access: accessToken,
-                                    expires: getTokenExpiry(accessToken),
-                                };
-                            },
-                        };
-                    },
-                },
-            ],
-        },
-    };
-};
-function buildCursorProviderModels(models, port) {
-    return Object.fromEntries(models.map((model) => [
-        model.id,
-        {
-            id: model.id,
-            providerID: CURSOR_PROVIDER_ID,
-            api: {
-                id: model.id,
-                url: `http://localhost:${port}/v1`,
-                npm: "@ai-sdk/openai-compatible",
-            },
-            name: model.name,
-            capabilities: {
-                temperature: true,
-                reasoning: model.reasoning,
-                attachment: false,
-                toolcall: true,
-                input: {
-                    text: true,
-                    audio: false,
-                    image: false,
-                    video: false,
-                    pdf: false,
-                },
-                output: {
-                    text: true,
-                    audio: false,
-                    image: false,
-                    video: false,
-                    pdf: false,
-                },
-                interleaved: false,
-            },
-            cost: estimateModelCost(model.id),
-            limit: {
-                context: model.contextWindow,
-                output: model.maxTokens,
-            },
-            status: "active",
-            options: {},
-            headers: {},
-            release_date: "",
-            variants: {},
-        },
-    ]));
-}
-// $/M token rates from cursor.com/docs/models-and-pricing
-const MODEL_COST_TABLE = {
-    // Anthropic
-    "claude-4-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    "claude-4-sonnet-1m": { input: 6, output: 22.5, cache: { read: 0.6, write: 7.5 } },
-    "claude-4.5-haiku": { input: 1, output: 5, cache: { read: 0.1, write: 1.25 } },
-    "claude-4.5-opus": { input: 5, output: 25, cache: { read: 0.5, write: 6.25 } },
-    "claude-4.5-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    "claude-4.6-opus": { input: 5, output: 25, cache: { read: 0.5, write: 6.25 } },
-    "claude-4.6-opus-fast": { input: 30, output: 150, cache: { read: 3, write: 37.5 } },
-    "claude-4.6-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    // Cursor
-    "composer-1": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "composer-1.5": { input: 3.5, output: 17.5, cache: { read: 0.35, write: 0 } },
-    "composer-2": { input: 0.5, output: 2.5, cache: { read: 0.2, write: 0 } },
-    "composer-2-fast": { input: 1.5, output: 7.5, cache: { read: 0.2, write: 0 } },
-    // Google
-    "gemini-2.5-flash": { input: 0.3, output: 2.5, cache: { read: 0.03, write: 0 } },
-    "gemini-3-flash": { input: 0.5, output: 3, cache: { read: 0.05, write: 0 } },
-    "gemini-3-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    "gemini-3-pro-image": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    "gemini-3.1-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    // OpenAI
-    "gpt-5": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5-fast": { input: 2.5, output: 20, cache: { read: 0.25, write: 0 } },
-    "gpt-5-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
-    "gpt-5-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex-max": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
-    "gpt-5.2": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.2-codex": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.3-codex": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.4": { input: 2.5, output: 15, cache: { read: 0.25, write: 0 } },
-    "gpt-5.4-mini": { input: 0.75, output: 4.5, cache: { read: 0.075, write: 0 } },
-    "gpt-5.4-nano": { input: 0.2, output: 1.25, cache: { read: 0.02, write: 0 } },
-    // xAI
-    "grok-4.20": { input: 2, output: 6, cache: { read: 0.2, write: 0 } },
-    // Moonshot
-    "kimi-k2.5": { input: 0.6, output: 3, cache: { read: 0.1, write: 0 } },
-};
-// Most-specific first
-const MODEL_COST_PATTERNS = [
-    { match: (id) => /claude.*opus.*fast/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-opus-fast"] },
-    { match: (id) => /claude.*opus/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-opus"] },
-    { match: (id) => /claude.*haiku/i.test(id), cost: MODEL_COST_TABLE["claude-4.5-haiku"] },
-    { match: (id) => /claude.*sonnet/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-sonnet"] },
-    { match: (id) => /claude/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-sonnet"] },
-    { match: (id) => /composer-?2/i.test(id), cost: MODEL_COST_TABLE["composer-2"] },
-    { match: (id) => /composer-?1\.5/i.test(id), cost: MODEL_COST_TABLE["composer-1.5"] },
-    { match: (id) => /composer/i.test(id), cost: MODEL_COST_TABLE["composer-1"] },
-    { match: (id) => /gpt-5\.4.*nano/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4-nano"] },
-    { match: (id) => /gpt-5\.4.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4-mini"] },
-    { match: (id) => /gpt-5\.4/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4"] },
-    { match: (id) => /gpt-5\.3/i.test(id), cost: MODEL_COST_TABLE["gpt-5.3-codex"] },
-    { match: (id) => /gpt-5\.2/i.test(id), cost: MODEL_COST_TABLE["gpt-5.2"] },
-    { match: (id) => /gpt-5\.1.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5.1-codex-mini"] },
-    { match: (id) => /gpt-5\.1/i.test(id), cost: MODEL_COST_TABLE["gpt-5.1-codex"] },
-    { match: (id) => /gpt-5.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5-mini"] },
-    { match: (id) => /gpt-5.*fast/i.test(id), cost: MODEL_COST_TABLE["gpt-5-fast"] },
-    { match: (id) => /gpt-5/i.test(id), cost: MODEL_COST_TABLE["gpt-5"] },
-    { match: (id) => /gemini.*3\.1/i.test(id), cost: MODEL_COST_TABLE["gemini-3.1-pro"] },
-    { match: (id) => /gemini.*3.*flash/i.test(id), cost: MODEL_COST_TABLE["gemini-3-flash"] },
-    { match: (id) => /gemini.*3/i.test(id), cost: MODEL_COST_TABLE["gemini-3-pro"] },
-    { match: (id) => /gemini.*flash/i.test(id), cost: MODEL_COST_TABLE["gemini-2.5-flash"] },
-    { match: (id) => /gemini/i.test(id), cost: MODEL_COST_TABLE["gemini-3.1-pro"] },
-    { match: (id) => /grok/i.test(id), cost: MODEL_COST_TABLE["grok-4.20"] },
-    { match: (id) => /kimi/i.test(id), cost: MODEL_COST_TABLE["kimi-k2.5"] },
-];
-const DEFAULT_COST = { input: 3, output: 15, cache: { read: 0.3, write: 0 } };
-function estimateModelCost(modelId) {
-    const normalized = modelId.toLowerCase();
-    const exact = MODEL_COST_TABLE[normalized];
-    if (exact)
-        return exact;
-    const stripped = normalized.replace(/-(high|medium|low|preview|thinking|spark-preview)$/g, "");
-    const strippedMatch = MODEL_COST_TABLE[stripped];
-    if (strippedMatch)
-        return strippedMatch;
-    return MODEL_COST_PATTERNS.find((p) => p.match(normalized))?.cost ?? DEFAULT_COST;
-}
-export default CursorAuthPlugin;
+export { CursorAuthPlugin } from "./plugin/cursor-auth-plugin";
+export { CursorAuthPlugin as default } from "./plugin/cursor-auth-plugin";

package/dist/logger.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function configurePluginLogger(input: PluginInput): void;
+export declare function errorDetails(error: unknown): Record<string, unknown>;
+export declare function logPluginWarn(message: string, extra?: Record<string, unknown>): void;
+export declare function logPluginError(message: string, extra?: Record<string, unknown>): void;
+export declare function flushPluginLogs(): Promise<void>;

package/dist/logger.js

@@ -0,0 +1,147 @@
+const PLUGIN_LOG_SERVICE = "opencode-cursor-oauth";
+const MAX_STRING_LENGTH = 1_500;
+const MAX_ARRAY_LENGTH = 20;
+const MAX_OBJECT_KEYS = 25;
+let currentLogger;
+let pendingLogWrites = Promise.resolve();
+export function configurePluginLogger(input) {
+    currentLogger = {
+        client: input.client,
+        directory: input.directory,
+    };
+}
+export function errorDetails(error) {
+    if (error instanceof Error) {
+        return {
+            errorName: error.name,
+            errorMessage: error.message,
+            errorStack: error.stack,
+            errorCause: serializeValue(error.cause, 1),
+        };
+    }
+    return {
+        errorType: typeof error,
+        errorValue: serializeValue(error, 1),
+    };
+}
+export function logPluginWarn(message, extra = {}) {
+    logPlugin("warn", message, extra);
+}
+export function logPluginError(message, extra = {}) {
+    logPlugin("error", message, extra);
+}
+export function flushPluginLogs() {
+    return pendingLogWrites;
+}
+function logPlugin(level, message, extra) {
+    const serializedExtra = serializeValue(extra, 0);
+    writeConsoleLog(level, message, serializedExtra);
+    if (!currentLogger?.client?.app?.log) {
+        return;
+    }
+    pendingLogWrites = pendingLogWrites
+        .catch(() => { })
+        .then(async () => {
+        try {
+            await currentLogger?.client.app.log({
+                query: { directory: currentLogger.directory },
+                body: {
+                    service: PLUGIN_LOG_SERVICE,
+                    level,
+                    message,
+                    extra: serializedExtra,
+                },
+            });
+        }
+        catch (logError) {
+            writeConsoleLog("warn", "Failed to forward plugin log to OpenCode", {
+                originalLevel: level,
+                originalMessage: message,
+                ...errorDetails(logError),
+            });
+        }
+    });
+}
+function writeConsoleLog(level, message, extra) {
+    const prefix = `[${PLUGIN_LOG_SERVICE}] ${message}`;
+    const suffix = Object.keys(extra).length > 0 ? ` ${JSON.stringify(extra)}` : "";
+    if (level === "error") {
+        console.error(`${prefix}${suffix}`);
+        return;
+    }
+    console.warn(`${prefix}${suffix}`);
+}
+function serializeValue(value, depth, seen = new WeakSet()) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string")
+        return truncateString(value);
+    const valueType = typeof value;
+    if (valueType === "number" || valueType === "boolean")
+        return value;
+    if (valueType === "bigint")
+        return value.toString();
+    if (valueType === "symbol")
+        return String(value);
+    if (valueType === "function")
+        return `[function ${value.name || "anonymous"}]`;
+    if (value instanceof URL)
+        return value.toString();
+    if (value instanceof Headers)
+        return Object.fromEntries(value.entries());
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: truncateString(value.stack),
+            cause: serializeValue(value.cause, depth + 1, seen),
+        };
+    }
+    if (value instanceof Uint8Array) {
+        return serializeBinary(value);
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 3)
+            return `[array(${value.length})]`;
+        return value
+            .slice(0, MAX_ARRAY_LENGTH)
+            .map((entry) => serializeValue(entry, depth + 1, seen));
+    }
+    if (typeof value === "object") {
+        if (seen.has(value))
+            return "[circular]";
+        seen.add(value);
+        if (depth >= 3) {
+            return `[object ${value.constructor?.name || "Object"}]`;
+        }
+        const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
+        return Object.fromEntries(entries.map(([key, entry]) => [
+            key,
+            serializeValue(entry, depth + 1, seen),
+        ]));
+    }
+    return String(value);
+}
+function serializeBinary(value) {
+    const text = new TextDecoder().decode(value);
+    const printable = /^[\x09\x0a\x0d\x20-\x7e]*$/.test(text);
+    if (printable) {
+        return {
+            type: "uint8array",
+            length: value.length,
+            text: truncateString(text),
+        };
+    }
+    return {
+        type: "uint8array",
+        length: value.length,
+        base64: truncateString(Buffer.from(value).toString("base64")),
+    };
+}
+function truncateString(value) {
+    if (value === undefined)
+        return undefined;
+    if (value.length <= MAX_STRING_LENGTH)
+        return value;
+    return `${value.slice(0, MAX_STRING_LENGTH - 3)}...`;
+}

package/dist/models.d.ts

@@ -5,6 +5,9 @@ export interface CursorModel {
     contextWindow: number;
     maxTokens: number;
 }
+export declare class CursorModelDiscoveryError extends Error {
+    constructor(message: string);
+}
 export declare function getCursorModels(apiKey: string): Promise<CursorModel[]>;
 /** @internal Test-only. */
 export declare function clearModelCache(): void;