feat: N-16 DWM cloaking prototype — hide windows from screen capture

Add collector/src/cloaking.rs with three public functions:
- cloak_window(hwnd): sets DWMWA_CLOAK=TRUE via DwmSetWindowAttribute
- uncloak_window(hwnd): sets DWMWA_CLOAK=FALSE
- is_cloaked(hwnd): reads DWMWA_CLOAKED attribute

No elevated privileges required (Windows 8+). PowerToys uses this
technique for instant show/hide of Command Palette. Foundation for
making DesktopAI's avatar overlay invisible to PrintScreen/OBS while
remaining visible on desktop.

8 tests (5 Windows real-DWM + 3 non-Windows stubs), Rust count 94→97.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

collector/Cargo.toml

@@ -31,7 +31,8 @@ windows = { version = "0.52", features = [
   "Win32_System_Com",
   "Win32_System_Variant",
   "Win32_System_Ole",
-  "Win32_Graphics_Gdi"
+  "Win32_Graphics_Gdi",
+  "Win32_Graphics_Dwm"
 ] }
 url = "2.5"
 tungstenite = "0.21"

collector/src/cloaking.rs

@@ -0,0 +1,214 @@
+//! DWM Window Cloaking — hide windows from screen capture while remaining visible.
+//!
+//! Uses `DwmSetWindowAttribute(DWMWA_CLOAK)` to make a window invisible to
+//! PrintScreen, OBS, and other capture methods while still rendering on desktop.
+//! PowerToys and Flow Launcher use this technique for instant show/hide.
+//!
+//! # Requirements
+//! - Windows 8+ (DWM is always-on since Windows 8)
+//! - No elevated privileges required
+//! - Window must be a top-level window (not a child window)
+
+#[cfg(windows)]
+use std::ffi::c_void;
+#[cfg(windows)]
+use std::mem;
+
+#[cfg(windows)]
+use windows::Win32::Foundation::{BOOL, HWND};
+#[cfg(windows)]
+use windows::Win32::Graphics::Dwm::{
+    DwmGetWindowAttribute, DwmSetWindowAttribute, DWMWA_CLOAK, DWMWA_CLOAKED,
+};
+
+/// Cloak a window — invisible to screen capture but still visible on desktop.
+#[cfg(windows)]
+pub fn cloak_window(hwnd: HWND) -> windows::core::Result<()> {
+    set_cloak(hwnd, true)
+}
+
+/// Uncloak a window — visible to screen capture again.
+#[cfg(windows)]
+pub fn uncloak_window(hwnd: HWND) -> windows::core::Result<()> {
+    set_cloak(hwnd, false)
+}
+
+/// Check whether a window is currently cloaked (by app, shell, or inheritance).
+#[cfg(windows)]
+pub fn is_cloaked(hwnd: HWND) -> windows::core::Result<bool> {
+    let mut cloaked: u32 = 0;
+    unsafe {
+        DwmGetWindowAttribute(
+            hwnd,
+            DWMWA_CLOAKED,
+            &mut cloaked as *mut u32 as *mut c_void,
+            mem::size_of::<u32>() as u32,
+        )?;
+    }
+    Ok(cloaked != 0)
+}
+
+#[cfg(windows)]
+fn set_cloak(hwnd: HWND, cloak: bool) -> windows::core::Result<()> {
+    let value = if cloak { BOOL(1) } else { BOOL(0) };
+    unsafe {
+        DwmSetWindowAttribute(
+            hwnd,
+            DWMWA_CLOAK,
+            &value as *const BOOL as *const c_void,
+            mem::size_of::<BOOL>() as u32,
+        )
+    }
+}
+
+// --- Non-Windows stubs (compile on Linux, always return error) ---
+
+/// Cloak a window (non-Windows stub — always errors).
+#[cfg(not(windows))]
+pub fn cloak_window(_hwnd_raw: isize) -> Result<(), String> {
+    Err("DWM cloaking requires Windows".to_string())
+}
+
+/// Uncloak a window (non-Windows stub — always errors).
+#[cfg(not(windows))]
+pub fn uncloak_window(_hwnd_raw: isize) -> Result<(), String> {
+    Err("DWM cloaking requires Windows".to_string())
+}
+
+/// Check cloaked state (non-Windows stub — always errors).
+#[cfg(not(windows))]
+pub fn is_cloaked(_hwnd_raw: isize) -> Result<bool, String> {
+    Err("DWM cloaking requires Windows".to_string())
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ---- Windows tests (real DWM API calls) ----
+
+    #[cfg(windows)]
+    mod windows_tests {
+        use super::*;
+        use windows::Win32::Foundation::HWND;
+        use windows::Win32::UI::WindowsAndMessaging::{
+            CreateWindowExW, DestroyWindow, RegisterClassW, CS_HREDRAW, CS_VREDRAW,
+            WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_OVERLAPPEDWINDOW, WNDCLASSW,
+        };
+        use windows::core::w;
+        use std::sync::Once;
+
+        static REGISTER_CLASS: Once = Once::new();
+        const CLASS_NAME: &str = "DesktopAICloakTest\0";
+
+        fn register_test_class() {
+            REGISTER_CLASS.call_once(|| unsafe {
+                let class_name = w!("DesktopAICloakTest");
+                let wc = WNDCLASSW {
+                    style: CS_HREDRAW | CS_VREDRAW,
+                    lpszClassName: class_name.into(),
+                    ..Default::default()
+                };
+                RegisterClassW(&wc);
+            });
+        }
+
+        fn create_test_window() -> HWND {
+            register_test_class();
+            unsafe {
+                CreateWindowExW(
+                    WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
+                    w!("DesktopAICloakTest"),
+                    w!("CloakTestWindow"),
+                    WS_OVERLAPPEDWINDOW,
+                    0, 0, 100, 100,
+                    None,
+                    None,
+                    None,
+                    None,
+                )
+            }
+            .expect("Failed to create test window")
+        }
+
+        #[test]
+        fn test_cloak_and_uncloak_round_trip() {
+            let hwnd = create_test_window();
+
+            // Cloak the window
+            cloak_window(hwnd).expect("cloak_window failed");
+            assert!(is_cloaked(hwnd).expect("is_cloaked failed"), "window should be cloaked");
+
+            // Uncloak the window
+            uncloak_window(hwnd).expect("uncloak_window failed");
+            assert!(!is_cloaked(hwnd).expect("is_cloaked failed"), "window should not be cloaked");
+
+            unsafe { let _ = DestroyWindow(hwnd); }
+        }
+
+        #[test]
+        fn test_uncloak_uncloaked_window_is_noop() {
+            let hwnd = create_test_window();
+            // Uncloaking an already-visible window should succeed silently
+            uncloak_window(hwnd).expect("uncloak on visible window should be Ok");
+            assert!(!is_cloaked(hwnd).expect("is_cloaked failed"));
+            unsafe { let _ = DestroyWindow(hwnd); }
+        }
+
+        #[test]
+        fn test_cloak_twice_is_idempotent() {
+            let hwnd = create_test_window();
+            cloak_window(hwnd).expect("first cloak failed");
+            cloak_window(hwnd).expect("second cloak should also succeed");
+            assert!(is_cloaked(hwnd).expect("is_cloaked failed"));
+            uncloak_window(hwnd).expect("cleanup uncloak failed");
+            unsafe { let _ = DestroyWindow(hwnd); }
+        }
+
+        #[test]
+        fn test_is_cloaked_on_new_window() {
+            let hwnd = create_test_window();
+            assert!(!is_cloaked(hwnd).expect("is_cloaked failed"), "fresh window should not be cloaked");
+            unsafe { let _ = DestroyWindow(hwnd); }
+        }
+
+        #[test]
+        fn test_invalid_hwnd_returns_error() {
+            let bad_hwnd = HWND(0xDEAD as *mut _);
+            assert!(cloak_window(bad_hwnd).is_err(), "cloaking invalid HWND should fail");
+            assert!(is_cloaked(bad_hwnd).is_err(), "querying invalid HWND should fail");
+        }
+    }
+
+    // ---- Non-Windows tests (stub error paths) ----
+
+    #[cfg(not(windows))]
+    mod non_windows_tests {
+        use super::*;
+
+        #[test]
+        fn test_cloak_fails_on_non_windows() {
+            let result = cloak_window(0);
+            assert!(result.is_err());
+            assert_eq!(result.unwrap_err(), "DWM cloaking requires Windows");
+        }
+
+        #[test]
+        fn test_uncloak_fails_on_non_windows() {
+            let result = uncloak_window(0);
+            assert!(result.is_err());
+            assert_eq!(result.unwrap_err(), "DWM cloaking requires Windows");
+        }
+
+        #[test]
+        fn test_is_cloaked_fails_on_non_windows() {
+            let result = is_cloaked(0);
+            assert!(result.is_err());
+            assert_eq!(result.unwrap_err(), "DWM cloaking requires Windows");
+        }
+    }
+}

collector/src/lib.rs

@@ -16,6 +16,7 @@ pub mod uia;
 pub mod windows;
 #[cfg(windows)]
 pub mod screenshot;
+pub mod cloaking;
 
 pub mod command;
 #[cfg(feature = "detection")]
@@ -35,6 +36,8 @@ pub use uia::{allow_uia_snapshot, get_uia, extract_document_text, uia_snapshot};
 pub use windows::{window_title, process_path, build_event, win_event_hook, idle_duration_ms};
 #[cfg(windows)]
 pub use screenshot::{capture_screenshot, init_screenshot_buffer};
+#[cfg(windows)]
+pub use cloaking::{cloak_window, uncloak_window, is_cloaked};
 
 #[cfg(windows)]
 use crossbeam_channel::unbounded;