opencode-ext-connector 0.3.0

package/dist/providers/cursor/run-session.d.ts

@@ -0,0 +1,50 @@
+import type { Clock } from "../../core/clock";
+import type { CursorBridgeStream } from "./bridge-client";
+import type { CursorRequestBlobOwnership } from "./request-blob-ownership";
+import { type CursorRunSessionBackgroundCleanupErrorHandler } from "./run-session-expiry";
+import type { CursorServerDispatcher } from "./server-dispatch";
+import type { CursorSessionId } from "./session-state";
+export type CursorRunSessionIdentity = {
+    readonly sessionId: CursorSessionId;
+    readonly modelId: string;
+};
+export type CursorRunSessionResources = CursorRunSessionIdentity & {
+    readonly stream: CursorBridgeStream;
+    readonly ownership: CursorRequestBlobOwnership;
+    readonly dispatcher: CursorServerDispatcher;
+    readonly disposeStores: () => void;
+};
+export type CursorRunSessionErrorReason = "duplicate-session" | "missing-session" | "mismatched-result" | "duplicate-result" | "ambiguous-result" | "retry-boundary";
+export declare class CursorRunSessionError extends Error {
+    readonly reason: CursorRunSessionErrorReason;
+    readonly name = "CursorRunSessionError";
+    readonly code = "CURSOR_RUN_SESSION_ERROR";
+    constructor(reason: CursorRunSessionErrorReason);
+}
+export type CursorRunSession = {
+    readonly identity: CursorRunSessionIdentity;
+    readonly dispatcher: CursorServerDispatcher;
+    readonly stream: CursorBridgeStream;
+    readonly write: (frame: Uint8Array, signal?: AbortSignal) => Promise<void>;
+    readonly writeContinuations: (continuations: readonly {
+        readonly callId: string;
+        readonly frame: Uint8Array;
+    }[], signal?: AbortSignal) => Promise<void>;
+    readonly touch: () => void;
+    readonly abort: () => Promise<void>;
+    readonly retireForRetry?: () => Promise<void>;
+    readonly dispose: () => Promise<void>;
+};
+export type CursorRunSessionRegistry = {
+    readonly register: (resources: CursorRunSessionResources) => CursorRunSession;
+    readonly find: (identity: CursorRunSessionIdentity) => CursorRunSession | null;
+    readonly resolveParkedCalls: (callIds: readonly string[], modelId: string) => CursorRunSession;
+    readonly terminate: (identity: CursorRunSessionIdentity) => Promise<void>;
+    readonly size: () => number;
+    readonly dispose: () => Promise<void>;
+};
+export declare function createCursorRunSessionRegistry(_options: {
+    readonly clock: Clock;
+    readonly ttlMs: number;
+    readonly onBackgroundCleanupError: CursorRunSessionBackgroundCleanupErrorHandler;
+}): CursorRunSessionRegistry;

package/dist/providers/cursor/run-session.js

