From ae1bbc8d6430b80cde9bbcbcf1f71cd6c01d006c Mon Sep 17 00:00:00 2001 From: npub1zurdm6fx3kksz8f8d8y4js3mvjyu3rshlpqejr8wa8hta5tsqqeshmes7w <1706dde9268dad011d2769c959423b6489c88e17f841990ceee9eebed1700033@sprout-oss.stage.blox.sqprod.co> Date: Sat, 18 Jul 2026 12:39:21 -0700 Subject: [PATCH] fix(desktop): resolve CI fmt and file-size failures MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three fixes for PR CI: - fmt: apply rustfmt to the rebased command_env helper in managed_agents/runtime/tests.rs (Rust Lint failure). - lib.rs over the 1000-line limit: move the window/haptic tauri commands (perform_sidebar_default_haptic, title_bar_double_click, fill_window, toggle_maximize) into commands/window_actions.rs where they belong with the other frontend-forwarded commands (1012 -> 901 lines, back under the default limit). - app_state.rs over its ratchet: drop the AppState field for the experiment entirely. The experiment flag now lives in commands/experiments.rs as a process-local atomic, lazily hydrated from the Rust-owned store on first read. The hydrate-before-restore ordering invariant now holds by construction (the spawn boundary is the first reader) instead of by an app-setup ordering requirement, and app_state.rs is byte-identical to main — one less shared surface the experiment touches. desktop src-tauri: cargo test 1483 passed, clippy and fmt clean, and node scripts/check-file-sizes.mjs passes. Co-authored-by: npub1zurdm6fx3kksz8f8d8y4js3mvjyu3rshlpqejr8wa8hta5tsqqeshmes7w <1706dde9268dad011d2769c959423b6489c88e17f841990ceee9eebed1700033@sprout-oss.stage.blox.sqprod.co> Signed-off-by: npub1zurdm6fx3kksz8f8d8y4js3mvjyu3rshlpqejr8wa8hta5tsqqeshmes7w <1706dde9268dad011d2769c959423b6489c88e17f841990ceee9eebed1700033@sprout-oss.stage.blox.sqprod.co> --- desktop/src-tauri/src/app_state.rs | 3 - desktop/src-tauri/src/commands/experiments.rs | 52 +++++---- desktop/src-tauri/src/commands/mod.rs | 2 + .../src-tauri/src/commands/window_actions.rs | 102 ++++++++++++++++ desktop/src-tauri/src/lib.rs | 110 ------------------ .../src-tauri/src/managed_agents/runtime.rs | 8 +- .../src/managed_agents/runtime/tests.rs | 7 +- 7 files changed, 137 insertions(+), 147 deletions(-) create mode 100644 desktop/src-tauri/src/commands/window_actions.rs diff --git a/desktop/src-tauri/src/app_state.rs b/desktop/src-tauri/src/app_state.rs index bab9c9431..3d910c313 100644 --- a/desktop/src-tauri/src/app_state.rs +++ b/desktop/src-tauri/src/app_state.rs @@ -38,8 +38,6 @@ pub struct AppState { /// records. Disabled by the agent-managed profiles experiment so an agent's /// own profile updates are not overwritten on start or restore. pub managed_agent_profile_reconcile_enabled: AtomicBool, - /// Process-local in-app experiment forwarded to newly spawned ACP harnesses. - pub acp_top_level_sessions_experiment: AtomicBool, /// Shared shutdown signal checked by launch-time agent restoration. pub shutdown_started: AtomicBool, /// Serializes the restore spawn/register transition with shutdown cleanup, @@ -203,7 +201,6 @@ pub fn build_app_state() -> AppState { relay_url_override: Mutex::new(None), managed_agent_restore_pending: AtomicBool::new(false), managed_agent_profile_reconcile_enabled: AtomicBool::new(true), - acp_top_level_sessions_experiment: AtomicBool::new(false), shutdown_started: AtomicBool::new(false), managed_agent_restore_transition: Mutex::new(()), identity_mutation: Mutex::new(()), diff --git a/desktop/src-tauri/src/commands/experiments.rs b/desktop/src-tauri/src/commands/experiments.rs index 7014fd0f8..a696a2145 100644 --- a/desktop/src-tauri/src/commands/experiments.rs +++ b/desktop/src-tauri/src/commands/experiments.rs @@ -1,17 +1,23 @@ use std::{ fs, path::{Path, PathBuf}, - sync::atomic::Ordering, + sync::atomic::{AtomicBool, Ordering}, + sync::Once, }; use atomic_write_file::AtomicWriteFile; use serde::{Deserialize, Serialize}; -use tauri::{AppHandle, Manager, State}; - -use crate::app_state::AppState; +use tauri::{AppHandle, Manager}; const EXPERIMENTS_FILE: &str = "desktop-experiments.json"; +/// Process-local experiment state, lazily hydrated from the Rust-owned store on +/// first read so every reader (spawn boundary, frontend) sees persisted state +/// without an app-setup ordering requirement. A corrupt store fails closed: +/// the error is logged and the disabled default stays. +static ACP_TOP_LEVEL_SESSIONS: AtomicBool = AtomicBool::new(false); +static HYDRATE: Once = Once::new(); + #[derive(Debug, Default, Deserialize, Serialize)] #[serde(default)] struct DesktopExperiments { @@ -52,36 +58,36 @@ fn save_experiments(path: &Path, experiments: &DesktopExperiments) -> Result<(), .map_err(|error| format!("commit {}: {error}", path.display())) } -/// Hydrate process state from the Rust-owned store before managed-agent restore. -pub(crate) fn hydrate_desktop_experiments(app: &AppHandle, state: &AppState) -> Result<(), String> { - let experiments = load_experiments(&experiments_path(app)?)?; - state - .acp_top_level_sessions_experiment - .store(experiments.acp_top_level_sessions, Ordering::Release); - Ok(()) +/// Read the experiment, hydrating from the store on first access. +pub(crate) fn acp_top_level_sessions_enabled(app: &AppHandle) -> bool { + HYDRATE.call_once( + || match experiments_path(app).and_then(|path| load_experiments(&path)) { + Ok(experiments) => { + ACP_TOP_LEVEL_SESSIONS.store(experiments.acp_top_level_sessions, Ordering::Release); + } + Err(error) => { + eprintln!("buzz-desktop: failed to hydrate desktop experiments: {error}"); + } + }, + ); + ACP_TOP_LEVEL_SESSIONS.load(Ordering::Acquire) } #[tauri::command] -pub fn get_acp_top_level_sessions_experiment(state: State<'_, AppState>) -> bool { - state - .acp_top_level_sessions_experiment - .load(Ordering::Acquire) +pub fn get_acp_top_level_sessions_experiment(app: AppHandle) -> bool { + acp_top_level_sessions_enabled(&app) } /// Durably apply the experiment before exposing it to subsequently spawned agents. #[tauri::command] -pub fn set_acp_top_level_sessions_experiment( - enabled: bool, - app: AppHandle, - state: State<'_, AppState>, -) -> Result<(), String> { +pub fn set_acp_top_level_sessions_experiment(enabled: bool, app: AppHandle) -> Result<(), String> { let path = experiments_path(&app)?; let mut experiments = load_experiments(&path)?; experiments.acp_top_level_sessions = enabled; save_experiments(&path, &experiments)?; - state - .acp_top_level_sessions_experiment - .store(enabled, Ordering::Release); + // Persisted first: even if first-read hydration races this store, it + // re-reads the same on-disk value. + ACP_TOP_LEVEL_SESSIONS.store(enabled, Ordering::Release); Ok(()) } diff --git a/desktop/src-tauri/src/commands/mod.rs b/desktop/src-tauri/src/commands/mod.rs index 9d0987f94..476c976fc 100644 --- a/desktop/src-tauri/src/commands/mod.rs +++ b/desktop/src-tauri/src/commands/mod.rs @@ -46,6 +46,7 @@ mod social; mod team_snapshot; mod teams; mod updater; +mod window_actions; mod window_vibrancy; mod workflows; mod workspace; @@ -93,6 +94,7 @@ pub use social::*; pub use team_snapshot::*; pub use teams::*; pub use updater::*; +pub use window_actions::*; pub use window_vibrancy::*; pub use workflows::*; pub use workspace::*; diff --git a/desktop/src-tauri/src/commands/window_actions.rs b/desktop/src-tauri/src/commands/window_actions.rs new file mode 100644 index 000000000..db70fe728 --- /dev/null +++ b/desktop/src-tauri/src/commands/window_actions.rs @@ -0,0 +1,102 @@ +//! Native window and haptic commands forwarded from the web frontend. + +#[tauri::command] +pub fn perform_sidebar_default_haptic() { + #[cfg(target_os = "macos")] + { + use objc2_app_kit::{ + NSHapticFeedbackManager, NSHapticFeedbackPattern, NSHapticFeedbackPerformanceTime, + NSHapticFeedbackPerformer, + }; + + NSHapticFeedbackManager::defaultPerformer().performFeedbackPattern_performanceTime( + NSHapticFeedbackPattern::Alignment, + NSHapticFeedbackPerformanceTime::Now, + ); + } +} + +/// Performs the window action matching the macOS "double-click a window's +/// title bar to" preference (`AppleActionOnDoubleClick`). +/// +/// macOS values are `Minimize`, `Maximize` (default when unset), `Fill`, or +/// `None`. +/// The desktop app uses a web-based title-bar drag region, so the frontend +/// forwards double-clicks here and suppresses Tauri's injected drag-region +/// handler, whose default macOS path hardcodes maximize. +/// +/// For `Fill`, resize to the current monitor work area instead of using +/// Tauri's maximize path, which maps to macOS zoom for titled, resizable +/// windows. +/// +/// On non-macOS platforms this always toggles maximize (the historical +/// behavior). +#[tauri::command] +pub fn title_bar_double_click(window: tauri::Window) { + #[cfg(target_os = "macos")] + { + let action = { + let output = std::process::Command::new("defaults") + .args(["read", "-g", "AppleActionOnDoubleClick"]) + .output(); + match output { + Ok(output) if output.status.success() => { + String::from_utf8_lossy(&output.stdout).trim().to_string() + } + _ => "Maximize".to_string(), + } + }; + + match action.as_str() { + "None" => {} + "Minimize" => { + let _ = window.minimize(); + } + "Fill" => { + fill_window(&window); + } + // "Maximize" or any unexpected value. + _ => { + toggle_maximize(&window); + } + } + } + + #[cfg(not(target_os = "macos"))] + { + toggle_maximize(&window); + } +} + +/// Fills the current display work area, excluding system UI like the menu bar +/// and Dock. +#[cfg(target_os = "macos")] +fn fill_window(window: &tauri::Window) { + match window.current_monitor() { + Ok(Some(monitor)) => { + if window.is_maximized().unwrap_or(false) { + let _ = window.unmaximize(); + } + + let work_area = monitor.work_area(); + let _ = window.set_position(work_area.position); + let _ = window.set_size(work_area.size); + } + _ => { + let _ = window.maximize(); + } + } +} + +/// Toggles the window between maximized and its previous size, matching the +/// historical double-click behavior. +fn toggle_maximize(window: &tauri::Window) { + match window.is_maximized() { + Ok(true) => { + let _ = window.unmaximize(); + } + _ => { + let _ = window.maximize(); + } + } +} diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs index cf9822272..2aadaf54c 100644 --- a/desktop/src-tauri/src/lib.rs +++ b/desktop/src-tauri/src/lib.rs @@ -63,106 +63,6 @@ use tauri_plugin_window_state::StateFlags; #[cfg(target_os = "macos")] const INITIAL_RENDER_READY_EVENT: &str = "initial-render-ready"; -#[tauri::command] -fn perform_sidebar_default_haptic() { - #[cfg(target_os = "macos")] - { - use objc2_app_kit::{ - NSHapticFeedbackManager, NSHapticFeedbackPattern, NSHapticFeedbackPerformanceTime, - NSHapticFeedbackPerformer, - }; - - NSHapticFeedbackManager::defaultPerformer().performFeedbackPattern_performanceTime( - NSHapticFeedbackPattern::Alignment, - NSHapticFeedbackPerformanceTime::Now, - ); - } -} - -/// Performs the window action matching the macOS "double-click a window's -/// title bar to" preference (`AppleActionOnDoubleClick`). -/// -/// macOS values are `Minimize`, `Maximize` (default when unset), `Fill`, or -/// `None`. -/// The desktop app uses a web-based title-bar drag region, so the frontend -/// forwards double-clicks here and suppresses Tauri's injected drag-region -/// handler, whose default macOS path hardcodes maximize. -/// -/// For `Fill`, resize to the current monitor work area instead of using -/// Tauri's maximize path, which maps to macOS zoom for titled, resizable -/// windows. -/// -/// On non-macOS platforms this always toggles maximize (the historical -/// behavior). -#[tauri::command] -fn title_bar_double_click(window: tauri::Window) { - #[cfg(target_os = "macos")] - { - let action = { - let output = std::process::Command::new("defaults") - .args(["read", "-g", "AppleActionOnDoubleClick"]) - .output(); - match output { - Ok(output) if output.status.success() => { - String::from_utf8_lossy(&output.stdout).trim().to_string() - } - _ => "Maximize".to_string(), - } - }; - - match action.as_str() { - "None" => {} - "Minimize" => { - let _ = window.minimize(); - } - "Fill" => { - fill_window(&window); - } - // "Maximize" or any unexpected value. - _ => { - toggle_maximize(&window); - } - } - } - - #[cfg(not(target_os = "macos"))] - { - toggle_maximize(&window); - } -} - -/// Fills the current display work area, excluding system UI like the menu bar -/// and Dock. -#[cfg(target_os = "macos")] -fn fill_window(window: &tauri::Window) { - match window.current_monitor() { - Ok(Some(monitor)) => { - if window.is_maximized().unwrap_or(false) { - let _ = window.unmaximize(); - } - - let work_area = monitor.work_area(); - let _ = window.set_position(work_area.position); - let _ = window.set_size(work_area.size); - } - _ => { - let _ = window.maximize(); - } - } -} - -/// Toggles the window between maximized and its previous size, matching the -/// historical double-click behavior. -fn toggle_maximize(window: &tauri::Window) { - match window.is_maximized() { - Ok(true) => { - let _ = window.unmaximize(); - } - _ => { - let _ = window.maximize(); - } - } -} fn reveal_initial_window(window: &tauri::Window) { if let Err(error) = window.show() { @@ -490,16 +390,6 @@ pub fn run() { migration::run_boot_migrations(&app_handle); } - // Hydrate Rust-owned experiments before any launch-time managed-agent - // restore can spawn a process. A corrupt store fails closed and leaves - // the disabled default in place. - let state = app_handle.state::(); - if let Err(error) = - commands::experiments::hydrate_desktop_experiments(&app_handle, &state) - { - eprintln!("buzz-desktop: failed to hydrate desktop experiments: {error}"); - } - // Resolve persisted identity key (env var → file → generate+save). // This is fatal — the app should not start with an ephemeral identity // that will be lost on restart, as that silently breaks channel diff --git a/desktop/src-tauri/src/managed_agents/runtime.rs b/desktop/src-tauri/src/managed_agents/runtime.rs index 264d9241d..ba951a6cd 100644 --- a/desktop/src-tauri/src/managed_agents/runtime.rs +++ b/desktop/src-tauri/src/managed_agents/runtime.rs @@ -1714,13 +1714,7 @@ pub fn spawn_agent_child( // Legacy default. User env may override this while the experiment is off; // enabled experiment state is authoritatively finalized at the spawn boundary. command.env("BUZZ_ACP_MULTIPLE_EVENT_HANDLING", "steer"); - let top_level_sessions = { - use std::sync::atomic::Ordering; - use tauri::Manager; - app.state::() - .acp_top_level_sessions_experiment - .load(Ordering::Acquire) - }; + let top_level_sessions = crate::commands::experiments::acp_top_level_sessions_enabled(app); command.env("BUZZ_ACP_DEDUP", "queue"); if let Some(meta) = runtime_meta { for (key, value) in meta.default_env { diff --git a/desktop/src-tauri/src/managed_agents/runtime/tests.rs b/desktop/src-tauri/src/managed_agents/runtime/tests.rs index 8d395acaa..9c5bdf107 100644 --- a/desktop/src-tauri/src/managed_agents/runtime/tests.rs +++ b/desktop/src-tauri/src/managed_agents/runtime/tests.rs @@ -761,10 +761,9 @@ fn own_group_grandchild_detected_by_ancestor_walk() { let _ = intermediate.wait(); } -fn command_env(command: &std::process::Command) -> std::collections::HashMap< - std::ffi::OsString, - std::ffi::OsString, -> { +fn command_env( + command: &std::process::Command, +) -> std::collections::HashMap { command .get_envs() .filter_map(|(key, value)| value.map(|value| (key.to_owned(), value.to_owned())))