@bobfrankston/rmfmail 1.1.230 → 1.1.231

package/packages/mailx-service/index.js

@@ -5,6 +5,7 @@
  */
 import * as dns from "node:dns/promises";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { parseSerial } from "@bobfrankston/mailx-store";
 const __dirname = import.meta.dirname;
@@ -54,6 +55,74 @@ async function detectEmailProvider(domain) {
     return null;
 }
 // sanitizeHtml and encodeQuotedPrintable imported from @bobfrankston/mailx-types (shared with Android)
+/** Scratch dir where the *Open* path stages an attachment before handing it to
+ *  the OS default app. It lives under the OS temp dir — not `~/.rmfmail/` —
+ *  because these are throwaway copies, not app state: the OS sweeps temp as a
+ *  backstop and they don't masquerade as durable data. `start`/`open` only need
+ *  the file to exist long enough for the launched app to read it. */
+function getAttachmentStagingDir() {
+    return path.join(os.tmpdir(), "rmfmail", "attachments");
+}
+const ATTACHMENT_STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/** Purge stale staged attachments (and retire the legacy
+ *  `~/.rmfmail/attachments/` location, which never had cleanup and accumulated
+ *  months of opened files). Best-effort: any error is swallowed — staging is
+ *  not load-bearing. Called at startup and is cheap (one readdir). */
+function cleanupAttachmentStaging(legacyDir) {
+    const sweep = (dir, maxAgeMs) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        const now = Date.now();
+        for (const name of entries) {
+            const p = path.join(dir, name);
+            try {
+                const st = fs.statSync(p);
+                if (st.isFile() && (maxAgeMs === 0 || now - st.mtimeMs > maxAgeMs)) {
+                    fs.unlinkSync(p);
+                }
+            }
+            catch { /* ignore — file may have vanished or be locked */ }
+        }
+    };
+    sweep(getAttachmentStagingDir(), ATTACHMENT_STAGING_MAX_AGE_MS);
+    // Legacy location: these are all orphaned Open-staging copies, so clear
+    // them regardless of age (maxAge 0), then drop the now-empty dir.
+    sweep(legacyDir, 0);
+    try {
+        fs.rmdirSync(legacyDir);
+    }
+    catch { /* not empty / not present — fine */ }
+}
+/** Map a MIME type to a file extension so a saved attachment whose name lost
+ *  its extension still dispatches to an OS handler. Covers the common types;
+ *  unknown types return "" (the file opens without an extension as before). */
+function extForMime(mime) {
+    const m = (mime || "").toLowerCase().split(";")[0].trim();
+    const map = {
+        "text/calendar": ".ics",
+        "application/ics": ".ics",
+        "application/pdf": ".pdf",
+        "text/plain": ".txt",
+        "text/html": ".html",
+        "image/png": ".png",
+        "image/jpeg": ".jpg",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/svg+xml": ".svg",
+        "application/zip": ".zip",
+        "application/json": ".json",
+        "application/msword": ".doc",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+        "application/vnd.ms-excel": ".xls",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    };
+    return map[m] || "";
+}
 /** Compare a local task row to an incoming Google task projection. Used by
  *  refreshTasks to skip no-op upserts that would otherwise emit `tasksUpdated`
  *  on every poll, feeding back into the UI's getTasks-on-event listener and
@@ -147,6 +216,11 @@ export class MailxService {
         this.store.db.setOnContactsChanged(() => this.markContactsDirty());
         // Initial load of contacts.jsonc — fire-and-forget; missing file is fine.
         this.loadContactsConfig().catch(() => { });
+        // Sweep stale Open-staging copies and retire the legacy in-config dir.
+        try {
+            cleanupAttachmentStaging(path.join(getConfigDir(), "attachments"));
+        }
+        catch { /* best-effort */ }
     }
     /** Transitional getter — direct DB access from MailxService for the
      *  ~50 callsites that haven't yet migrated to Store methods. Future:
@@ -2624,13 +2698,26 @@ export class MailxService {
      *  a programmatic `<a download>` click is silently dropped inside msger's
      *  WebView2, so the open must happen in the Node process (same pattern as
      *  openInWord / openLocalPath). Cross-platform: start / open / xdg-open. */
-    async openAttachment(accountId, uid, attachmentId, folderId) {
+    async openAttachment(accountId, uid, attachmentId, folderId, filename) {
         const att = await this.getAttachment(accountId, uid, attachmentId, folderId);
-        const dir = path.join(getConfigDir(), "attachments");
+        const dir = getAttachmentStagingDir();
         fs.mkdirSync(dir, { recursive: true });
-        // basename() strips any path components so a crafted filename can't
-        // escape the temp dir; also drop newlines.
-        const safeName = (path.basename(att.filename || "attachment").replace(/[\r\n]/g, "_")) || "attachment";
+        // Prefer the filename the UI is showing — it comes from the sync-time
+        // parse stored in the DB. The re-parse inside getAttachment() can lose
+        // a part's name param (notably Google calendar invites: the part
+        // re-parses with an empty filename), and a NAMELESS temp file gets no
+        // extension, so `start` on Windows has no handler to dispatch to and
+        // silently no-ops — the invite.ics that "did nothing" (2026-06-08).
+        // basename() strips any path components so a crafted name can't escape
+        // the temp dir; also drop newlines.
+        let safeName = (path.basename(filename || att.filename || "attachment").replace(/[\r\n]/g, "_")) || "attachment";
+        // Guarantee an extension so the OS has something to associate. Derive
+        // it from the MIME type when the name lacks one.
+        if (!path.extname(safeName)) {
+            const ext = extForMime(att.contentType);
+            if (ext)
+                safeName += ext;
+        }
         const target = path.join(dir, safeName);
         fs.writeFileSync(target, att.content);
         const { spawn } = await import("node:child_process");