UNPKG

@bitkyc08/opencodex

Version:

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

917 lines (914 loc) • 32 kB
import { Database } from "bun:sqlite"; import { createHash, createHmac, randomBytes } from "node:crypto"; import { chmodSync, lstatSync, realpathSync, } from "node:fs"; import { resolve } from "node:path"; import { getConfigDir } from "../../config/paths"; import { initializeConfigOwnership, recordOwnedConfigPath } from "../../lib/config-ownership"; import { sameFileIdentity, type FileIdentity } from "../../lib/file-identity"; import { isPassiveRead } from "../../lib/passive-read"; import { assertPrivateSqliteEntryOrMissing, assertPrivateSqliteSidecars, preparePrivateSqliteDatabase } from "../../lib/private-sqlite-path"; import { assertStorageOwned, currentSpendLedgerOwnerGeneration, mintSpendLedgerStorage, onSpendLedgerOwnerAcquired, onSpendLedgerOwnerReleased, onSpendLedgerOwnerReleasing, spendLedgerStoragePath, type SpendLedgerStorage, } from "../../lib/spend-ledger-owner"; import { assertNotRealHomeUnderTest } from "../../lib/test-home-guard"; import { hardenSecretPath } from "../../lib/windows-secret-acl"; import { readCodexAccountRecord } from "../account-store"; import { isRequestOwnedAffinityKey } from "../request-owned-affinity-key"; import { setCodexConversationAnchorObserver } from "../lineage"; import type { CodexQuotaScope } from "./health-store"; export type StoredThreadRow = { scope: string; accountId: string; fence: string; createdAt: number; lastUsedAt: number; }; export const CODEX_UNKNOWN_CONVERSATION_STATE_ISSUER = "__unknown_codex_conversation_state_issuer__"; type LiveReader = { thread( key: string, scope: string, ): | { accountId: string; identityFence?: string; createdAt: number; lastUsedAt: number; } | undefined; issuer( key: string, ): { accountId: string; fence?: string; lastUsedAt: number } | undefined; clearLive(): void; }; type Op = { sql: string; args: (string | number | null)[]; key?: string; scope?: string; kind: string; }; type Scope = { home: string; generation: number; token: SpendLedgerStorage; db?: Database; /** The database file the handle was opened on; every write transaction re-checks the path against it. */ file?: FileIdentity; secret?: Uint8Array; disabled: boolean; poisoned: boolean; failures: number; log: Op[]; threads: Map<string, { key: string; scope: string; rowKey: string }>; issuers: Map<string, { key: string; rowKey: string }>; anchors: Map<string, { family: string; thread: string; at: number }>; threadKeys: Map<string, { rowKey: string; scopes: Map<string, string> }>; issuerKeys: Map<string, string>; consulted: Set<string>; timer?: ReturnType<typeof setTimeout>; pruneTimer?: ReturnType<typeof setInterval>; scheduled: boolean; }; const TTL = 24 * 60 * 60_000; const BASE_SCOPES = [ "shared", "reserve", ] as const satisfies readonly CodexQuotaScope[]; const BASE_SCOPES_EXHAUSTIVE: Exclude< CodexQuotaScope, (typeof BASE_SCOPES)[number] > extends never ? true : never = true; void BASE_SCOPES_EXHAUSTIVE; let current: Scope | undefined; let observedHome: string | undefined; /** The home whose database the most recent scope in this process actually opened. */ let persistedHome: string | undefined; /** * A persistable change to pins or issuers happened while that home's database was not writable * (between leases, or while a scope could not open it). The database may still hold the row the * change replaced or deleted, so the next scope that opens it clears it first. Live memory keeps * routing as before; a later restart then restores nothing rather than something stale. Only a * process that releases and reacquires its lease reaches this: a serving proxy holds one lease for * its whole life. */ let needsClear = false; /** Anchors of the last retired scope, handed to the next scope of the same home. */ let carried: { home: string; anchors: Scope["anchors"]; threadKeys: Scope["threadKeys"]; issuerKeys: Scope["issuerKeys"] } | undefined; let reader: LiveReader | undefined; export function registerCodexAffinityLiveState(value: LiveReader): void { reader = value; setCodexConversationAnchorObserver(observeAnchor); } function warning(): void { console.warn("Codex affinity persistence unavailable; continuing in memory."); } /** Retire the lease-scoped handle without discarding in-memory affinity. */ function retire(): void { const s = current; if (!s) return; current = undefined; // Anchors are process-local facts about this home's conversations; the next scope of the same // home needs them to re-derive row keys for pins that are still live in memory. // Row keys too: after an anchor is evicted they are the only way a delete can still reach its row. if (s.db && !s.poisoned) carried = { home: s.home, anchors: s.anchors, threadKeys: s.threadKeys, issuerKeys: s.issuerKeys }; if (s.timer) clearTimeout(s.timer); if (s.pruneTimer) clearInterval(s.pruneTimer); try { s.db?.close(); } catch { warning(); } } // BigInt stats: NTFS file IDs exceed Number.MAX_SAFE_INTEGER, and a rounded identity can match a // different file. function checkFile(path: string) { const stat = lstatSync(path, { bigint: true }); if ( !stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n || (process.platform !== "win32" && stat.uid !== BigInt(process.getuid!())) ) throw new Error("unsafe file"); return stat; } function open(s: Scope): void { const path = spendLedgerStoragePath(s.token); let db: Database | undefined; try { assertNotRealHomeUnderTest(s.home); // An owned home must list these files before they exist, so uninstall removes them. A home with // no ownership manifest (one that predates ownership tracking) cannot record anything, and // uninstall refuses to remove anything from it; like the spend-ledger owner database, the store // still works there rather than silently losing persistence. for (const suffix of ["", "-journal", "-wal", "-shm"]) if (!recordOwnedConfigPath(s.home, path + suffix) && initializeConfigOwnership(s.home)) throw new Error("ownership"); // Refuses a link or reparse point at the database or a sidecar before anything is created: // Windows creates a new file through a link at its name. preparePrivateSqliteDatabase(path); const before = checkFile(path); if (before.size > 8n * 1024n * 1024n) throw new Error("oversized"); if (process.platform !== "win32") chmodSync(path, 0o600); if (!hardenSecretPath(path, { required: true }).ok) throw new Error("acl"); checkFile(path); assertStorageOwned(s.token); // SQLite creates sidecars in the private, hardened config directory, as with // spend-ledger-owner.sqlite and config-mutation.sqlite. assertPrivateSqliteSidecars(path); db = new Database(path); db.exec("PRAGMA busy_timeout = 0; BEGIN IMMEDIATE"); const version = ( db.query("PRAGMA user_version").get() as { user_version: number } ).user_version; const objects = db .query("SELECT type, name FROM sqlite_master ORDER BY name") .all() as { type: string; name: string }[]; const tables = objects.filter((o) => o.type === "table"); if (version === 0 && objects.length === 0) { db.exec( "CREATE TABLE meta(name TEXT PRIMARY KEY, value BLOB); CREATE TABLE threads(row_key TEXT, scope TEXT, account_id TEXT, fence TEXT, created_at INTEGER, last_used_at INTEGER, PRIMARY KEY(row_key, scope)); CREATE TABLE issuers(row_key TEXT PRIMARY KEY, account_id TEXT, fence TEXT, last_used_at INTEGER); PRAGMA user_version = 1", ); db.query("INSERT INTO meta VALUES ('secret', ?), ('clean', 0)").run( randomBytes(32), ); } else { if ( version !== 1 || tables.map((t) => t.name).join(",") !== "issuers,meta,threads" ) throw new Error("version"); const expected: Record<string, string> = { meta: "name:TEXT:1,value:BLOB:0", threads: "row_key:TEXT:1,scope:TEXT:2,account_id:TEXT:0,fence:TEXT:0,created_at:INTEGER:0,last_used_at:INTEGER:0", issuers: "row_key:TEXT:1,account_id:TEXT:0,fence:TEXT:0,last_used_at:INTEGER:0", }; for (const [table, columns] of Object.entries(expected)) { const actual = db.query(`PRAGMA table_info(${table})`).all() as { name: string; type: string; pk: number; notnull: number; dflt_value: unknown; }[]; if ( actual.map((c) => `${c.name}:${c.type}:${c.pk}`).join(",") !== columns || actual.some((c) => c.notnull !== 0 || c.dflt_value !== null) ) throw new Error("shape"); } const indexes = objects .filter((o) => o.type === "index") .map((o) => o.name) .join(","); if ( objects.length !== 6 || indexes !== "sqlite_autoindex_issuers_1,sqlite_autoindex_meta_1,sqlite_autoindex_threads_1" ) throw new Error("shape"); const rows = db.query("SELECT name, value FROM meta").all() as { name: string; value: unknown; }[]; const secret = rows.find((r) => r.name === "secret")?.value; const clean = rows.find((r) => r.name === "clean")?.value; if ( !(secret instanceof Uint8Array) || secret.length !== 32 || rows.length !== 2 || !rows.some((r) => r.name === "clean") ) throw new Error("meta"); db.exec("PRAGMA secure_delete = ON"); // Only a completed final flush permits the next owner to restore rows. if (clean !== 1) db.exec("DELETE FROM threads; DELETE FROM issuers"); db.exec("UPDATE meta SET value=0 WHERE name='clean'"); } db.exec("PRAGMA secure_delete = ON"); const pageSize = (db.query("PRAGMA page_size").get() as { page_size: number }).page_size; db.exec(`PRAGMA max_page_count = ${Math.floor(8 * 1024 * 1024 / pageSize)}`); prune(db, Date.now()); const secret = ( db.query("SELECT value FROM meta WHERE name='secret'").get() as { value: Uint8Array; } ).value; db.exec("COMMIT"); const after = checkFile(path); if (!sameFileIdentity(before, after)) throw new Error("replaced"); s.db = db; s.file = after; s.secret = secret; s.pruneTimer = setInterval(() => { if (current === s) { if (s.poisoned || isPassiveRead()) pruneOnly(s); else flush(s, false); } }, 60 * 60_000); s.pruneTimer.unref(); } catch { try { db?.exec("ROLLBACK"); } catch { /* no transaction */ } try { db?.close(); } catch { /* preserve open failure */ } s.disabled = true; warning(); } } /** * Refuse a write unless the database is still the single-link private file this handle opened and * no sidecar name holds a link: the rollback journal is created per transaction, and a link added * to the database since open would expose every later write. */ function assertWritable(s: Scope): void { const path = spendLedgerStoragePath(s.token); assertPrivateSqliteSidecars(path); if (!assertPrivateSqliteEntryOrMissing(path)) throw new Error("missing"); const now = checkFile(path); if (!s.file || !sameFileIdentity(now, s.file)) throw new Error("replaced"); } function resolvedHome(acquiredHome?: string): string { let home = resolve(acquiredHome ?? getConfigDir()); try { home = realpathSync.native(home); } catch { /* ownership check below refuses it */ } return process.platform === "win32" ? home.toLowerCase() : home; } function scope(acquiredHome?: string): Scope | undefined { if (!acquiredHome && isPassiveRead()) return undefined; const home = resolvedHome(acquiredHome); // A lease ends a store scope; only a change of home invalidates live maps. if (observedHome !== undefined && observedHome !== home) { retire(); carried = undefined; persistedHome = undefined; needsClear = false; reader?.clearLive(); } observedHome = home; const generation = currentSpendLedgerOwnerGeneration(); if (current && (current.home !== home || current.generation !== generation)) retire(); if (current) { try { assertStorageOwned(current.token); return current; } catch { retire(); return undefined; } } let token: SpendLedgerStorage; try { token = mintSpendLedgerStorage("codex-affinity.sqlite"); assertStorageOwned(token); } catch { return undefined; } const s: Scope = { home, generation, token, disabled: false, poisoned: false, failures: 0, log: [], threads: new Map(), issuers: new Map(), anchors: carried?.home === home ? carried.anchors : new Map(), threadKeys: carried?.home === home ? carried.threadKeys : new Map(), issuerKeys: carried?.home === home ? carried.issuerKeys : new Map(), consulted: new Set(), scheduled: false, }; const prior = carried; carried = undefined; current = s; open(s); // A scope that could not open never touched the carried maps; keep them for the next one. if (!s.db && prior?.home === home) carried = prior; if (s.db) { if (needsClear && persistedHome === home) recordAllCleared(); needsClear = false; persistedHome = home; } return s; } /** * The scope for a change to which pins or issuers exist. When the change could have been persisted * but this home's database is not writable right now, remember that the database is stale. */ function writableScope(persistable: boolean): Scope | undefined { const s = usable(); if (!s && persistable && persistedHome !== undefined && !isPassiveRead() && persistedHome === resolvedHome()) needsClear = true; return s; } function usable(): Scope | undefined { const s = scope(); return s && !s.disabled && !s.poisoned && s.db ? s : undefined; } function observeAnchor(key: string, family: string, thread: string): void { // Caller-owned keys are process-local by contract (structure/providers/codex-request-owned-affinity.md). if (isRequestOwnedAffinityKey(key)) return; const s = usable(); if (!s) return; const now = Date.now(); for (const [k, a] of s.anchors) { if (now - a.at <= TTL) break; s.anchors.delete(k); } s.anchors.delete(key); s.anchors.set(key, { family, thread, at: now }); while (s.anchors.size > 4096) s.anchors.delete(s.anchors.keys().next().value!); } setCodexConversationAnchorObserver(observeAnchor); function rowKey( s: Scope, key: string, kind: "conversation" | "issuer", ): string | undefined { // The single choke point for every bind, touch, delete, adoption and issuer path: a request-owned // key never has a durable row key, so nothing for it is ever written or restored. if (isRequestOwnedAffinityKey(key)) return undefined; const a = s.anchors.get(key); if (!a || Date.now() - a.at > TTL) { s.anchors.delete(key); return kind === "conversation" ? s.threadKeys.get(key)?.rowKey : s.issuerKeys.get(key); } return createHmac("sha256", s.secret!) .update(`opencodex/codex-affinity/${kind}/v1\0`) .update(a.family) .update("\0") .update(a.thread) .digest("hex"); } export function codexAffinityIdentityFence( accountId: string, ): string | undefined { if (accountId === "__main__") return undefined; const record = readCodexAccountRecord(accountId); if ( !record?.credential || record.deletedAt != null || !record.quotaHistoryIdentity ) return undefined; return identityFence(record.quotaHistoryIdentity); } export function identityFence(identity: string | undefined): string | undefined { if (!identity) return undefined; return createHash("sha256") .update("opencodex/codex-affinity/identity/v1\0") .update(identity) .digest("hex"); } function rememberThreadKey(s: Scope, key: string, rk: string, scopeName: string, accountId: string): void { let entry = s.threadKeys.get(key); if (!entry) s.threadKeys.set(key, entry = { rowKey: rk, scopes: new Map() }); entry.scopes.set(scopeName, accountId); if (s.threadKeys.size + s.issuerKeys.size > 8192) poison(s); } function rememberIssuerKey(s: Scope, key: string, rk: string): void { s.issuerKeys.set(key, rk); if (s.threadKeys.size + s.issuerKeys.size > 8192) poison(s); } /** A poisoned scope cannot safely declare itself clean on release. */ function poison(s: Scope): void { s.poisoned = true; s.log = []; s.threads.clear(); s.issuers.clear(); s.threadKeys.clear(); s.issuerKeys.clear(); if (s.timer) clearTimeout(s.timer); warning(); } function enqueue(s: Scope, op: Op): void { // Preserve structural ordering; only clearAll supersedes the whole log. if (op.kind === "clearAll") s.log = []; s.log.push(op); if (s.log.length > 16384) { poison(s); return; } if (!s.scheduled) { s.scheduled = true; queueMicrotask(() => { s.scheduled = false; if (current === s && !isPassiveRead()) flush(s, false); }); } } function scheduleTouch(s: Scope): void { if (s.timer) return; s.timer = setTimeout(() => { s.timer = undefined; if (current === s && !isPassiveRead()) flush(s, false); }, 1000); s.timer.unref(); } function prune(db: Database, now: number): void { for (const table of ["threads", "issuers"]) db.query(`DELETE FROM ${table} WHERE last_used_at < ? OR last_used_at > ?`).run(now - TTL, now); db.query("DELETE FROM threads WHERE created_at > ?").run(now); db.exec("DELETE FROM threads WHERE rowid IN (SELECT rowid FROM threads ORDER BY (scope LIKE 'model-detour:%') ASC, last_used_at DESC, row_key, scope LIMIT -1 OFFSET 2048); DELETE FROM issuers WHERE rowid IN (SELECT rowid FROM issuers ORDER BY last_used_at DESC, row_key LIMIT -1 OFFSET 2048)"); } function pruneOnly(s: Scope): boolean { if (!s.db || s.disabled) return false; try { assertStorageOwned(s.token); assertWritable(s); s.db.exec("BEGIN IMMEDIATE"); // Pending touches first, so a pin used since its last persisted timestamp is not evicted as idle. if (!s.poisoned) applyTouches(s, s.db); prune(s.db, Date.now()); s.db.exec("COMMIT"); return true; } catch { try { s.db.exec("ROLLBACK"); } catch { /* no transaction */ } warning(); return false; } } /** Write the live last-used time of every touched row; UPDATE-only, so it never creates or revives a row. */ function applyTouches(s: Scope, db: Database): void { for (const t of s.threads.values()) { const row = reader?.thread(t.key, t.scope); if (row?.identityFence) db.query( "UPDATE threads SET last_used_at=max(last_used_at, ?) WHERE row_key=? AND scope=? AND account_id=? AND fence=?", ).run( row.lastUsedAt, t.rowKey, t.scope, row.accountId, row.identityFence, ); } for (const t of s.issuers.values()) { const row = reader?.issuer(t.key); if (row) db.query( "UPDATE issuers SET last_used_at=max(last_used_at, ?) WHERE row_key=? AND account_id=? AND fence IS ?", ).run(row.lastUsedAt, t.rowKey, row.accountId, row.fence ?? null); } } /** * Commit the ordered log and touches. The final release flush (clean=true) commits work that was * logged outside any passive read, so it runs even if the release happens inside one. */ function flush(s: Scope, clean: boolean): boolean { if (!s.db || s.disabled || s.poisoned || (!clean && isPassiveRead())) return false; const db = s.db; for (let attempt = 0; attempt < 2; attempt++) try { assertStorageOwned(s.token); assertWritable(s); db.exec("BEGIN IMMEDIATE"); // Touches go before the log as well as after it, so the pruning between chunks sees the live // last-used times and cannot evict a pin that is in use but persisted with an old timestamp. applyTouches(s, db); for (let i = 0; i < s.log.length; i++) { const op = s.log[i]!; if (op.args.length) db.query(op.sql).run(...op.args); else db.exec(op.sql); // Touches before every chunk prune, so rows this chunk inserted carry their live last-used time. if ((i + 1) % 256 === 0) { applyTouches(s, db); prune(db, Date.now()); } } // Again after the log: rows the log just inserted take their live last-used time. applyTouches(s, db); prune(db, Date.now()); if (clean) db.exec("UPDATE meta SET value=1 WHERE name='clean'"); db.exec("COMMIT"); s.log = []; s.threads.clear(); s.issuers.clear(); s.failures = 0; return true; } catch (error) { try { db.exec("ROLLBACK"); } catch { /* preserve failure */ } if (attempt === 0 && error instanceof Error && "code" in error && error.code === "SQLITE_FULL" && pruneOnly(s)) continue; if (++s.failures >= 3) poison(s); else warning(); // Deleting expired rows does not depend on the failed batch; keep the retention bound. pruneOnly(s); return false; } return false; } // Open eagerly so the startup prune runs without traffic; a passive read never opens the store. onSpendLedgerOwnerAcquired((home) => { if (!isPassiveRead()) scope(home); }); // Commit clean before closing; a later close failure cannot undo that commit. onSpendLedgerOwnerReleasing(() => { const s = current; if (s) { flush(s, true); retire(); } }); onSpendLedgerOwnerReleased(() => retire()); function pending(s: Scope, row: string, issuer: boolean): boolean { return s.log.some( (op) => op.kind === "clearAll" || (issuer ? op.kind === "clearIssuers" || (op.kind === "issuerDelete" && op.key === row) : op.kind === "clearThreads" || (op.kind === "deleteKey" && op.key === row)), ); } function consulted(s: Scope, key: string): boolean { if (s.consulted.has(key)) return true; s.consulted.add(key); if (s.consulted.size > 8192) s.consulted.delete(s.consulted.values().next().value!); return false; } function validScope(value: string): boolean { const bases: readonly string[] = ["legacy", ...BASE_SCOPES]; if (bases.includes(value)) return true; const m = /^model-detour:([^:]+):(.+)$/s.exec(value); return ( !!m && bases.includes(m[1]!) && Buffer.byteLength(m[2]!, "utf8") <= 512 ); } export function adoptStoredThreadRows( key: string, now: number, scopeName?: string, ): StoredThreadRow[] { const s = usable(); if (!s) return []; const rk = rowKey(s, key, "conversation"); // A completed unscoped read (marker "*") already adopted every stored scope for this key. if ( !rk || pending(s, rk, false) || s.consulted.has(`t:${rk}:*`) || (scopeName !== undefined && s.consulted.has(`t:${rk}:${scopeName}`)) ) return []; try { // Enumerating every scope matters: routing decides account-wide release from this view. The // table itself is trimmed to 2048 rows at open and on every flush, which bounds the read. const rows = s .db!.query( scopeName === undefined ? "SELECT scope, account_id, fence, created_at, last_used_at FROM threads WHERE row_key=? ORDER BY last_used_at DESC, scope LIMIT 2048" : "SELECT scope, account_id, fence, created_at, last_used_at FROM threads WHERE row_key=? AND scope=? LIMIT 1", ) .all(...(scopeName === undefined ? [rk] : [rk, scopeName])) as { scope: string; account_id: string; fence: string; created_at: number; last_used_at: number; }[]; const result: StoredThreadRow[] = []; for (const r of rows) { if ( s.log.some( (op) => op.kind === "deleteScope" && op.key === rk && op.scope === r.scope, ) || s.log.some( (op) => (op.kind === "deleteAccount" && op.args[0] === r.account_id) || (op.kind === "deleteKeyAccount" && op.key === rk && op.args[1] === r.account_id), ) ) continue; if ( !validScope(r.scope) || !Number.isFinite(r.created_at) || !Number.isFinite(r.last_used_at) || r.created_at > now || r.last_used_at > now || now - r.last_used_at > TTL || !r.fence || codexAffinityIdentityFence(r.account_id) !== r.fence ) { enqueue(s, { kind: "deleteScope", key: rk, scope: r.scope, sql: "DELETE FROM threads WHERE row_key=? AND scope=?", args: [rk, r.scope], }); continue; } rememberThreadKey(s, key, rk, r.scope, r.account_id); if (s.poisoned) return []; result.push({ scope: r.scope, accountId: r.account_id, fence: r.fence, createdAt: r.created_at, lastUsedAt: r.last_used_at, }); } for (const row of rows) consulted(s, `t:${rk}:${row.scope}`); if (scopeName !== undefined) consulted(s, `t:${rk}:${scopeName}`); else consulted(s, `t:${rk}:*`); return result; } catch { warning(); return []; } } export function adoptStoredIssuer( key: string, now: number, ): { issuer: string; storedAccountId: string; storedFence: string | null } | undefined { const s = usable(); if (!s) return; const rk = rowKey(s, key, "issuer"); if (!rk || pending(s, rk, true) || s.consulted.has(`i:${rk}`)) return; try { const r = s .db!.query( "SELECT account_id, fence, last_used_at FROM issuers WHERE row_key=?", ) .get(rk) as { account_id: string; fence: string | null; last_used_at: number; } | null; if (!r) { consulted(s, `i:${rk}`); return; } if ( !Number.isFinite(r.last_used_at) || r.last_used_at > now || now - r.last_used_at > TTL ) { enqueue(s, { kind: "issuerDelete", key: rk, sql: "DELETE FROM issuers WHERE row_key=?", args: [rk], }); return; } const result = r.fence && codexAffinityIdentityFence(r.account_id) === r.fence ? r.account_id : CODEX_UNKNOWN_CONVERSATION_STATE_ISSUER; rememberIssuerKey(s, key, rk); if (s.poisoned) return; consulted(s, `i:${rk}`); return { issuer: result, storedAccountId: r.account_id, storedFence: r.fence }; } catch { warning(); return; } } export function recordThreadBind( key: string, scopeName: string, row: StoredThreadRow, ): void { if (isRequestOwnedAffinityKey(key)) return; const s = writableScope(row.accountId !== "__main__" && !!row.fence); if (!s || row.accountId === "__main__" || !row.fence) return; const rk = rowKey(s, key, "conversation"); if (!rk) return; rememberThreadKey(s, key, rk, scopeName, row.accountId); if (s.poisoned) return; enqueue(s, { kind: "bind", key: rk, scope: scopeName, sql: "INSERT INTO threads VALUES (?,?,?,?,?,?) ON CONFLICT(row_key,scope) DO UPDATE SET account_id=excluded.account_id,fence=excluded.fence,created_at=excluded.created_at,last_used_at=excluded.last_used_at", args: [ rk, scopeName, row.accountId, row.fence, row.createdAt, row.lastUsedAt, ], }); } export function recordThreadTouch(key: string, scopeName: string): void { const s = usable(); if (!s) return; const rk = rowKey(s, key, "conversation"); if (!rk) return; s.threads.set(`${rk}\0${scopeName}`, { key, scope: scopeName, rowKey: rk }); scheduleTouch(s); } export function recordThreadDelete(key: string, scopeName?: string): void { if (isRequestOwnedAffinityKey(key)) return; const s = writableScope(true); if (!s) return; const rk = rowKey(s, key, "conversation"); if (!rk) return; const known = s.threadKeys.get(key); if (scopeName === undefined) s.threadKeys.delete(key); else if (known) { known.scopes.delete(scopeName); if (!known.scopes.size) s.threadKeys.delete(key); } enqueue( s, scopeName === undefined ? { kind: "deleteKey", key: rk, sql: "DELETE FROM threads WHERE row_key=?", args: [rk], } : { kind: "deleteScope", key: rk, scope: scopeName, sql: "DELETE FROM threads WHERE row_key=? AND scope=?", args: [rk, scopeName], }, ); } export function recordThreadAccountDeleted(key: string, id: string): void { if (isRequestOwnedAffinityKey(key)) return; const s = writableScope(true); if (!s) return; const rk = rowKey(s, key, "conversation"); if (!rk) return; const known = s.threadKeys.get(key); if (known) { for (const [scopeName, account] of known.scopes) if (account === id) known.scopes.delete(scopeName); if (!known.scopes.size) s.threadKeys.delete(key); } enqueue(s, { kind: "deleteKeyAccount", key: rk, sql: "DELETE FROM threads WHERE row_key=? AND account_id=?", args: [rk, id] }); } export function recordAccountPinsCleared(id: string): void { const s = writableScope(true); if (s) { for (const [key, entry] of s.threadKeys) { for (const [scopeName, account] of entry.scopes) if (account === id) entry.scopes.delete(scopeName); if (!entry.scopes.size) s.threadKeys.delete(key); } enqueue(s, { kind: "deleteAccount", sql: "DELETE FROM threads WHERE account_id=?", args: [id], }); } } export function recordAllCleared(): void { const s = writableScope(true); if (s) { s.threadKeys.clear(); s.issuerKeys.clear(); enqueue(s, { kind: "clearAll", sql: "DELETE FROM threads; DELETE FROM issuers", args: [], }); } } /** A manual account switch clears pins but keeps the issuers of carried state. */ export function recordThreadsCleared(): void { const s = writableScope(true); if (s) { s.threadKeys.clear(); enqueue(s, { kind: "clearThreads", sql: "DELETE FROM threads", args: [] }); } } /** Test seam: feed the anchor observer directly, as a future derivation path might. */ export function noteCodexAffinityAnchorForTests(key: string, family: string, thread: string): void { observeAnchor(key, family, thread); } export function recordIssuerSet( key: string, id: string, fence: string | null, lastUsedAt: number, ): void { if (isRequestOwnedAffinityKey(key)) return; const s = writableScope(id !== "__main__"); if (!s || id === "__main__") return; const rk = rowKey(s, key, "issuer"); if (!rk) return; rememberIssuerKey(s, key, rk); if (s.poisoned) return; enqueue(s, { kind: "issuerSet", key: rk, sql: "INSERT INTO issuers VALUES (?,?,?,?) ON CONFLICT(row_key) DO UPDATE SET account_id=excluded.account_id,fence=excluded.fence,last_used_at=excluded.last_used_at", args: [rk, id, fence, lastUsedAt], }); } export function recordIssuerTouch(key: string): void { const s = usable(); if (!s) return; const rk = rowKey(s, key, "issuer"); if (!rk) return; s.issuers.set(rk, { key, rowKey: rk }); scheduleTouch(s); } export function recordIssuerDelete(key: string): void { if (isRequestOwnedAffinityKey(key)) return; const s = writableScope(true); if (!s) return; const rk = rowKey(s, key, "issuer"); if (rk) { s.issuerKeys.delete(key); enqueue(s, { kind: "issuerDelete", key: rk, sql: "DELETE FROM issuers WHERE row_key=?", args: [rk], }); } } export function recordIssuersCleared(): void { const s = writableScope(true); if (s) { s.issuerKeys.clear(); enqueue(s, { kind: "clearIssuers", sql: "DELETE FROM issuers", args: [] }); } } export function flushCodexAffinityStoreForTests(): void { if (current && !isPassiveRead()) flush(current, false); } export function resetCodexAffinityStoreForTests(): void { if (current) { flush(current, false); retire(); } // Model a fresh process: nothing carried from an earlier scope, nothing known to be stale. carried = undefined; persistedHome = undefined; needsClear = false; }