@playwo/opencode-cursor-oauth 0.0.0-dev.1b946f85e9b0 → 0.0.0-dev.2a59bf1639ea

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,89 @@
+import { errorDetails, logPluginError } 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-opencode-session-id") ??
+                        req.headers.get("x-session-id") ??
+                        undefined;
+                    const agentKey = req.headers.get("x-opencode-agent") ?? undefined;
+                    return handleChatCompletion(body, accessToken, {
+                        sessionId,
+                        agentKey,
+                    });
+                }
+                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;