opencode-ext-connector 0.3.0

package/dist/providers/cursor/exec-reply.js

@@ -0,0 +1,102 @@
+// Derived from Rahularya01/pi-cursor src/stream/server-messages.ts exec replies.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { encodeConnectFrame } from "./connect-frame";
+import { encodeAgentClientMessage } from "./proto/request";
+import { decodeAgentServerMessage } from "./proto/server";
+import { concatBytes, encodeBoolField, encodeBytesField, encodeInt32Field, encodeStringField, } from "./proto-wire";
+const NATIVE_REJECT = "This native Cursor tool is not available. Use the MCP tools provided instead.";
+export function cursorMcpDefinitions(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        providerIdentifier: "opencode",
+        toolName: tool.name,
+    }));
+}
+export function encodeCursorClientFrame(message) {
+    return encodeConnectFrame(encodeAgentClientMessage(message));
+}
+export function encodeRequestContextFrame(message, tools) {
+    return encodeCursorClientFrame({
+        kind: "exec-client-message",
+        message: {
+            kind: "request-context-result",
+            id: message.id,
+            execId: message.execId,
+            result: { kind: "success", requestContext: { tools: cursorMcpDefinitions(tools) } },
+        },
+    });
+}
+function rejectedPath() {
+    return encodeBytesField(3, concatBytes([encodeStringField(1, ""), encodeStringField(2, NATIVE_REJECT)]));
+}
+function rejectedError() {
+    return encodeBytesField(2, encodeStringField(1, NATIVE_REJECT));
+}
+function nativeRejectionPayload(operation) {
+    switch (operation) {
+        case "shell":
+        case "shell-stream":
+        case "background-shell-spawn":
+            return encodeBytesField(operation === "background-shell-spawn" ? 3 : 4, concatBytes([
+                encodeStringField(1, ""),
+                encodeStringField(2, ""),
+                encodeStringField(3, NATIVE_REJECT),
+                encodeBoolField(4, false),
+            ]));
+        case "write":
+        case "delete":
+        case "read":
+        case "ls":
+            return rejectedPath();
+        case "grep":
+        case "write-shell-stdin":
+        case "list-mcp-resources":
+        case "record-screen":
+            return rejectedError();
+        case "read-mcp-resource":
+        case "fetch":
+            return encodeBytesField(2, concatBytes([encodeStringField(1, ""), encodeStringField(2, NATIVE_REJECT)]));
+        case "computer-use":
+            return encodeBytesField(2, concatBytes([
+                encodeStringField(1, NATIVE_REJECT),
+                encodeInt32Field(2, 0),
+                encodeInt32Field(3, 0),
+            ]));
+        case "diagnostics":
+            return new Uint8Array();
+        default:
+            return operation;
+    }
+}
+export function encodeNativeRejectFrame(message) {
+    return encodeCursorClientFrame({
+        kind: "exec-client-message",
+        message: {
+            kind: "native",
+            operation: message.operation,
+            field: message.field,
+            id: message.id,
+            execId: message.execId,
+            payload: nativeRejectionPayload(message.operation),
+        },
+    });
+}
+export function cursorServerReplies(bytes, tools) {
+    const server = decodeAgentServerMessage(bytes);
+    if (server.kind !== "exec-server-message")
+        return [];
+    switch (server.message.kind) {
+        case "request-context-args":
+            return [encodeRequestContextFrame(server.message, tools)];
+        case "native":
+            return [encodeNativeRejectFrame(server.message)];
+        case "metadata":
+            return [];
+        case "mcp-args":
+            return [];
+        default:
+            return server.message;
+    }
+}

package/dist/providers/cursor/h2-bridge-response.d.ts

@@ -0,0 +1,9 @@
+import type { ClientHttp2Stream, IncomingHttpHeaders } from "node:http2";
+export type CursorH2ResponseCallbacks = {
+    readonly onData: (chunk: Uint8Array) => boolean;
+    readonly onEnd: () => void;
+    readonly onError: (code: string, message: string) => void;
+};
+export declare function bridgeResponseHeaders(headers: IncomingHttpHeaders): Readonly<Record<string, string>>;
+export declare function responseStatus(headers: IncomingHttpHeaders): number;
+export declare function attachCursorH2ResponseBody(request: ClientHttp2Stream, headers: IncomingHttpHeaders, callbacks: CursorH2ResponseCallbacks): void;

package/dist/providers/cursor/h2-bridge-response.js

