test

This commit splits the komorebi crate into a mixed binary and library
crate.

All types and logic related to window management have been moved under
lib.rs, and are imported from there for use in main.rs, which is now
only responsible for starting and running the window manager process.

In preparation for exposing a new komorebi-client crate in the future,
serde::Deserialize has been derived on Notification and any struct that
may appear in a notification receievd by a process that has subscribed
to event updates.

re #659

Cargo.lock

@@ -157,9 +157,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "clap"
-version = "4.5.0"
+version = "4.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80c21025abd42669a92efc996ef13cfb2c5c627858421ea58d5c3b331a6c134f"
+checksum = "c918d541ef2913577a0f9566e9ce27cb35b6df072075769e0b26cb5a554520da"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -167,9 +167,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.0"
+version = "4.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458bf1f341769dfcf849846f65dffdf9146daa56bcd2a47cb4e1de9915567c99"
+checksum = "9f3e7391dad68afb0c2ede1bf619f579a3dc9c2ec67f089baa397123a2f3d1eb"
 dependencies = [
  "anstream",
  "anstyle",
@@ -788,7 +788,7 @@ dependencies = [
 
 [[package]]
 name = "komorebi"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 dependencies = [
  "bitflags 2.4.2",
  "clap",
@@ -828,7 +828,7 @@ dependencies = [
 
 [[package]]
 name = "komorebi-core"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 dependencies = [
  "clap",
  "color-eyre",
@@ -844,7 +844,7 @@ dependencies = [
 
 [[package]]
 name = "komorebic"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 dependencies = [
  "clap",
  "color-eyre",
@@ -871,7 +871,7 @@ dependencies = [
 
 [[package]]
 name = "komorebic-no-console"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 
 [[package]]
 name = "lazy_static"

README.md

@@ -82,6 +82,8 @@ A [detailed installation and quickstart
 guide](https://lgug2z.github.io/komorebi/installation.html) is available which shows how to get started
 using `scoop`, `winget` or building from source.
 
+[![Watch the quickstart walkthrough video](https://img.youtube.com/vi/H9-_c1egQ4g/hqdefault.jpg)](https://www.youtube.com/watch?v=H9-_c1egQ4g)
+
 # Demonstrations
 
 [@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows

komorebi-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

komorebi-core/src/lib.rs

@@ -156,8 +156,10 @@ pub enum SocketMessage {
     ToggleMouseFollowsFocus,
     RemoveTitleBar(ApplicationIdentifier, String),
     ToggleTitleBars,
-    AddSubscriber(String),
-    RemoveSubscriber(String),
+    AddSubscriberSocket(String),
+    RemoveSubscriberSocket(String),
+    AddSubscriberPipe(String),
+    RemoveSubscriberPipe(String),
     ApplicationSpecificConfigurationSchema,
     NotificationSchema,
     SocketSchema,

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]

komorebi/src/container.rs

@@ -3,14 +3,14 @@ use std::collections::VecDeque;
 use getset::Getters;
 use nanoid::nanoid;
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 
 use crate::ring::Ring;
 use crate::window::Window;
 
-#[derive(Debug, Clone, Serialize, Getters, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, Getters, JsonSchema)]
 pub struct Container {
-    #[serde(skip_serializing)]
     #[getset(get = "pub")]
     id: String,
     windows: Ring<Window>,

komorebi/src/lib.rs

@@ -0,0 +1,358 @@
+pub mod border;
+pub mod com;
+#[macro_use]
+pub mod ring;
+pub mod container;
+pub mod hidden;
+pub mod monitor;
+pub mod process_command;
+pub mod process_event;
+pub mod process_movement;
+pub mod set_window_position;
+pub mod static_config;
+pub mod styles;
+pub mod window;
+pub mod window_manager;
+pub mod window_manager_event;
+pub mod windows_api;
+pub mod windows_callbacks;
+pub mod winevent;
+pub mod winevent_listener;
+pub mod workspace;
+
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Write;
+use std::net::TcpStream;
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicI32;
+use std::sync::atomic::AtomicIsize;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+pub use hidden::*;
+pub use process_command::*;
+pub use process_event::*;
+pub use static_config::*;
+pub use window_manager::*;
+pub use window_manager_event::*;
+pub use windows_api::WindowsApi;
+pub use windows_api::*;
+
+use color_eyre::Result;
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::config_generation::MatchingStrategy;
+use komorebi_core::ApplicationIdentifier;
+use komorebi_core::HidingBehaviour;
+use komorebi_core::Rect;
+use komorebi_core::SocketMessage;
+use os_info::Version;
+use parking_lot::Mutex;
+use regex::Regex;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use uds_windows::UnixStream;
+use which::which;
+use winreg::enums::HKEY_CURRENT_USER;
+use winreg::RegKey;
+
+type WorkspaceRule = (usize, usize, bool);
+
+lazy_static! {
+    static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
+    static ref LAYERED_WHITELIST: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Exe,
+            id: String::from("steam.exe"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+    ]));
+    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> =
+        Arc::new(Mutex::new(vec![
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("explorer.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("firefox.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("chrome.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("idea64.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("ApplicationFrameHost.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("steam.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            }
+        ]));
+    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Exe,
+            id: String::from("firefox.exe"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Exe,
+            id: String::from("idea64.exe"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+    ]));
+    static ref MONITOR_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, Rect>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref DISPLAY_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, String>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, WorkspaceRule>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
+    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        // mstsc.exe creates these on Windows 11 when a WSL process is launched
+        // https://github.com/LGUG2Z/komorebi/issues/74
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Class,
+            id: String::from("OPContainerClass"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Class,
+            id: String::from("IHWindowClass"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        }
+    ]));
+    static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
+        "Chrome_RenderWidgetHostHWND".to_string(),
+    ]));
+    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
+    static ref WSL2_UI_PROCESSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
+        "X410.exe".to_string(),
+        "vcxsrv.exe".to_string(),
+    ]));
+    static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref SUBSCRIPTION_SOCKETS: Arc<Mutex<HashMap<String, PathBuf>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
+        Arc::new(Mutex::new(HidingBehaviour::Minimize));
+    pub static ref HOME_DIR: PathBuf = {
+        std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(|_| dirs::home_dir().expect("there is no home directory"), |home_path| {
+            let home = PathBuf::from(&home_path);
+
+            if home.as_path().is_dir() {
+                home
+            } else {
+                panic!(
+                    "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory",
+                );
+            }
+        })
+    };
+    static ref DATA_DIR: PathBuf = dirs::data_local_dir().expect("there is no local data directory").join("komorebi");
+    pub static ref AHK_EXE: String = {
+        let mut ahk: String = String::from("autohotkey.exe");
+
+        if let Ok(komorebi_ahk_exe) = std::env::var("KOMOREBI_AHK_EXE") {
+            if which(&komorebi_ahk_exe).is_ok() {
+                ahk = komorebi_ahk_exe;
+            }
+        }
+
+        ahk
+    };
+    static ref WINDOWS_11: bool = {
+        matches!(
+            os_info::get().version(),
+            Version::Semantic(_, _, x) if x >= &22000
+        )
+    };
+
+    static ref BORDER_RECT: Arc<Mutex<Rect>> =
+        Arc::new(Mutex::new(Rect::default()));
+
+    static ref BORDER_OFFSET: Arc<Mutex<Option<Rect>>> =
+        Arc::new(Mutex::new(None));
+
+    // Use app-specific titlebar removal options where possible
+    // eg. Windows Terminal, IntelliJ IDEA, Firefox
+    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
+}
+
+pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
+pub static DEFAULT_CONTAINER_PADDING: AtomicI32 = AtomicI32::new(10);
+
+pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
+pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
+pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
+pub static ALT_FOCUS_HACK: AtomicBool = AtomicBool::new(false);
+pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(false);
+pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
+pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);
+pub static BORDER_COLOUR_SINGLE: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_COLOUR_STACK: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_COLOUR_MONOCLE: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_COLOUR_CURRENT: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(20);
+// 0 0 0 aka pure black, I doubt anyone will want this as a border colour
+pub const TRANSPARENCY_COLOUR: u32 = 0;
+pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
+
+pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);
+
+#[must_use]
+pub fn current_virtual_desktop() -> Option<Vec<u8>> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // This is the path on Windows 10
+    let mut current = hkcu
+        .open_subkey(format!(
+            r#"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\SessionInfo\{}\VirtualDesktops"#,
+            SESSION_ID.load(Ordering::SeqCst)
+        ))
+        .ok()
+        .and_then(
+            |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
+                Ok(current) => Option::from(current.bytes),
+                Err(_) => None,
+            },
+        );
+
+    // This is the path on Windows 11
+    if current.is_none() {
+        current = hkcu
+            .open_subkey(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VirtualDesktops")
+            .ok()
+            .and_then(
+                |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
+                    Ok(current) => Option::from(current.bytes),
+                    Err(_) => None,
+                },
+            );
+    }
+
+    // For Win10 users that do not use virtual desktops, the CurrentVirtualDesktop value will not
+    // exist until one has been created in the task view
+
+    // The registry value will also not exist on user login if virtual desktops have been created
+    // but the task view has not been initiated
+
+    // In both of these cases, we return None, and the virtual desktop validation will never run. In
+    // the latter case, if the user desires this validation after initiating the task view, komorebi
+    // should be restarted, and then when this // fn runs again for the first time, it will pick up
+    // the value of CurrentVirtualDesktop and validate against it accordingly
+    current
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(untagged)]
+pub enum NotificationEvent {
+    WindowManager(WindowManagerEvent),
+    Socket(SocketMessage),
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct Notification {
+    pub event: NotificationEvent,
+    pub state: State,
+}
+
+pub fn notify_subscribers(notification: &str) -> Result<()> {
+    let mut stale_sockets = vec![];
+    let mut sockets = SUBSCRIPTION_SOCKETS.lock();
+
+    for (socket, path) in &mut *sockets {
+        match UnixStream::connect(path) {
+            Ok(mut stream) => {
+                tracing::debug!("pushed notification to subscriber: {socket}");
+                stream.write_all(notification.as_bytes())?;
+            }
+            Err(_) => {
+                stale_sockets.push(socket.clone());
+            }
+        }
+    }
+
+    for socket in stale_sockets {
+        tracing::warn!("removing stale subscription: {socket}");
+        sockets.remove(&socket);
+    }
+
+    let mut stale_pipes = vec![];
+    let mut pipes = SUBSCRIPTION_PIPES.lock();
+    for (subscriber, pipe) in &mut *pipes {
+        match writeln!(pipe, "{notification}") {
+            Ok(()) => {
+                tracing::debug!("pushed notification to subscriber: {subscriber}");
+            }
+            Err(error) => {
+                // ERROR_FILE_NOT_FOUND
+                // 2 (0x2)
+                // The system cannot find the file specified.
+
+                // ERROR_NO_DATA
+                // 232 (0xE8)
+                // The pipe is being closed.
+
+                // Remove the subscription; the process will have to subscribe again
+                if let Some(2 | 232) = error.raw_os_error() {
+                    stale_pipes.push(subscriber.clone());
+                }
+            }
+        }
+    }
+
+    for subscriber in stale_pipes {
+        tracing::warn!("removing stale subscription: {}", subscriber);
+        pipes.remove(&subscriber);
+    }
+
+    Ok(())
+}
+
+pub fn load_configuration() -> Result<()> {
+    let config_pwsh = HOME_DIR.join("komorebi.ps1");
+    let config_ahk = HOME_DIR.join("komorebi.ahk");
+
+    if config_pwsh.exists() {
+        let powershell_exe = if which("pwsh.exe").is_ok() {
+            "pwsh.exe"
+        } else {
+            "powershell.exe"
+        };
+
+        tracing::info!("loading configuration file: {}", config_pwsh.display());
+
+        Command::new(powershell_exe)
+            .arg(config_pwsh.as_os_str())
+            .output()?;
+    } else if config_ahk.exists() && which(&*AHK_EXE).is_ok() {
+        tracing::info!("loading configuration file: {}", config_ahk.display());
+
+        Command::new(&*AHK_EXE)
+            .arg(config_ahk.as_os_str())
+            .output()?;
+    }
+
+    Ok(())
+}

komorebi/src/main.rs

@@ -6,16 +6,7 @@
     clippy::significant_drop_in_scrutinee
 )]
 
