@bobfrankston/msger 0.1.79 → 0.1.80

package/README.md

@@ -512,98 +512,23 @@ Notes:
   - Runtime zoom: Ctrl+Wheel, Ctrl+Plus, Ctrl+Minus
 ```
 
-## Current Status & Known Issues (v0.1.74)
-
-### What Works ✅
-
-**Template Mode** (using `-message`, `-html`, `-htmlfrom`):
-- ✅ OK/Cancel buttons work perfectly
-- ✅ Button results returned to parent process via IPC
-- ✅ Custom buttons, input fields, forms all work
-- ✅ Native browser localStorage (recommended - works everywhere)
-- ✅ IPC communication functional
-
-**URL Mode** (using `-url`):
-- ✅ Direct webpage loading
-- ✅ PWA support (Service Workers, IndexedDB, Cache API)
-- ✅ Full web functionality
-- ✅ Native browser APIs work perfectly
-
-**General Features:**
-- ✅ Fast native window creation (~50-200ms)
-- ✅ Isolated storage (%LOCALAPPDATA%\msger\webview2\)
-- ✅ F11 HTML5 fullscreen (content fullscreen, not native window)
-- ✅ `-fullscreen` CLI flag for native window fullscreen
-- ✅ DevTools (press F12)
-- ✅ Esc key to close windows
-- ✅ Auto-close with `-timeout`
-- ✅ Detached mode with `-detach`
+## Important Notes
 
-### msger JavaScript API
-
-**Minimal API** - Most functionality uses native browser APIs:
-- `msger.isAvailable()` - Feature detection (returns true in msger)
-- `msger.close()` - Same as `window.close()` (native API preferred)
-- **localStorage functions** - Optional convenience wrappers (native localStorage recommended)
-
-**Recommendation:** Use native browser APIs (`localStorage`, `window.close()`) for compatibility. Code will work in any browser context, not just msger.
-
-### Known Limitations ❌
-
-**URL Mode IPC (wry 0.47.2 bug):**
-- ❌ All IPC calls crash in `-url` mode with injected scripts
-- ❌ No window control buttons work in URL mode
-- **Workaround:** Use template mode (`-htmlfrom` instead of `-url`) if you need buttons
-
-**F11 Fullscreen:**
-- ❌ F11 triggers HTML5 fullscreen (content only), not native window fullscreen
-- ❌ WebView2 captures F11 before Rust window handler
-- **Workaround:** Use `-fullscreen` CLI flag for native fullscreen
-
-**-dev Flag:**
-- ❌ Can't auto-open DevTools (wry 0.47.2 doesn't expose open_devtools() method)
-- **Workaround:** Press F12 manually (DevTools always enabled)
-
-**-htmlfrom with External Resources:**
-- ⚠️ External CSS/JS/images may be blocked by CSP when embedding HTML
-- **Workaround:** Use `-url` for pages with external resources, or use self-contained HTML
-
-### Mode Comparison
-
-| Feature | `-message/-html` | `-htmlfrom` | `-url` |
-|---------|------------------|-------------|--------|
-| OK/Cancel buttons | ✅ | ✅ | ❌ |
-| Button results via IPC | ✅ | ✅ | ❌ (crashes) |
-| Native localStorage | ✅ | ✅ | ✅ |
-| Native window.close() | ✅ | ✅ | ✅ |
-| External resources | N/A | ⚠️ CSP blocks | ✅ |
-| PWA features | Limited | Limited | ✅ |
-| msger API needed? | No (native APIs work) | No (native APIs work) | No (IPC broken) |
-| Use case | Simple dialogs | Embedded HTML | Full web pages |
-
-### Security Note
+### Security
 
 ⚠️ **msger is designed for displaying trusted, friendly content** (local apps, your HTML files). It is NOT a secure sandbox for untrusted/hostile web content. Use `-htmlfrom` and `-url` with trusted sources only.
 
-### Future Improvements
+### Technical Details & Known Issues
 
-1. **File System API** - Native file access for platform apps
-   - **File dialogs** (always safe): `msger.selectFile()`, `msger.selectFiles()`, `msger.saveFileAs()`, `msger.selectFolder()`
-   - **Direct path access** (requires `--allowFs` flag): `msger.fs.read(path)`, `msger.fs.write(path, content)`, `msger.fs.list(path)`, etc.
-   - Returns actual file paths (better than `<input type="file">`)
-   - Possible in template mode using bidirectional IPC (same mechanism as button clicks)
-   - See SESSION-NOTES.md for full implementation approach
+For detailed technical information, known limitations, current status, and planned features, see [TODO.md](TODO.md).
 
-2. **Window Manipulation APIs** - Runtime window control in template mode
-   - `msger.setSize()`, `msger.setPosition()`, `msger.setTitle()`, etc.
-   - IPC works in template mode, these were disabled prematurely
-   - Can be re-enabled with bidirectional IPC pattern
+### msger JavaScript API
 
-3. **Periodic wry updates** - Check if URL mode IPC bug fixed in newer versions
-   - Would enable file/window APIs in URL mode too
-   - Currently works only in template mode
+**Minimal API** - Most functionality uses native browser APIs:
+- `msger.isAvailable()` - Feature detection (returns true in msger)
+- `msger.close()` - Same as `window.close()` (native API preferred)
 
-4. Cross-compile support for Raspberry Pi on Windows
+**Recommendation:** Use native browser APIs (`localStorage`, `window.close()`) for compatibility. Code will work in any browser context, not just msger.
 
 ## License
 

package/TODO.md

@@ -261,6 +261,20 @@ None currently known!
 
 ## Completed ✅
 
+- ✅ JSON configuration file support (2025-11-11)
+  - Load from file: `msgernative config.json` or `-json config.json`
+  - CLI arguments override JSON values
+  - Pure CLI mode works without JSON
+  - Added `clap` crate for argument parsing
+- ✅ Windows system menu integration (2025-11-11)
+  - "About (Window Info)" entry in system menu
+  - Shows window position, size, DPI scaling details
+  - Uses Windows API (GetSystemMenu, AppendMenuW)
+  - Window subclassing for WM_SYSCOMMAND handling
+- ✅ Code refactoring (2025-11-11)
+  - Extracted JavaScript API to msger-api.js
+  - Uses include_str! for compile-time embedding
+  - Cleaner separation of concerns
 - ✅ Multi-monitor positioning fix - Rust side (2025-11-06)
 - ✅ Multi-monitor positioning fix - CLI parsing bug (2025-11-06)
   - Fixed: `-pos 10,10,1` now correctly parses third parameter as screen number

package/msger-native/Cargo.toml

@@ -9,6 +9,7 @@ tao = "0.30"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 image = "0.24"
+clap = { version = "4.5", features = ["derive"] }
 
 [target.'cfg(windows)'.dependencies]
 windows = { version = "0.58", features = ["Win32_UI_WindowsAndMessaging", "Win32_Foundation", "Win32_UI_Shell"] }

package/msger-native/README.md

@@ -12,7 +12,7 @@ This is a native implementation alternative to `@bobfrankston/msgview` (Electron
 
 ```
 Node.js (msgview CLI)
