@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
362 lines (331 loc) • 13 kB
text/typescript
import { create, toBinary } from "@bufbuild/protobuf";
import type { TranslatorBudget } from "../../lib/translator-budget";
import { CURSOR_MAX_EFFECTIVE_CONNECT_PAYLOAD_BYTES } from "../../lib/translator-budget";
import { readBoundedResponseBytes } from "../../lib/bounded-body";
import { withUpstreamHttpVersionValue } from "../../lib/upstream-http-version";
import { isPreConnectReachabilityError } from "../../lib/upstream-reachability";
import { BidiRequestIdSchema } from "./gen/agent_pb";
import { consumeConnectFrames, encodeConnectFrame } from "./framing";
const CURSOR_RUN_SSE_PATH = "/agent.v1.AgentService/RunSSE";
const CURSOR_BIDI_APPEND_PATH = "/aiserver.v1.BidiService/BidiAppend";
const CURSOR_HTTP1_APPEND_TIMEOUT_MS = 30_000;
const CURSOR_HTTP1_APPEND_RESPONSE_MAX_BYTES = 64 * 1024;
const HEX = "0123456789abcdef";
export interface CursorHttp1BidiCallbacks {
onCommitted(): void;
onData(chunk: Uint8Array): void;
onEnd(): void;
onError(error: Error): void;
}
export interface CursorHttp1BidiOptions {
baseUrl: string;
token: string;
clientVersion: string;
sessionId: string;
requestId: string;
translatorBudget: TranslatorBudget;
callbacks: CursorHttp1BidiCallbacks;
fetch?: typeof globalThis.fetch;
}
interface PendingAppend {
payload: Uint8Array;
seqno: bigint;
rawBytesCharged: boolean;
}
function varintLength(value: bigint): number {
let length = 1;
for (let current = value; current >= 0x80n; current >>= 7n) length += 1;
return length;
}
function writeVarint(target: Uint8Array, offset: number, value: bigint): number {
let current = value;
while (current >= 0x80n) {
target[offset++] = Number(current & 0x7fn) | 0x80;
current >>= 7n;
}
target[offset++] = Number(current);
return offset;
}
function requestIdMessageBytes(requestId: string): Uint8Array {
const value = new TextEncoder().encode(requestId);
const message = new Uint8Array(1 + varintLength(BigInt(value.byteLength)) + value.byteLength);
let offset = 0;
message[offset++] = 0x0a; // field 1, string request_id
offset = writeVarint(message, offset, BigInt(value.byteLength));
message.set(value, offset);
return message;
}
/** Exact encoded size of Cursor's aiserver.v1.BidiAppendRequest hex fallback shape. */
export function cursorBidiAppendRequestSize(payloadBytes: number, requestId: string, seqno: bigint): number {
const hexBytes = payloadBytes * 2;
const requestIdBytes = requestIdMessageBytes(requestId).byteLength;
return (hexBytes > 0 ? 1 + varintLength(BigInt(hexBytes)) + hexBytes : 0)
+ 1 + varintLength(BigInt(requestIdBytes)) + requestIdBytes
+ (seqno > 0n ? 1 + varintLength(seqno) : 0);
}
/**
* Encode the compatibility request used by Cursor when HTTP/2 is disabled.
* The public client defaults to field 1's hexadecimal data when its binary-append
* feature gate is unavailable, so OpenCodex uses that backwards-compatible shape.
*/
export function encodeCursorBidiAppendRequest(
payload: Uint8Array,
requestId: string,
seqno: bigint,
): Uint8Array {
const requestIdBytes = requestIdMessageBytes(requestId);
const output = new Uint8Array(cursorBidiAppendRequestSize(payload.byteLength, requestId, seqno));
let offset = 0;
if (payload.byteLength > 0) {
const hexBytes = payload.byteLength * 2;
output[offset++] = 0x0a; // field 1, string data
offset = writeVarint(output, offset, BigInt(hexBytes));
for (const byte of payload) {
output[offset++] = HEX.charCodeAt(byte >>> 4);
output[offset++] = HEX.charCodeAt(byte & 0x0f);
}
}
output[offset++] = 0x12; // field 2, BidiRequestId request_id
offset = writeVarint(output, offset, BigInt(requestIdBytes.byteLength));
output.set(requestIdBytes, offset);
offset += requestIdBytes.byteLength;
if (seqno > 0n) {
output[offset++] = 0x18; // field 3, int64 append_seqno
offset = writeVarint(output, offset, seqno);
}
return output;
}
function cursorHttp1Error(operation: "RunSSE" | "BidiAppend", status: number): Error {
return new Error(`Cursor HTTP/1.1 ${operation} failed with HTTP ${status || "unknown"}`);
}
function asError(error: unknown): Error {
return error instanceof Error ? error : new Error(String(error));
}
/** Bun accepts Uint8Array request bodies; TypeScript's DOM BodyInit omits that runtime shape. */
function bunFetchBody(bytes: Uint8Array): BodyInit {
return bytes as unknown as BodyInit;
}
/**
* Cursor's HTTP/1.1 compatibility bridge: a server-streaming RunSSE request carries
* output, while each client message is posted separately through BidiAppend.
*/
export class CursorHttp1BidiConnection {
private readonly abortController = new AbortController();
private readonly fetchImpl: typeof globalThis.fetch;
private readonly runSseReady: Promise<void>;
private resolveRunSseReady!: () => void;
private rejectRunSseReady!: (reason?: unknown) => void;
private appendChain: Promise<void> = Promise.resolve();
private nextAppendSeqno = 0n;
private committed = false;
private paused = false;
private resumeWaiters: Array<() => void> = [];
private terminal = false;
private closed = false;
destroyed = false;
constructor(private readonly options: CursorHttp1BidiOptions) {
this.fetchImpl = options.fetch ?? globalThis.fetch;
this.runSseReady = new Promise<void>((resolve, reject) => {
this.resolveRunSseReady = resolve;
this.rejectRunSseReady = reject;
});
// A RunSSE failure can happen before the first append reaches its await; observe it here so
// the readiness promise never becomes an unhandled rejection.
void this.runSseReady.catch(() => undefined);
}
start(): void {
void this.runSse().catch(error => {
this.rejectRunSseReady(error);
this.fail(asError(error));
});
}
write(frameBytes: Uint8Array): boolean {
if (this.closed || this.terminal) return false;
let frame;
try {
const decoded = consumeConnectFrames(frameBytes, CURSOR_MAX_EFFECTIVE_CONNECT_PAYLOAD_BYTES, 2);
if (decoded.frames.length !== 1 || decoded.consumedBytes !== frameBytes.byteLength) {
throw new Error("Cursor HTTP/1.1 append requires exactly one complete Connect frame");
}
frame = decoded.frames[0]!;
if (frame.flags !== 0) throw new Error(`Cursor HTTP/1.1 append does not support Connect flags ${frame.flags}`);
this.options.translatorBudget.chargeRetained(frame.payload.byteLength, { kind: "request_copies" });
} catch (error) {
this.fail(asError(error));
return false;
}
const pending: PendingAppend = {
payload: frame.payload,
seqno: this.nextAppendSeqno++,
rawBytesCharged: true,
};
this.appendChain = this.appendChain
.then(() => this.postAppend(pending))
.catch(error => this.fail(asError(error)))
.finally(() => {
if (!pending.rawBytesCharged) return;
pending.rawBytesCharged = false;
this.options.translatorBudget.releaseRetained(pending.payload.byteLength, { kind: "request_copies" });
});
return true;
}
pause(): void {
this.paused = true;
}
resume(): void {
if (!this.paused) return;
this.paused = false;
const waiters = this.resumeWaiters;
this.resumeWaiters = [];
for (const resume of waiters) resume();
}
close(): void {
if (this.closed) return;
this.closed = true;
this.destroyed = true;
this.resume();
const reason = new DOMException("Cursor HTTP/1.1 connection closed", "AbortError");
this.rejectRunSseReady(reason);
this.abortController.abort(reason);
queueMicrotask(() => this.finish());
}
destroy(): void {
this.close();
}
private commonHeaders(contentType: string): Headers {
return new Headers({
"content-type": contentType,
"connect-protocol-version": "1",
authorization: `Bearer ${this.options.token}`,
"x-ghost-mode": "true",
"x-cursor-client-version": this.options.clientVersion,
"x-cursor-client-type": "cli",
"x-request-id": this.options.requestId,
"x-session-id": this.options.sessionId,
});
}
private requestUrl(path: string): string {
const url = new URL(path, this.options.baseUrl);
if (url.protocol !== "https:") {
throw new Error("Cursor HTTP/1.1 transport requires an HTTPS base URL");
}
return url.toString();
}
private http1Init(url: string, init: RequestInit): RequestInit {
return withUpstreamHttpVersionValue(url, init, "http1.1") ?? init;
}
private markCommitted(): void {
if (this.committed) return;
this.committed = true;
this.options.callbacks.onCommitted();
}
private async runSse(): Promise<void> {
const url = this.requestUrl(CURSOR_RUN_SSE_PATH);
const requestId = toBinary(BidiRequestIdSchema, create(BidiRequestIdSchema, {
requestId: this.options.requestId,
}));
const response = await this.fetchImpl(url, this.http1Init(url, {
method: "POST",
headers: this.commonHeaders("application/connect+proto"),
body: bunFetchBody(encodeConnectFrame(requestId)),
redirect: "manual",
signal: this.abortController.signal,
}));
if (response.status !== 200) {
void response.body?.cancel().catch(() => undefined);
throw cursorHttp1Error("RunSSE", response.status);
}
if (!response.body) throw new Error("Cursor HTTP/1.1 RunSSE returned no response body");
// Cursor has accepted the request id once RunSSE returns successful headers. Do not race the
// first BidiAppend ahead of that registration.
this.resolveRunSseReady();
const reader = response.body.getReader();
try {
while (!this.closed && !this.terminal) {
await this.waitWhilePaused();
if (this.closed || this.terminal) break;
const { value, done } = await reader.read();
if (done) break;
if (value && value.byteLength > 0) this.options.callbacks.onData(value);
}
this.finish();
} finally {
try { reader.releaseLock(); } catch { /* a pending abort may still own it */ }
}
}
private async postAppend(pending: PendingAppend): Promise<void> {
if (this.closed || this.terminal) return;
await this.runSseReady;
if (this.closed || this.terminal) return;
const encodedBytes = cursorBidiAppendRequestSize(
pending.payload.byteLength,
this.options.requestId,
pending.seqno,
);
const reservation = this.options.translatorBudget.reserveTransient(encodedBytes, { kind: "request_copies" });
let body: Uint8Array;
try {
body = encodeCursorBidiAppendRequest(pending.payload, this.options.requestId, pending.seqno);
} catch (error) {
reservation.release();
throw error;
}
if (pending.rawBytesCharged) {
pending.rawBytesCharged = false;
this.options.translatorBudget.releaseRetained(pending.payload.byteLength, { kind: "request_copies" });
}
try {
const url = this.requestUrl(CURSOR_BIDI_APPEND_PATH);
const timeout = AbortSignal.timeout(CURSOR_HTTP1_APPEND_TIMEOUT_MS);
const signal = AbortSignal.any([this.abortController.signal, timeout]);
let response: Response;
try {
response = await this.fetchImpl(url, this.http1Init(url, {
method: "POST",
headers: this.commonHeaders("application/proto"),
body: bunFetchBody(body),
redirect: "manual",
signal,
}));
} catch (error) {
// A proven DNS/TCP pre-connect failure means no append bytes reached Cursor and replay is
// safe. Every ambiguous rejection stays conservative: the server may have accepted the
// append before the response path failed, so suppress replay exactly as the h2 path does.
if (!isPreConnectReachabilityError(error)) this.markCommitted();
throw error;
}
this.markCommitted();
if (response.status !== 200) {
void response.body?.cancel().catch(() => undefined);
throw cursorHttp1Error("BidiAppend", response.status);
}
const result = await readBoundedResponseBytes(response, {
maxBytes: CURSOR_HTTP1_APPEND_RESPONSE_MAX_BYTES,
signal,
});
if (result.oversized) throw new Error("Cursor HTTP/1.1 BidiAppend response exceeds 64 KiB");
} finally {
reservation.release();
}
}
private waitWhilePaused(): Promise<void> {
if (!this.paused) return Promise.resolve();
return new Promise(resolve => this.resumeWaiters.push(resolve));
}
private fail(error: Error): void {
if (this.terminal) return;
this.terminal = true;
this.destroyed = true;
this.resume();
this.rejectRunSseReady(error);
if (!this.abortController.signal.aborted) this.abortController.abort(error);
this.options.callbacks.onError(error);
}
private finish(): void {
if (this.terminal) return;
this.terminal = true;
this.destroyed = true;
this.resume();
this.options.callbacks.onEnd();
}
}