-use std::collections::HashMap;
-use std::fs::File;
-use std::io::Write;
-use std::net::TcpStream;
 use std::path::PathBuf;
-use std::process::Command;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::AtomicIsize;
-use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 #[cfg(feature = "deadlock_detection")]
@@ -26,219 +17,29 @@ use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::Backoff;
-use lazy_static::lazy_static;
-use os_info::Version;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
-use regex::Regex;
-use schemars::JsonSchema;
-use serde::Serialize;
 use sysinfo::Process;
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
-use which::which;
-use winreg::enums::HKEY_CURRENT_USER;
-use winreg::RegKey;
 
-use crate::hidden::Hidden;
-use komorebi_core::config_generation::IdWithIdentifier;
-use komorebi_core::config_generation::MatchingStrategy;
-use komorebi_core::ApplicationIdentifier;
-use komorebi_core::HidingBehaviour;
-use komorebi_core::Rect;
-use komorebi_core::SocketMessage;
-
-use crate::process_command::listen_for_commands;
-use crate::process_command::listen_for_commands_tcp;
-use crate::process_event::listen_for_events;
-use crate::process_movement::listen_for_movements;
-use crate::static_config::StaticConfig;
-use crate::window_manager::State;
-use crate::window_manager::WindowManager;
-use crate::window_manager_event::WindowManagerEvent;
-use crate::windows_api::WindowsApi;
-
-#[macro_use]
-mod ring;
-
-mod border;
-mod com;
-mod container;
-mod hidden;
-mod monitor;
-mod process_command;
-mod process_event;
-mod process_movement;
-mod set_window_position;
-mod static_config;
-mod styles;
-mod window;
-mod window_manager;
-mod window_manager_event;
-mod windows_api;
-mod windows_callbacks;
-mod winevent;
-mod winevent_listener;
-mod workspace;
-
-type WorkspaceRule = (usize, usize, bool);
-
-lazy_static! {
-    static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
-    static ref LAYERED_WHITELIST: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
-        IdWithIdentifier {
-            kind: ApplicationIdentifier::Exe,
-            id: String::from("steam.exe"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
-        },
-    ]));
-    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> =
-        Arc::new(Mutex::new(vec![
-            IdWithIdentifier {
-                kind: ApplicationIdentifier::Exe,
-                id: String::from("explorer.exe"),
-                matching_strategy: Option::from(MatchingStrategy::Equals),
-            },
-            IdWithIdentifier {
-                kind: ApplicationIdentifier::Exe,
-                id: String::from("firefox.exe"),
-                matching_strategy: Option::from(MatchingStrategy::Equals),
-            },
-            IdWithIdentifier {
-                kind: ApplicationIdentifier::Exe,
-                id: String::from("chrome.exe"),
-                matching_strategy: Option::from(MatchingStrategy::Equals),
-            },
-            IdWithIdentifier {
-                kind: ApplicationIdentifier::Exe,
-                id: String::from("idea64.exe"),
-                matching_strategy: Option::from(MatchingStrategy::Equals),
-            },
-            IdWithIdentifier {
-                kind: ApplicationIdentifier::Exe,
-                id: String::from("ApplicationFrameHost.exe"),
-                matching_strategy: Option::from(MatchingStrategy::Equals),
-            },
-            IdWithIdentifier {
-                kind: ApplicationIdentifier::Exe,
-                id: String::from("steam.exe"),
-                matching_strategy: Option::from(MatchingStrategy::Equals),
-            }
-        ]));
-    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
-        IdWithIdentifier {
-            kind: ApplicationIdentifier::Exe,
-            id: String::from("firefox.exe"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
-        },
-        IdWithIdentifier {
-            kind: ApplicationIdentifier::Exe,
-            id: String::from("idea64.exe"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
-        },
-    ]));
-    static ref MONITOR_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, Rect>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-    static ref DISPLAY_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, String>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, WorkspaceRule>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-    static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
-    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
-        // mstsc.exe creates these on Windows 11 when a WSL process is launched
-        // https://github.com/LGUG2Z/komorebi/issues/74
-        IdWithIdentifier {
-            kind: ApplicationIdentifier::Class,
-            id: String::from("OPContainerClass"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
-        },
-        IdWithIdentifier {
-            kind: ApplicationIdentifier::Class,
-            id: String::from("IHWindowClass"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
-        }
-    ]));
-    static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
-        "Chrome_RenderWidgetHostHWND".to_string(),
-    ]));
-    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
-    static ref WSL2_UI_PROCESSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
-        "X410.exe".to_string(),
-        "vcxsrv.exe".to_string(),
-    ]));
-    static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-    static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-    static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
-        Arc::new(Mutex::new(HidingBehaviour::Minimize));
-    static ref HOME_DIR: PathBuf = {
-        std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(|_| dirs::home_dir().expect("there is no home directory"), |home_path| {
-            let home = PathBuf::from(&home_path);
-
-            if home.as_path().is_dir() {
-                home
-            } else {
-                panic!(
-                    "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory",
-                );
-            }
-        })
-    };
-    static ref DATA_DIR: PathBuf = dirs::data_local_dir().expect("there is no local data directory").join("komorebi");
-    static ref AHK_EXE: String = {
-        let mut ahk: String = String::from("autohotkey.exe");
-
-        if let Ok(komorebi_ahk_exe) = std::env::var("KOMOREBI_AHK_EXE") {
-            if which(&komorebi_ahk_exe).is_ok() {
-                ahk = komorebi_ahk_exe;
-            }
-        }
-
-        ahk
-    };
-    static ref WINDOWS_11: bool = {
-        matches!(
-            os_info::get().version(),
-            Version::Semantic(_, _, x) if x >= &22000
-        )
-    };
-
-    static ref BORDER_RECT: Arc<Mutex<Rect>> =
-        Arc::new(Mutex::new(Rect::default()));
-
-    static ref BORDER_OFFSET: Arc<Mutex<Option<Rect>>> =
-        Arc::new(Mutex::new(None));
-
-    // Use app-specific titlebar removal options where possible
-    // eg. Windows Terminal, IntelliJ IDEA, Firefox
-    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
-}
-
-pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
-pub static DEFAULT_CONTAINER_PADDING: AtomicI32 = AtomicI32::new(10);
-
-pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
-pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
-pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
-pub static ALT_FOCUS_HACK: AtomicBool = AtomicBool::new(false);
-pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(false);
-pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
-pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);
-pub static BORDER_COLOUR_SINGLE: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_COLOUR_STACK: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_COLOUR_MONOCLE: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_COLOUR_CURRENT: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(20);
-// 0 0 0 aka pure black, I doubt anyone will want this as a border colour
-pub const TRANSPARENCY_COLOUR: u32 = 0;
-pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
-
-pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);
+use komorebi::hidden::Hidden;
+use komorebi::load_configuration;
+use komorebi::process_command::listen_for_commands;
+use komorebi::process_command::listen_for_commands_tcp;
+use komorebi::process_event::listen_for_events;
+use komorebi::process_movement::listen_for_movements;
+use komorebi::static_config::StaticConfig;
+use komorebi::window_manager::WindowManager;
+use komorebi::window_manager_event::WindowManagerEvent;
+use komorebi::windows_api::WindowsApi;
+use komorebi::winevent_listener;
+use komorebi::CUSTOM_FFM;
+use komorebi::HOME_DIR;
+use komorebi::INITIAL_CONFIGURATION_LOADED;
+use komorebi::SESSION_ID;
 
 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
