@bobfrankston/msger 0.1.319 → 0.1.321

package/msger-native/builder/postinstall.js

@@ -2,9 +2,14 @@
 /**
  * msger-native postinstall:
  * 1. Copy binary from target/release/ to bin/ (if newer — after cargo build)
- * 2. Create timestamped copy (so new installs don't conflict with running old version)
- * 3. Clean up old timestamped copies (skip if locked by running process)
+ * 2. Create timestamped copy in the PER-USER bin dir (not node_modules)
+ *    so the locked previous-version exe doesn't block npm's aside-dir cleanup
+ *    on upgrade — npm only manages the stable msgernative.exe in bin/.
+ * 3. Clean up old timestamped copies in the user dir (skip if locked)
  * 4. Set binary permissions on Linux/Mac
+ *
+ * NOTE: keep this in sync with `getUserBinDir()` in shower.ts — same path
+ * convention so the launcher finds what postinstall just wrote.
  */
 import fs from "fs";
 import path from "path";
@@ -32,6 +37,18 @@ if (isWindows) {
 const srcBinary = path.join(binDir, `${baseName}${ext}`);
 const buildBinary = path.join(nativeDir, "target", "release", `${baseName}${ext}`);
 
+function getUserBinDir() {
+    if (isWindows) {
+        const base = process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || ".", "AppData", "Local");
+        return path.join(base, "msger", "bin");
+    }
+    const xdg = process.env.XDG_DATA_HOME;
+    const base = xdg || path.join(process.env.HOME || ".", ".local", "share");
+    return path.join(base, "msger", "bin");
+}
+
+const userBinDir = getUserBinDir();
+
 // Step 1: Copy from target/release/ → bin/ if build output is newer
 if (fs.existsSync(buildBinary)) {
     const buildTime = fs.statSync(buildBinary).mtimeMs;
@@ -47,9 +64,10 @@ if (fs.existsSync(buildBinary)) {
     }
 }
 
-// Step 2: Create timestamped copy
+// Step 2: Create timestamped copy in the user bin dir (NOT node_modules)
+try { fs.mkdirSync(userBinDir, { recursive: true }); } catch { /* exists */ }
 const stamp = Date.now();
-const versionedBinary = path.join(binDir, `${baseName}-${stamp}${ext}`);
+const versionedBinary = path.join(userBinDir, `${baseName}-${stamp}${ext}`);
 if (fs.existsSync(srcBinary)) {
     try {
         fs.copyFileSync(srcBinary, versionedBinary);
@@ -58,12 +76,25 @@ if (fs.existsSync(srcBinary)) {
     }
 }
 
-// Step 3: Clean up old timestamped copies (keep the one we just created)
+// Step 3a: Clean up old timestamped copies in the user bin dir (keep the one
+// we just created). Locked copies are silently skipped — they get cleaned up
+// on the next install once their owning process has exited.
+const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
 try {
-    const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
-    for (const f of fs.readdirSync(binDir)) {
+    for (const f of fs.readdirSync(userBinDir)) {
         if (f.match(pattern) && f !== path.basename(versionedBinary)) {
-            try { fs.unlinkSync(path.join(binDir, f)); } catch { /* locked — cleaned up next time */ }
+            try { fs.unlinkSync(path.join(userBinDir, f)); } catch { /* locked */ }
+        }
+    }
+} catch { /* user dir didn't exist or unreadable */ }
+
+// Step 3b: Migrate-and-clean any stale timestamped copies still living inside
+// node_modules from older installs. They serve no purpose now and may be the
+// EPERM blocker on upgrade.
+try {
+    for (const f of fs.readdirSync(binDir)) {
+        if (f.match(pattern)) {
+            try { fs.unlinkSync(path.join(binDir, f)); } catch { /* locked */ }
         }
     }
 } catch { /* ignore */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/msger",
-  "version": "0.1.319",
+  "version": "0.1.321",
   "description": "Fast, lightweight, cross-platform message box - Rust-powered alternative to msgview",
   "type": "module",
   "main": "./index.js",
@@ -25,8 +25,7 @@
     "prerelease:local": "git add -A && (git diff-index --quiet HEAD || git commit -m \"Pre-release commit\")",
     "preversion": "npm run build:ts && npm run build:native && git add -A",
     "release": "npm run prerelease:local && npm version patch && npm publish --quiet",
-    "installer": "npm run release && node utils/install-latest.ts",
-    "postversion": "git push && git push --tags"
+    "installer": "npm run release && node utils/install-latest.ts"
   },
   "keywords": [
     "message-box",

package/shower.js

@@ -47,12 +47,31 @@ export function closeMessageBox(pid) {
  * @param options Message box configuration
  * @returns MessageBoxHandle with result promise
  */
-/** Resolve the native binary path — uses timestamped name (e.g., msgernative-1712345678901.exe)
- *  so a new version can be installed while the old one is still running. */
+/** Per-user bin dir for timestamped exe copies. Storing them OUTSIDE
+ *  node_modules avoids npm's EPERM cleanup warnings on upgrade — npm tries to
+ *  delete the previous package's `.msger-<rand>/` aside-dir but the running
+ *  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. */
+function getUserBinDir() {
+    const isWindows = platform() === 'win32';
+    if (isWindows) {
+        const base = process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || '.', 'AppData', 'Local');
+        return path.join(base, 'msger', 'bin');
+    }
+    const xdg = process.env.XDG_DATA_HOME;
+    const base = xdg || path.join(process.env.HOME || '.', '.local', 'share');
+    return path.join(base, 'msger', '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 resolveBinaryPath() {
     const isWindows = platform() === 'win32';
     const arch = process.arch;
-    const binDir = path.join(import.meta.dirname, 'msger-native', 'bin');
+    const pkgBinDir = path.join(import.meta.dirname, 'msger-native', 'bin');
+    const userBinDir = getUserBinDir();
     let baseName;
     let ext;
     if (isWindows) {
@@ -67,18 +86,29 @@ function resolveBinaryPath() {
         baseName = 'msgernative';
         ext = '';
     }
-    // Find the latest timestamped binary, fall back to unversioned
+    const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
+    // Prefer per-user timestamped copy
+    try {
+        const matches = fs.readdirSync(userBinDir)
+            .filter(f => pattern.test(f))
+            .sort()
+            .reverse();
+        if (matches.length > 0)
+            return path.join(userBinDir, matches[0]);
+    }
+    catch { /* user dir doesn't exist yet — fall through */ }
+    // Legacy: timestamped copies inside the package (older installs that ran
+    // the old postinstall). Still honored so a half-migrated tree keeps working.
     try {
-        const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
-        const matches = fs.readdirSync(binDir)
+        const matches = fs.readdirSync(pkgBinDir)
             .filter(f => pattern.test(f))
             .sort()
             .reverse();
         if (matches.length > 0)
-            return path.join(binDir, matches[0]);
+            return path.join(pkgBinDir, matches[0]);
     }
     catch { /* fall through */ }
-    return path.join(binDir, `${baseName}${ext}`);
+    return path.join(pkgBinDir, `${baseName}${ext}`);
 }
 function createMessageBoxHandle(options) {
     const binaryPath = resolveBinaryPath();