@bobfrankston/mailx 1.0.360 → 1.0.361

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.360",
+  "version": "1.0.361",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-imap/index.js

@@ -689,6 +689,14 @@ export class ImapManager extends EventEmitter {
                 }
                 if (msg.uid <= highestUid)
                     continue; // already have it
+                // Tombstone check: if the user locally deleted this Message-ID,
+                // don't re-import it. Server-side EXPUNGE may lag, or reconcile
+                // may find the message in an old list snapshot. Without this,
+                // deleted messages reappear on the next sync pass.
+                if (msg.messageId && this.db.hasTombstone(accountId, msg.messageId)) {
+                    console.log(`  [tombstone] ${accountId}: skipping ${msg.messageId} (locally deleted)`);
+                    continue;
+                }
                 const source = msg.source || "";
                 let bodyPath = "";
                 let preview = "";
@@ -1581,6 +1589,17 @@ export class ImapManager extends EventEmitter {
             this.syncIntervals.set("prefetch", prefetchInterval);
             console.log(`  [periodic] body prefetch every 60s (independent of sync)`);
         }
+        // Tombstone prune: age out local-delete records older than 30 days.
+        // Runs hourly — cheap (one indexed DELETE).
+        const TOMBSTONE_RETENTION_DAYS = 30;
+        const pruneTombstones = () => {
+            const cutoff = Date.now() - TOMBSTONE_RETENTION_DAYS * 86400_000;
+            const n = this.db.pruneTombstones(cutoff);
+            if (n > 0)
+                console.log(`  [tombstones] pruned ${n} older than ${TOMBSTONE_RETENTION_DAYS} days`);
+        };
+        setTimeout(pruneTombstones, 30_000); // first run after startup settles
+        this.syncIntervals.set("tombstone-prune", setInterval(pruneTombstones, 3600_000));
         // Full sync (all folders + IDLE restart) at configured interval
         const fullInterval = setInterval(async () => {
             console.log(`  [periodic] Full sync at ${new Date().toLocaleTimeString()}`);

package/packages/mailx-service/index.js

@@ -646,6 +646,11 @@ export class MailxService {
         const envelope = this.db.getMessageByUid(accountId, uid);
         if (!envelope)
             throw new Error("Message not found");
+        // Tombstone the Message-ID so a subsequent sync pass can't resurrect
+        // the row if the server's EXPUNGE hasn't propagated yet. `undelete`
+        // removes the tombstone.
+        if (envelope.messageId)
+            this.db.addTombstone(accountId, envelope.messageId, envelope.subject || "");
         await this.imapManager.trashMessage(accountId, envelope.folderId, envelope.uid);
     }
     async deleteMessages(accountId, uids) {
@@ -653,6 +658,9 @@ export class MailxService {
             const env = this.db.getMessageByUid(accountId, uid);
             if (!env)
                 return null;
+            // Tombstone each — same reason as single-delete above.
+            if (env.messageId)
+                this.db.addTombstone(accountId, env.messageId, env.subject || "");
             return { uid: env.uid, folderId: env.folderId };
         }).filter(m => m !== null);
         await this.imapManager.trashMessages(accountId, messages);
@@ -711,6 +719,12 @@ export class MailxService {
         return { targetFolderId: target.id, moved: uids.length };
     }
     async undeleteMessage(accountId, uid, folderId) {
+        // Clear the tombstone first so a subsequent sync can re-import if
+        // the server still has the row. Messages with no Message-ID just
+        // didn't get a tombstone — this is a no-op for them.
+        const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+        if (envelope?.messageId)
+            this.db.removeTombstone(accountId, envelope.messageId);
         await this.imapManager.undeleteMessage(accountId, uid, folderId);
     }
     async deleteOnServer(accountId, folderPath, uid) {

package/packages/mailx-store/db.d.ts

@@ -12,6 +12,20 @@ export declare class MailxDB {
     hasSentMessage(messageId: string): boolean;
     /** Record a successfully sent message so future attempts are skipped. */
     recordSent(messageId: string, accountId: string, subject: string, recipients: string[]): void;
+    /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
+     *  is empty (e.g. provider stripped the header) — without a stable id we
+     *  can't check against future sync results anyway. */
+    addTombstone(accountId: string, messageId: string, subject?: string): void;
+    /** Is this Message-ID tombstoned for this account? */
+    hasTombstone(accountId: string, messageId: string): boolean;
+    /** Remove a tombstone — used by "undelete" (Ctrl-Z) so a subsequent sync
+     *  re-imports the message as normal. Also lets the user recover from a
+     *  mistaken local delete. */
+    removeTombstone(accountId: string, messageId: string): void;
+    /** Age-out tombstones older than the given cutoff. Keeps the table from
+     *  growing unboundedly. Default retention is 30 days; caller passes the
+     *  actual cutoff in ms since epoch. */
+    pruneTombstones(olderThanMs: number): number;
     /** Idempotently add a column to a table if it's missing. */
     private addColumnIfMissing;
     /** Compute a thread id for an incoming message. Strategy:

package/packages/mailx-store/db.js

@@ -126,6 +126,21 @@ const SCHEMA = `
         last_error TEXT,
         UNIQUE(account_id, action, uid, folder_id)
     );
+
+    -- Tombstones: messages the user deleted locally. Sync checks this table
+    -- before inserting a new row so a server-side delete that hasn't yet
+    -- propagated (or a stale server listing during the EXPUNGE race) can't
+    -- resurrect a message the user already removed. Keyed by Message-ID
+    -- because that's the only identifier stable across UID renumbers,
+    -- UIDVALIDITY bumps, and cross-folder moves.
+    CREATE TABLE IF NOT EXISTS tombstones (
+        account_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        deleted_at INTEGER NOT NULL,
+        subject TEXT DEFAULT '',
+        PRIMARY KEY (account_id, message_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_tombstones_deleted_at ON tombstones(deleted_at);
 `;
 export class MailxDB {
     db;
@@ -172,6 +187,53 @@ export class MailxDB {
             console.error(`  [sent_log] failed to record ${messageId}: ${e.message}`);
         }
     }
+    // ── Tombstones (local-delete record so server echo can't resurrect) ──
+    /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
+     *  is empty (e.g. provider stripped the header) — without a stable id we
+     *  can't check against future sync results anyway. */
+    addTombstone(accountId, messageId, subject = "") {
+        if (!messageId)
+            return;
+        try {
+            this.db.prepare("INSERT INTO tombstones (account_id, message_id, deleted_at, subject) VALUES (?, ?, ?, ?) ON CONFLICT(account_id, message_id) DO UPDATE SET deleted_at = excluded.deleted_at").run(accountId, messageId, Date.now(), subject || "");
+        }
+        catch (e) {
+            console.error(`  [tombstones] failed to record ${messageId}: ${e.message}`);
+        }
+    }
+    /** Is this Message-ID tombstoned for this account? */
+    hasTombstone(accountId, messageId) {
+        if (!messageId)
+            return false;
+        const row = this.db.prepare("SELECT 1 FROM tombstones WHERE account_id = ? AND message_id = ? LIMIT 1").get(accountId, messageId);
+        return !!row;
+    }
+    /** Remove a tombstone — used by "undelete" (Ctrl-Z) so a subsequent sync
+     *  re-imports the message as normal. Also lets the user recover from a
+     *  mistaken local delete. */
+    removeTombstone(accountId, messageId) {
+        if (!messageId)
+            return;
+        try {
+            this.db.prepare("DELETE FROM tombstones WHERE account_id = ? AND message_id = ?").run(accountId, messageId);
+        }
+        catch (e) {
+            console.error(`  [tombstones] failed to remove ${messageId}: ${e.message}`);
+        }
+    }
+    /** Age-out tombstones older than the given cutoff. Keeps the table from
+     *  growing unboundedly. Default retention is 30 days; caller passes the
+     *  actual cutoff in ms since epoch. */
+    pruneTombstones(olderThanMs) {
+        try {
+            const res = this.db.prepare("DELETE FROM tombstones WHERE deleted_at < ?").run(olderThanMs);
+            return Number(res.changes || 0);
+        }
+        catch (e) {
+            console.error(`  [tombstones] prune failed: ${e.message}`);
+            return 0;
+        }
+    }
     /** Idempotently add a column to a table if it's missing. */
     addColumnIfMissing(table, column, sqlType) {
         try {