UNPKG

@bitkyc08/opencodex

Version:

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

992 lines (941 loc) • 36.4 kB
/** * Pure byte-level validators, RFC 8259 JSON string/key scanners, and Codex TOML byte parser * for keyless CC-Switch provider import. */ export class CcSwitchImportError extends Error { constructor(message: string) { super(message); this.name = "CcSwitchImportError"; } } export type CcSwitchInvalidReason = | "missing_base_url" | "invalid_base_url" | "private_network_refused" | "invalid_provider_name" | "unsupported_app_type" | "ambiguous_codex_provider" | "disallowed_metadata" | "malformed_entry"; export const METADATA_REFUSED_SENTINEL = "__METADATA_REFUSED__"; export const URL_SYNTAX_REFUSED_SENTINEL = "__URL_REFUSED__"; const MAX_SQLITE_BYTES = 32 * 1024 * 1024; export const MAX_CODEX_TOML_BYTES = 64 * 1024; export type MetadataFieldKind = "id" | "app" | "model" | "url" | "wire"; function hasControlChars(value: string): boolean { for (let i = 0; i < value.length; i++) { const c = value.charCodeAt(i); if (c <= 0x1f || c === 0x7f) return true; } return false; } function isDigitByte(b: number): boolean { return b >= 0x30 && b <= 0x39; } function isLowerByte(b: number): boolean { return b >= 0x61 && b <= 0x7a; } function isUpperByte(b: number): boolean { return b >= 0x41 && b <= 0x5a; } function isAlphaByte(b: number): boolean { return isLowerByte(b) || isUpperByte(b); } function isHexByte(b: number): boolean { return isDigitByte(b) || (b >= 0x61 && b <= 0x66) || (b >= 0x41 && b <= 0x46); } function toLowerByte(b: number): number { return isUpperByte(b) ? b + 32 : b; } export function equalsAsciiBytes(slice: Uint8Array, ascii: string): boolean { if (slice.length !== ascii.length) return false; for (let i = 0; i < ascii.length; i++) { if (slice[i] !== ascii.charCodeAt(i)) return false; } return true; } export function parseHex4Bytes(bytes: Uint8Array, offset: number): number { if (offset + 4 > bytes.length) return -1; let out = 0; for (let i = 0; i < 4; i++) { const b = bytes[offset + i]!; let v: number; if (b >= 0x30 && b <= 0x39) v = b - 0x30; else if (b >= 0x41 && b <= 0x46) v = b - 0x41 + 10; else if (b >= 0x61 && b <= 0x66) v = b - 0x61 + 10; else return -1; out = (out << 4) | v; } return out; } export function encodeCodePointUtf8(cp: number, target: Uint8Array, offset: number): number { if (cp <= 0x7f) { target[offset] = cp; return 1; } if (cp <= 0x7ff) { target[offset] = 0xc0 | (cp >> 6); target[offset + 1] = 0x80 | (cp & 0x3f); return 2; } if (cp <= 0xffff) { target[offset] = 0xe0 | (cp >> 12); target[offset + 1] = 0x80 | ((cp >> 6) & 0x3f); target[offset + 2] = 0x80 | (cp & 0x3f); return 3; } target[offset] = 0xf0 | (cp >> 18); target[offset + 1] = 0x80 | ((cp >> 12) & 0x3f); target[offset + 2] = 0x80 | ((cp >> 6) & 0x3f); target[offset + 3] = 0x80 | (cp & 0x3f); return 4; } /** * Strict RFC 8259 + UTF-8 byte-level JSON string validator. * Validates escapes (including paired UTF-16 surrogates) and multi-byte UTF-8 sequences * without decoding string contents into JavaScript strings. */ export function validateUtf8AndJsonStringBounds( bytes: Uint8Array, quotePos: number, ): { start: number; end: number; hasEscapes: boolean; nextPos: number } | null { if (quotePos >= bytes.length || bytes[quotePos] !== 0x22) return null; let pos = quotePos + 1; const start = pos; let hasEscapes = false; while (pos < bytes.length) { const b = bytes[pos]!; if (b < 0x20) return null; if (b === 0x22) { return { start, end: pos, hasEscapes, nextPos: pos + 1 }; } if (b === 0x5c) { hasEscapes = true; pos++; if (pos >= bytes.length) return null; const esc = bytes[pos]!; pos++; if ( esc === 0x22 || esc === 0x5c || esc === 0x2f || esc === 0x62 || esc === 0x66 || esc === 0x6e || esc === 0x72 || esc === 0x74 ) { continue; } if (esc === 0x75) { const cu = parseHex4Bytes(bytes, pos); if (cu < 0) return null; pos += 4; if (cu >= 0xdc00 && cu <= 0xdfff) return null; if (cu >= 0xd800 && cu <= 0xdbff) { if (pos + 6 > bytes.length || bytes[pos] !== 0x5c || bytes[pos + 1] !== 0x75) return null; const low = parseHex4Bytes(bytes, pos + 2); if (low < 0xdc00 || low > 0xdfff) return null; pos += 6; } continue; } return null; } if (b < 0x80) { pos++; continue; } if (b >= 0xc2 && b <= 0xdf) { if (pos + 1 >= bytes.length) return null; const c1 = bytes[pos + 1]!; if ((c1 & 0xc0) !== 0x80) return null; pos += 2; continue; } if (b >= 0xe0 && b <= 0xef) { if (pos + 2 >= bytes.length) return null; const c1 = bytes[pos + 1]!; const c2 = bytes[pos + 2]!; if ((c1 & 0xc0) !== 0x80 || (c2 & 0xc0) !== 0x80) return null; if (b === 0xe0 && c1 < 0xa0) return null; if (b === 0xed && c1 >= 0xa0) return null; pos += 3; continue; } if (b >= 0xf0 && b <= 0xf4) { if (pos + 3 >= bytes.length) return null; const c1 = bytes[pos + 1]!; const c2 = bytes[pos + 2]!; const c3 = bytes[pos + 3]!; if ((c1 & 0xc0) !== 0x80 || (c2 & 0xc0) !== 0x80 || (c3 & 0xc0) !== 0x80) return null; if (b === 0xf0 && c1 < 0x90) return null; if (b === 0xf4 && c1 > 0x8f) return null; pos += 4; continue; } return null; } return null; } export function validateJsonPrimitiveBytes(bytes: Uint8Array, start: number, end: number): boolean { const slice = bytes.subarray(start, end); if (slice.length === 0) return false; if (equalsAsciiBytes(slice, "true") || equalsAsciiBytes(slice, "false") || equalsAsciiBytes(slice, "null")) { return true; } let i = 0; if (slice[i] === 0x2d) { i++; if (i >= slice.length) return false; } if (slice[i] === 0x30) { i++; } else if (slice[i]! >= 0x31 && slice[i]! <= 0x39) { while (i < slice.length && isDigitByte(slice[i]!)) i++; } else { return false; } if (i < slice.length && slice[i] === 0x2e) { i++; if (i >= slice.length || !isDigitByte(slice[i]!)) return false; while (i < slice.length && isDigitByte(slice[i]!)) i++; } if (i < slice.length && (slice[i] === 0x65 || slice[i] === 0x45)) { i++; if (i < slice.length && (slice[i] === 0x2b || slice[i] === 0x2d)) i++; if (i >= slice.length || !isDigitByte(slice[i]!)) return false; while (i < slice.length && isDigitByte(slice[i]!)) i++; } return i === slice.length; } export function unescapeJsonStringBytesBounded( bytes: Uint8Array, bounds: { start: number; end: number; hasEscapes: boolean }, maxBytes: number, ): Uint8Array | null { const rawLen = bounds.end - bounds.start; if (rawLen > maxBytes * 6) return null; const out = new Uint8Array(Math.max(rawLen, 4)); let r = bounds.start; let w = 0; while (r < bounds.end) { const b = bytes[r]!; if (b !== 0x5c) { out[w++] = b; r++; continue; } r++; const esc = bytes[r]!; r++; if (esc === 0x22 || esc === 0x5c || esc === 0x2f) out[w++] = esc; else if (esc === 0x62) out[w++] = 0x08; else if (esc === 0x66) out[w++] = 0x0c; else if (esc === 0x6e) out[w++] = 0x0a; else if (esc === 0x72) out[w++] = 0x0d; else if (esc === 0x74) out[w++] = 0x09; else if (esc === 0x75) { let cp = parseHex4Bytes(bytes, r); if (cp < 0) { out.fill(0); return null; } r += 4; if (cp >= 0xd800 && cp <= 0xdbff) { const low = parseHex4Bytes(bytes, r + 2); if (low < 0xdc00 || low > 0xdfff) { out.fill(0); return null; } r += 6; cp = ((cp - 0xd800) << 10) + (low - 0xdc00) + 0x10000; } else if (cp >= 0xdc00 && cp <= 0xdfff) { out.fill(0); return null; } w += encodeCodePointUtf8(cp, out, w); } else { out.fill(0); return null; } } if (w > maxBytes) { out.fill(0); return null; } const result = new Uint8Array(w); result.set(out.subarray(0, w)); out.fill(0); return result; } export function matchKnownJsonKeyBytes<T extends string>( bytes: Uint8Array, bounds: { start: number; end: number; hasEscapes: boolean }, allowed: readonly T[], ): T | null { if (!bounds.hasEscapes) { const raw = bytes.subarray(bounds.start, bounds.end); for (const candidate of allowed) { if (equalsAsciiBytes(raw, candidate)) return candidate; } return null; } const unescaped = unescapeJsonStringBytesBounded(bytes, bounds, 48); if (!unescaped) return null; try { for (const candidate of allowed) { if (equalsAsciiBytes(unescaped, candidate)) return candidate; } return null; } finally { unescaped.fill(0); } } const FORBIDDEN_SUBSTRINGS_LOWER = [ "sk-", "rk-", "pk-", "ak-", "ghp_", "gho_", "github_pat_", "xoxb-", "xoxp-", "xoxa-", "xoxr-", "xoxs-", "aiza", "eyj", "bearer", "secret", "apikey", "api_key", "passwd", "password", "private_key", "access_token", "refresh_token", "auth_token", ].map(s => Buffer.from(s, "ascii")); function containsForbiddenBytes(slice: Uint8Array): boolean { for (const pat of FORBIDDEN_SUBSTRINGS_LOWER) { if (slice.length < pat.length) continue; for (let i = 0; i <= slice.length - pat.length; i++) { let match = true; for (let j = 0; j < pat.length; j++) { if (toLowerByte(slice[i + j]!) !== pat[j]!) { match = false; break; } } if (match) return true; } } // Reject 3+ grouped 4-hex segments like a1b2-c3d4-e5f6 (UUID / grouped hex key). if (slice.length >= 14) { for (let i = 0; i <= slice.length - 14; i++) { if ( isHexByte(slice[i]!) && isHexByte(slice[i + 1]!) && isHexByte(slice[i + 2]!) && isHexByte(slice[i + 3]!) && slice[i + 4] === 0x2d && isHexByte(slice[i + 5]!) && isHexByte(slice[i + 6]!) && isHexByte(slice[i + 7]!) && isHexByte(slice[i + 8]!) && slice[i + 9] === 0x2d && isHexByte(slice[i + 10]!) && isHexByte(slice[i + 11]!) && isHexByte(slice[i + 12]!) && isHexByte(slice[i + 13]!) ) { return true; } } } return false; } const ALLOWED_API_TERMINAL_PATH_SEGMENTS = [ "api", "openai", "anthropic", "codex", "chat", "responses", "gateway", "compat", "models", "inference", "llm", "proxy", ] as const; function isCanonicalUuidBytes(slice: Uint8Array): boolean { if (slice.length !== 36) return false; for (let i = 0; i < 36; i++) { const b = slice[i]!; if (i === 8 || i === 13 || i === 18 || i === 23) { if (b !== 0x2d) return false; } else if (!isHexByte(b)) { return false; } } return true; } function isModelParamSizeSeg(slice: Uint8Array, start: number, end: number): boolean { const n = end - start; if (n < 2 || n > 4 || slice[end - 1] !== 0x62) return false; const dStart = slice[start] === 0x61 ? start + 1 : start; if (dStart >= end - 1 || slice[dStart] === 0x30) return false; for (let k = dStart; k < end - 1; k++) if (!isDigitByte(slice[k]!)) return false; return true; } function isApiVersionSegmentBytes(seg: Uint8Array): boolean { // Matches v1..v9, v1.1, v1beta, v1beta1, etc. if (seg.length < 2 || seg.length > 10 || seg[0] !== 0x76 || !(seg[1]! >= 0x31 && seg[1]! <= 0x39)) { return false; } for (let i = 2; i < seg.length; i++) { const b = seg[i]!; if (!isLowerByte(b) && !isDigitByte(b) && b !== 0x2e) return false; } return seg[seg.length - 1] !== 0x2e; } function isAllowedTerminalUrlSegmentBytes(seg: Uint8Array): boolean { if (isApiVersionSegmentBytes(seg)) return true; for (const allowed of ALLOWED_API_TERMINAL_PATH_SEGMENTS) { if (equalsAsciiBytes(seg, allowed)) return true; } return false; } function validateAuthorityBytes(auth: Uint8Array): boolean { if (auth.length === 0 || auth.length > 190) return false; let hostEnd = auth.length; if (auth[0] === 0x5b) { // Bracketed IPv6 literal: [hex:...] with optional :port let closeIdx = -1; let sawColon = false; for (let i = 1; i < auth.length; i++) { const b = auth[i]!; if (b === 0x5d) { closeIdx = i; break; } if (b === 0x3a) sawColon = true; else if (!isHexByte(b) && b !== 0x2e) return false; } if (closeIdx < 3 || !sawColon) return false; if (closeIdx === auth.length - 1) return true; if (auth[closeIdx + 1] !== 0x3a) return false; hostEnd = closeIdx + 1; } else { const colonIdx = auth.indexOf(0x3a); if (colonIdx === 0) return false; const host = colonIdx > 0 ? auth.subarray(0, colonIdx) : auth; if (host.length === 0 || host.length > 180) return false; if (host[0] === 0x2e || host[0] === 0x2d || host[host.length - 1] === 0x2d) return false; for (let i = 0; i < host.length; i++) { const b = host[i]!; if (!isAlphaByte(b) && !isDigitByte(b) && b !== 0x2e && b !== 0x2d) return false; if (b === 0x2e && i > 0 && host[i - 1] === 0x2e) return false; } if (colonIdx < 0) return true; hostEnd = colonIdx; } // Validate :port (1..65535) const portSlice = auth.subarray(hostEnd + 1); if (portSlice.length === 0 || portSlice.length > 5) return false; let port = 0; for (let i = 0; i < portSlice.length; i++) { const b = portSlice[i]!; if (!isDigitByte(b)) return false; port = port * 10 + (b - 0x30); } return port >= 1 && port <= 65535; } /** * Byte-level syntax & defense-in-depth validation enforced BEFORE decoding into a JavaScript string. * Note: the primary security boundary is structural (secret-named fields are never read); this * enforces narrow URL/identifier/model syntax as defense in depth. */ export function isAllowedMetadataBytes(slice: Uint8Array, kind: MetadataFieldKind): boolean { const len = slice.length; if (len === 0) return false; for (let i = 0; i < len; i++) { const b = slice[i]!; if (b <= 0x20 || b >= 0x7f) return false; } // CC-Switch generates canonical 36-char randomUUID() primary keys for custom providers. if (kind === "id" && isCanonicalUuidBytes(slice)) return true; if (containsForbiddenBytes(slice)) return false; if (kind === "app") { if (len > 16) return false; let hasLower = false; let hasUpper = false; for (let i = 0; i < len; i++) { const b = slice[i]!; if (!isAlphaByte(b) && b !== 0x2d && b !== 0x5f) return false; if (isLowerByte(b)) hasLower = true; if (isUpperByte(b)) hasUpper = true; } if (len >= 10 && hasLower && hasUpper) return false; return true; } if (kind === "wire") { if (len > 24) return false; for (let i = 0; i < len; i++) { const b = slice[i]!; if (!isAlphaByte(b) && b !== 0x2d && b !== 0x5f) return false; } return true; } if (kind === "url") { if (len < 8 || len > 256) return false; // Must start with http:// or https:// const isHttp = toLowerByte(slice[0]!) === 0x68 && toLowerByte(slice[1]!) === 0x74 && toLowerByte(slice[2]!) === 0x74 && toLowerByte(slice[3]!) === 0x70; if (!isHttp) return false; let schemeEnd = 4; if (toLowerByte(slice[4]!) === 0x73) schemeEnd = 5; if (slice[schemeEnd] !== 0x3a || slice[schemeEnd + 1] !== 0x2f || slice[schemeEnd + 2] !== 0x2f) return false; let firstPathSlash = -1; for (let i = schemeEnd + 3; i < len; i++) { const b = slice[i]!; // Reject @, ?, #, %, ~, quotes, backslashes if (b === 0x40 || b === 0x3f || b === 0x23 || b === 0x25 || b === 0x7e || b === 0x22 || b === 0x27 || b === 0x5c) return false; if (b === 0x2f && firstPathSlash < 0) firstPathSlash = i; } const authorityEnd = firstPathSlash >= 0 ? firstPathSlash : len; if (!validateAuthorityBytes(slice.subarray(schemeEnd + 3, authorityEnd))) return false; if (firstPathSlash < 0) return true; const pathLen = len - firstPathSlash; if (pathLen === 1) return true; if (pathLen > 48) return false; const pathEnd = slice[len - 1] === 0x2f ? len - 1 : len; if (pathEnd <= firstPathSlash + 1) return false; // Reject "//" let segStart = firstPathSlash + 1; let segCount = 0; let totalPathDigits = 0; let lastSeg: Uint8Array | null = null; for (let i = firstPathSlash + 1; i <= pathEnd; i++) { if (i < pathEnd && slice[i] !== 0x2f) continue; const segLen = i - segStart; if (segLen <= 0 || segLen > 20) return false; // Reject empty interior segment "//" segCount++; if (segCount > 4) return false; const seg = slice.subarray(segStart, i); if (equalsAsciiBytes(seg, ".") || equalsAsciiBytes(seg, "..")) return false; const firstB = seg[0]!; const lastB = seg[segLen - 1]!; if ((!isLowerByte(firstB) && !isDigitByte(firstB)) || (!isLowerByte(lastB) && !isDigitByte(lastB))) { return false; } let segDigits = 0; let segHex = true; for (let k = 0; k < segLen; k++) { const b = seg[k]!; // Strict lowercase [a-z0-9._-] path grammar only if (!isLowerByte(b) && !isDigitByte(b) && b !== 0x2e && b !== 0x2d && b !== 0x5f) return false; if (isDigitByte(b)) segDigits++; if (!isHexByte(b)) segHex = false; } totalPathDigits += segDigits; if (segDigits >= 3) return false; if (segHex && segLen >= 8) return false; lastSeg = seg; segStart = i + 1; } if (totalPathDigits > 2) return false; return lastSeg !== null && isAllowedTerminalUrlSegmentBytes(lastSeg); } // kind === "id" or "model" const maxLen = kind === "id" ? 48 : 80; if (len > maxLen) return false; let sepCount = 0; let totalDigits = 0; for (let i = 0; i < len; i++) { const b = slice[i]!; const isSep = b === 0x2d || b === 0x5f || b === 0x2e || (kind === "model" && (b === 0x2f || b === 0x3a)); if (isSep) { sepCount++; continue; } if (!isAlphaByte(b) && !isDigitByte(b)) return false; if (isDigitByte(b)) totalDigits++; } if (sepCount === 0 && len >= 16) return false; if (kind === "id" && totalDigits > 5) return false; let segStart = 0; let mixedDigitsTotal = 0; let nonDateDigits = totalDigits; let usedDateExemption = false; let skipHyphenDateParts = 0; let paramSizeSegs = 0; for (let i = 0; i <= len; i++) { const b = i < len ? slice[i]! : 0x2d; const isSep = i === len || b === 0x2d || b === 0x5f || b === 0x2e || b === 0x2f || b === 0x3a; if (!isSep) continue; const segLen = i - segStart; if (segLen > 16) return false; if (segLen > 0) { let segDigits = 0; let segAllDigits = true; let segHex = true; let hasLower = false; let hasUpper = false; for (let k = segStart; k < i; k++) { const cb = slice[k]!; if (isDigitByte(cb)) segDigits++; else segAllDigits = false; if (!isHexByte(cb)) segHex = false; if (isLowerByte(cb)) hasLower = true; if (isUpperByte(cb)) hasUpper = true; } if (segAllDigits) { if (skipHyphenDateParts > 0) { skipHyphenDateParts--; segStart = i + 1; continue; } const isDate8 = kind === "model" && !usedDateExemption && segLen === 8 && slice[segStart] === 0x32 && slice[segStart + 1] === 0x30 && ((slice[segStart + 4]! - 0x30) * 10 + (slice[segStart + 5]! - 0x30)) >= 1 && ((slice[segStart + 4]! - 0x30) * 10 + (slice[segStart + 5]! - 0x30)) <= 12 && ((slice[segStart + 6]! - 0x30) * 10 + (slice[segStart + 7]! - 0x30)) >= 1 && ((slice[segStart + 6]! - 0x30) * 10 + (slice[segStart + 7]! - 0x30)) <= 31; const isHyphenDate = kind === "model" && !usedDateExemption && segLen === 4 && slice[segStart] === 0x32 && slice[segStart + 1] === 0x30 && segStart + 10 <= len && slice[segStart + 4] === 0x2d && slice[segStart + 7] === 0x2d && isDigitByte(slice[segStart + 5]!) && isDigitByte(slice[segStart + 6]!) && isDigitByte(slice[segStart + 8]!) && isDigitByte(slice[segStart + 9]!) && ((slice[segStart + 5]! - 0x30) * 10 + (slice[segStart + 6]! - 0x30)) >= 1 && ((slice[segStart + 5]! - 0x30) * 10 + (slice[segStart + 6]! - 0x30)) <= 12 && ((slice[segStart + 8]! - 0x30) * 10 + (slice[segStart + 9]! - 0x30)) >= 1 && ((slice[segStart + 8]! - 0x30) * 10 + (slice[segStart + 9]! - 0x30)) <= 31 && (segStart + 10 === len || [0x2d, 0x5f, 0x2e, 0x2f, 0x3a].includes(slice[segStart + 10]!)); if (isDate8) { usedDateExemption = true; nonDateDigits -= 8; } else if (isHyphenDate) { usedDateExemption = true; skipHyphenDateParts = 2; nonDateDigits -= 8; } else if (segLen > 4) { return false; } } else { if (kind === "model" && paramSizeSegs < 2 && isModelParamSizeSeg(slice, segStart, i)) { paramSizeSegs++; nonDateDigits -= segDigits; segStart = i + 1; continue; } if (segHex && segLen >= 10) return false; if (segDigits >= 4) return false; if (segLen >= 10 && hasLower && hasUpper && segDigits >= 1) return false; mixedDigitsTotal += segDigits; } } segStart = i + 1; } if (kind === "model" && nonDateDigits > 8) return false; if (mixedDigitsTotal >= 5) return false; return true; } export function isDisallowedMetadataValue(value: string, kind: MetadataFieldKind): boolean { if (value === METADATA_REFUSED_SENTINEL || value === URL_SYNTAX_REFUSED_SENTINEL || hasControlChars(value)) return true; const bytes = Buffer.from(value, "utf8"); try { return !isAllowedMetadataBytes(bytes, kind); } finally { bytes.fill(0); } } /** * Syntax-aware, single-line TOML projection for Codex settings_config.config. * Operates on a transient UTF-8 byte buffer (zeroed by the caller in finally) and decodes ONLY: * - [table] headers (bare or quoted) * - root model, model_provider, base_url, openai_base_url, wire_api * - [model_providers.<key>] base_url and wire_api * Rejects triple-quoted strings, inline tables, arrays, unclosed quotes, or non-assignment lines. */ export interface CodexTomlProjection { model?: string; modelProvider?: string; rootBaseUrl?: string; rootWireApi?: string; providers: Map<string, { baseUrl?: string; wireApi?: string }>; } const ALLOWED_TOML_KEYS = ["model", "model_provider", "base_url", "openai_base_url", "wire_api"] as const; type AllowedTomlKey = (typeof ALLOWED_TOML_KEYS)[number]; function tomlKeyMetadataKind(key: AllowedTomlKey): MetadataFieldKind { if (key === "model") return "model"; if (key === "model_provider") return "id"; if (key === "wire_api") return "wire"; return "url"; } /** * Unescape a single-line TOML quoted string slice (without surrounding quotes) into a transient * Uint8Array. Caller must zero `out` in finally. */ export function unescapeTomlStringBytes( raw: Uint8Array, quoteByte: number, ): Uint8Array | null { const out = new Uint8Array(raw.length); let r = 0; let w = 0; while (r < raw.length) { const b = raw[r]!; if (b < 0x20 || b === 0x7f) { out.fill(0); return null; } if (quoteByte === 0x22 && b === 0x5c) { r++; if (r >= raw.length) { out.fill(0); return null; } const esc = raw[r]!; r++; if (esc === 0x22 || esc === 0x5c || esc === 0x2f) out[w++] = esc; else if (esc === 0x6e || esc === 0x72 || esc === 0x74 || esc === 0x62 || esc === 0x66) { out.fill(0); return null; // Control escapes are never valid in provider IDs, models, wire APIs, or URLs. } else if (esc === 0x75) { const cp = parseHex4Bytes(raw, r); if (cp <= 0x20 || cp >= 0x7f) { out.fill(0); return null; } r += 4; w += encodeCodePointUtf8(cp, out, w); } else { out.fill(0); return null; } continue; } out[w++] = b; r++; } return out.subarray(0, w); } function hasOnlyCommentOrSpaceBytes(slice: Uint8Array, fromIndex: number): boolean { let i = fromIndex; while (i < slice.length && (slice[i] === 0x20 || slice[i] === 0x09)) i++; return i >= slice.length || slice[i] === 0x23; } function findQuotedEndInBytes(slice: Uint8Array, quoteStart: number): number { const q = slice[quoteStart]!; if (q !== 0x22 && q !== 0x27) return -1; if (quoteStart + 2 < slice.length && slice[quoteStart + 1] === q && slice[quoteStart + 2] === q) { return -1; // Triple-quoted strings are forbidden. } let i = quoteStart + 1; while (i < slice.length) { const b = slice[i]!; if (b < 0x20 || b === 0x7f) return -1; if (q === 0x22 && b === 0x5c) { i += 2; continue; } if (b === q) return i; i++; } return -1; } function parseTomlHeaderBytes( innerRaw: Uint8Array, decoder: TextDecoder, ): { kind: "other" } | { kind: "model_provider"; id: string } | { kind: "error"; reason: CcSwitchInvalidReason } { let s = 0; let e = innerRaw.length; while (s < e && (innerRaw[s] === 0x20 || innerRaw[s] === 0x09)) s++; while (e > s && (innerRaw[e - 1] === 0x20 || innerRaw[e - 1] === 0x09)) e--; const inner = innerRaw.subarray(s, e); if (inner.length === 0) return { kind: "error", reason: "malformed_entry" }; if (equalsAsciiBytes(inner, "__MULTILINE_REFUSED__") || equalsAsciiBytes(inner, "__MALFORMED_LINE__")) { return { kind: "error", reason: "malformed_entry" }; } if (equalsAsciiBytes(inner, METADATA_REFUSED_SENTINEL)) { return { kind: "error", reason: "disallowed_metadata" }; } const segments: Uint8Array[] = []; const owned: Uint8Array[] = []; try { let i = 0; while (i < inner.length) { while (i < inner.length && (inner[i] === 0x20 || inner[i] === 0x09)) i++; if (i >= inner.length) return { kind: "error", reason: "malformed_entry" }; const b0 = inner[i]!; if (b0 === 0x22 || b0 === 0x27) { const qEnd = findQuotedEndInBytes(inner, i); if (qEnd < 0) return { kind: "error", reason: "malformed_entry" }; const unesc = unescapeTomlStringBytes(inner.subarray(i + 1, qEnd), b0); if (!unesc || unesc.length === 0) return { kind: "error", reason: "malformed_entry" }; owned.push(unesc); segments.push(unesc); i = qEnd + 1; } else { const segStart = i; while (i < inner.length) { const b = inner[i]!; if (isAlphaByte(b) || isDigitByte(b) || b === 0x5f || b === 0x2d) i++; else break; } if (i === segStart) return { kind: "error", reason: "malformed_entry" }; segments.push(inner.subarray(segStart, i)); } while (i < inner.length && (inner[i] === 0x20 || inner[i] === 0x09)) i++; if (i === inner.length) break; if (inner[i] === 0x2e) { i++; if (i >= inner.length) return { kind: "error", reason: "malformed_entry" }; continue; } return { kind: "error", reason: "malformed_entry" }; } if (segments.length === 2 && equalsAsciiBytes(segments[0]!, "model_providers")) { const idSlice = segments[1]!; if (!isAllowedMetadataBytes(idSlice, "id")) { return { kind: "error", reason: "disallowed_metadata" }; } const id = decoder.decode(idSlice); return { kind: "model_provider", id }; } return { kind: "other" }; } catch { return { kind: "error", reason: "malformed_entry" }; } finally { for (const buf of owned) buf.fill(0); } } function classifyTomlKeyBytes(keySlice: Uint8Array): AllowedTomlKey | "other_key" | null { const b0 = keySlice[0]!; if (b0 === 0x22 || b0 === 0x27) { const qEnd = findQuotedEndInBytes(keySlice, 0); if (qEnd !== keySlice.length - 1) return null; const unesc = unescapeTomlStringBytes(keySlice.subarray(1, qEnd), b0); if (!unesc || unesc.length === 0) return null; try { for (const allowed of ALLOWED_TOML_KEYS) { if (equalsAsciiBytes(unesc, allowed)) return allowed; } return "other_key"; } finally { unesc.fill(0); } } for (let i = 0; i < keySlice.length; i++) { const b = keySlice[i]!; if (!isAlphaByte(b) && !isDigitByte(b) && b !== 0x5f && b !== 0x2d) return null; } for (const allowed of ALLOWED_TOML_KEYS) { if (equalsAsciiBytes(keySlice, allowed)) return allowed; } return "other_key"; } export function parseCodexTomlBytes(bytes: Uint8Array): { ok: true; value: CodexTomlProjection } | { ok: false; reason: CcSwitchInvalidReason } { if (bytes.length > MAX_CODEX_TOML_BYTES) return { ok: false, reason: "malformed_entry" }; const projection: CodexTomlProjection = { providers: new Map() }; let currentSection: { kind: "root" } | { kind: "model_provider"; id: string } | { kind: "other" } = { kind: "root" }; const decoder = new TextDecoder("utf-8", { fatal: true }); let lineStart = 0; let lineCount = 0; for (let idx = 0; idx <= bytes.length; idx++) { if (idx < bytes.length && bytes[idx] !== 0x0a) continue; lineCount++; if (lineCount > 501) return { ok: false, reason: "malformed_entry" }; let lineEnd = idx; if (lineEnd > lineStart && bytes[lineEnd - 1] === 0x0d) lineEnd--; const slice = bytes.subarray(lineStart, lineEnd); lineStart = idx + 1; let p = 0; while (p < slice.length && (slice[p] === 0x20 || slice[p] === 0x09)) p++; if (p >= slice.length || slice[p] === 0x23) continue; if (slice[p] === 0x5b) { // Scan and classify table headers in raw bytes so neither trailing comments nor unvalidated/unrelated headers are decoded. if (p + 1 < slice.length && slice[p + 1] === 0x5b) return { ok: false, reason: "malformed_entry" }; let closeB = -1; let inQ = 0; for (let k = p + 1; k < slice.length; k++) { const b = slice[k]!; if (inQ === 0 && b === 0x23) break; if (inQ === 0 && (b === 0x22 || b === 0x27)) { inQ = b; continue; } if (inQ === 0x22 && b === 0x5c) { k++; continue; } if (inQ !== 0 && b === inQ) { inQ = 0; continue; } if (inQ === 0 && b === 0x5d) { closeB = k; break; } } if (closeB < 0 || !hasOnlyCommentOrSpaceBytes(slice, closeB + 1)) { return { ok: false, reason: "malformed_entry" }; } const header = parseTomlHeaderBytes(slice.subarray(p + 1, closeB), decoder); if (header.kind === "error") return { ok: false, reason: header.reason }; currentSection = header; continue; } let eq = -1; let inKeyQuote = 0; for (let k = p; k < slice.length; k++) { const b = slice[k]!; if (inKeyQuote === 0 && b === 0x23) break; if (inKeyQuote === 0 && (b === 0x22 || b === 0x27)) { inKeyQuote = b; continue; } if (inKeyQuote !== 0 && b === 0x5c && inKeyQuote === 0x22) { k++; continue; } if (inKeyQuote !== 0 && b === inKeyQuote) { inKeyQuote = 0; continue; } if (inKeyQuote === 0 && b === 0x3d) { eq = k; break; } } if (eq < 0) return { ok: false, reason: "malformed_entry" }; let kStart = p; let kEnd = eq; while (kStart < kEnd && (slice[kStart] === 0x20 || slice[kStart] === 0x09)) kStart++; while (kEnd > kStart && (slice[kEnd - 1] === 0x20 || slice[kEnd - 1] === 0x09)) kEnd--; if (kEnd - kStart <= 0 || kEnd - kStart > 128) return { ok: false, reason: "malformed_entry" }; const classifiedKey = classifyTomlKeyBytes(slice.subarray(kStart, kEnd)); if (classifiedKey === null) return { ok: false, reason: "malformed_entry" }; let vStart = eq + 1; while (vStart < slice.length && (slice[vStart] === 0x20 || slice[vStart] === 0x09)) vStart++; if (vStart >= slice.length) return { ok: false, reason: "malformed_entry" }; if ( vStart + 2 < slice.length && ((slice[vStart] === 0x22 && slice[vStart + 1] === 0x22 && slice[vStart + 2] === 0x22) || (slice[vStart] === 0x27 && slice[vStart + 1] === 0x27 && slice[vStart + 2] === 0x27)) ) { return { ok: false, reason: "malformed_entry" }; } const relevant = classifiedKey !== "other_key" && ( currentSection.kind === "root" || (currentSection.kind === "model_provider" && (classifiedKey === "base_url" || classifiedKey === "wire_api")) ); if (!relevant) { let q = 0; let depth = 0; for (let k = vStart; k < slice.length; k++) { const b = slice[k]!; if (q === 0 && b === 0x23) break; if (q === 0 && (b === 0x22 || b === 0x27)) { q = b; continue; } if (q !== 0 && b === 0x5c && q === 0x22) { k++; continue; } if (q !== 0 && b === q) { q = 0; continue; } if (q === 0 && (b === 0x5b || b === 0x7b)) depth++; if (q === 0 && (b === 0x5d || b === 0x7d)) { depth--; if (depth < 0) return { ok: false, reason: "malformed_entry" }; } } if (q !== 0 || depth !== 0) return { ok: false, reason: "malformed_entry" }; continue; } // Scan the quoted value in raw bytes so trailing '# comment' is never decoded! const vEnd = findQuotedEndInBytes(slice, vStart); if (vEnd < 0 || !hasOnlyCommentOrSpaceBytes(slice, vEnd + 1)) { return { ok: false, reason: "malformed_entry" }; } const key: AllowedTomlKey = classifiedKey as AllowedTomlKey; const unescaped = unescapeTomlStringBytes(slice.subarray(vStart + 1, vEnd), slice[vStart]!); if (!unescaped || unescaped.length === 0) return { ok: false, reason: "malformed_entry" }; let value: string; try { const metaKind = tomlKeyMetadataKind(key); if (metaKind === "url" && equalsAsciiBytes(unescaped, URL_SYNTAX_REFUSED_SENTINEL)) { return { ok: false, reason: "invalid_base_url" }; } if (equalsAsciiBytes(unescaped, METADATA_REFUSED_SENTINEL)) { return { ok: false, reason: "disallowed_metadata" }; } if (!isAllowedMetadataBytes(unescaped, metaKind)) { return { ok: false, reason: metaKind === "url" ? "invalid_base_url" : "disallowed_metadata" }; } value = decoder.decode(unescaped); if (value === URL_SYNTAX_REFUSED_SENTINEL) return { ok: false, reason: "invalid_base_url" }; if (value === METADATA_REFUSED_SENTINEL) return { ok: false, reason: "disallowed_metadata" }; } catch { return { ok: false, reason: "malformed_entry" }; } finally { unescaped.fill(0); } if (currentSection.kind === "root") { if (key === "model") projection.model = value; else if (key === "model_provider") projection.modelProvider = value; else if (key === "base_url" || key === "openai_base_url") projection.rootBaseUrl = value; else if (key === "wire_api") projection.rootWireApi = value; } else if (currentSection.kind === "model_provider") { const entry = projection.providers.get(currentSection.id) ?? {}; if (key === "base_url") entry.baseUrl = value; else if (key === "wire_api") entry.wireApi = value; projection.providers.set(currentSection.id, entry); } } return { ok: true, value: projection }; } export function resolveCodexProjection(proj: CodexTomlProjection): { ok: true; baseUrl: string; wireApi: string; defaultModel?: string } | { ok: false; reason: CcSwitchInvalidReason } { let baseUrl: string | undefined; let wireApi = proj.rootWireApi ?? "responses"; if (proj.modelProvider !== undefined) { const selected = proj.providers.get(proj.modelProvider); if (!selected?.baseUrl) return { ok: false, reason: "missing_base_url" }; baseUrl = selected.baseUrl; if (selected.wireApi) wireApi = selected.wireApi; } else if (proj.providers.size > 1) { return { ok: false, reason: "ambiguous_codex_provider" }; } else if (proj.providers.size === 1) { const only = [...proj.providers.values()][0]!; if (!only.baseUrl) return { ok: false, reason: "missing_base_url" }; baseUrl = only.baseUrl; if (only.wireApi) wireApi = only.wireApi; } else if (proj.rootBaseUrl) { baseUrl = proj.rootBaseUrl; } else { return { ok: false, reason: "missing_base_url" }; } return { ok: true, baseUrl, wireApi, ...(proj.model ? { defaultModel: proj.model } : {}), }; }