UNPKG

@bitkyc08/opencodex

Version:

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

191 lines (188 loc) • 9.74 kB
/** Private, bounded Anthropic affinity snapshots. No session or credential bytes reach disk. */ import { createHash } from "node:crypto"; import { join } from "node:path"; import { atomicWriteFileNoFollow } from "../config/atomic-write"; import { getConfigDir, withConfigDirHardeningSettled } from "../config/paths"; import { registerOptionalShutdownHook } from "../lib/optional-shutdown-hooks"; import { trackBackgroundWork } from "../lib/background-work"; import { getAccountSet } from "./store"; import { readBoundedRegularFileSync } from "../lib/bounded-file-read"; import type { AnthropicInstanceId } from "../providers/anthropic-instance-id"; export const AFFINITY_IDLE_TTL_MS = 24 * 60 * 60_000; export const MAX_AFFINITY_ENTRIES = 2_000; export const MAX_AFFINITY_FILE_BYTES = 1_048_576; const WRITE_DELAY_MS = 1_000; type Entry = { accountId: string; lastUsedAt: number; loginFence?: string }; type AccountSnapshot = ReturnType<typeof getAccountSet>; type Fences = ReadonlyMap<string, string | undefined>; type Scope = { home: string; rows: Map<string, Entry>; dirty: boolean; active: boolean; revision: number; timer?: ReturnType<typeof setTimeout>; pending?: Promise<void> }; const owners = new Set<AnthropicSessionAffinityStore>(); const digest = (domain: string, value: string) => createHash("sha256").update(`${domain}\0${value}`).digest("hex"); export function anthropicAffinityDigest(instance: AnthropicInstanceId, normalizedKey: string): string { return normalizedKey ? digest(`opencodex/anthropic-affinity/session/v1/${instance}`, normalizedKey) : ""; } export function anthropicAffinityPath(home: string, instance: AnthropicInstanceId): string { return join(home, `anthropic-affinity-${digest("opencodex/anthropic-affinity/instance/v1", instance)}.json`); } function warn(): void { console.warn("[anthropic-affinity] snapshot persistence failed; using runtime affinity"); } export class AnthropicSessionAffinityStore implements Iterable<[string, Entry]> { private scope?: Scope; constructor(private readonly instance: AnthropicInstanceId, private readonly write = atomicWriteFileNoFollow) { owners.add(this); } private fences(snapshot: AccountSnapshot = getAccountSet(this.instance)): Fences { const fences = new Map<string, string | undefined>(); for (const account of snapshot?.accounts ?? []) { if (account.paused || account.needsReauth) continue; // Legacy accounts without a persistent login identity remain memory-only until next login. fences.set(account.id, account.loginId ? digest("opencodex/anthropic-affinity/login/v1", account.loginId) : undefined); } return fences; } private valid(entry: Entry, fences: Fences): boolean { return fences.has(entry.accountId) && fences.get(entry.accountId) === entry.loginFence; } private current(fences?: Fences): Scope { const home = getConfigDir(); if (this.scope?.home === home) return this.scope; this.resetMemory(); const scope: Scope = { home, rows: new Map(), dirty: false, active: true, revision: 0 }; this.scope = scope; // Starts synchronously; retained ACL children are joined by the tracked writer. registerOptionalShutdownHook(`anthropic-affinity:${this.instance}`, () => { void this.flush(); }); try { const bytes = readBoundedRegularFileSync(anthropicAffinityPath(home, this.instance), MAX_AFFINITY_FILE_BYTES); const snapshot = JSON.parse(bytes.toString("utf8")); if (!snapshot || snapshot.version !== 1 || !Array.isArray(snapshot.entries)) return scope; fences ??= this.fences(); const now = Date.now(); for (const row of snapshot.entries) { if (!row || typeof row.sessionDigest !== "string" || !/^[a-f0-9]{64}$/.test(row.sessionDigest) || typeof row.accountId !== "string" || row.accountId.length > 512 || typeof row.loginFence !== "string" || !/^[a-f0-9]{64}$/.test(row.loginFence) || !Number.isFinite(row.lastUsedAt) || row.lastUsedAt > now || now - row.lastUsedAt > AFFINITY_IDLE_TTL_MS || !this.valid(row, fences)) continue; const previous = scope.rows.get(row.sessionDigest); if (!previous || previous.lastUsedAt < row.lastUsedAt) scope.rows.set(row.sessionDigest, { accountId: row.accountId, lastUsedAt: row.lastUsedAt, loginFence: row.loginFence, }); } this.trim(scope); if (scope.rows.size !== snapshot.entries.length) this.changed(scope); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") { console.warn("[anthropic-affinity] snapshot unavailable or invalid; using runtime affinity"); } } return scope; } private trim(scope: Scope): void { if (scope.rows.size <= MAX_AFFINITY_ENTRIES) return; if (scope.rows.size > MAX_AFFINITY_ENTRIES + 1) { const ordered = [...scope.rows].sort((a, b) => b[1].lastUsedAt - a[1].lastUsedAt); for (const [key] of ordered.slice(MAX_AFFINITY_ENTRIES)) scope.rows.delete(key); return; } let oldest: [string, Entry] | undefined; for (const row of scope.rows) { if (!oldest || row[1].lastUsedAt <= oldest[1].lastUsedAt) oldest = row; } if (oldest) scope.rows.delete(oldest[0]); } private changed(scope: Scope): void { scope.dirty = true; scope.revision++; scope.timer ??= setTimeout(() => { scope.timer = undefined; void this.flushScope(scope); }, WRITE_DELAY_MS); scope.timer.unref(); } private flushSync(scope: Scope): void { if (!scope.active || !scope.dirty || this.scope !== scope) return; if (getConfigDir() !== scope.home) { this.resetMemory(); return; } try { const entries = [...scope.rows].filter(([, row]) => row.loginFence).map(([sessionDigest, row]) => ({ sessionDigest, ...row })); this.write(anthropicAffinityPath(scope.home, this.instance), JSON.stringify({ version: 1, entries })); scope.dirty = false; } catch { warn(); } } async flush(): Promise<void> { const scope = this.scope; if (scope) await this.flushScope(scope); } /** Operator acknowledgements require publication, not only completion of an attempt. */ async flushConfirmed(): Promise<boolean> { const scope = this.scope; if (!scope) return true; await this.flushScope(scope); if (scope.pending) await scope.pending; return this.scope === scope && scope.active && !scope.dirty && getConfigDir() === scope.home; } private async flushScope(scope: Scope): Promise<void> { if (!scope?.active) return; if (getConfigDir() !== scope.home) { if (this.scope === scope) this.resetMemory(); return; } if (scope.timer) { clearTimeout(scope.timer); scope.timer = undefined; } if (scope.pending) return scope.pending; if (!scope.dirty) return; let attemptedRevision = scope.revision; scope.pending = trackBackgroundWork("anthropic-affinity-write", withConfigDirHardeningSettled(scope.home, () => { attemptedRevision = scope.revision; this.flushSync(scope); }).catch(() => { warn(); }).finally(() => { scope.pending = undefined; // A mutation after publication but before settlement still needs its own write. if (scope.active && scope.dirty && scope.revision !== attemptedRevision) return this.flushScope(scope); })); return scope.pending; } resetMemory(): void { if (this.scope) { this.scope.active = false; if (this.scope.timer) clearTimeout(this.scope.timer); } this.scope = undefined; } get size(): number { return this.current().rows.size; } get(key: string, snapshot: AccountSnapshot = getAccountSet(this.instance), now = Date.now()): Entry | undefined { const fences = this.fences(snapshot); const scope = this.current(fences); const row = scope.rows.get(key); if (row && (!this.valid(row, fences) || now - row.lastUsedAt > AFFINITY_IDLE_TTL_MS)) { scope.rows.delete(key); this.changed(scope); return undefined; } return row; } set(key: string, value: Entry, snapshot: AccountSnapshot = getAccountSet(this.instance)): void { if (!/^[a-f0-9]{64}$/.test(key) || !Number.isFinite(value.lastUsedAt)) return; const fences = this.fences(snapshot); const scope = this.current(fences); if (!fences.has(value.accountId)) { this.delete(key); return; } const loginFence = fences.get(value.accountId); scope.rows.set(key, { accountId: value.accountId, lastUsedAt: value.lastUsedAt, loginFence }); this.trim(scope); this.changed(scope); } /** Roster mutations validate every binding once, against one captured auth generation. */ invalidate(snapshot: AccountSnapshot = getAccountSet(this.instance), keep: (accountId: string) => boolean = () => true): number { const fences = this.fences(snapshot); const scope = this.current(fences); const now = Date.now(); let removed = 0; for (const [key, row] of scope.rows) { if (this.valid(row, fences) && keep(row.accountId) && row.lastUsedAt <= now && now - row.lastUsedAt <= AFFINITY_IDLE_TTL_MS) continue; scope.rows.delete(key); removed++; } if (removed) this.changed(scope); return removed; } delete(key: string): boolean { const scope = this.current(); const deleted = scope.rows.delete(key); if (deleted) this.changed(scope); return deleted; } clear(): void { const scope = this.current(); scope.rows.clear(); this.changed(scope); } *entries(): IterableIterator<[string, Entry]> { yield* this.current().rows; } [Symbol.iterator](): IterableIterator<[string, Entry]> { return this.entries(); } } export async function flushAnthropicSessionAffinity(): Promise<void> { for (const owner of owners) await owner.flush(); }