@@ -0,0 +1,51 @@
+import { createBrotliDecompress, createGunzip } from "node:zlib";
+import { MAX_BRIDGE_BINARY_BYTES } from "./bridge-limits";
+export function bridgeResponseHeaders(headers) {
+    const result = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.startsWith(":") || value === undefined) {
+            continue;
+        }
+        result[name] = Array.isArray(value) ? value.join(", ") : String(value);
+    }
+    return result;
+}
+export function responseStatus(headers) {
+    const status = headers[":status"];
+    return typeof status === "number" ? status : Number(status ?? 0);
+}
+export function attachCursorH2ResponseBody(request, headers, callbacks) {
+    const encoding = headers["content-encoding"];
+    const source = encoding === "gzip"
+        ? request.pipe(createGunzip())
+        : encoding === "br"
+            ? request.pipe(createBrotliDecompress())
+            : request;
+    if (encoding !== undefined &&
+        encoding !== "identity" &&
+        encoding !== "gzip" &&
+        encoding !== "br") {
+        callbacks.onError("unsupported-content-encoding", "Cursor response encoding is unsupported");
+        request.close();
+        return;
+    }
+    let outputBytes = 0;
+    source.on("data", (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes > MAX_BRIDGE_BINARY_BYTES) {
+            callbacks.onError("decompressed-body-too-large", "Cursor response body exceeds the limit");
+            source.destroy();
+            request.close();
+            return;
+        }
+        if (!callbacks.onData(new Uint8Array(chunk))) {
+            source.pause();
+            process.stdout.once("drain", () => source.resume());
+        }
+    });
+    source.on("error", () => {
+        callbacks.onError("response-body-error", "Cursor response body could not be decoded");
+        request.close();
+    });
+    source.once("end", callbacks.onEnd);
+}

package/dist/providers/cursor/h2-bridge-session.d.ts

@@ -0,0 +1,24 @@
+import type { BridgeCommand, BridgeEvent } from "./bridge-protocol";
+export type CursorH2BridgeOutput = {
+    readonly accessToken: string;
+    readonly event: BridgeEvent;
+};
+export type CursorH2BridgeEventSink = (output: CursorH2BridgeOutput) => boolean;
+export declare class CursorH2BridgeSession {
+    private readonly emit;
+    private readonly active;
+    private readonly client;
+    private readonly pingTimer;
+    private closing;
+    constructor(endpoint: string, emit: CursorH2BridgeEventSink);
+    handle(command: BridgeCommand): Promise<void>;
+    private open;
+    private write;
+    private abort;
+    private closeRequest;
+    private finish;
+    private finishError;
+    private emitError;
+    private failSession;
+    close(): Promise<void>;
+}

package/dist/providers/cursor/h2-bridge-session.js

