@playwo/opencode-cursor-oauth 0.2.0 → 0.3.0

package/dist/openai/tools.js

@@ -0,0 +1,58 @@
+import { create, fromBinary, fromJson, toBinary, toJson, } from "@bufbuild/protobuf";
+import { ValueSchema } from "@bufbuild/protobuf/wkt";
+import { McpToolDefinitionSchema } from "../proto/agent_pb";
+export function selectToolsForChoice(tools, toolChoice) {
+    if (!tools.length)
+        return [];
+    if (toolChoice === undefined ||
+        toolChoice === null ||
+        toolChoice === "auto" ||
+        toolChoice === "required") {
+        return tools;
+    }
+    if (toolChoice === "none") {
+        return [];
+    }
+    if (typeof toolChoice === "object") {
+        const choice = toolChoice;
+        if (choice.type === "function" &&
+            typeof choice.function?.name === "string") {
+            return tools.filter((tool) => tool.function.name === choice.function.name);
+        }
+    }
+    return tools;
+}
+/** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
+export function buildMcpToolDefinitions(tools) {
+    return tools.map((t) => {
+        const fn = t.function;
+        const jsonSchema = fn.parameters && typeof fn.parameters === "object"
+            ? fn.parameters
+            : { type: "object", properties: {}, required: [] };
+        const inputSchema = toBinary(ValueSchema, fromJson(ValueSchema, jsonSchema));
+        return create(McpToolDefinitionSchema, {
+            name: fn.name,
+            description: fn.description || "",
+            providerIdentifier: "opencode",
+            toolName: fn.name,
+            inputSchema,
+        });
+    });
+}
+/** Decode a Cursor MCP arg value (protobuf Value bytes) to a JS value. */
+function decodeMcpArgValue(value) {
+    try {
+        const parsed = fromBinary(ValueSchema, value);
+        return toJson(ValueSchema, parsed);
+    }
+    catch { }
+    return new TextDecoder().decode(value);
+}
+/** Decode a map of MCP arg values. */
+export function decodeMcpArgsMap(args) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(args)) {
+        decoded[key] = decodeMcpArgValue(value);
+    }
+    return decoded;
+}

package/dist/openai/types.d.ts

@@ -0,0 +1,41 @@
+export interface OpenAIToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** A single element in an OpenAI multi-part content array. */
+export interface ContentPart {
+    type: string;
+    text?: string;
+}
+export interface OpenAIMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null | ContentPart[];
+    tool_call_id?: string;
+    tool_calls?: OpenAIToolCall[];
+}
+export interface OpenAIToolDef {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: OpenAIMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    tools?: OpenAIToolDef[];
+    tool_choice?: unknown;
+}
+export interface ChatRequestContext {
+    sessionId?: string;
+    agentKey?: string;
+}

package/dist/openai/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin/cursor-auth-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const CursorAuthPlugin: Plugin;
+export default CursorAuthPlugin;

package/dist/plugin/cursor-auth-plugin.js

@@ -0,0 +1,139 @@
+import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "../auth";
+import { CURSOR_PROVIDER_ID } from "../constants";
+import { configurePluginLogger, errorDetails, logPluginError, logPluginWarn, } from "../logger";
+import { getCursorModels } from "../models";
+import { buildCursorProviderModels, buildDisabledProviderConfig, setProviderModels, stripAuthorizationHeader, } from "../provider/models";
+import { startProxy, stopProxy } from "../proxy";
+let lastModelDiscoveryError = null;
+export const CursorAuthPlugin = async (input) => {
+    configurePluginLogger(input);
+    return {
+        auth: {
+            provider: CURSOR_PROVIDER_ID,
+            async loader(getAuth, provider) {
+                try {
+                    const auth = await getAuth();
+                    if (!auth || auth.type !== "oauth")
+                        return {};
+                    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);
+                    lastModelDiscoveryError = null;
+                    const port = await startProxy(async () => {
+                        const currentAuth = await getAuth();
+                        if (currentAuth.type !== "oauth") {
+                            const authError = new Error("Cursor auth not configured");
+                            logPluginError("Cursor proxy access token lookup failed", {
+                                stage: "proxy_access_token",
+                                ...errorDetails(authError),
+                            });
+                            throw authError;
+                        }
+                        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);
+                    setProviderModels(provider, buildCursorProviderModels(models, port));
+                    return {
+                        baseURL: `http://localhost:${port}/v1`,
+                        apiKey: "cursor-proxy",
+                        async fetch(requestInput, init) {
+                            return fetch(requestInput, stripAuthorizationHeader(init));
+                        },
+                    };
+                }
+                catch (error) {
+                    const message = error instanceof Error
+                        ? error.message
+                        : "Cursor model discovery failed.";
+                    logPluginError("Cursor auth loader failed", {
+                        stage: "loader",
+                        providerID: CURSOR_PROVIDER_ID,
+                        ...errorDetails(error),
+                    });
+                    stopProxy();
+                    setProviderModels(provider, {});
+                    if (message !== lastModelDiscoveryError) {
+                        lastModelDiscoveryError = message;
+                        await showDiscoveryFailureToast(input, message);
+                    }
+                    return buildDisabledProviderConfig(message);
+                }
+            },
+            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),
+                                };
+                            },
+                        };
+                    },
+                },
+            ],
+        },
+        async "chat.headers"(incoming, output) {
+            if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            output.headers["x-session-id"] = incoming.sessionID;
+            if (incoming.agent) {
+                output.headers["x-opencode-agent"] = incoming.agent;
+            }
+        },
+    };
+};
+async function showDiscoveryFailureToast(input, message) {
+    try {
+        await input.client.tui.showToast({
+            body: {
+                title: "Cursor plugin disabled",
+                message,
+                variant: "error",
+                duration: 8_000,
+            },
+        });
+    }
+    catch (error) {
+        logPluginWarn("Failed to display Cursor plugin toast", {
+            title: "Cursor plugin disabled",
+            message,
+            ...errorDetails(error),
+        });
+    }
+}
+export default CursorAuthPlugin;