@@ -0,0 +1,205 @@
+import { InvalidArgumentError } from "../../core/errors";
+import { createAsyncDisposable } from "../../core/lifecycle";
+import { settleCursorRunSessionExpiry, } from "./run-session-expiry";
+import { settleCursorCleanup } from "./settle-cleanup";
+export class CursorRunSessionError extends Error {
+    reason;
+    name = "CursorRunSessionError";
+    code = "CURSOR_RUN_SESSION_ERROR";
+    constructor(reason) {
+        super("Cursor run session continuation failed");
+        this.reason = reason;
+    }
+}
+export function createCursorRunSessionRegistry(_options) {
+    const options = _options;
+    if (!Number.isSafeInteger(options.ttlMs) || options.ttlMs < 0) {
+        throw new InvalidArgumentError("ttlMs");
+    }
+    const sessions = new Map();
+    const ownersByModel = new Map();
+    let disposed = false;
+    const removeOwnership = (sessionId) => {
+        for (const [modelId, ownersByCallId] of ownersByModel) {
+            for (const [callId, owners] of ownersByCallId) {
+                owners.delete(sessionId);
+                if (owners.size === 0)
+                    ownersByCallId.delete(callId);
+            }
+            if (ownersByCallId.size === 0)
+                ownersByModel.delete(modelId);
+        }
+    };
+    const terminate = async (identity) => {
+        const session = sessions.get(identity.sessionId);
+        if (session === undefined)
+            return;
+        sessions.delete(identity.sessionId);
+        removeOwnership(identity.sessionId);
+        await session.dispose();
+    };
+    const register = (resources) => {
+        if (disposed)
+            throw new CursorRunSessionError("missing-session");
+        const identity = {
+            sessionId: resources.sessionId,
+            modelId: resources.modelId,
+        };
+        if (sessions.has(identity.sessionId))
+            throw new CursorRunSessionError("duplicate-session");
+        const consumed = new Set();
+        const reserved = new Set();
+        let writes = Promise.resolve();
+        let timer;
+        let streamSettlement = "close";
+        let retired = false;
+        const cancelTimer = () => {
+            timer?.cancel();
+            timer = undefined;
+        };
+        const disposal = createAsyncDisposable(() => {
+            cancelTimer();
+            removeOwnership(identity.sessionId);
+            resources.dispatcher.parkedCalls.clear();
+            if (retired)
+                return;
+            return settleCursorCleanup([
+                streamSettlement === "abort" ? resources.stream.abort : resources.stream.close,
+                resources.ownership.release,
+                resources.disposeStores,
+            ]);
+        });
+        const touch = () => {
+            cancelTimer();
+            removeOwnership(identity.sessionId);
+            const ownersByCallId = ownersByModel.get(identity.modelId) ?? new Map();
+            for (const callId of resources.dispatcher.parkedCalls.keys()) {
+                const owners = ownersByCallId.get(callId) ?? new Set();
+                owners.add(identity.sessionId);
+                ownersByCallId.set(callId, owners);
+            }
+            ownersByModel.set(identity.modelId, ownersByCallId);
+            timer = options.clock.schedule(options.ttlMs, () => {
+                settleCursorRunSessionExpiry({
+                    identity,
+                    terminate,
+                    onBackgroundCleanupError: options.onBackgroundCleanupError,
+                });
+            });
+        };
+        const session = {
+            identity,
+            dispatcher: resources.dispatcher,
+            stream: resources.stream,
+            write: (frame, signal) => {
+                const operation = writes.then(() => resources.stream.write(frame, signal));
+                writes = operation.then(() => undefined, () => undefined);
+                return operation;
+            },
+            writeContinuations: (continuations, signal) => {
+                const transactionIds = new Set();
+                for (const continuation of continuations) {
+                    if (consumed.has(continuation.callId) || reserved.has(continuation.callId)) {
+                        return Promise.reject(new CursorRunSessionError("duplicate-result"));
+                    }
+                    if (!resources.dispatcher.parkedCalls.has(continuation.callId)) {
+                        return Promise.reject(new CursorRunSessionError("mismatched-result"));
+                    }
+                    if (transactionIds.has(continuation.callId)) {
+                        return Promise.reject(new CursorRunSessionError("duplicate-result"));
+                    }
+                    transactionIds.add(continuation.callId);
+                }
+                for (const callId of transactionIds)
+                    reserved.add(callId);
+                cancelTimer();
+                removeOwnership(identity.sessionId);
+                const operation = writes.then(async () => {
+                    for (const continuation of continuations) {
+                        await resources.stream.write(continuation.frame, signal);
+                    }
+                });
+                const transaction = operation.then(() => {
+                    for (const callId of transactionIds) {
+                        resources.dispatcher.parkedCalls.delete(callId);
+                        reserved.delete(callId);
+                        consumed.add(callId);
+                    }
+                }, async (error) => {
+                    for (const callId of transactionIds)
+                        reserved.delete(callId);
+                    try {
+                        await terminate(identity);
+                    }
+                    catch (cleanupError) {
+                        const message = error instanceof Error ? error.message : "Continuation write failed";
+                        throw new AggregateError([error, cleanupError], message);
+                    }
+                    throw error;
+                });
+                writes = transaction.then(() => undefined, () => undefined);
+                return transaction;
+            },
+            touch,
+            abort: () => {
+                streamSettlement = "abort";
+                sessions.delete(identity.sessionId);
+                removeOwnership(identity.sessionId);
+                return disposal.dispose();
+            },
+            retireForRetry: async () => {
+                if (resources.dispatcher.parkedCalls.size > 0 || reserved.size > 0)
+                    throw new CursorRunSessionError("retry-boundary");
+                retired = true;
+                cancelTimer();
+                sessions.delete(identity.sessionId);
+                removeOwnership(identity.sessionId);
+                resources.dispatcher.parkedCalls.clear();
+                await settleCursorCleanup([resources.stream.abort, resources.ownership.release]);
+            },
+            dispose: disposal.dispose,
+        };
+        sessions.set(identity.sessionId, session);
+        return session;
+    };
+    const resolveParkedCalls = (callIds, modelId) => {
+        let resolved = null;
+        const ownersByCallId = ownersByModel.get(modelId);
+        for (const callId of callIds) {
+            const owners = ownersByCallId?.get(callId);
+            if (owners === undefined)
+                throw new CursorRunSessionError("missing-session");
+            if (owners.size !== 1)
+                throw new CursorRunSessionError("ambiguous-result");
+            const sessionId = owners.values().next().value;
+            const candidate = sessionId === undefined ? undefined : sessions.get(sessionId);
+            if (candidate === undefined)
+                throw new CursorRunSessionError("missing-session");
+            if (candidate.identity.modelId !== modelId) {
+                throw new CursorRunSessionError("mismatched-result");
+            }
+            if (resolved !== null && resolved !== candidate) {
+                throw new CursorRunSessionError("mismatched-result");
+            }
+            resolved = candidate;
+        }
+        if (resolved === null)
+            throw new CursorRunSessionError("missing-session");
+        return resolved;
+    };
+    const disposal = createAsyncDisposable(async () => {
+        disposed = true;
+        const active = [...sessions.values()];
+        sessions.clear();
+        ownersByModel.clear();
+        await settleCursorCleanup(active.map((session) => session.dispose));
+    });
+    return {
+        register,
+        find: (identity) => sessions.get(identity.sessionId) ?? null,
+        resolveParkedCalls,
+        terminate,
+        size: () => sessions.size,
+        dispose: disposal.dispose,
+    };
+}

