@bobfrankston/rmfmail 1.2.9 → 1.2.10

package/packages/mailx-store/db.ts

@@ -442,6 +442,20 @@ export class MailxDB {
         }
         this.db.exec("PRAGMA journal_mode = WAL");
         this.db.exec("PRAGMA foreign_keys = ON");
+        // WAL hygiene. With THREE connections (main writer, sync-worker writer,
+        // read-worker reader) the WAL was never getting checkpointed — failed
+        // writes (two-writer contention) never commit, so the auto-checkpoint
+        // that normally fires on commit never ran, and the WAL ballooned to
+        // 71 MB (Bob 2026-06-14: every read/write crawled, `database is locked`
+        // everywhere, a bulk move took 51s and timed out). A bloated WAL is
+        // self-reinforcing: bigger WAL → slower writes → more lock failures →
+        // fewer commits → no checkpoint. Boot is the one moment main is the
+        // SOLE connection (read/sync workers spawn later), so TRUNCATE here
+        // resets the file to empty; `checkpoint()` on a timer keeps it small.
+        try {
+            const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get() as any;
+            console.log(`  [db] boot WAL checkpoint: busy=${r?.busy} log=${r?.log} checkpointed=${r?.checkpointed}`);
+        } catch (e: any) { console.error(`  [db] boot WAL checkpoint failed: ${e?.message || e}`); }
         // Multi-writer foundation for the sync-worker migration: once sync runs
         // on its own thread with its own write connection, it and the main
         // thread are two writers on one WAL file. WAL serializes writers, so a
@@ -2644,6 +2658,17 @@ export class MailxDB {
      *  already open this just runs `fn` (its writes join the open txn);
      *  otherwise it owns a fresh BEGIN/COMMIT. `fn` MUST be synchronous so it
      *  can't span an await and leave a transaction open across a yield. */
+    /** Run a WAL checkpoint to bound the WAL file size. PASSIVE never blocks
+     *  on readers — it reclaims frames older than the oldest live snapshot and
+     *  returns immediately otherwise. Drive it from ONE connection (main) on a
+     *  timer so the WAL can't balloon while three connections share the file.
+     *  Returns {busy, log, checkpointed} (log = frames in WAL, checkpointed =
+     *  frames moved into the db) or null on error. */
+    checkpoint(mode: "PASSIVE" | "FULL" | "RESTART" | "TRUNCATE" = "PASSIVE"): { busy: number; log: number; checkpointed: number } | null {
+        try { return this.db.prepare(`PRAGMA wal_checkpoint(${mode})`).get() as any; }
+        catch { return null; }
+    }
+
     runInTxn<T>(fn: () => T): T {
         if (this.db.isTransaction) return fn();
         this.db.exec("BEGIN");