-    ↓ spawns with JSON input via stdin
+    ↓ spawns with JSON input via stdin OR JSON file + CLI args
 Rust msger executable
     ↓ creates native window with webview
     ↓ displays HTML message with buttons
@@ -21,24 +21,93 @@ Rust msger executable
 Node.js reads and returns result
 ```
 
+## Usage Modes
+
+### 1. Stdin (Original)
+```bash
+echo '{"message":"Hello"}' | msgernative
+```
+
+### 2. JSON File
+```bash
+msgernative config.json
+# or
+msgernative -json config.json
+```
+
+### 3. JSON File + CLI Overrides
+```bash
+msgernative config.json --title "New Title" --width 800
+```
+
+### 4. Pure CLI (No JSON)
+```bash
+msgernative --message "Hello World" --buttons "OK,Cancel"
+```
+
 ## API Compatibility
 
 This implementation is 100% compatible with `@bobfrankston/msgview` API:
 
-### MessageBoxOptions (input via stdin)
+### MessageBoxOptions (Complete Structure)
 ```json
 {
-    "title": "Message",
+    "title": "Window Title",
     "message": "Plain text message",
     "html": "<p>Optional HTML content</p>",
+    "url": "https://example.com",
     "width": 600,
     "height": 400,
+    "pos": {
+        "x": 100,
+        "y": 100,
+        "screen": 0
+    },
     "buttons": ["Cancel", "OK"],
     "defaultValue": "default input",
-    "allowInput": false
+    "inputPlaceholder": "Enter text...",
+    "allowInput": false,
+    "timeout": 30,
+    "autoSize": false,
+    "alwaysOnTop": false,
+    "fullscreen": false,
+    "zoomPercent": 100,
+    "debug": false,
+    "icon": "path/to/icon.png",
+    "dev": false
 }
 ```
 
+### Command-Line Arguments
+
+All JSON options can be overridden via command-line:
+
+```
+OPTIONS:
+    -j, --json <FILE>              JSON file to load defaults from
+        --title <TITLE>            Window title
+        --message <MESSAGE>        Plain text message
+        --html <HTML>              HTML content
+        --url <URL>                URL to load
+        --width <WIDTH>            Window width
+        --height <HEIGHT>          Window height
+        --x <X>                    Window X position
+        --y <Y>                    Window Y position
+        --screen <SCREEN>          Screen number (multi-monitor)
+        --buttons <BUTTONS>...     Button labels (comma-separated)
+        --default-value <VALUE>    Default input value
+        --input-placeholder <TEXT> Input placeholder
+        --allow-input              Allow text input
+        --timeout <SECONDS>        Auto-close timeout
+        --auto-size                Auto-size window to content
+        --always-on-top            Keep window on top
+        --fullscreen               Start in fullscreen
+        --zoom-percent <PERCENT>   Zoom level
+        --debug                    Enable debug mode
+        --icon <PATH>              Window icon path
+        --dev                      Enable developer mode
+```
+
 ### MessageBoxResult (output to stdout)
 ```json
 {
@@ -148,11 +217,21 @@ if (existsSync(nativeBinary)) {
 
 - ✅ Cross-platform native webview
 - ✅ Full HTML/CSS support
+- ✅ URL loading support
 - ✅ Customizable buttons
 - ✅ Input field support
-- ✅ Keyboard shortcuts (Enter, Escape)
+- ✅ Keyboard shortcuts (Enter, Escape, F11)
 - ✅ Window close detection
 - ✅ JSON stdin/stdout communication
+- ✅ JSON file configuration support
+- ✅ Command-line argument overrides
+- ✅ Multi-monitor positioning
+- ✅ Window icon support
+- ✅ Auto-size and fullscreen modes
+- ✅ Timeout support
+- ✅ System menu integration (Windows)
+  - About dialog showing window info
+  - Position, size, DPI scaling details
 - ✅ Small binary size (~2-5MB)
 - ✅ Fast startup (~50-200ms)
 

package/msger-native/example-config.json

@@ -0,0 +1,20 @@
+{
+    "title": "Example Message Box",
+    "message": "This is a sample message box configuration.\n\nYou can override any of these settings via command-line arguments.",
+    "width": 600,
+    "height": 400,
+    "pos": {
+        "x": 100,
+        "y": 100,
+        "screen": 0
+    },
+    "buttons": [
+        "Cancel",
+        "OK"
+    ],
+    "allowInput": false,
+    "alwaysOnTop": false,
+    "autoSize": false,
+    "fullscreen": false,
+    "zoomPercent": 100
+}

package/msger-native/src/main.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::io::{self, Read};
+use std::fs;
 use tao::{
     event::{Event, WindowEvent, ElementState, KeyEvent},
     event_loop::{ControlFlow, EventLoop},
@@ -8,6 +9,7 @@ use tao::{
     platform::windows::WindowExtWindows,
 };
 use wry::{WebViewBuilder, WebContext};
+use clap::Parser;
 
 #[cfg(windows)]
 use windows::Win32::UI::WindowsAndMessaging::{
@@ -56,6 +58,104 @@ unsafe extern "system" fn subclass_proc(
 // JavaScript API to inject into webviews
 const MSGER_JS_API: &str = include_str!("msger-api.js");
 
+/// Message box application with webview support
+#[derive(Parser, Debug)]
+#[command(name = "msgernative")]
+#[command(about = "Display message boxes with HTML/URL content", long_about = None)]
+struct Cli {
+    /// JSON file to load default options from
+    #[arg(short, long, value_name = "FILE")]
+    json: Option<String>,
+
+    /// Window title
+    #[arg(long)]
+    title: Option<String>,
+
+    /// Plain text message to display
+    #[arg(long)]
+    message: Option<String>,
+
+    /// HTML content to display
+    #[arg(long)]
+    html: Option<String>,
+
+    /// URL to load
+    #[arg(long)]
+    url: Option<String>,
+
+    /// Window width
+    #[arg(long)]
+    width: Option<i32>,
+
+    /// Window height
+    #[arg(long)]
+    height: Option<i32>,
+
+    /// Window X position
+    #[arg(long)]
+    x: Option<i32>,
+
+    /// Window Y position
+    #[arg(long)]
+    y: Option<i32>,
+
+    /// Screen number (for multi-monitor setups)
+    #[arg(long)]
+    screen: Option<i32>,
+
+    /// Button labels (comma-separated)
+    #[arg(long, value_delimiter = ',')]
+    buttons: Option<Vec<String>>,
+
+    /// Default input value
+    #[arg(long)]
+    default_value: Option<String>,
+
+    /// Input placeholder text
+    #[arg(long)]
+    input_placeholder: Option<String>,
+
+    /// Allow text input
+    #[arg(long)]
+    allow_input: bool,
+
+    /// Timeout in seconds
+    #[arg(long)]
+    timeout: Option<u64>,
+
+    /// Auto-size window to content
+    #[arg(long)]
+    auto_size: bool,
+
+    /// Keep window always on top
+    #[arg(long)]
+    always_on_top: bool,
+
+    /// Start in fullscreen mode
+    #[arg(long)]
+    fullscreen: bool,
+
+    /// Zoom percentage
+    #[arg(long)]
+    zoom_percent: Option<f64>,
+
+    /// Enable debug mode
+    #[arg(long)]
+    debug: bool,
+
+    /// Path to window icon
+    #[arg(long)]
+    icon: Option<String>,
+
+    /// Enable developer mode
+    #[arg(long)]
+    dev: bool,
+
+    /// Positional argument (if ends with .json, treated as JSON file)
+    #[arg(value_name = "FILE_OR_JSON")]
+    file: Option<String>,
+}
+
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 struct Position {
@@ -240,15 +340,135 @@ fn escape_html(s: &str) -> String {
         .replace('\'', "&#39;")
 }
 
+fn load_options_from_json(json_str: &str) -> Result<MessageBoxOptions, serde_json::Error> {
+    serde_json::from_str(json_str)
+}
+
+fn merge_cli_with_options(cli: &Cli, mut options: MessageBoxOptions) -> MessageBoxOptions {
+    // Override with CLI arguments if provided
+    if let Some(ref title) = cli.title {
+        options.title = title.clone();
+    }
+    if let Some(ref message) = cli.message {
+        options.message = Some(message.clone());
+    }
+    if let Some(ref html) = cli.html {
+        options.html = Some(html.clone());
+    }
+    if let Some(ref url) = cli.url {
+        options.url = Some(url.clone());
+    }
+    if let Some(width) = cli.width {
+        options.width = width;
+    }
+    if let Some(height) = cli.height {
+        options.height = height;
+    }
+
+    // Handle position
+    if cli.x.is_some() || cli.y.is_some() || cli.screen.is_some() {
+        let existing_pos = options.pos.take().unwrap_or(Position {
+            x: 0,
+            y: 0,
+            screen: None,
+        });
+        options.pos = Some(Position {
+            x: cli.x.unwrap_or(existing_pos.x),
+            y: cli.y.unwrap_or(existing_pos.y),
+            screen: cli.screen.or(existing_pos.screen),
+        });
+    }
+
+    if let Some(ref buttons) = cli.buttons {
+        options.buttons = buttons.clone();
+    }
+    if let Some(ref default_value) = cli.default_value {
+        options.default_value = Some(default_value.clone());
+    }
+    if let Some(ref input_placeholder) = cli.input_placeholder {
+        options.input_placeholder = Some(input_placeholder.clone());
+    }
+    if cli.allow_input {
+        options.allow_input = true;
+    }
+    if let Some(timeout) = cli.timeout {
+        options.timeout = Some(timeout);
+    }
+    if cli.auto_size {
+        options.auto_size = true;
+    }
+    if cli.always_on_top {
+        options.always_on_top = true;
+    }
+    if cli.fullscreen {
+        options.fullscreen = true;
+    }
+    if let Some(zoom_percent) = cli.zoom_percent {
+        options.zoom_percent = Some(zoom_percent);
+    }
+    if cli.debug {
+        options.debug = true;
+    }
+    if let Some(ref icon) = cli.icon {
+        options.icon = Some(icon.clone());
+    }
+    if cli.dev {
+        options.dev = true;
+    }
+
+    options
+}
+
 fn main() {
-    // Read JSON from stdin
-    let mut input = String::new();
-    io::stdin()
-        .read_to_string(&mut input)
-        .expect("Failed to read stdin");
-
-    let options: MessageBoxOptions =
-        serde_json::from_str(&input).expect("Failed to parse JSON input");
+    // Parse command-line arguments
+    let cli = Cli::parse();
+
+    // Determine JSON source and load options
+    let options = if let Some(ref json_file) = cli.json {
+        // Explicit -json flag
+        let json_str = fs::read_to_string(json_file)
+            .unwrap_or_else(|e| panic!("Failed to read JSON file '{}': {}", json_file, e));
+        let base_options = load_options_from_json(&json_str)
+            .expect("Failed to parse JSON input");
+        merge_cli_with_options(&cli, base_options)
+    } else if let Some(ref file) = cli.file {
+        // First positional argument - check if it's a .json file
+        if file.ends_with(".json") {
+            let json_str = fs::read_to_string(file)
+                .unwrap_or_else(|e| panic!("Failed to read JSON file '{}': {}", file, e));
+            let base_options = load_options_from_json(&json_str)
+                .expect("Failed to parse JSON input");
+            merge_cli_with_options(&cli, base_options)
+        } else {
+            // Not a JSON file, read from stdin
+            let mut input = String::new();
+            io::stdin()
+                .read_to_string(&mut input)
+                .expect("Failed to read stdin");
+            let base_options = load_options_from_json(&input)
+                .expect("Failed to parse JSON input");
+            merge_cli_with_options(&cli, base_options)
+        }
+    } else {
+        // Check if stdin has data (piped input)
+        use std::io::IsTerminal;
+        if !io::stdin().is_terminal() {
+            // Data piped via stdin
+            let mut input = String::new();
+            io::stdin()
+                .read_to_string(&mut input)
+                .expect("Failed to read stdin");
+            let base_options = load_options_from_json(&input)
+                .expect("Failed to parse JSON input");
+            merge_cli_with_options(&cli, base_options)
+        } else {
+            // No JSON file, no stdin - create default options and apply CLI args
+            let default_json = "{}";
+            let base_options = load_options_from_json(default_json)
+                .expect("Failed to create default options");
+            merge_cli_with_options(&cli, base_options)
+        }
+    };
 
     // Create event loop and window
     let event_loop = EventLoop::new();

package/package.json

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