@@ -0,0 +1,197 @@
+// Derived from Rahularya01/pi-cursor's persistent HTTP/2 bridge. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { randomUUID } from "node:crypto";
+import { once } from "node:events";
+import http2, {} from "node:http2";
+import { attachCursorH2ResponseBody, bridgeResponseHeaders, responseStatus, } from "./h2-bridge-response";
+import { CURSOR_CLIENT_VERSION } from "./http2";
+const PING_INTERVAL_MS = 20_000;
+const FORCE_CLOSE_MS = 1_000;
+function assertNever(command) {
+    void command;
+    throw new TypeError("unexpected Cursor bridge command");
+}
+function requestHeaders(command) {
+    return {
+        ...command.headers,
+        ":method": "POST",
+        ":path": command.path,
+        "content-type": "application/connect+proto",
+        "connect-protocol-version": "1",
+        te: "trailers",
+        authorization: `Bearer ${command.accessToken}`,
+        "accept-encoding": "gzip, br",
+        "x-ghost-mode": "true",
+        "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+        "x-cursor-client-type": "cli",
+        "x-request-id": randomUUID(),
+    };
+}
+export class CursorH2BridgeSession {
+    emit;
+    active = new Map();
+    client;
+    pingTimer;
+    closing = false;
+    constructor(endpoint, emit) {
+        this.emit = emit;
+        this.client = http2.connect(endpoint);
+        this.client.on("error", () => this.failSession("session-error", "Cursor HTTP/2 session failed"));
+        this.client.on("goaway", () => this.failSession("session-goaway", "Cursor HTTP/2 session received GOAWAY"));
+        this.pingTimer = setInterval(() => {
+            if (!this.client.closed && !this.client.destroyed) {
+                this.client.ping((error) => {
+                    if (error !== null) {
+                        this.failSession("session-ping-error", "Cursor HTTP/2 session PING failed");
+                    }
+                });
+            }
+        }, PING_INTERVAL_MS);
+        this.pingTimer.unref();
+    }
+    async handle(command) {
+        switch (command.kind) {
+            case "open":
+                this.open(command);
+                return;
+            case "write-frame":
+                await this.write(command.id, command.payload);
+                return;
+            case "abort":
+                this.abort(command.id);
+                return;
+            case "close":
+                this.closeRequest(command.id);
+                return;
+            default:
+                return assertNever(command);
+        }
+    }
+    open(command) {
+        if (this.closing || this.active.has(command.id)) {
+            this.emitError(command.id, command.accessToken, "stream-unavailable", "Cursor stream cannot be opened");
+            return;
+        }
+        const request = this.client.request(requestHeaders(command));
+        const active = { accessToken: command.accessToken, request, terminal: false };
+        this.active.set(command.id, active);
+        request.once("response", (headers) => {
+            this.emit({
+                accessToken: active.accessToken,
+                event: {
+                    kind: "headers",
+                    id: command.id,
+                    status: responseStatus(headers),
+                    headers: bridgeResponseHeaders(headers),
+                },
+            });
+            attachCursorH2ResponseBody(request, headers, {
+                onData: (payload) => this.emit({
+                    accessToken: active.accessToken,
+                    event: { kind: "data", id: command.id, payload },
+                }),
+                onEnd: () => this.finish(command.id, active),
+                onError: (code, message) => this.finishError(command.id, active, code, message),
+            });
+        });
+        request.on("trailers", (headers) => {
+            this.emit({
+                accessToken: active.accessToken,
+                event: { kind: "trailers", id: command.id, headers: bridgeResponseHeaders(headers) },
+            });
+        });
+        request.once("error", () => this.finishError(command.id, active, "stream-error", "Cursor HTTP/2 stream failed"));
+        this.emit({ accessToken: active.accessToken, event: { kind: "opened", id: command.id } });
+    }
+    async write(id, payload) {
+        const active = this.active.get(id);
+        if (active === undefined ||
+            active.terminal ||
+            active.request.destroyed ||
+            active.request.writableEnded) {
+            this.emitError(id, active?.accessToken ?? "", "stream-unavailable", "Cursor stream is unavailable");
+            return;
+        }
+        if (!active.request.write(payload)) {
+            await once(active.request, "drain");
+        }
+    }
+    abort(id) {
+        const active = this.active.get(id);
+        if (active === undefined) {
+            return;
+        }
+        active.request.close(http2.constants.NGHTTP2_CANCEL);
+        this.finish(id, active);
+        this.active.delete(id);
+    }
+    closeRequest(id) {
+        const active = this.active.get(id);
+        if (active === undefined) {
+            return;
+        }
+        active.request.end();
+        this.active.delete(id);
+    }
+    finish(id, active) {
+        if (active.terminal) {
+            return;
+        }
+        active.terminal = true;
+        this.emit({ accessToken: active.accessToken, event: { kind: "end", id } });
+    }
+    finishError(id, active, code, message) {
+        if (active.terminal) {
+            return;
+        }
+        active.terminal = true;
+        this.active.delete(id);
+        active.request.close(http2.constants.NGHTTP2_CANCEL);
+        this.emitError(id, active.accessToken, code, message);
+    }
+    emitError(id, accessToken, code, message) {
+        this.emit({ accessToken, event: { kind: "error", id, code, message } });
+    }
+    failSession(code, message) {
+        if (this.closing) {
+            return;
+        }
+        this.closing = true;
+        clearInterval(this.pingTimer);
+        for (const [id, active] of this.active) {
+            active.request.close(http2.constants.NGHTTP2_CANCEL);
+            if (!active.terminal) {
+                active.terminal = true;
+                this.emitError(id, active.accessToken, code, message);
+            }
+        }
+        this.active.clear();
+        this.client.destroy();
+    }
+    async close() {
+        if (this.closing) {
+            return;
+        }
+        this.closing = true;
+        clearInterval(this.pingTimer);
+        for (const [id, active] of this.active) {
+            active.request.close(http2.constants.NGHTTP2_CANCEL);
+            this.finish(id, active);
+        }
+        this.active.clear();
+        this.client.close();
+        if (this.client.closed || this.client.destroyed) {
+            return;
+        }
+        await Promise.race([
+            once(this.client, "close"),
+            new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    this.client.destroy();
+                    resolve();
+                }, FORCE_CLOSE_MS);
+                timer.unref();
+            }),
+        ]);
+    }
+}

package/dist/providers/cursor/h2-bridge.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCursorH2Endpoint(endpoint?: string): string;
+export declare function runCursorH2Bridge(endpoint?: string): Promise<number>;