opencode-ext-connector 0.3.0

package/dist/providers/cursor/bridge-client.js

@@ -0,0 +1,200 @@
+import { OperationCancelledError, ResourceDisposedError } from "../../core/errors";
+import { createAsyncDisposable } from "../../core/lifecycle";
+import { CursorBridgeProcessError, createNodeCursorBridgeProcessFactory, } from "./bridge-process";
+import { CursorBridgeProtocolError, createBridgeEventLineDecoder, serializeBridgeCommand, } from "./bridge-protocol";
+export class CursorBridgeSessionError extends Error {
+    reason;
+    name = "CursorBridgeSessionError";
+    code = "CURSOR_BRIDGE_SESSION_ERROR";
+    constructor(reason) {
+        super("Cursor bridge stream is unavailable");
+        this.reason = reason;
+    }
+}
+class EventInbox {
+    events = [];
+    waiters = [];
+    failure = null;
+    finished = false;
+    push(event) {
+        if (this.failure !== null || this.finished)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter === undefined)
+            this.events.push(event);
+        else {
+            if (waiter.signal !== undefined && waiter.onAbort !== undefined) {
+                waiter.signal.removeEventListener("abort", waiter.onAbort);
+            }
+            waiter.resolve(event);
+        }
+    }
+    next(signal) {
+        const event = this.events.shift();
+        if (event !== undefined)
+            return Promise.resolve(event);
+        if (this.failure !== null)
+            return Promise.reject(this.failure);
+        if (this.finished)
+            return Promise.reject(new CursorBridgeSessionError("stream-closed"));
+        if (signal?.aborted === true) {
+            return Promise.reject(new OperationCancelledError("wait-cursor-bridge-event"));
+        }
+        const deferred = Promise.withResolvers();
+        const onAbort = signal === undefined
+            ? undefined
+            : () => {
+                const index = this.waiters.findIndex((candidate) => candidate.resolve === deferred.resolve);
+                if (index >= 0)
+                    this.waiters.splice(index, 1);
+                deferred.reject(new OperationCancelledError("wait-cursor-bridge-event"));
+            };
+        if (onAbort !== undefined)
+            signal?.addEventListener("abort", onAbort, { once: true });
+        this.waiters.push({ resolve: deferred.resolve, reject: deferred.reject, signal, onAbort });
+        return deferred.promise;
+    }
+    finish() {
+        this.finished = true;
+        this.rejectWaiters(new CursorBridgeSessionError("stream-closed"));
+    }
+    fail(error) {
+        if (this.failure !== null || this.finished)
+            return;
+        this.failure = error;
+        this.rejectWaiters(error);
+    }
+    rejectWaiters(error) {
+        for (const waiter of this.waiters.splice(0)) {
+            if (waiter.signal !== undefined && waiter.onAbort !== undefined) {
+                waiter.signal.removeEventListener("abort", waiter.onAbort);
+            }
+            waiter.reject(error);
+        }
+    }
+}
+function processFailure(exit) {
+    const status = exit.code === null ? (exit.signal ?? "unknown signal") : `code ${exit.code}`;
+    const detail = exit.stderr.length === 0 ? status : `${status}: ${exit.stderr}`;
+    return new CursorBridgeProcessError("child-exited", detail);
+}
+export async function createCursorBridgeClient(options = {}) {
+    const lifecycle = new AbortController();
+    if (options.signal?.aborted === true)
+        throw new OperationCancelledError("start-cursor-bridge");
+    const processFactory = options.processFactory ?? createNodeCursorBridgeProcessFactory();
+    const child = await processFactory.start(options.signal ?? lifecycle.signal);
+    const sessions = new Map();
+    const claimedIds = new Set();
+    const decoder = createBridgeEventLineDecoder();
+    let fatal = null;
+    let disposed = false;
+    let writes = Promise.resolve();
+    const failAll = (error) => {
+        if (fatal === null)
+            fatal = error;
+        for (const session of sessions.values())
+            session.inbox.fail(error);
+        sessions.clear();
+    };
+    const send = (command, signal = lifecycle.signal) => {
+        const operation = writes.then(async () => {
+            if (disposed)
+                throw new ResourceDisposedError("cursor-bridge-client");
+            if (fatal !== null)
+                throw fatal;
+            await child.write(serializeBridgeCommand(command), signal);
+        });
+        writes = operation.then(() => undefined, () => undefined);
+        return operation;
+    };
+    const finishSession = (id, event) => {
+        const session = sessions.get(id);
+        if (session === undefined)
+            return;
+        session.inbox.push(event);
+        if (event.kind === "end" || event.kind === "error") {
+            session.abortSignal.removeEventListener("abort", session.abortListener);
+            session.inbox.finish();
+            sessions.delete(id);
+        }
+    };
+    const outputTask = (async () => {
+        try {
+            for await (const chunk of child.stdout) {
+                for (const event of decoder.push(chunk))
+                    finishSession(event.id, event);
+            }
+            decoder.finish();
+        }
+        catch (error) {
+            const failure = error instanceof CursorBridgeProtocolError || error instanceof CursorBridgeProcessError
+                ? error
+                : new CursorBridgeProcessError("stdout-failed", "stdout reader failed");
+            failAll(failure);
+            await child.terminate();
+        }
+    })();
+    const exitTask = child.wait().then((exit) => {
+        if (!disposed && fatal === null)
+            failAll(processFailure(exit));
+    });
+    const disposal = createAsyncDisposable(async () => {
+        disposed = true;
+        lifecycle.abort();
+        const error = new ResourceDisposedError("cursor-bridge-client");
+        for (const session of sessions.values()) {
+            session.abortSignal.removeEventListener("abort", session.abortListener);
+            session.inbox.fail(error);
+        }
+        sessions.clear();
+        await child.dispose();
+        await Promise.all([outputTask, exitTask]);
+    });
+    return {
+        pid: child.pid,
+        async open(input) {
+            if (disposed)
+                throw new ResourceDisposedError("cursor-bridge-client");
+            if (fatal !== null)
+                throw fatal;
+            if (claimedIds.has(input.id))
+                throw new CursorBridgeSessionError("duplicate-stream");
+            if (input.signal.aborted)
+                throw new OperationCancelledError("open-cursor-bridge-stream");
+            claimedIds.add(input.id);
+            const inbox = new EventInbox();
+            let abortOperation = null;
+            const abort = () => {
+                if (abortOperation !== null)
+                    return abortOperation;
+                sessions.delete(input.id);
+                input.signal.removeEventListener("abort", abortListener);
+                inbox.fail(new OperationCancelledError("cursor-bridge-stream"));
+                abortOperation = send({ kind: "abort", id: input.id });
+                return abortOperation;
+            };
+            const abortListener = () => {
+                void abort();
+            };
+            sessions.set(input.id, { inbox, abortSignal: input.signal, abortListener });
+            input.signal.addEventListener("abort", abortListener, { once: true });
+            await send({
+                kind: "open",
+                id: input.id,
+                accessToken: input.accessToken,
+                path: input.path,
+                headers: input.headers,
+            });
+            return {
+                id: input.id,
+                write: (payload, signal) => send({ kind: "write-frame", id: input.id, payload }, signal),
+                nextEvent: (signal) => inbox.next(signal),
+                abort,
+                close: () => send({ kind: "close", id: input.id }),
+            };
+        },
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal.dispose,
+    };
+}

