@bobfrankston/msger 0.1.74 → 0.1.75

package/SESSION-NOTES.md

@@ -0,0 +1,678 @@
+# msger Development Session Notes
+**Date:** 2025-11-04
+**Status:** In Progress - Ready to Continue
+
+## What Was Completed Today ✅
+
+### 1. Fixed Fullscreen Feature (F11 and Esc Keys)
+- **Problem:** Fullscreen wasn't working with F11 or Esc keys
+- **Root Cause:** Was mixing native window fullscreen (Rust/tao) with HTML5 fullscreen (JavaScript)
+- **Solution:**
+  - Implemented keyboard event handling at Rust/window level
+  - F11 toggles fullscreen (works everywhere, including `-url` mode)
+  - Esc exits fullscreen first, then dismisses window on second press
+  - Fixed monitor detection bug by using `current_monitor()` instead of `None`
+- **Files Modified:**
+  - `msger-native/src/main.rs` - Added KeyboardInput event handling, monitor detection
+  - `msger-native/src/template.html` - Updated F11/Esc handlers
+- **Binary Rebuilt:** ✅ Latest binary includes all fixes
+
+### 2. Implemented msger JavaScript API
+Full window control and data persistence API now available!
+
+#### Window Control Functions
+```javascript
+msger.toggleFullscreen()
+msger.setFullscreen(enabled)
+msger.minimize()
+msger.maximize()
+msger.setSize(width, height)
+msger.setPosition(x, y)
+msger.setAlwaysOnTop(enabled)
+msger.setTitle(title)
+msger.close(result?)
+```
+
+#### Data Persistence Functions
+```javascript
+msger.saveData(key, value)       // localStorage with msger_ prefix
+msger.loadData(key, defaultValue?)
+msger.removeData(key)
+msger.clearData()                // Clear all msger_* keys
+```
+
+**Implementation:**
+- JavaScript API injected into both template.html and URL mode
+- IPC message passing from JS → Rust
+- Event loop processes actions in `MainEventsCleared`
+- **Works in both `-message` and `-url` modes!**
+
+**Files Modified:**
+- `msger-native/src/main.rs` - Added IPC action handling, window control logic
+- `msger-native/src/template.html` - Added window.msger API
+
+### 3. Created @bobfrankston/msgerdefs Package
+Separate TypeScript definitions package for the msger API!
+
+**Files Created:**
+- `msgerdefs/package.json` - NPM package configuration
+- `msgerdefs/msgerdefs.ts` - Full TypeScript definitions
+- `msgerdefs/msgerdefs.d.ts` - Compiled type definitions
+- `msgerdefs/msgerdefs.js` - Compiled JavaScript
+- `msgerdefs/README.md` - Package documentation
+- `msgerdefs/tsconfig.json` - TypeScript compiler config
+- `msgerdefs/samples.html` - Interactive examples & test page
+- `msgerdefs/.gitignore` - Git ignore file
+
+**Features:**
+- Full TypeScript type definitions for all API methods
+- Browser-compatible `getMsgerAPI()` function
+- `isMsger()` detection function
+- Ready for separate Git repository
+- Ready to publish to NPM as `@bobfrankston/msgerdefs`
+
+### 4. Created Comprehensive Documentation
+- **MSGER-API.md** - Complete API reference with examples
+- **msgerdefs/README.md** - Package usage guide
+- **msgerdefs/samples.html** - Interactive examples for all features
+
+## Known Issues 🐛
+
+### Fullscreen Toggle Bug (FIXED ✅)
+- **Issue:** Window disappeared after clicking "Toggle Fullscreen" button
+- **Fix Applied:** Now uses `current_monitor()` to ensure fullscreen on correct monitor
+- **Rebuild Status:** Fixed in latest binary
+- **Test:** Try `msger -url msgerdefs/samples.html` (now supports relative paths!)
+
+### Relative Path URLs Not Working (FIXED ✅)
+- **Issue:** `node cli.js -url msgerdefs/samples.html` failed with WebView2Error
+- **Root Cause:** WebView2 requires absolute `file://` URLs, not relative paths
+- **Fix Applied:** Added path normalization in `shower.ts` - automatically converts file paths to `file://` URLs
+- **Now Supports:**
+  - Relative paths: `msgerdefs/samples.html`
+  - Absolute paths: `Y:/dev/utils/msger/file.html`
+  - File URLs: `file:///Y:/dev/utils/msger/file.html`
+  - HTTP URLs: `http://example.com` and `https://example.com`
+- **Files Modified:** `shower.ts` - Added pathToFileURL conversion
+
+### Toggle Fullscreen Crashes in URL Mode (CRITICAL BUG 🔴)
+- **Issue:** Clicking "Toggle Fullscreen" button in samples.html causes panic/crash
+- **Error:** `wry-0.47.2\src\webview2\mod.rs:812:58: http::Error(InvalidUri(InvalidFormat))`
+- **Root Cause:** Bug in wry library - calling window fullscreen operations while webview is active causes wry to parse something as URI and fail
+- **Workaround:** F11 key works fine! Only the JavaScript `msger.toggleFullscreen()` button crashes
+- **Status:** Need to either:
+  1. Update wry to newer version (check if fixed)
+  2. Disable JS fullscreen button for URL mode
+  3. Find different approach to fullscreen that doesn't trigger wry bug
+- **Note:** This is a wry library bug, not our code bug
+- **Reproducible:**
+  ```bash
+  node cli.js -url msgerdefs/samples.html
+  # Click "Toggle Fullscreen" button → CRASH
+  # Press F11 key → Works fine
+  ```
+
+## Next Steps - File System API 📁
+
+### Agreed Approach: Option A - Hybrid
+File system access with two modes:
+
+#### 1. File Dialogs (Always Safe - No Flag Required)
+```javascript
+// Select files
+const file = await msger.fs.selectFile(options)
+const files = await msger.fs.selectFiles(options)
+const path = await msger.fs.saveFileAs(content, filename, options)
+const folder = await msger.fs.selectFolder(options)
+```
+- User chooses files via native dialogs
+- Always returns content + path
+- No security concerns (user explicitly selects)
+
+#### 2. Direct File Access (Requires `--allowFs` Flag)
+```javascript
+// Read/write/list files directly by path
+const content = await msger.fs.read(path)
+await msger.fs.write(path, content)
+const files = await msger.fs.list(path)
+const exists = await msger.fs.exists(path)
+await msger.fs.delete(path)
+```
+- Requires launching with: `msger -url "..." --allowFs`
+- Security conscious - disabled by default
+- Useful for trusted local apps
+
+### Implementation Plan
+
+#### Step 1: Add Dependencies to Cargo.toml
+```toml
+[dependencies]
+# File dialog library
+rfd = "0.14"  # Native file dialogs (cross-platform)
+```
+
+#### Step 2: Extend IPC Message Types
+Add new action types for file operations:
+- `selectFile`, `selectFiles`, `saveFileAs`, `selectFolder`
+- `fs.read`, `fs.write`, `fs.list`, `fs.exists`, `fs.delete`
+
+#### Step 3: Implement in Rust (main.rs)
+- Handle file dialog actions → return results to JS via IPC
+- Handle direct file access (check `allowFs` flag first!)
+- Return results/errors as JSON
+
+#### Step 4: Extend JavaScript API
+- Add `msger.fs.*` methods
+- Make async (return Promises)
+- Update both template.html and injected script
+
+#### Step 5: Update TypeScript Definitions
+- Add file system types to msgerdefs.ts
+- Mark `fs` as optional (only available when `allowFs` enabled)
+
+#### Step 6: Test & Document
+- Create file system examples in samples.html
+- Update MSGER-API.md with file system docs
+- Test on Windows (primary), Linux (if possible)
+
+## Important Notes for Tomorrow
+
+### CLI Options Status
+- **Case Sensitivity:** CLI options are NOT case sensitive (user confirmed)
+  - `-url` and `-URL` and `--url` all work
+  - `-fullscreen` and `--fullscreen` both work
+
+### PWA Support
+- PWAs loaded with `-url` work! (Service Workers, IndexedDB, Manifest)
+- Service Workers: ✅ Work
+- Offline mode: ✅ Works
+- "Install" UI: ❌ Not applicable (already native window)
+- Push notifications: ⚠️ Platform-dependent
+
+### Git Repository Plan
+- `msgerdefs/` should have its own Git repository
+- Keep copy in parent msger repo for convenience
+- Publish to NPM as `@bobfrankston/msgerdefs`
+
+## File Locations
+
+### Source Code
+- `msger-native/src/main.rs` - Rust backend (window, IPC, events)
+- `msger-native/src/template.html` - HTML template with msger API
+- `clihandler.ts` - CLI argument parsing
+- `shower.ts` - TypeScript wrapper for Rust binary
+
+### TypeScript Definitions
+- `msgerdefs/msgerdefs.ts` - TypeScript source
+- `msgerdefs/package.json` - NPM package config
+- `msgerdefs/samples.html` - Interactive examples
+
+### Documentation
+- `README.md` - Main project readme
+- `MSGER-API.md` - Complete API reference
+- `FULLSCREEN-FEATURE.md` - Fullscreen implementation details
+- `msgerdefs/README.md` - TypeScript package readme
+- `SESSION-NOTES.md` - This file!
+
+### Built Files
+- `msger-native/bin/msgernative.exe` - Windows binary (latest)
+- `msgernative-linux-x64` - Linux x64 binary
+- `msgerdefs/msgerdefs.js` - Compiled JavaScript
+- `msgerdefs/msgerdefs.d.ts` - Compiled TypeScript definitions
+
+## Build Commands
+
+### Rebuild Rust Binary (Windows)
+```powershell
+powershell.exe -Command "& {Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'; Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Community' -SkipAutomaticLocation; cd Y:\dev\utils\msger\msger-native; cargo build --release; Copy-Item target\release\msgernative.exe bin\ -Force}"
+```
+
+### Compile TypeScript
+```bash
+# Main project
+tsc
+
+# msgerdefs package
+cd msgerdefs && tsc
+```
+
+### Test Commands
+```bash
+# Test basic window
+node cli.js -message "Test" -timeout 5
+
+# Test fullscreen
+node cli.js --fullscreen -message "Press F11 or Esc" -timeout 10
+
+# Test samples page
+node cli.js -url "file:///Y:/dev/utils/msger/msgerdefs/samples.html" -size 900,700
+
+# Test with URL
+node cli.js -url "https://example.com" -size 1024,768
+```
+
+## Questions to Address Tomorrow
+
+1. **Window Closing Bug:** Why does window abort after some operations?
+2. **File Dialog Library:** Confirm `rfd` crate is the best choice for cross-platform file dialogs
+3. **allowFs Flag:** How to pass/validate the `--allowFs` flag securely?
+4. **Async Responses:** How to handle async file operations and return results to JavaScript?
+5. **Error Handling:** How to return errors to JavaScript (reject promises)?
+
+## Remember
+
+- Always use VS Developer Command Prompt for Rust builds on Windows
+- Test in both template mode (`-message`) and URL mode (`-url`)
+- Update both Rust code AND JavaScript API in template.html
+- Keep msgerdefs types in sync with implementation
+- Fullscreen fix: Always use `current_monitor()` not `None`
+
+---
+
+**Session End Time:** Ready to continue tomorrow!
+**Next Priority:** Implement file system API (Option A - Hybrid approach)
+
+** One Additional note
+
+According to
+https://www.perplexity.ai/search/can-the-rust-tool-chain-compil-kTNtAElGREq2YIU8qCpx_Q#1
+rust should be able to cross compile to the pi on Windows.
+
+---
+
+# Session 2025-11-05: Critical Bug Discovery
+
+## CRITICAL: Window Manipulation API Completely Broken ❌
+
+### What We Discovered
+Testing revealed that **ALL window manipulation functions** cause crashes when called via JavaScript IPC, not just fullscreen. This is a fundamental bug in wry 0.47.2.
+
+### The Bug
+**Error:** `http::Error(InvalidUri(InvalidFormat))` at `wry-0.47.2/src/webview2/mod.rs:812:58`
+
+When JavaScript calls any window manipulation function through IPC (`window.ipc.postMessage`), the wry library tries to parse something as an HTTP URI internally and crashes. The panic occurs in FFI code that "cannot unwind", so even Rust's `catch_unwind` can't prevent the crash.
+
+### Affected Functions (ALL DISABLED)
+- ❌ `msger.toggleFullscreen()`
+- ❌ `msger.setFullscreen(enabled)`
+- ❌ `msger.minimize()`
+- ❌ `msger.maximize()`
+- ❌ `msger.setSize(width, height)`
+- ❌ `msger.setPosition(x, y)`
+- ❌ `msger.setAlwaysOnTop(enabled)`
+- ❌ `msger.setTitle(title)`
+
+### Still Working ✅
+- ✅ `msger.saveData()` / `msger.loadData()` / `msger.removeData()` / `msger.clearData()` - localStorage only
+- ✅ `msger.isAvailable()` - Pure JavaScript
+- ✅ `msger.testHello()` - Pure JavaScript test function
+- ⚠️ `msger.close(result)` - May work (exits immediately)
+
+### Changes Made
+
+#### 1. Disabled All Broken Functions
+Updated both `main.rs` (MSGER_JS_API) and `template.html`:
+- All window manipulation functions now return `false`
+- Log descriptive error messages to console
+- Provide alternative solutions (CLI flags, F11 key)
+- No more crashes!
+
+#### 2. Added Error Handling
+- IPC availability check before sending messages
+- Try/catch blocks around all IPC operations
+- `safePostMessage()` helper function
+- Graceful degradation with helpful error messages
+
+#### 3. Created Test Suite
+- `test-msger-functions.html` - Comprehensive test page
+- Tests basic functionality (testHello, testIPC)
+- Tests each API function individually
+- Auto-runs basic tests on load
+
+#### 4. Documentation
+- **KNOWN-BUGS.md** - Complete documentation of the wry bug
+  - Detailed technical explanation
+  - Workarounds for each function
+  - Testing instructions
+  - Potential solutions
+
+### Workarounds
+
+Since JavaScript API is broken, use **CLI arguments** instead:
+
+```bash
+# Configure everything at startup
+node cli.js -url page.html \
+  -fullscreen \
+  -size 1920,1080 \
+  -pos 0,0 \
+  -alwaysOnTop \
+  -title "My App"
+```
+
+For fullscreen toggle during runtime:
+- **F11 key** - Works at native window level (bypasses IPC)
+- **Esc key** - Exits fullscreen
+
+### Next Steps
+
+1. **Test CLI workarounds** - Verify all CLI flags work correctly
+2. **Update msgerdefs package** - Mark window functions as deprecated/broken
+3. **Research wry updates** - Check if newer versions fix this
+4. **Consider alternatives:**
+   - Full Tauri framework (better WebView2 integration)
+   - Different WebView library
+   - Native UI for controls instead of HTML/JS
+
+### Files Modified
+- `msger-native/src/main.rs` - Disabled window manipulation API
+- `msger-native/src/template.html` - Disabled window manipulation API
+- `test-msger-functions.html` - Created test suite
+- `KNOWN-BUGS.md` - Created documentation
+
+### Binary Status
+- ✅ Rebuilt with all fixes (v0.1.57)
+- ✅ No more crashes from window manipulation
+- ✅ Helpful error messages in console
+- ✅ localStorage functions still work perfectly
+
+### DEFINITIVE TEST RESULTS
+
+#### IPC Crash Test
+Created `test-ipc-reach.html` to test if messages reach Rust handlers:
+- **Result:** CRASH on `window.ipc.postMessage()`
+- **Location:** wry-0.47.2/src/webview2/mod.rs:812:58
+- **Error:** `http::Error(InvalidUri(InvalidFormat))`
+
+**Critical Finding:**
+- Crash happens **INSIDE wry library**, not in our code
+- Message never reaches Rust handlers (no DEBUG output)
+- `catch_unwind` is **useless** (panic in FFI/COM code)
+- **ALL IPC is broken at the library level**
+
+#### What Actually Works
+- ✅ `msger.saveData()` - localStorage only
+- ✅ `msger.loadData()` - localStorage only
+- ✅ `msger.removeData()` - localStorage only
+- ✅ `msger.clearData()` - localStorage only
+- ✅ Browser APIs (File API, Download API)
+- ❌ **Everything else is broken**
+
+#### Why F11 Doesn't Work
+- WebView2 captures keyboard events before window handler
+- Rust window handler never receives F11/Esc keys
+- HTML5 fullscreen API (document.requestFullscreen) might work but not native window fullscreen
+
+### Clean Demo Created
+**`msgerdefs/samples.html`** - Updated to show only working features:
+- Basic storage with timestamps
+- Structured data (objects, arrays)
+- List/clear all data
+- Download with custom filename (not "virtual files")
+- Storage location information
+- PWA support documentation
+- No broken window control buttons
+- Clear warnings about limitations
+
+### Storage Questions Answered
+
+**Q: Where are settings saved?**
+- **Location:** `%LOCALAPPDATA%\Microsoft\Edge\User Data\WebView2\Default\Local Storage\leveldb\`
+- Each URL origin has its own storage partition
+- Data persists across restarts
+- Can be viewed with `showStorageInfo()` function in samples.html
+
+**Q: Do PWAs work?**
+- ✅ **YES!** PWAs loaded with `-url` work great:
+  - Service Workers ✅
+  - IndexedDB ✅ (can store GBs of data)
+  - Cache API ✅ (offline assets)
+  - localStorage/sessionStorage ✅
+  - Web Manifest ✅
+  - Push Notifications ⚠️ (platform dependent)
+  - "Install" UI ❌ (not applicable - already native window)
+- Example: `node cli.js -url https://your-pwa.app -detach`
+
+**Q: Why "virtual files"?**
+- Bad naming! Changed to "Download with custom filename"
+- It's just localStorage + browser download API
+- No real file system involved
+
+---
+
+# Session 2025-11-05 (Continued): F11 Fullscreen Fixed ✅
+
+## F11 Fullscreen Now Works!
+
+**Problem:** F11 key was not working because WebView2 captures keyboard events before the Rust window handler receives them.
+
+**Solution:** Implemented HTML5 Fullscreen API handler in JavaScript
+- Added `keydown` event listener that intercepts F11
+- Uses `document.documentElement.requestFullscreen()` for fullscreen
+- Uses `document.exitFullscreen()` to exit
+- **No IPC required** - pure browser API, so no crash!
+
+**How it Works:**
+- Press **F11** → Toggle fullscreen (enter if not fullscreen, exit if fullscreen)
+- Press **Esc** → Exit fullscreen (if in fullscreen mode)
+
+**Files Modified:**
+- `msgerdefs/samples.html` - Added F11 keyboard handler, updated info boxes
+
+**Note:** This is HTML5 fullscreen (webpage fullscreen), not native window fullscreen, but it provides the same user experience.
+
+## Isolated Storage with Custom WebContext ✅
+
+**Problem:** msger was using the default WebView2 data folder, which meant all WebView2 applications shared the same localStorage!
+
+**Solution:** Implemented custom `WebContext` with dedicated data directory
+- Created `WebContext::new(Some(PathBuf))` with custom path
+- Used `WebViewBuilder::with_web_context()` to apply it
+- **New storage location:** `%LOCALAPPDATA%\msger\webview2\` (isolated from other apps)
+
+**Benefits:**
+- Each app using msger gets its own isolated storage
+- No conflicts with other WebView2 applications
+- Data is still persistent across restarts
+- Each URL origin still gets its own partition within msger's storage
+
+**Files Modified:**
+- `msger-native/src/main.rs` - Added WebContext import and configuration
+- Binary rebuilt successfully
+
+## OK/Cancel Buttons Added to Samples ✅
+
+**Added:** Window control demonstration buttons to show broken IPC
+- Three red buttons: "Try OK", "Try Cancel", "Try Close"
+- Safely call `msger.close()` methods without crashing
+- Display helpful error messages explaining the wry bug
+- List workarounds (X button, Alt+F4, CLI flags)
+
+**Files Modified:**
+- `msgerdefs/samples.html` - Added window controls section with demo buttons
+
+## Critical JavaScript Bug Fixed ✅
+
+**Problem:** Template.html had a "Temporal Dead Zone" error
+- **Line 312**: Used `zoomLevel` variable before declaration
+- **Line 317**: Declared `let zoomLevel = 1.0` (too late!)
+- **Error:** `Uncaught ReferenceError: Cannot access 'zoomLevel' before initialization`
+- **Impact:** Entire script stopped executing, preventing ALL JavaScript from running (including F11 handler in URL mode)
+
+**Solution:** Moved `let zoomLevel = 1.0` declaration before usage
+- Zoom features now work correctly
+- F11 handler in samples.html can now execute
+- No more JavaScript errors blocking initialization
+
+**Files Modified:**
+- `msger-native/src/template.html` - Fixed zoomLevel declaration order
+- Binary rebuilt (v0.1.57)
+
+**This explains why F11 wasn't working!** The JavaScript error was stopping script execution.
+
+## IPC Works in Template Mode, Crashes in URL Mode ✅
+
+**Critical Discovery:**
+- **IPC WORKS** in template mode (`-message`, `-html`, `-htmlfrom`)
+- **IPC CRASHES** in URL mode (`-url` with injected script)
+- Root cause: wry 0.47.2 bug only affects injected scripts in URL mode
+
+**Working:**
+- ✅ OK/Cancel buttons work in message mode
+- ✅ `msger.saveData()` etc. work everywhere (no IPC needed)
+- ✅ `msger.close()` works in template mode via IPC
+
+**Broken:**
+- ❌ All IPC operations crash in URL mode (injected script context)
+- ❌ F11 for native fullscreen (HTML5 fullscreen works but only makes content fullscreen, not window)
+
+**Files Verified:**
+- `msger-native/src/template.html` - Restored working IPC in sendResult()
+- Binary tested and confirmed working
+
+## Added -htmlfrom Option ✅
+
+**Purpose:** Load HTML from file or URL and embed in template (unlike -url which loads directly)
+
+**Implementation:**
+- Added `-htmlfrom <file|url>` CLI option
+- Fetches HTML content (file or URL) and embeds in template.html
+- Has OK/Cancel buttons (unlike -url)
+- msger API available (IPC works since it's template mode)
+- No CORS restrictions (fetched server-side)
+
+**Files Modified:**
+- `clihandler.ts` - Added htmlfrom parsing, URL/file loading
+- `shower.ts` - TypeScript interface
+- Compiled successfully
+
+**Known Limitation:**
+- ⚠️ External resources (CSS, JS, images) may be blocked by CSP when embedding HTML
+- Works best for self-contained HTML or local files
+- For full web pages with external resources, use `-url` instead
+
+## Added -dev Flag (Partial) ⚠️
+
+**Status:** Parses flag but can't auto-open DevTools
+- wry 0.47.2 doesn't have `open_devtools()` method available
+- Flag accepted but prints message to press F12 manually
+- DevTools enabled by default, just can't auto-open
+
+**Files Modified:**
+- `clihandler.ts` - Added -dev parsing
+- `shower.ts` - Added dev field
+- `main.rs` - Added dev field, commented out open_devtools()
+
+## Security Note Added ✅
+
+Added security warning to help text:
+> msger is designed for displaying trusted, friendly content (local apps, your own HTML).
+> It is NOT a secure sandbox for untrusted/hostile web content.
+> Use -htmlfrom and -url with trusted sources only.
+
+## Session Summary - 2025-11-05 (Continued) - Updated 2025-11-06
+
+### What Works ✅
+1. **Native browser APIs** - localStorage, window.close(), all standard web APIs work perfectly
+2. **Template mode** - Message, HTML, htmlfrom all work with OK/Cancel buttons
+3. **Button results via IPC** - Parent process gets user's button choice (template mode only)
+4. **F11 fullscreen** - HTML5 fullscreen (content only, not native window)
+5. **Isolated storage** - Custom WebContext at %LOCALAPPDATA%\msger\webview2\
+6. **CLI fullscreen** - `-fullscreen` flag for native window fullscreen
+7. **-htmlfrom** - Load HTML from file/URL with buttons
+
+### msger JavaScript API - Minimal & Optional
+**The msger API is almost empty** - native browser APIs are preferred:
+- `msger.isAvailable()` - Feature detection (returns true in msger)
+- `msger.close()` - Same as native `window.close()` (no added value)
+- Storage functions - Optional wrappers around native localStorage (not needed)
+
+**Recommendation:** Use native browser APIs (`localStorage`, `window.close()`) for compatibility. Your code will work in any browser context, not just msger.
+
+### The Real Value of msger
+**msger = Fast CLI tool that creates native windows with HTML and returns button results**
+- Not a JavaScript API library
+- It's a CLI wrapper around native webview
+- Button results flow back to parent process (template mode)
+- Everything else uses standard browser APIs
+
+### What's Broken ❌
+1. **URL mode IPC** - All window controls crash in `-url` mode (wry 0.47.2 bug)
+2. **Native F11** - Can't toggle native window fullscreen (WebView2 captures key)
+3. **-dev auto-open** - Can't programmatically open DevTools (method not available)
+4. **External resources in -htmlfrom** - CSP blocks external CSS/JS/images
+
+### Recently Fixed ✅
+1. **Multi-monitor positioning** (Fixed 2025-11-06)
+   - Was: Assumed monitors arranged left-to-right, added widths (wrong!)
+   - Now: Gets specific monitor's actual OS position and adds user offset
+   - Fix in main.rs: Use `monitor.position()` instead of adding widths
+   - Test with: `msger -message "Test" -pos 10,10,1` (screen 1 = second monitor)
+
+### Workarounds 🔧
+1. **Use template mode** (`-message`, `-html`, `-htmlfrom`) instead of `-url` when you need buttons
+2. **Use `-fullscreen` CLI flag** for native fullscreen instead of F11
+3. **Press F12** manually to open DevTools
+4. **Use `-url`** for pages with external resources instead of `-htmlfrom`
+5. **Press Esc or Alt+F4** to close window in URL mode
+
+### Next Session Priorities
+
+#### 1. File System API - IMPLEMENT WHEN TIME FOR DEBUGGING (Week of 2025-11-11+)
+**Goal:** Make msger feasible for writing platform apps with file access
+
+**Why it's possible:**
+- IPC works perfectly in template mode (proven by button clicks)
+- Just need bidirectional IPC pattern (JavaScript → Rust → JavaScript)
+- Use `rfd` crate for native file dialogs
+
+**Two modes to implement:**
+
+**A) File Dialogs (Always Safe - No Flag Required):**
+```javascript
+// User chooses files via native dialogs
+await msger.selectFile(options)      // Pick single file → {path, content}
+await msger.selectFiles(options)     // Pick multiple files → [{path, content}...]
+await msger.saveFileAs(content, name, options)  // Save dialog → path
+await msger.selectFolder(options)    // Folder picker → path
+```
+
+**B) Direct File Access (Requires --allowFs Flag):**
+```javascript
+// Direct file operations by path - requires: msger -htmlfrom app.html --allowFs
+await msger.fs.read(path)            // Read file content
+await msger.fs.write(path, content)  // Write file
+await msger.fs.list(path)            // List directory
+await msger.fs.exists(path)          // Check if exists
+await msger.fs.delete(path)          // Delete file
+await msger.fs.mkdir(path)           // Create directory
+```
+
+**Implementation approach:**
+- Add `rfd = "0.14"` to Cargo.toml for dialogs
+- Add `allowFs` flag to MessageBoxOptions
+- Extend IPC handler to recognize file actions
+- Check `allowFs` flag before allowing direct path operations
+- Send results back via `webview.evaluate_script()`
+- JavaScript polls for result in `window.__msger_file_result`
+- Much better than native `<input type="file">` - returns actual paths!
+
+#### 2. Window Manipulation APIs - ALSO POSSIBLE IN TEMPLATE MODE
+**Discovery:** IPC only crashes in URL mode. Window manipulation should work in template mode!
+
+**What could work:**
+```javascript
+await msger.setSize(width, height)
+await msger.setPosition(x, y)
+await msger.setTitle(title)
+await msger.setAlwaysOnTop(enabled)
+await msger.minimize()
+await msger.maximize()
+```
+
+These were disabled thinking ALL IPC was broken, but template mode IPC works fine. Could re-enable with same bidirectional pattern as file API.
+
+#### 3. Periodic wry Update Check
+Check every few months if wry has fixed the URL mode IPC crash bug. Update to newer wry version if fixed. This would enable window/file APIs in URL mode too.
+
+#### 4. Test PWA functionality with sample app

package/clihandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clihandler.d.ts","sourceRoot":"","sources":["clihandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AA8EhD;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,OAAO,EAAE,iBAAiB,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAgLpH;AAED,wBAAgB,QAAQ,IAAI,IAAI,CAE/B;AAED,wBAAgB,WAAW,IAAI,IAAI,CAElC"}
+{"version":3,"file":"clihandler.d.ts","sourceRoot":"","sources":["clihandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AA8FhD;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,OAAO,EAAE,iBAAiB,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CA0NpH;AAED,wBAAgB,QAAQ,IAAI,IAAI,CAE/B;AAED,wBAAgB,WAAW,IAAI,IAAI,CAElC"}