@bobfrankston/rmfmail 1.2.197 → 1.2.199

package/packages/mailx-service/index.js

@@ -1231,6 +1231,53 @@ export class MailxService {
         else {
             console.log(`  [word-edit] opened ${filePath} via ${opener}`);
         }
+        // ── Word COM autosave sidecar (win32 + Word only) ──
+        // "Save on close should be one step" (Bob 2026-07-30) — better: make
+        // save CONTINUOUS so closing Word is the only step and the save
+        // prompt never appears. A hidden PowerShell loop attaches to the
+        // running Word via COM every ~2 s and calls doc.Save() whenever the
+        // document is dirty. Each save trips the fs.watch above → mammoth →
+        // compose mirrors the edit live. When the document (or Word) closes,
+        // the sidecar exits on its own; stop() kills it if compose closes
+        // first. PowerShell is used as the COM bridge deliberately: Node has
+        // no COM without a native build dep, and allowScripts skips install
+        // scripts so a compiled addon would arrive broken from the registry.
+        let autosaveChild = null;
+        if (process.platform === "win32" && opener === "word") {
+            try {
+                const psPath = path.join(dir, `${fileBase}-autosave.ps1`);
+                fs.writeFileSync(psPath, [
+                    "param([string]$DocPath)",
+                    "$deadline = (Get-Date).AddHours(6)",
+                    "$attached = $false",
+                    "while ((Get-Date) -lt $deadline) {",
+                    "    Start-Sleep -Seconds 2",
+                    "    $word = $null",
+                    "    try { $word = [Runtime.InteropServices.Marshal]::GetActiveObject('Word.Application') }",
+                    "    catch { if ($attached) { exit 0 } else { continue } }",
+                    "    $doc = $null",
+                    "    try { foreach ($d in $word.Documents) { if ($d.FullName -ieq $DocPath) { $doc = $d; break } } } catch { continue }",
+                    "    if ($null -eq $doc) { if ($attached) { exit 0 } else { continue } }",
+                    "    $attached = $true",
+                    "    try { if (-not $doc.Saved) { $doc.Save() } } catch { }",
+                    "}",
+                    "exit 1",
+                ].join("\r\n"), "utf-8");
+                autosaveChild = spawn("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", psPath, filePath], { detached: false, stdio: "ignore", windowsHide: true });
+                autosaveChild.on("error", () => { autosaveChild = null; });
+                autosaveChild.on("exit", (code) => {
+                    console.log(`  [word-edit] autosave sidecar exited (${code === 0 ? "document closed" : `code ${code}`})`);
+                    try {
+                        fs.unlinkSync(psPath);
+                    }
+                    catch { /* */ }
+                });
+                console.log(`  [word-edit] autosave sidecar armed — closing Word is the only step`);
+            }
+            catch (e) {
+                console.warn(`  [word-edit] autosave sidecar failed to start (${e?.message || e}) — Ctrl+S still works`);
+            }
+        }
         // Watch for save events. fs.watch on Windows fires multiple events
         // per save (rename + change for atomic replacement); debounce so the
         // UI only reloads once per save. Watch the directory rather than the
@@ -1305,6 +1352,10 @@ export class MailxService {
             catch { /* */ }
             if (debounce)
                 clearTimeout(debounce);
+            try {
+                autosaveChild?.kill();
+            }
+            catch { /* */ }
         };
         this.wordEdits.set(editId, { path: filePath, stop });
         return { ok: opener !== "none", path: filePath, opener };
