codex-cleaner 0.0.1 → 0.0.2

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,21 +30,21 @@ 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;
 }): Record<string, unknown>;
 export declare function nextBackupPath(dbPath: 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;
@@ -438,7 +438,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 +447,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,
@@ -749,23 +748,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 +908,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,
@@ -1368,15 +1362,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 +1390,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 +1421,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 +1598,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 {

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/package.json

@@ -1,10 +1,10 @@
 {
   "name": "codex-cleaner",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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",