feat(ui): Flyout tray panel

src-tauri/Cargo.toml

@@ -42,7 +42,11 @@ panic = "abort"
 
 [dependencies]
 risuko-engine = { workspace = true }
-tauri = { version = "2", features = ["tray-icon", "image-png"] }
+tauri = { version = "2", features = [
+	"tray-icon",
+	"image-png",
+	"macos-private-api",
+] }
 tauri-plugin-store = "2"
 tauri-plugin-deep-link = "2"
 tauri-plugin-dialog = "2"

src-tauri/capabilities/default.json

@@ -1,7 +1,7 @@
 {
 	"identifier": "default",
 	"description": "Default capabilities for Risuko",
-	"windows": ["main"],
+	"windows": ["main", "tray-panel"],
 	"permissions": [
 		"core:default",
 		"core:window:default",

src-tauri/capabilities/tray-panel.json

@@ -0,0 +1,13 @@
+{
+	"identifier": "tray-panel",
+	"description": "Minimal capabilities for the tray flyout panel. Grants only window management, store access, and the invoke channel needed for flyout commands (show_window, get_global_stat, tell_active, tell_waiting, tell_stopped, pause/unpause/remove task, add_uri, open_path, reveal_in_folder). No filesystem, shell, process, OS, or dialog access.",
+	"windows": ["tray-panel"],
+	"permissions": [
+		"core:default",
+		"core:window:allow-show",
+		"core:window:allow-hide",
+		"core:window:allow-set-focus",
+		"core:window:allow-start-dragging",
+		"store:default"
+	]
+}

src-tauri/risuko-bt/src/torrent.rs

@@ -1700,7 +1700,6 @@ fn maybe_clear_endgame(chunk_tracker: &mut ChunkTracker) {
 }
 
 /// Handle an inbound BEP-55 ut_holepunch message
-
 fn handle_holepunch(
     hp: HolepunchMsg,
     from_addr: SocketAddr,
@@ -1791,10 +1790,14 @@ fn try_initiate_holepunch(
     let Some(relay_hp) = relay.their_ut_holepunch_id else {
         return; // relay doesn't support holepunch
     };
-    if relay.cmd_tx.try_send(PeerCommand::Send(Message::Extended {
-        ext_id: relay_hp,
-        payload: build_holepunch(holepunch_type::RENDEZVOUS, target, 0),
-    })).is_ok() {
+    if relay
+        .cmd_tx
+        .try_send(PeerCommand::Send(Message::Extended {
+            ext_id: relay_hp,
+            payload: build_holepunch(holepunch_type::RENDEZVOUS, target, 0),
+        }))
+        .is_ok()
+    {
         holepunch_attempted.insert(target);
         log::debug!(
             target: "diag",

src-tauri/src/commands/file_cmds.rs

@@ -1204,7 +1204,10 @@ fn trash_generated_torrent_sidecars_in_dir(dir: &Path, normalized_info_hash: Opt
         // dict and comparing to this task's info-hash identifies the sidecar
         // precisely, and never touches an unrelated torrent (different hash).
         let hex_stem = generated_torrent_hex_stem(file_name);
-        let matched_by_name = hex_stem.as_deref().map(|stem| stem == hash).unwrap_or(false);
+        let matched_by_name = hex_stem
+            .as_deref()
+            .map(|stem| stem == hash)
+            .unwrap_or(false);
         // Only probe content when the filename has no hex-infohash stem.
         // A hex-named .torrent whose stem differs from our hash is definitively
         // a different torrent; content-matching it would be a false positive that

src-tauri/src/lib.rs

@@ -338,6 +338,8 @@ pub fn run() {
 
         managers::tray::setup_tray(app)?;
 
+        managers::flyout::setup_flyout(app)?;
+
         // Start RSS background polling
         if let Ok(guard) = app.state::<state::AppState>().rss.lock() {
             if let Some(rss) = guard.clone() {
@@ -353,6 +355,15 @@ pub fn run() {
     })
     .on_window_event(|window, event| {
         if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+            #[cfg(not(target_os = "android"))]
+            if window.label() == managers::flyout::FLYOUT_LABEL {
+                api.prevent_close();
+                let _ = window.hide();
+                return;
+            }
+            if window.label() != "main" {
+                return;
+            }
             let quitting = window
                 .app_handle()
                 .state::<state::AppState>()
@@ -364,6 +375,17 @@ pub fn run() {
             api.prevent_close();
             let _ = commands::app_cmds::hide_main_window(window.app_handle());
         }
+
+        if let tauri::WindowEvent::Focused(false) = event {
+            #[cfg(not(target_os = "android"))]
+            if window.label() == managers::flyout::FLYOUT_LABEL {
+                #[cfg(target_os = "macos")]
+                let _ = window
+                    .app_handle()
+                    .set_activation_policy(tauri::ActivationPolicy::Accessory);
+                let _ = window.hide();
+            }
+        }
     })
     .invoke_handler(tauri::generate_handler![
         commands::config_cmds::get_app_config,

src-tauri/src/managers/flyout.rs

@@ -0,0 +1,173 @@
+//! Tray "Quick Panel" flyout window
+
+#[cfg(not(target_os = "android"))]
+use tauri::{
+    AppHandle, Emitter, Manager, PhysicalPosition, WebviewUrl, WebviewWindow, WebviewWindowBuilder,
+};
+
+#[cfg(target_os = "android")]
+use tauri::AppHandle;
+
+#[cfg(not(target_os = "android"))]
+pub const FLYOUT_LABEL: &str = "tray-panel";
+
+/// Logical size of the flyout window
+#[cfg(not(target_os = "android"))]
+const FLYOUT_WIDTH: f64 = 396.0;
+#[cfg(not(target_os = "android"))]
+const FLYOUT_HEIGHT: f64 = 540.0;
+
+/// Gap in physical pixels between the tray icon and the flyout edge
+#[cfg(not(target_os = "android"))]
+const FLYOUT_GAP: i32 = 0;
+
+/// Create the flyout window
+#[cfg(not(target_os = "android"))]
+pub fn setup_flyout(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
+    let handle = app.handle();
+    // Skip if it somehow already exists
+    if handle.get_webview_window(FLYOUT_LABEL).is_some() {
+        return Ok(());
+    }
+
+    let mut builder =
+        WebviewWindowBuilder::new(app, FLYOUT_LABEL, WebviewUrl::App("tray.html".into()))
+            .title("Risuko Quick Panel")
+            .inner_size(FLYOUT_WIDTH, FLYOUT_HEIGHT)
+            .decorations(false)
+            .always_on_top(true)
+            .skip_taskbar(true)
+            .resizable(false)
+            .visible(false)
+            .focused(false)
+            .transparent(true)
+            .shadow(false)
+            .accept_first_mouse(true);
+
+    #[cfg(target_os = "macos")]
+    {
+        builder = builder.visible_on_all_workspaces(true);
+    }
+
+    builder.build()?;
+    Ok(())
+}
+
+#[cfg(target_os = "android")]
+pub fn setup_flyout(_app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
+    Ok(())
+}
+
+/// Cache the tray icon rect
+#[cfg(not(target_os = "android"))]
+pub fn cache_tray_rect(app: &AppHandle, rect: &tauri::Rect, scale_factor: f64) {
+    let pos = rect.position.to_physical::<f64>(scale_factor);
+    let size = rect.size.to_physical::<f64>(scale_factor);
+    if let Some(state) = app.try_state::<crate::state::AppState>() {
+        if let Ok(mut anchor) = state.tray_anchor.lock() {
+            *anchor = Some((pos.x, pos.y, size.width, size.height));
+        }
+    }
+}
+
+/// Toggle the flyout
+#[cfg(not(target_os = "android"))]
+pub fn toggle_flyout(app: &AppHandle) {
+    let Some(window) = app.get_webview_window(FLYOUT_LABEL) else {
+        log::warn!("[Risuko] flyout window not found");
+        return;
+    };
+
+    if window.is_visible().unwrap_or(false) {
+        #[cfg(target_os = "macos")]
+        let _ = app.set_activation_policy(tauri::ActivationPolicy::Accessory);
+        let _ = window.hide();
+        return;
+    }
+
+    position_flyout(app, &window);
+    let _ = window.show();
+    let _ = window.set_focus();
+    // Wake the webview's polling loop so the panel is fresh on open.
+    let _ = window.emit("flyout:show", ());
+}
+
+#[cfg(target_os = "android")]
+pub fn toggle_flyout(_app: &AppHandle) {}
+
+/// Position the flyout near the cached tray anchor
+#[cfg(not(target_os = "android"))]
+fn position_flyout(app: &AppHandle, window: &WebviewWindow) {
+    // Resolve the anchor point (icon center) in physical pixels
+    let anchor = app
+        .try_state::<crate::state::AppState>()
+        .and_then(|state| state.tray_anchor.lock().ok().and_then(|guard| *guard));
+
+    let (icon_x, icon_y, icon_w, icon_h) = match anchor {
+        Some(rect) => rect,
+        None => {
+            // No tray rect was ever delivered
+            match app.cursor_position() {
+                Ok(pos) => (pos.x, pos.y, 0.0, 0.0),
+                Err(_) => (0.0, 0.0, 0.0, 0.0),
+            }
+        }
+    };
+
+    let icon_center_x = icon_x + icon_w / 2.0;
+    let icon_center_y = icon_y + icon_h / 2.0;
+
+    // Find the monitor under the icon; fall back to primary
+    let monitor = app
+        .monitor_from_point(icon_center_x, icon_center_y)
+        .ok()
+        .flatten()
+        .or_else(|| app.primary_monitor().ok().flatten());
+
+    let Some(monitor) = monitor else {
+        // Last resort: drop it at the anchor with no clamping
+        let _ = window.set_position(PhysicalPosition::new(icon_x as i32, icon_y as i32));
+        return;
+    };
+
+    let scale = monitor.scale_factor();
+    let work = monitor.work_area();
+    let wa_x = work.position.x as f64;
+    let wa_y = work.position.y as f64;
+    let wa_w = work.size.width as f64;
+    let wa_h = work.size.height as f64;
+
+    // Window size in physical pixels
+    let win_w = FLYOUT_WIDTH * scale;
+    let win_h = FLYOUT_HEIGHT * scale;
+    let gap = FLYOUT_GAP as f64 * scale;
+
+    // Decide above vs below using the icon center relative to the work area
+    let in_top_half = icon_center_y < wa_y + wa_h / 2.0;
+    let mut y = if in_top_half {
+        // Place below the icon
+        icon_y + icon_h + gap
+    } else {
+        // Place above the icon
+        icon_y - win_h - gap
+    };
+
+    // Horizontally center on the icon
+    let mut x = icon_center_x - win_w / 2.0;
+
+    // Clamp into the work area
+    let max_x = wa_x + wa_w - win_w;
+    let max_y = wa_y + wa_h - win_h;
+    if x < wa_x {
+        x = wa_x;
+    } else if x > max_x {
+        x = max_x.max(wa_x);
+    }
+    if y < wa_y {
+        y = wa_y;
+    } else if y > max_y {
+        y = max_y.max(wa_y);
+    }
+
+    let _ = window.set_position(PhysicalPosition::new(x.round() as i32, y.round() as i32));
+}

src-tauri/src/managers/mod.rs

@@ -1,3 +1,4 @@
+pub mod flyout;
 pub mod menu;
 pub mod tray;
 pub mod vault;

src-tauri/src/managers/tray.rs

@@ -5,24 +5,24 @@ use tauri::{
     image::Image,
     menu::{Menu, MenuBuilder, MenuItemBuilder, PredefinedMenuItem},
     tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
-    App, AppHandle, Emitter, Manager,
+    App, AppHandle, Emitter,
 };
 
 #[cfg(target_os = "android")]
 use tauri::{App, AppHandle};
 
 #[cfg(not(target_os = "android"))]
-use super::{emit_command, show_and_emit};
+use super::{emit_command, flyout, show_and_emit};
 
 #[cfg(not(target_os = "android"))]
-fn toggle_main_window(app: &AppHandle) {
-    if let Some(window) = app.get_webview_window("main") {
-        let is_visible = window.is_visible().unwrap_or(false);
-        if is_visible {
-            let _ = crate::commands::app_cmds::hide_main_window(app);
-        } else {
-            let _ = crate::commands::app_cmds::show_main_window(app);
-        }
+fn tray_event_rect(event: &TrayIconEvent) -> Option<(&tauri::Rect, (f64, f64))> {
+    match event {
+        TrayIconEvent::Click { rect, position, .. }
+        | TrayIconEvent::DoubleClick { rect, position, .. }
+        | TrayIconEvent::Enter { rect, position, .. }
+        | TrayIconEvent::Move { rect, position, .. }
+        | TrayIconEvent::Leave { rect, position, .. } => Some((rect, (position.x, position.y))),
+        _ => None,
     }
 }
 
@@ -62,6 +62,11 @@ fn build_tray_menu(
         get_tray_menu_text(labels, "tray-show", "Show Risuko"),
     )
     .build(handle)?;
+    let quick_panel = MenuItemBuilder::with_id(
+        "tray-quick-panel",
+        get_tray_menu_text(labels, "tray-quick-panel", "Quick Panel"),
+    )
+    .build(handle)?;
     let manual = MenuItemBuilder::with_id(
         "tray-manual",
         get_tray_menu_text(labels, "tray-manual", "Manual"),
@@ -95,6 +100,7 @@ fn build_tray_menu(
             &open_file,
             &sep1,
             &show,
+            &quick_panel,
             &manual,
             &check_updates,
             &sep2,
@@ -123,13 +129,26 @@ pub fn setup_tray(app: &App) -> Result<(), Box<dyn std::error::Error>> {
         .icon_as_template(true)
         .show_menu_on_left_click(false)
         .on_tray_icon_event(|tray, event| {
+            let app = tray.app_handle();
+            // Cache the tray icon rect from any positional event so the flyout
+            // can anchor near the tray even when opened from the menu item
+            if let Some((rect, point)) = tray_event_rect(&event) {
+                let scale = app
+                    .monitor_from_point(point.0, point.1)
+                    .ok()
+                    .flatten()
+                    .map(|m| m.scale_factor())
+                    .unwrap_or(1.0);
+                flyout::cache_tray_rect(app, rect, scale);
+            }
+
             if let TrayIconEvent::Click {
                 button: MouseButton::Left,
                 button_state: MouseButtonState::Up,
                 ..
             } = event
             {
-                toggle_main_window(tray.app_handle());
+                flyout::toggle_flyout(app);
             }
         })
         .on_menu_event(move |app, event| {
@@ -141,6 +160,7 @@ pub fn setup_tray(app: &App) -> Result<(), Box<dyn std::error::Error>> {
                 "tray-show" => {
                     let _ = crate::commands::app_cmds::show_main_window(app);
                 }
+                "tray-quick-panel" => flyout::toggle_flyout(app),
                 "tray-manual" => {
                     let _ = open::that("https://github.com/YueMiyuki/Risuko/wiki");
                 }