@bobfrankston/msger 0.1.341 → 0.1.342

package/index.d.ts

@@ -1 +1 @@
-export { showMessageBox, showService, ServiceHandle, MessageBoxOptions, MessageBoxResult, setAppName } from "./shower.js";
+export { showMessageBox, showService, ServiceHandle, MessageBoxOptions, MessageBoxResult, setAppName, setAppIcon } from "./shower.js";

package/index.js

@@ -1,5 +1,5 @@
 // Export showMessageBox and types for use as a library
-export { showMessageBox, showService, ServiceHandle, setAppName } from "./shower.js";
+export { showMessageBox, showService, ServiceHandle, setAppName, setAppIcon } from "./shower.js";
 // If run directly (e.g., `node .` or `node index.js`), run the CLI
 // @ts-ignore - import.meta.main is available in Node.js 20+
 if (import.meta.main) {

package/package.json

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

package/shower.d.ts

@@ -61,9 +61,14 @@ export interface MessageBoxResult {
         autoSize: boolean;
     };
 }
-/** Set the app name used for the per-user binary directory.
- *  Call before showService/showMessageBox — e.g. `setAppName("mailx")`. */
+/** Set the app name used for the per-user bin dir AND the per-app exe filename.
+ *  Call before showService/showMessageBox — e.g. `setAppName("mailx")` makes
+ *  the running process appear as `mailx.exe` in Task Manager and the taskbar. */
 export declare function setAppName(name: string): void;
+/** Set a per-app icon (PNG or ICO). Copied next to the per-app exe at first
+ *  provision so Rust's window icon search picks it up. Per-call `icon` in
+ *  `MessageBoxOptions` still takes precedence. */
+export declare function setAppIcon(iconPath: string): void;
 /**
  * Show a message box dialog using native Rust implementation (extended version)
  * @param options Message box configuration

package/shower.js

@@ -53,27 +53,149 @@ export function closeMessageBox(pid) {
  *  exe inside it is locked. Keeping timestamped copies here means npm only
  *  manages the stable `msgernative.exe` (which isn't the one being executed),
  *  so it's never locked. */
-/** App name for per-user bin dir. Set via `setAppName()` so each app using
- *  msger gets its own binary path (%LOCALAPPDATA%\<appName>\bin\) and thus
- *  its own taskbar identity. Defaults to "msger" for standalone use. */
+/** App name for per-user bin dir + per-app exe filename. Set via `setAppName()`
+ *  so each app using msger gets its own binary path
+ *  (`%LOCALAPPDATA%\<appName>\bin\<appName>.exe` on Windows) and thus its own
+ *  taskbar identity, Task Manager process name, and pin target. Defaults to
+ *  "msger" for standalone use, which preserves the original `msgernative.exe`
+ *  behavior. */
 let _appName = "msger";
-/** Set the app name used for the per-user binary directory.
- *  Call before showService/showMessageBox — e.g. `setAppName("mailx")`. */
+/** Optional per-app icon path. Set via `setAppIcon()`. When set, msger copies
+ *  it next to the per-app exe so Rust's default-icon search picks it up — no
+ *  need to pass `icon` on every spawn call. PNG and ICO accepted. */
+let _appIcon;
+/** Set the app name used for the per-user bin dir AND the per-app exe filename.
+ *  Call before showService/showMessageBox — e.g. `setAppName("mailx")` makes
+ *  the running process appear as `mailx.exe` in Task Manager and the taskbar. */
 export function setAppName(name) { _appName = name; }
-function getUserBinDir() {
+/** Set a per-app icon (PNG or ICO). Copied next to the per-app exe at first
+ *  provision so Rust's window icon search picks it up. Per-call `icon` in
+ *  `MessageBoxOptions` still takes precedence. */
+export function setAppIcon(iconPath) { _appIcon = iconPath; }
+function getUserBinDirFor(appName) {
     const isWindows = platform() === 'win32';
     if (isWindows) {
         const base = process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || '.', 'AppData', 'Local');
-        return path.join(base, _appName, 'bin');
+        return path.join(base, appName, 'bin');
     }
     const xdg = process.env.XDG_DATA_HOME;
     const base = xdg || path.join(process.env.HOME || '.', '.local', 'share');
-    return path.join(base, _appName, 'bin');
+    return path.join(base, appName, 'bin');
 }
