@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
599 lines (557 loc) • 24.2 kB
text/typescript
import { constants, createHash, generateKeyPairSync, privateDecrypt, randomUUID } from "node:crypto";
import { redactSecretString } from "../lib/redact";
export const ZED_WEB_BASE_URL = "https://zed.dev";
export const ZED_CLOUD_BASE_URL = "https://cloud.zed.dev";
export const ZED_HEADERS = Object.freeze({
expiredToken: "x-zed-expired-token",
outdatedToken: "x-zed-outdated-token",
clientSupportsStatus: "x-zed-client-supports-status-messages",
clientSupportsStreamEnded: "x-zed-client-supports-stream-ended-request-completion-status",
clientSupportsXai: "x-zed-client-supports-x-ai",
systemId: "x-zed-system-id",
});
const PRIVATE_KEY_PREFIX = "zed-rsa-pkcs1:";
const LLM_TOKEN_TTL_MS = 50 * 60 * 1000;
const MODEL_CACHE_TTL_MS = 60 * 60 * 1000;
const MODEL_RESPONSE_MAX_BYTES = 4 * 1024 * 1024;
const SMALL_RESPONSE_MAX_BYTES = 64 * 1024;
const MODEL_MAX_ROWS = 2_000;
export interface ZedCredentials {
userId: string;
accessToken: string;
systemId?: string;
}
export interface ZedNativeAuthData {
authUrl: string;
privateKeyVerifier: string;
nativeAppPort: number;
systemId: string;
publicKey: string;
}
export interface ZedCallbackPayload {
userId: string;
encryptedAccessToken: string;
}
export interface ZedModel {
id: string;
name: string;
provider?: string;
contextLength?: number;
contextLengthInMaxMode?: number;
maxOutputTokens?: number;
supportsTools: boolean;
supportsImages: boolean;
supportsThinking: boolean;
supportsDisablingThinking: boolean;
supportsFastMode: boolean;
supportedEffortLevels: string[];
isDisabled: boolean;
}
export interface ZedModelCatalog {
expiresAt: number;
models: ZedModel[];
rawById: Map<string, Record<string, unknown>>;
defaultModel?: string;
defaultFastModel?: string;
recommendedModels: string[];
}
export type ZedFetch = typeof globalThis.fetch;
interface ZedRequestOptions {
fetchFn?: ZedFetch;
signal?: AbortSignal;
forceRefresh?: boolean;
}
interface CachedLlmToken {
token: string;
expiresAt: number;
organizationId: string;
}
const llmTokenCache = new Map<string, CachedLlmToken>();
const organizationCache = new Map<string, string>();
const modelCache = new Map<string, ZedModelCatalog>();
const modelInflight = new Map<string, Promise<ZedModelCatalog>>();
function base64Url(value: Uint8Array | string): string {
return Buffer.from(value).toString("base64url");
}
function decodeBase64Url(value: string): Buffer {
return Buffer.from(value, "base64url");
}
function normalizeBaseUrl(value: string | undefined, fallback: string): string {
return String(value || fallback).replace(/\/+$/, "");
}
function stringValue(value: unknown): string | undefined {
return typeof value === "string" && value.trim() ? value.trim() : undefined;
}
function normalizeModelId(value: unknown): string {
if (typeof value === "string") return value.trim();
if (Array.isArray(value) && typeof value[0] === "string") return value[0].trim();
if (value && typeof value === "object" && typeof (value as { id?: unknown }).id === "string") {
return String((value as { id: string }).id).trim();
}
return "";
}
function zedCacheKey(credentials: ZedCredentials): string {
// In-memory caches are keyed by an irreversible digest so no map key holds the raw token.
return createHash("sha256").update(JSON.stringify([credentials.userId, credentials.accessToken])).digest("hex");
}
function zedUrl(path: string, baseUrl = ZED_CLOUD_BASE_URL): string {
return `${normalizeBaseUrl(baseUrl, ZED_CLOUD_BASE_URL)}${path}`;
}
/** Build Zed's native-app URL and retain the private key only in an opaque verifier string. */
export function createZedNativeAuthData(nativeAppPort: number, systemId = randomUUID()): ZedNativeAuthData {
if (!Number.isInteger(nativeAppPort) || nativeAppPort <= 0 || nativeAppPort > 65_535) {
throw new Error("Zed native-app callback port is invalid");
}
const { publicKey, privateKey } = generateKeyPairSync("rsa", {
modulusLength: 2_048,
publicKeyEncoding: { type: "pkcs1", format: "der" },
privateKeyEncoding: { type: "pkcs1", format: "pem" },
});
const url = new URL(`${ZED_WEB_BASE_URL}/native_app_signin`);
url.searchParams.set("native_app_port", String(nativeAppPort));
url.searchParams.set("native_app_public_key", base64Url(publicKey));
url.searchParams.set("system_id", systemId);
return {
authUrl: url.toString(),
privateKeyVerifier: `${PRIVATE_KEY_PREFIX}${base64Url(privateKey)}`,
nativeAppPort,
systemId,
publicKey: base64Url(publicKey),
};
}
function decodePrivateKeyVerifier(verifier: string): string {
if (!verifier.startsWith(PRIVATE_KEY_PREFIX)) {
throw new Error("Missing Zed private-key verifier; restart the login flow");
}
return decodeBase64Url(verifier.slice(PRIVATE_KEY_PREFIX.length)).toString("utf8");
}
/** Parse a native-app callback URL, query string, or JSON payload without logging its token. */
export function parseZedCallbackPayload(input: string): ZedCallbackPayload {
const raw = input.trim();
if (!raw) throw new Error("Missing Zed callback URL");
let data: Record<string, unknown> = {};
try {
const parsed: unknown = JSON.parse(raw);
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not an object");
data = parsed as Record<string, unknown>;
} catch {
let url: URL;
try {
url = new URL(raw);
} catch {
const query = raw.includes("?") ? raw.slice(raw.indexOf("?") + 1) : raw.replace(/^\?/, "");
url = new URL(`http://127.0.0.1/?${query}`);
}
url.searchParams.forEach((value, key) => { data[key] = value; });
}
const userId = stringValue(data.user_id) ?? stringValue(data.userId);
const encryptedAccessToken = stringValue(data.access_token)
?? stringValue(data.accessToken)
?? stringValue(data.token);
if (!userId || !encryptedAccessToken) {
throw new Error("Zed callback must include user_id and access_token");
}
return { userId, encryptedAccessToken };
}
/** Decrypt the callback token with OAEP-SHA256, falling back to PKCS#1 v1.5 for older Zed builds. */
export function decryptZedAccessToken(encryptedAccessToken: string, privateKeyVerifier: string): string {
const encrypted = decodeBase64Url(encryptedAccessToken);
const privateKey = decodePrivateKeyVerifier(privateKeyVerifier);
let oaepError: unknown;
try {
const token = privateDecrypt(
{ key: privateKey, padding: constants.RSA_PKCS1_OAEP_PADDING, oaepHash: "sha256" },
encrypted,
).toString("utf8");
if (!token || token.includes("�")) throw new Error("decrypted token is invalid UTF-8");
return token;
} catch (error) {
oaepError = error;
}
try {
const token = privateDecrypt(
{ key: privateKey, padding: constants.RSA_PKCS1_PADDING },
encrypted,
).toString("utf8");
// PKCS#1 v1.5 unpadding is not integrity-checked. Replacement characters are a
// concrete signal that a wrong key or malformed ciphertext produced garbage.
if (!token || token.includes("�")) throw new Error("decrypted token is invalid UTF-8");
return token;
} catch {
const reason = oaepError instanceof Error ? oaepError.message : "unsupported ciphertext";
throw new Error(`Failed to decrypt Zed access token: ${reason}`);
}
}
export function buildZedUserAuthHeader(credentials: ZedCredentials): string {
if (!credentials.userId || !credentials.accessToken) throw new Error("Zed credential is incomplete");
return `${credentials.userId} ${credentials.accessToken}`;
}
function systemHeaders(credentials: ZedCredentials): Record<string, string> {
return credentials.systemId ? { [ZED_HEADERS.systemId]: credentials.systemId } : {};
}
/** Remove the account token and user id from upstream text before it can reach an error or log. */
export function scrubZedCredentials(text: string, credentials: ZedCredentials): string {
let scrubbed = text;
for (const secret of [credentials.accessToken, credentials.userId]) {
const value = secret?.trim();
if (value) scrubbed = scrubbed.split(value).join("[redacted]");
}
return redactSecretString(scrubbed);
}
function rejectionMessage(error: unknown): string {
return error instanceof Error ? error.message : String(error);
}
function containsZedCredential(text: string, credentials: ZedCredentials): boolean {
return [credentials.accessToken, credentials.userId].some((secret) => {
const value = secret?.trim();
return Boolean(value) && text.includes(value!);
});
}
/**
* Rethrow a rejection from a credential-bearing Zed call without the account token or user id.
*
* The decision is made on content alone: a rejection that carries neither value is rethrown by
* identity, so a clean abort stays the same object. One that carries either is replaced, keeping
* its `name` (a DOMException stays a DOMException, so AbortError/TimeoutError still read as
* cancellation) and any numeric `status`. The original is not kept as `cause`, because its
* message is exactly what must not travel.
*/
export function scrubZedRejection(error: unknown, credentials: ZedCredentials): never {
const message = rejectionMessage(error);
const name = error instanceof Error ? error.name : "Error";
if (!containsZedCredential(message, credentials) && !containsZedCredential(name, credentials)) throw error;
const scrubbed = scrubZedCredentials(message, credentials);
const safeName = containsZedCredential(name, credentials) ? "Error" : name;
const replacement: Error = error instanceof DOMException
? new DOMException(scrubbed, safeName)
: Object.assign(new Error(scrubbed), { name: safeName });
const status = error && typeof error === "object" ? (error as { status?: unknown }).status : undefined;
if (typeof status === "number") Object.assign(replacement, { status });
throw replacement;
}
async function responseJson(response: Response, label: string, credentials: ZedCredentials): Promise<unknown> {
const length = Number(response.headers.get("content-length"));
if (Number.isFinite(length) && length > SMALL_RESPONSE_MAX_BYTES) {
await response.body?.cancel().catch(() => undefined);
throw new Error(`${label}: response exceeded the size limit`);
}
const reader = response.body?.getReader();
if (!reader) {
if (!response.ok) throw new Error(`${label}: HTTP ${response.status}`);
return null;
}
const chunks: Uint8Array[] = [];
let total = 0;
try {
while (true) {
const { done, value } = await reader.read();
if (done) break;
if (!value) continue;
total += value.byteLength;
if (total > SMALL_RESPONSE_MAX_BYTES) {
await reader.cancel().catch(() => undefined);
throw new Error(`${label}: response exceeded the size limit`);
}
chunks.push(value);
}
} finally {
reader.releaseLock();
}
const bytes = new Uint8Array(total);
let offset = 0;
for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
let data: unknown = null;
if (text) {
try { data = JSON.parse(text) as unknown; } catch { data = { raw: text }; }
}
if (response.ok) return data;
const record = data && typeof data === "object" && !Array.isArray(data)
? data as Record<string, unknown>
: undefined;
const nested = record?.error && typeof record.error === "object" && !Array.isArray(record.error)
? record.error as Record<string, unknown>
: undefined;
const message = stringValue(record?.message) ?? stringValue(nested?.message) ?? `HTTP ${response.status}`;
const error = new Error(`${label}: ${scrubZedCredentials(message, credentials)}`);
Object.assign(error, { status: response.status });
throw error;
}
export async function fetchZedAuthenticatedUser(
credentials: ZedCredentials,
options: ZedRequestOptions = {},
): Promise<Record<string, unknown>> {
const fetchFn = options.fetchFn ?? globalThis.fetch;
let value: unknown;
try {
const response = await fetchFn(zedUrl("/client/users/me"), {
method: "GET",
headers: {
Accept: "application/json",
Authorization: buildZedUserAuthHeader(credentials),
...systemHeaders(credentials),
},
signal: options.signal,
});
value = await responseJson(response, "Zed account lookup", credentials);
} catch (error) {
scrubZedRejection(error, credentials);
}
if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Zed account lookup returned an invalid response");
return value as Record<string, unknown>;
}
function normalizeOrganizationId(value: unknown): string | undefined {
if (typeof value === "string" && value.trim()) return value.trim();
if (Array.isArray(value) && typeof value[0] === "string" && value[0].trim()) return value[0].trim();
if (value && typeof value === "object" && typeof (value as { id?: unknown }).id === "string") {
return String((value as { id: string }).id).trim() || undefined;
}
return undefined;
}
export function resolveZedOrganizationId(user: Record<string, unknown>): string | undefined {
const explicit = normalizeOrganizationId(user.default_organization_id)
?? normalizeOrganizationId(user.defaultOrganizationId)
?? normalizeOrganizationId(user.organization_id)
?? normalizeOrganizationId(user.organizationId)
?? normalizeOrganizationId(user.default_organization);
if (explicit) return explicit;
const organizations = Array.isArray(user.organizations) ? user.organizations : [];
const personal = organizations.find(item => item && typeof item === "object" && (item as { is_personal?: unknown }).is_personal === true);
const selected = personal ?? organizations[0];
return selected && typeof selected === "object"
? normalizeOrganizationId((selected as { id?: unknown }).id)
: undefined;
}
async function resolveOrganization(
credentials: ZedCredentials,
options: ZedRequestOptions,
): Promise<string> {
const key = zedCacheKey(credentials);
const cached = organizationCache.get(key);
if (cached) return cached;
const user = await fetchZedAuthenticatedUser(credentials, options);
const organizationId = resolveZedOrganizationId(user);
if (!organizationId) throw new Error("Zed account has no organization");
organizationCache.set(key, organizationId);
return organizationId;
}
export async function fetchZedLlmToken(
credentials: ZedCredentials,
options: ZedRequestOptions = {},
): Promise<string> {
const key = zedCacheKey(credentials);
const cached = llmTokenCache.get(key);
if (!options.forceRefresh && cached && cached.expiresAt > Date.now()) return cached.token;
const organizationId = await resolveOrganization(credentials, options);
const fetchFn = options.fetchFn ?? globalThis.fetch;
let data: unknown;
try {
const response = await fetchFn(zedUrl("/client/llm_tokens"), {
method: "POST",
headers: {
Accept: "application/json",
"Content-Type": "application/json",
Authorization: buildZedUserAuthHeader(credentials),
...systemHeaders(credentials),
},
body: JSON.stringify({ organization_id: organizationId }),
signal: options.signal,
});
data = await responseJson(response, "Zed LLM token exchange", credentials);
} catch (error) {
scrubZedRejection(error, credentials);
}
const record = data && typeof data === "object" && !Array.isArray(data)
? data as Record<string, unknown>
: undefined;
const token = stringValue(record?.token)
?? (record?.token && typeof record.token === "object" ? stringValue((record.token as { value?: unknown }).value) : undefined)
?? stringValue(record?.access_token)
?? stringValue(record?.llm_token)
?? stringValue(record?.llmToken);
if (!token) throw new Error("Zed LLM token exchange returned no token");
llmTokenCache.set(key, { token, organizationId, expiresAt: Date.now() + LLM_TOKEN_TTL_MS });
return token;
}
export function shouldRefreshZedLlmToken(response: Response): boolean {
return response.status === 401
|| response.headers.has(ZED_HEADERS.expiredToken)
|| response.headers.has(ZED_HEADERS.outdatedToken);
}
export async function zedLlmFetch(
credentials: ZedCredentials,
path: string,
options: ZedRequestOptions & { fetchInit?: RequestInit; baseUrl?: string } = {},
): Promise<Response> {
const fetchFn = options.fetchFn ?? globalThis.fetch;
const request = async (forceRefresh: boolean): Promise<Response> => {
const token = await fetchZedLlmToken(credentials, { ...options, forceRefresh });
const headers = new Headers(options.fetchInit?.headers);
headers.set("Authorization", `Bearer ${token}`);
try {
return await fetchFn(zedUrl(path, options.baseUrl), {
...options.fetchInit,
headers,
signal: options.signal,
});
} catch (error) {
scrubZedRejection(error, credentials);
}
};
let response = await request(false);
if (shouldRefreshZedLlmToken(response)) {
await response.body?.cancel().catch(() => undefined);
response = await request(true);
}
return response;
}
function mapZedModel(raw: unknown): ZedModel | undefined {
if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
const model = raw as Record<string, unknown>;
const id = normalizeModelId(model.id);
if (!id) return undefined;
const numberField = (...keys: string[]): number | undefined => {
for (const key of keys) {
const value = model[key];
if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
}
return undefined;
};
const listField = (...keys: string[]): string[] => {
for (const key of keys) {
if (!Array.isArray(model[key])) continue;
return model[key].filter(value => typeof value === "string" && value.trim()).map(value => String(value));
}
return [];
};
const contextLength = numberField("max_token_count", "maxTokenCount");
const contextLengthInMaxMode = numberField("max_token_count_in_max_mode", "maxTokenCountInMaxMode");
const maxOutputTokens = numberField("max_output_tokens", "maxOutputTokens");
return {
id,
name: stringValue(model.display_name) ?? stringValue(model.displayName) ?? id,
...(stringValue(model.provider) ? { provider: stringValue(model.provider) } : {}),
...(contextLength ? { contextLength } : {}),
...(contextLengthInMaxMode ? { contextLengthInMaxMode } : {}),
...(maxOutputTokens ? { maxOutputTokens } : {}),
supportsTools: model.supports_tools === true || model.supportsTools === true,
supportsImages: model.supports_images === true || model.supportsImages === true,
supportsThinking: model.supports_thinking === true || model.supportsThinking === true,
supportsDisablingThinking: model.supports_disabling_thinking === true || model.supportsDisablingThinking === true,
supportsFastMode: model.supports_fast_mode === true || model.supportsFastMode === true,
supportedEffortLevels: listField("supported_effort_levels", "supportedEffortLevels"),
isDisabled: model.is_disabled === true || model.isDisabled === true,
};
}
async function readBoundedJson(response: Response, maxBytes: number): Promise<unknown> {
const length = Number(response.headers.get("content-length"));
if (Number.isFinite(length) && length > maxBytes) {
if (response.body) await response.body.cancel().catch(() => undefined);
throw new Error("Zed model catalog exceeded the response size limit");
}
const reader = response.body?.getReader();
if (!reader) throw new Error("Zed model catalog returned no body");
const chunks: Uint8Array[] = [];
let total = 0;
try {
while (true) {
const { done, value } = await reader.read();
if (done) break;
if (!value) continue;
total += value.byteLength;
if (total > maxBytes) {
await reader.cancel().catch(() => undefined);
throw new Error("Zed model catalog exceeded the response size limit");
}
chunks.push(value);
}
} finally {
reader.releaseLock();
}
const bytes = new Uint8Array(total);
let offset = 0;
for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
try {
return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)) as unknown;
} catch {
throw new Error("Zed model catalog returned invalid JSON");
}
}
/** Resolve the account-scoped live model roster; the list is display metadata, not a model allowlist. */
export async function resolveZedModels(
credentials: ZedCredentials,
options: ZedRequestOptions = {},
): Promise<ZedModelCatalog> {
const key = zedCacheKey(credentials);
const cached = modelCache.get(key);
if (!options.forceRefresh && cached && cached.expiresAt > Date.now()) return cached;
const existing = modelInflight.get(key);
if (existing && !options.forceRefresh) return existing;
const promise = (async (): Promise<ZedModelCatalog> => {
const response = await zedLlmFetch(credentials, "/models", {
...options,
fetchInit: {
method: "GET",
headers: {
Accept: "application/json",
[ZED_HEADERS.clientSupportsXai]: "true",
},
},
});
if (!response.ok) throw new Error(`Zed model catalog failed: HTTP ${response.status}`);
const data = await readBoundedJson(response, MODEL_RESPONSE_MAX_BYTES);
const record = data && typeof data === "object" && !Array.isArray(data)
? data as Record<string, unknown>
: undefined;
const rawModels = Array.isArray(data)
? data
: Array.isArray(record?.models)
? record.models
: Array.isArray(record?.data)
? record.data
: Array.isArray(record?.available_models) ? record.available_models : undefined;
if (!rawModels || rawModels.length > MODEL_MAX_ROWS) throw new Error("Zed model catalog returned too many models");
const models = rawModels.map(mapZedModel).filter((model): model is ZedModel => !!model && !model.isDisabled);
const rawById = new Map<string, Record<string, unknown>>();
for (const raw of rawModels) {
if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
const id = normalizeModelId((raw as Record<string, unknown>).id);
if (id) rawById.set(id, raw as Record<string, unknown>);
}
const catalog: ZedModelCatalog = {
expiresAt: Date.now() + MODEL_CACHE_TTL_MS,
models,
rawById,
...(normalizeModelId(record?.default_model ?? record?.defaultModel) ? { defaultModel: normalizeModelId(record?.default_model ?? record?.defaultModel) } : {}),
...(normalizeModelId(record?.default_fast_model ?? record?.defaultFastModel) ? { defaultFastModel: normalizeModelId(record?.default_fast_model ?? record?.defaultFastModel) } : {}),
recommendedModels: (Array.isArray(record?.recommended_models) ? record.recommended_models : Array.isArray(record?.recommendedModels) ? record.recommendedModels : [])
.map(normalizeModelId).filter(Boolean),
};
modelCache.set(key, catalog);
return catalog;
})();
modelInflight.set(key, promise);
try {
return await promise;
} finally {
if (modelInflight.get(key) === promise) modelInflight.delete(key);
}
}
export function normalizeZedProvider(value: unknown, model: string): "anthropic" | "open_ai" | "google" | "x_ai" {
const raw = String(value ?? "").toLowerCase();
if (raw === "anthropic") return "anthropic";
if (raw === "openai" || raw === "open_ai") return "open_ai";
if (raw === "google" || raw === "gemini") return "google";
if (raw === "xai" || raw === "x_ai" || raw === "x-ai") return "x_ai";
const lowerModel = model.toLowerCase();
if (lowerModel.includes("claude")) return "anthropic";
if (lowerModel.includes("gemini")) return "google";
if (lowerModel.includes("grok") || lowerModel.includes("xai")) return "x_ai";
return "open_ai";
}
export function clearZedCaches(): void {
llmTokenCache.clear();
organizationCache.clear();
modelCache.clear();
modelInflight.clear();
}