@playwo/opencode-cursor-oauth 0.0.0-dev.e3644b4a140d → 0.0.0-dev.eb79b6283515

package/dist/proxy/cursor-request.js

@@ -0,0 +1,104 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { createHash } from "node:crypto";
+import { AgentClientMessageSchema, AgentRunRequestSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, ModelDetailsSchema, ResumeActionSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
+export function buildCursorRequest(modelId, systemPrompt, userText, turns, conversationId, checkpoint, existingBlobStore) {
+    const blobStore = new Map(existingBlobStore ?? []);
+    // System prompt → blob store (Cursor requests it back via KV handshake)
+    const systemJson = JSON.stringify({ role: "system", content: systemPrompt });
+    const systemBytes = new TextEncoder().encode(systemJson);
+    const systemBlobId = new Uint8Array(createHash("sha256").update(systemBytes).digest());
+    blobStore.set(Buffer.from(systemBlobId).toString("hex"), systemBytes);
+    let conversationState;
+    if (checkpoint) {
+        conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
+    }
+    else {
+        const turnBytes = [];
+        for (const turn of turns) {
+            const userMsg = create(UserMessageSchema, {
+                text: turn.userText,
+                messageId: crypto.randomUUID(),
+            });
+            const userMsgBytes = toBinary(UserMessageSchema, userMsg);
+            const stepBytes = [];
+            if (turn.assistantText) {
+                const step = create(ConversationStepSchema, {
+                    message: {
+                        case: "assistantMessage",
+                        value: create(AssistantMessageSchema, { text: turn.assistantText }),
+                    },
+                });
+                stepBytes.push(toBinary(ConversationStepSchema, step));
+            }
+            const agentTurn = create(AgentConversationTurnStructureSchema, {
+                userMessage: userMsgBytes,
+                steps: stepBytes,
+            });
+            const turnStructure = create(ConversationTurnStructureSchema, {
+                turn: { case: "agentConversationTurn", value: agentTurn },
+            });
+            turnBytes.push(toBinary(ConversationTurnStructureSchema, turnStructure));
+        }
+        conversationState = create(ConversationStateStructureSchema, {
+            rootPromptMessagesJson: [systemBlobId],
+            turns: turnBytes,
+            todos: [],
+            pendingToolCalls: [],
+            previousWorkspaceUris: [],
+            fileStates: {},
+            fileStatesV2: {},
+            summaryArchives: [],
+            turnTimings: [],
+            subagentStates: {},
+            selfSummaryCount: 0,
+            readPaths: [],
+        });
+    }
+    const userMessage = create(UserMessageSchema, {
+        text: userText,
+        messageId: crypto.randomUUID(),
+    });
+    const action = create(ConversationActionSchema, {
+        action: {
+            case: "userMessageAction",
+            value: create(UserMessageActionSchema, { userMessage }),
+        },
+    });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore);
+}
+export function buildCursorResumeRequest(modelId, systemPrompt, conversationId, checkpoint, existingBlobStore) {
+    const blobStore = new Map(existingBlobStore ?? []);
+    const systemJson = JSON.stringify({ role: "system", content: systemPrompt });
+    const systemBytes = new TextEncoder().encode(systemJson);
+    const systemBlobId = new Uint8Array(createHash("sha256").update(systemBytes).digest());
+    blobStore.set(Buffer.from(systemBlobId).toString("hex"), systemBytes);
+    const conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
+    const action = create(ConversationActionSchema, {
+        action: {
+            case: "resumeAction",
+            value: create(ResumeActionSchema, {}),
+        },
+    });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore);
+}
+function buildRunRequest(modelId, conversationId, conversationState, action, blobStore) {
+    const modelDetails = create(ModelDetailsSchema, {
+        modelId,
+        displayModelId: modelId,
+        displayName: modelId,
+    });
+    const runRequest = create(AgentRunRequestSchema, {
+        conversationState,
+        action,
+        modelDetails,
+        conversationId,
+    });
+    const clientMessage = create(AgentClientMessageSchema, {
+        message: { case: "runRequest", value: runRequest },
+    });
+    return {
+        requestBytes: toBinary(AgentClientMessageSchema, clientMessage),
+        blobStore,
+        mcpTools: [],
+    };
+}

