@bobfrankston/msger 0.1.351 → 0.1.353

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.353",
   "description": "Fast, lightweight, cross-platform message box - Rust-powered alternative to msgview",
   "type": "module",
   "main": "./index.js",
@@ -51,7 +51,8 @@
   "dependencies": {
     "@bobfrankston/msgcommon": "^0.1.23",
     "ansi-to-html": "^0.7.2",
-    "json5": "^2.2.3"
+    "json5": "^2.2.3",
+    "rcedit": "^4.0.1"
   },
   "files": [
     "*.js",

package/shower.js

@@ -1,7 +1,8 @@
-import { spawn } from 'child_process';
+import { spawn, execFileSync } from 'child_process';
 import { platform } from 'os';
 import path from 'path';
 import { pathToFileURL } from 'url';
+import { createRequire } from 'module';
 import fs from 'fs';
 import AnsiToHtml from 'ansi-to-html';
 // Load package.json for version
@@ -113,61 +114,174 @@ 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 */ }
+}
+/** Locate the rcedit-<arch>.exe shipped with the `rcedit` npm package
+ *  (Electron-team maintained, published unscoped). Returns null on
+ *  non-Windows or if the package isn't installed. We resolve the path
+ *  manually so we can call the binary with `execFileSync` and keep the
+ *  caller synchronous. */
+function findRceditBinary() {
+    if (platform() !== "win32")
+        return null;
+    try {
+        // The package ships rcedit-x64.exe / rcedit-ia32.exe / rcedit-arm64.exe
+        // in its `bin/` dir. Resolve via require.resolve('rcedit') → walk up
+        // to the package root, then into bin/.
+        const pkgEntry = createRequire(import.meta.url).resolve("rcedit");
+        const pkgRoot = path.dirname(pkgEntry);
+        const archMap = {
+            x64: "rcedit-x64.exe",
+            ia32: "rcedit-ia32.exe",
+            arm64: "rcedit-arm64.exe",
+        };
+        const exeName = archMap[process.arch] || "rcedit-x64.exe";
+        const candidates = [
+            path.join(pkgRoot, "bin", exeName),
+            path.join(pkgRoot, "..", "bin", exeName),
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(c))
+                return c;
+        }
+    }
+    catch { /* not installed — caller will fall back to plain copy */ }
+    return null;
+}
+/** 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 — fires the
+ *  bundled rcedit.exe via `execFileSync`. Returns true on success. Failures
+ *  don't break launch — the launcher just runs without the embedded icon. */
+function injectIcon(exePath, icoPath) {
+    const rcedit = findRceditBinary();
+    if (!rcedit) {
+        console.error(`  msger: rcedit binary not found — per-app icon not injected (install \`rcedit\` npm package)`);
+        return false;
+    }
+    try {
+        execFileSync(rcedit, [exePath, "--set-icon", icoPath], { stdio: "pipe" });
+        return true;
+    }
+    catch (e) {
+        console.error(`  msger: rcedit failed for ${exePath}: ${e?.message || e}`);
+        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 `rcedit` 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);
+    // Copy + rcedit 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;
     }
-    catch {
-        return; /* held open by another instance — retry next launch */
-    }
-    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.
+    if (!stale)
+        return;
+    // Build the new exe out-of-band so a running instance never sees a
+    // half-rcedit'd file. Sequence: copy → rcedit 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 {
-        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 rceditOk = false;
+        if (isIco) {
+            rceditOk = injectIcon(tmpExe, _appIcon);
+        }
+        if (!isIco || !rceditOk) {
+            // No .ico available, or rcedit couldn't inject — 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`