package/dist/providers/cursor/run.d.ts

@@ -0,0 +1,9 @@
+import { type CursorHttp2Post } from "./http2";
+import { type CursorMcpTool } from "./mcp-tools";
+export declare function buildCursorRunMessage(modelId: string, prompt: string, tools?: readonly CursorMcpTool[]): Uint8Array;
+export declare function extractCursorTextDeltas(message: Uint8Array): readonly string[];
+export type CursorRunPost = (request: CursorHttp2Post) => Promise<{
+    readonly status: number;
+    readonly body: Uint8Array;
+}>;
+export declare function streamCursorAssistantNdjson(modelId: string, prompt: string, token: string, signal: AbortSignal, post?: CursorRunPost, tools?: readonly CursorMcpTool[]): AsyncIterable<string>;

package/dist/providers/cursor/run.js

@@ -0,0 +1,151 @@
+// Derived from Rahularya01/pi-cursor AgentService/Run Connect framing.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { randomUUID } from "node:crypto";
+import { AdapterError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { decodeConnectFrames, decodeConnectFramesWithRest, encodeConnectFrame, } from "./connect-frame";
+import { cursorServerReplies } from "./exec-reply";
+import { cursorHttp2Post, cursorHttp2Stream } from "./http2";
+import { encodeCursorMcpTools } from "./mcp-tools";
+import { concatBytes, decodeUtf8, encodeBytesField, encodeInt32Field, encodeStringField, } from "./proto-wire";
+import { extractCursorRunEvents } from "./run-events";
+export function buildCursorRunMessage(modelId, prompt, tools = []) {
+    const messageId = randomUUID();
+    const userMessage = concatBytes([
+        encodeStringField(1, prompt),
+        encodeStringField(2, messageId),
+        encodeInt32Field(4, 1),
+        encodeStringField(17, messageId),
+    ]);
+    const action = encodeBytesField(1, encodeBytesField(1, userMessage));
+    const conversationState = concatBytes([
+        encodeInt32Field(10, 1),
+        encodeStringField(22, "opencode"),
+    ]);
+    const parts = [
+        encodeBytesField(1, conversationState),
+        encodeBytesField(2, action),
+        encodeBytesField(3, encodeStringField(1, modelId)),
+        encodeBytesField(4, encodeCursorMcpTools(tools)),
+        encodeStringField(5, randomUUID()),
+        encodeBytesField(9, encodeStringField(1, modelId)),
+    ];
+    return encodeBytesField(1, concatBytes(parts));
+}
+export function extractCursorTextDeltas(message) {
+    const deltas = [];
+    for (const event of extractCursorRunEvents(message)) {
+        if (event.kind === "text") {
+            deltas.push(event.text);
+        }
+    }
+    return deltas;
+}
+function connectErrorMessage(bytes) {
+    const text = decodeUtf8(bytes).trim();
+    if (!text.startsWith("{")) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed !== "object" || parsed === null || !("error" in parsed)) {
+            return null;
+        }
+        const error = Reflect.get(parsed, "error");
+        if (typeof error === "object" && error !== null && "message" in error) {
+            const message = Reflect.get(error, "message");
+            if (typeof message === "string" && message.length > 0) {
+                return message;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return text.includes('"error"') ? text : null;
+}
+function* ndjsonFromFrames(frames) {
+    for (const frame of frames) {
+        const errorMessage = connectErrorMessage(frame.bytes);
+        if (errorMessage !== null) {
+            throw new Error(errorMessage);
+        }
+        for (const event of extractCursorRunEvents(frame.bytes)) {
+            switch (event.kind) {
+                case "text":
+                    yield JSON.stringify({
+                        type: "assistant",
+                        message: { content: [{ type: "text", text: event.text }] },
+                    });
+                    break;
+                case "thinking":
+                    yield JSON.stringify({ type: "thinking", text: event.text });
+                    break;
+                case "tool":
+                    yield JSON.stringify({
+                        type: "tool_call",
+                        subtype: "started",
+                        call_id: event.callId,
+                        name: event.name,
+                        arguments: event.args,
+                    });
+                    break;
+                case "turn-ended":
+                    break;
+            }
+        }
+    }
+}
+export async function* streamCursorAssistantNdjson(modelId, prompt, token, signal, post = cursorHttp2Post, tools = []) {
+    let writeFrame = () => undefined;
+    const request = {
+        path: "/agent.v1.AgentService/Run",
+        token,
+        body: encodeConnectFrame(buildCursorRunMessage(modelId, prompt, tools)),
+        headers: {
+            "content-type": "application/connect+proto",
+            "connect-protocol-version": "1",
+        },
+        signal,
+        keepOpen: true,
+        heartbeat: encodeConnectFrame(encodeBytesField(7, new Uint8Array())),
+        onWriter: (write) => {
+            writeFrame = write;
+        },
+    };
+    if (post !== cursorHttp2Post) {
+        const response = await post(request);
+        if (response.status < 200 || response.status >= 300) {
+            throw new AdapterError({
+                operation: "cursor-run-http",
+                retryable: response.status >= 500,
+                cause: null,
+                providerId: parseProviderId("cursor"),
+            });
+        }
+        yield* ndjsonFromFrames(decodeConnectFrames(response.body));
+        yield JSON.stringify({ type: "result", result: "" });
+        return;
+    }
+    let rest = new Uint8Array();
+    stream: for await (const chunk of cursorHttp2Stream(request)) {
+        const split = decodeConnectFramesWithRest(concatBytes([rest, chunk]));
+        rest = new Uint8Array(split.rest);
+        for (const frame of split.frames) {
+            for (const reply of cursorServerReplies(frame.bytes, tools)) {
+                writeFrame(reply);
+            }
+        }
+        for (const line of ndjsonFromFrames(split.frames)) {
+            yield line;
+        }
+        for (const frame of split.frames) {
+            for (const event of extractCursorRunEvents(frame.bytes)) {
+                if (event.kind === "turn-ended") {
+                    break stream;
+                }
+            }
+        }
+    }
+    yield JSON.stringify({ type: "result", result: "" });
+}

package/dist/providers/cursor/runner.d.ts

@@ -0,0 +1 @@
+export declare function runCursorAgentPrompt(env: Readonly<Record<string, string | undefined>>, prompt: string, signal: AbortSignal, cwd: string, model: string): Promise<string | null>;

package/dist/providers/cursor/runner.js

@@ -0,0 +1,55 @@
+// Derived from Nomadcxx/opencode-cursor@8e14a26c1e080382f471a729436092ef72edf34e.
+// Licensed under BSD-3-Clause. See THIRD_PARTY_NOTICES.md.
+import { spawn } from "node:child_process";
+import { OperationCancelledError } from "../../core/errors";
+import { resolveCursorAgent } from "./auth";
+import { extractCursorNdjsonText } from "./ndjson";
+export async function runCursorAgentPrompt(env, prompt, signal, cwd, model) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("cursor-run-prompt");
+    }
+    const agent = await resolveCursorAgent(env, signal);
+    if (agent === null) {
+        return null;
+    }
+    return await new Promise((resolve, reject) => {
+        const child = spawn(agent, [
+            "--print",
+            "--output-format",
+            "stream-json",
+            "--stream-partial-output",
+            "--workspace",
+            cwd,
+            "--model",
+            model,
+            ...(env["CURSOR_ACP_FORCE"] === "false" ? [] : ["--force"]),
+        ], {
+            signal,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const chunks = [];
+        child.stdout.on("data", (chunk) => {
+            chunks.push(chunk);
+        });
+        child.once("error", (error) => {
+            if (signal.aborted) {
+                reject(new OperationCancelledError("cursor-run-prompt"));
+                return;
+            }
+            reject(error);
+        });
+        child.once("close", (code) => {
+            if (signal.aborted) {
+                reject(new OperationCancelledError("cursor-run-prompt"));
+                return;
+            }
+            if (code !== 0) {
+                resolve(null);
+                return;
+            }
+            resolve(extractCursorNdjsonText(Buffer.concat(chunks).toString("utf8")));
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}

package/dist/providers/cursor/server-dispatch-types.d.ts

@@ -0,0 +1,83 @@
+import type { CursorBlobStore } from "./blob-store";
+import type { CursorCheckpointStore } from "./checkpoint-store";
+import type { CursorMcpTool } from "./mcp-tools";
+import type { McpArgs } from "./proto/mcp";
+import type { AgentServerMessage } from "./proto/server";
+import type { CursorSessionId } from "./session-state";
+export type ParkedMcpCall = {
+    readonly callId: string;
+    readonly execId: string;
+    readonly execMessageId: number;
+    readonly args: McpArgs;
+};
+export type CursorDispatchOutcome = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "thinking";
+    readonly text: string;
+} | {
+    readonly kind: "tokens";
+    readonly tokens: number;
+} | {
+    readonly kind: "turn-ended";
+} | {
+    readonly kind: "heartbeat";
+} | {
+    readonly kind: "telemetry";
+    readonly name: string;
+} | {
+    readonly kind: "kv-get";
+    readonly id: number;
+    readonly found: boolean;
+} | {
+    readonly kind: "kv-set";
+    readonly id: number;
+    readonly stored: boolean;
+} | {
+    readonly kind: "checkpoint";
+    readonly stored: boolean;
+} | {
+    readonly kind: "request-context-replied";
+    readonly id: number;
+    readonly execId: string;
+} | {
+    readonly kind: "mcp-parked";
+    readonly parked: ParkedMcpCall;
+} | {
+    readonly kind: "mcp-rejected";
+    readonly callId: string;
+} | {
+    readonly kind: "native-rejected";
+    readonly operation: string;
+} | {
+    readonly kind: "interaction-replied";
+    readonly id: number;
+    readonly action: "rejected" | "acked";
+} | {
+    readonly kind: "control";
+    readonly control: "abort";
+    readonly id: number;
+} | {
+    readonly kind: "drift";
+    readonly area: "server-message" | "mcp-call";
+    readonly detail: string;
+    readonly stranding: boolean;
+};
+export type CursorDispatchResult = {
+    readonly outcome: CursorDispatchOutcome;
+    readonly replyFrames: readonly Uint8Array[];
+    readonly closeStream: boolean;
+};
+export type CursorServerDispatcherOptions = {
+    readonly blobStore: CursorBlobStore;
+    readonly checkpointStore: CursorCheckpointStore;
+    readonly sessionId: CursorSessionId;
+    readonly tools: readonly CursorMcpTool[];
+};
+export type CursorServerDispatcher = {
+    readonly dispatch: (message: AgentServerMessage) => CursorDispatchResult;
+    readonly dispatchBytes: (bytes: Uint8Array) => CursorDispatchResult;
+    /** Mutable unresolved-call state; retirement is part of successful continuation commit. */
+    readonly parkedCalls: Map<string, ParkedMcpCall>;
+};

package/dist/providers/cursor/server-dispatch-types.js

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

package/dist/providers/cursor/server-dispatch.d.ts

@@ -0,0 +1,3 @@
+import type { CursorServerDispatcher, CursorServerDispatcherOptions } from "./server-dispatch-types";
+export type { CursorDispatchOutcome, CursorDispatchResult, CursorServerDispatcher, CursorServerDispatcherOptions, ParkedMcpCall, } from "./server-dispatch-types";
+export declare function createCursorServerDispatcher(options: CursorServerDispatcherOptions): CursorServerDispatcher;