@bobfrankston/msger 0.1.421 → 0.1.423

package/README.md

@@ -80,9 +80,20 @@ msger -url "https://example.com" -detach
 # Fullscreen mode
 msger -fullscreen -url "https://example.com"
 
-# Multi-monitor (Windows only - show on second screen)
+# Multi-monitor - show on second screen
 msger -message "Second screen" -pos 0,100 -screen 1
 
+# What displays are there? (JSON, no window; indices match -screen)
+msger -list
+
+# Transparent click-through overlay on screen 1, gone after 3 seconds
+msger -overlay -fullscreen -screen 1 -timeout 3 "1"
+
+# Number every screen, the way the display settings "Identify" button does
+msger -list | ConvertFrom-Json | ForEach-Object { $_.monitors } | ForEach-Object {
+    Start-Process msger -ArgumentList "-overlay -fullscreen -screen $($_.index) -timeout 3 `"$($_.index + 1)`""
+}
+
 # Auto-close timeout
 msger -message "Closing in 5 seconds..." -timeout 5
 
@@ -239,6 +250,9 @@ msger -title "Test" -message "Saving config..." -save test.json
 | `autoSize` | boolean | true when no size | Auto-resize window to fit content |
 | `alwaysOnTop` | boolean | false | Keep window on top |
 | `fullscreen` | boolean | false | Start in fullscreen mode |
+| `screen` | number | null | Monitor index (0-based) for `fullscreen`, and the fallback for `pos.screen`. The portable way to target a display — Wayland refuses client-set window coordinates but honors fullscreen on a chosen output |
+| `overlay` | boolean | false | Frameless, transparent, click-through, always-on-top window drawn over the desktop, kept out of the taskbar and never taking focus. Pair with `timeout` — it has no close button and passes clicks through, so nothing in it can be operated. With `url`/`rawHtml` the page must set its own transparent background; the built-in template already does. Each overlay gets its own WebView2 profile (keyed by screen) so a set of them can start in parallel |
+| `listMonitors` | boolean | false | Print the monitor layout as JSON and exit without opening a window: `{"monitors":[{index,name,x,y,width,height,scale,primary}]}` |
 | `zoom` | number | 100 | Initial zoom level (100=100%, 150=150%). Applies in every mode — message, HTML and URL |
 | `newWindow` | string | `"browser"` | Where "open in new window" / `target=_blank` links go: `"browser"` (system browser) or `"msger"` (spawns another msger window) |
 | `contextMenu` | string | `"page"` | `"always"` forces the native right-click menu everywhere, even where the page suppresses it with its own `contextmenu` handler |
@@ -320,7 +334,9 @@ Options:
   -default, --default <text>      Default value for input field
   -size, --size <width,height>    Window size (e.g., -size 800,600)
   -pos, --pos <x,y>               Window position (e.g., -pos 100,200)
-  -screen, --screen <number>      [Windows only] Screen index (0=primary, 1=second, etc.)
+  -screen, --screen <number>      Screen index (0=primary, 1=second, etc.). Offsets -pos into
+                                  that screen, and picks which screen -fullscreen covers.
+  -list, --list                   Print the monitor layout as JSON and exit (no window)
   -zoom, --zoom <percent>         Zoom level as percentage (e.g., -zoom 150 for 150%).
                                   Works in message, HTML and URL modes alike.
   -newwindow, --newwindow <where> Where "open in new window" links go:
@@ -329,6 +345,9 @@ Options:
   -ontop, --ontop                 Keep window always on top
   -detach, --detach               Launch window independently (parent returns immediately)
   -fullscreen, --fullscreen       Start window in fullscreen mode (F11 to toggle, Escape to exit)
+  -overlay, --overlay             Frameless, transparent, click-through window over the desktop.
+                                  Always on top, no taskbar slot, never takes focus. Pair with
+                                  -timeout; combine with -fullscreen -screen <n> per display.
   -raw, --raw                     With -html: load HTML as-is, no msger template/buttons (alias: -full)
   -debug, --debug                 Return debug info (HTML, size, autoSize) in result
   -render, --render [file]        Render the page to a bitmap instead of displaying it.

package/cli.js

@@ -46,11 +46,21 @@ Options:
   -size <width,height>    Set window size (e.g., -size 800,600)
   -zoom <percent>         Set zoom level as percentage (e.g., -zoom 150 for 150%)
   -pos <x,y>              Set window position (e.g., -pos 100,200)
-  -screen <number>        [Windows only] Screen index for multi-monitor (0=primary, 1=second, etc.)
+  -screen <number>        Screen index for multi-monitor (0=primary, 1=second, etc.). Offsets
+                          -pos into that screen, and picks which screen -fullscreen covers.
+  -list                   Print the monitor layout as JSON and exit (no window). Indices
+                          match -screen: {"monitors":[{index,name,x,y,width,height,scale,primary}]}
   -icon <path>            Set window icon (PNG file). Default: icon.png in current directory
   -timeout <seconds>      Auto-close after specified seconds
   -detach                 Leave window open after app exits (parent process returns immediately)
   -fullscreen             Start window in fullscreen mode (F11 to toggle, Escape to exit)
+  -overlay                Frameless, transparent, click-through window drawn over the
+                          desktop. Always on top, no taskbar slot, never takes focus.
+                          Pair with -timeout: it has no close button and passes clicks
+                          through, so the timeout is how it goes away. Combine with
+                          -fullscreen -screen <n> to cover one display, e.g.
+                            msger -overlay -fullscreen -screen 1 -timeout 3 "2"
+                          With -url/-raw the page must set its own transparent background.
   -no-escape-closes       Prevent Escape key from closing window (still exits fullscreen)
   -reset                  Clear localStorage on startup (useful for resetting web content state)
   -ontop                  Keep window always on top of other windows

package/msger-native/builder/postinstall.js

@@ -54,18 +54,48 @@ function getUserBinDir() {
 
 const userBinDir = getUserBinDir();
 
-// Step 1: Copy from target/release/ → bin/ if build output is newer
+// Step 1: Copy from target/release/ → bin/ if build output is newer.
+//
+// A plain copy here fails whenever a msger window is running from bin/ —
+// Windows refuses to overwrite a running exe — and the old behavior was to
+// shrug and keep shipping the STALE binary, which is how a fresh build can
+// silently not reach the package. Use the same rename-aside trick step 2b
+// uses: renaming a running exe is permitted, so retire the locked file and
+// drop the new one into the freed path. The running process keeps executing
+// from the retired name.
+//
+// Retired copies go to msger-native/.old/ rather than beside the binary,
+// because package.json ships `msger-native/bin/` — an `.old-*` file left in
+// bin/ would be published as a stray multi-MB binary. Same volume, so the
+// rename stays a rename (a cross-device move degrades to copy+delete, which
+// is exactly what a running exe forbids).
 if (fs.existsSync(buildBinary)) {
     const buildTime = fs.statSync(buildBinary).mtimeMs;
     const srcTime = fs.existsSync(srcBinary) ? fs.statSync(srcBinary).mtimeMs : 0;
     if (buildTime > srcTime) {
+        const retireDir = path.join(nativeDir, ".old");
         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`);
