src-tauri/Cargo.lock

@@ -2991,7 +2991,6 @@ checksum = "47c225751e8fbfaaaac5572a80e25d0a0921e9cf408c55509526161b5609157c"
 dependencies = [
  "ironrdp-connector",
  "ironrdp-core",
- "ironrdp-displaycontrol",
  "ironrdp-graphics",
  "ironrdp-input",
  "ironrdp-pdu",

src-tauri/Cargo.toml

@@ -65,7 +65,7 @@ ureq = "3"
 png = "0.17"
 
 # RDP (IronRDP)
-ironrdp = { version = "0.14", features = ["connector", "session", "graphics", "input", "displaycontrol"] }
+ironrdp = { version = "0.14", features = ["connector", "session", "graphics", "input"] }
 ironrdp-tokio = { version = "0.8", features = ["reqwest-rustls-ring"] }
 ironrdp-tls = { version = "0.2", features = ["rustls"] }
 tokio-rustls = "0.26"

src-tauri/src/commands/mod.rs

@@ -14,4 +14,3 @@ pub mod updater;
 pub mod tools_commands_r2;
 pub mod workspace_commands;
 pub mod docker_commands;
-pub mod window_commands;

src-tauri/src/commands/rdp_commands.rs

@@ -19,37 +19,18 @@ pub fn connect_rdp(
     state.rdp.connect(config, app_handle)
 }
 
-/// Get the dirty region since last call as raw RGBA bytes via binary IPC.
+/// Get the current frame buffer as raw RGBA bytes via binary IPC.
 ///
-/// Binary format: 8-byte header + pixel data
+/// Uses `tauri::ipc::Response` to return raw bytes without JSON serialization.
-///   Header: [x: u16, y: u16, width: u16, height: u16] (little-endian)
+/// Pixel format: RGBA, 4 bytes per pixel, row-major, top-left origin.
-///   If header is all zeros, the payload is a full frame (width*height*4 bytes).
+/// Returns empty payload if frame hasn't changed since last call.
-///   If header is non-zero, payload contains only the dirty rectangle pixels.
-/// Returns empty payload if nothing changed.
 #[tauri::command]
-pub fn rdp_get_frame(
+pub async fn rdp_get_frame(
     session_id: String,
     state: State<'_, AppState>,
 ) -> Result<Response, String> {
-    let (region, pixels) = state.rdp.get_frame(&session_id)?;
+    let frame = state.rdp.get_frame(&session_id).await?;
-    if pixels.is_empty() {
+    Ok(Response::new(frame))
-        return Ok(Response::new(Vec::new()));
-    }
-    // Prepend 8-byte dirty rect header
-    let mut out = Vec::with_capacity(8 + pixels.len());
-    match region {
-        Some(rect) => {
-            out.extend_from_slice(&rect.x.to_le_bytes());
-            out.extend_from_slice(&rect.y.to_le_bytes());
-            out.extend_from_slice(&rect.width.to_le_bytes());
-            out.extend_from_slice(&rect.height.to_le_bytes());
-        }
-        None => {
-            out.extend_from_slice(&[0u8; 8]); // full frame marker
-        }
-    }
-    out.extend_from_slice(&pixels);
-    Ok(Response::new(out))
 }
 
 /// Send a mouse event to an RDP session.
@@ -101,29 +82,6 @@ pub fn rdp_send_clipboard(
     state.rdp.send_clipboard(&session_id, &text)
 }
 
-/// Force the next get_frame to return a full frame regardless of dirty state.
-/// Used when switching tabs or after resize to ensure the canvas is fully repainted.
-#[tauri::command]
-pub fn rdp_force_refresh(
-    session_id: String,
-    state: State<'_, AppState>,
-) -> Result<(), String> {
-    state.rdp.force_refresh(&session_id)
-}
-
-/// Resize the RDP session's desktop resolution.
-/// Sends a Display Control Virtual Channel request to the server.
-/// The server will re-render at the new resolution and send updated frames.
-#[tauri::command]
-pub fn rdp_resize(
-    session_id: String,
-    width: u16,
-    height: u16,
-    state: State<'_, AppState>,
-) -> Result<(), String> {
-    state.rdp.resize(&session_id, width, height)
-}
-
 /// Disconnect an RDP session.
 ///
 /// Sends a graceful shutdown to the RDP server and removes the session.

src-tauri/src/commands/window_commands.rs

@@ -1,40 +0,0 @@
-use tauri::AppHandle;
-use tauri::WebviewWindowBuilder;
-
-/// Open a child window from the Rust side using WebviewWindowBuilder.
-///
-/// The `url` parameter supports hash fragments (e.g. "index.html#/tool/ping?sessionId=abc").
-/// WebviewUrl::App takes a PathBuf and cannot handle hash/query — so we load plain
-/// index.html and set the hash via JS after the window is created.
-#[tauri::command]
-pub fn open_child_window(
-    app_handle: AppHandle,
-    label: String,
-    title: String,
-    url: String,
-    width: f64,
-    height: f64,
-) -> Result<(), String> {
-    // Split "index.html#/tool/ping?sessionId=abc" into path and fragment
-    let (path, hash) = match url.split_once('#') {
-        Some((p, h)) => (p.to_string(), Some(format!("#{}", h))),
-        None => (url.clone(), None),
-    };
-
-    let webview_url = tauri::WebviewUrl::App(path.into());
-    let window = WebviewWindowBuilder::new(&app_handle, &label, webview_url)
-        .title(&title)
-        .inner_size(width, height)
-        .resizable(true)
-        .center()
-        .build()
-        .map_err(|e| format!("Failed to create window '{}': {}", label, e))?;
-
-    // Set the hash fragment after the window loads — this triggers App.vue's
-    // onMounted hash detection to render the correct tool/detached component.
-    if let Some(hash) = hash {
-        let _ = window.eval(&format!("window.location.hash = '{}';", hash));
-    }
-
-    Ok(())
-}

src-tauri/src/connections/mod.rs

@@ -434,9 +434,6 @@ impl ConnectionService {
     /// Batch-update sort_order for a list of connection IDs.
     pub fn reorder_connections(&self, ids: &[i64]) -> Result<(), String> {
         let conn = self.db.conn();
-        conn.execute_batch("BEGIN")
-            .map_err(|e| format!("Failed to begin reorder transaction: {e}"))?;
-        let result = (|| {
         for (i, id) in ids.iter().enumerate() {
             conn.execute(
                 "UPDATE connections SET sort_order = ?1 WHERE id = ?2",
@@ -445,22 +442,11 @@ impl ConnectionService {
             .map_err(|e| format!("Failed to reorder connection {id}: {e}"))?;
         }
         Ok(())
-        })();
-        if result.is_err() {
-            let _ = conn.execute_batch("ROLLBACK");
-        } else {
-            conn.execute_batch("COMMIT")
-                .map_err(|e| format!("Failed to commit reorder transaction: {e}"))?;
-        }
-        result
     }
 
     /// Batch-update sort_order for a list of group IDs.
     pub fn reorder_groups(&self, ids: &[i64]) -> Result<(), String> {
         let conn = self.db.conn();
-        conn.execute_batch("BEGIN")
-            .map_err(|e| format!("Failed to begin reorder transaction: {e}"))?;
-        let result = (|| {
         for (i, id) in ids.iter().enumerate() {
             conn.execute(
                 "UPDATE groups SET sort_order = ?1 WHERE id = ?2",
@@ -469,14 +455,6 @@ impl ConnectionService {
             .map_err(|e| format!("Failed to reorder group {id}: {e}"))?;
         }
         Ok(())
-        })();
-        if result.is_err() {
-            let _ = conn.execute_batch("ROLLBACK");
-        } else {
-            conn.execute_batch("COMMIT")
-                .map_err(|e| format!("Failed to commit reorder transaction: {e}"))?;
-        }
-        result
     }
 }
 

src-tauri/src/lib.rs

@@ -224,7 +224,7 @@ pub fn run() {
             commands::credentials::list_credentials, commands::credentials::create_password, commands::credentials::create_ssh_key, commands::credentials::delete_credential, commands::credentials::decrypt_password, commands::credentials::decrypt_ssh_key,
             commands::ssh_commands::connect_ssh, commands::ssh_commands::connect_ssh_with_key, commands::ssh_commands::ssh_write, commands::ssh_commands::ssh_resize, commands::ssh_commands::disconnect_ssh, commands::ssh_commands::disconnect_session, commands::ssh_commands::list_ssh_sessions,
             commands::sftp_commands::sftp_list, commands::sftp_commands::sftp_read_file, commands::sftp_commands::sftp_write_file, commands::sftp_commands::sftp_mkdir, commands::sftp_commands::sftp_delete, commands::sftp_commands::sftp_rename,
-            commands::rdp_commands::connect_rdp, commands::rdp_commands::rdp_get_frame, commands::rdp_commands::rdp_force_refresh, commands::rdp_commands::rdp_send_mouse, commands::rdp_commands::rdp_send_key, commands::rdp_commands::rdp_send_clipboard, commands::rdp_commands::rdp_resize, commands::rdp_commands::disconnect_rdp, commands::rdp_commands::list_rdp_sessions,
+            commands::rdp_commands::connect_rdp, commands::rdp_commands::rdp_get_frame, commands::rdp_commands::rdp_send_mouse, commands::rdp_commands::rdp_send_key, commands::rdp_commands::rdp_send_clipboard, commands::rdp_commands::disconnect_rdp, commands::rdp_commands::list_rdp_sessions,
             commands::theme_commands::list_themes, commands::theme_commands::get_theme,
             commands::pty_commands::list_available_shells, commands::pty_commands::spawn_local_shell, commands::pty_commands::pty_write, commands::pty_commands::pty_resize, commands::pty_commands::disconnect_pty,
             commands::mcp_commands::mcp_list_sessions, commands::mcp_commands::mcp_terminal_read, commands::mcp_commands::mcp_terminal_execute, commands::mcp_commands::mcp_get_session_context, commands::mcp_commands::mcp_bridge_path,
@@ -234,7 +234,6 @@ pub fn run() {
             commands::updater::check_for_updates,
             commands::workspace_commands::save_workspace, commands::workspace_commands::load_workspace,
             commands::docker_commands::docker_list_containers, commands::docker_commands::docker_list_images, commands::docker_commands::docker_list_volumes, commands::docker_commands::docker_action,
-            commands::window_commands::open_child_window,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/mcp/server.rs

@@ -187,7 +187,7 @@ async fn handle_screenshot(
     AxumState(state): AxumState<Arc<McpServerState>>,
     Json(req): Json<ScreenshotRequest>,
 ) -> Json<McpResponse<String>> {
-    match state.rdp.screenshot_png_base64(&req.session_id) {
+    match state.rdp.screenshot_png_base64(&req.session_id).await {
         Ok(b64) => ok_response(b64),
         Err(e) => err_response(e),
     }

src-tauri/src/rdp/mod.rs

@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::net::TcpStream;
 use tokio::sync::mpsc;
-
+use tokio::sync::Mutex as TokioMutex;
 
 use ironrdp::connector::{self, ClientConnector, ConnectionResult, Credentials, DesktopSize};
 use ironrdp::graphics::image_processing::PixelFormat;
@@ -63,29 +63,15 @@ enum InputEvent {
         pressed: bool,
     },
     Clipboard(String),
-    Resize { width: u16, height: u16 },
     Disconnect,
 }
 
-/// Dirty rectangle from the last GraphicsUpdate — used for partial frame transfer.
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DirtyRect {
-    pub x: u16,
-    pub y: u16,
-    pub width: u16,
-    pub height: u16,
-}
-
 struct RdpSessionHandle {
     id: String,
     hostname: String,
     width: u16,
     height: u16,
-    /// Frame buffer: RDP thread writes via RwLock write, IPC reads via RwLock read.
+    frame_buffer: Arc<TokioMutex<Vec<u8>>>,
-    front_buffer: Arc<std::sync::RwLock<Vec<u8>>>,
-    /// Accumulated dirty region since last get_frame — union of all GraphicsUpdate rects.
-    dirty_region: Arc<std::sync::Mutex<Option<DirtyRect>>>,
     frame_dirty: Arc<AtomicBool>,
     input_tx: mpsc::UnboundedSender<InputEvent>,
 }
@@ -113,8 +99,7 @@ impl RdpService {
         for pixel in initial_buf.chunks_exact_mut(4) {
             pixel[3] = 255;
         }
-        let front_buffer = Arc::new(std::sync::RwLock::new(initial_buf));
+        let frame_buffer = Arc::new(TokioMutex::new(initial_buf));
-        let dirty_region = Arc::new(std::sync::Mutex::new(None));
         let frame_dirty = Arc::new(AtomicBool::new(false));
 
         let (input_tx, input_rx) = mpsc::unbounded_channel();
@@ -124,8 +109,7 @@ impl RdpService {
             hostname: hostname.clone(),
             width,
             height,
-            front_buffer: front_buffer.clone(),
+            frame_buffer: frame_buffer.clone(),
-            dirty_region: dirty_region.clone(),
             frame_dirty: frame_dirty.clone(),
             input_tx,
         });
@@ -172,8 +156,7 @@ impl RdpService {
                 if let Err(e) = run_active_session(
                     connection_result,
                     framed,
-                    front_buffer,
+                    frame_buffer,
-                    dirty_region,
                     frame_dirty,
                     input_rx,
                     width as u16,
@@ -217,57 +200,27 @@ impl RdpService {
         Ok(session_id)
     }
 
-    /// Get the dirty region since the last call. Returns (region_metadata, pixel_bytes).
+    pub async fn get_frame(&self, session_id: &str) -> Result<Vec<u8>, String> {
-    /// The pixel bytes contain only the dirty rectangle in row-major RGBA order.
-    /// If nothing changed, returns empty bytes. If the dirty region covers >50% of the
-    /// frame, falls back to full frame for efficiency (avoids row-by-row extraction).
-    pub fn get_frame(&self, session_id: &str) -> Result<(Option<DirtyRect>, Vec<u8>), String> {
         let handle = self.sessions.get(session_id).ok_or_else(|| format!("RDP session {} not found", session_id))?;
-        if !handle.frame_dirty.swap(false, Ordering::Acquire) {
+        if !handle.frame_dirty.swap(false, Ordering::Relaxed) {
-            return Ok((None, Vec::new()));
+            return Ok(Vec::new()); // No change — return empty
+        }
+        let buf = handle.frame_buffer.lock().await;
+        Ok(buf.clone())
     }
 
-        let region = handle.dirty_region.lock().unwrap_or_else(|e| e.into_inner()).take();
+    pub async fn get_frame_raw(&self, session_id: &str) -> Result<Vec<u8>, String> {
-        let buf = handle.front_buffer.read().unwrap_or_else(|e| e.into_inner());
-        let stride = handle.width as usize * 4;
-        let total_pixels = handle.width as usize * handle.height as usize;
-
-        match region {
-            Some(rect) if (rect.width as usize * rect.height as usize) < total_pixels / 2 => {
-                // Partial: extract only the dirty rectangle
-                let rw = rect.width as usize;
-                let rh = rect.height as usize;
-                let rx = rect.x as usize;
-                let ry = rect.y as usize;
-                let mut out = Vec::with_capacity(rw * rh * 4);
-                for row in ry..ry + rh {
-                    let start = row * stride + rx * 4;
-                    let end = start + rw * 4;
-                    if end <= buf.len() {
-                        out.extend_from_slice(&buf[start..end]);
-                    }
-                }
-                Ok((Some(rect), out))
-            }
-            _ => {
-                // Full frame: dirty region covers most of the screen or is missing
-                Ok((None, buf.clone()))
-            }
-        }
-    }
-
-    pub fn get_frame_raw(&self, session_id: &str) -> Result<Vec<u8>, String> {
         let handle = self.sessions.get(session_id).ok_or_else(|| format!("RDP session {} not found", session_id))?;
-        let buf = handle.front_buffer.read().unwrap_or_else(|e| e.into_inner());
+        let buf = handle.frame_buffer.lock().await;
         Ok(buf.clone())
     }
 
     /// Capture the current RDP frame as a base64-encoded PNG.
-    pub fn screenshot_png_base64(&self, session_id: &str) -> Result<String, String> {
+    pub async fn screenshot_png_base64(&self, session_id: &str) -> Result<String, String> {
         let handle = self.sessions.get(session_id).ok_or_else(|| format!("RDP session {} not found", session_id))?;
         let width = handle.width as u32;
         let height = handle.height as u32;
-        let buf = handle.front_buffer.read().unwrap_or_else(|e| e.into_inner());
+        let buf = handle.frame_buffer.lock().await;
 
         // Encode RGBA raw bytes to PNG (fast compression for speed)
         let mut png_data = Vec::new();
@@ -300,19 +253,6 @@ impl RdpService {
         handle.input_tx.send(InputEvent::Key { scancode, pressed }).map_err(|_| format!("RDP session {} input channel closed", session_id))
     }
 
-    pub fn force_refresh(&self, session_id: &str) -> Result<(), String> {
-        let handle = self.sessions.get(session_id).ok_or_else(|| format!("RDP session {} not found", session_id))?;
-        // Clear any accumulated dirty region so get_frame returns the full buffer
-        *handle.dirty_region.lock().unwrap_or_else(|e| e.into_inner()) = None;
-        handle.frame_dirty.store(true, Ordering::Release);
-        Ok(())
-    }
-
-    pub fn resize(&self, session_id: &str, width: u16, height: u16) -> Result<(), String> {
-        let handle = self.sessions.get(session_id).ok_or_else(|| format!("RDP session {} not found", session_id))?;
-        handle.input_tx.send(InputEvent::Resize { width, height }).map_err(|_| format!("RDP session {} input channel closed", session_id))
-    }
-
     pub fn disconnect(&self, session_id: &str) -> Result<(), String> {
         let handle = self.sessions.get(session_id).ok_or_else(|| format!("RDP session {} not found", session_id))?;
         let _ = handle.input_tx.send(InputEvent::Disconnect);
@@ -366,11 +306,7 @@ fn build_connector_config(config: &RdpConfig) -> Result<connector::Config, Strin
         request_data: None,
         autologon: false,
         enable_audio_playback: false,
-        performance_flags: PerformanceFlags::DISABLE_WALLPAPER
+        performance_flags: PerformanceFlags::default(),
-            | PerformanceFlags::DISABLE_MENUANIMATIONS
-            | PerformanceFlags::DISABLE_CURSOR_SHADOW
-            | PerformanceFlags::ENABLE_FONT_SMOOTHING
-            | PerformanceFlags::ENABLE_DESKTOP_COMPOSITION,
         desktop_scale_factor: 0,
         hardware_id: None,
         license_cache: None,
@@ -400,7 +336,7 @@ async fn establish_connection(config: connector::Config, hostname: &str, port: u
     Ok((connection_result, upgraded_framed))
 }
 
-async fn run_active_session(connection_result: ConnectionResult, framed: UpgradedFramed, front_buffer: Arc<std::sync::RwLock<Vec<u8>>>, dirty_region: Arc<std::sync::Mutex<Option<DirtyRect>>>, frame_dirty: Arc<AtomicBool>, mut input_rx: mpsc::UnboundedReceiver<InputEvent>, mut width: u16, mut height: u16, app_handle: tauri::AppHandle, session_id: String) -> Result<(), String> {
+async fn run_active_session(connection_result: ConnectionResult, framed: UpgradedFramed, frame_buffer: Arc<TokioMutex<Vec<u8>>>, frame_dirty: Arc<AtomicBool>, mut input_rx: mpsc::UnboundedReceiver<InputEvent>, width: u16, height: u16, app_handle: tauri::AppHandle, session_id: String) -> Result<(), String> {
     let (mut reader, mut writer) = split_tokio_framed(framed);
     let mut image = DecodedImage::new(PixelFormat::RgbA32, width, height);
     let mut active_stage = ActiveStage::new(connection_result);
@@ -452,67 +388,18 @@ async fn run_active_session(connection_result: ConnectionResult, framed: Upgrade
                         }
                         all_outputs
                     }
-                    Some(InputEvent::Resize { width: new_w, height: new_h }) => {
-                        // Ensure dimensions are within RDP spec (200-8192, even width)
-                        let w = (new_w.max(200).min(8192) & !1) as u32;
-                        let h = new_h.max(200).min(8192) as u32;
-                        if let Some(Ok(resize_frame)) = active_stage.encode_resize(w, h, None, None) {
-                            writer.write_all(&resize_frame).await.map_err(|e| format!("Failed to send resize: {}", e))?;
-                            // Reallocate image and front buffer for new dimensions
-                            image = DecodedImage::new(PixelFormat::RgbA32, w as u16, h as u16);
-                            let buf_size = w as usize * h as usize * 4;
-                            let mut new_buf = vec![0u8; buf_size];
-                            for pixel in new_buf.chunks_exact_mut(4) { pixel[3] = 255; }
-                            *front_buffer.write().unwrap_or_else(|e| e.into_inner()) = new_buf;
-                            width = w as u16;
-                            height = h as u16;
-                            info!("RDP session {} resized to {}x{}", session_id, width, height);
-                        }
-                        Vec::new()
-                    }
                 }
             }
         };
         for out in outputs {
             match out {
                 ActiveStageOutput::ResponseFrame(frame) => { writer.write_all(&frame).await.map_err(|e| format!("Failed to write RDP response frame: {}", e))?; }
-                ActiveStageOutput::GraphicsUpdate(region) => {
+                ActiveStageOutput::GraphicsUpdate(_region) => {
-                    let rx = region.left as usize;
+                    let mut buf = frame_buffer.lock().await;
-                    let ry = region.top as usize;
-                    let rr = (region.right as usize).saturating_add(1).min(width as usize);
-                    let rb = (region.bottom as usize).saturating_add(1).min(height as usize);
-                    let stride = width as usize * 4;
-
-                    // Copy only the dirty rectangle rows from decoded image → front buffer
-                    {
                     let src = image.data();
-                        let mut front = front_buffer.write().unwrap_or_else(|e| e.into_inner());
+                    if src.len() == buf.len() { buf.copy_from_slice(src); } else { *buf = src.to_vec(); }
-                        for row in ry..rb {
+                    frame_dirty.store(true, Ordering::Relaxed);
-                            let src_start = row * stride + rx * 4;
+                    // Push frame notification to frontend — no data, just a signal to fetch
-                            let src_end = row * stride + rr * 4;
-                            if src_end <= src.len() && src_end <= front.len() {
-                                front[src_start..src_end].copy_from_slice(&src[src_start..src_end]);
-                            }
-                        }
-                    }
-
-                    // Accumulate dirty region (union of all rects since last get_frame)
-                    {
-                        let new_rect = DirtyRect { x: rx as u16, y: ry as u16, width: (rr - rx) as u16, height: (rb - ry) as u16 };
-                        let mut dr = dirty_region.lock().unwrap_or_else(|e| e.into_inner());
-                        *dr = Some(match dr.take() {
-                            None => new_rect,
-                            Some(prev) => {
-                                let x = prev.x.min(new_rect.x);
-                                let y = prev.y.min(new_rect.y);
-                                let r = (prev.x + prev.width).max(new_rect.x + new_rect.width);
-                                let b = (prev.y + prev.height).max(new_rect.y + new_rect.height);
-                                DirtyRect { x, y, width: r - x, height: b - y }
-                            }
-                        });
-                    }
-
-                    frame_dirty.store(true, Ordering::Release);
                     let _ = app_handle.emit(&format!("rdp:frame:{}", session_id), ());
                 }
                 ActiveStageOutput::Terminate(reason) => { info!("RDP session terminated: {:?}", reason); return Ok(()); }

src-tauri/src/scanner/mod.rs

@@ -64,36 +64,11 @@ fn service_name(port: u16) -> &'static str {
     }
 }
 
-/// Validate that `subnet` contains exactly three dot-separated octet groups,
-/// each consisting only of 1–3 ASCII digits (e.g. "192.168.1").
-/// Returns an error string if the format is invalid.
-fn validate_subnet(subnet: &str) -> Result<(), String> {
-    let parts: Vec<&str> = subnet.split('.').collect();
-    if parts.len() != 3 {
-        return Err(format!(
-            "Invalid subnet '{}': expected three octets (e.g. 192.168.1)",
-            subnet
-        ));
-    }
-    for part in &parts {
-        if part.is_empty() || part.len() > 3 || !part.chars().all(|c| c.is_ascii_digit()) {
-            return Err(format!(
-                "Invalid subnet '{}': each octet must be 1–3 decimal digits",
-                subnet
-            ));
-        }
-    }
-    Ok(())
-}
-
 /// Discover hosts on the remote network using ARP table and ping sweep.
 pub async fn scan_network(
     handle: &Arc<TokioMutex<Handle<SshClient>>>,
     subnet: &str,
 ) -> Result<Vec<DiscoveredHost>, String> {
-    // Validate subnet format before using it in remote shell commands.
-    validate_subnet(subnet)?;
-
     // Script that works on Linux and macOS:
     // 1. Ping sweep the subnet to populate ARP cache
     // 2. Read ARP table for IP/MAC pairs

src-tauri/tauri.conf.json

@@ -18,12 +18,11 @@
         "minHeight": 600,
         "decorations": true,
         "resizable": true,
-        "dragDropEnabled": false,
+        "dragDropEnabled": false
-        "additionalBrowserArgs": "--enable-gpu-rasterization --enable-zero-copy --disable-features=msWebOOUI,msPdfOOUI,msSmartScreenProtection"
       }
     ],
     "security": {
-      "csp": null
+      "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' asset: https://asset.localhost data:; connect-src 'self' ipc: http://ipc.localhost"
     },
     "withGlobalTauri": false
   },

src/App.vue

@@ -1,65 +1,48 @@
 <script setup lang="ts">
-import { ref, onMounted, onErrorCaptured, defineAsyncComponent } from "vue";
+import { ref, onMounted, defineAsyncComponent } from "vue";
 import { useAppStore } from "@/stores/app.store";
 import UnlockLayout from "@/layouts/UnlockLayout.vue";
-import ToolWindow from "@/components/tools/ToolWindow.vue";
 
-const MainLayout = defineAsyncComponent({
+const MainLayout = defineAsyncComponent(
-  loader: () => import("@/layouts/MainLayout.vue"),
+  () => import("@/layouts/MainLayout.vue")
-  onError(error) { console.error("[App] MainLayout load failed:", error); },
+);
-});
+const ToolWindow = defineAsyncComponent(
-const DetachedSession = defineAsyncComponent({
+  () => import("@/components/tools/ToolWindow.vue")
-  loader: () => import("@/components/session/DetachedSession.vue"),
+);
-  onError(error) { console.error("[App] DetachedSession load failed:", error); },
+const DetachedSession = defineAsyncComponent(
-});
+  () => import("@/components/session/DetachedSession.vue")
+);
 
 const app = useAppStore();
-const appError = ref<string | null>(null);
 
+// Tool window mode — detected from URL hash: #/tool/network-scanner?sessionId=abc
 const isToolMode = ref(false);
 const isDetachedMode = ref(false);
 const toolName = ref("");
 const toolSessionId = ref("");
 
-onErrorCaptured((err) => {
+onMounted(async () => {
-  appError.value = err instanceof Error ? err.message : String(err);
+  const hash = window.location.hash;
-  console.error("[App] Uncaught error:", err);
-  return false;
-});
-
-/** Parse hash and set mode flags. Called on mount and on hashchange. */
-function applyHash(hash: string): void {
   if (hash.startsWith("#/tool/")) {
     isToolMode.value = true;
-    const rest = hash.substring(7);
+    const rest = hash.substring(7); // after "#/tool/"
     const [name, query] = rest.split("?");
     toolName.value = name;
     toolSessionId.value = new URLSearchParams(query || "").get("sessionId") || "";
   } else if (hash.startsWith("#/detached-session")) {
     isDetachedMode.value = true;
-  }
+  } else {
-}
-
-onMounted(async () => {
-  // Check hash at load time (present if JS-side WebviewWindow set it in the URL)
-  applyHash(window.location.hash);
-
-  // Also listen for hash changes (Rust-side window sets hash via eval after load)
-  window.addEventListener("hashchange", () => applyHash(window.location.hash));
-
-  // Only init vault for the main app window (no hash)
-  if (!isToolMode.value && !isDetachedMode.value) {
     await app.checkVaultState();
   }
 });
 </script>
 
 <template>
-  <div v-if="appError" class="fixed inset-0 z-50 flex items-center justify-center bg-[#0d1117] text-red-400 p-8 text-sm font-mono whitespace-pre-wrap">
+  <!-- Detached session window mode -->
-    {{ appError }}
+  <DetachedSession v-if="isDetachedMode" />
-  </div>
+  <!-- Tool popup window mode -->
-  <DetachedSession v-else-if="isDetachedMode" />
   <ToolWindow v-else-if="isToolMode" :tool="toolName" :session-id="toolSessionId" />
+  <!-- Normal app mode -->
   <div v-else class="app-root">
     <UnlockLayout v-if="!app.isUnlocked" />
     <MainLayout v-else />

src/assets/css/terminal.css

@@ -2,7 +2,7 @@
 
 .terminal-container {
   width: 100%;
-  min-height: 0;
+  height: 100%;
   position: relative;
   overflow: hidden;
   background: var(--wraith-bg-primary);
@@ -20,16 +20,14 @@
   height: 100%;
 }
 
-/* WKWebView focus fix: xterm.js hides its helper textarea with opacity: 0,
+/* Selection styling */
-   width/height: 0, left: -9999em. macOS WKWebView doesn't reliably focus
+.terminal-container .xterm-selection div {
-   elements with zero dimensions positioned off-screen. Override to keep it
+  background-color: rgba(88, 166, 255, 0.3) !important;
-   within the viewport with non-zero dimensions so focus events fire. */
+}
-.terminal-container .xterm .xterm-helper-textarea {
+
-  left: 0 !important;
+/* Cursor styling */
-  top: 0 !important;
+.terminal-container .xterm-cursor-layer {
-  width: 1px !important;
+  z-index: 4;
-  height: 1px !important;
-  opacity: 0.01 !important;
 }
 
 /* Scrollbar inside terminal */

src/components/common/StatusBar.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="h-[48px] flex items-center justify-between px-6 bg-[var(--wraith-bg-secondary)] border-t border-[var(--wraith-border)] text-base text-[var(--wraith-text-muted)] shrink-0">
+  <div class="h-6 flex items-center justify-between px-4 bg-[var(--wraith-bg-secondary)] border-t border-[var(--wraith-border)] text-[10px] text-[var(--wraith-text-muted)] shrink-0">
     <!-- Left: connection info -->
     <div class="flex items-center gap-3">
       <template v-if="sessionStore.activeSession">

src/components/common/ThemePicker.vue

@@ -112,8 +112,6 @@ export interface ThemeDefinition {
   brightMagenta: string;
   brightCyan: string;
   brightWhite: string;
-  selectionBackground?: string;
-  selectionForeground?: string;
   isBuiltin?: boolean;
 }
 

src/components/rdp/RdpView.vue

@@ -28,8 +28,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, computed, onMounted, onBeforeUnmount, watch } from "vue";
+import { ref, onMounted, onBeforeUnmount, watch } from "vue";
-import { invoke } from "@tauri-apps/api/core";
 import { useRdp, MouseFlag } from "@/composables/useRdp";
 
 const props = defineProps<{
@@ -43,8 +42,8 @@ const containerRef = ref<HTMLElement | null>(null);
 const canvasWrapper = ref<HTMLElement | null>(null);
 const canvasRef = ref<HTMLCanvasElement | null>(null);
 
-const rdpWidth = computed(() => props.width ?? 1920);
+const rdpWidth = props.width ?? 1920;
-const rdpHeight = computed(() => props.height ?? 1080);
+const rdpHeight = props.height ?? 1080;
 
 const {
   connected,
@@ -77,8 +76,8 @@ function toRdpCoords(e: MouseEvent): { x: number; y: number } | null {
   if (!canvas) return null;
 
   const rect = canvas.getBoundingClientRect();
-  const scaleX = canvas.width / rect.width;
+  const scaleX = rdpWidth / rect.width;
-  const scaleY = canvas.height / rect.height;
+  const scaleY = rdpHeight / rect.height;
 
   return {
     x: Math.floor((e.clientX - rect.left) * scaleX),
@@ -154,95 +153,25 @@ function handleKeyUp(e: KeyboardEvent): void {
   sendKey(props.sessionId, e.code, false);
 }
 
-let resizeObserver: ResizeObserver | null = null;
-let resizeTimeout: ReturnType<typeof setTimeout> | null = null;
-
 onMounted(() => {
   if (canvasRef.value) {
-    startFrameLoop(props.sessionId, canvasRef.value, rdpWidth.value, rdpHeight.value);
+    startFrameLoop(props.sessionId, canvasRef.value, rdpWidth, rdpHeight);
-  }
-
-  // Watch container size and request server-side RDP resize (debounced 500ms)
-  if (canvasWrapper.value) {
-    resizeObserver = new ResizeObserver((entries) => {
-      const entry = entries[0];
-      if (!entry || !connected.value) return;
-      const { width: cw, height: ch } = entry.contentRect;
-      if (cw < 200 || ch < 200) return;
-
-      // Round to even width (RDP spec requirement)
-      const newW = Math.round(cw) & ~1;
-      const newH = Math.round(ch);
-
-      if (resizeTimeout) clearTimeout(resizeTimeout);
-      resizeTimeout = setTimeout(() => {
-        invoke("rdp_resize", {
-          sessionId: props.sessionId,
-          width: newW,
-          height: newH,
-        }).then(() => {
-          if (canvasRef.value) {
-            canvasRef.value.width = newW;
-            canvasRef.value.height = newH;
-          }
-          // Force full frame after resize so canvas gets a clean repaint
-          setTimeout(() => {
-            invoke("rdp_force_refresh", { sessionId: props.sessionId }).catch(() => {});
-          }, 200);
-        }).catch((err: unknown) => {
-          console.warn("[RdpView] resize failed:", err);
-        });
-      }, 500);
-    });
-    resizeObserver.observe(canvasWrapper.value);
   }
 });
 
 onBeforeUnmount(() => {
   stopFrameLoop();
-  if (resizeObserver) { resizeObserver.disconnect(); resizeObserver = null; }
-  if (resizeTimeout) { clearTimeout(resizeTimeout); resizeTimeout = null; }
 });
 
-// Focus canvas, re-check dimensions, and force full frame on tab switch.
+// Focus canvas when this tab becomes active and keyboard is grabbed
-// Uses 300ms delay to let the flex layout fully settle (copilot panel toggle, etc.)
 watch(
   () => props.isActive,
   (active) => {
-    if (!active || !canvasRef.value) return;
+    if (active && keyboardGrabbed.value && canvasRef.value) {
-
-    // Immediate focus so keyboard works right away
-    if (keyboardGrabbed.value) canvasRef.value.focus();
-
-    // Immediate force refresh to show SOMETHING while we check dimensions
-    invoke("rdp_force_refresh", { sessionId: props.sessionId }).catch(() => {});
-
-    // Delayed dimension check — layout needs time to settle
       setTimeout(() => {
-      const wrapper = canvasWrapper.value;
+        canvasRef.value?.focus();
-      const canvas = canvasRef.value;
+      }, 0);
-      if (!wrapper || !canvas) return;
-
-      const { width: cw, height: ch } = wrapper.getBoundingClientRect();
-      const newW = Math.round(cw) & ~1;
-      const newH = Math.round(ch);
-
-      if (newW >= 200 && newH >= 200 && (newW !== canvas.width || newH !== canvas.height)) {
-        invoke("rdp_resize", {
-          sessionId: props.sessionId,
-          width: newW,
-          height: newH,
-        }).then(() => {
-          if (canvas) {
-            canvas.width = newW;
-            canvas.height = newH;
     }
-          setTimeout(() => {
-            invoke("rdp_force_refresh", { sessionId: props.sessionId }).catch(() => {});
-          }, 500);
-        }).catch(() => {});
-      }
-    }, 300);
   },
 );
 </script>
@@ -267,8 +196,9 @@ watch(
 }
 
 .rdp-canvas {
-  width: 100%;
+  max-width: 100%;
-  height: 100%;
+  max-height: 100%;
+  object-fit: contain;
   cursor: default;
   outline: none;
   image-rendering: auto;

src/components/session/TabBar.vue

@@ -133,14 +133,16 @@ async function detachTab(): Promise<void> {
   session.active = false;
 
   // Open a new Tauri window for this session
-  try {
+  const { WebviewWindow } = await import("@tauri-apps/api/webviewWindow");
-    await invoke("open_child_window", {
+  const label = `detached-${session.id.substring(0, 8)}-${Date.now()}`;
-      label: `detached-${session.id.substring(0, 8)}-${Date.now()}`,
+  new WebviewWindow(label, {
     title: `${session.name} — Wraith`,
+    width: 900,
+    height: 600,
+    resizable: true,
+    center: true,
     url: `index.html#/detached-session?sessionId=${session.id}&name=${encodeURIComponent(session.name)}&protocol=${session.protocol}`,
-      width: 900, height: 600,
   });
-  } catch (err) { console.error("Detach window error:", err); }
 }
 
 function closeMenuTab(): void {

src/components/terminal/LocalTerminalView.vue

@@ -12,7 +12,6 @@
 import { ref, onMounted, onBeforeUnmount, watch } from "vue";
 import { invoke } from "@tauri-apps/api/core";
 import { useTerminal } from "@/composables/useTerminal";
-import { useSessionStore } from "@/stores/session.store";
 import "@/assets/css/terminal.css";
 
 const props = defineProps<{
@@ -20,57 +19,13 @@ const props = defineProps<{
   isActive: boolean;
 }>();
 
-const sessionStore = useSessionStore();
 const containerRef = ref<HTMLElement | null>(null);
 const { terminal, mount, fit, destroy } = useTerminal(props.sessionId, "pty");
 
-/** Apply the session store's active theme to this local terminal instance. */
-function applyTheme(): void {
-  const theme = sessionStore.activeTheme;
-  if (!theme) return;
-  terminal.options.theme = {
-    background: theme.background,
-    foreground: theme.foreground,
-    cursor: theme.cursor,
-    cursorAccent: theme.background,
-    selectionBackground: theme.selectionBackground ?? "#264f78",
-    selectionForeground: theme.selectionForeground ?? "#ffffff",
-    selectionInactiveBackground: theme.selectionBackground ?? "#264f78",
-    black: theme.black,
-    red: theme.red,
-    green: theme.green,
-    yellow: theme.yellow,
-    blue: theme.blue,
-    magenta: theme.magenta,
-    cyan: theme.cyan,
-    white: theme.white,
-    brightBlack: theme.brightBlack,
-    brightRed: theme.brightRed,
-    brightGreen: theme.brightGreen,
-    brightYellow: theme.brightYellow,
-    brightBlue: theme.brightBlue,
-    brightMagenta: theme.brightMagenta,
-    brightCyan: theme.brightCyan,
-    brightWhite: theme.brightWhite,
-  };
-
-  if (containerRef.value) {
-    containerRef.value.style.backgroundColor = theme.background;
-  }
-
-  terminal.refresh(0, terminal.rows - 1);
-}
-
 onMounted(() => {
   if (containerRef.value) {
     mount(containerRef.value);
   }
-
-  // Apply current theme immediately if one is already active
-  if (sessionStore.activeTheme) {
-    applyTheme();
-  }
-
   setTimeout(() => {
     fit();
     terminal.focus();
@@ -101,11 +56,6 @@ watch(
   },
 );
 
-// Watch for theme changes and apply to this local terminal
-watch(() => sessionStore.activeTheme, (newTheme) => {
-  if (newTheme) applyTheme();
-}, { deep: true });
-
 onBeforeUnmount(() => {
   destroy();
 });

src/components/terminal/MonitorBar.vue

@@ -1,7 +1,7 @@
 <template>
   <div
     v-if="stats"
-    class="flex items-center gap-4 px-6 h-[48px] bg-[var(--wraith-bg-tertiary)] border-t border-[var(--wraith-border)] text-base font-mono shrink-0 select-none"
+    class="flex items-center gap-4 px-3 h-6 bg-[var(--wraith-bg-tertiary)] border-t border-[var(--wraith-border)] text-[10px] font-mono shrink-0 select-none"
   >
     <!-- CPU -->
     <span class="flex items-center gap-1">

src/components/terminal/TerminalView.vue

@@ -77,10 +77,6 @@ const containerRef = ref<HTMLElement | null>(null);
 const { terminal, searchAddon, mount, fit } = useTerminal(props.sessionId);
 let resizeDisposable: IDisposable | null = null;
 
-function handleFocus(): void {
-  terminal.focus();
-}
-
 // --- Search state ---
 const searchVisible = ref(false);
 const searchQuery = ref("");
@@ -189,10 +185,6 @@ function applyTheme(): void {
     background: theme.background,
     foreground: theme.foreground,
     cursor: theme.cursor,
-    cursorAccent: theme.background,
-    selectionBackground: theme.selectionBackground ?? "#264f78",
-    selectionForeground: theme.selectionForeground ?? "#ffffff",
-    selectionInactiveBackground: theme.selectionBackground ?? "#264f78",
     black: theme.black,
     red: theme.red,
     green: theme.green,
@@ -210,22 +202,12 @@ function applyTheme(): void {
     brightCyan: theme.brightCyan,
     brightWhite: theme.brightWhite,
   };
-
-  // Sync the container background so areas outside the canvas match the theme
-  if (containerRef.value) {
-    containerRef.value.style.backgroundColor = theme.background;
 }
 
-  // Force xterm.js to repaint all visible rows with the new theme colors
+// Watch for theme changes in the session store and apply to this terminal
-  terminal.refresh(0, terminal.rows - 1);
-}
-
-// Watch for theme changes in the session store and apply to this terminal.
-// Uses deep comparison because the theme is an object — a shallow watch may miss
-// updates if Pinia returns the same reactive proxy wrapper after reassignment.
 watch(() => sessionStore.activeTheme, (newTheme) => {
   if (newTheme) applyTheme();
-}, { deep: true });
+});
 
 onBeforeUnmount(() => {
   if (resizeDisposable) {
@@ -233,4 +215,8 @@ onBeforeUnmount(() => {
     resizeDisposable = null;
   }
 });
+
+function handleFocus(): void {
+  terminal.focus();
+}
 </script>

src/composables/useRdp.ts

@@ -158,8 +158,8 @@ export interface UseRdpReturn {
   keyboardGrabbed: Ref<boolean>;
   /** Whether clipboard sync is enabled */
   clipboardSync: Ref<boolean>;
-  /** Fetch and render the dirty region directly to a canvas context */
+  /** Fetch the current frame as RGBA ImageData */
-  fetchAndRender: (sessionId: string, width: number, height: number, ctx: CanvasRenderingContext2D) => Promise<boolean>;
+  fetchFrame: (sessionId: string, width: number, height: number) => Promise<ImageData | null>;
   /** Send a mouse event to the backend */
   sendMouse: (sessionId: string, x: number, y: number, flags: number) => void;
   /** Send a key event to the backend */
@@ -199,50 +199,38 @@ export function useRdp(): UseRdpReturn {
   let unlistenFrame: (() => void) | null = null;
 
   /**
-   * Fetch the dirty region from the Rust RDP backend and apply it to the canvas.
+   * Fetch the current frame from the Rust RDP backend.
    *
-   * Binary format from backend: 8-byte header + pixel data
+   * rdp_get_frame returns raw RGBA bytes (width*height*4) serialised as a
-   *   Header: [x: u16, y: u16, w: u16, h: u16] (little-endian)
+   * base64 string over Tauri's IPC bridge. We decode it to Uint8ClampedArray
-   *   If header is all zeros → full frame (width*height*4 bytes)
+   * and wrap in an ImageData for putImageData().
-   *   If header is non-zero → dirty rectangle (w*h*4 bytes)
-   *
-   * Returns true if a frame was rendered, false if nothing changed.
    */
-  async function fetchAndRender(
+  async function fetchFrame(
     sessionId: string,
     width: number,
     height: number,
-    ctx: CanvasRenderingContext2D,
+  ): Promise<ImageData | null> {
-  ): Promise<boolean> {
     let raw: ArrayBuffer;
     try {
       raw = await invoke<ArrayBuffer>("rdp_get_frame", { sessionId });
     } catch {
-      return false;
+      return null;
     }
 
-    if (!raw || raw.byteLength <= 8) return false;
+    if (!raw || raw.byteLength === 0) return null;
 
-    const view = new DataView(raw);
+    // Binary IPC — tauri::ipc::Response delivers raw bytes as ArrayBuffer
-    const rx = view.getUint16(0, true);
+    const bytes = new Uint8ClampedArray(raw);
-    const ry = view.getUint16(2, true);
-    const rw = view.getUint16(4, true);
-    const rh = view.getUint16(6, true);
-    const pixelData = new Uint8ClampedArray(raw, 8);
 
-    if (rx === 0 && ry === 0 && rw === 0 && rh === 0) {
-      // Full frame
     const expected = width * height * 4;
-      if (pixelData.length !== expected) return false;
+    if (bytes.length !== expected) {
-      ctx.putImageData(new ImageData(pixelData, width, height), 0, 0);
+      console.warn(
-    } else {
+        `[useRdp] Frame size mismatch: got ${bytes.length}, expected ${expected}`,
-      // Dirty rectangle — apply at offset
+      );
-      const expected = rw * rh * 4;
+      return null;
-      if (pixelData.length !== expected) return false;
-      ctx.putImageData(new ImageData(pixelData, rw, rh), rx, ry);
     }
 
-    return true;
+    return new ImageData(bytes, width, height);
   }
 
   /**
@@ -311,35 +299,30 @@ export function useRdp(): UseRdpReturn {
     canvas.height = height;
 
     let fetchPending = false;
-    let rafScheduled = false;
 
-    // Fetch and render dirty region when backend signals new frame data.
+    // Fetch frame when backend signals a new frame is ready
-    // Uses rAF to coalesce rapid events into one fetch per display frame.
+    async function onFrameReady(): Promise<void> {
-    function scheduleFrameFetch(): void {
+      if (fetchPending) return; // Don't stack fetches
-      if (rafScheduled) return;
-      rafScheduled = true;
-      animFrameId = requestAnimationFrame(async () => {
-        rafScheduled = false;
-        if (fetchPending) return;
       fetchPending = true;
-        if (!ctx) return;
+      const imageData = await fetchFrame(sessionId, width, height);
-        const rendered = await fetchAndRender(sessionId, width, height, ctx);
       fetchPending = false;
-        if (rendered && !connected.value) connected.value = true;
+      if (imageData && ctx) {
-      });
+        ctx.putImageData(imageData, 0, 0);
+        if (!connected.value) connected.value = true;
+      }
     }
 
     // Listen for frame events from the backend (push model)
     import("@tauri-apps/api/event").then(({ listen }) => {
       listen(`rdp:frame:${sessionId}`, () => {
-        scheduleFrameFetch();
+        onFrameReady();
       }).then((unlisten) => {
         unlistenFrame = unlisten;
       });
     });
 
-    // Initial poll in case frames arrived before listener was set up
+    // Also do an initial poll in case frames arrived before listener was set up
-    scheduleFrameFetch();
+    onFrameReady();
   }
 
   /**
@@ -373,7 +356,7 @@ export function useRdp(): UseRdpReturn {
     connected,
     keyboardGrabbed,
     clipboardSync,
-    fetchAndRender,
+    fetchFrame,
     sendMouse,
     sendKey,
     sendClipboard,

src/composables/useTerminal.ts

@@ -14,9 +14,8 @@ const defaultTheme = {
   foreground: "#e0e0e0",
   cursor: "#58a6ff",
   cursorAccent: "#0d1117",
-  selectionBackground: "#264f78",
+  selectionBackground: "rgba(88, 166, 255, 0.3)",
   selectionForeground: "#ffffff",
-  selectionInactiveBackground: "#264f78",
   black: "#0d1117",
   red: "#f85149",
   green: "#3fb950",
@@ -156,7 +155,6 @@ export function useTerminal(sessionId: string, backend: 'ssh' | 'pty' = 'ssh'):
     // cell widths — producing tiny dashes and 200+ column terminals.
     document.fonts.ready.then(() => {
       fitAddon.fit();
-      terminal.focus();
     });
 
     // Right-click paste on the terminal's DOM element

src/layouts/MainLayout.vue

@@ -367,14 +367,16 @@ function closeHelpMenuDeferred(): void {
 
 async function handleHelpAction(page: string): Promise<void> {
   showHelpMenu.value = false;
-  try {
+  const { WebviewWindow } = await import("@tauri-apps/api/webviewWindow");
-    await invoke("open_child_window", {
+  const label = `help-${page}-${Date.now()}`;
-      label: `help-${page}-${Date.now()}`,
+  new WebviewWindow(label, {
-      title: "Wraith — Help",
+    title: `Wraith — Help`,
+    width: 750,
+    height: 600,
+    resizable: true,
+    center: true,
     url: `index.html#/tool/help?page=${page}`,
-      width: 750, height: 600,
   });
-  } catch (err) { console.error("Help window error:", err); alert("Window error: " + String(err)); }
 }
 
 async function handleToolAction(tool: string): Promise<void> {
@@ -388,6 +390,8 @@ async function handleToolAction(tool: string): Promise<void> {
     return;
   }
 
+  const { WebviewWindow } = await import("@tauri-apps/api/webviewWindow");
+
   const toolConfig: Record<string, { title: string; width: number; height: number }> = {
     "network-scanner": { title: "Network Scanner", width: 800, height: 600 },
     "port-scanner": { title: "Port Scanner", width: 700, height: 500 },
@@ -408,14 +412,16 @@ async function handleToolAction(tool: string): Promise<void> {
 
   const sessionId = activeSessionId.value || "";
 
-  try {
+  // Open tool in a new Tauri window
-    await invoke("open_child_window", {
+  const label = `tool-${tool}-${Date.now()}`;
-      label: `tool-${tool}-${Date.now()}`,
+  new WebviewWindow(label, {
     title: `Wraith — ${config.title}`,
+    width: config.width,
+    height: config.height,
+    resizable: true,
+    center: true,
     url: `index.html#/tool/${tool}?sessionId=${sessionId}`,
-      width: config.width, height: config.height,
   });
-  } catch (err) { console.error("Tool window error:", err); alert("Tool window error: " + String(err)); }
 }
 
 async function handleFileMenuAction(action: string): Promise<void> {
@@ -435,13 +441,18 @@ function handleThemeSelect(theme: ThemeDefinition): void {
 async function handleOpenFile(entry: FileEntry): Promise<void> {
   if (!activeSessionId.value) return;
   try {
+    const { WebviewWindow } = await import("@tauri-apps/api/webviewWindow");
     const fileName = entry.path.split("/").pop() || entry.path;
+    const label = `editor-${Date.now()}`;
     const sessionId = activeSessionId.value;
-    await invoke("open_child_window", {
+
-      label: `editor-${Date.now()}`,
+    new WebviewWindow(label, {
       title: `${fileName} — Wraith Editor`,
+      width: 800,
+      height: 600,
+      resizable: true,
+      center: true,
       url: `index.html#/tool/editor?sessionId=${sessionId}&path=${encodeURIComponent(entry.path)}`,
-      width: 800, height: 600,
     });
   } catch (err) { console.error("Failed to open editor:", err); }
 }
@@ -491,19 +502,6 @@ onMounted(async () => {
 
   await connectionStore.loadAll();
 
-  // Restore saved theme so every terminal opens with the user's preferred colors
-  try {
-    const savedThemeName = await invoke<string | null>("get_setting", { key: "active_theme" });
-    if (savedThemeName) {
-      const themes = await invoke<Array<{ name: string; foreground: string; background: string; cursor: string; black: string; red: string; green: string; yellow: string; blue: string; magenta: string; cyan: string; white: string; brightBlack: string; brightRed: string; brightGreen: string; brightYellow: string; brightBlue: string; brightMagenta: string; brightCyan: string; brightWhite: string }>>("list_themes");
-      const theme = themes?.find(t => t.name === savedThemeName);
-      if (theme) {
-        sessionStore.setTheme(theme);
-        statusBar.value?.setThemeName(theme.name);
-      }
-    }
-  } catch {}
-
   // Restore workspace — reconnect saved tabs (non-blocking, non-fatal)
   setTimeout(async () => {
     try {

vite.config.ts

@@ -1,20 +1,10 @@
-import { defineConfig, type Plugin } from "vite";
+import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
 import tailwindcss from "@tailwindcss/vite";
 import { resolve } from "path";
 
-/** Strip crossorigin attribute from HTML — WKWebView + Tauri custom protocol compatibility. */
-function stripCrossOrigin(): Plugin {
-  return {
-    name: "strip-crossorigin",
-    transformIndexHtml(html) {
-      return html.replace(/ crossorigin/g, "");
-    },
-  };
-}
-
 export default defineConfig({
-  plugins: [vue(), tailwindcss(), stripCrossOrigin()],
+  plugins: [vue(), tailwindcss()],
   resolve: {
     alias: {
       "@": resolve(__dirname, "src"),
@@ -33,9 +23,5 @@ export default defineConfig({
     target: ["es2021", "chrome100", "safari13"],
     minify: !process.env.TAURI_DEBUG ? "esbuild" : false,
     sourcemap: !!process.env.TAURI_DEBUG,
-    // Disable crossorigin attribute on script/link tags — WKWebView on
-    // macOS may reject CORS-mode requests for Tauri's custom tauri://
-    // protocol in dynamically created child WebviewWindows.
-    crossOriginLoading: false,
   },
 });