@bobfrankston/rmfmail 1.2.173 → 1.2.177

package/TODO.md

@@ -219,7 +219,7 @@ Items blocked on a design decision. Short-form question here; full context in th
 | **C41** | PARTIAL | Reply quoting — already wraps in `<blockquote>`; read-only + non-editable-above-the-line still owed (needs Quill module work). |
 | **C43** | OPEN | Message list column controls + threading flags. ✓ (sort-by-column-click is small) |
 | **C44** | DONE (v1.2.105) | Real OS popup windows / pop-out — floating-overlay popout landed (Q64 v1.0.344); v1.2.105 unblocked the real OS window: 🗗 asks the daemon, which spawns a native msger window (`showMessageBoxEx({url})`) pointed at the loopback popout server. Toolbar actions POST back → `popoutAction` event → main window opens editable compose / flags / deletes (delete also closes the window). Browser-window option deferred (same URL, just `openExternal` it). |
-| [**C46**](#ext46) | PARTIAL | Mailto handler split out as [P115](#ext115) (registry-only, not blocked). Remaining (Share target, tray, notifications, MSIX) still blocked on MSIX packaging. |
+| [**C46**](#ext46) | PARTIAL | Mailto handler split out as [P115](#ext115) (registry-only, not blocked). Share target SHIPPED v1.2.175 (`-register-share`, loose AppX — no MSIX needed). Remaining (tray, notifications) still blocked on MSIX packaging. |
 | **C127** | OPTIONAL | **Push relay for calendar / mail / tasks** — design at [`docs/push-relay.md`](push-relay.md). New `MailApps/relayer/` package, alerter-shape (single Node Express+ws process, deploy alongside other small services). Generic API: client POSTs `/subscribe` with upstream + params, relay registers the upstream `events.watch` and returns an SSE/WS endpoint the client holds open. Per-upstream adapter files (`google-calendar.ts`, `google-gmail.ts`, `ms-graph-events.ts`); fan-out + replay buffer + subscription store generic. Client side: `pushRelayUrl` + credentials in settings, falls back to syncToken polling when relay unreachable. **Build only when polling latency demonstrably matters** — for typical use, 5–10 s syncToken cadence is functionally instant. Push is a freshness boost, not a correctness fix. |
 | **C128** | OPEN | **Body pre-parse on prefetch** — first click on any unviewed message pays `simpleParser` + `sanitizeHtml` cost (~100–500 ms on rich HTML). The parsedCache (added 2026-05-09) eliminates 2nd-and-later view costs but not the first. Fix: extend prefetch to ALSO parse + sanitize the body during background fetch and store the result alongside the .eml (e.g., `<uuid>.parsed.json` next to `<uuid>.eml`, or a `body_html_cached` column). Click-time path reads pre-parsed JSON, no parser invocation. Touches `mailx-imap/index.ts` prefetch path + `mailx-store/file-store.ts` for the parsed-blob storage. |
 | **C129** | OPEN | **Android prod/dev split via filename/URL channel** — User 2026-05-09 (revised): no separate MAUI project. Same source tree builds; output filenames distinguish channels: Phase 1 (start now) writes `rmfmaildev.apk` alongside today's `mailx-maui.apk`. Phase 2 (when a release is declared) switches to `rmfmail-<version>.apk` versioned + `rmfmaildev.apk` for latest, with promotion = re-pointing `rmfmail.apk` at a chosen version. Single APK contents per build; channel is runtime setting in AppUpdater (Settings toggle for which URL to poll). Side-by-side install on one device NOT supported by this design (single Android package id) — that's a separate need. See `docs/prod-android.md` for full plan. Phase 1 ~30 min; full flow ~2.5 hours when activated. |
@@ -488,8 +488,8 @@ Most likely cause based on the bobma folder layout: Dovecot designates "Deleted
 ### C46 — Windows OS integration (PARTIAL)  [↑ summary](#sum)
 
 - [ ] **mailto: handler** → see [P115](#ext115) — split out as standalone priority item, NOT blocked on MSIX (registry-only).
-- [ ] **Windows Share target** — register as Share target (requires MSIX packaging)
-- [ ] Native right-click context menus, system tray, file associations, notifications
+- [x] **Windows Share target** (v1.2.175) — no MSIX signing needed after all: loose AppX deployment (`Add-AppxPackage -Register`, unsigned, needs Developer Mode). `rmfmail -register-share` stages `%LOCALAPPDATA%\rmfmail\share-target\` (rmfshare.exe + AppxManifest with `windows.shareTarget` + logos scaled from icon.png). `bin/rmfshare-src/` is a C# NativeAOT helper (3.8 MB, checked-in like rmfmailto.exe): ShareTarget activation → WinRT DataPackageView → files copied to `~/.rmfmail/share-staging/` → `pending-share.json` → daemon fs.watch base64s files and pushes `openShare` → compose opens with attachments/link/text. Startup-race twin `consumePendingShare` IPC, same shape as P115 mailto. Machines without Developer Mode get a clear message; Settings-UI toggle still owed (lands with P116 Settings rework).
+- [ ] Native right-click context menus, system tray, file associations, notifications (tray + notifications still MSIX-blocked)
 
 <a id="ext115"></a>
 

package/bin/build-rmfshare-exe.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Build the rmfshare.exe Windows Share-target activation helper (C46).
+ *
+ * Mirrors build-rmfmailto-exe.js: hooked into `npm run build`, skips when
+ *   - not on Windows,
+ *   - the .NET SDK isn't installed (uses the checked-in bin/rmfshare.exe),
+ *   - the shipped exe is newer than every file in bin/rmfshare-src/.
+ *
+ * On a real rebuild runs `dotnet publish -c Release -r win-x64` (NativeAOT —
+ * needs the VS C++ toolchain; vswhere's dir is appended to PATH because the
+ * ILCompiler targets shell out to it) and copies the published exe to
+ * bin/rmfshare.exe. The exe is checked into git so `npm install -g` ships
+ * it without requiring .NET on install machines.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { execSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SRC_DIR = path.join(__dirname, "rmfshare-src");
+const BUILT_EXE = path.join(SRC_DIR, "bin", "Release", "net10.0-windows10.0.19041.0", "win-x64", "publish", "rmfshare.exe");
+const SHIPPED_EXE = path.join(__dirname, "rmfshare.exe");
+
+if (process.platform !== "win32") {
+    console.log("[rmfshare] non-Windows host — skipping (binary is Win-only)");
+    process.exit(0);
+}
+
+try {
+    execSync("dotnet --version", { stdio: "pipe" });
+} catch {
+    console.log("[rmfshare] dotnet not found — skipping build (using checked-in bin/rmfshare.exe).");
+    process.exit(0);
+}
+
+// mtime gate — same shape as build-rmfmailto-exe.js.
+function newestMtime(dir) {
+    let newest = 0;
+    const stack = [dir];
+    while (stack.length) {
+        const d = stack.pop();
+        for (const name of fs.readdirSync(d)) {
+            if (name === "bin" || name === "obj") continue; // dotnet output dirs
+            const full = path.join(d, name);
+            const st = fs.statSync(full);
+            if (st.isDirectory()) stack.push(full);
+            else if (st.mtimeMs > newest) newest = st.mtimeMs;
+        }
+    }
+    return newest;
+}
+
+const srcMtime = newestMtime(SRC_DIR);
+let shippedMtime = 0;
+try { shippedMtime = fs.statSync(SHIPPED_EXE).mtimeMs; } catch { /* missing */ }
+if (shippedMtime > srcMtime) {
+    console.log("[rmfshare] up-to-date — skipping dotnet publish");
+    process.exit(0);
+}
+
+console.log("[rmfshare] building (dotnet publish NativeAOT)...");
+const t0 = Date.now();
+const vswhereDir = "C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer";
+const r = spawnSync("dotnet", ["publish", "-c", "Release", "-r", "win-x64"], {
+    cwd: SRC_DIR,
+    stdio: "inherit",
+    shell: true,
+    env: { ...process.env, PATH: `${process.env.PATH};${vswhereDir}` },
+});
+if (r.status !== 0) {
+    console.error(`[rmfshare] dotnet publish failed (exit ${r.status})`);
+    process.exit(r.status || 1);
+}
+fs.copyFileSync(BUILT_EXE, SHIPPED_EXE);
+const sec = ((Date.now() - t0) / 1000).toFixed(1);
+console.log(`[rmfshare] built and copied to bin/rmfshare.exe (${sec}s)`);

package/bin/mailx.js

@@ -389,6 +389,20 @@ if (hasFlag("register-mailto") || hasFlag("unregister-mailto")) {
     console.log(r.message);
     process.exit(r.ok ? 0 : 1);
 }
+// C46: Windows Share-target registration. Loose AppX deployment of
+// bin/rmfshare.exe (see bin/share-target.ts for the full flow). Android
+// gets the same feature from the MAUI manifest; macOS/Linux have no
+// equivalent OS share sheet to register into.
+if (hasFlag("register-share") || hasFlag("unregister-share")) {
+    if (process.platform !== "win32") {
+        console.error("-register-share / -unregister-share: Windows only (the Share sheet is a Windows shell feature).");
+        process.exit(1);
+    }
+    const { registerShareWindows } = await import("./share-target.js");
+    const r = registerShareWindows(hasFlag("unregister-share"));
+    console.log(r.message);
+    process.exit(r.ok ? 0 : 1);
+}
 // Read our own version once — used for the instance file + upgrade check below.
 const __selfRoot = path.join(import.meta.dirname, "..");
 const __selfVersion = (() => {
@@ -558,7 +572,7 @@ const repairMode = hasFlag("repair");
 const recoverMode = hasFlag("recover");
 const importMode = hasFlag("import");
 // Validate arguments
-const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "recover", "fix-flags", "relink-bodies", "log", "import", "email", "mail", "daemon", "reauth", "mailto", "register-mailto", "unregister-mailto", "allow-elevated", "another", "no-browser", "debug-server", "send", "account"];
+const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "recover", "fix-flags", "relink-bodies", "log", "import", "email", "mail", "daemon", "reauth", "mailto", "register-mailto", "unregister-mailto", "register-share", "unregister-share", "allow-elevated", "another", "no-browser", "debug-server", "send", "account"];
 for (const arg of args) {
     // Strip a leading -/-- and any `=value` suffix before checking.
     const flag = arg.replace(/^--?/, "").split("=")[0];
@@ -597,6 +611,10 @@ for (const arg of args) {
             "    -register-mailto       Register as the OS-level mailto: handler\n" +
             "    -unregister-mailto     Remove the mailto: handler registration\n" +
             "    -mailto <url>          (internal) Decode a mailto URL and open compose\n" +
+            "  Share target (Windows):\n" +
+            "    -register-share        Add rmfmail to the Windows Share menu\n" +
+            "                           (needs Developer Mode for the unsigned manifest)\n" +
+            "    -unregister-share      Remove rmfmail from the Windows Share menu\n" +
             "  Internal:\n" +
             "    -daemon                (internal) marker for the detached daemon respawn\n" +
             "    -allow-elevated        Bypass the admin/root refusal (debug only)");
@@ -2764,6 +2782,39 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
             console.error(`  [mailto] watch setup failed: ${e.message}`);
         }
     }
+    // Pending Windows-share handler (C46). Same two-path pickup as mailto
+    // above: the client's startup consumePendingShare poll covers the
+    // "rmfshare.exe spawned us" race; this fs.watch covers shares that land
+    // while we're already running. The daemon (not the client) base64s the
+    // staged files — the WebView can't read disk.
+    {
+        const { consumePendingShare, loadShareAttachments, cleanupShareStaging, getPendingShareFile } = await import("./share-target.js");
+        try {
+            cleanupShareStaging();
+            const pendingPath = getPendingShareFile();
+            const dir = path.dirname(pendingPath);
+            const baseName = path.basename(pendingPath);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.watch(dir, (_event, filename) => {
+                if (filename !== baseName)
+                    return;
+                if (!fs.existsSync(pendingPath))
+                    return;
+                setTimeout(() => {
+                    const data = consumePendingShare();
+                    if (!data)
+                        return;
+                    const { attachments, skipped } = loadShareAttachments(data.files);
+                    handle.send({ _event: "openShare", type: "openShare",
+                        title: data.title, text: data.text, url: data.url,
+                        attachments, skipped });
+                }, 50);
+            });
+        }
+        catch (e) {
+            console.error(`  [share] watch setup failed: ${e.message}`);
+        }
+    }
     // No artificial pause here. msger's stdin is queued — writes from
     // imapManager events arriving before the WebView is ready get buffered
     // and delivered when the WebView attaches. The earlier 500 ms wait