opencode-ext-connector 0.3.0

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

@@ -0,0 +1,53 @@
+import { Buffer } from "node:buffer";
+import { sanitizeBridgeEvent } from "./bridge-event-sanitize";
+import { MAX_BRIDGE_LINE_LENGTH } from "./bridge-limits";
+import { CursorBridgeProtocolError, } from "./bridge-protocol";
+function assertNever(value) {
+    void value;
+    throw new CursorBridgeProtocolError("invalid-message");
+}
+function encodeBase64(payload) {
+    return Buffer.from(payload).toString("base64");
+}
+function serializeLine(value) {
+    const line = JSON.stringify(value);
+    if (line.length > MAX_BRIDGE_LINE_LENGTH) {
+        throw new CursorBridgeProtocolError("line-too-long");
+    }
+    return `${line}\n`;
+}
+export function serializeBridgeCommand(command) {
+    switch (command.kind) {
+        case "open":
+        case "abort":
+        case "close":
+            return serializeLine(command);
+        case "write-frame":
+            return serializeLine({
+                kind: command.kind,
+                id: command.id,
+                payload: encodeBase64(command.payload),
+            });
+        default:
+            return assertNever(command);
+    }
+}
+export function serializeBridgeEvent(event, context) {
+    const sanitized = sanitizeBridgeEvent(event, context.accessToken);
+    switch (sanitized.kind) {
+        case "opened":
+        case "headers":
+        case "trailers":
+        case "end":
+        case "error":
+            return serializeLine(sanitized);
+        case "data":
+            return serializeLine({
+                kind: sanitized.kind,
+                id: sanitized.id,
+                payload: encodeBase64(sanitized.payload),
+            });
+        default:
+            return assertNever(sanitized);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { type BridgeCommand, type BridgeEvent } from "./bridge-protocol";
+export declare function parseBridgeCommandLine(line: string): BridgeCommand;
+export declare function parseBridgeEventLine(line: string): BridgeEvent;

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

@@ -0,0 +1,163 @@
+import { Buffer } from "node:buffer";
+import { z } from "zod";
+import { isSensitiveBridgeHeader } from "./bridge-event-sanitize";
+import { MAX_BRIDGE_BASE64_CHARACTERS, MAX_BRIDGE_LINE_LENGTH } from "./bridge-limits";
+import { CursorBridgeProtocolError } from "./bridge-protocol";
+const BridgeIdSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+const HeaderNameSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[!#$%&'*+.^_`|~0-9a-z-]+$/);
+const HeaderValueSchema = z
+    .string()
+    .max(8192)
+    .refine((value) => !/[\r\n]/.test(value));
+const HeadersSchema = z.record(HeaderNameSchema, HeaderValueSchema);
+const OpenHeadersSchema = z.record(HeaderNameSchema.refine((value) => !isSensitiveBridgeHeader(value)), HeaderValueSchema);
+const PathSchema = z
+    .string()
+    .min(1)
+    .max(2048)
+    .regex(/^\/[^\r\n]*$/);
+const AccessTokenSchema = z
+    .string()
+    .min(1)
+    .max(8192)
+    .refine((value) => !/[\r\n]/.test(value));
+function isCanonicalBase64(value) {
+    if (value.length === 0) {
+        return true;
+    }
+    if (value.length % 4 !== 0 ||
+        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+        return false;
+    }
+    return Buffer.from(value, "base64").toString("base64") === value;
+}
+const Base64Schema = z.string().max(MAX_BRIDGE_BASE64_CHARACTERS).refine(isCanonicalBase64, {
+    message: "invalid-base64",
+});
+const OpenCommandSchema = z
+    .object({
+    kind: z.literal("open"),
+    id: BridgeIdSchema,
+    accessToken: AccessTokenSchema,
+    path: PathSchema,
+    headers: OpenHeadersSchema,
+})
+    .strict();
+const WriteFrameCommandSchema = z
+    .object({ kind: z.literal("write-frame"), id: BridgeIdSchema, payload: Base64Schema })
+    .strict();
+const AbortCommandSchema = z.object({ kind: z.literal("abort"), id: BridgeIdSchema }).strict();
+const CloseCommandSchema = z.object({ kind: z.literal("close"), id: BridgeIdSchema }).strict();
+const CommandSchema = z.discriminatedUnion("kind", [
+    OpenCommandSchema,
+    WriteFrameCommandSchema,
+    AbortCommandSchema,
+    CloseCommandSchema,
+]);
+const OpenedEventSchema = z.object({ kind: z.literal("opened"), id: BridgeIdSchema }).strict();
+const HeadersEventSchema = z
+    .object({
+    kind: z.literal("headers"),
+    id: BridgeIdSchema,
+    status: z.number().int().min(100).max(599),
+    headers: HeadersSchema,
+})
+    .strict();
+const DataEventSchema = z
+    .object({ kind: z.literal("data"), id: BridgeIdSchema, payload: Base64Schema })
+    .strict();
+const TrailersEventSchema = z
+    .object({ kind: z.literal("trailers"), id: BridgeIdSchema, headers: HeadersSchema })
+    .strict();
+const EndEventSchema = z.object({ kind: z.literal("end"), id: BridgeIdSchema }).strict();
+const ErrorEventSchema = z
+    .object({
+    kind: z.literal("error"),
+    id: BridgeIdSchema,
+    code: z.string().min(1).max(128),
+    message: z.string().min(1).max(4096),
+})
+    .strict();
+const EventSchema = z.discriminatedUnion("kind", [
+    OpenedEventSchema,
+    HeadersEventSchema,
+    DataEventSchema,
+    TrailersEventSchema,
+    EndEventSchema,
+    ErrorEventSchema,
+]);
+function assertNever(value) {
+    void value;
+    throw new CursorBridgeProtocolError("invalid-message");
+}
+function parseJson(line) {
+    if (line.length > MAX_BRIDGE_LINE_LENGTH) {
+        throw new CursorBridgeProtocolError("line-too-long");
+    }
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        throw new CursorBridgeProtocolError("malformed-json");
+    }
+}
+function parseWireCommand(line) {
+    const result = CommandSchema.safeParse(parseJson(line));
+    if (!result.success) {
+        const code = result.error.issues.some((issue) => issue.message === "invalid-base64")
+            ? "invalid-base64"
+            : "invalid-message";
+        throw new CursorBridgeProtocolError(code);
+    }
+    return result.data;
+}
+function parseWireEvent(line) {
+    const result = EventSchema.safeParse(parseJson(line));
+    if (!result.success) {
+        const code = result.error.issues.some((issue) => issue.message === "invalid-base64")
+            ? "invalid-base64"
+            : "invalid-message";
+        throw new CursorBridgeProtocolError(code);
+    }
+    return result.data;
+}
+function decodeBase64(payload) {
+    return new Uint8Array(Buffer.from(payload, "base64"));
+}
+export function parseBridgeCommandLine(line) {
+    const command = parseWireCommand(line);
+    switch (command.kind) {
+        case "open":
+            return command;
+        case "write-frame":
+            return { kind: command.kind, id: command.id, payload: decodeBase64(command.payload) };
+        case "abort":
+        case "close":
+            return command;
+        default:
+            return assertNever(command);
+    }
+}
+export function parseBridgeEventLine(line) {
+    const event = parseWireEvent(line);
+    switch (event.kind) {
+        case "opened":
+        case "headers":
+        case "trailers":
+        case "end":
+        case "error":
+            return event;
+        case "data":
+            return { kind: event.kind, id: event.id, payload: decodeBase64(event.payload) };
+        default:
+            return assertNever(event);
+    }
+}

package/dist/providers/cursor/checkpoint-store.d.ts

@@ -0,0 +1,28 @@
+import type { Clock } from "../../core/clock";
+import { type CursorBlobId, type CursorBlobStore } from "./blob-store";
+import type { CursorSessionId } from "./session-state";
+export type CursorCheckpoint = {
+    readonly blobIds: readonly CursorBlobId[];
+    readonly bytes: Uint8Array;
+};
+export type CursorCheckpointUpdate = {
+    readonly blobIds?: readonly CursorBlobId[];
+    readonly bytes: Uint8Array;
+    readonly sessionId: CursorSessionId;
+};
+export type CursorCheckpointStoreOptions = {
+    readonly blobStore: CursorBlobStore;
+    readonly clock: Clock;
+    readonly maxBlobReferences?: number;
+    readonly maxBytes: number;
+    readonly maxEntries: number;
+    /** Logical milliseconds; zero expires checkpoints on the next store operation. */
+    readonly ttlMs: number;
+};
+export type CursorCheckpointStore = {
+    readonly invalidate: (sessionId: CursorSessionId) => void;
+    readonly resume: (sessionId: CursorSessionId) => CursorCheckpoint | null;
+    readonly size: () => number;
+    readonly update: (checkpoint: CursorCheckpointUpdate) => boolean;
+};
+export declare function createCursorCheckpointStore(options: CursorCheckpointStoreOptions): CursorCheckpointStore;

package/dist/providers/cursor/checkpoint-store.js

@@ -0,0 +1,94 @@
+import { requireCursorStoreTtl, requirePositiveCursorStoreBound, } from "./blob-store";
+export function createCursorCheckpointStore(options) {
+    const maxBlobReferences = options.maxBlobReferences ?? 64;
+    requirePositiveCursorStoreBound(maxBlobReferences, "maxBlobReferences");
+    requirePositiveCursorStoreBound(options.maxBytes, "maxBytes");
+    requirePositiveCursorStoreBound(options.maxEntries, "maxEntries");
+    requireCursorStoreTtl(options.ttlMs);
+    const entries = new Map();
+    let totalBytes = 0;
+    const release = (entry) => {
+        for (const blobId of entry.blobIds) {
+            options.blobStore.release(blobId);
+        }
+    };
+    const remove = (sessionId) => {
+        const entry = entries.get(sessionId);
+        if (entry !== undefined) {
+            entries.delete(sessionId);
+            totalBytes -= entry.bytes.byteLength;
+            release(entry);
+        }
+    };
+    const evictExpired = (nowMs) => {
+        for (const [sessionId, entry] of entries) {
+            if (nowMs - entry.lastAccessMs >= options.ttlMs) {
+                remove(sessionId);
+            }
+        }
+    };
+    const evictToBounds = () => {
+        while (entries.size > options.maxEntries || totalBytes > options.maxBytes) {
+            const oldest = entries.keys().next().value;
+            if (oldest === undefined) {
+                return;
+            }
+            remove(oldest);
+        }
+    };
+    const insert = (sessionId, entry) => {
+        remove(sessionId);
+        entries.set(sessionId, entry);
+        totalBytes += entry.bytes.byteLength;
+    };
+    const invalidate = remove;
+    return {
+        invalidate,
+        resume: (sessionId) => {
+            const nowMs = options.clock.nowMs();
+            evictExpired(nowMs);
+            const entry = entries.get(sessionId);
+            if (entry === undefined) {
+                return null;
+            }
+            for (const blobId of entry.blobIds) {
+                if (!options.blobStore.has(blobId)) {
+                    invalidate(sessionId);
+                    return null;
+                }
+            }
+            entries.delete(sessionId);
+            entries.set(sessionId, { ...entry, lastAccessMs: nowMs });
+            return { blobIds: [...entry.blobIds], bytes: new Uint8Array(entry.bytes) };
+        },
+        size: () => {
+            evictExpired(options.clock.nowMs());
+            return entries.size;
+        },
+        update: (checkpoint) => {
+            const nowMs = options.clock.nowMs();
+            evictExpired(nowMs);
+            const blobIds = checkpoint.blobIds ?? [];
+            if (checkpoint.bytes.byteLength > options.maxBytes || blobIds.length > maxBlobReferences) {
+                return false;
+            }
+            const pinned = [];
+            for (const blobId of blobIds) {
+                if (!options.blobStore.pin(blobId)) {
+                    for (const pinnedId of pinned) {
+                        options.blobStore.release(pinnedId);
+                    }
+                    return false;
+                }
+                pinned.push(blobId);
+            }
+            insert(checkpoint.sessionId, {
+                blobIds: [...blobIds],
+                bytes: new Uint8Array(checkpoint.bytes),
+                lastAccessMs: nowMs,
+            });
+            evictToBounds();
+            return entries.has(checkpoint.sessionId);
+        },
+    };
+}

package/dist/providers/cursor/connect-frame-stream.d.ts

@@ -0,0 +1,19 @@
+export type ConnectStreamFrame = {
+    readonly kind: "message";
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: "end";
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+    } | null;
+};
+export type ConnectFrameStreamDecoder = {
+    readonly push: (chunk: Uint8Array) => readonly ConnectStreamFrame[];
+    readonly finish: () => void;
+};
+export type ConnectFrameStreamDecoderOptions = {
+    readonly maxFrameBytes?: number;
+    readonly maxMessageBytes?: number;
+};
+export declare function createConnectFrameStreamDecoder(options?: ConnectFrameStreamDecoderOptions): ConnectFrameStreamDecoder;

package/dist/providers/cursor/connect-frame-stream.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { CONNECT_COMPRESSED, CONNECT_END_STREAM, MAX_CONNECT_FRAME_BYTES, MAX_CONNECT_MESSAGE_BYTES, } from "./connect-frame";
+import { CursorProtocolError } from "./proto/errors";
+const ConnectCodeSchema = z.enum([
+    "canceled",
+    "unknown",
+    "invalid_argument",
+    "deadline_exceeded",
+    "not_found",
+    "already_exists",
+    "permission_denied",
+    "resource_exhausted",
+    "failed_precondition",
+    "aborted",
+    "out_of_range",
+    "unimplemented",
+    "internal",
+    "unavailable",
+    "data_loss",
+    "unauthenticated",
+]);
+const ConnectEndStreamSchema = z
+    .object({
+    error: z
+        .object({
+        code: ConnectCodeSchema,
+        message: z.string().min(1),
+        details: z.array(z.unknown()).optional(),
+    })
+        .strict()
+        .optional(),
+    metadata: z.record(z.string(), z.array(z.string())).optional(),
+})
+    .strict();
+function validateBound(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new CursorProtocolError("malformed", "Connect stream", "invalid size bound");
+    }
+}
+function parseEndStream(bytes) {
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+        throw new CursorProtocolError("malformed", "Connect end-stream", "invalid UTF-8");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(decoded);
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+        throw new CursorProtocolError("malformed", "Connect end-stream", "invalid JSON");
+    }
+    const result = ConnectEndStreamSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new CursorProtocolError("malformed", "Connect end-stream", "invalid envelope");
+    }
+    const error = result.data.error;
+    return {
+        kind: "end",
+        error: error === undefined ? null : { code: error.code, message: error.message },
+    };
+}
+export function createConnectFrameStreamDecoder(options = {}) {
+    const maxMessageBytes = options.maxMessageBytes ?? MAX_CONNECT_MESSAGE_BYTES;
+    const maxFrameBytes = options.maxFrameBytes ?? MAX_CONNECT_FRAME_BYTES;
+    validateBound(maxMessageBytes);
+    validateBound(maxFrameBytes);
+    const header = new Uint8Array(5);
+    let headerBytes = 0;
+    let payload = new Uint8Array();
+    let payloadBytes = 0;
+    let endStream = false;
+    let ended = false;
+    const reset = () => {
+        headerBytes = 0;
+        payload = new Uint8Array();
+        payloadBytes = 0;
+        endStream = false;
+    };
+    const complete = () => {
+        const frame = endStream
+            ? parseEndStream(payload)
+            : { kind: "message", bytes: payload };
+        if (endStream)
+            ended = true;
+        reset();
+        return frame;
+    };
+    const parseHeader = () => {
+        const flags = header.at(0);
+        if (flags === undefined) {
+            throw new CursorProtocolError("truncated", "Connect stream", "frame flags are absent");
+        }
+        if ((flags & ~(CONNECT_COMPRESSED | CONNECT_END_STREAM)) !== 0) {
+            throw new CursorProtocolError("unsupported-flags", "Connect stream", `unsupported flags 0x${flags.toString(16)}`);
+        }
+        if ((flags & CONNECT_COMPRESSED) !== 0) {
+            throw new CursorProtocolError("unsupported-flags", "Connect stream", "compressed payload requires a negotiated decompressor");
+        }
+        const length = new DataView(header.buffer, header.byteOffset + 1, 4).getUint32(0);
+        if (length > maxMessageBytes) {
+            throw new CursorProtocolError("oversized", "Connect stream", `message exceeds ${maxMessageBytes} bytes`);
+        }
+        if (length + 5 > maxFrameBytes) {
+            throw new CursorProtocolError("oversized", "Connect stream", `frame exceeds ${maxFrameBytes} bytes`);
+        }
+        endStream = (flags & CONNECT_END_STREAM) !== 0;
+        payload = new Uint8Array(length);
+        return length === 0 ? complete() : null;
+    };
+    return {
+        push(chunk) {
+            if (ended && chunk.length > 0) {
+                throw new CursorProtocolError("malformed", "Connect stream", "data follows end-stream");
+            }
+            const frames = [];
+            let offset = 0;
+            while (offset < chunk.length) {
+                if (headerBytes < header.length) {
+                    const count = Math.min(header.length - headerBytes, chunk.length - offset);
+                    header.set(chunk.subarray(offset, offset + count), headerBytes);
+                    headerBytes += count;
+                    offset += count;
+                    if (headerBytes < header.length)
+                        continue;
+                    const empty = parseHeader();
+                    if (empty !== null)
+                        frames.push(empty);
+                    if (ended && offset < chunk.length) {
+                        throw new CursorProtocolError("malformed", "Connect stream", "data follows end-stream");
+                    }
+                    if (headerBytes === 0)
+                        continue;
+                }
+                const count = Math.min(payload.length - payloadBytes, chunk.length - offset);
+                payload.set(chunk.subarray(offset, offset + count), payloadBytes);
+                payloadBytes += count;
+                offset += count;
+                if (payloadBytes === payload.length) {
+                    frames.push(complete());
+                    if (ended && offset < chunk.length) {
+                        throw new CursorProtocolError("malformed", "Connect stream", "data follows end-stream");
+                    }
+                }
+            }
+            return frames;
+        },
+        finish() {
+            if (headerBytes !== 0 || payloadBytes !== 0) {
+                throw new CursorProtocolError("truncated", "Connect stream", "trailing partial frame");
+            }
+        },
+    };
+}

