@bobfrankston/msger 0.1.328 → 0.1.329

package/msger-native/builder/postinstall.js

@@ -65,7 +65,16 @@ if (fs.existsSync(buildBinary)) {
 }
 
 // Step 2: Create timestamped copy in the user bin dir (NOT node_modules)
-try { fs.mkdirSync(userBinDir, { recursive: true }); } catch { /* exists */ }
+try {
+    fs.mkdirSync(userBinDir, { recursive: true });
+} catch (e) {
+    // recursive:true normally makes this idempotent, so a real failure here
+    // means the path can't be created at all (permissions, disk full, etc.).
+    if (e.code !== "EEXIST") {
+        console.error(`  msger: could not create user bin dir ${userBinDir}: ${e.message}`);
+        throw e;
+    }
+}
 const stamp = Date.now();
 const versionedBinary = path.join(userBinDir, `${baseName}-${stamp}${ext}`);
 if (fs.existsSync(srcBinary)) {
@@ -78,44 +87,113 @@ if (fs.existsSync(srcBinary)) {
 
 // Step 2b: Create/update a stable-name hardlink so the launcher always uses
 // the same path. Taskbar pins and AUMID grouping depend on a fixed exe path.
-// Hardlink shares inode with the timestamped copy — deleting the old link
-// doesn't affect a running process (it holds its own file handle).
+//
+// Rename-aside pattern: Windows lets you rename a running exe's path but
+// refuses to delete it. So we rename the current stable link aside (to a
+// timestamped `.old-<ts>` name) before creating the new hardlink. This works
+// whether or not the old binary is currently executing — the retired name
+// keeps the running process's path valid; the stable slot is freed for the
+// new hardlink. Previously we tried unlink+link, which silently failed when
+// the stable name was locked, leaving users on a stale binary indefinitely.
 const stableLink = path.join(userBinDir, `${baseName}${ext}`);
+if (fs.existsSync(stableLink)) {
+    const retired = path.join(userBinDir, `${baseName}${ext}.old-${stamp}`);
+    try {
+        fs.renameSync(stableLink, retired);
+    } catch (e) {
+        console.error(`  msger: could not rename stable link aside: ${e.message}`);
+        console.error(`  msger: update cannot proceed — stable link ${stableLink} is in an unexpected state`);
+    }
+}
 try {
-    // Remove old link (may point to previous version)
-    try { fs.unlinkSync(stableLink); } catch { /* didn't exist */ }
     fs.linkSync(versionedBinary, stableLink);
 } catch (e) {
-    // Hardlink failed (cross-device, locked, etc.) — copy as fallback
-    try { fs.copyFileSync(versionedBinary, stableLink); } catch { /* */ }
+    // Hardlink failed (cross-device, weird FS). Copy as a fallback.
+    console.error(`  msger: hardlink ${stableLink} -> ${versionedBinary} failed (${e.message}); falling back to copy`);
+    try {
+        fs.copyFileSync(versionedBinary, stableLink);
+    } catch (e2) {
+        console.error(`  msger: copy fallback also failed: ${e2.message}`);
+        console.error(`  msger: launcher will fall back to timestamped copies; taskbar pins may not group.`);
+    }
+}
+
+// Step 2c: Clean up retired `.old-<ts>` copies from previous updates. A file
+// that's still locked by a not-yet-exited process stays behind and gets
+// retried on the NEXT update — that's expected, so an EBUSY/EPERM on unlink
+// isn't an error, but anything else is.
+const oldPattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}${ext.replace('.', '\\.')}\\.old-\\d+$`);
+try {
+    for (const f of fs.readdirSync(userBinDir)) {
+        if (!oldPattern.test(f)) continue;
+        const full = path.join(userBinDir, f);
+        try {
+            fs.unlinkSync(full);
+        } catch (e) {
+            if (e.code !== "EBUSY" && e.code !== "EPERM") {
+                console.error(`  msger: unexpected error cleaning up ${f}: ${e.message}`);
+            }
+            // else: expected — owning process still running, defer to next update
+        }
+    }
+} catch (e) {
+    console.error(`  msger: could not scan ${userBinDir} for retired copies: ${e.message}`);
 }
 
 // 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.
+// we just created). EBUSY/EPERM on a locked copy means the owning process is
+// still running — expected, retry on next update. Anything else is unexpected
+// and gets logged.
 const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
 try {
     for (const f of fs.readdirSync(userBinDir)) {
-        if (f.match(pattern) && f !== path.basename(versionedBinary)) {
-            try { fs.unlinkSync(path.join(userBinDir, f)); } catch { /* locked */ }
+        if (!f.match(pattern) || f === path.basename(versionedBinary)) continue;
+        const full = path.join(userBinDir, f);
+        try {
+            fs.unlinkSync(full);
+        } catch (e) {
+            if (e.code !== "EBUSY" && e.code !== "EPERM") {
+                console.error(`  msger: unexpected error cleaning up ${f}: ${e.message}`);
+            }
         }
     }
-} catch { /* user dir didn't exist or unreadable */ }
+} catch (e) {
+    console.error(`  msger: could not scan ${userBinDir} for stale timestamped copies: ${e.message}`);
+}
 
 // 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 */ }
+        if (!f.match(pattern)) continue;
+        const full = path.join(binDir, f);
+        try {
+            fs.unlinkSync(full);
+        } catch (e) {
+            if (e.code !== "EBUSY" && e.code !== "EPERM") {
+                console.error(`  msger: unexpected error cleaning up legacy ${f}: ${e.message}`);
+            }
         }
     }
-} catch { /* ignore */ }
+} catch (e) {
+    // binDir should always exist inside the package — if it doesn't, something
+    // is very wrong, but we can still let the install complete.
+    console.error(`  msger: could not scan ${binDir} for legacy timestamped copies: ${e.message}`);
+}
 
 // Step 4: Set permissions on Linux/Mac
 if (!isWindows) {
     for (const bin of [srcBinary, versionedBinary]) {
-        try { fs.chmodSync(bin, 0o755); } catch { /* */ }
+        try {
+            fs.chmodSync(bin, 0o755);
+        } catch (e) {
+            // ENOENT = we never created that file (bin wasn't present); any
+            // other error (EACCES, EROFS, etc.) means the binary will fail to
+            // launch later, which is user-visible — log loud.
+            if (e.code !== "ENOENT") {
+                console.error(`  msger: could not chmod ${bin}: ${e.message}`);
+            }
+        }
     }
 }

package/package.json

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