release: v1.2.0

Modularize the Rust crate and apply a round of review-driven fixes.

Rust crate split from one 1,899-line main.rs into 14 focused modules
(main.rs: 1,899 -> 246 lines). New layout: state, config_io, urls,
logging, injection, window_state, actions, hotkeys, tray, commands.
Largest remaining file is commands.rs at ~460 lines.

Fixes
- Config save pipeline: proper shutdown with saver-thread join via
  RunEvent::Exit, no more race between quit and pending writes.
- Startup safety: force-clear click-through on launch, write sync so
  it reaches disk before any crash can strand the user.
- Tray quit persists geometry before exit; RunEvent::Exit flushes.
- Media hotkeys target the most recently interacted <video>/<audio>.
- Bookmark add: dedup checked before limit; fuzzy URL matching.
- Crop region persists via new set_crop/clear_crop commands, clamped
  and NaN-guarded; f64::clamp panic on NaN max avoided.
- Opacity startup reads fresh value at apply time (no stale capture).
- Error-page detection: narrower title regex, avoids false-positives.
- Tray exit_lock starts disabled, tracks locked state reliably.
- Media tracker waits for document.body instead of silently no-oping.

Improvements
- Hotkey parser: 80-line match -> OnceLock<HashMap>. Full alphabet,
  digits, F1-F12, nav/arrow keys, punctuation.
- Geometry auto-save: cooperative shutdown via AtomicBool (1s tick).
- Dropped <R: Runtime> generics throughout -- app is Wry-only.
- Tray exit_lock stores MenuItem<Wry> directly (no dyn Fn closure).
- Selective warn!/error! logging in direct-action helpers so failed
  native calls are visible when debugging a stuck session.
- Real clear_site_data command via WebView2 native API.

Tests & hygiene
- 17 tests (up from 5): URL matching/normalization, config sanitize
  including NaN/Inf crop, hotkey parsing, bookmark limits, geometry.
- cargo clippy -D warnings clean.
- injection.js gained a table of contents + 20 section banners.
- AGENTS.md updated with the new module layout.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: davidtorcivia

AGENTS.md

@@ -37,10 +37,20 @@ floatview/
 │   └── index.html              # Landing page (URL input)
 ├── src-tauri/
 │   ├── src/
-│   │   ├── main.rs             # Main application logic
-│   │   ├── config.rs           # Configuration types
+│   │   ├── main.rs             # Entry point, run(), RunEvent::Exit hook
+│   │   ├── state.rs            # AppState, auth, tray item mutator
+│   │   ├── config.rs           # serde config types
+│   │   ├── config_io.rs        # load/save/sanitize/shutdown pipeline
+│   │   ├── urls.rs             # normalize_url, urls_match
+│   │   ├── logging.rs          # tracing subscriber setup
+│   │   ├── injection.rs        # init-script builder + media JS + UA
+│   │   ├── window_state.rs     # geometry clamp, persist, startup restore
+│   │   ├── actions.rs          # do_* helpers (hotkeys / tray actions)
+│   │   ├── hotkeys.rs          # parse_hotkey + register_hotkeys
+│   │   ├── tray.rs             # setup_tray
+│   │   ├── commands.rs         # all #[tauri::command] handlers
+│   │   ├── browsing_data.rs    # WebView2 clear-all-data wrapper
 │   │   ├── opacity.rs          # Cross-platform opacity interop
-│   │   ├── clear_site_data.rs  # Browsing data clearing wrapper
 │   │   └── injection.js        # Shadow DOM control strip (embedded)
 │   ├── capabilities/
 │   │   └── default.json        # Tauri v2 permissions
@@ -97,30 +107,30 @@ The drag bar uses `-webkit-app-region: drag` for native WebView2 drag handling.
 
 | Command | Purpose | File |
 |---------|---------|------|
