@bobfrankston/msger 0.1.351 → 0.1.355

package/msger-native/builder/postinstall.js

@@ -197,3 +197,19 @@ if (!isWindows) {
         }
     }
 }
+
+// Friendly message about the EPERM warnings npm itself emits during a
+// subsequent global upgrade. They come from npm trying to delete its own
+// staging directory while the previously-running msgernative.exe inside
+// still holds a file handle. msger's rename-aside scheme above has already
+// handled the actual upgrade safely; the warnings are cosmetic.
+if (isWindows) {
+    console.log("");
+    console.log("  msger: install OK.");
+    console.log("  msger: if a future `npm i -g @bobfrankston/msger` prints");
+    console.log("         EPERM/ENOTEMPTY warnings about removing a staging");
+    console.log("         directory, those are expected when an older msger");
+    console.log("         is still running — the upgrade has already taken");
+    console.log("         effect via rename-aside. Safe to ignore.");
+    console.log("");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/msger",
-  "version": "0.1.351",
+  "version": "0.1.355",
   "description": "Fast, lightweight, cross-platform message box - Rust-powered alternative to msgview",
   "type": "module",
   "main": "./index.js",

package/shower.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { spawn, execFileSync } from 'child_process';
 import { platform } from 'os';
 import path from 'path';
 import { pathToFileURL } from 'url';
@@ -113,61 +113,139 @@ function findMsgerSource() {
         return bundled;
     return null;
 }
-/** Ensure a per-app exe is present at `perAppExe` and points at the same inode
- *  as `sourceExe`. On Windows, hardlinks share inodes so a `stat().ino`
- *  comparison detects when msger's postinstall has rename-asided the source
- *  and written a new file (which leaves our hardlink dangling on the OLD
- *  inode). Re-link in that case, using the same rename-aside trick to avoid
- *  EBUSY when the per-app exe is itself being executed by another instance. */
+/** Sweep stale `.aside-*` / `.old-*` siblings of `perAppExe`. Best-effort —
+ *  files held open by an older instance throw EPERM and stay until the next
+ *  launch when nothing has them mapped. */
+function sweepAsideSiblings(perAppExe) {
+    try {
+        const dir = path.dirname(perAppExe);
+        const base = path.basename(perAppExe);
+        const pat = new RegExp(`^${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.(?:old|aside|tmp)-(\\d+)$`);
+        for (const f of fs.readdirSync(dir)) {
+            const m = pat.exec(f);
+            if (!m)
+                continue;
+            try {
+                fs.unlinkSync(path.join(dir, f));
+            }
+            catch { /* still locked, try next time */ }
+        }
+    }
+    catch { /* fall through */ }
+}
+/** Inject `.ico` into `exePath` as the IDI_ICON1 / RT_GROUP_ICON resource so
+ *  the per-app exe shows the app's own icon in Explorer, Task Manager, the
+ *  taskbar, and pinned shortcuts — every Windows context that reads the exe
+ *  resource (which `with_window_icon` doesn't reach). Sync — invokes the
+ *  shipped `msgernative.exe --update-icon` subcommand (no external deps;
+ *  msger stays self-contained). Returns true on success. Failures don't
+ *  break launch — the launcher just runs without the embedded icon. */
+function injectIcon(msgerNative, exePath, icoPath) {
+    try {
+        execFileSync(msgerNative, ["--update-icon", exePath, icoPath], { stdio: "pipe" });
+        return true;
+    }
+    catch (e) {
+        const stderr = (e?.stderr ?? "").toString().trim();
+        console.error(`  msger: --update-icon failed for ${exePath}: ${e?.message || e}${stderr ? ` (${stderr})` : ""}`);
+        return false;
+    }
+}
+/** Ensure a per-app exe is present at `perAppExe`, derived from `sourceExe`,
+ *  with the per-app icon resource injected. Two modes:
+ *
+ *  - `_appIcon` is set (the per-app-identity case): the per-app exe is a
+ *    *real copy*, not a hardlink, because `--update-icon` rewrites the resource
+ *    section and we don't want that change to bleed back into the shared
+ *    `msgernative.exe` (which a hardlink would). Staleness compared via
+ *    mtime of source exe + mtime of source icon. Refresh uses the
+ *    rename-aside pattern so a running instance doesn't block the update.
+ *
+ *  - `_appIcon` is unset: legacy hardlink behavior — `mailx.exe` shares an
+ *    inode with `msgernative.exe`, no resource injection. Same as before.
+ */
 function ensureFresh(perAppExe, sourceExe) {
-    if (!fs.existsSync(perAppExe)) {
-        fs.mkdirSync(path.dirname(perAppExe), { recursive: true });
+    fs.mkdirSync(path.dirname(perAppExe), { recursive: true });
+    // Hardlink path (callers that didn't `setAppIcon`) — unchanged behavior.
+    if (!_appIcon || !fs.existsSync(_appIcon)) {
+        if (!fs.existsSync(perAppExe)) {
+            try {
+                fs.linkSync(sourceExe, perAppExe);
+            }
+            catch {
+                fs.copyFileSync(sourceExe, perAppExe);
+            }
+            return;
+        }
+        if (fs.statSync(perAppExe).ino === fs.statSync(sourceExe).ino)
+            return;
+        const aside = `${perAppExe}.aside-${Date.now()}`;
+        try {
+            fs.renameSync(perAppExe, aside);
+        }
+        catch {
+            return;
+        }
         try {
             fs.linkSync(sourceExe, perAppExe);
         }
         catch {
-            fs.copyFileSync(sourceExe, perAppExe); /* cross-volume fallback */
+            fs.copyFileSync(sourceExe, perAppExe);
         }
+        sweepAsideSiblings(perAppExe);
         return;
     }
-    if (fs.statSync(perAppExe).ino === fs.statSync(sourceExe).ino)
-        return;
-    // Stale hardlink — source was rename-asided + replaced. Rename-aside the
-    // per-app exe (a running mailx keeps its file handle to the OLD inode via
-    // the aside name) and re-link to the new source.
-    const aside = `${perAppExe}.old-${Date.now()}`;
-    try {
-        fs.renameSync(perAppExe, aside);
-    }
-    catch {
-        return; /* held open by another instance — retry next launch */
+    // Copy + --update-icon path. Stale when the per-app exe is missing OR the source
+    // exe is newer (msger updated) OR the source icon is newer (icon changed).
+    const srcMtime = fs.statSync(sourceExe).mtimeMs;
+    const icoMtime = fs.statSync(_appIcon).mtimeMs;
+    let stale = !fs.existsSync(perAppExe);
+    if (!stale) {
+        const dstMtime = fs.statSync(perAppExe).mtimeMs;
+        stale = dstMtime < srcMtime || dstMtime < icoMtime;
     }
+    if (!stale)
+        return;
+    // Build the new exe out-of-band so a running instance never sees a
+    // half---update-icon'd file. Sequence: copy → --update-icon tmp → rename old aside →
+    // rename tmp into place. All renames work even on locked files; only
+    // delete is blocked, and we defer that to the next launch's sweep.
+    const stamp = Date.now();
+    const tmpExe = `${perAppExe}.tmp-${stamp}`;
+    const isIco = _appIcon.toLowerCase().endsWith(".ico");
     try {
-        fs.linkSync(sourceExe, perAppExe);
-    }
-    catch {
-        fs.copyFileSync(sourceExe, perAppExe);
-    }
-    // Best-effort sweep of `.old-*` siblings older than 24 h. Same pattern as
-    // postinstall.js. Skip silently — they'll get cleaned up next time.
-    try {
-        const dir = path.dirname(perAppExe);
-        const base = path.basename(perAppExe);
-        const oldPat = new RegExp(`^${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.old-(\\d+)$`);
-        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-        for (const f of fs.readdirSync(dir)) {
-            const m = oldPat.exec(f);
-            if (!m)
-                continue;
-            if (Number(m[1]) > cutoff)
-                continue;
+        fs.copyFileSync(sourceExe, tmpExe);
+        let injected = false;
+        if (isIco) {
+            injected = injectIcon(sourceExe, tmpExe, _appIcon);
+        }
+        if (!isIco || !injected) {
+            // No .ico available, or the resource update failed — fall back
+            // to a plain copy. Window-icon path still gets set via Tao at
+            // launch; we just don't get the EXE-level resource.
+        }
+        if (fs.existsSync(perAppExe)) {
             try {
-                fs.unlinkSync(path.join(dir, f));
+                fs.renameSync(perAppExe, `${perAppExe}.aside-${stamp}`);
+            }
+            catch { /* held open — leave the old file in place; we'll retry */
+                try {
+                    fs.unlinkSync(tmpExe);
+                }
+                catch { /* */ }
+                return;
             }
-            catch { /* still locked, try next time */ }
         }
+        fs.renameSync(tmpExe, perAppExe);
+        sweepAsideSiblings(perAppExe);
+    }
+    catch (e) {
+        console.error(`  msger: per-app exe provision failed (${perAppExe}): ${e?.message || e}`);
+        try {
+            fs.unlinkSync(tmpExe);
+        }
+        catch { /* */ }
     }
-    catch { /* fall through */ }
 }
 /** Copy the per-app icon next to the per-app exe so Rust's default-icon
  *  search (`load_icon` in main.rs) picks it up. Rust looks for `msger.ico`