@bobfrankston/rmfmail 1.2.147 → 1.2.148

package/packages/mailx-service/index.ts

@@ -990,14 +990,38 @@ export class MailxService implements MailxApi {
 `;
         try {
             const htmlToDocx = (await import("html-to-docx")).default;
-            const buf = await htmlToDocx(wrapped) as Buffer | ArrayBuffer;
-            const out = Buffer.isBuffer(buf) ? buf : Buffer.from(buf as ArrayBuffer);
+            let out: Buffer;
+            try {
+                const buf = await htmlToDocx(wrapped) as Buffer | ArrayBuffer;
+                out = Buffer.isBuffer(buf) ? buf : Buffer.from(buf as ArrayBuffer);
+            } catch (first: any) {
+                // Two known html-to-docx crashes on real mail bodies
+                // (Bob 2026-07-18, reply with a deep quoted chain):
+                //   - "Cannot read properties of undefined (reading
+                //     'createFont')" — font-family styles in some nestings
+                //     hit an undefined docxDocumentInstance inside the lib;
+                //   - "unsupported file type: undefined" — a remote http(s)
+                //     <img> the lib tries (and fails) to download.
+                // Retry once with font-family styles stripped and remote
+                // imgs swapped for their alt text — slightly lower fidelity
+                // beats losing the .docx round-trip (the .html fallback
+                // needs Save-As-Web-Page gymnastics in Word).
+                const sanitized = wrapped
+                    .replace(/font-family\s*:[^;"']*;?/gi, "")
+                    .replace(/<img\b[^>]*\bsrc\s*=\s*["']https?:[^>]*>/gi, (tag) => {
+                        const alt = /\balt\s*=\s*["']([^"']*)["']/i.exec(tag)?.[1] || "";
+                        return alt ? `[image: ${alt}]` : "[image]";
+                    });
+                console.warn(`  [word-edit] html-to-docx failed (${first?.message || first}) — retrying with fonts/remote-imgs sanitized`);
+                const buf = await htmlToDocx(sanitized) as Buffer | ArrayBuffer;
+                out = Buffer.isBuffer(buf) ? buf : Buffer.from(buf as ArrayBuffer);
+            }
             fs.writeFileSync(filePath, out);
         } catch (e: any) {
-            // html-to-docx couldn't produce a docx (rare; usually CJK font
-            // fallback issues). Fall back to plain .html so the user still
-            // gets *something* — they'll need Save-As-Web-Page in Word but
-            // that's better than no edit path at all.
+            // html-to-docx couldn't produce a docx even sanitized. Fall back
+            // to plain .html so the user still gets *something* — they'll
+            // need Save-As-Web-Page in Word but that's better than no edit
+            // path at all.
             console.warn(`  [word-edit] html-to-docx failed: ${e?.message || e} — falling back to .html`);
             const htmlPath = path.join(dir, `${fileBase}.html`);
             fs.writeFileSync(htmlPath, wrapped, "utf-8");
@@ -1082,20 +1106,33 @@ export class MailxService implements MailxApi {
         // save so the cold-start cost is paid only when the user actually
         // edits in Word — most sessions never hit it.
         let debounce: ReturnType<typeof setTimeout> | null = null;
-        let lastSize = -1;
+        let lastSig = "";
+        // Word saves the .docx in place on Ctrl+S, but Save-As-Web-Page
+        // writes a SIBLING .htm/.html (same base name) — catch those too so
+        // 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`]);
         const watcher = fs.watch(dir, (eventType, name) => {
-            if (name !== `${fileBase}.docx`) return;
+            if (!name || !watchNames.has(name)) return;
+            const savedPath = path.join(dir, name);
+            const isDocx = name.endsWith(".docx");
             if (debounce) clearTimeout(debounce);
             debounce = setTimeout(async () => {
                 let stat: fs.Stats;
-                try { stat = fs.statSync(filePath); } catch { return; }
-                if (stat.size === lastSize) return;
-                lastSize = stat.size;
+                try { stat = fs.statSync(savedPath); } catch { return; }
+                const sig = `${savedPath}:${stat.size}:${stat.mtimeMs}`;
+                if (sig === lastSig) return;
+                lastSig = sig;
                 try {
-                    const buf = fs.readFileSync(filePath);
-                    const mammoth = (await import("mammoth")).default;
-                    const result = await mammoth.convertToHtml({ buffer: buf });
-                    let inner = result.value || "";
+                    let inner: string;
+                    if (isDocx) {
+                        const buf = fs.readFileSync(savedPath);
+                        const mammoth = (await import("mammoth")).default;
+                        const result = await mammoth.convertToHtml({ buffer: buf });
+                        inner = result.value || "";
+                    } else {
+                        inner = fs.readFileSync(savedPath, "utf-8");
+                    }
                     // mammoth returns body-content HTML (no <html><body> wrapper).
                     // Defensive: if a wrapper sneaks in, strip it.
                     const bodyMatch = inner.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
@@ -1148,35 +1185,41 @@ export class MailxService implements MailxApi {
             if (tryLaunch("xdg-open", [filePath])) opener = "default";
         }
         let debounce: ReturnType<typeof setTimeout> | null = null;
-        let lastSize = -1;
+        let lastSig = "";
         const htmlName = path.basename(filePath);                  // <editId>.html
         const docxName = htmlName.replace(/\.html$/i, ".docx");    // what Word writes on Ctrl+S
+        const htmName = htmlName.replace(/\.html$/i, ".htm");      // what Word's Save-As-Web-Page writes
         const docxPath = path.join(dir, docxName);
+        const htmPath = path.join(dir, htmName);
         // CRITICAL: Word, given an .html, converts it to a SIBLING .docx on save
         // (Bob 2026-06-06: "Word turns it into a docx you don't see when I do
-        // ^s"). The old watcher only watched the .html, so those edits never came
-        // back. Watch BOTH; prefer the .docx (run it through mammoth) since
-        // that's the authoritative save, falling back to the .html.
+        // ^s") — and Save-As-Web-Page writes a SIBLING .htm (Bob 2026-07-18:
+        // "not seeing the updated .htm when I save it in Word"). The watcher
+        // must cover all three spellings; prefer the .docx (mammoth) as the
+        // authoritative save, then .htm, then the original .html.
         const watcher = fs.watch(dir, (_evt, name) => {
-            if (name !== htmlName && name !== docxName) return;
+            if (name !== htmlName && name !== docxName && name !== htmName) return;
             if (debounce) clearTimeout(debounce);
             debounce = setTimeout(async () => {
                 try {
                     let inner: string;
                     if (fs.existsSync(docxPath)) {
                         const st = fs.statSync(docxPath);
-                        if (st.size === lastSize) return;
-                        lastSize = st.size;
+                        const sig = `docx:${st.size}:${st.mtimeMs}`;
+                        if (sig === lastSig) return;
+                        lastSig = sig;
                         const mammoth = (await import("mammoth")).default;
                         const result = await mammoth.convertToHtml({ buffer: fs.readFileSync(docxPath) });
                         inner = result.value || "";
                         const bm = inner.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
                         if (bm) inner = bm[1];
                     } else {
-                        const st = fs.statSync(filePath);
-                        if (st.size === lastSize) return;
-                        lastSize = st.size;
-                        const updatedHtml = fs.readFileSync(filePath, "utf-8");
+                        const srcPath = fs.existsSync(htmPath) ? htmPath : filePath;
+                        const st = fs.statSync(srcPath);
+                        const sig = `${srcPath}:${st.size}:${st.mtimeMs}`;
+                        if (sig === lastSig) return;
+                        lastSig = sig;
+                        const updatedHtml = fs.readFileSync(srcPath, "utf-8");
                         const bm = updatedHtml.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
                         inner = bm ? bm[1] : updatedHtml;
                     }