-| `navigate` | Navigate to a URL (returns `true`) | `main.rs` |
-| `navigate_home` | Navigate to home URL (returns `true`) | `main.rs` |
-| `toggle_always_on_top` | Toggle pin state | `main.rs` |
-| `toggle_locked` | Toggle click-through | `main.rs` |
-| `set_opacity` | Set window opacity | `main.rs` |
-| `set_opacity_live` | Set opacity without persisting | `main.rs` |
-| `minimize_window` | Minimize window | `main.rs` |
-| `get_config` | Read current config | `main.rs` |
-| `update_config` | Update config fields | `main.rs` |
-| `set_url` | Set the last_url and recent list | `main.rs` |
-| `save_window_geometry` | Persist current geometry | `main.rs` |
-| `snap_window` | Snap window to corner/center | `main.rs` |
-| `open_settings` | Emit open-settings event | `main.rs` |
-| `exit_click_through` | Disable click-through mode | `main.rs` |
-| `close_window` | Close window | `main.rs` |
-| `maximize_toggle` | Maximize/unmaximize window | `main.rs` |
-| `get_version` | Get app version string | `main.rs` |
-| `check_for_updates` | Check for available updates | `main.rs` |
-| `set_window_title` | Set window title (truncated to 256 chars) | `main.rs` |
-| `add_bookmark` | Add URL to bookmarks (dedup, max 50) | `main.rs` |
-| `remove_bookmark` | Remove URL from bookmarks (fuzzy match) | `main.rs` |
-| `set_crop` | Persist crop region | `main.rs` |
-| `clear_crop` | Clear persisted crop region | `main.rs` |
-| `clear_site_data` | Clear all webview browsing data | `clear_site_data.rs` |
+| `navigate` | Navigate to a URL (returns `true`) | `commands.rs` |
+| `navigate_home` | Navigate to home URL (returns `true`) | `commands.rs` |
+| `toggle_always_on_top` | Toggle pin state | `commands.rs` |
+| `toggle_locked` | Toggle click-through | `commands.rs` |
+| `set_opacity` | Set window opacity | `commands.rs` |
+| `set_opacity_live` | Set opacity without persisting | `commands.rs` |
+| `minimize_window` | Minimize window | `commands.rs` |
+| `get_config` | Read current config | `commands.rs` |
+| `update_config` | Update config fields | `commands.rs` |
+| `set_url` | Set the last_url and recent list | `commands.rs` |
+| `save_window_geometry` | Persist current geometry | `commands.rs` |
+| `snap_window` | Snap window to corner/center | `commands.rs` |
+| `open_settings` | Emit open-settings event | `commands.rs` |
+| `exit_click_through` | Disable click-through mode | `commands.rs` |
+| `close_window` | Close window | `commands.rs` |
+| `maximize_toggle` | Maximize/unmaximize window | `commands.rs` |
+| `get_version` | Get app version string | `commands.rs` |
+| `check_for_updates` | Check for available updates | `commands.rs` |
+| `set_window_title` | Set window title (truncated to 256 chars) | `commands.rs` |
+| `add_bookmark` | Add URL to bookmarks (dedup, max 50) | `commands.rs` |
+| `remove_bookmark` | Remove URL from bookmarks (fuzzy match) | `commands.rs` |
+| `set_crop` | Persist crop region | `commands.rs` |
+| `clear_crop` | Clear persisted crop region | `commands.rs` |
+| `clear_site_data` | Clear all webview browsing data | `commands.rs` (→ `browsing_data.rs`) |
 
 All commands require an auth token (`token` param) via `authorize_command()`.
 
@@ -174,16 +184,16 @@ It is disabled on startup (since locked mode is auto-cleared for safety) and upd
 
 ### Adding a Tauri Command
 
-1. Add function with `#[tauri::command]` attribute in `main.rs`
-2. Add to `invoke_handler!` macro
+1. Add function with `#[tauri::command]` attribute in `commands.rs` (declared `pub`)
+2. Add `commands::<name>` to `generate_handler![ ... ]` in `main.rs`
 3. Call from JS via `invoke('command_name', { args })`
 
-All commands must accept a `token: String` parameter and call `authorize_command(&state, &token, "command_name")?`.
+All commands must accept a `token: String` parameter and call `authorize_command(&state, &token, "command_name")?` from the `state` module.
 
 ### Adding a Global Hotkey
 
 1. Add to `HotkeyConfig` in `config.rs`