@@ -1767,20 +1818,118 @@ export class MailxService {
             // counter. Without this, typing fast left N stale 90-folder IMAP
             // sweeps all churning to completion in the background.
             const myGen = ++this.serverSearchGen;
-            // Parse qualifiers once; SEARCH runs per folder.
-            const criteria = {};
-            const fromMatch = q.match(/from:(\S+)/i);
-            const toMatch = q.match(/to:(\S+)/i);
-            const subjectMatch = q.match(/subject:(.+?)(?:\s+\w+:|$)/i);
-            const bodyText = q.replace(/(?:from|to|subject):\S+/gi, "").trim();
-            if (fromMatch)
-                criteria.from = fromMatch[1];
-            if (toMatch)
-                criteria.to = toMatch[1];
-            if (subjectMatch)
-                criteria.subject = subjectMatch[1].trim();
-            if (bodyText)
-                criteria.body = bodyText;
+            // Parse qualifiers once; SEARCH runs per folder. Same query
+            // syntax as local search (Bob 2026-07-30 "IMAP search should be
+            // the same as desktop"): quoted phrases, from:/to:/cc:/subject:,
+            // is:unread etc., after:/before:/date:, uppercase NOT (works
+            // anywhere, including first) and OR — all mapped onto IMAP's
+            // native SEARCH keys (NOT/OR/UNSEEN/SINCE/… are core RFC 3501).
+            // has:attachment has no IMAP key and is ignored server-side.
+            const criteria = { not: [], or: [] };
+            const bodyTerms = [];
+            const unq = (s) => s.replace(/^"|"$/g, "");
+            const parseRelDate = (s) => {
+                const lower = s.toLowerCase().trim();
+                if (lower === "today") {
+                    const d = new Date();
+                    d.setHours(0, 0, 0, 0);
+                    return d;
+                }
+                if (lower === "yesterday") {
+                    const d = new Date();
+                    d.setHours(0, 0, 0, 0);
+                    return new Date(d.getTime() - 86400_000);
+                }
+                const rel = lower.match(/^(\d+)([dwmy])$/);
+                if (rel) {
+                    const n = parseInt(rel[1]);
+                    const ms = rel[2] === "d" ? n * 86400_000 : rel[2] === "w" ? n * 7 * 86400_000
+                        : rel[2] === "m" ? n * 30 * 86400_000 : n * 365 * 86400_000;
+                    return new Date(Date.now() - ms);
+                }
+                const ts = Date.parse(s);
+                return isNaN(ts) ? null : new Date(ts);
+            };
+            // One token → one criteria fragment (or null for date/unmappable,
+            // which merge into the top level / get dropped).
+            const tokenToFrag = (tok) => {
+                const m = tok.match(/^(from|to|cc|subject):(.+)$/i);
+                if (m)
+                    return { [m[1].toLowerCase()]: unq(m[2]) };
+                const is = tok.match(/^is:(.+)$/i);
+                if (is) {
+                    const v = is[1].toLowerCase();
+                    if (v === "unread")
+                        return { unseen: true };
+                    if (v === "read" || v === "seen")
+                        return { seen: true };
+                    if (v === "flagged" || v === "starred")
+                        return { flagged: true };
+                    if (v === "answered")
+                        return { answered: true };
+                    if (v === "draft")
+                        return { draft: true };
+                    return null;
+                }
+                if (/^(has|folder|date|after|before):/i.test(tok))
+                    return null;
+                const t = unq(tok);
+                return t ? { body: t } : null;
+            };
+            const tokens = q.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+            let negate = false;
+            for (let ti = 0; ti < tokens.length; ti++) {
+                const tok = tokens[ti];
+                if (tok === "NOT") {
+                    negate = true;
+                    continue;
+                }
+                if (tok === "AND" || tok === "OR") {
+                    negate = false;
+                    continue;
+                }
+                // Dates apply at the top level (negated dates are rare and
+                // ambiguous — treated as positive).
+                const dm = tok.match(/^date:([><]?=?)(.+)$/i) || tok.match(/^(after|before):(.+)$/i);
+                if (dm) {
+                    const isAfter = /^after:/i.test(tok) || dm[1] === ">" || dm[1] === ">=";
+                    const isBefore = /^before:/i.test(tok) || dm[1] === "<" || dm[1] === "<=";
+                    const d = parseRelDate(unq(dm[2]));
+                    if (d) {
+                        if (isAfter)
+                            criteria.since = d;
+                        else if (isBefore)
+                            criteria.before = d;
+                        else {
+                            criteria.since = d;
+                            criteria.before = new Date(d.getTime() + 86400_000);
+                        }
+                    }
+                    negate = false;
+                    continue;
+                }
+                const frag = tokenToFrag(tok);
+                if (!frag) {
+                    negate = false;
+                    continue;
+                }
+                const orAdjacent = tokens[ti - 1] === "OR" || tokens[ti + 1] === "OR";
+                if (negate)
+                    criteria.not.push(frag);
+                else if (orAdjacent)
+                    criteria.or.push(frag);
+                else if (frag.body)
+                    bodyTerms.push(frag.body);
+                else
+                    Object.assign(criteria, frag);
+                negate = false;
+            }
+            if (bodyTerms.length)
+                criteria.body = bodyTerms.length === 1 ? bodyTerms[0] : bodyTerms;
+            if (criteria.not.length === 0)
+                delete criteria.not;
+            if (criteria.or.length === 0)
+                delete criteria.or;
             // Server search spans every selectable folder on every enabled
             // account — otherwise a message that got moved / was in Sent /
             // only exists in an archive folder silently fails to turn up.