package/dist/providers/cursor/bridge-event-sanitize.d.ts

@@ -0,0 +1,3 @@
+import type { BridgeEvent } from "./bridge-protocol";
+export declare function isSensitiveBridgeHeader(name: string): boolean;
+export declare function sanitizeBridgeEvent(event: BridgeEvent, accessToken: string): BridgeEvent;

package/dist/providers/cursor/bridge-event-sanitize.js

@@ -0,0 +1,49 @@
+function assertNever(event) {
+    void event;
+    throw new TypeError("unexpected bridge event");
+}
+function redactExactToken(value, accessToken) {
+    return accessToken.length === 0 ? value : value.split(accessToken).join("[REDACTED]");
+}
+function containsExactToken(value, accessToken) {
+    return accessToken.length > 0 && value.includes(accessToken);
+}
+export function isSensitiveBridgeHeader(name) {
+    return (name === "authorization" ||
+        name === "proxy-authorization" ||
+        name === "cookie" ||
+        name === "set-cookie" ||
+        name.includes("token") ||
+        name.includes("api-key") ||
+        name.includes("apikey") ||
+        name.includes("api_key") ||
+        name.includes("secret") ||
+        name.includes("password"));
+}
+function sanitizeHeaders(headers, accessToken) {
+    const sanitized = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (!isSensitiveBridgeHeader(name) && !containsExactToken(name, accessToken)) {
+            sanitized[name] = redactExactToken(value, accessToken);
+        }
+    }
+    return sanitized;
+}
+export function sanitizeBridgeEvent(event, accessToken) {
+    switch (event.kind) {
+        case "opened":
+        case "data":
+        case "end":
+            return event;
+        case "headers":
+        case "trailers":
+            return { ...event, headers: sanitizeHeaders(event.headers, accessToken) };
+        case "error":
+            return {
+                ...event,
+                message: redactExactToken(event.message, accessToken),
+            };
+        default:
+            return assertNever(event);
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare const MAX_BRIDGE_BINARY_BYTES: number;
+export declare const MAX_BRIDGE_BASE64_CHARACTERS: number;
+export declare const MAX_BRIDGE_LINE_LENGTH: number;

package/dist/providers/cursor/bridge-limits.js

@@ -0,0 +1,10 @@
+import { MAX_CONNECT_FRAME_BYTES } from "./connect-frame";
+const MAX_BRIDGE_ID_CHARACTERS = 128;
+const MAX_BRIDGE_WIRE_OVERHEAD = '{"kind":"write-frame","id":"","payload":""}'.length;
+const OPTIONAL_CARRIAGE_RETURN_CHARACTERS = 1;
+export const MAX_BRIDGE_BINARY_BYTES = MAX_CONNECT_FRAME_BYTES;
+export const MAX_BRIDGE_BASE64_CHARACTERS = Math.ceil(MAX_BRIDGE_BINARY_BYTES / 3) * 4;
+export const MAX_BRIDGE_LINE_LENGTH = MAX_BRIDGE_BASE64_CHARACTERS +
+    MAX_BRIDGE_ID_CHARACTERS +
+    MAX_BRIDGE_WIRE_OVERHEAD +
+    OPTIONAL_CARRIAGE_RETURN_CHARACTERS;

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

@@ -0,0 +1,45 @@
+import { type AsyncDisposableHandle } from "../../core/lifecycle";
+export type CursorBridgeUnavailableReason = "node-unavailable" | "malformed-node-version" | "unsupported-node" | "spawn-failed";
+export declare class CursorBridgeUnavailableError extends Error {
+    readonly reason: CursorBridgeUnavailableReason;
+    readonly name = "CursorBridgeUnavailableError";
+    readonly code = "CURSOR_BRIDGE_UNAVAILABLE";
+    constructor(reason: CursorBridgeUnavailableReason);
+}
+export type CursorBridgeProcessErrorReason = "stdin-closed" | "stdout-failed" | "child-exited" | "termination-failed";
+export declare class CursorBridgeProcessError extends Error {
+    readonly reason: CursorBridgeProcessErrorReason;
+    readonly name = "CursorBridgeProcessError";
+    readonly code = "CURSOR_BRIDGE_PROCESS_ERROR";
+    readonly detail: string;
+    constructor(reason: CursorBridgeProcessErrorReason, detail: string);
+}
+export type CursorBridgeProcessExit = {
+    readonly code: number | null;
+    readonly signal: string | null;
+    readonly stderr: string;
+};
+export interface CursorBridgeProcess extends AsyncDisposableHandle {
+    readonly pid: number;
+    readonly stdout: AsyncIterable<string>;
+    write(data: string, signal: AbortSignal): Promise<void>;
+    wait(): Promise<CursorBridgeProcessExit>;
+    terminate(): Promise<void>;
+}
+export interface CursorBridgeProcessFactory {
+    start(signal: AbortSignal): Promise<CursorBridgeProcess>;
+}
+export type CursorBridgeSpawnInput = {
+    readonly executable: string;
+    readonly arguments: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+};
+export type NodeCursorBridgeProcessFactoryOptions = {
+    readonly nodeExecutable?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly childUrl?: URL;
+    readonly endpoint?: string;
+    readonly probeVersion?: (executable: string, signal: AbortSignal) => Promise<string>;
+    readonly spawnBridge?: (input: CursorBridgeSpawnInput, signal: AbortSignal) => Promise<CursorBridgeProcess>;
+};
+export declare function createNodeCursorBridgeProcessFactory(options?: NodeCursorBridgeProcessFactoryOptions): CursorBridgeProcessFactory;

package/dist/providers/cursor/bridge-process.js

@@ -0,0 +1,211 @@
+import { Buffer } from "node:buffer";
+import { execFile, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { OperationCancelledError } from "../../core/errors";
+import { createAsyncDisposable } from "../../core/lifecycle";
+const execFileAsync = promisify(execFile);
+const maximumStderrBytes = 16 * 1024;
+const preservedEnvironment = [
+    "PATH",
+    "SystemRoot",
+    "WINDIR",
+    "NODE_EXTRA_CA_CERTS",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+];
+export class CursorBridgeUnavailableError extends Error {
+    reason;
+    name = "CursorBridgeUnavailableError";
+    code = "CURSOR_BRIDGE_UNAVAILABLE";
+    constructor(reason) {
+        super("Cursor bridge is unavailable");
+        this.reason = reason;
+    }
+}
+export class CursorBridgeProcessError extends Error {
+    reason;
+    name = "CursorBridgeProcessError";
+    code = "CURSOR_BRIDGE_PROCESS_ERROR";
+    detail;
+    constructor(reason, detail) {
+        super("Cursor bridge process failed");
+        this.reason = reason;
+        this.detail = redactProcessText(detail);
+    }
+}
+function safeEnvironment(source) {
+    const env = {};
+    for (const name of preservedEnvironment) {
+        const value = source[name];
+        if (value !== undefined)
+            env[name] = value;
+    }
+    return env;
+}
+function redactProcessText(value) {
+    return value
+        .replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
+        .replace(/\b(authorization|cookie|token|api[-_]?key|password|secret)\s*[:=]\s*[^\s,;]+/gi, "$1=[REDACTED]")
+        .replace(/([?&][^=&#\s]+)=([^&#\s]*)/g, "$1=[REDACTED]");
+}
+function parseNodeMajor(version) {
+    const match = /^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?\r?\n?$/.exec(version);
+    if (match === null)
+        return null;
+    const major = Number(match[1]);
+    return Number.isSafeInteger(major) ? major : null;
+}
+async function defaultProbeVersion(executable, signal, env) {
+    const result = await execFileAsync(executable, ["--version"], {
+        encoding: "utf8",
+        env,
+        signal,
+        windowsHide: true,
+    });
+    return result.stdout;
+}
+async function* readStdout(child) {
+    const decoder = new TextDecoder();
+    for await (const value of child.stdout) {
+        const chunk = value;
+        if (!Buffer.isBuffer(chunk)) {
+            throw new CursorBridgeProcessError("stdout-failed", "non-buffer stdout chunk");
+        }
+        yield decoder.decode(chunk, { stream: true });
+    }
+    const trailing = decoder.decode();
+    if (trailing.length > 0)
+        yield trailing;
+}
+class NodeCursorBridgeProcess {
+    child;
+    pid;
+    stdout;
+    exit = Promise.withResolvers();
+    disposal;
+    stderr = [];
+    stderrBytes = 0;
+    constructor(child) {
+        this.child = child;
+        const pid = child.pid;
+        if (pid === undefined)
+            throw new CursorBridgeUnavailableError("spawn-failed");
+        this.pid = pid;
+        this.stdout = readStdout(child);
+        child.stderr.on("data", (value) => {
+            if (!Buffer.isBuffer(value) || this.stderrBytes >= maximumStderrBytes)
+                return;
+            const remaining = maximumStderrBytes - this.stderrBytes;
+            const chunk = value.subarray(0, remaining);
+            this.stderr.push(chunk);
+            this.stderrBytes += chunk.byteLength;
+        });
+        child.once("exit", (code, signal) => {
+            this.exit.resolve({
+                code,
+                signal,
+                stderr: redactProcessText(Buffer.concat(this.stderr).toString("utf8")),
+            });
+        });
+        this.disposal = createAsyncDisposable(() => this.terminate());
+    }
+    write(data, signal) {
+        if (signal.aborted)
+            return Promise.reject(new OperationCancelledError("write-cursor-bridge"));
+        const deferred = Promise.withResolvers();
+        const onAbort = () => deferred.reject(new OperationCancelledError("write-cursor-bridge"));
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.child.stdin.write(data, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            if (error === null || error === undefined)
+                deferred.resolve();
+            else
+                deferred.reject(new CursorBridgeProcessError("stdin-closed", "stdin write failed"));
+        });
+        return deferred.promise;
+    }
+    wait() {
+        return this.exit.promise;
+    }
+    async terminate() {
+        if (this.child.exitCode !== null || this.child.signalCode !== null)
+            return;
+        this.child.stdin.end();
+        this.child.kill("SIGTERM");
+        let timer;
+        await Promise.race([
+            this.exit.promise,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, 1_000);
+                timer.unref();
+            }),
+        ]);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        if (this.child.exitCode === null && this.child.signalCode === null) {
+            if (!this.child.kill("SIGKILL")) {
+                throw new CursorBridgeProcessError("termination-failed", "failed to signal child");
+            }
+            await this.exit.promise;
+        }
+    }
+    dispose() {
+        return this.disposal.dispose();
+    }
+    [Symbol.asyncDispose]() {
+        return this.disposal.dispose();
+    }
+}
+async function defaultSpawnBridge(input, signal) {
+    const child = spawn(input.executable, [...input.arguments], {
+        env: input.env,
+        signal,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+    });
+    return new NodeCursorBridgeProcess(child);
+}
+export function createNodeCursorBridgeProcessFactory(options = {}) {
+    const executable = options.nodeExecutable ?? "node";
+    const childUrl = options.childUrl ?? new URL("./h2-bridge.js", import.meta.url);
+    const env = safeEnvironment(options.env ?? process.env);
+    const probeVersion = options.probeVersion ?? ((target, signal) => defaultProbeVersion(target, signal, env));
+    const spawnBridge = options.spawnBridge ?? defaultSpawnBridge;
+    return {
+        async start(signal) {
+            if (signal.aborted)
+                throw new OperationCancelledError("start-cursor-bridge");
+            let version;
+            try {
+                version = await probeVersion(executable, signal);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw new OperationCancelledError("start-cursor-bridge");
+                void error;
+                throw new CursorBridgeUnavailableError("node-unavailable");
+            }
+            const major = parseNodeMajor(version);
+            if (major === null)
+                throw new CursorBridgeUnavailableError("malformed-node-version");
+            if (major < 22)
+                throw new CursorBridgeUnavailableError("unsupported-node");
+            const childPath = fileURLToPath(childUrl);
+            const arguments_ = options.endpoint === undefined ? [childPath] : [childPath, options.endpoint];
+            try {
+                return await spawnBridge({ executable, arguments: arguments_, env }, signal);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw new OperationCancelledError("start-cursor-bridge");
+                void error;
+                throw new CursorBridgeUnavailableError("spawn-failed");
+            }
+        },
+    };
+}

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

@@ -0,0 +1,68 @@
+export { sanitizeBridgeEvent } from "./bridge-event-sanitize";
+export { MAX_BRIDGE_BASE64_CHARACTERS, MAX_BRIDGE_BINARY_BYTES, MAX_BRIDGE_LINE_LENGTH, } from "./bridge-limits";
+export { serializeBridgeCommand, serializeBridgeEvent } from "./bridge-serialize";
+export { parseBridgeCommandLine, parseBridgeEventLine } from "./bridge-wire";
+export type BridgeCommand = {
+    readonly kind: "open";
+    readonly id: string;
+    readonly accessToken: string;
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string>>;
+} | {
+    readonly kind: "write-frame";
+    readonly id: string;
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "abort";
+    readonly id: string;
+} | {
+    readonly kind: "close";
+    readonly id: string;
+};
+export type BridgeEvent = {
+    readonly kind: "opened";
+    readonly id: string;
+} | {
+    readonly kind: "headers";
+    readonly id: string;
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+} | {
+    readonly kind: "data";
+    readonly id: string;
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "trailers";
+    readonly id: string;
+    readonly headers: Readonly<Record<string, string>>;
+} | {
+    readonly kind: "end";
+    readonly id: string;
+} | {
+    readonly kind: "error";
+    readonly id: string;
+    readonly code: string;
+    readonly message: string;
+};
+export type BridgeEventSerializationContext = {
+    readonly accessToken: string;
+};
+export type CursorBridgeProtocolErrorCode = "malformed-json" | "invalid-message" | "invalid-base64" | "line-too-long" | "incomplete-line";
+export declare class CursorBridgeProtocolError extends Error {
+    readonly code: CursorBridgeProtocolErrorCode;
+    readonly name = "CursorBridgeProtocolError";
+    constructor(code: CursorBridgeProtocolErrorCode);
+    toJSON(): {
+        readonly name: string;
+        readonly code: CursorBridgeProtocolErrorCode;
+    };
+}
+export type BridgeLineDecoderOptions = {
+    readonly maximumLineLength?: number;
+};
+export interface BridgeLineDecoder<T> {
+    push(chunk: string): readonly T[];
+    finish(): readonly T[];
+}
+export declare function createBridgeCommandLineDecoder(options?: BridgeLineDecoderOptions): BridgeLineDecoder<BridgeCommand>;
+export declare function createBridgeEventLineDecoder(options?: BridgeLineDecoderOptions): BridgeLineDecoder<BridgeEvent>;

package/dist/providers/cursor/bridge-protocol.js

@@ -0,0 +1,49 @@
+import { MAX_BRIDGE_LINE_LENGTH } from "./bridge-limits";
+import { parseBridgeCommandLine, parseBridgeEventLine } from "./bridge-wire";
+export { sanitizeBridgeEvent } from "./bridge-event-sanitize";
+export { MAX_BRIDGE_BASE64_CHARACTERS, MAX_BRIDGE_BINARY_BYTES, MAX_BRIDGE_LINE_LENGTH, } from "./bridge-limits";
+export { serializeBridgeCommand, serializeBridgeEvent } from "./bridge-serialize";
+export { parseBridgeCommandLine, parseBridgeEventLine } from "./bridge-wire";
+export class CursorBridgeProtocolError extends Error {
+    code;
+    name = "CursorBridgeProtocolError";
+    constructor(code) {
+        super("cursor bridge protocol error");
+        this.code = code;
+    }
+    toJSON() {
+        return { name: this.name, code: this.code };
+    }
+}
+function createBridgeLineDecoder(options, parseLine) {
+    const maximumLineLength = options.maximumLineLength ?? MAX_BRIDGE_LINE_LENGTH;
+    let buffered = "";
+    const parseLines = (lines) => lines.map((line) => {
+        if (line.length > maximumLineLength) {
+            throw new CursorBridgeProtocolError("line-too-long");
+        }
+        return parseLine(line);
+    });
+    return {
+        push(chunk) {
+            const lines = `${buffered}${chunk}`.split("\n");
+            buffered = lines.pop() ?? "";
+            if (buffered.length > maximumLineLength) {
+                throw new CursorBridgeProtocolError("line-too-long");
+            }
+            return parseLines(lines);
+        },
+        finish() {
+            if (buffered.length > 0) {
+                throw new CursorBridgeProtocolError("incomplete-line");
+            }
+            return [];
+        },
+    };
+}
+export function createBridgeCommandLineDecoder(options = {}) {
+    return createBridgeLineDecoder(options, parseBridgeCommandLine);
+}
+export function createBridgeEventLineDecoder(options = {}) {
+    return createBridgeLineDecoder(options, parseBridgeEventLine);
+}

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

@@ -0,0 +1,3 @@
+import { type BridgeCommand, type BridgeEvent, type BridgeEventSerializationContext } from "./bridge-protocol";
+export declare function serializeBridgeCommand(command: BridgeCommand): string;
+export declare function serializeBridgeEvent(event: BridgeEvent, context: BridgeEventSerializationContext): string;