@bobfrankston/msger 0.1.198 → 0.1.200

package/msger-native/builder/postinstall.js

@@ -1,34 +1,76 @@
 #!/usr/bin/env node
 /**
- * msger-native postinstall — set binary permissions on Linux/Mac.
- * Uses @bobfrankston/rust-builder if available, falls back to direct chmod.
+ * 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)
+ * 4. Set binary permissions on Linux/Mac
  */
+import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const binDir = path.join(__dirname, "..", "bin");
+const nativeDir = path.join(__dirname, "..");
+const binDir = path.join(nativeDir, "bin");
 
-const binaries = {
-    win32: "msgernative.exe",
-    darwin: "msgernative",
-    darwinArm64: "msgernative-arm64",
-    linux: "msgernative",
-    linuxArm64: "msgernative-linux-aarch64",
-};
+const isWindows = process.platform === "win32";
+const arch = process.arch;
 
+let baseName, ext;
+if (isWindows) {
+    baseName = "msgernative";
+    ext = ".exe";
+} else if (process.platform === "darwin") {
+    baseName = arch === "arm64" ? "msgernative-arm64" : "msgernative";
+    ext = "";
+} else {
+    baseName = arch === "arm64" ? "msgernative-linux-aarch64" : "msgernative";
+    ext = "";
+}
+
+const srcBinary = path.join(binDir, `${baseName}${ext}`);
+const buildBinary = path.join(nativeDir, "target", "release", `${baseName}${ext}`);
+
+// Step 1: Copy from target/release/ → bin/ if build output is newer
+if (fs.existsSync(buildBinary)) {
+    const buildTime = fs.statSync(buildBinary).mtimeMs;
+    const srcTime = fs.existsSync(srcBinary) ? fs.statSync(srcBinary).mtimeMs : 0;
+    if (buildTime > srcTime) {
+        try {
+            fs.copyFileSync(buildBinary, srcBinary);
+            console.log(`  msger: updated ${baseName}${ext} from build`);
+        } catch (e) {
+            // Source might be locked by running process — that's OK, timestamped copy will use what we have
+            console.log(`  msger: could not update ${baseName}${ext} (locked?) — using existing`);
+        }
+    }
+}
+
+// Step 2: Create timestamped copy
+const stamp = Date.now();
+const versionedBinary = path.join(binDir, `${baseName}-${stamp}${ext}`);
+if (fs.existsSync(srcBinary)) {
+    try {
+        fs.copyFileSync(srcBinary, versionedBinary);
+    } catch (e) {
+        console.error(`  msger: failed to create versioned binary: ${e.message}`);
+    }
+}
+
+// Step 3: Clean up old timestamped copies (keep the one we just created)
 try {
-    const { runPostinstall } = await import("@bobfrankston/rust-builder/postinstall");
-    runPostinstall({ binaryName: "msgernative", binDir, binaries });
-} catch {
-    // rust-builder not available (npm consumer install) — do chmod directly
-    if (process.platform !== "win32") {
-        const fs = await import("fs");
-        const arch = process.arch;
-        const name = process.platform === "darwin"
-            ? (arch === "arm64" ? binaries.darwinArm64 : binaries.darwin)
-            : (arch === "arm64" ? binaries.linuxArm64 : binaries.linux);
-        const bin = path.join(binDir, name);
-        try { fs.chmodSync(bin, 0o755); } catch { /* binary may not exist yet */ }
+    const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
+    for (const f of fs.readdirSync(binDir)) {
+        if (f.match(pattern) && f !== path.basename(versionedBinary)) {
+            try { fs.unlinkSync(path.join(binDir, f)); } catch { /* locked — cleaned up next time */ }
+        }
+    }
+} catch { /* ignore */ }
+
+// Step 4: Set permissions on Linux/Mac
+if (!isWindows) {
+    for (const bin of [srcBinary, versionedBinary]) {
+        try { fs.chmodSync(bin, 0o755); } catch { /* */ }
     }
 }

package/package.json

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

package/shower.d.ts

@@ -41,8 +41,10 @@ export interface MessageBoxOptions {
     debug?: boolean; /** Return debug information (HTML, size) in result (default: false) */
     showVersion?: boolean; /** Show version in window title (default: false) */
     appUserModelId?: string; /** Windows AppUserModelID for taskbar pinning (internal use) */
-    initScript?: string; /** Custom JS injected into WebView alongside msger-api.js */
+    initScript?: string; /** Custom JS injected into WebView alongside msger-api.js (inline) */
+    initScriptPath?: string; /** Path to JS file injected into WebView (avoids large JSON) */
     service?: boolean; /** Service mode: bidirectional IPC with parent. Stdin/stdout stay open. */
+    contentDir?: string; /** Base directory for custom protocol file serving (avoids file:// URLs) */
 }
 export interface MessageBoxResult {
     button: string;

package/shower.js

@@ -47,21 +47,41 @@ export function closeMessageBox(pid) {
  * @param options Message box configuration
  * @returns MessageBoxHandle with result promise
  */
-function createMessageBoxHandle(options) {
+/** 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. */
+function resolveBinaryPath() {
     const isWindows = platform() === 'win32';
     const arch = process.arch;
-    // Determine the binary name based on platform and architecture
-    let binaryName;
+    const binDir = path.join(import.meta.dirname, 'msger-native', 'bin');
+    let baseName;
+    let ext;
     if (isWindows) {
-        binaryName = 'msgernative.exe';
+        baseName = 'msgernative';
+        ext = '.exe';
     }
     else if (arch === 'arm64') {
-        binaryName = 'msgernative-linux-aarch64';
+        baseName = 'msgernative-linux-aarch64';
+        ext = '';
     }
     else {
-        binaryName = 'msgernative';
+        baseName = 'msgernative';
+        ext = '';
+    }
+    // Find the latest timestamped binary, fall back to unversioned
+    try {
+        const pattern = new RegExp(`^${baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)${ext.replace('.', '\\.')}$`);
+        const matches = fs.readdirSync(binDir)
+            .filter(f => pattern.test(f))
+            .sort()
+            .reverse();
+        if (matches.length > 0)
+            return path.join(binDir, matches[0]);
     }
-    const binaryPath = path.join(import.meta.dirname, 'msger-native', 'bin', binaryName);
+    catch { /* fall through */ }
+    return path.join(binDir, `${baseName}${ext}`);
+}
+function createMessageBoxHandle(options) {
+    const binaryPath = resolveBinaryPath();
     // Declare variables that will be used outside the Promise
     const childEnv = { ...process.env };
     if ('NODE_OPTIONS' in childEnv) {
@@ -77,7 +97,7 @@ function createMessageBoxHandle(options) {
             return;
         }
         // On Unix systems, check if binary is executable
-        if (!isWindows) {
+        if (platform() !== 'win32') {
             try {
                 fs.accessSync(binaryPath, fs.constants.X_OK);
             }
@@ -316,16 +336,7 @@ export class ServiceHandle {
  */
 export function showService(options) {
     const serviceOptions = { ...options, service: true, detach: false };
-    const isWindows = platform() === "win32";
-    const arch = process.arch;
-    let binaryName;
-    if (isWindows)
-        binaryName = "msgernative.exe";
-    else if (arch === "arm64")
-        binaryName = "msgernative-linux-aarch64";
-    else
-        binaryName = "msgernative";
-    const binaryPath = path.join(import.meta.dirname, "msger-native", "bin", binaryName);
+    const binaryPath = resolveBinaryPath();
     const childEnv = { ...process.env };
     if ("NODE_OPTIONS" in childEnv)
         delete childEnv.NODE_OPTIONS;
@@ -345,14 +356,20 @@ export function showService(options) {
         rustOptions.height = rustOptions.size.height;
         delete rustOptions.size;
     }
-    // Convert local paths to file:// URLs (same as createMessageBoxHandle)
-    if (rustOptions.url && !rustOptions.url.startsWith("http://") && !rustOptions.url.startsWith("https://") && !rustOptions.url.startsWith("file://")) {
+    // Convert local paths to file:// URLs when no custom protocol (contentDir) is used
+    if (!rustOptions.contentDir && rustOptions.url && !rustOptions.url.startsWith("http://") && !rustOptions.url.startsWith("https://") && !rustOptions.url.startsWith("file://")) {
         const absolutePath = path.resolve(rustOptions.url);
         if (!fs.existsSync(absolutePath)) {
             throw new Error(`File not found: ${absolutePath}`);
         }
         rustOptions.url = pathToFileURL(absolutePath).href;
     }
-    child.stdin?.write(JSON.stringify(rustOptions) + "\n");
+    // Resolve contentDir to absolute path
+    if (rustOptions.contentDir) {
+        rustOptions.contentDir = path.resolve(rustOptions.contentDir);
+    }
+    const jsonToSend = JSON.stringify(rustOptions);
+    console.error(`[service] Sending to Rust: ${jsonToSend.slice(0, 200)}`);
+    child.stdin?.write(jsonToSend + "\n");
     return new ServiceHandle(child);
 }