@bobfrankston/rmfmail 1.2.246 → 1.2.248

package/packages/mailx-service/index.ts

@@ -1208,9 +1208,64 @@ export class MailxService implements MailxApi {
         }
     }
 
+    /** Age out the external-edit scratch directory.
+     *
+     *  Every Edit-in-Word writes a fresh timestamped .docx (the filename is
+     *  unique per open so a still-locked previous file cannot cause EBUSY),
+     *  plus Word's ~$ lock files and the autosave sidecar's .ps1. Nothing
+     *  ever deleted them, so the directory accumulated every document the
+     *  user had ever edited — copies of real letters, sitting in the clear
+     *  indefinitely (Bob 2026-08-10: "clean up external edits more than a
+     *  week old"). A week is comfortably longer than any live editing session
+     *  and short enough that the folder stops being an archive.
+     *
+     *  Files belonging to a LIVE session are skipped regardless of age — a
+     *  document open in Word for eight days is still in use. */
+    private sweepExternalEdits(dir: string, maxAgeMs = 7 * 24 * 60 * 60 * 1000): void {
+        // Protect every file a live session owns: the document itself, Word's
+        // "~$" owner-lock (which drops the first TWO characters of the name,
+        // so a substring test never matches it), and the sidecar script.
+        const live = new Set<string>();
+        for (const e of this.wordEdits.values()) {
+            const base = path.basename(e.path).replace(/\.(docx|html?)$/i, "");
+            live.add(`${base}.docx`);
+            live.add(`${base}.html`);
+            live.add(`${base}.htm`);
+            live.add(`~$${base.slice(2)}.docx`);
+            live.add(`${base}-autosave.ps1`);
+        }
+        let removed = 0, bytes = 0;
+        const cutoff = Date.now() - maxAgeMs;
+        let names: string[] = [];
+        try { names = fs.readdirSync(dir); } catch { return; }
+        for (const name of names) {
+            if (live.has(name)) continue;
+            const full = path.join(dir, name);
+            try {
+                const st = fs.statSync(full);
+                if (st.mtimeMs > cutoff) continue;
+                bytes += st.size;
+                fs.rmSync(full, { recursive: true, force: true });
+                removed++;
+            } catch (e: any) {
+                // In use, or permissions — leave it and say so. Silently
+                // skipping is how a directory quietly keeps growing.
+                console.log(`  [word-edit] could not remove stale ${name}: ${e?.message || e}`);
+            }
+        }
+        if (removed > 0) {
+            console.log(`  [word-edit] swept ${removed} external-edit file(s) older than 7 days (${(bytes / 1024).toFixed(0)} KB)`);
+        }
+    }
+
     private async openInWordUncached(editId: string, html: string, popoutId = ""): Promise<{ ok: boolean; path: string; opener: string }> {
         const dir = path.join(getConfigDir(), "external-edit");
         fs.mkdirSync(dir, { recursive: true });
+        // Housekeeping on the way in: cheap (one readdir), and it runs exactly
+        // when the directory is about to be used, so there is no timer to own.
+        try { this.sweepExternalEdits(dir); } catch (e: any) {
+            console.log(`  [word-edit] sweep failed: ${e?.message || e}`);
+        }
         // Pre-convert to .docx (Word's native format) so Save in Word writes
         // back to the same file naturally — no Save-As-Web-Page gymnastics.
         // The .html-as-input flow had a 50% rate of "user saved but rmfmail
@@ -1400,10 +1455,7 @@ export class MailxService implements MailxApi {
                         // is no longer there.
                         const entry = this.wordEdits.get(editId);
                         if (entry) entry.closed = true;
-                        // popoutId names the window to raise; empty means the
-                        // compose lives in the main window, which the daemon
-                        // raises through its own service channel.
-                        this.imapManager.emit("wordEditClosed", { editId, fromPopout: !!popoutId, popoutId });
+                        announceClosed("autosave sidecar");
                     }
                 });
                 console.log(`  [word-edit] autosave sidecar armed — closing Word is the only step`);
