@bobfrankston/rmfmail 1.2.173 → 1.2.177

package/bin/mailx.ts

@@ -368,6 +368,21 @@ if (hasFlag("register-mailto") || hasFlag("unregister-mailto")) {
     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: string = (() => {
@@ -523,7 +538,7 @@ 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];
@@ -563,6 +578,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)"
@@ -2673,6 +2692,37 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
         }
     }
 
+    // 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: any) {
+            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

package/bin/rmfshare-src/Program.cs

@@ -0,0 +1,225 @@
+// rmfshare — Windows Share-target activation handler for rmfmail (C46).
+//
+// Flow when the user picks "rmfmail" in the Windows Share sheet:
+//   1. Windows activates this exe (declared in the sparse AppxManifest that
+//      `rmfmail -register-share` registered) with ShareTarget activation.
+//   2. We read the DataPackageView — title, text, web link, storage items —
+//      while the ShareOperation is still alive (the source app's data is
+//      only guaranteed reachable until ReportCompleted).
+//   3. Files are copied into ~/.rmfmail/share-staging/<stamp>/ because the
+//      source StorageFiles live in the sharing app's sandbox — a raw path
+//      may not exist or may vanish as soon as the share pane closes.
+//   4. Write ~/.rmfmail/pending-share.json (atomic rename), ReportCompleted,
+//      then launch/poke the daemon exactly like the mailto handler: if a
+//      daemon runs, its fs.watch fires; if not, we spawn `node mailx.js`
+//      and the client's startup poll consumes the file.
+//
+// Launched without share activation (e.g. double-clicked): just launch
+// rmfmail — harmless, and better than an error box.
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.ApplicationModel.DataTransfer.ShareTarget;
+using Windows.Storage;
+
+internal static class Program
+{
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    private static extern int MessageBoxW(nint hwnd, string text, string caption, uint type);
+
+    private static void ShowError(string msg) =>
+        MessageBoxW(0, msg, "rmfmail share target", 0x10 /* MB_ICONERROR */);
+
+    private static string RmfmailDir =>
+        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".rmfmail");
+
+    [STAThread]
+    private static int Main()
+    {
+        try
+        {
+            IActivatedEventArgs? activation = null;
+            try { activation = AppInstance.GetActivatedEventArgs(); }
+            catch { /* unpackaged launch (double-click outside the manifest) */ }
+
+            if (activation is ShareTargetActivatedEventArgs share)
+            {
+                HandleShare(share).GetAwaiter().GetResult();
+            }
+            LaunchDaemon();
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            ShowError($"Share to rmfmail failed:\n{ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task HandleShare(ShareTargetActivatedEventArgs share)
+    {
+        var op = share.ShareOperation;
+        try { op.ReportStarted(); } catch { /* optional progress hint only */ }
+
+        var data = op.Data;
+        string title = "";
+        try { title = data.Properties?.Title ?? ""; } catch { }
+        string text = "";
+        string url = "";
+        var files = new List<(string Name, string Path, long Size)>();
+
+        if (data.Contains(StandardDataFormats.Text))
+        {
+            try { text = await data.GetTextAsync(); } catch { }
+        }
+        if (data.Contains(StandardDataFormats.WebLink))
+        {
+            try { url = (await data.GetWebLinkAsync())?.AbsoluteUri ?? ""; } catch { }
+        }
+        if (data.Contains(StandardDataFormats.StorageItems))
+        {
+            var stamp = DateTime.Now.ToString("yyyyMMdd_HHmmss") + "-" +
+                        Random.Shared.Next(10000).ToString("D4");
+            var staging = Path.Combine(RmfmailDir, "share-staging", stamp);
+            var items = await data.GetStorageItemsAsync();
+            foreach (var item in items)
+            {
+                if (item is not StorageFile f) continue; // folders: not meaningful as attachments
+                Directory.CreateDirectory(staging);
+                var dest = Path.Combine(staging, SafeName(f.Name, files.Count));
+                // Copy via the WinRT stream — f.Path can be empty for
+                // virtual/sandboxed items (e.g. shares out of UWP apps).
+                using (var src = (await f.OpenReadAsync()).AsStreamForRead())
+                using (var dst = File.Create(dest))
+                {
+                    await src.CopyToAsync(dst);
+                }
+                files.Add((f.Name, dest, new FileInfo(dest).Length));
+            }
+        }
+
+        WritePendingShare(title, text, url, files);
+
+        try { op.ReportCompleted(); } catch { /* pane may already be gone */ }
+    }
+
+    /// Avoid collisions when two shared files carry the same name.
+    private static string SafeName(string name, int index)
+    {
+        foreach (var c in Path.GetInvalidFileNameChars()) name = name.Replace(c, '_');
+        return index == 0 ? name
+            : Path.GetFileNameWithoutExtension(name) + $" ({index})" + Path.GetExtension(name);
+    }
+
+    /// Hand-rolled JSON writer — keeps NativeAOT trivially happy (no
+    /// reflection serializer, no source-gen context for a 5-field payload).
+    private static void WritePendingShare(
+        string title, string text, string url, List<(string Name, string Path, long Size)> files)
+    {
+        var sb = new StringBuilder();
+        sb.Append('{');
+        sb.Append("\"title\":").Append(Quote(title)).Append(',');
+        sb.Append("\"text\":").Append(Quote(text)).Append(',');
+        sb.Append("\"url\":").Append(Quote(url)).Append(',');
+        sb.Append("\"files\":[");
+        for (int i = 0; i < files.Count; i++)
+        {
+            if (i > 0) sb.Append(',');
+            sb.Append("{\"name\":").Append(Quote(files[i].Name))
+              .Append(",\"path\":").Append(Quote(files[i].Path))
+              .Append(",\"size\":").Append(files[i].Size).Append('}');
+        }
+        sb.Append("],");
+        sb.Append("\"writtenAt\":").Append(DateTimeOffset.Now.ToUnixTimeMilliseconds());
+        sb.Append('}');
+
+        Directory.CreateDirectory(RmfmailDir);
+        var target = Path.Combine(RmfmailDir, "pending-share.json");
+        var tmp = target + ".tmp";
+        File.WriteAllText(tmp, sb.ToString(), new UTF8Encoding(false));
+        File.Move(tmp, target, overwrite: true);
+    }
+
+    private static string Quote(string s)
+    {
+        var sb = new StringBuilder(s.Length + 2);
+        sb.Append('"');
+        foreach (var c in s)
+        {
+            switch (c)
+            {
+                case '"': sb.Append("\\\""); break;
+                case '\\': sb.Append("\\\\"); break;
+                case '\n': sb.Append("\\n"); break;
+                case '\r': sb.Append("\\r"); break;
+                case '\t': sb.Append("\\t"); break;
+                default:
+                    if (c < ' ') sb.Append("\\u").Append(((int)c).ToString("x4"));
+                    else sb.Append(c);
+                    break;
+            }
+        }
+        sb.Append('"');
+        return sb.ToString();
+    }
+
+    /// Same node + mailx.js lookup as the Rust rmfmailto launcher: env
+    /// overrides first, then the standard npm -g install location, then PATH.
+    /// A bare `node mailx.js` is correct both ways — if a daemon is already
+    /// running the new process exits at the instance check (fs.watch on the
+    /// pending file has already fired); otherwise it becomes the daemon and
+    /// the client's startup poll consumes the file.
+    private static void LaunchDaemon()
+    {
+        var mailxJs = Environment.GetEnvironmentVariable("RMFMAIL_JS");
+        if (string.IsNullOrEmpty(mailxJs) || !File.Exists(mailxJs))
+        {
+            var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+            mailxJs = Path.Combine(appData, "npm", "node_modules",
+                "@bobfrankston", "rmfmail", "bin", "mailx.js");
+        }
+        if (!File.Exists(mailxJs))
+        {
+            ShowError($"rmfmail not found at {mailxJs}.\nInstall with: npm install -g @bobfrankston/rmfmail");
+            return;
+        }
+
+        var node = FindNode();
+        if (node == null)
+        {
+            ShowError("node.exe not found on PATH — rmfmail needs Node.js installed.");
+            return;
+        }
+
+        var psi = new ProcessStartInfo
+        {
+            FileName = node,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+            WorkingDirectory = Path.GetDirectoryName(mailxJs)!,
+        };
+        psi.ArgumentList.Add(mailxJs);
+        Process.Start(psi);
+    }
+
+    private static string? FindNode()
+    {
+        var env = Environment.GetEnvironmentVariable("NODE_EXE");
+        if (!string.IsNullOrEmpty(env) && File.Exists(env)) return env;
+        foreach (var dir in (Environment.GetEnvironmentVariable("PATH") ?? "").Split(';'))
+        {
+            if (dir.Length == 0) continue;
+            try
+            {
+                var candidate = Path.Combine(dir.Trim(), "node.exe");
+                if (File.Exists(candidate)) return candidate;
+            }
+            catch { /* malformed PATH entry */ }
+        }
+        return null;
+    }
+}

package/bin/rmfshare-src/rmfshare.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!--
+    rmfshare — Windows Share-target activation helper (C46).
+
+    Declared as the Application executable in the sparse AppxManifest that
+    `rmfmail -register-share` registers (see bin/share-target.ts). When the
+    user picks "rmfmail" in the Windows Share sheet, Windows launches this
+    exe with ShareTarget activation; we read the shared data via WinRT,
+    stage any files under ~/.rmfmail/share-staging/, drop
+    ~/.rmfmail/pending-share.json, and poke the daemon (same pending-file
+    pattern as the P115 mailto handler).
+
+    NativeAOT so the shipped bin/rmfshare.exe is a single self-contained
+    binary — no .NET runtime required on install machines (mirrors the
+    checked-in Rust rmfmailto.exe). Build via bin/build-rmfshare-exe.js
+    (hooked into `npm run build`); requires the .NET 10 SDK + VS C++ tools
+    on the BUILD machine only.
+  -->
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <PublishAot>true</PublishAot>
+    <SelfContained>true</SelfContained>
+    <InvariantGlobalization>true</InvariantGlobalization>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>rmfshare</AssemblyName>
+    <!-- FileDescription — anything that surfaces the exe name shows "rmfmail" -->
+    <AssemblyTitle>rmfmail</AssemblyTitle>
+    <Product>rmfmail</Product>
+    <Company>Bob Frankston</Company>
+    <Version>1.0.0</Version>
+  </PropertyGroup>
+</Project>

package/bin/share-target.js

@@ -0,0 +1,314 @@
+/**
+ * Windows Share-target integration (C46).
+ *
+ * Share flow when rmfmail is picked in the Windows Share sheet:
+ *
+ *   1. Windows activates rmfshare.exe (bin/rmfshare-src/, declared in the
+ *      AppxManifest registered by `rmfmail -register-share`).
+ *   2. rmfshare.exe copies shared files to ~/.rmfmail/share-staging/<stamp>/,
+ *      writes ~/.rmfmail/pending-share.json (atomic rename), and launches
+ *      `node mailx.js` — which exits at the instance check if a daemon
+ *      already runs (its fs.watch on the pending file has fired) or becomes
+ *      the daemon (the client's startup poll consumes the file).
+ *   3. The daemon loads the staged files as base64 and pushes an `openShare`
+ *      event; the client opens compose with the shared content attached.
+ *
+ * Same pending-file indirection as the P115 mailto handler (bin/mailto.ts) —
+ * no IPC socket needed, one share = one file write.
+ *
+ * Registration is a "loose" AppX deployment: a staged folder holding
+ * rmfshare.exe + AppxManifest.xml + Assets, registered per-user via
+ * `Add-AppxPackage -Register`. That requires Developer Mode (unsigned
+ * manifest) — the registration path checks and says so. No MSIX signing,
+ * no Store, no admin.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+/** Attachments larger than this are skipped (typical SMTP servers reject
+ *  messages this size anyway); the skip is reported, never silent. */
+export const SHARE_ATTACHMENT_MAX_BYTES = 25 * 1024 * 1024;
+const IDENTITY_NAME = "BobFrankston.rmfmail";
+function rmfmailDir() {
+    const home = process.env.USERPROFILE || process.env.HOME || ".";
+    return path.join(home, ".rmfmail");
+}
+export function getPendingShareFile() {
+    return path.join(rmfmailDir(), "pending-share.json");
+}
+/** Read + delete the pending-share file. One-shot, same contract as
+ *  consumePendingMailto: caller acts on the result, the file is gone either
+ *  way, stale files (crashed handoff) are dropped. */
+export function consumePendingShare() {
+    const target = getPendingShareFile();
+    let raw;
+    try {
+        raw = fs.readFileSync(target, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        fs.unlinkSync(target);
+    }
+    catch { /* */ }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const age = Date.now() - (parsed.writtenAt || 0);
+    if (age > 10 * 60_000) {
+        // Crashed handoff — user shared but nothing consumed it for 10
+        // minutes. Drop it (staging cleanup reaps the copied files).
+        return null;
+    }
+    parsed.title = parsed.title || "";
+    parsed.text = parsed.text || "";
+    parsed.url = parsed.url || "";
+    parsed.files = Array.isArray(parsed.files) ? parsed.files : [];
+    return parsed;
+}
+const MIME_BY_EXT = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml",
+    ".heic": "image/heic",
+    ".txt": "text/plain", ".log": "text/plain", ".md": "text/plain",
+    ".html": "text/html", ".htm": "text/html",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".zip": "application/zip",
+    ".7z": "application/x-7z-compressed",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".eml": "message/rfc822",
+    ".ics": "text/calendar",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+};
+export function mimeForFilename(name) {
+    return MIME_BY_EXT[path.extname(name).toLowerCase()] || "application/octet-stream";
+}
+/** Load staged share files as compose-init attachments (base64). Oversized
+ *  or unreadable files land in `skipped` with a reason — surfaced to the
+ *  user in the compose body, never dropped silently. Consumed staging dirs
+ *  are deleted afterwards; the content lives on in the compose draft. */
+export function loadShareAttachments(files) {
+    const attachments = [];
+    const skipped = [];
+    const dirs = new Set();
+    for (const f of files) {
+        try {
+            const st = fs.statSync(f.path);
+            if (st.size > SHARE_ATTACHMENT_MAX_BYTES) {
+                skipped.push({ name: f.name, reason: `larger than ${Math.round(SHARE_ATTACHMENT_MAX_BYTES / 1024 / 1024)} MB` });
+            }
+            else {
+                attachments.push({
+                    filename: f.name,
+                    mimeType: mimeForFilename(f.name),
+                    dataBase64: fs.readFileSync(f.path).toString("base64"),
+                });
+            }
+            dirs.add(path.dirname(f.path));
+        }
+        catch (e) {
+            skipped.push({ name: f.name, reason: e?.message || "unreadable" });
+        }
+    }
+    for (const d of dirs) {
+        // Only reap inside our own staging root — a hand-written pending
+        // file must never turn this into an arbitrary directory delete.
+        if (d.startsWith(path.join(rmfmailDir(), "share-staging") + path.sep)) {
+            try {
+                fs.rmSync(d, { recursive: true, force: true });
+            }
+            catch { /* next startup sweep */ }
+        }
+    }
+    return { attachments, skipped };
+}
+/** Reap staging dirs older than 2 days — leftovers from shares that never
+ *  got consumed (daemon crash between copy and compose). Called once at
+ *  daemon startup. */
+export function cleanupShareStaging() {
+    const root = path.join(rmfmailDir(), "share-staging");
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const cutoff = Date.now() - 2 * 24 * 3600_000;
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const full = path.join(root, e.name);
+        try {
+            if (fs.statSync(full).mtimeMs < cutoff) {
+                fs.rmSync(full, { recursive: true, force: true });
+            }
+        }
+        catch { /* in use or already gone */ }
+    }
+}
+// ── Registration (Windows only) ─────────────────────────────────────────
+function buildAppxManifest(version) {
+    // Unsigned loose deployment: Publisher only has to be well-formed, it
+    // isn't validated against a certificate. AppListEntry="none" keeps the
+    // entry out of the Start menu — rmfshare.exe is a share sink, not an
+    // app the user launches.
+    return `<?xml version="1.0" encoding="utf-8"?>
+<Package
+    xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+    xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+    xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+    IgnorableNamespaces="uap rescap">
+  <Identity Name="${IDENTITY_NAME}" Publisher="CN=Bob Frankston" Version="${version}" ProcessorArchitecture="x64" />
+  <Properties>
+    <DisplayName>rmfmail</DisplayName>
+    <PublisherDisplayName>Bob Frankston</PublisherDisplayName>
+    <Logo>Assets\\logo150.png</Logo>
+  </Properties>
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
+  </Dependencies>
+  <Resources>
+    <Resource Language="en-us" />
+  </Resources>
+  <Applications>
+    <Application Id="rmfmail" Executable="rmfshare.exe" EntryPoint="Windows.FullTrustApplication">
+      <uap:VisualElements DisplayName="rmfmail" Description="Share to rmfmail"
+          BackgroundColor="transparent"
+          Square150x150Logo="Assets\\logo150.png" Square44x44Logo="Assets\\logo44.png"
+          AppListEntry="none" />
+      <Extensions>
+        <uap:Extension Category="windows.shareTarget">
+          <uap:ShareTarget Description="Share to rmfmail">
+            <uap:SupportedFileTypes>
+              <uap:SupportsAnyFileType />
+            </uap:SupportedFileTypes>
+            <uap:DataFormat>Text</uap:DataFormat>
+            <uap:DataFormat>WebLink</uap:DataFormat>
+            <uap:DataFormat>StorageItems</uap:DataFormat>
+          </uap:ShareTarget>
+        </uap:Extension>
+      </Extensions>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <rescap:Capability Name="runFullTrust" />
+  </Capabilities>
+</Package>
+`;
+}
+function powershell(script) {
+    return execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: ["pipe", "pipe", "pipe"] }).toString();
+}
+function developerModeEnabled() {
+    try {
+        const out = powershell("(Get-ItemProperty 'HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\AppModelUnlock' -ErrorAction SilentlyContinue).AllowDevelopmentWithoutDevLicense");
+        return out.trim() === "1";
+    }
+    catch {
+        return false;
+    }
+}
+/** Register (or unregister) rmfmail as a Windows Share target. Mirrors
+ *  registerMailtoWindows in mailx.ts: returns outcome text instead of
+ *  printing so the CLI and any future Settings toggle share one path. */
+export function registerShareWindows(unregister) {
+    const lines = [];
+    if (unregister) {
+        try {
+            powershell(`Get-AppxPackage '${IDENTITY_NAME}' | Remove-AppxPackage`);
+            lines.push("rmfmail removed from the Windows Share menu.");
+        }
+        catch (e) {
+            return { ok: false, message: `Remove-AppxPackage failed: ${e?.stderr?.toString?.() || e.message}` };
+        }
+        return { ok: true, message: lines.join("\n") };
+    }
+    const pkgExe = path.join(import.meta.dirname, "rmfshare.exe");
+    if (!fs.existsSync(pkgExe)) {
+        return { ok: false, message: `rmfshare.exe not found at ${pkgExe} — package was built without it. Re-run 'npm run build' on the build machine.` };
+    }
+    if (!developerModeEnabled()) {
+        return {
+            ok: false,
+            message: "Registering an unsigned Share target needs Windows Developer Mode:\n" +
+                "  Settings → System → For developers → Developer Mode → On\n" +
+                "then re-run `rmfmail -register-share`.",
+        };
+    }
+    // Stage under %LOCALAPPDATA%\rmfmail\share-target — NOT inside
+    // node_modules: the registered package points at absolute paths, and an
+    // npm upgrade replacing node_modules would strand the registration.
+    const stageDir = path.join(process.env.LOCALAPPDATA || rmfmailDir(), "rmfmail", "share-target");
+    const assetsDir = path.join(stageDir, "Assets");
+    fs.mkdirSync(assetsDir, { recursive: true });
+    fs.copyFileSync(pkgExe, path.join(stageDir, "rmfshare.exe"));
+    // Manifest logos scaled from the app icon at register time (System.
+    // Drawing via PowerShell — registration is already a Windows-only,
+    // PowerShell-driven path).
+    const iconPng = path.join(import.meta.dirname, "..", "client", "icon.png");
+    try {
+        powershell(`
+Add-Type -AssemblyName System.Drawing
+$src = [System.Drawing.Image]::FromFile('${iconPng.replace(/'/g, "''")}')
+foreach ($s in 44,150) {
+  $bmp = New-Object System.Drawing.Bitmap $s, $s
+  $g = [System.Drawing.Graphics]::FromImage($bmp)
+  $g.InterpolationMode = 'HighQualityBicubic'
+  $g.DrawImage($src, 0, 0, $s, $s)
+  $bmp.Save('${assetsDir.replace(/'/g, "''")}\\logo' + $s + '.png', [System.Drawing.Imaging.ImageFormat]::Png)
+  $g.Dispose(); $bmp.Dispose()
+}
+$src.Dispose()`);
+    }
+    catch (e) {
+        return { ok: false, message: `Icon scaling failed: ${e?.stderr?.toString?.() || e.message}` };
+    }
+    // Manifest version tracks the package version so re-registering after an
+    // upgrade redeploys cleanly (4th part must be 0 for AppX).
+    let pkgVersion = "1.0.0";
+    try {
+        pkgVersion = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8")).version || pkgVersion;
+    }
+    catch { /* fall back */ }
+    const appxVersion = pkgVersion.split(".").slice(0, 3).map(p => String(parseInt(p, 10) || 0)).join(".") + ".0";
+    fs.writeFileSync(path.join(stageDir, "AppxManifest.xml"), buildAppxManifest(appxVersion));
+    try {
+        // Remove any prior registration first — Add-AppxPackage -Register
+        // rejects same-version re-registration, and downgrades after a
+        // rollback would fail outright.
+        powershell(`Get-AppxPackage '${IDENTITY_NAME}' | Remove-AppxPackage`);
+    }
+    catch { /* not registered — fine */ }
+    try {
+        powershell(`Add-AppxPackage -Register '${path.join(stageDir, "AppxManifest.xml").replace(/'/g, "''")}'`);
+    }
+    catch (e) {
+        return { ok: false, message: `Add-AppxPackage failed: ${e?.stderr?.toString?.() || e.message}` };
+    }
+    lines.push("rmfmail registered as a Windows Share target.");
+    lines.push("It now appears in the Share sheet (Explorer right-click → Share, browser Share, etc.).");
+    lines.push(`Staged at: ${stageDir}`);
+    lines.push("Note: re-run -register-share after major upgrades so the staged rmfshare.exe stays current.");
+    return { ok: true, message: lines.join("\n") };
+}
+//# sourceMappingURL=share-target.js.map