package/dist/providers/cursor/connect-frame.d.ts

@@ -0,0 +1,31 @@
+export declare const CONNECT_COMPRESSED: number;
+export declare const CONNECT_END_STREAM: number;
+export declare const MAX_CONNECT_MESSAGE_BYTES: number;
+export declare const MAX_CONNECT_FRAME_BYTES: number;
+export type ConnectFrame = {
+    readonly compressed: boolean;
+    readonly endStream: boolean;
+    readonly bytes: Uint8Array;
+};
+export type ConnectFrameOptions = {
+    readonly compressed?: boolean;
+    readonly endStream?: boolean;
+    readonly maxMessageBytes?: number;
+};
+export type ConnectDecodeOptions = {
+    readonly maxFrameBytes?: number;
+    readonly maxMessageBytes?: number;
+};
+export type ConnectDecompressor = (bytes: Uint8Array, maxOutputBytes: number) => Uint8Array;
+export type ConnectPayloadDecodeOptions = {
+    readonly maxOutputBytes: number;
+    readonly decompressor?: ConnectDecompressor;
+};
+export declare function decodeConnectFramePayload(frame: ConnectFrame, options: ConnectPayloadDecodeOptions): Uint8Array;
+export declare function encodeConnectFrame(message: Uint8Array, options?: ConnectFrameOptions): Uint8Array;
+export declare function decodeConnectFrames(buffer: Uint8Array): readonly ConnectFrame[];
+export declare function decodeConnectFramesWithRest(buffer: Uint8Array): {
+    readonly frames: readonly ConnectFrame[];
+    readonly rest: Uint8Array;
+};
+export declare function decodeConnectFramesStrict(buffer: Uint8Array, options?: ConnectDecodeOptions): readonly ConnectFrame[];