@@ -303,124 +104,6 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     Ok((guard, color_guard))
 }
 
-pub fn load_configuration() -> Result<()> {
-    let config_pwsh = HOME_DIR.join("komorebi.ps1");
-    let config_ahk = HOME_DIR.join("komorebi.ahk");
-
-    if config_pwsh.exists() {
-        let powershell_exe = if which("pwsh.exe").is_ok() {
-            "pwsh.exe"
-        } else {
-            "powershell.exe"
-        };
-
-        tracing::info!("loading configuration file: {}", config_pwsh.display());
-
-        Command::new(powershell_exe)
-            .arg(config_pwsh.as_os_str())
-            .output()?;
-    } else if config_ahk.exists() && which(&*AHK_EXE).is_ok() {
-        tracing::info!("loading configuration file: {}", config_ahk.display());
-
-        Command::new(&*AHK_EXE)
-            .arg(config_ahk.as_os_str())
-            .output()?;
-    }
-
-    Ok(())
-}
-
-#[must_use]
-pub fn current_virtual_desktop() -> Option<Vec<u8>> {
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-
-    // This is the path on Windows 10
-    let mut current = hkcu
-        .open_subkey(format!(
-            r#"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\SessionInfo\{}\VirtualDesktops"#,
-            SESSION_ID.load(Ordering::SeqCst)
-        ))
-        .ok()
-        .and_then(
-            |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
-                Ok(current) => Option::from(current.bytes),
-                Err(_) => None,
-            },
-        );
-
-    // This is the path on Windows 11
-    if current.is_none() {
-        current = hkcu
-            .open_subkey(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VirtualDesktops")
-            .ok()
-            .and_then(
-                |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
-                    Ok(current) => Option::from(current.bytes),
-                    Err(_) => None,
-                },
-            );
-    }
-
-    // For Win10 users that do not use virtual desktops, the CurrentVirtualDesktop value will not
-    // exist until one has been created in the task view
-
-    // The registry value will also not exist on user login if virtual desktops have been created
-    // but the task view has not been initiated
-
-    // In both of these cases, we return None, and the virtual desktop validation will never run. In
-    // the latter case, if the user desires this validation after initiating the task view, komorebi
-    // should be restarted, and then when this // fn runs again for the first time, it will pick up
-    // the value of CurrentVirtualDesktop and validate against it accordingly
-    current
-}
-
-#[derive(Debug, Serialize, JsonSchema)]
-#[serde(untagged)]
-pub enum NotificationEvent {
-    WindowManager(WindowManagerEvent),
-    Socket(SocketMessage),
-}
-
-#[derive(Debug, Serialize, JsonSchema)]
-pub struct Notification {
-    pub event: NotificationEvent,
-    pub state: State,
-}
-
-pub fn notify_subscribers(notification: &str) -> Result<()> {
-    let mut stale_subscriptions = vec![];
-    let mut subscriptions = SUBSCRIPTION_PIPES.lock();
-    for (subscriber, pipe) in &mut *subscriptions {
-        match writeln!(pipe, "{notification}") {
-            Ok(()) => {
-                tracing::debug!("pushed notification to subscriber: {}", subscriber);
-            }
-            Err(error) => {
-                // ERROR_FILE_NOT_FOUND
-                // 2 (0x2)
-                // The system cannot find the file specified.
-
-                // ERROR_NO_DATA
-                // 232 (0xE8)
-                // The pipe is being closed.
-
-                // Remove the subscription; the process will have to subscribe again
-                if let Some(2 | 232) = error.raw_os_error() {
-                    let subscriber_cl = subscriber.clone();
-                    stale_subscriptions.push(subscriber_cl);
-                }
-            }
-        }
-    }
-
-    for subscriber in stale_subscriptions {
-        tracing::warn!("removing stale subscription: {}", subscriber);
-        subscriptions.remove(&subscriber);
-    }
-
-    Ok(())
-}
-
 #[cfg(feature = "deadlock_detection")]
 #[tracing::instrument]
 fn detect_deadlocks() {

komorebi/src/monitor.rs

@@ -9,6 +9,7 @@ use getset::Getters;
 use getset::MutGetters;
 use getset::Setters;
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 
 use komorebi_core::Rect;
@@ -17,7 +18,9 @@ use crate::container::Container;
 use crate::ring::Ring;
 use crate::workspace::Workspace;
 
-#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema,
+)]
 pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
     id: isize,