package/dist/proxy/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./server";
+export * from "./bridge";
+export * from "./chat-completion";
+export * from "./conversation-meta";
+export * from "./conversation-state";
+export * from "./cursor-request";
+export * from "./sse";
+export * from "./state-sync";
+export * from "./stream-dispatch";
+export * from "./stream-state";
+export * from "./title";
+export * from "./types";

package/dist/proxy/index.js

@@ -0,0 +1,12 @@
+export * from "./server";
+export * from "./bridge";
+export * from "./chat-completion";
+export * from "./conversation-meta";
+export * from "./conversation-state";
+export * from "./cursor-request";
+export * from "./sse";
+export * from "./state-sync";
+export * from "./stream-dispatch";
+export * from "./stream-state";
+export * from "./title";
+export * from "./types";

package/dist/proxy/server.d.ts

@@ -0,0 +1,6 @@
+export declare function getProxyPort(): number | undefined;
+export declare function startProxy(getAccessToken: () => Promise<string>, models?: ReadonlyArray<{
+    id: string;
+    name: string;
+}>): Promise<number>;
+export declare function stopProxy(): void;

package/dist/proxy/server.js

@@ -0,0 +1,107 @@
+import { errorDetails, logPluginError, logPluginWarn } from "../logger";
+import { handleChatCompletion } from "./chat-completion";
+import { activeBridges, conversationStates } from "./conversation-state";
+let proxyServer;
+let proxyPort;
+let proxyAccessTokenProvider;
+let proxyModels = [];
+function buildOpenAIModelList(models) {
+    return models.map((model) => ({
+        id: model.id,
+        object: "model",
+        created: 0,
+        owned_by: "cursor",
+    }));
+}
+export function getProxyPort() {
+    return proxyPort;
+}
+export async function startProxy(getAccessToken, models = []) {
+    proxyAccessTokenProvider = getAccessToken;
+    proxyModels = models.map((model) => ({
+        id: model.id,
+        name: model.name,
+    }));
+    if (proxyServer && proxyPort)
+        return proxyPort;
+    proxyServer = Bun.serve({
+        port: 0,
+        idleTimeout: 255, // max — Cursor responses can take 30s+
+        async fetch(req) {
+            const url = new URL(req.url);
+            if (req.method === "GET" && url.pathname === "/v1/models") {
+                return new Response(JSON.stringify({
+                    object: "list",
+                    data: buildOpenAIModelList(proxyModels),
+                }), { headers: { "Content-Type": "application/json" } });
+            }
+            if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+                try {
+                    const body = (await req.json());
+                    if (!proxyAccessTokenProvider) {
+                        throw new Error("Cursor proxy access token provider not configured");
+                    }
+                    const accessToken = await proxyAccessTokenProvider();
+                    const sessionId = req.headers.get("x-session-id") ?? undefined;
+                    const agentKey = req.headers.get("x-opencode-agent") ?? undefined;
+                    const response = await handleChatCompletion(body, accessToken, {
+                        sessionId,
+                        agentKey,
+                    });
+                    if (response.status >= 400) {
+                        let responseBody = "";
+                        try {
+                            responseBody = await response.clone().text();
+                        }
+                        catch (error) {
+                            responseBody = `Failed to read rejected response body: ${error instanceof Error ? error.message : String(error)}`;
+                        }
+                        logPluginWarn("Rejected Cursor chat completion", {
+                            path: url.pathname,
+                            method: req.method,
+                            sessionId,
+                            agentKey,
+                            status: response.status,
+                            requestBody: body,
+                            requestBodyText: JSON.stringify(body),
+                            responseBody,
+                        });
+                    }
+                    return response;
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    logPluginError("Cursor proxy request failed", {
+                        path: url.pathname,
+                        method: req.method,
+                        ...errorDetails(err),
+                    });
+                    return new Response(JSON.stringify({
+                        error: { message, type: "server_error", code: "internal_error" },
+                    }), { status: 500, headers: { "Content-Type": "application/json" } });
+                }
+            }
+            return new Response("Not Found", { status: 404 });
+        },
+    });
+    proxyPort = proxyServer.port;
+    if (!proxyPort)
+        throw new Error("Failed to bind proxy to a port");
+    return proxyPort;
+}
+export function stopProxy() {
+    if (proxyServer) {
+        proxyServer.stop();
+        proxyServer = undefined;
+        proxyPort = undefined;
+        proxyAccessTokenProvider = undefined;
+        proxyModels = [];
+    }
+    // Clean up any lingering bridges
+    for (const active of activeBridges.values()) {
+        clearInterval(active.heartbeatTimer);
+        active.bridge.end();
+    }
+    activeBridges.clear();
+    conversationStates.clear();
+}

