@bobfrankston/msger 0.1.360 → 0.1.361

package/package.json

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

package/shower.js

@@ -362,42 +362,40 @@ function resolveBinaryPath() {
 }
 function createMessageBoxHandle(options) {
     const binaryPath = resolveBinaryPath();
-    // Declare variables that will be used outside the Promise
+    // Validate the binary up front and synchronously. Doing this inside the
+    // Promise executor used to leave `child` undefined when the binary was
+    // missing, then `new MessageBoxHandle(child, ...)` blew up on `child.pid`
+    // with a cryptic "cannot read properties of undefined" — masking the real
+    // "binary not found" message. Throw directly here so callers see the
+    // actual cause.
+    if (!fs.existsSync(binaryPath)) {
+        throw new Error(`msger native binary not found at: ${binaryPath}\n` +
+            `Platform: ${platform()} ${process.arch}. ` +
+            `If you just installed @bobfrankston/msger, the published package may be missing the binary for this platform.`);
+    }
+    if (platform() !== 'win32') {
+        try {
+            fs.accessSync(binaryPath, fs.constants.X_OK);
+        }
+        catch {
+            throw new Error(`msger native binary is not executable: ${binaryPath}\n` +
+                `Please run: chmod +x "${binaryPath}"`);
+        }
+    }
     const childEnv = { ...process.env };
     if ('NODE_OPTIONS' in childEnv) {
         delete childEnv.NODE_OPTIONS;
     }
-    let child;
+    // Spawn before constructing the Promise so `child` is guaranteed defined
+    // by the time we hand it to MessageBoxHandle.
+    const child = spawn(binaryPath, [], {
+        stdio: options.detach ? ['pipe', 'ignore', 'ignore'] : ['pipe', 'pipe', 'pipe'],
+        detached: options.detach || false,
+        env: childEnv
+    });
     let stdout = '';
     let stderr = '';
     const resultPromise = new Promise((resolve, reject) => {
-        // Check if binary exists
-        if (!fs.existsSync(binaryPath)) {
-            reject(new Error(`Binary not found: ${binaryPath}`));
-            return;
-        }
-        // On Unix systems, check if binary is executable
-        if (platform() !== 'win32') {
-            try {
-                fs.accessSync(binaryPath, fs.constants.X_OK);
-            }
-            catch (error) {
-                reject(new Error(`Binary is not executable: ${binaryPath}\n` +
-                    `Please run: sudo chmod +x ${binaryPath}`));
-                return;
-            }
-        }
-        // Spawn the Rust binary
-        // Spawn child with a sanitized environment. Electron will print
-        // warnings if NODE_OPTIONS is present in the environment of a
-        // packaged app. Remove NODE_OPTIONS to avoid that warning.
-        // When detached, use 'ignore' for stdout/stderr so parent can exit
-        // We only need stdin to send the options, not to receive results
-        child = spawn(binaryPath, [], {
-            stdio: options.detach ? ['pipe', 'ignore', 'ignore'] : ['pipe', 'pipe', 'pipe'],
-            detached: options.detach || false,
-            env: childEnv
-        });
         // If detached, unref the child so parent can exit
         if (options.detach) {
             child.unref();