@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
293 lines (273 loc) • 10.4 kB
text/typescript
import { createHash } from "node:crypto";
import { existsSync, readdirSync, statSync } from "node:fs";
import { join } from "node:path";
import { Database } from "bun:sqlite";
import { resolveCodexHomeDir } from "../../codex/home";
import { columnExists, discoverRuntimeDbPaths, tableExists } from "./db";
import { ARCHIVED_SESSIONS_DIR, isSafeArchiveFileName, logicalRolloutRelPath, normalizeArchivedRolloutPath } from "./paths";
import { collectRestorePendingAcceptedDestRels } from "./pending";
import type { ArchivedCandidate, CleanupPreview } from "./types";
export function clampPercent(percent: unknown): number {
if (typeof percent !== "number" || !Number.isFinite(percent)) return 0;
return Math.max(0, Math.min(100, Math.floor(percent)));
}
function candidateDigestLines(candidates: ArchivedCandidate[]): string[] {
return candidates
.map(c => {
const physical = [...c.physicalFiles]
.sort((a, b) => a.relPath.localeCompare(b.relPath))
.map(f => `${f.relPath}|${f.bytes}|${Math.trunc(f.mtimeMs)}`)
.join(",");
return `${c.relPath}|${c.bytes}|${Math.trunc(c.mtimeMs)}|${physical}`;
})
.sort();
}
/** Content digest of the exact previewed candidate set (paths + size + mtime). */
export function computePreviewDigest(candidates: ArchivedCandidate[], percent: number): string {
return createHash("sha256")
.update(`${clampPercent(percent)}\n${candidateDigestLines(candidates).join("\n")}`)
.digest("hex");
}
/**
* Digest bound to an explicit candidate list (not a percent selection).
* Used when reduceToBytes needs an exact count that percent rounding cannot represent.
*/
export function computeExactPreviewDigest(candidates: ArchivedCandidate[]): string {
return createHash("sha256")
.update(`exact\n${candidateDigestLines(candidates).join("\n")}`)
.digest("hex");
}
/** List archived rollout groups oldest-first. Never walks `sessions/`. */
export function listArchivedCandidates(codexHome: string): ArchivedCandidate[] {
const dir = join(codexHome, ARCHIVED_SESSIONS_DIR);
let names: string[] = [];
try {
names = readdirSync(dir);
} catch {
return [];
}
type Acc = {
logicalRel: string;
files: Array<{ name: string; absPath: string; relPath: string; bytes: number; mtimeMs: number }>;
};
const groups = new Map<string, Acc>();
for (const name of names) {
if (!isSafeArchiveFileName(name)) continue;
const absPath = join(dir, name);
try {
const st = statSync(absPath);
if (!st.isFile()) continue;
const relPath = `${ARCHIVED_SESSIONS_DIR}/${name}`;
const logicalRel = logicalRolloutRelPath(relPath);
let acc = groups.get(logicalRel);
if (!acc) {
acc = { logicalRel, files: [] };
groups.set(logicalRel, acc);
}
acc.files.push({
name,
absPath,
relPath,
bytes: st.size,
mtimeMs: st.mtimeMs,
});
} catch {
/* vanished mid-scan */
}
}
const out: ArchivedCandidate[] = [];
for (const acc of groups.values()) {
// Prefer the plain `.jsonl` path as the public/logical identity when both exist.
acc.files.sort((a, b) => a.relPath.localeCompare(b.relPath));
const primary =
acc.files.find(f => f.relPath === acc.logicalRel) ??
acc.files[0]!;
out.push({
relPath: acc.logicalRel,
absPath: primary.absPath,
bytes: acc.files.reduce((sum, f) => sum + f.bytes, 0),
mtimeMs: Math.min(...acc.files.map(f => f.mtimeMs)),
physicalRelPaths: acc.files.map(f => f.relPath),
physicalFiles: acc.files.map(f => ({ relPath: f.relPath, bytes: f.bytes, mtimeMs: f.mtimeMs })),
});
}
out.sort((a, b) => a.mtimeMs - b.mtimeMs || a.relPath.localeCompare(b.relPath));
return out;
}
export function selectOldestPercent(candidates: ArchivedCandidate[], percent: number): ArchivedCandidate[] {
const pct = clampPercent(percent);
if (pct <= 0 || candidates.length === 0) return [];
if (pct >= 100) return [...candidates];
const n = percentSelectionTargetCount(candidates.length, pct);
return candidates.slice(0, n);
}
/** Count implied by percent selection over the full candidate list. */
export function percentSelectionTargetCount(totalCount: number, percent: number): number {
const pct = clampPercent(percent);
if (pct <= 0 || totalCount === 0) return 0;
if (pct >= 100) return totalCount;
return Math.max(1, Math.floor((totalCount * pct) / 100));
}
export function candidateOverlapsPendingRestore(
candidate: ArchivedCandidate,
pendingDestRels: ReadonlySet<string>,
): boolean {
if (pendingDestRels.size === 0) return false;
for (const rel of candidate.physicalRelPaths) {
if (pendingDestRels.has(rel)) return true;
}
return pendingDestRels.has(candidate.relPath);
}
/** Drop cleanup candidates whose physical paths overlap an in-progress restore. */
export function filterCandidatesExcludingPendingRestore(
candidates: ArchivedCandidate[],
codexHome: string = resolveCodexHomeDir(),
): ArchivedCandidate[] {
const pendingDestRels = collectRestorePendingAcceptedDestRels(codexHome);
if (pendingDestRels.size === 0) return candidates;
return candidates.filter(c => !candidateOverlapsPendingRestore(c, pendingDestRels));
}
/**
* Oldest-first percent selection that skips pending-restore destinations without
* consuming the percent budget, backfilling with the next oldest safe candidates.
*/
export function selectOldestPercentSkippingPendingRestore(
candidates: ArchivedCandidate[],
percent: number,
codexHome: string = resolveCodexHomeDir(),
): ArchivedCandidate[] {
const target = percentSelectionTargetCount(candidates.length, percent);
if (target === 0) return [];
const pendingDestRels = collectRestorePendingAcceptedDestRels(codexHome);
const out: ArchivedCandidate[] = [];
for (const c of candidates) {
if (candidateOverlapsPendingRestore(c, pendingDestRels)) continue;
out.push(c);
if (out.length >= target) break;
}
return out;
}
/**
* Reduce archived total toward `reduceToBytes` using oldest safe candidates only.
* Pending-restore destinations are skipped and do not count toward bytes freed.
*/
export function selectReduceToBytesSkippingPendingRestore(
candidates: ArchivedCandidate[],
reduceToBytes: number,
codexHome: string = resolveCodexHomeDir(),
): ArchivedCandidate[] {
if (!Number.isFinite(reduceToBytes) || reduceToBytes < 0) return [];
const total = candidates.reduce((sum, c) => sum + c.bytes, 0);
if (total <= reduceToBytes) return [];
const need = total - reduceToBytes;
const pendingDestRels = collectRestorePendingAcceptedDestRels(codexHome);
const out: ArchivedCandidate[] = [];
let freed = 0;
for (const c of candidates) {
if (candidateOverlapsPendingRestore(c, pendingDestRels)) continue;
out.push(c);
freed += c.bytes;
if (freed >= need) break;
}
return out;
}
/**
* Normalized rollout paths of pinned threads. Pinned threads are never
* cleanup candidates: a pin is the user's explicit "keep this" signal and
* deleting its rollout would be permanent task-data loss (#858).
*
* Selection-time use is advisory: on any DB problem this returns an empty
* set, and the write-locked re-check inside reconcileDeletedThreads stays
* the fail-closed gate. Older schemas without `is_pinned` keep prior
* behavior.
*/
function collectPinnedArchivedRolloutPaths(codexHome: string): Set<string> {
const statePath = discoverRuntimeDbPaths(codexHome).state;
if (!statePath || !existsSync(statePath)) return new Set();
let db: Database | undefined;
try {
db = new Database(statePath, { readonly: true });
if (!tableExists(db, "threads") || !columnExists(db, "threads", "is_pinned")) {
return new Set();
}
const rows = db.query<{ rollout_path: string }, []>(
`SELECT rollout_path FROM threads WHERE is_pinned = 1`,
).all();
const out = new Set<string>();
for (const row of rows) {
const normalized = normalizeArchivedRolloutPath(row.rollout_path, codexHome);
if (normalized) out.add(normalized);
}
return out;
} catch {
return new Set();
} finally {
try { db?.close(); } catch { /* */ }
}
}
/** Drop candidates whose rollout belongs to a pinned thread (#858). */
export function filterCandidatesExcludingPinned(
candidates: ArchivedCandidate[],
codexHome: string,
): ArchivedCandidate[] {
const pinned = collectPinnedArchivedRolloutPaths(codexHome);
if (pinned.size === 0) return candidates;
return candidates.filter(c => !pinned.has(c.relPath));
}
export function previewArchivedCleanup(
percent: number,
codexHome: string = resolveCodexHomeDir(),
): CleanupPreview {
const all = listArchivedCandidates(codexHome);
const safe = selectOldestPercentSkippingPendingRestore(
filterCandidatesExcludingPinned(all, codexHome),
percent,
codexHome,
);
const pct = clampPercent(percent);
return {
codexHome,
percent: pct,
count: safe.length,
bytes: safe.reduce((sum, c) => sum + c.bytes, 0),
digest: computePreviewDigest(safe, pct),
candidates: safe,
};
}
/** Preview bound to an explicit candidate set (exact digest, percent left at 0). */
export function previewExactArchivedCleanup(
candidates: ArchivedCandidate[],
codexHome: string = resolveCodexHomeDir(),
): CleanupPreview {
const safe = filterCandidatesExcludingPinned(
filterCandidatesExcludingPendingRestore(candidates, codexHome),
codexHome,
);
return {
codexHome,
percent: 0,
count: safe.length,
bytes: safe.reduce((sum, c) => sum + c.bytes, 0),
digest: computeExactPreviewDigest(safe),
candidates: safe,
};
}
/**
* Resolve an exact candidate list from current archive state.
* Returns null when any requested path is missing or drifted (caller maps to stale_preview).
*/
export function resolveExactArchivedCandidates(
candidateRelPaths: string[],
codexHome: string = resolveCodexHomeDir(),
): ArchivedCandidate[] | null {
if (!Array.isArray(candidateRelPaths) || candidateRelPaths.length === 0) return [];
const all = listArchivedCandidates(codexHome);
const byRel = new Map(all.map(c => [c.relPath, c]));
const selected: ArchivedCandidate[] = [];
for (const rel of candidateRelPaths) {
const hit = byRel.get(rel);
if (!hit) return null;
selected.push(hit);
}
return selected;
}