+            try {
+                fs.mkdirSync(retireDir, { recursive: true });
+                const retired = path.join(retireDir, `${baseName}${ext}.old-${Date.now()}`);
+                fs.renameSync(srcBinary, retired);
+                fs.copyFileSync(buildBinary, srcBinary);
+                console.log(`  msger: updated ${baseName}${ext} from build (retired the running copy aside)`);
+            } catch (e2) {
+                console.error(`  msger: could not update ${baseName}${ext}: ${e2.message}`);
+                console.error(`  msger: the package would ship a STALE binary — close any running msger and rebuild.`);
+            }
         }
+        // Sweep retired copies whose process has since exited. Still-locked
+        // ones stay for the next run; that's expected, not an error.
+        try {
+            for (const f of fs.readdirSync(retireDir)) {
+                try { fs.unlinkSync(path.join(retireDir, f)); } catch { /* still running */ }
+            }
+        } catch { /* no retire dir — nothing was ever locked */ }
     }
 }
 

package/package.json

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

package/prep-mac-source.js

@@ -9,6 +9,13 @@
  *
  * Excludes `target/` (build output, gigabytes), `pibuild/` (Pi-specific),
  * and the existing `bin/` (Linux/Windows binaries — Mac doesn't need them).
+ *
+ * EXCEPT the image assets in `bin/`: `main.rs` pulls `../bin/msger.png` in with
+ * `include_bytes!`, so it is a compile-time input, not build output. Skipping
+ * the whole of `bin/` silently broke the Mac build the moment that include
+ * landed ("couldn't read `src/../bin/msger.png`"), which is why Mac binaries
+ * went stale. The binaries themselves are still excluded — only the small
+ * icon files come across.
  */
 import fs from "fs";
 import path from "path";
@@ -55,6 +62,28 @@ function copyDir(src, dst) {
 
 copyDir(srcDir, dstDir);
 
+// bin/ is skipped wholesale above (it holds tens of MB of other platforms'
+// binaries), but the icon assets in it are `include_bytes!` inputs the Rust
+// build needs. Copy just those.
+const binSrc = path.join(srcDir, "bin");
+const binDst = path.join(dstDir, "bin");
+if (fs.existsSync(binSrc)) {
+    fs.mkdirSync(binDst, { recursive: true });
+    for (const name of fs.readdirSync(binSrc)) {
+        if (!/\.(png|ico)$/i.test(name)) continue;
+        const s = path.join(binSrc, name);
+        const d = path.join(binDst, name);
+        if (!fs.statSync(s).isFile()) continue;
+        const dMtime = fs.existsSync(d) ? fs.statSync(d).mtimeMs : 0;
+        if (dMtime >= fs.statSync(s).mtimeMs) {
+            skipped++;
+            continue;
+        }
+        fs.copyFileSync(s, d);
+        copied++;
+    }
+}
+
 console.log(`  msger: prep:mac — ${copied} file(s) copied, ${skipped} unchanged`);
 console.log(`  msger: source staged at mac/msger-native/. OneDrive will sync to the Mac;`);
 console.log(`  msger: then run \`./build-mac.sh\` from the OneDrive folder on the Mac.`);

package/shower.d.ts

@@ -23,8 +23,11 @@ export interface MessageBoxOptions {
     pos?: {
         x: number; /** Window X position in pixels */
         y: number; /** Window Y position in pixels */
-        screen?: number; /** Optional screen index (0-based, Windows only) - NOT used by Rust binary */
+        screen?: number; /** Optional screen index (0-based). Offsets x/y into that monitor. Was Windows-only; now applied on Mac and X11 too. Wayland ignores client-set window positions entirely — use `fullscreen` + `screen` there. */
     };
+    screen?: number; /** Monitor index (0-based) for `fullscreen`, and the fallback for `pos.screen`. The portable way to target a display: Wayland refuses client-set coordinates but honors fullscreen-on-a-given-output. */
+    overlay?: boolean; /** Frameless, transparent, click-through, always-on-top window drawn over the desktop — transient notices, e.g. per-monitor identification. Combine with `fullscreen` + `screen` to cover one display and `timeout` to dismiss it; an overlay has no close button and passes clicks through, so nothing in it can be operated. With `url` / `rawHtml` the page must set its own transparent background (the built-in template already does). */
+    listMonitors?: boolean; /** Print the monitor layout as JSON (`{monitors:[{index,name,x,y,width,height,scale,primary}]}`) and exit without opening a window. Indices match `screen`. */
     zoom?: number; /** Initial zoom level as percentage (100=100%, 150=150%, 50=50%, etc.) */
     autoSize?: boolean; /** Automatically resize window to fit content (default: false) */
     alwaysOnTop?: boolean; /** Keep window on top of other windows (default: false) */

package/shower.js

@@ -637,9 +637,12 @@ function createMessageBoxHandle(options) {
         });
         // Send options to stdin
         try {
-            // If autoSize is not explicitly set, enable it when no size is specified
+            // If autoSize is not explicitly set, enable it when no size is specified.
+            // Not for overlays: auto-sizing shrinks the window to its content,
+            // which for a full-screen overlay collapses the very area it is
+            // meant to cover. The caller's geometry (or fullscreen) wins there.
             const optionsToSend = { ...options };
-            if (optionsToSend.autoSize === undefined && !optionsToSend.size) {
+            if (optionsToSend.autoSize === undefined && !optionsToSend.size && !optionsToSend.overlay) {
                 optionsToSend.autoSize = true;
             }
             // Render mode: Rust wants a bare boolean plus a format string; the