codex-cleaner 0.0.1 → 0.0.3

package/dist/cleaner.d.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 import type { BlockingProcess, CleanerOptions, CompactWhere } from "./types.js";
 type CodexSpawnCommand = {
     args: string[];
@@ -30,22 +30,23 @@ export declare function compactWhere(args: {
     protectRecent: boolean;
     protectedIds: Set<string>;
 }): CompactWhere;
-export declare function collectCompactCandidateStats(db: Database.Database, args: {
+export declare function collectCompactCandidateStats(db: DatabaseSync, args: {
     archivedOnly: boolean;
     cutoffMs: number;
     maxChars: number;
     protectRecent: boolean;
     protectedIds: Set<string>;
 }): Record<string, unknown>;
-export declare function collectStaleArchiveCandidateStats(db: Database.Database, codexHome: string, args: {
+export declare function collectStaleArchiveCandidateStats(db: DatabaseSync, codexHome: string, args: {
     cutoffMs: number;
     protectedIds: Set<string>;
     statRollouts?: boolean;
 }): Record<string, unknown>;
-export declare function collectLogCleanupStats(db: Database.Database, options: CleanerOptions): Record<string, unknown>;
+export declare function collectLogCleanupStats(db: DatabaseSync, options: CleanerOptions): Record<string, unknown>;
 export declare function collectTuiLogCleanupStats(logPath: string, keepMib: number): Record<string, unknown>;
-export declare function collectOrphanRolloutArchiveStats(db: Database.Database, codexHome: string, args: {
+export declare function collectOrphanRolloutArchiveStats(db: DatabaseSync, codexHome: string, args: {
     cutoffMs: number;
+    protectedIds: Set<string>;
 }): Record<string, unknown>;
 export declare function nextBackupPath(dbPath: string, backupDir: string, now?: Date): string;
 export declare function nextFileBackupPath(filePath: string, backupDir: string, now?: Date): string;

package/dist/cleaner.js

@@ -2,8 +2,8 @@ import { execFile, spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { backup as sqliteBackup, DatabaseSync } from "node:sqlite";
 import { promisify } from "node:util";
-import Database from "better-sqlite3";
 const execFileAsync = promisify(execFile);
 const THREAD_COLUMNS_TO_CAP = ["title", "preview", "first_user_message"];
 const APP_SERVER_REQUEST_TIMEOUT_MS = 60_000;
@@ -373,7 +373,10 @@ export function buildScanReport(options) {
             });
         }
         if (options.archiveOrphanRollouts) {
-            report.orphanRolloutArchiveCandidates = collectOrphanRolloutArchiveStats(db, codexHome, { cutoffMs });
+            report.orphanRolloutArchiveCandidates = collectOrphanRolloutArchiveStats(db, codexHome, {
+                cutoffMs,
+                protectedIds,
+            });
         }
         report.recentSample = queryAll(db, `
       SELECT id, archived, updated_at, updated_at_ms, source, agent_role,
@@ -438,7 +441,7 @@ export async function compactMetadata(options) {
             throw new Error("--apply requires --confirm-lossy-metadata");
         }
         if (options.apply && Number(before.rows) > 0) {
-            backupPath = await backupSqliteDatabase(stateDb, resolveBackupDir(options, codexHome));
+            backupPath = await backupOpenSqliteDatabase(db, stateDb, resolveBackupDir(options, codexHome));
             const where = compactWhere({
                 archivedOnly: options.archivedOnly,
                 cutoffMs,
@@ -447,9 +450,8 @@ export async function compactMetadata(options) {
                 protectedIds,
             });
             const assignments = THREAD_COLUMNS_TO_CAP.map((column) => `${column} = CASE WHEN length(${column}) > @maxChars THEN substr(${column}, 1, @maxChars) ELSE ${column} END`).join(", ");
-            const update = db.prepare(`UPDATE threads SET ${assignments} WHERE ${where.sql}`);
-            const tx = db.transaction(() => update.run(where.params));
-            changedRows = Number(tx().changes);
+            const update = prepareStatement(db, `UPDATE threads SET ${assignments} WHERE ${where.sql}`);
+            changedRows = Number(runTransaction(db, () => update.run(where.params).changes));
         }
         const after = collectCompactCandidateStats(db, {
             archivedOnly: options.archivedOnly,
@@ -592,10 +594,11 @@ export function archiveOrphanRollouts(options) {
     const codexHome = resolveCodexHome(options);
     const stateDb = path.join(codexHome, "state_5.sqlite");
     const cutoffMs = recentCutoffMs(options.keepRecentDays);
+    const protectedIds = allProtectedIds(loadThreadProtection(codexHome, loadGlobalState(codexHome)));
     const beforeDb = openReadonlyDb(stateDb);
     let beforePlan;
     try {
-        beforePlan = buildOrphanRolloutPlan(beforeDb, codexHome, { cutoffMs });
+        beforePlan = buildOrphanRolloutPlan(beforeDb, codexHome, { cutoffMs, protectedIds });
     }
     finally {
         beforeDb.close();
@@ -614,6 +617,7 @@ export function archiveOrphanRollouts(options) {
             codexHome,
             policy: {
                 keepRecentDays: options.keepRecentDays,
+                protectedThreads: protectedIds.size,
                 recentCutoffMs: cutoffMs,
                 recentCutoffUtc: millisToIso(cutoffMs),
             },
@@ -645,6 +649,7 @@ export function archiveOrphanRollouts(options) {
             codexHome,
             policy: {
                 keepRecentDays: options.keepRecentDays,
+                protectedThreads: protectedIds.size,
                 recentCutoffMs: cutoffMs,
                 recentCutoffUtc: millisToIso(cutoffMs),
             },
@@ -657,7 +662,7 @@ export function archiveOrphanRollouts(options) {
     const afterDb = openReadonlyDb(stateDb);
     let afterPlan;
     try {
-        afterPlan = buildOrphanRolloutPlan(afterDb, codexHome, { cutoffMs });
+        afterPlan = buildOrphanRolloutPlan(afterDb, codexHome, { cutoffMs, protectedIds });
     }
     finally {
         afterDb.close();
@@ -669,6 +674,7 @@ export function archiveOrphanRollouts(options) {
         generatedAt: new Date().toISOString(),
         policy: {
             keepRecentDays: options.keepRecentDays,
+            protectedThreads: protectedIds.size,
             recentCutoffMs: cutoffMs,
             recentCutoffUtc: millisToIso(cutoffMs),
         },
@@ -749,23 +755,20 @@ export async function cleanLogs(options) {
         const hasRowChanges = Number(before.cap_rows) > 0 || Number(before.delete_rows) > 0;
         const shouldVacuum = Number(beforeSpace.freelist_count) > 0 || hasRowChanges;
         if (options.apply && shouldVacuum) {
-            backupPath = await backupSqliteDatabase(logsDb, resolveBackupDir(options, codexHome));
+            backupPath = await backupOpenSqliteDatabase(db, logsDb, resolveBackupDir(options, codexHome));
             const cutoffSeconds = logCutoffSeconds(options.keepLogDays);
             if (hasRowChanges) {
-                const tx = db.transaction(() => {
-                    deletedRows = Number(db.prepare("DELETE FROM logs WHERE ts < @cutoffSeconds").run({ cutoffSeconds }).changes);
-                    cappedRows = Number(db
-                        .prepare(`
+                runTransaction(db, () => {
+                    deletedRows = Number(prepareStatement(db, "DELETE FROM logs WHERE ts < @cutoffSeconds").run({ cutoffSeconds }).changes);
+                    cappedRows = Number(prepareStatement(db, `
                 UPDATE logs
                 SET estimated_bytes = max(0, estimated_bytes - (length(feedback_log_body) - @maxLogBodyChars)),
                     feedback_log_body = substr(feedback_log_body, 1, @maxLogBodyChars)
                 WHERE ts >= @cutoffSeconds
                   AND feedback_log_body IS NOT NULL
                   AND length(feedback_log_body) > @maxLogBodyChars
-              `)
-                        .run({ cutoffSeconds, maxLogBodyChars: options.maxLogBodyChars }).changes);
+              `).run({ cutoffSeconds, maxLogBodyChars: options.maxLogBodyChars }).changes);
                 });
-                tx();
             }
             db.exec("VACUUM");
             queryAll(db, "PRAGMA wal_checkpoint(TRUNCATE)");
@@ -912,9 +915,7 @@ export async function scheduleBackupPrune(options) {
     };
 }
 export function compactWhere(args) {
-    const clauses = [
-        `(${THREAD_COLUMNS_TO_CAP.map((column) => `length(${column}) > @maxChars`).join(" OR ")})`,
-    ];
+    const clauses = [`(${THREAD_COLUMNS_TO_CAP.map((column) => `length(${column}) > @maxChars`).join(" OR ")})`];
     const params = {
         cutoffMs: args.cutoffMs,
         maxChars: args.maxChars,
@@ -1185,6 +1186,10 @@ function buildOrphanRolloutPlan(db, codexHome, args) {
             skipped.push({ ...move, reason: "recent" });
             continue;
         }
+        if (threadId && args.protectedIds.has(threadId)) {
+            skipped.push({ ...move, reason: "protected" });
+            continue;
+        }
         if (move.indexed) {
             skipped.push({ ...move, reason: "session-indexed" });
             continue;
@@ -1216,6 +1221,7 @@ function buildOrphanRolloutPlan(db, codexHome, args) {
             unindexed_size_mib: fileMoveListSizeMib(unindexed),
             skipped_files: skipped.length,
             skipped_recent_files: skipped.filter((move) => move.reason === "recent").length,
+            skipped_protected_files: skipped.filter((move) => move.reason === "protected").length,
             skipped_session_indexed_files: skipped.filter((move) => move.reason === "session-indexed").length,
             skipped_destination_exists_files: skipped.filter((move) => move.reason === "destination-exists").length,
             oldest_candidate_modified_utc: millisToIso(minNumberOrNull(modifiedValues)),
@@ -1368,15 +1374,18 @@ function backupFileStats(files) {
     };
 }
 async function backupSqliteDatabase(dbPath, backupDir) {
-    fs.mkdirSync(backupDir, { recursive: true });
-    const backupPath = nextBackupPath(dbPath, backupDir);
     const db = openWritableDb(dbPath);
     try {
-        await db.backup(backupPath);
+        return await backupOpenSqliteDatabase(db, dbPath, backupDir);
     }
     finally {
         db.close();
     }
+}
+async function backupOpenSqliteDatabase(db, dbPath, backupDir) {
+    fs.mkdirSync(backupDir, { recursive: true });
+    const backupPath = nextBackupPath(dbPath, backupDir);
+    await sqliteBackup(db, backupPath);
     return backupPath;
 }
 function backupRegularFile(filePath, backupDir) {
@@ -1393,7 +1402,7 @@ async function vacuumSqliteDatabase(args) {
         const beforeSpace = collectSqliteSpaceStats(db);
         if (args.apply && Number(beforeSpace.freelist_count) > 0) {
             if (args.backupBeforeVacuum) {
-                backupPath = await backupSqliteDatabase(args.dbPath, args.backupDir);
+                backupPath = await backupOpenSqliteDatabase(db, args.dbPath, args.backupDir);
             }
             db.exec("VACUUM");
             queryAll(db, "PRAGMA wal_checkpoint(TRUNCATE)");
@@ -1424,10 +1433,7 @@ function nextOrphanRolloutManifestPath(backupDir, now = new Date()) {
     return nextTimestampedPath(backupDir, "orphan-rollouts", ".manifest.bak", now);
 }
 function nextTimestampedPath(backupDir, name, suffix, now) {
-    const stamp = now
-        .toISOString()
-        .replace(/[-:]/g, "")
-        .replace(".", "_");
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(".", "_");
     const base = `${name}.${stamp}`;
     let candidate = path.join(backupDir, `${base}${suffix}`);
     let collision = 2;
@@ -1604,21 +1610,38 @@ function timestampForName(date) {
 function openReadonlyDb(file) {
     if (!fs.existsSync(file))
         throw new Error(`SQLite database not found: ${file}`);
-    return new Database(file, { fileMustExist: true, readonly: true });
+    return new DatabaseSync(file, { readOnly: true });
 }
 function openWritableDb(file) {
     if (!fs.existsSync(file))
         throw new Error(`SQLite database not found: ${file}`);
-    const db = new Database(file, { fileMustExist: true });
-    db.pragma("busy_timeout = 5000");
-    db.pragma("foreign_keys = ON");
+    const db = new DatabaseSync(file);
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA foreign_keys = ON");
     return db;
 }
 function queryAll(db, sql, params) {
-    return db.prepare(sql).all(params ?? {});
+    return prepareStatement(db, sql).all(params ?? {});
 }
 function queryOne(db, sql, params) {
-    return db.prepare(sql).get(params ?? {}) ?? {};
+    return prepareStatement(db, sql).get(params ?? {}) ?? {};
+}
+function prepareStatement(db, sql) {
+    const statement = db.prepare(sql);
+    statement.setAllowUnknownNamedParameters(true);
+    return statement;
+}
+function runTransaction(db, fn) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const result = fn();
+        db.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
 }
 function tryQueryAll(db, sql) {
     try {
@@ -2227,6 +2250,7 @@ function printOrphanRolloutArchiveCandidate(title, value) {
         "unindexed_files",
         "empty_dir_candidates",
         "skipped_recent_files",
+        "skipped_protected_files",
         "skipped_session_indexed_files",
         "skipped_destination_exists_files",
         "oldest_candidate_modified_utc",

package/dist/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
+import { spawnSync } from "node:child_process";
 import { parseArgs } from "node:util";
-import { buildScanReport, archiveOrphanRollouts, checkpointWal, cleanCodex, compactMetadata, emitReport, pruneBackups, requireStoppedOrReadonlyAllowed, scanBackups, scheduleBackupPrune, } from "./cleaner.js";
-import { runWizard } from "./wizard.js";
 const USAGE = `
 codex-cleaner [command] [options]
 
@@ -131,7 +130,12 @@ async function main(argv = process.argv.slice(2)) {
         pruneLogs: Boolean(parsed.values["prune-logs"]),
         pruneTuiLog: Boolean(parsed.values["prune-tui-log"]),
     };
+    const reexecCode = reexecWithSqliteWarningDisabled(argv);
+    if (reexecCode != null)
+        return reexecCode;
+    const { archiveOrphanRollouts, buildScanReport, checkpointWal, cleanCodex, compactMetadata, emitReport, pruneBackups, requireStoppedOrReadonlyAllowed, scanBackups, scheduleBackupPrune, } = await import("./cleaner.js");
     if (!command) {
+        const { runWizard } = await import("./wizard.js");
         return runWizard(options);
     }
     if (command !== "backups") {
@@ -178,6 +182,24 @@ function isMutating(command, options) {
 function allowsRunningFileOnlyMutation(command, options) {
     return command === "archive-orphan-rollouts" && options.apply && options.allowRunningOrphanRolloutArchive;
 }
+function reexecWithSqliteWarningDisabled(argv) {
+    const alreadyDisabled = process.env.NODE_NO_WARNINGS === "1" ||
+        process.execArgv.includes("--no-warnings") ||
+        process.execArgv.includes("--disable-warning=ExperimentalWarning");
+    if (alreadyDisabled)
+        return null;
+    if (!process.allowedNodeEnvironmentFlags.has("--disable-warning=ExperimentalWarning"))
+        return null;
+    if (!process.argv[1])
+        return null;
+    const result = spawnSync(process.execPath, [...process.execArgv, "--disable-warning=ExperimentalWarning", process.argv[1], ...argv], {
+        stdio: "inherit",
+        windowsHide: true,
+    });
+    if (result.error)
+        throw result.error;
+    return result.status ?? 1;
+}
 function parsePositiveInt(raw, name) {
     const value = Number(raw);
     if (!Number.isInteger(value) || value <= 0) {

package/dist/wizard.js

@@ -252,6 +252,9 @@ function printDryRunSummary(report) {
         if (Number(orphanRollouts.skipped_recent_files) > 0) {
             console.log(pc.yellow(`  Skipped ${String(orphanRollouts.skipped_recent_files)} orphan rollouts inside the recent window.`));
         }
+        if (Number(orphanRollouts.skipped_protected_files) > 0) {
+            console.log(pc.yellow(`  Skipped ${String(orphanRollouts.skipped_protected_files)} protected orphan rollouts.`));
+        }
         if (Number(orphanRollouts.skipped_session_indexed_files) > 0) {
             console.log(pc.yellow(`  Skipped ${String(orphanRollouts.skipped_session_indexed_files)} DB-orphaned rollouts still present in session_index.jsonl.`));
         }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "codex-cleaner",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Guarded cleanup and compaction utility for local Codex state.",
   "license": "MIT",
   "type": "module",
-  "packageManager": "npm@11.11.0",
+  "packageManager": "npm@11.15.0",
   "bin": {
     "codex-cleaner": "dist/cli.js"
   },
@@ -13,7 +13,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=22.12"
+    "node": ">=22.16"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -21,16 +21,14 @@
     "format": "prettier --check .",
     "lint": "eslint .",
     "prepack": "npm run build",
-    "test": "vitest run"
+    "test": "node scripts/run-vitest.js"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.3",
-    "better-sqlite3": "^12.10.0",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.9.1",
     "eslint": "^10.4.0",
     "globals": "^17.6.0",