package/dist/providers/cursor/connect-frame.js

@@ -0,0 +1,121 @@
+// Derived from Rahularya01/pi-cursor Connect envelope handling. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { CursorProtocolError } from "./proto/errors";
+export const CONNECT_COMPRESSED = 0x01;
+export const CONNECT_END_STREAM = 0x02;
+export const MAX_CONNECT_MESSAGE_BYTES = 64 * 1024 * 1024;
+export const MAX_CONNECT_FRAME_BYTES = MAX_CONNECT_MESSAGE_BYTES + 5;
+export function decodeConnectFramePayload(frame, options) {
+    validateBound(options.maxOutputBytes, "Connect payload");
+    if (frame.endStream) {
+        throw new CursorProtocolError("malformed", "Connect frame", "end-stream has no protobuf payload");
+    }
+    if (!frame.compressed) {
+        if (frame.bytes.length > options.maxOutputBytes) {
+            throw new CursorProtocolError("oversized", "Connect payload", `message exceeds ${options.maxOutputBytes} bytes`);
+        }
+        return frame.bytes;
+    }
+    if (options.decompressor === undefined) {
+        throw new CursorProtocolError("unsupported-flags", "Connect frame", "compressed payload requires a negotiated decompressor");
+    }
+    const payload = options.decompressor(frame.bytes, options.maxOutputBytes);
+    if (payload.length > options.maxOutputBytes) {
+        throw new CursorProtocolError("oversized", "Connect payload", `decompressed message exceeds ${options.maxOutputBytes} bytes`);
+    }
+    return payload;
+}
+function validateBound(value, context) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new CursorProtocolError("malformed", context, "invalid size bound");
+    }
+}
+export function encodeConnectFrame(message, options = {}) {
+    const maxMessageBytes = options.maxMessageBytes ?? MAX_CONNECT_MESSAGE_BYTES;
+    validateBound(maxMessageBytes, "Connect frame");
+    if (message.length > maxMessageBytes) {
+        throw new CursorProtocolError("oversized", "Connect frame", `message exceeds ${maxMessageBytes} bytes`);
+    }
+    const frame = new Uint8Array(5 + message.length);
+    frame[0] =
+        (options.compressed === true ? CONNECT_COMPRESSED : 0) |
+            (options.endStream === true ? CONNECT_END_STREAM : 0);
+    const view = new DataView(frame.buffer, frame.byteOffset, 5);
+    view.setUint32(1, message.length);
+    frame.set(message, 5);
+    return frame;
+}
+export function decodeConnectFrames(buffer) {
+    const frames = [];
+    let offset = 0;
+    while (offset + 5 <= buffer.length) {
+        const flags = buffer[offset] ?? 0;
+        const view = new DataView(buffer.buffer, buffer.byteOffset + offset + 1, 4);
+        const length = view.getUint32(0);
+        const start = offset + 5;
+        const end = start + length;
+        if (end > buffer.length) {
+            break;
+        }
+        frames.push({
+            compressed: (flags & CONNECT_COMPRESSED) !== 0,
+            endStream: (flags & CONNECT_END_STREAM) !== 0,
+            bytes: buffer.subarray(start, end),
+        });
+        offset = end;
+    }
+    return frames;
+}
+export function decodeConnectFramesWithRest(buffer) {
+    const frames = decodeConnectFrames(buffer);
+    let offset = 0;
+    for (const frame of frames) {
+        offset += 5 + frame.bytes.length;
+    }
+    return { frames, rest: buffer.subarray(offset) };
+}
+export function decodeConnectFramesStrict(buffer, options = {}) {
+    const context = "Connect frame";
+    const maxMessageBytes = options.maxMessageBytes ?? MAX_CONNECT_MESSAGE_BYTES;
+    const maxFrameBytes = options.maxFrameBytes ?? MAX_CONNECT_FRAME_BYTES;
+    validateBound(maxMessageBytes, context);
+    validateBound(maxFrameBytes, context);
+    const frames = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        if (buffer.length - offset < 5) {
+            throw new CursorProtocolError("truncated", context, "frame header is incomplete");
+        }
+        const flags = buffer[offset];
+        if (flags === undefined) {
+            throw new CursorProtocolError("truncated", context, "frame flags are absent");
+        }
+        if ((flags & ~(CONNECT_COMPRESSED | CONNECT_END_STREAM)) !== 0) {
+            throw new CursorProtocolError("unsupported-flags", context, `unsupported flags 0x${flags.toString(16)}`);
+        }
+        if ((flags & (CONNECT_COMPRESSED | CONNECT_END_STREAM)) ===
+            (CONNECT_COMPRESSED | CONNECT_END_STREAM)) {
+            throw new CursorProtocolError("unsupported-flags", context, "end-stream envelope cannot be compressed");
+        }
+        const view = new DataView(buffer.buffer, buffer.byteOffset + offset + 1, 4);
+        const length = view.getUint32(0);
+        if (length > maxMessageBytes) {
+            throw new CursorProtocolError("oversized", context, `message exceeds ${maxMessageBytes} bytes`);
+        }
+        if (length + 5 > maxFrameBytes) {
+            throw new CursorProtocolError("oversized", context, `frame exceeds ${maxFrameBytes} bytes`);
+        }
+        const start = offset + 5;
+        const end = start + length;
+        if (end > buffer.length) {
+            throw new CursorProtocolError("truncated", context, "frame payload is incomplete");
+        }
+        frames.push({
+            compressed: (flags & CONNECT_COMPRESSED) !== 0,
+            endStream: (flags & CONNECT_END_STREAM) !== 0,
+            bytes: buffer.subarray(start, end),
+        });
+        offset = end;
+    }
+    return frames;
+}

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

@@ -0,0 +1,5 @@
+export type CursorCredentials = {
+    readonly accessToken: string;
+    readonly refreshToken: string | null;
+};
+export declare function parseCursorCredentials(value: unknown): CursorCredentials | null;