UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

271 lines (250 loc) • 11.2 kB
import { OPEN_CODEX_CREDENTIAL_PATTERN, REDACTED_SECRET } from "../../lib/redact"; const TAIL_CHARS = 512; const BATCH_CHARS = 2 * TAIL_CHARS; const MAX_ORDERED_CHUNKS = 64; const MAX_ORDERED_CHARS = 2 * BATCH_CHARS; const BEARER = /\b(Bearer[ \t]{1,64})[A-Za-z0-9._~+/=-]{8,}/i; const JWT = /\beyJ[A-Za-z0-9_-]{8}[A-Za-z0-9._-]*/; const API_KEY = /\bsk-[A-Za-z0-9][A-Za-z0-9._-]{6,}/; const OAUTH_LABELS = ["access_token", "refresh_token", "id_token", "access-token", "refresh-token", "id-token", "accessToken", "refreshToken", "idToken"]; const OAUTH_BOUNDARY = /(?<![A-Za-z0-9_-])/; const OAUTH_KEY_END = /["']?[ \t]{0,64}/; const BARE_OAUTH_CHAR = /[^\s"'`,;{}\[\]<>]/; const OAUTH_LABEL = "(?:" + OAUTH_LABELS.join("|") + ")"; const OAUTH_JSON_KEY = '(?<=")' + OAUTH_LABEL + '"'; const OAUTH_ASSIGNMENT = OAUTH_BOUNDARY.source + OAUTH_LABEL + OAUTH_KEY_END.source + "[:=]"; const JSON_WHITESPACE = /^[ \t\r\n]*/; const INLINE_WHITESPACE = /^[ \t]*/; const TOKEN_PATTERN = new RegExp( `${OPEN_CODEX_CREDENTIAL_PATTERN.source}|(${BEARER.source})|(${JWT.source}|${API_KEY.source})|(${OAUTH_JSON_KEY})|(${OAUTH_ASSIGNMENT})`, "gi", ); const BEARER_CONTINUATION = /^[A-Za-z0-9._~+/=-]*/; const KEY_CONTINUATION = /^[A-Za-z0-9._-]*/; const OAUTH_LABEL_PREFIXES = new Set(OAUTH_LABELS.flatMap(label => Array.from({ length: label.length - 1 }, (_, index) => label.slice(0, index + 1)))); const INCOMPLETE_OAUTH = new RegExp(OAUTH_BOUNDARY.source + "(?:" + [...OAUTH_LABEL_PREFIXES].join("|") + "|(?!" + OAUTH_JSON_KEY + ")" + OAUTH_LABEL + OAUTH_KEY_END.source + ")"); // A short suffix that could start or complete a supported credential in a later frame. const INCOMPLETE_TOKEN = new RegExp(`(?:${[ /o(?:c(?:x(?:_[A-Za-z0-9_-]{0,51}|r(?:w(?:_[A-Za-z0-9_-]{0,42})?)?)?)?)?/, /\b(?:b|be|bea|bear|beare|bearer(?:[ \t]{1,64}[A-Za-z0-9._~+/=-]{0,7})?)/, /\b(?:e|ey|eyj[A-Za-z0-9_-]{0,7})/, /\b(?:s|sk|sk-[A-Za-z0-9._-]{0,6})/, INCOMPLETE_OAUTH, ].map(pattern => pattern.source).join("|")})$`, "i"); type ConsumeSpan = (raw: string, replacement?: string) => void; type OAuthSeparator = { phase: "delimiter" | "json-value" | "inline-value"; exhausted: boolean }; type OAuthValue = { quote?: string; escaped: boolean; masked: boolean }; /** Bound lookahead, then discard a recognized long token's remaining characters as they arrive. */ class AcpOutputRedactor { private pending = ""; private previous = ""; private continuation?: RegExp; private oauthSeparator?: OAuthSeparator; private oauthValue?: OAuthValue; constructor(private readonly consume: ConsumeSpan) {} push(chunk: string): void { for (let offset = 0; offset < chunk.length; offset += BATCH_CHARS) { this.pending += chunk.slice(offset, offset + BATCH_CHARS); if (this.pending.length >= BATCH_CHARS) this.drain("batch"); } this.drain("stream"); } flush(): void { this.drain("final"); } private consumeOAuthSeparator(raw: string, start: number, separator: OAuthSeparator, final: boolean): number { const pattern = separator.phase === "inline-value" ? INLINE_WHITESPACE : JSON_WHITESPACE; const whitespace = pattern.exec(raw.slice(start))![0]; const valueStart = start + whitespace.length; separator.exhausted ||= whitespace.length >= TAIL_CHARS; this.oauthSeparator = !final && valueStart === raw.length ? separator : undefined; if (this.oauthSeparator && !separator.exhausted) return start; // Once the lookahead fills, stream the whitespace and remember the value is still pending. this.consume(whitespace); if (valueStart === raw.length) return valueStart; if (separator.phase === "delimiter") { const delimiter = raw.charAt(valueStart); if (delimiter === ":" || (delimiter === "=" && (separator.exhausted || !/[\r\n]/.test(whitespace)))) { this.consume(delimiter); const phase = delimiter === ":" || separator.exhausted ? "json-value" : "inline-value"; return this.consumeOAuthSeparator(raw, valueStart + 1, { phase, exhausted: false }, final); } if (!separator.exhausted) return valueStart; } const char = raw.charAt(valueStart); const quote = char === '"' || char === "'" ? char : undefined; if (quote) this.consume(quote); else if (!BARE_OAUTH_CHAR.test(char)) return valueStart; return this.consumeOAuthValue(raw, valueStart + (quote?.length ?? 0), { quote, escaped: false, masked: false }); } private consumeOAuthValue(raw: string, start: number, value: OAuthValue): number { let end = start; for (; end < raw.length; end++) { const char = raw[end]!; if (!value.quote) { if (!BARE_OAUTH_CHAR.test(char)) break; } else if (value.escaped) { value.escaped = false; } else if (char === value.quote) { break; } else { value.escaped = char === "\\"; } } if (end > start) { this.consume(raw.slice(start, end), value.masked ? "" : REDACTED_SECRET); value.masked = true; } this.oauthValue = end === raw.length ? value : undefined; return end; } private drain(mode: "batch" | "stream" | "final"): void { const final = mode === "final"; if (this.oauthSeparator || this.oauthValue) { const consumed = this.oauthSeparator ? this.consumeOAuthSeparator(this.pending, 0, this.oauthSeparator, final) : this.consumeOAuthValue(this.pending, 0, this.oauthValue!); if (consumed) this.previous = this.pending.charAt(consumed - 1); this.pending = this.pending.slice(consumed); if (this.oauthSeparator || this.oauthValue) return; } if (this.continuation) { const tail = this.continuation.exec(this.pending)![0]; this.pending = this.pending.slice(tail.length); if (tail) { this.consume(tail, ""); this.previous = tail.slice(-1); } if (!this.pending && !final) return; this.continuation = undefined; } const raw = this.previous + this.pending; const start = this.previous.length; const incomplete = mode === "stream" ? INCOMPLETE_TOKEN.exec(raw) : null; let cut = mode === "batch" ? Math.max(start, raw.length - TAIL_CHARS) : Math.max(start, incomplete?.index ?? raw.length); if (!final && /[\uD800-\uDBFF]/.test(raw.charAt(cut - 1))) cut = Math.max(start, cut - 1); let cursor = start; TOKEN_PATTERN.lastIndex = start; let match: RegExpExecArray | null; while ((match = TOKEN_PATTERN.exec(raw)) !== null && match.index < cut) { const end = match.index + match[0].length; const [, bearer, bearerPrefix, key, jsonKey, assignment] = match; if (jsonKey || assignment) { this.consume(raw.slice(cursor, end)); const phase = jsonKey ? "delimiter" : "inline-value"; cursor = this.consumeOAuthSeparator(raw, end, { phase, exhausted: false }, final); if (this.oauthSeparator) { // Keep the unresolved separator for the next drain. cut = cursor; break; } // An overlapping match can start inside the OAuth value and extend beyond it. TOKEN_PATTERN.lastIndex = cursor; continue; } const valueStart = match.index + (bearerPrefix?.length ?? 0); this.consume(raw.slice(cursor, valueStart)); this.consume(raw.slice(valueStart, end), REDACTED_SECRET); cursor = end; if (!final && end === raw.length) { this.continuation = bearer ? BEARER_CONTINUATION : key ? KEY_CONTINUATION : undefined; } } const consumed = Math.max(cut, cursor); this.consume(raw.slice(cursor, consumed)); this.previous = final ? "" : raw.charAt(consumed - 1); this.pending = raw.slice(consumed); } } type OutputType = "text_delta" | "thinking_delta"; interface PendingChunk { type: OutputType; remaining: number; safe: string; released?: boolean; } /** Match each channel independently while publishing safe spans in ACP arrival order. */ export class AcpTurnOutput { private readonly streams = new Map<OutputType, { redactor: AcpOutputRedactor; chunks: PendingChunk[] }>(); private pending: PendingChunk[] = []; private head = 0; constructor(private readonly emit: (type: OutputType, text: string) => void) {} push(type: OutputType, text: string): boolean { if (!text) return false; let stream = this.streams.get(type); if (!stream) { const chunks: PendingChunk[] = []; stream = { chunks, redactor: new AcpOutputRedactor((raw, replacement) => this.consume(chunks, raw, replacement)) }; this.streams.set(type, stream); } const chunk = { type, remaining: text.length, safe: "" }; this.pending.push(chunk); stream.chunks.push(chunk); stream.redactor.push(text); let emitted = this.emitReady(); while (this.orderedBacklogExceeded()) { const blocked = this.pending[this.head]!; // Keep the raw suffix in its channel scanner to catch an eventual continuation. // Release its place in the shared output order with a conservative replacement. blocked.released = true; blocked.safe = REDACTED_SECRET; emitted = this.emitReady() || emitted; } return emitted; } flush(): void { for (const { redactor } of this.streams.values()) redactor.flush(); this.emitReady(); } private consume(chunks: PendingChunk[], raw: string, replacement?: string): void { if (!raw.length) return; if (replacement !== undefined && !chunks[0]!.released) chunks[0]!.safe += replacement; for (let offset = 0; offset < raw.length;) { const chunk = chunks[0]!; const count = Math.min(chunk.remaining, raw.length - offset); if (replacement === undefined && !chunk.released) chunk.safe += raw.slice(offset, offset + count); chunk.remaining -= count; offset += count; if (!chunk.remaining) chunks.shift(); } } private orderedBacklogExceeded(): boolean { // A live suffix alone is smaller than the lookahead. Only a queued successor can block. if (this.pending.length - this.head <= 1) return false; if (this.pending.length - this.head > MAX_ORDERED_CHUNKS) return true; let size = 0; for (let i = this.head; i < this.pending.length; i++) { const chunk = this.pending[i]!; size += chunk.remaining + chunk.safe.length; if (size > MAX_ORDERED_CHARS) return true; } return false; } private emitReady(): boolean { let type: OutputType | undefined; let text = ""; for (let chunk = this.pending[this.head]; chunk; chunk = this.pending[this.head]) { if (chunk.safe) { if (type && chunk.type !== type) { this.emit(type, text); text = ""; } type = chunk.type; text += chunk.safe; chunk.safe = ""; } if (chunk.remaining && !chunk.released) break; this.head++; } if (this.head === this.pending.length || (this.head > 1024 && this.head * 2 >= this.pending.length)) { this.pending = this.pending.slice(this.head); this.head = 0; } if (type) this.emit(type, text); return type !== undefined; } }