UNPKG

@bitkyc08/opencodex

Version:

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

80 lines (74 loc) • 3.87 kB
import { createHash } from "node:crypto"; import { constants, lstatSync, openSync, fstatSync, readFileSync, closeSync, type BigIntStats } from "node:fs"; import { join } from "node:path"; /** Read an existing single-owner salt without creating or hardening any file. */ export function readExistingSpendSalt(home: string): string | undefined { let fd: number | undefined; let salt: string | undefined; try { const path = join(home, "spend-ledger.salt"); const before = lstatSync(path, { bigint: true }); if (!before.isFile() || before.nlink !== 1n) return undefined; const matches = (stat: BigIntStats): boolean => stat.isFile() && stat.nlink === 1n && stat.dev === before.dev && stat.ino === before.ino; fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)); if (!matches(fstatSync(fd, { bigint: true }))) return undefined; const contents = readFileSync(fd, "utf8").trim(); if (matches(fstatSync(fd, { bigint: true })) && matches(lstatSync(path, { bigint: true })) && /^[0-9a-f]{32,}$/.test(contents)) salt = contents; } catch { salt = undefined; } finally { if (fd !== undefined) { try { closeSync(fd); } catch { salt = undefined; } } } return salt; } /** * The one owner of the spend ledger's salted alias hash. The ledger, config diagnostics and * runtime policy validation must all compute the same alias for the same (salt, domain, id), * so the hash lives here and nowhere else. The raw id never leaves this function. */ export function hashSpendAlias(salt: string, kind: string, id: string): string { return createHash("sha256").update(salt).update("\u0000").update(kind).update("\u0000").update(id) .digest("hex").slice(0, 32); } const isAlias = (value: unknown): value is string => typeof value === "string" && /^[0-9a-f]{32}$/.test(value); /** Shape and optional roster check, outside `spend` so old schemas keep configured ceilings. */ export function spendPoolAliasesError(value: unknown, providerIds?: Iterable<string>): string | undefined { if (value === undefined) return undefined; if (!value || typeof value !== "object" || Array.isArray(value)) return "spendPoolAliases must be an object"; if (Object.keys(value).length > 4_096) return "spendPoolAliases has too many entries"; const providers = providerIds === undefined ? undefined : new Set(providerIds); for (const [alias, provider] of Object.entries(value)) { if (!isAlias(alias) || typeof provider !== "string" || !provider.trim() || provider.trim() !== provider || provider.length > 256) { return "spendPoolAliases requires exact 32-character salted pool aliases and nonempty provider IDs"; } if (providers && !providers.has(provider)) return "spendPoolAliases targets a provider that is not configured"; } return undefined; } /** * Semantic owner check: an alias that is the salted pool alias of a configured provider P * belongs to P. Mapping it to any other provider Q would move P's own history into Q's pool, * so `aliases[h("pool", P)] = Q` with Q !== P is rejected. Re-run whenever the provider set * changes: adding P later turns an existing mapping into a conflict. */ export function validatePoolAliasOwners( aliases: unknown, salt: string, providerIds: Iterable<string>, ): string | undefined { const shape = spendPoolAliasesError(aliases); if (shape) return shape; if (aliases === undefined) return undefined; const mapping = aliases as Record<string, string>; for (const provider of new Set(providerIds)) { const owned = hashSpendAlias(salt, "pool", provider); const target = Object.hasOwn(mapping, owned) ? mapping[owned] : undefined; if (target !== undefined && target !== provider) { return "spendPoolAliases maps a configured provider's own pool alias to a different provider"; } } return undefined; }