-/** Resolve the native binary path. Prefers a timestamped copy in the per-user
- *  bin dir (immune to npm-upgrade locks). Falls back to the package's bundled
- *  unversioned binary when no per-user copy exists yet — first launch after a
- *  fresh install before postinstall has copied one out. */
+function getUserBinDir() { return getUserBinDirFor(_appName); }
+/** Locate the msger-managed source binary that per-app exes hardlink to.
+ *  Prefers `%LOCALAPPDATA%\msger\bin\msgernative.exe` (postinstall's stable
+ *  name), falls back to a per-user timestamped copy, then to the package's
+ *  bundled binary. Returns null only if msger truly isn't installed. */
+function findMsgerSource() {
+    const isWindows = platform() === 'win32';
+    const arch = process.arch;
+    const ext = isWindows ? '.exe' : '';
+    const baseName = (!isWindows && arch === 'arm64')
+        ? 'msgernative-linux-aarch64'
+        : 'msgernative';
+    const msgerBin = getUserBinDirFor('msger');
+    const pkgBin = path.join(import.meta.dirname, 'msger-native', 'bin');
+    const stable = path.join(msgerBin, `${baseName}${ext}`);
+    if (fs.existsSync(stable))
+        return stable;
+    const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
+    for (const dir of [msgerBin, pkgBin]) {
+        try {
+            const matches = fs.readdirSync(dir).filter(f => pattern.test(f)).sort().reverse();
+            if (matches.length > 0)
+                return path.join(dir, matches[0]);
+        }
+        catch { /* dir doesn't exist — keep looking */ }
+    }
+    const bundled = path.join(pkgBin, `${baseName}${ext}`);
+    if (fs.existsSync(bundled))
+        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. */
+function ensureFresh(perAppExe, sourceExe) {
+    if (!fs.existsSync(perAppExe)) {
+        fs.mkdirSync(path.dirname(perAppExe), { recursive: true });
+        try {
+            fs.linkSync(sourceExe, perAppExe);
+        }
+        catch {
+            fs.copyFileSync(sourceExe, perAppExe); /* cross-volume fallback */
+        }
+        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 */
+    }
+    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;
+            try {
+                fs.unlinkSync(path.join(dir, f));
+            }
+            catch { /* still locked, try next time */ }
+        }
+    }
+    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`
+ *  / `msger.png` adjacent to the exe — we drop our icon under that name so
+ *  no Rust changes are needed. Only re-copies when source is newer. */
+function provisionAppIcon(perAppDir) {
+    if (!_appIcon || !fs.existsSync(_appIcon))
+        return;
+    const iconExt = path.extname(_appIcon).toLowerCase();
+    if (iconExt !== '.png' && iconExt !== '.ico')
+        return;
+    const dest = path.join(perAppDir, `msger${iconExt}`);
+    try {
+        if (fs.existsSync(dest) && fs.statSync(dest).mtimeMs >= fs.statSync(_appIcon).mtimeMs)
+            return;
+        fs.copyFileSync(_appIcon, dest);
+    }
+    catch { /* non-fatal — caller can still pass icon per-call */ }
+}
+/** Resolve the native binary path. Two modes:
+ *  - `_appName === "msger"` (default, standalone msger use): unchanged from
+ *    the original — find `msgernative.exe` in user bin, fall back to legacy
+ *    timestamped copies, finally to the package-bundled binary.
+ *  - `_appName !== "msger"` (per-app, e.g. mailx): provision a hardlink at
+ *    `%LOCALAPPDATA%\<_appName>\bin\<_appName>.exe` pointing at the msger
+ *    source binary, refresh the link if msger has been updated, copy the
+ *    icon next to it, return the per-app path. This is what gives mailx its
+ *    own taskbar identity. */
 function resolveBinaryPath() {
     const isWindows = platform() === 'win32';
     const arch = process.arch;
@@ -93,8 +215,28 @@ function resolveBinaryPath() {
         baseName = 'msgernative';
         ext = '';
     }
-    // Prefer the stable-name hardlink in the user dir — same path every time,
-    // so taskbar pins and AUMID grouping don't break on updates.
+    // Per-app mode: provision and use a renamed hardlink so taskbar / Task
+    // Manager / pinned shortcuts see the app's own identity.
+    if (_appName !== 'msger') {
+        const source = findMsgerSource();
+        if (source) {
+            const perAppExe = path.join(userBinDir, `${_appName}${ext}`);
+            try {
+                ensureFresh(perAppExe, source);
+                provisionAppIcon(userBinDir);
+                if (fs.existsSync(perAppExe))
+                    return perAppExe;
+            }
+            catch {
+                // Provisioning failed — fall through to the source binary so
+                // the app at least launches, just with msger's identity.
+            }
+            return source;
+        }
+        // No source found — fall through to the legacy lookup below, which
+        // will return the package-bundled binary as a last resort.
+    }
+    // Default msger-itself path (or per-app fallback if findMsgerSource failed).
     const stableLink = path.join(userBinDir, `${baseName}${ext}`);
     if (fs.existsSync(stableLink))
         return stableLink;