Refactor to Cargo Workspace (#129)

* Refactor project into a Cargo workspace with distinct packages

- Created a root `Cargo.toml` defining a workspace.
- Moved `src/types` and `src/utils` into a new `pwsp-lib` crate for shared logic.
- Split binaries into their own crates: `pwsp-daemon`, `pwsp-cli`, and `pwsp-gui`.
- Shifted all dependencies into `[workspace.dependencies]` for centralized version management.
- Updated import paths across all crates (e.g. from `pwsp::` to `pwsp_lib::`).
- Updated build scripts, GitHub actions, Flatpak manifest, and AUR PKGBUILD to support the new workspace structure.
- Ensured no core application logic was altered.

Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com>

* Fix cargo-deb build process in GitHub actions for workspace architecture

Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com>

* Fix cargo-deb asset discovery by using exact target/release paths

Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com>

* refactor deps in Cargo.toml files

* fix incorrect assets path

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

pwsp-lib/src/utils/daemon.rs

@@ -0,0 +1,144 @@
+use crate::types::{
+    audio_player::AudioPlayer,
+    config::DaemonConfig,
+    socket::{MAX_MESSAGE_SIZE, Request, Response},
+};
+
+use anyhow::Result;
+use std::os::unix::fs::{DirBuilderExt, MetadataExt, PermissionsExt};
+use std::path::PathBuf;
+use std::{env, error::Error, fs};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::UnixStream,
+    sync::{Mutex, OnceCell},
+    time::{Duration, sleep},
+};
+
+static AUDIO_PLAYER: OnceCell<Mutex<AudioPlayer>> = OnceCell::const_new();
+
+pub async fn get_audio_player() -> Result<&'static Mutex<AudioPlayer>, String> {
+    AUDIO_PLAYER
+        .get_or_try_init(|| async {
+            println!("Initializing audio player");
+            match AudioPlayer::new().await {
+                Ok(player) => Ok(Mutex::new(player)),
+                Err(err) => Err(err.to_string()),
+            }
+        })
+        .await
+}
+
+pub fn get_daemon_config() -> DaemonConfig {
+    DaemonConfig::load_from_file().unwrap_or_else(|_| {
+        let config = DaemonConfig::default();
+        config.save_to_file().ok();
+        config
+    })
+}
+
+fn get_current_uid() -> u32 {
+    rustix::process::geteuid().as_raw()
+}
+
+pub fn get_runtime_dir() -> PathBuf {
+    dirs::runtime_dir().unwrap_or_else(|| {
+        let uid = get_current_uid();
+        env::temp_dir().join(format!("pwsp-{}", uid))
+    })
+}
+
+pub fn create_runtime_dir() -> Result<()> {
+    let runtime_dir = get_runtime_dir();
+
+    if runtime_dir.exists() {
+        let meta = fs::symlink_metadata(&runtime_dir)?;
+        if meta.is_symlink() {
+            return Err(anyhow::anyhow!("Runtime directory is a symlink"));
+        }
+        let uid = get_current_uid();
+        if meta.uid() != uid {
+            return Err(anyhow::anyhow!(
+                "Runtime directory is owned by another user"
+            ));
+        }
+        if meta.permissions().mode() & 0o777 != 0o700 {
+            return Err(anyhow::anyhow!(
+                "Runtime directory has incorrect permissions"
+            ));
+        }
+    } else {
+        fs::DirBuilder::new()
+            .recursive(true)
+            .mode(0o700)
+            .create(&runtime_dir)?;
+    }
+
+    Ok(())
+}
+
+pub fn is_daemon_running() -> Result<bool> {
+    let lock_file = fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(false)
+        .open(get_runtime_dir().join("daemon.lock"))?;
+    match lock_file.try_lock() {
+        Ok(_) => Ok(false),
+        Err(_) => Ok(true),
+    }
+}
+
+pub async fn wait_for_daemon() -> Result<()> {
+    if is_daemon_running()? {
+        return Ok(());
+    }
+
+    println!("Daemon not found, waiting for it...");
+    while !is_daemon_running()? {
+        sleep(Duration::from_millis(100)).await;
+    }
+
+    println!("Found running daemon");
+
+    Ok(())
+}
+
+pub async fn make_request(request: Request) -> Result<Response, Box<dyn Error + Send + Sync>> {
+    let socket_path = get_runtime_dir().join("daemon.sock");
+    let mut stream = UnixStream::connect(socket_path).await?;
+
+    // ---------- Send request (start) ----------
+    let request_data = serde_json::to_vec(&request)?;
+    let request_len = request_data.len() as u32;
+    if stream.write_all(&request_len.to_le_bytes()).await.is_err() {
+        return Err("Failed to send request length".into());
+    };
+    if stream.write_all(&request_data).await.is_err() {
+        return Err("Failed to send request".into());
+    }
+    // ---------- Send request (end) ----------
+
+    // ---------- Read response (start) ----------
+    let mut len_bytes = [0u8; 4];
+    if stream.read_exact(&mut len_bytes).await.is_err() {
+        return Err("Failed to read response length".into());
+    }
+    let response_len = u32::from_le_bytes(len_bytes) as usize;
+
+    if response_len > MAX_MESSAGE_SIZE {
+        eprintln!(
+            "Failed to read response from daemon: response too large ({} bytes)!",
+            response_len
+        );
+        return Err("Response too large".into());
+    }
+
+    let mut buffer = vec![0u8; response_len];
+    if stream.read_exact(&mut buffer).await.is_err() {
+        return Err("Failed to read response".into());
+    };
+    // ---------- Read response (end) ----------
+
+    Ok(serde_json::from_slice(&buffer)?)
+}