@playwo/opencode-cursor-oauth 0.2.0 → 0.3.0

package/dist/proxy/conversation-state.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { buildCompletedTurnsFingerprint, textContent, } from "../openai/messages";
+// Active bridges keyed by a session token (derived from conversation state).
+// When tool_calls are returned, the bridge stays alive. The next request
+// with tool results looks up the bridge and sends mcpResult messages.
+export const activeBridges = new Map();
+export const conversationStates = new Map();
+const CONVERSATION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+export function evictStaleConversations() {
+    const now = Date.now();
+    for (const [key, stored] of conversationStates) {
+        if (now - stored.lastAccessMs > CONVERSATION_TTL_MS) {
+            conversationStates.delete(key);
+        }
+    }
+}
+export function normalizeAgentKey(agentKey) {
+    const trimmed = agentKey?.trim();
+    return trimmed ? trimmed : "default";
+}
+export function hashString(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function createStoredConversation() {
+    return {
+        conversationId: crypto.randomUUID(),
+        checkpoint: null,
+        blobStore: new Map(),
+        lastAccessMs: Date.now(),
+        systemPromptHash: "",
+        completedTurnsFingerprint: "",
+    };
+}
+export function resetStoredConversation(stored) {
+    stored.conversationId = crypto.randomUUID();
+    stored.checkpoint = null;
+    stored.blobStore = new Map();
+    stored.lastAccessMs = Date.now();
+    stored.systemPromptHash = "";
+    stored.completedTurnsFingerprint = "";
+}
+export function deriveBridgeKey(modelId, messages, sessionId, agentKey) {
+    if (sessionId) {
+        const normalizedAgent = normalizeAgentKey(agentKey);
+        return createHash("sha256")
+            .update(`bridge:${sessionId}:${normalizedAgent}`)
+            .digest("hex")
+            .slice(0, 16);
+    }
+    const firstUserMsg = messages.find((m) => m.role === "user");
+    const firstUserText = firstUserMsg ? textContent(firstUserMsg.content) : "";
+    const normalizedAgent = normalizeAgentKey(agentKey);
+    return createHash("sha256")
+        .update(`bridge:${normalizedAgent}:${modelId}:${firstUserText.slice(0, 200)}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+/** Derive a key for conversation state. Model-independent so context survives model switches. */
+export function deriveConversationKey(messages, sessionId, agentKey) {
+    if (sessionId) {
+        const normalizedAgent = normalizeAgentKey(agentKey);
+        return createHash("sha256")
+            .update(`session:${sessionId}:${normalizedAgent}`)
+            .digest("hex")
+            .slice(0, 16);
+    }
+    return createHash("sha256")
+        .update(`${normalizeAgentKey(agentKey)}:${buildConversationFingerprint(messages)}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+export function buildConversationFingerprint(messages) {
+    return messages
+        .map((message) => {
+        const toolCallIDs = (message.tool_calls ?? [])
+            .map((call) => call.id)
+            .join(",");
+        return `${message.role}:${textContent(message.content)}:${message.tool_call_id ?? ""}:${toolCallIDs}`;
+    })
+        .join("\n---\n");
+}
+export function updateStoredConversationAfterCompletion(convKey, metadata, assistantText) {
+    const stored = conversationStates.get(convKey);
+    if (!stored)
+        return;
+    const nextTurns = metadata.userText
+        ? [
+            ...metadata.turns,
+            { userText: metadata.userText, assistantText: assistantText.trim() },
+        ]
+        : metadata.turns;
+    stored.systemPromptHash = metadata.systemPromptHash;
+    stored.completedTurnsFingerprint = buildCompletedTurnsFingerprint(metadata.systemPrompt, nextTurns);
+    stored.lastAccessMs = Date.now();
+}

package/dist/proxy/cursor-request.d.ts

@@ -0,0 +1,6 @@
+import type { CursorRequestPayload } from "./types";
+export declare function buildCursorRequest(modelId: string, systemPrompt: string, userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, conversationId: string, checkpoint: Uint8Array | null, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;
+export declare function buildCursorResumeRequest(modelId: string, systemPrompt: string, conversationId: string, checkpoint: Uint8Array, existingBlobStore?: Map<string, Uint8Array>): CursorRequestPayload;

package/dist/proxy/cursor-request.js

@@ -0,0 +1,101 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { AgentClientMessageSchema, AgentRunRequestSchema, AgentConversationTurnStructureSchema, AssistantMessageSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationTurnStructureSchema, ConversationStepSchema, ModelDetailsSchema, ResumeActionSchema, UserMessageActionSchema, UserMessageSchema, } from "../proto/agent_pb";
+export function buildCursorRequest(modelId, systemPrompt, userText, turns, conversationId, checkpoint, existingBlobStore) {
+    const blobStore = new Map(existingBlobStore ?? []);
+    const cloudRule = buildCloudRule(systemPrompt);
+    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: [],
+            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, cloudRule);
+}
+export function buildCursorResumeRequest(modelId, systemPrompt, conversationId, checkpoint, existingBlobStore) {
+    const blobStore = new Map(existingBlobStore ?? []);
+    const cloudRule = buildCloudRule(systemPrompt);
+    const conversationState = fromBinary(ConversationStateStructureSchema, checkpoint);
+    const action = create(ConversationActionSchema, {
+        action: {
+            case: "resumeAction",
+            value: create(ResumeActionSchema, {}),
+        },
+    });
+    return buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule);
+}
+function buildRunRequest(modelId, conversationId, conversationState, action, blobStore, cloudRule) {
+    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,
+        cloudRule,
+        mcpTools: [],
+    };
+}
+function buildCloudRule(systemPrompt) {
+    const content = systemPrompt.trim();
+    return content || undefined;
+}

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>, cloudRule: string | undefined, 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;