@ohmykreee/dsh-remote-control 0.0.0-stage → 1.0.3

package/src/rust/src/volume/mod.rs

@@ -0,0 +1,116 @@
+//! System output volume: Core Audio, PipeWire/PulseAudio/ALSA, or osascript.
+
+use serde_json::{json, Value};
+
+use crate::cli::{action_of, option_number, CliError, CliResult};
+use crate::util;
+
+#[cfg(windows)]
+#[path = "windows.rs"]
+mod platform;
+#[cfg(target_os = "linux")]
+#[path = "linux.rs"]
+mod platform;
+#[cfg(target_os = "macos")]
+#[path = "macos.rs"]
+mod platform;
+
+#[cfg(all(feature = "macos-check", not(target_os = "macos")))]
+#[allow(dead_code)]
+#[path = "macos.rs"]
+mod macos_preview;
+
+/// A successful volume reading from whichever backend handled it.
+#[derive(Debug, Clone)]
+pub struct Reading {
+    pub volume: f64,
+    pub muted: bool,
+    pub backend: String,
+}
+
+fn envelope(result: Result<Reading, String>, started_at: i64) -> Value {
+    match result {
+        Ok(reading) => json!({
+            "ok": true,
+            "available": true,
+            "volume": util::clamp(reading.volume, 0.0, 1.0),
+            "muted": reading.muted,
+            "backend": reading.backend,
+            "error": null,
+            "updatedAt": util::now_ms(),
+            "sampledAt": started_at,
+        }),
+        Err(error) => json!({
+            "ok": false,
+            "available": false,
+            "volume": 0.5,
+            "muted": false,
+            "backend": platform::BACKEND,
+            "error": error,
+            "updatedAt": util::now_ms(),
+            "sampledAt": started_at,
+        }),
+    }
+}
+
+pub fn read() -> Value {
+    let started_at = util::now_ms();
+    envelope(platform::read(), started_at)
+}
+
+pub fn set(value: f64) -> Value {
+    let started_at = util::now_ms();
+    envelope(platform::set(util::clamp(value, 0.0, 1.0)), started_at)
+}
+
+pub fn toggle() -> Value {
+    let started_at = util::now_ms();
+    envelope(platform::toggle(), started_at)
+}
+
+pub fn cli(args: &[String], _started_at: i64) -> CliResult {
+    let action = action_of(args);
+    match action.as_str() {
+        "read" => Ok(read()),
+        "set" => {
+            let value = option_number(args, "--value")
+                .or_else(|| {
+                    args.iter()
+                        .find(|arg| arg.parse::<f64>().is_ok())
+                        .and_then(|arg| arg.parse::<f64>().ok())
+                })
+                .ok_or_else(|| CliError::usage("volume set requires --value <0.0..1.0>"))?;
+            Ok(set(value))
+        }
+        "toggle" | "mute" => Ok(toggle()),
+        other => Err(CliError::usage(format!(
+            "unsupported volume action: {other} (expected read, set, toggle)"
+        ))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn envelope_clamps_and_marks_errors() {
+        let value = envelope(
+            Ok(Reading {
+                volume: 4.2,
+                muted: true,
+                backend: "test".to_string(),
+            }),
+            123,
+        );
+        assert_eq!(value["ok"], true);
+        assert_eq!(value["volume"], 1.0);
+        assert_eq!(value["muted"], true);
+        assert_eq!(value["sampledAt"], 123);
+
+        let error = envelope(Err("nope".to_string()), 5);
+        assert_eq!(error["ok"], false);
+        assert_eq!(error["error"], "nope");
+        assert_eq!(error["volume"], 0.5);
+    }
+}

package/src/rust/src/volume/windows.rs

@@ -0,0 +1,75 @@
+//! Windows volume probe: WASAPI default render endpoint via Core Audio.
+
+use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
+use windows::Win32::Media::Audio::{eMultimedia, eRender, IMMDeviceEnumerator, MMDeviceEnumerator};
+use windows::Win32::System::Com::{
+    CoCreateInstance, CoInitializeEx, CLSCTX_ALL, COINIT_MULTITHREADED,
+};
+
+use super::Reading;
+use crate::util;
+
+pub const BACKEND: &str = "coreaudio";
+
+fn failure(error: impl std::fmt::Display) -> String {
+    format!("Core Audio: {error}")
+}
+
+fn ensure_com() {
+    static ONCE: std::sync::Once = std::sync::Once::new();
+    ONCE.call_once(|| unsafe {
+        let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
+    });
+}
+
+fn endpoint() -> Result<IAudioEndpointVolume, String> {
+    ensure_com();
+    unsafe {
+        let enumerator: IMMDeviceEnumerator =
+            CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL).map_err(failure)?;
+        let device = enumerator
+            .GetDefaultAudioEndpoint(eRender, eMultimedia)
+            .map_err(failure)?;
+        device
+            .Activate::<IAudioEndpointVolume>(CLSCTX_ALL, None)
+            .map_err(failure)
+    }
+}
+
+fn read_from(endpoint: &IAudioEndpointVolume) -> Result<Reading, String> {
+    unsafe {
+        let volume = endpoint.GetMasterVolumeLevelScalar().map_err(failure)?;
+        let muted = endpoint.GetMute().map_err(failure)?.as_bool();
+        Ok(Reading {
+            volume: util::clamp(volume as f64, 0.0, 1.0),
+            muted,
+            backend: BACKEND.to_string(),
+        })
+    }
+}
+
+pub fn read() -> Result<Reading, String> {
+    let endpoint = endpoint()?;
+    read_from(&endpoint)
+}
+
+pub fn set(value: f64) -> Result<Reading, String> {
+    let endpoint = endpoint()?;
+    unsafe {
+        endpoint
+            .SetMasterVolumeLevelScalar(util::clamp(value, 0.0, 1.0) as f32, std::ptr::null())
+            .map_err(failure)?;
+    }
+    read_from(&endpoint)
+}
+
+pub fn toggle() -> Result<Reading, String> {
+    let endpoint = endpoint()?;
+    let muted = unsafe { endpoint.GetMute().map_err(failure)?.as_bool() };
+    unsafe {
+        endpoint
+            .SetMute(!muted, std::ptr::null())
+            .map_err(failure)?;
+    }
+    read_from(&endpoint)
+}

package/src/rust/tests/cli.rs

@@ -0,0 +1,79 @@
+//! End-to-end checks that every invocation prints one parseable JSON line.
+
+use std::process::Command;
+
+fn run(args: &[&str]) -> (std::process::Output, serde_json::Value) {
+    let output = Command::new(env!("CARGO_BIN_EXE_dsh-probe"))
+        .args(args)
+        .output()
+        .expect("failed to run dsh-probe");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let line = stdout
+        .lines()
+        .rev()
+        .find(|line| line.trim_start().starts_with('{'))
+        .unwrap_or_else(|| panic!("no JSON on stdout for {args:?}: {stdout}"));
+    let value = serde_json::from_str(line).expect("stdout was not valid JSON");
+    (output, value)
+}
+
+#[test]
+fn version_reports_platform() {
+    let (output, value) = run(&["version"]);
+    assert!(output.status.success());
+    assert_eq!(value["ok"], true);
+    assert_eq!(value["name"], "dsh-probe");
+    assert_eq!(value["os"], std::env::consts::OS);
+    assert!(value["media"].as_str().is_some());
+}
+
+#[test]
+fn help_is_json() {
+    let (output, value) = run(&["--help"]);
+    assert!(output.status.success());
+    assert_eq!(value["ok"], true);
+    assert!(value["help"].as_str().unwrap().contains("volume"));
+}
+
+#[test]
+fn unknown_command_is_a_usage_error() {
+    let (output, value) = run(&["not-a-command"]);
+    assert_eq!(output.status.code(), Some(2));
+    assert_eq!(value["ok"], false);
+    assert_eq!(value["usageError"], true);
+    assert!(value["error"].as_str().unwrap().contains("unknown command"));
+}
+
+#[test]
+fn volume_and_performance_emit_json() {
+    for command in ["volume", "performance"] {
+        let (output, value) = run(&[command, "read"]);
+        assert!(
+            output.status.success(),
+            "{command} exited with {:?}",
+            output.status
+        );
+        assert!(value.get("ok").is_some());
+        assert!(value.get("sampledAt").is_some());
+    }
+}
+
+#[test]
+fn location_and_notifications_emit_json() {
+    for args in [&["location"][..], &["notifications", "--limit", "2"][..]] {
+        let (output, value) = run(args);
+        assert!(
+            output.status.success(),
+            "{args:?} exited with {:?}",
+            output.status
+        );
+        assert!(value.get("ok").is_some(), "{args:?} missing ok");
+        assert!(
+            value.get("sampledAt").is_some(),
+            "{args:?} missing sampledAt"
+        );
+    }
+    let (_, value) = run(&["notifications", "--limit", "2"]);
+    assert!(value["notifications"].as_array().is_some());
+    assert!(value["apps"].as_array().is_some());
+}

package/src/rust/tests/daemon.rs

@@ -0,0 +1,107 @@
+//! End-to-end checks for the persistent `daemon` protocol.
+
+use std::io::{BufRead, BufReader, Write};
+use std::process::{Child, ChildStdin, Command, Stdio};
+use std::sync::mpsc::{self, Receiver};
+use std::time::Duration;
+
+use serde_json::{json, Value};
+
+fn start() -> (Child, Receiver<String>, ChildStdin) {
+    let mut child = Command::new(env!("CARGO_BIN_EXE_dsh-probe"))
+        .arg("daemon")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("failed to start dsh-probe daemon");
+    let stdout = child.stdout.take().expect("stdout");
+    let (sender, receiver) = mpsc::channel();
+    std::thread::spawn(move || {
+        let reader = BufReader::new(stdout);
+        for line in reader.lines() {
+            match line {
+                Ok(line) => {
+                    if sender.send(line).is_err() {
+                        break;
+                    }
+                }
+                Err(_) => break,
+            }
+        }
+    });
+    let stdin = child.stdin.take().expect("stdin");
+    (child, receiver, stdin)
+}
+
+fn next(receiver: &Receiver<String>) -> Value {
+    let line = receiver
+        .recv_timeout(Duration::from_secs(20))
+        .expect("daemon produced no response");
+    serde_json::from_str(&line).expect("daemon response was not JSON")
+}
+
+fn send(stdin: &mut ChildStdin, request: Value) {
+    writeln!(stdin, "{request}").expect("write request");
+    stdin.flush().expect("flush request");
+}
+
+fn wait_with_timeout(child: &mut Child) -> bool {
+    for _ in 0..100 {
+        match child.try_wait() {
+            Ok(Some(_)) => return true,
+            Ok(None) => std::thread::sleep(Duration::from_millis(50)),
+            Err(_) => return false,
+        }
+    }
+    let _ = child.kill();
+    false
+}
+
+#[test]
+fn daemon_answers_requests_and_exits_on_eof() {
+    let (mut child, responses, mut stdin) = start();
+
+    let ready = next(&responses);
+    assert_eq!(ready["event"], "ready");
+    assert_eq!(ready["ok"], true);
+    assert_eq!(ready["protocol"], 1);
+    assert!(ready["pid"].as_u64().is_some());
+
+    send(&mut stdin, json!({"id": 1, "argv": ["version"]}));
+    let version = next(&responses);
+    assert_eq!(version["id"], 1);
+    assert_eq!(version["ok"], true);
+    assert_eq!(version["result"]["name"], "dsh-probe");
+
+    // Two performance requests share one process and its sampler baseline.
+    for id in [2, 3] {
+        send(&mut stdin, json!({"id": id, "argv": ["performance"]}));
+        let performance = next(&responses);
+        assert_eq!(performance["id"], id);
+        assert_eq!(performance["ok"], true);
+        assert!(performance["result"].get("cpu").is_some());
+        assert!(performance["result"].get("memory").is_some());
+    }
+
+    // A malformed request is rejected but must not stop the daemon.
+    stdin.write_all(b"{not json}\n").expect("write garbage");
+    stdin.flush().expect("flush garbage");
+    let failure = next(&responses);
+    assert_eq!(failure["ok"], false);
+    assert!(failure["error"]
+        .as_str()
+        .unwrap_or_default()
+        .contains("invalid request"));
+
+    send(&mut stdin, json!({"id": "last", "argv": ["version"]}));
+    let version = next(&responses);
+    assert_eq!(version["id"], "last");
+    assert_eq!(version["result"]["ok"], true);
+
+    drop(stdin);
+    assert!(
+        wait_with_timeout(&mut child),
+        "daemon did not exit after stdin EOF"
+    );
+}