@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
129 lines (115 loc) • 5.27 kB
text/typescript
import { randomBytes } from "node:crypto";
import { REMOTE_CONTROL_MAX_RELAY_PAYLOAD_BYTES } from "./protocol";
const RPC_FRAME_MAGIC = Uint8Array.of(0x4f, 0x43, 0x58, 0x52); // OCXR
const RPC_FRAME_VERSION = 1;
const RPC_FRAME_HEADER_BYTES = 30;
const RPC_FRAME_MESSAGE_ID_BYTES = 16;
const RPC_FRAME_MESSAGE_ID_OFFSET = 6;
const RPC_FRAME_TOTAL_BYTES_OFFSET = 22;
const RPC_FRAME_CHUNK_OFFSET = 26;
const RPC_ENCRYPTION_OVERHEAD_BYTES = 24;
const RPC_MAX_PLAINTEXT_FRAME_BYTES = REMOTE_CONTROL_MAX_RELAY_PAYLOAD_BYTES - RPC_ENCRYPTION_OVERHEAD_BYTES;
const RPC_MAX_CHUNK_BYTES = RPC_MAX_PLAINTEXT_FRAME_BYTES - RPC_FRAME_HEADER_BYTES;
const RPC_MAX_INCOMPLETE_MESSAGES = 8;
const RPC_INCOMPLETE_MESSAGE_TTL_MS = 30_000;
// A 256 KiB UTF-8 write can expand by up to 6x when JSON escapes control bytes.
// Keep the wire contract bounded while still carrying every executor-approved text file.
export const REMOTE_WORKSPACE_RPC_MAX_MESSAGE_BYTES = 2 * 1024 * 1024;
interface IncompleteMessage {
buffer: Uint8Array;
nextOffset: number;
timer: ReturnType<typeof setTimeout>;
}
function hasMagic(value: Uint8Array): boolean {
return RPC_FRAME_MAGIC.every((byte, index) => value[index] === byte);
}
function messageKey(frame: Uint8Array): string {
return Buffer.from(
frame.subarray(RPC_FRAME_MESSAGE_ID_OFFSET, RPC_FRAME_MESSAGE_ID_OFFSET + RPC_FRAME_MESSAGE_ID_BYTES),
).toString("hex");
}
function writeHeader(frame: Uint8Array, messageId: Uint8Array, totalBytes: number, offset: number): void {
frame.set(RPC_FRAME_MAGIC, 0);
frame[4] = RPC_FRAME_VERSION;
frame[5] = 0;
frame.set(messageId, RPC_FRAME_MESSAGE_ID_OFFSET);
const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
view.setUint32(RPC_FRAME_TOTAL_BYTES_OFFSET, totalBytes);
view.setUint32(RPC_FRAME_CHUNK_OFFSET, offset);
}
/**
* Splits one logical RPC message without retaining a second full-size copy.
* Each yielded plaintext fits one authenticated relay frame.
*/
export function* frameRemoteWorkspaceRpcMessage(message: Uint8Array): Generator<Uint8Array> {
if (!(message instanceof Uint8Array)
|| message.byteLength < 1
|| message.byteLength > REMOTE_WORKSPACE_RPC_MAX_MESSAGE_BYTES) {
throw new Error("invalid remote workspace RPC message length");
}
const messageId = randomBytes(RPC_FRAME_MESSAGE_ID_BYTES);
for (let offset = 0; offset < message.byteLength; offset += RPC_MAX_CHUNK_BYTES) {
const end = Math.min(offset + RPC_MAX_CHUNK_BYTES, message.byteLength);
const frame = new Uint8Array(RPC_FRAME_HEADER_BYTES + end - offset);
writeHeader(frame, messageId, message.byteLength, offset);
frame.set(message.subarray(offset, end), RPC_FRAME_HEADER_BYTES);
yield frame;
}
}
/** Bounded, ordered reassembly for authenticated RPC fragments. */
export class RemoteWorkspaceRpcReassembler {
private readonly incomplete = new Map<string, IncompleteMessage>();
accept(frame: Uint8Array): Uint8Array | null {
if (!(frame instanceof Uint8Array)
|| frame.byteLength <= RPC_FRAME_HEADER_BYTES
|| frame.byteLength > RPC_MAX_PLAINTEXT_FRAME_BYTES
|| !hasMagic(frame)
|| frame[4] !== RPC_FRAME_VERSION
|| frame[5] !== 0) {
throw new Error("invalid remote workspace RPC frame");
}
const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
const totalBytes = view.getUint32(RPC_FRAME_TOTAL_BYTES_OFFSET);
const offset = view.getUint32(RPC_FRAME_CHUNK_OFFSET);
const payload = frame.subarray(RPC_FRAME_HEADER_BYTES);
if (totalBytes < 1
|| totalBytes > REMOTE_WORKSPACE_RPC_MAX_MESSAGE_BYTES
|| offset >= totalBytes
|| payload.byteLength > totalBytes - offset
|| (offset + payload.byteLength < totalBytes && payload.byteLength !== RPC_MAX_CHUNK_BYTES)) {
throw new Error("invalid remote workspace RPC fragment bounds");
}
if (offset === 0 && payload.byteLength === totalBytes) return payload;
const key = messageKey(frame);
let state = this.incomplete.get(key);
if (!state) {
if (offset !== 0) throw new Error("remote workspace RPC fragment started out of order");
if (this.incomplete.size >= RPC_MAX_INCOMPLETE_MESSAGES) {
throw new Error("remote workspace RPC fragment limit reached");
}
const timer = setTimeout(() => this.drop(key), RPC_INCOMPLETE_MESSAGE_TTL_MS);
timer.unref?.();
state = { buffer: new Uint8Array(totalBytes), nextOffset: 0, timer };
this.incomplete.set(key, state);
} else if (state.buffer.byteLength !== totalBytes || state.nextOffset !== offset) {
this.drop(key);
throw new Error("remote workspace RPC fragments are inconsistent or out of order");
}
state.buffer.set(payload, offset);
state.nextOffset += payload.byteLength;
if (state.nextOffset !== totalBytes) return null;
this.incomplete.delete(key);
clearTimeout(state.timer);
return state.buffer;
}
clear(): void {
for (const state of this.incomplete.values()) clearTimeout(state.timer);
this.incomplete.clear();
}
private drop(key: string): void {
const state = this.incomplete.get(key);
if (!state) return;
clearTimeout(state.timer);
this.incomplete.delete(key);
}
}