-2. Add key code to `parse_hotkey()` in `main.rs`
+2. Add key code to the `hotkey_code_map()` table in `hotkeys.rs`
 3. Register in `register_hotkeys()` -- call a `do_*` helper directly, don't emit events
 4. Update `__floatViewUpdate()` in `injection.js` if UI sync needed
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "floatview",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A minimal floating browser window for streaming media on a secondary monitor",
   "scripts": {
     "tauri": "tauri",

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "floatview"
-version = "1.1.0"
+version = "1.2.0"
 description = "A minimal floating browser window for streaming media"
 authors = ["David Torcivia"]
 license = "MIT"

src-tauri/Cargo.toml

@@ -0,0 +1,211 @@
+//! Direct-action helpers invoked from the tray menu and global hotkeys.
+//!
+//! These bypass the JS command bus — they mutate state in Rust, call the
+//! native window API directly, and emit events to the webview so the
+//! control strip stays in sync. They match the behavior of their
+//! `#[tauri::command]` siblings but are callable without a token.
+
+use tauri::{AppHandle, Emitter, Manager};
+use tracing::{error, info, warn};
+use tauri_plugin_updater::UpdaterExt;
+
+use crate::config_io::save_config;
+use crate::opacity;
+use crate::state::{update_tray_exit_lock_enabled, AppState};
+use crate::urls::{normalize_url, DEFAULT_HOME_URL};
+
+pub fn do_navigate_home(app: &AppHandle) {
+    if let Some(window) = app.get_webview_window("main") {
+        let state = app.state::<AppState>();
+        let home_url = if let Ok(mut config) = state.config.lock() {
+            config.last_url = None;
+            save_config(&state, &config);
+            normalize_url(&config.home_url).unwrap_or_else(|_| DEFAULT_HOME_URL.to_string())
+        } else {
+            DEFAULT_HOME_URL.to_string()
+        };
+        let _ = window.eval("window.stop()");
+        let _ = window.eval(format!("window.location.href = {:?}", home_url));
+    }
+}
+
+pub fn do_toggle_always_on_top(app: &AppHandle) {
+    let Some(window) = app.get_webview_window("main") else {
+        warn!("do_toggle_always_on_top: main window not found");
+        return;
+    };
+    let current = window.is_always_on_top().unwrap_or(false);
+    let new_value = !current;
+    if let Err(e) = window.set_always_on_top(new_value) {
+        warn!(error = %e, new_value, "set_always_on_top failed");
+    }
+
+    let state = app.state::<AppState>();
+    if let Ok(mut config) = state.config.lock() {
+        config.window.always_on_top = new_value;
+        save_config(&state, &config);
+    }
+
+    if let Err(e) = app.emit("always-on-top-changed", new_value) {
+        warn!(error = %e, "failed to emit always-on-top-changed");
+    }
+    let _ = window.eval(format!(
+        "if(window.__floatViewUpdate) window.__floatViewUpdate('always_on_top', {})",
+        new_value
+    ));
+}
+
+pub fn do_toggle_locked(app: &AppHandle) {
+    let Some(window) = app.get_webview_window("main") else {
+        warn!("do_toggle_locked: main window not found");
+        return;
+    };
+    let new_value = {
+        let state = app.state::<AppState>();
+        let mut config = match state.config.lock() {
+            Ok(config) => config,
+            Err(e) => {
+                error!("Failed to lock config in do_toggle_locked: {}", e);
+                return;
+            }
+        };
+        let nv = !config.window.locked;
+        config.window.locked = nv;
+        save_config(&state, &config);
+        nv
+    };
+
+    if let Err(e) = window.set_ignore_cursor_events(new_value) {
+        // If this fails while enabling lock, the user's click-through request
+        // silently no-ops, which is confusing but not dangerous. If it fails
+        // while disabling lock, the user is trapped behind an invisible window
+        // — that's a significant UX failure worth a loud log line.
+        error!(error = %e, new_value, "set_ignore_cursor_events failed");
+    }
+
+    update_tray_exit_lock_enabled(app, new_value);
+
+    if let Err(e) = app.emit("locked-changed", new_value) {
+        warn!(error = %e, "failed to emit locked-changed");
+    }
+    let _ = window.eval(format!(
+        "if(window.__floatViewUpdate) window.__floatViewUpdate('locked', {})",
+        new_value
+    ));
+}
+
+pub fn do_exit_click_through(app: &AppHandle) {
+    let is_locked = {
+        let state = app.state::<AppState>();
+        let config = match state.config.lock() {
+            Ok(config) => config,
+            Err(e) => {
+                error!("Failed to lock config in do_exit_click_through: {}", e);
+                return;
+            }
+        };
+        config.window.locked
+    };
+    if !is_locked {
+        return;
+    }
+
+    let Some(window) = app.get_webview_window("main") else {
+        warn!("do_exit_click_through: main window not found");
+        return;
+    };
+    {
+        let state = app.state::<AppState>();
+        let mut config = match state.config.lock() {
+            Ok(config) => config,
+            Err(e) => {
+                error!("Failed to lock config in do_exit_click_through: {}", e);
+                return;
+            }
+        };
+        config.window.locked = false;
+        save_config(&state, &config);
+    }
+
+    // Safety-critical: this releases the user from click-through mode. If it
+    // fails, the invisible window still eats all cursor input. Log at error
+    // level so it's impossible to miss when debugging a stuck session.
+    if let Err(e) = window.set_ignore_cursor_events(false) {
+        error!(error = %e, "failed to disable click-through from exit hotkey");
+    }
+    update_tray_exit_lock_enabled(app, false);
+
+    if let Err(e) = app.emit("locked-changed", false) {
+        warn!(error = %e, "failed to emit locked-changed");
+    }
+    let _ = window.eval("if(window.__floatViewUpdate) window.__floatViewUpdate('locked', false)");
+}
+
+pub fn do_opacity_change(app: &AppHandle, delta: f64) {
+    if let Some(window) = app.get_webview_window("main") {
+        let new_opacity = {
+            let state = app.state::<AppState>();
+            let mut config = match state.config.lock() {
+                Ok(config) => config,
+                Err(e) => {
+                    error!("Failed to lock config in do_opacity_change: {}", e);
+                    return;
+                }
+            };
+            let op = (config.window.opacity + delta).clamp(0.1, 1.0);
+            config.window.opacity = op;
+            save_config(&state, &config);
+            op
+        };
+
+        opacity::set_window_opacity(&window, new_opacity);
+
+        let _ = app.emit("opacity-changed", new_opacity);
+        let _ = window.eval(format!(
+            "if(window.__floatViewUpdate) window.__floatViewUpdate('opacity', {})",
+            new_opacity
+        ));
+    }
+}
+
+pub fn do_media_action(app: &AppHandle, script: &'static str) {
+    if let Some(window) = app.get_webview_window("main") {
+        let _ = window.eval(script);
+    }
+}
+
+pub fn do_install_update(app: &AppHandle) {
+    let app_handle = app.clone();
+    tauri::async_runtime::spawn(async move {
+        match install_update(app_handle.clone()).await {
+            Ok(true) => {
+                let _ = app_handle.emit(
+                    "update-install-status",
+                    "Installing update and restarting...",
+                );
+                app_handle.restart();
+            }
+            Ok(false) => {
+                let _ = app_handle.emit("update-install-status", "No update available to install");
+                info!("Install update requested but no update was available");
+            }
+            Err(e) => {
+                let _ = app_handle.emit("update-install-status", format!("Install failed: {}", e));
+                error!("Install update failed: {}", e);
+            }
+        }
+    });
+}
+
+pub async fn install_update(app: AppHandle) -> Result<bool, String> {
+    let updater = app.updater().map_err(|e| e.to_string())?;
+    if let Some(update) = updater.check().await.map_err(|e| e.to_string())? {
+        info!(version = %update.version, "Installing update from native action");
+        update
+            .download_and_install(|_, _| {}, || {})
+            .await
+            .map_err(|e| e.to_string())?;
+        return Ok(true);
+    }
+    Ok(false)
+}

src-tauri/src/actions.rs

@@ -1,5 +1,5 @@
 use tauri::{Runtime, WebviewWindow};
 
-pub fn clear_all_browsing_data<R: Runtime>(window: &WebviewWindow<R>) -> Result<(), String> {
+pub fn clear_all<R: Runtime>(window: &WebviewWindow<R>) -> Result<(), String> {
     window.clear_all_browsing_data().map_err(|e| e.to_string())
 }