@@ -34,10 +37,9 @@ pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
     work_area_offset: Option<Rect>,
     workspaces: Ring<Workspace>,
-    #[serde(skip_serializing)]
+    #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
     last_focused_workspace: Option<usize>,
-    #[serde(skip_serializing)]
     #[getset(get_mut = "pub")]
     workspace_names: HashMap<usize, String>,
 }

komorebi/src/process_command.rs

@@ -4,7 +4,6 @@ use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Read;
-use std::io::Write;
 use std::net::TcpListener;
 use std::net::TcpStream;
 use std::num::NonZeroUsize;
@@ -72,6 +71,7 @@ use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REMOVE_TITLEBARS;
 use crate::SUBSCRIPTION_PIPES;
+use crate::SUBSCRIPTION_SOCKETS;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
@@ -144,8 +144,15 @@ pub fn listen_for_commands_tcp(wm: Arc<Mutex<WindowManager>>, port: usize) {
 }
 
 impl WindowManager {
-    #[tracing::instrument(skip(self))]
-    pub fn process_command(&mut self, message: SocketMessage) -> Result<()> {
+    // TODO(raggi): wrap reply in a newtype that can decorate a human friendly
+    // name for the peer, such as getting the pid of the komorebic process for
+    // the UDS or the IP:port for TCP.
+    #[tracing::instrument(skip(self, reply))]
+    pub fn process_command(
+        &mut self,
+        message: SocketMessage,
+        mut reply: impl std::io::Write,
+    ) -> Result<()> {
         if let Some(virtual_desktop_id) = &self.virtual_desktop_id {
             if let Some(id) = current_virtual_desktop() {
                 if id != *virtual_desktop_id {
@@ -743,15 +750,11 @@ impl WindowManager {
                     Err(error) => error.to_string(),
                 };
 
-                let socket = DATA_DIR.join("komorebic.sock");
+                tracing::info!("replying to state");
 
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(state.as_bytes())?;
-                    }
-                }
+                reply.write_all(state.as_bytes())?;
+
+                tracing::info!("replying to state done");
             }
             SocketMessage::VisibleWindows => {
                 let mut monitor_visible_windows = HashMap::new();
@@ -774,15 +777,7 @@ impl WindowManager {
                         Err(error) => error.to_string(),
                     };
 
-                let socket = DATA_DIR.join("komorebic.sock");
-
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(visible_windows_state.as_bytes())?;
-                    }
-                }
+                reply.write_all(visible_windows_state.as_bytes())?;
             }
 
             SocketMessage::Query(query) => {
@@ -801,15 +796,7 @@ impl WindowManager {
                 }
                 .to_string();
 
-                let socket = DATA_DIR.join("komorebic.sock");
-
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(response.as_bytes())?;
-                    }
-                }
+                reply.write_all(response.as_bytes())?;
             }
             SocketMessage::ResizeWindowEdge(direction, sizing) => {
                 self.resize_window(direction, sizing, self.resize_delta, true)?;
@@ -1170,7 +1157,16 @@ impl WindowManager {
                 workspace.set_resize_dimensions(resize);
                 self.update_focused_workspace(false)?;
             }
-            SocketMessage::AddSubscriber(ref subscriber) => {
+            SocketMessage::AddSubscriberSocket(ref socket) => {
+                let mut sockets = SUBSCRIPTION_SOCKETS.lock();
+                let socket_path = DATA_DIR.join(socket);
+                sockets.insert(socket.clone(), socket_path);
+            }
+            SocketMessage::RemoveSubscriberSocket(ref socket) => {
+                let mut sockets = SUBSCRIPTION_SOCKETS.lock();
+                sockets.remove(socket);
+            }
+            SocketMessage::AddSubscriberPipe(ref subscriber) => {
                 let mut pipes = SUBSCRIPTION_PIPES.lock();
                 let pipe_path = format!(r"\\.\pipe\{subscriber}");
                 let pipe = connect(&pipe_path).map_err(|_| {
@@ -1179,7 +1175,7 @@ impl WindowManager {
 
                 pipes.insert(subscriber.clone(), pipe);
             }
-            SocketMessage::RemoveSubscriber(ref subscriber) => {
+            SocketMessage::RemoveSubscriberPipe(ref subscriber) => {
                 let mut pipes = SUBSCRIPTION_PIPES.lock();
                 pipes.remove(subscriber);
             }
@@ -1275,41 +1271,20 @@ impl WindowManager {
             SocketMessage::ApplicationSpecificConfigurationSchema => {
                 let asc = schema_for!(Vec<ApplicationConfiguration>);
                 let schema = serde_json::to_string_pretty(&asc)?;
-                let socket = DATA_DIR.join("komorebic.sock");
 
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(schema.as_bytes())?;
-                    }
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::NotificationSchema => {
                 let notification = schema_for!(Notification);
                 let schema = serde_json::to_string_pretty(&notification)?;
-                let socket = DATA_DIR.join("komorebic.sock");
 
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(schema.as_bytes())?;
-                    }
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::SocketSchema => {
                 let socket_message = schema_for!(SocketMessage);
                 let schema = serde_json::to_string_pretty(&socket_message)?;
-                let socket = DATA_DIR.join("komorebic.sock");
 
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(schema.as_bytes())?;
-                    }
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::StaticConfigSchema => {
                 let settings = SchemaSettings::default().with(|s| {
@@ -1321,27 +1296,13 @@ impl WindowManager {
                 let gen = settings.into_generator();
                 let socket_message = gen.into_root_schema_for::<StaticConfig>();
                 let schema = serde_json::to_string_pretty(&socket_message)?;
-                let socket = DATA_DIR.join("komorebic.sock");
 
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(schema.as_bytes())?;
-                    }
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::GenerateStaticConfig => {
                 let config = serde_json::to_string_pretty(&StaticConfig::from(&*self))?;
-                let socket = DATA_DIR.join("komorebic.sock");
 
-                let mut connected = false;
-                while !connected {
-                    if let Ok(mut stream) = UnixStream::connect(&socket) {
-                        connected = true;
-                        stream.write_all(config.as_bytes())?;
-                    }
-                }
+                reply.write_all(config.as_bytes())?;
             }
             SocketMessage::RemoveTitleBar(_, ref id) => {
                 let mut identifiers = NO_TITLEBAR.lock();
@@ -1526,9 +1487,13 @@ impl WindowManager {
     }
 }
 
-pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, stream: UnixStream) -> Result<()> {
-    let stream = BufReader::new(stream);
-    for line in stream.lines() {
+pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, mut stream: UnixStream) -> Result<()> {
+    let reader = BufReader::new(stream.try_clone()?);
+    // TODO(raggi): while this processes more than one command, if there are
+    // replies there is no clearly defined protocol for framing yet - it's
+    // perhaps whole-json objects for now, but termination is signalled by
+    // socket shutdown.
+    for line in reader.lines() {
         let message = SocketMessage::from_str(&line?)?;
 
         let mut wm = wm.lock();
@@ -1536,7 +1501,7 @@ pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, stream: UnixStream) ->
         if wm.is_paused {
             return match message {
                 SocketMessage::TogglePause | SocketMessage::State | SocketMessage::Stop => {
-                    Ok(wm.process_command(message)?)
+                    Ok(wm.process_command(message, &mut stream)?)
                 }
                 _ => {
                     tracing::trace!("ignoring while paused");
@@ -1545,7 +1510,7 @@ pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, stream: UnixStream) ->
             };
         }
 
-        wm.process_command(message.clone())?;
+        wm.process_command(message.clone(), &mut stream)?;
         notify_subscribers(&serde_json::to_string(&Notification {
             event: NotificationEvent::Socket(message.clone()),
             state: wm.as_ref().into(),
@@ -1560,11 +1525,11 @@ pub fn read_commands_tcp(
     stream: &mut TcpStream,
     addr: &str,
 ) -> Result<()> {
-    let mut stream = BufReader::new(stream);
+    let mut reader = BufReader::new(stream.try_clone()?);
 
     loop {
         let mut buf = vec![0; 1024];
-        match stream.read(&mut buf) {
+        match reader.read(&mut buf) {
             Err(..) => {
                 tracing::warn!("removing disconnected tcp client: {addr}");
                 let mut connections = TCP_CONNECTIONS.lock();
@@ -1585,7 +1550,7 @@ pub fn read_commands_tcp(
                 if wm.is_paused {
                     return match message {
                         SocketMessage::TogglePause | SocketMessage::State | SocketMessage::Stop => {
-                            Ok(wm.process_command(message)?)
+                            Ok(wm.process_command(message, stream)?)
                         }
                         _ => {
                             tracing::trace!("ignoring while paused");
@@ -1594,7 +1559,7 @@ pub fn read_commands_tcp(
                     };
                 }
 
-                wm.process_command(message.clone())?;
+                wm.process_command(message.clone(), &mut *stream)?;
                 notify_subscribers(&serde_json::to_string(&Notification {
                     event: NotificationEvent::Socket(message.clone()),
                     state: wm.as_ref().into(),

komorebi/src/ring.rs

@@ -1,9 +1,10 @@
 use std::collections::VecDeque;
 
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct Ring<T> {
     elements: VecDeque<T>,
     focused: usize,

komorebi/src/window.rs

@@ -15,6 +15,7 @@ use regex::Regex;
 use schemars::JsonSchema;
 use serde::ser::Error;
 use serde::ser::SerializeStruct;
+use serde::Deserialize;
 use serde::Serialize;
 use serde::Serializer;
 use windows::Win32::Foundation::HWND;
@@ -42,7 +43,7 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-#[derive(Debug, Clone, Copy, JsonSchema)]
+#[derive(Debug, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
     pub(crate) hwnd: isize,
 }

komorebi/src/window_manager.rs

@@ -16,6 +16,7 @@ use hotwatch::notify::DebouncedEvent;
 use hotwatch::Hotwatch;
 use parking_lot::Mutex;
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 use uds_windows::UnixListener;
 
@@ -84,7 +85,7 @@ pub struct WindowManager {
 }
 
 #[allow(clippy::struct_excessive_bools)]
-#[derive(Debug, Serialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct State {
     pub monitors: Ring<Monitor>,
     pub is_paused: bool,

komorebi/src/window_manager_event.rs

@@ -2,6 +2,7 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 
 use crate::window::should_act;
@@ -10,7 +11,7 @@ use crate::winevent::WinEvent;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
 
-#[derive(Debug, Copy, Clone, Serialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type", content = "content")]
 pub enum WindowManagerEvent {
     Destroy(WinEvent, Window),

komorebi/src/windows_api.rs

@@ -264,7 +264,7 @@ impl WindowsApi {
         }
         .ok()
         {
-            Ok(_) => {}
+            Ok(()) => {}
             Err(error) => {
                 tracing::error!("enum_display_devices: {}", error);
                 return Err(error.into());

komorebi/src/winevent.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::use_self)]
 
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_AIA_END;
@@ -88,7 +89,7 @@ use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Display, JsonSchema)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Display, JsonSchema)]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {

komorebi/src/workspace.rs

@@ -9,6 +9,7 @@ use getset::Getters;
 use getset::MutGetters;
 use getset::Setters;
 use schemars::JsonSchema;
+use serde::Deserialize;
 use serde::Serialize;
 
 use komorebi_core::Axis;
@@ -31,19 +32,22 @@ use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::NO_TITLEBAR;
 use crate::REMOVE_TITLEBARS;
 
-#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
+#[allow(clippy::struct_field_names)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema,
+)]
 pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
     name: Option<String>,
     containers: Ring<Container>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
     monocle_container: Option<Container>,
-    #[serde(skip_serializing)]
+    #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
     monocle_container_restore_idx: Option<usize>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
     maximized_window: Option<Window>,
-    #[serde(skip_serializing)]
+    #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
     maximized_window_restore_idx: Option<usize>,
     #[getset(get = "pub", get_mut = "pub")]
@@ -58,7 +62,6 @@ pub struct Workspace {
     workspace_padding: Option<i32>,
     #[getset(get_copy = "pub", set = "pub")]
     container_padding: Option<i32>,
-    #[serde(skip_serializing)]
     #[getset(get = "pub", set = "pub")]
     latest_layout: Vec<Rect>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]

komorebic-no-console/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.21"
+version = "0.1.22-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]

komorebic/src/main.rs

@@ -5,8 +5,9 @@ use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
-use std::io::ErrorKind;
+use std::io::Read;
 use std::io::Write;
+use std::net::Shutdown;
 use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
@@ -20,6 +21,7 @@ use clap::ValueEnum;
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
 use color_eyre::Result;
+use dirs::data_local_dir;
 use fs_tail::TailedFile;
 use heck::ToKebabCase;
 use komorebi_core::resolve_home_path;
@@ -29,7 +31,6 @@ use miette::Report;
 use miette::SourceOffset;
 use miette::SourceSpan;
 use paste::paste;
-use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 use which::which;
 use windows::Win32::Foundation::HWND;
@@ -720,13 +721,25 @@ struct LoadCustomLayout {
 }
 
 #[derive(Parser, AhkFunction)]
-struct Subscribe {
+struct SubscribeSocket {
+    /// Name of the socket to send event notifications to
+    socket: String,
+}
+
+#[derive(Parser, AhkFunction)]
+struct UnsubscribeSocket {
+    /// Name of the socket to stop sending event notifications to
+    socket: String,
+}
+
+#[derive(Parser, AhkFunction)]
+struct SubscribePipe {
     /// Name of the pipe to send event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
 #[derive(Parser, AhkFunction)]
-struct Unsubscribe {
+struct UnsubscribePipe {
     /// Name of the pipe to stop sending event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
@@ -801,12 +814,20 @@ enum SubCommand {
     /// Query the current window manager state
     #[clap(arg_required_else_help = true)]
     Query(Query),
-    /// Subscribe to komorebi events
+    /// Subscribe to komorebi events using a Unix Domain Socket
     #[clap(arg_required_else_help = true)]
-    Subscribe(Subscribe),
+    SubscribeSocket(SubscribeSocket),
     /// Unsubscribe from komorebi events
     #[clap(arg_required_else_help = true)]
-    Unsubscribe(Unsubscribe),
+    UnsubscribeSocket(UnsubscribeSocket),
+    /// Subscribe to komorebi events using a Named Pipe
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "subscribe")]
+    SubscribePipe(SubscribePipe),
+    /// Unsubscribe from komorebi events
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "unsubscribe")]
+    UnsubscribePipe(UnsubscribePipe),
     /// Tail komorebi.exe's process logs (cancel with Ctrl-C)
     Log,
     /// Quicksave the current resize layout dimensions
@@ -1171,35 +1192,26 @@ pub fn send_message(bytes: &[u8]) -> Result<()> {
     Ok(())
 }
 
-fn with_komorebic_socket<F: Fn() -> Result<()>>(f: F) -> Result<()> {
-    let socket = DATA_DIR.join("komorebic.sock");
+pub fn send_query(bytes: &[u8]) -> Result<String> {
+    let socket = DATA_DIR.join("komorebi.sock");
 
-    match std::fs::remove_file(&socket) {
-        Ok(()) => {}
-        Err(error) => match error.kind() {
-            // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
-            ErrorKind::NotFound => {}
-            _ => {
-                return Err(error.into());
-            }
-        },
-    };
+    let mut stream = UnixStream::connect(socket)?;
+    stream.write_all(bytes)?;
+    stream.shutdown(Shutdown::Write)?;
 
-    f()?;
+    let mut reader = BufReader::new(stream);
+    let mut response = String::new();
+    reader.read_to_string(&mut response)?;
 
-    let listener = UnixListener::bind(socket)?;
-    match listener.accept() {
-        Ok(incoming) => {
-            let stream = BufReader::new(incoming.0);
-            for line in stream.lines() {
-                println!("{}", line?);
-            }
+    Ok(response)
+}
 
-            Ok(())
-        }
-        Err(error) => {
-            panic!("{}", error);
-        }
+// print_query is a helper that queries komorebi and prints the response.
+// panics on error.
+fn print_query(bytes: &[u8]) {
+    match send_query(bytes) {
+        Ok(response) => println!("{response}"),
+        Err(error) => panic!("{}", error),
     }
 }
 
@@ -1247,7 +1259,10 @@ fn main() -> Result<()> {
 
             let home_dir = dirs::home_dir().expect("could not find home dir");
             let config_dir = home_dir.join(".config");
+            let local_appdata_dir = data_local_dir().expect("could not find localdata dir");
+            let data_dir = local_appdata_dir.join("komorebi");
             std::fs::create_dir_all(&config_dir)?;
+            std::fs::create_dir_all(data_dir)?;
 
             let komorebi_json = reqwest::blocking::get(
                 format!("https://raw.githubusercontent.com/LGUG2Z/komorebi/v{version}/komorebi.example.json")
@@ -1438,7 +1453,7 @@ fn main() -> Result<()> {
             let color_log = std::env::temp_dir().join("komorebi.log");
             let file = TailedFile::new(File::open(color_log)?);
             let locked = file.lock();
-            #[allow(clippy::significant_drop_in_scrutinee)]
+            #[allow(clippy::significant_drop_in_scrutinee, clippy::lines_filter_map_ok)]
             for line in locked.lines().flatten() {
                 println!("{line}");
             }
@@ -1735,7 +1750,7 @@ fn main() -> Result<()> {
             let exec = if let Ok(output) = Command::new("where.exe").arg("komorebi.ps1").output() {
                 let stdout = String::from_utf8(output.stdout)?;
                 match stdout.trim() {
-                    stdout if stdout.is_empty() => None,
+                    "" => None,
                     // It's possible that a komorebi.ps1 config will be in %USERPROFILE% - ignore this
                     stdout if !stdout.contains("scoop") => None,
                     stdout => {
@@ -1996,15 +2011,13 @@ Stop-Process -Name:whkd -ErrorAction SilentlyContinue
             )?;
         }
         SubCommand::State => {
-            with_komorebic_socket(|| send_message(&SocketMessage::State.as_bytes()?))?;
+            print_query(&SocketMessage::State.as_bytes()?);
         }
         SubCommand::VisibleWindows => {
-            with_komorebic_socket(|| send_message(&SocketMessage::VisibleWindows.as_bytes()?))?;
+            print_query(&SocketMessage::VisibleWindows.as_bytes()?);
         }
         SubCommand::Query(arg) => {
-            with_komorebic_socket(|| {
-                send_message(&SocketMessage::Query(arg.state_query).as_bytes()?)
-            })?;
+            print_query(&SocketMessage::Query(arg.state_query).as_bytes()?);
         }
         SubCommand::RestoreWindows => {
             let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
@@ -2095,11 +2108,17 @@ Stop-Process -Name:whkd -ErrorAction SilentlyContinue
         SubCommand::LoadResize(arg) => {
             send_message(&SocketMessage::Load(resolve_home_path(arg.path)?).as_bytes()?)?;
         }
-        SubCommand::Subscribe(arg) => {
-            send_message(&SocketMessage::AddSubscriber(arg.named_pipe).as_bytes()?)?;
+        SubCommand::SubscribeSocket(arg) => {
+            send_message(&SocketMessage::AddSubscriberSocket(arg.socket).as_bytes()?)?;
         }
-        SubCommand::Unsubscribe(arg) => {
-            send_message(&SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
+        SubCommand::UnsubscribeSocket(arg) => {
+            send_message(&SocketMessage::RemoveSubscriberSocket(arg.socket).as_bytes()?)?;
+        }
+        SubCommand::SubscribePipe(arg) => {
+            send_message(&SocketMessage::AddSubscriberPipe(arg.named_pipe).as_bytes()?)?;
+        }
+        SubCommand::UnsubscribePipe(arg) => {
+            send_message(&SocketMessage::RemoveSubscriberPipe(arg.named_pipe).as_bytes()?)?;
         }
         SubCommand::ToggleMouseFollowsFocus => {
             send_message(&SocketMessage::ToggleMouseFollowsFocus.as_bytes()?)?;
@@ -2235,23 +2254,19 @@ Stop-Process -Name:whkd -ErrorAction SilentlyContinue
             );
         }
         SubCommand::ApplicationSpecificConfigurationSchema => {
-            with_komorebic_socket(|| {
-                send_message(&SocketMessage::ApplicationSpecificConfigurationSchema.as_bytes()?)
-            })?;
+            print_query(&SocketMessage::ApplicationSpecificConfigurationSchema.as_bytes()?);
         }
         SubCommand::NotificationSchema => {
-            with_komorebic_socket(|| send_message(&SocketMessage::NotificationSchema.as_bytes()?))?;
+            print_query(&SocketMessage::NotificationSchema.as_bytes()?);
         }
         SubCommand::SocketSchema => {
-            with_komorebic_socket(|| send_message(&SocketMessage::SocketSchema.as_bytes()?))?;
+            print_query(&SocketMessage::SocketSchema.as_bytes()?);
         }
         SubCommand::StaticConfigSchema => {
-            with_komorebic_socket(|| send_message(&SocketMessage::StaticConfigSchema.as_bytes()?))?;
+            print_query(&SocketMessage::StaticConfigSchema.as_bytes()?);
         }
         SubCommand::GenerateStaticConfig => {
-            with_komorebic_socket(|| {
-                send_message(&SocketMessage::GenerateStaticConfig.as_bytes()?)
-            })?;
+            print_query(&SocketMessage::GenerateStaticConfig.as_bytes()?);
         }
     }