package/dist/proxy/sse.d.ts

@@ -0,0 +1,5 @@
+export declare const SSE_HEADERS: {
+    readonly "Content-Type": "text/event-stream";
+    readonly "Cache-Control": "no-cache";
+    readonly Connection: "keep-alive";
+};

package/dist/proxy/sse.js

@@ -0,0 +1,5 @@
+export const SSE_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+};

package/dist/proxy/state-sync.d.ts

@@ -0,0 +1,2 @@
+export declare function updateConversationCheckpoint(convKey: string, checkpointBytes: Uint8Array): void;
+export declare function syncStoredBlobStore(convKey: string, blobStore: Map<string, Uint8Array>): void;

package/dist/proxy/state-sync.js

@@ -0,0 +1,17 @@
+import { conversationStates } from "./conversation-state";
+export function updateConversationCheckpoint(convKey, checkpointBytes) {
+    const stored = conversationStates.get(convKey);
+    if (!stored)
+        return;
+    stored.checkpoint = checkpointBytes;
+    stored.lastAccessMs = Date.now();
+}
+export function syncStoredBlobStore(convKey, blobStore) {
+    const stored = conversationStates.get(convKey);
+    if (!stored)
+        return;
+    for (const [key, value] of blobStore) {
+        stored.blobStore.set(key, value);
+    }
+    stored.lastAccessMs = Date.now();
+}

package/dist/proxy/stream-dispatch.d.ts

@@ -0,0 +1,42 @@
+import { type AgentServerMessage, type McpToolDefinition } from "../proto/agent_pb";
+import type { CursorSession } from "../cursor/bidi-session";
+import type { StreamState } from "./stream-state";
+import type { PendingExec } from "./types";
+export interface UnhandledExecInfo {
+    execCase: string;
+    execId: string;
+    execMsgId: number;
+}
+export interface UnsupportedServerMessageInfo {
+    category: "agentMessage" | "interactionUpdate" | "interactionQuery" | "execServerControl" | "toolCall";
+    caseName: string;
+    detail?: string;
+}
+export declare function parseConnectEndStream(data: Uint8Array): Error | null;
+export declare function makeHeartbeatBytes(): Uint8Array;
+export declare function scheduleBridgeEnd(bridge: CursorSession): void;
+/**
+ * Create a stateful parser for Connect protocol frames.
+ * Handles buffering partial data across chunks.
+ */
+export declare function createConnectFrameParser(onMessage: (bytes: Uint8Array) => void, onEndStream: (bytes: Uint8Array) => void): (incoming: Buffer) => void;
+/**
+ * Strip thinking tags from streamed text, routing tagged content to reasoning.
+ * Buffers partial tags across chunk boundaries.
+ */
+export declare function createThinkingTagFilter(): {
+    process(text: string): {
+        content: string;
+        reasoning: string;
+    };
+    flush(): {
+        content: string;
+        reasoning: string;
+    };
+};
+export declare function computeUsage(state: StreamState): {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+};
+export declare function processServerMessage(msg: AgentServerMessage, blobStore: Map<string, Uint8Array>, mcpTools: McpToolDefinition[], sendFrame: (data: Uint8Array) => void, state: StreamState, onText: (text: string, isThinking?: boolean) => void, onMcpExec: (exec: PendingExec) => void, onCheckpoint?: (checkpointBytes: Uint8Array) => void, onTurnEnded?: () => void, onUnsupportedMessage?: (info: UnsupportedServerMessageInfo) => void, onUnhandledExec?: (info: UnhandledExecInfo) => void): void;