@bobfrankston/msger 0.1.78 → 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,3 +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,100 +1,160 @@
 use serde::{Deserialize, Serialize};
 use std::io::{self, Read};
+use std::fs;
 use tao::{
     event::{Event, WindowEvent, ElementState, KeyEvent},
     event_loop::{ControlFlow, EventLoop},
     keyboard::KeyCode,
     window::WindowBuilder,
+    platform::windows::WindowExtWindows,
 };
 use wry::{WebViewBuilder, WebContext};
+use clap::Parser;
 
-// JavaScript API to inject into webviews
-const MSGER_JS_API: &str = r#"
-(function() {
-    console.log('[MSGER] Initializing msger API...');
-
-    // Check if IPC is available
-    const hasIPC = typeof window.ipc !== 'undefined' && window.ipc.postMessage;
-    console.log('[MSGER] IPC available:', hasIPC);
-
-    // Helper to safely send IPC messages
-    function safePostMessage(data) {
-        try {
-            if (!hasIPC) {
-                console.error('msger API: window.ipc not available');
-                return false;
-            }
-            window.ipc.postMessage(JSON.stringify(data));
-            return true;
-        } catch(e) {
-            console.error('msger API error:', e);
-            return false;
+#[cfg(windows)]
+use windows::Win32::UI::WindowsAndMessaging::{
+    GetSystemMenu, AppendMenuW, MF_STRING, MF_SEPARATOR, WM_SYSCOMMAND,
+};
+#[cfg(windows)]
+use windows::Win32::UI::Shell::{
+    SetWindowSubclass, DefSubclassProc,
+};
+#[cfg(windows)]
+use windows::Win32::Foundation::{HWND, LPARAM, WPARAM, LRESULT};
+#[cfg(windows)]
+use windows::core::PCWSTR;
+#[cfg(windows)]
+use std::sync::atomic::{AtomicBool, Ordering};
+
+// Custom menu ID for About item (must be < 0xF000 to avoid conflicts with system commands)
+#[cfg(windows)]
+const IDM_ABOUT: u32 = 0x1000;
+
+// Global flag to signal About menu was clicked
+#[cfg(windows)]
+static ABOUT_CLICKED: AtomicBool = AtomicBool::new(false);
+
+// Window subclass procedure to intercept WM_SYSCOMMAND
+#[cfg(windows)]
+unsafe extern "system" fn subclass_proc(
+    hwnd: HWND,
+    msg: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+    _uidsubclass: usize,
+    _dwrefdata: usize,
+) -> LRESULT {
+    if msg == WM_SYSCOMMAND {
+        let cmd = wparam.0 & 0xFFF0;
+        if cmd == IDM_ABOUT as usize {
+            // Set flag that About was clicked
+            ABOUT_CLICKED.store(true, Ordering::SeqCst);
+            return LRESULT(0);
         }
     }
+    DefSubclassProc(hwnd, msg, wparam, lparam)
+}
 
-    window.msger = {
-        // Window control - only close() with window.close() workaround (IPC broken)
-        close: function(result) {
-            // IPC is broken in wry 0.47.2, so we use window.close() instead
-            // Result cannot be returned to parent process
-            try {
-                window.close();
-                return true;
-            } catch(e) {
-                console.error('window.close() failed:', e);
-                return false;
-            }
-        },
-        saveData: function(key, value) {
-            try {
-                localStorage.setItem('msger_' + key, JSON.stringify(value));
-                return true;
-            } catch(e) {
-                console.error('Failed to save data:', e);
-                return false;
-            }
-        },
-        loadData: function(key, defaultValue) {
-            try {
-                const item = localStorage.getItem('msger_' + key);
-                return item ? JSON.parse(item) : defaultValue;
-            } catch(e) {
-                console.error('Failed to load data:', e);
-                return defaultValue;
-            }
-        },
-        removeData: function(key) {
-            try {
-                localStorage.removeItem('msger_' + key);
-                return true;
-            } catch(e) {
-                console.error('Failed to remove data:', e);
-                return false;
-            }
-        },
-        clearData: function() {
-            try {
-                const keys = Object.keys(localStorage);
-                for (const key of keys) {
-                    if (key.startsWith('msger_')) {
-                        localStorage.removeItem(key);
-                    }
-                }
-                return true;
-            } catch(e) {
-                console.error('Failed to clear data:', e);
-                return false;
-            }
-        },
-        // Check if running in msger environment
-        isAvailable: function() {
-            return true;
-        }
-    };
+// 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>,
 
-    console.log('[MSGER] API initialized successfully! window.msger =', window.msger);
-})();
-"#;
+    /// 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")]
@@ -280,15 +340,135 @@ fn escape_html(s: &str) -> String {
         .replace('\'', "&#39;")
 }
 
-fn main() {
-    // Read JSON from stdin
-    let mut input = String::new();
-    io::stdin()
-        .read_to_string(&mut input)
-        .expect("Failed to read stdin");
+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
+}
 
-    let options: MessageBoxOptions =
-        serde_json::from_str(&input).expect("Failed to parse JSON input");
+fn main() {
+    // 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();
@@ -359,6 +539,22 @@ fn main() {
         .build(&event_loop)
         .expect("Failed to create window"));
 
+    // Add About item to Windows system menu and install subclass
+    #[cfg(windows)]
+    unsafe {
+        let hwnd = HWND(window.hwnd() as *mut _);
+        let hmenu = GetSystemMenu(hwnd, false);
+        if !hmenu.is_invalid() {
+            // Add separator
+            AppendMenuW(hmenu, MF_SEPARATOR, 0, PCWSTR::null()).ok();
+            // Add About item
+            let about_text: Vec<u16> = "About (Window Info)\0".encode_utf16().collect();
+            AppendMenuW(hmenu, MF_STRING, IDM_ABOUT as usize, PCWSTR(about_text.as_ptr())).ok();
+        }
+        // Install window subclass to intercept WM_SYSCOMMAND
+        SetWindowSubclass(hwnd, Some(subclass_proc), 1, 0).ok();
+    }
+
     // Generate HTML
     let html = generate_html(&options);
 
@@ -488,6 +684,55 @@ fn main() {
 
     // Run event loop
     event_loop.run(move |event, _,control_flow| {
+        // Check for About menu click
+        #[cfg(windows)]
+        if ABOUT_CLICKED.swap(false, Ordering::SeqCst) {
+            // Get window information
+            let position = window_clone.outer_position().unwrap_or_default();
+            let inner_size = window_clone.inner_size();
+            let outer_size = window_clone.outer_size();
+            let scale_factor = window_clone.scale_factor();
+            let is_maximized = window_clone.is_maximized();
+            let is_fullscreen = window_clone.fullscreen().is_some();
+            let is_always_on_top = window_clone.is_always_on_top();
+
+            // Calculate logical sizes (what you specify in the API)
+            let logical_inner_width = (inner_size.width as f64 / scale_factor) as i32;
+            let logical_inner_height = (inner_size.height as f64 / scale_factor) as i32;
+            let logical_outer_width = (outer_size.width as f64 / scale_factor) as i32;
+            let logical_outer_height = (outer_size.height as f64 / scale_factor) as i32;
+
+            let info = format!(
+                "Window Information\\n\\n\
+                Position: x={}, y={}\\n\\n\
+                Logical Size (API): {}x{} inner\\n\
+                Physical Size (Screen): {}x{} inner\\n\
+                Outer Size (Physical): {}x{}\\n\
+                Outer Size (Logical): {}x{}\\n\\n\
+                Scale Factor: {:.2} ({}% DPI)\\n\
+                Maximized: {}\\n\
+                Fullscreen: {}\\n\
+                Always On Top: {}\\n\\n\
+                Version: {}",
+                position.x, position.y,
+                logical_inner_width, logical_inner_height,
+                inner_size.width, inner_size.height,
+                outer_size.width, outer_size.height,
+                logical_outer_width, logical_outer_height,
+                scale_factor, (scale_factor * 100.0) as i32,
+                is_maximized,
+                is_fullscreen,
+                is_always_on_top,
+                env!("NPM_VERSION")
+            );
+
+            // Show the info in an alert
+            let script = format!("alert('{}')", info);
+            if let Err(e) = webview.evaluate_script(&script) {
+                eprintln!("Failed to show about dialog: {}", e);
+            }
+        }
+
         // Check timeout
         if let Some(deadline) = timeout_instant {
             if std::time::Instant::now() >= deadline {

package/msger-native/src/msger-api.js

@@ -0,0 +1,84 @@
+(function() {
+    console.log('[MSGER] Initializing msger API...');
+
+    // Check if IPC is available
+    const hasIPC = typeof window.ipc !== 'undefined' && window.ipc.postMessage;
+    console.log('[MSGER] IPC available:', hasIPC);
+
+    // Helper to safely send IPC messages
+    function safePostMessage(data) {
+        try {
+            if (!hasIPC) {
+                console.error('msger API: window.ipc not available');
+                return false;
+            }
+            window.ipc.postMessage(JSON.stringify(data));
+            return true;
+        } catch(e) {
+            console.error('msger API error:', e);
+            return false;
+        }
+    }
+
+    window.msger = {
+        // Window control - only close() with window.close() workaround (IPC broken)
+        close: function(result) {
+            // IPC is broken in wry 0.47.2, so we use window.close() instead
+            // Result cannot be returned to parent process
+            try {
+                window.close();
+                return true;
+            } catch(e) {
+                console.error('window.close() failed:', e);
+                return false;
+            }
+        },
+        saveData: function(key, value) {
+            try {
+                localStorage.setItem('msger_' + key, JSON.stringify(value));
+                return true;
+            } catch(e) {
+                console.error('Failed to save data:', e);
+                return false;
+            }
+        },
+        loadData: function(key, defaultValue) {
+            try {
+                const item = localStorage.getItem('msger_' + key);
+                return item ? JSON.parse(item) : defaultValue;
+            } catch(e) {
+                console.error('Failed to load data:', e);
+                return defaultValue;
+            }
+        },
+        removeData: function(key) {
+            try {
+                localStorage.removeItem('msger_' + key);
+                return true;
+            } catch(e) {
+                console.error('Failed to remove data:', e);
+                return false;
+            }
+        },
+        clearData: function() {
+            try {
+                const keys = Object.keys(localStorage);
+                for (const key of keys) {
+                    if (key.startsWith('msger_')) {
+                        localStorage.removeItem(key);
+                    }
+                }
+                return true;
+            } catch(e) {
+                console.error('Failed to clear data:', e);
+                return false;
+            }
+        },
+        // Check if running in msger environment
+        isAvailable: function() {
+            return true;
+        }
+    };
+
+    console.log('[MSGER] API initialized successfully! window.msger =', window.msger);
+})();

package/package.json

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