@@ -1429,7 +1481,34 @@ export class MailxService implements MailxApi {
         // a web-page save doesn't vanish into an unwatched file (Bob
         // 2026-07-18, .html-fallback variant of the same report).
         const watchNames = new Set([`${fileBase}.docx`, `${fileBase}.htm`, `${fileBase}.html`]);
+        // Word's owner-lock file: "~$" + the filename with its first TWO
+        // characters dropped. Word creates it while the document is open and
+        // DELETES it on close — a filesystem fact the watcher already sees.
+        //
+        // This is now the primary "document closed" signal. The COM autosave
+        // sidecar was the only one and it is fragile: it attaches through
+        // GetActiveObject and matches an exact FullName, so when Word hands
+        // the document to an already-running instance (or normalises the
+        // path) it never attaches, never exits, and never reports the close.
+        // Observed doing exactly that on 2026-08-10 — Word had zero documents
+        // open while the sidecar was still looping, so nothing raised the
+        // compose window ("so there is still the z-plane problem"). Whichever
+        // signal arrives first wins; announceClosed collapses the duplicate.
+        const lockName = "~$" + fileBase.slice(2) + ".docx";
+        let closeAnnounced = false;
+        const announceClosed = (how: string): void => {
+            if (closeAnnounced) return;
+            closeAnnounced = true;
+            console.log(`  [word-edit] document closed (${how}) — raising the compose window`);
+            this.imapManager.emit("wordEditClosed", { editId, fromPopout: !!popoutId, popoutId });
+        };
         const watcher = fs.watch(dir, (eventType, name) => {
+            if (name === lockName) {
+                // Removal = Word let go of the document. Creation fires here
+                // too, so only ABSENCE counts as closed.
+                if (!fs.existsSync(path.join(dir, lockName))) announceClosed("lock file removed");
+                return;
+            }
             if (!name || !watchNames.has(name)) return;
             const savedPath = path.join(dir, name);
             const isDocx = name.endsWith(".docx");

package/packages/mailx-service/test/external-edit-sweep.test.mjs

@@ -0,0 +1,48 @@
+/** Exercise the real sweepExternalEdits over a scratch directory: old files go,
+ *  recent ones stay, and anything belonging to a LIVE edit is untouchable. */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import assert from "node:assert";
+
+const { MailxService } = await import("file:///Y:/dev/email/mailx/app/packages/mailx-service/index.js");
+
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), "extedit-"));
+const DAY = 24 * 60 * 60 * 1000;
+const mk = (name, ageDays) => {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, "x".repeat(100));
+    const t = new Date(Date.now() - ageDays * DAY);
+    fs.utimesSync(p, t, t);
+    return p;
+};
+
+const oldDoc = mk("compose-old-1.docx", 30);
+const oldLock = mk("~$mpose-old-1.docx", 30);
+const oldPs1 = mk("compose-old-1-autosave.ps1", 30);
+const freshDoc = mk("compose-fresh-2.docx", 1);
+const liveDoc = mk("compose-live-3.docx", 30);          // ancient BUT open in Word
+const liveLock = mk("~$mpose-live-3.docx", 30);
+const edgeDoc = mk("compose-edge-4.docx", 6.9);         // just inside a week
+
+const svc = Object.create(MailxService.prototype);
+svc.wordEdits = new Map([["live", { path: liveDoc, stop: () => {}, opener: "word", html: "" }]]);
+
+MailxService.prototype.sweepExternalEdits.call(svc, dir);
+
+const left = fs.readdirSync(dir).sort();
+assert.ok(!left.includes(path.basename(oldDoc)), "a 30-day-old document should be swept");
+assert.ok(!left.includes(path.basename(oldLock)), "its stale lock file should go too");
+assert.ok(!left.includes(path.basename(oldPs1)), "its stale sidecar script should go too");
+assert.ok(left.includes(path.basename(freshDoc)), "yesterday's document must stay");
+assert.ok(left.includes(path.basename(edgeDoc)), "6.9 days old is inside the window and must stay");
+assert.ok(left.includes(path.basename(liveDoc)), "a document open in Word must survive regardless of age");
+assert.ok(left.includes(path.basename(liveLock)), "the live document's lock file must survive too");
+
+// idempotent: running again removes nothing further
+const before = fs.readdirSync(dir).length;
+MailxService.prototype.sweepExternalEdits.call(svc, dir);
+assert.strictEqual(fs.readdirSync(dir).length, before, "a second sweep must be a no-op");
+
+fs.rmSync(dir, { recursive: true, force: true });
+console.log(`external-edit sweep: 8 checks passed (kept ${left.join(", ")})`);