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

package/src/rust/Cargo.toml

@@ -0,0 +1,68 @@
+[package]
+name = "dsh-probe"
+version = "1.0.3"
+edition = "2021"
+rust-version = "1.89"
+license = "MIT"
+description = "Native OS probe sidecar for the DSH LAN console (media, volume, performance)"
+publish = false
+
+[[bin]]
+name = "dsh-probe"
+path = "src/main.rs"
+
+[dependencies]
+base64 = "0.22"
+plist = "1.10"
+rusqlite = { version = "0.42", features = ["bundled"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sysinfo = "0.33"
+
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.62", features = [
+    "Devices_Geolocation",
+    "Foundation",
+    "Media_Control",
+    "Storage_Streams",
+    "Wdk_Graphics_Direct3D",
+    "Win32_Foundation",
+    "Win32_Graphics_Dxgi",
+    "Win32_Media_Audio",
+    "Win32_Media_Audio_Endpoints",
+    "Win32_Security",
+    "Win32_Storage_FileSystem",
+    "Win32_System_Com",
+    "Win32_System_Com_StructuredStorage",
+    "Win32_System_IO",
+    "Win32_System_Ole",
+    "Win32_System_Performance",
+    "Win32_System_Power",
+    "Win32_System_Threading",
+    "Win32_System_Variant",
+    "Win32_UI_Accessibility",
+    "Win32_UI_Shell",
+    "Win32_UI_WindowsAndMessaging",
+] }
+windows-future = "0.3"
+winreg = "0.56"
+
+[target.'cfg(target_os = "linux")'.dependencies]
+zbus = "5"
+
+[features]
+# Compile the macOS modules on any host so their syntax and types can be
+# checked without a Mac. This does not make them tested; see README.
+macos-check = []
+
+[profile.release]
+opt-level = "s"
+lto = true
+codegen-units = 1
+strip = true
+
+# libsqlite3-sys builds the bundled SQLite C source. MSVC's `/Z7` can fail with
+# C compiler error D8050 on some Build Tools installations; the crate itself does
+# not need debug info for our tests.
+[profile.dev.package.libsqlite3-sys]
+debug = false

package/src/rust/src/cli.rs

@@ -0,0 +1,233 @@
+//! Command-line parsing and the JSON envelope shared by every subcommand.
+
+use serde_json::{json, Value};
+
+use crate::location;
+use crate::media;
+use crate::notifications;
+use crate::perf;
+use crate::util;
+use crate::volume;
+
+/// A command failure. Probe failures still print JSON and exit 0 so the Node
+/// bridge can surface a useful error and fall back; usage errors exit 2.
+pub struct CliError {
+    pub message: String,
+    pub usage: bool,
+}
+
+impl CliError {
+    pub fn usage(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+            usage: true,
+        }
+    }
+
+    pub fn into_json(self, command: Option<&str>, started_at: i64) -> Value {
+        json!({
+            "ok": false,
+            "available": false,
+            "error": self.message,
+            "command": command,
+            "usageError": self.usage,
+            "sampledAt": started_at,
+        })
+    }
+}
+
+pub type CliResult = Result<Value, CliError>;
+
+const HELP: &str = "dsh-probe <command> [options]
+
+Commands:
+  version
+  media read [--app-id ID] [--player DEST] [--no-thumbnail]
+  media playpause|next|previous|seek [--position SECONDS] [--app-id ID] [--player DEST]
+  media like [--value true|false] [--app-id ID] [--player DEST]
+  media cdp                                  # NetEase CDP diagnostics
+  volume read
+  volume set --value 0.0..1.0
+  volume toggle
+  performance
+  notifications [--limit 1..20]
+  notifications watch [--limit 1..20]
+  location
+  location request [--open-settings]
+
+Every command prints one line of JSON on stdout. Probe errors are reported as
+{\"ok\":false,...\"} with exit code 0; malformed invocations exit with code 2.
+`notifications watch` streams one JSON line per update and runs until killed.";
+
+pub fn dispatch(args: &[String]) -> (Value, i32) {
+    let started_at = util::now_ms();
+    let command = args.first().map(String::as_str);
+    let result = match command {
+        Some("version") | Some("--version") | Some("-V") => Ok(version_json()),
+        Some("help") | Some("--help") | Some("-h") | None => Ok(help_json()),
+        Some("media") => media::cli(&args[1..], started_at),
+        Some("volume") => volume::cli(&args[1..], started_at),
+        Some("performance") | Some("perf") => perf::cli(&args[1..], started_at),
+        Some("notifications") | Some("notification") => notifications::cli(&args[1..], started_at),
+        Some("location") => location::cli(&args[1..], started_at),
+        Some(other) => Err(CliError::usage(format!("unknown command: {other}"))),
+    };
+    match result {
+        Ok(value) => (value, 0),
+        Err(error) => {
+            let usage = error.usage;
+            let value = error.into_json(command, started_at);
+            (value, if usage { 2 } else { 0 })
+        }
+    }
+}
+
+pub fn version_json() -> Value {
+    json!({
+        "ok": true,
+        "name": "dsh-probe",
+        "version": env!("CARGO_PKG_VERSION"),
+        "os": std::env::consts::OS,
+        "arch": std::env::consts::ARCH,
+        "media": platform_media_backend(),
+        "volume": platform_volume_backend(),
+        "performance": platform_perf_backend(),
+        "notifications": platform_notification_backend(),
+        "location": platform_location_backend(),
+        "sampledAt": util::now_ms(),
+    })
+}
+
+fn help_json() -> Value {
+    json!({ "ok": true, "help": HELP, "version": env!("CARGO_PKG_VERSION") })
+}
+
+pub fn platform_media_backend() -> &'static str {
+    #[cfg(windows)]
+    {
+        "windows-smtc"
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "linux-mpris"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macos-media"
+    }
+    #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
+    {
+        "unsupported"
+    }
+}
+
+pub fn platform_volume_backend() -> &'static str {
+    #[cfg(windows)]
+    {
+        "windows-coreaudio"
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "linux-wpctl-pactl-amixer"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macos-osascript"
+    }
+    #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
+    {
+        "unsupported"
+    }
+}
+
+pub fn platform_perf_backend() -> &'static str {
+    #[cfg(windows)]
+    {
+        "windows-dxgi-pdh-d3dkmt"
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "linux-sysinfo-sysfs"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macos-sysinfo"
+    }
+    #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
+    {
+        "unsupported"
+    }
+}
+
+pub fn platform_notification_backend() -> &'static str {
+    #[cfg(windows)]
+    {
+        "windows-notification-database"
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "linux-dbus-notifications"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macos-notification-center"
+    }
+    #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
+    {
+        "unsupported"
+    }
+}
+
+pub fn platform_location_backend() -> &'static str {
+    #[cfg(windows)]
+    {
+        "windows-geolocation"
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "linux-geoclue2"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macos-corelocation-unavailable"
+    }
+    #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
+    {
+        "unsupported"
+    }
+}
+
+/// Read `--name value` (or `--name=value`) from an argument list.
+pub fn option_value(args: &[String], name: &str) -> Option<String> {
+    let mut index = 0;
+    while index < args.len() {
+        let arg = &args[index];
+        if arg == name {
+            return args.get(index + 1).cloned();
+        }
+        if let Some(value) = arg.strip_prefix(&format!("{name}=")) {
+            return Some(value.to_string());
+        }
+        index += 1;
+    }
+    None
+}
+
+/// Parse an option as a finite number, ignoring malformed values.
+pub fn option_number(args: &[String], name: &str) -> Option<f64> {
+    option_value(args, name)
+        .and_then(|value| value.trim().parse::<f64>().ok())
+        .filter(|value| value.is_finite())
+}
+
+pub fn has_flag(args: &[String], name: &str) -> bool {
+    args.iter().any(|arg| arg == name)
+}
+
+/// The action word for `media`/`volume`, defaulting to `read`.
+pub fn action_of(args: &[String]) -> String {
+    args.first()
+        .filter(|value| !value.starts_with("--"))
+        .map(|value| value.to_ascii_lowercase())
+        .unwrap_or_else(|| "read".to_string())
+}

package/src/rust/src/daemon.rs

@@ -0,0 +1,140 @@
+//! Persistent probe mode: newline-delimited JSON over stdin/stdout.
+//!
+//! The host starts `dsh-probe daemon` once and keeps it alive, sending one
+//! request per line instead of paying process startup plus platform sampler
+//! warm-up on every poll:
+//!
+//! ```text
+//! -> {"id":1,"argv":["performance"]}
+//! <- {"id":1,"ok":true,"result":{...}}
+//! ```
+//!
+//! The first line on stdout is a `ready` event. Requests are handled in order
+//! on the same thread so platform sampler caches (sysinfo, PDH handles, D-Bus
+//! connections) stay warm. A malformed request is rejected without exiting;
+//! the host closes stdin to stop the daemon. The daemon never opens a socket:
+//! all traffic stays on the inherited stdio pipes.
+
+use std::io::{self, BufRead, Write};
+
+use serde_json::{json, Value};
+
+use crate::cli;
+
+/// Bumped only when the request/response shape changes incompatibly.
+pub const PROTOCOL_VERSION: u32 = 1;
+
+/// Run the daemon loop until stdin reaches EOF or a pipe error occurs.
+pub fn run() -> i32 {
+    let stdout = io::stdout();
+    let mut output = stdout.lock();
+    let ready = json!({
+        "event": "ready",
+        "ok": true,
+        "protocol": PROTOCOL_VERSION,
+        "version": env!("CARGO_PKG_VERSION"),
+        "pid": std::process::id(),
+    });
+    if write_message(&mut output, &ready).is_err() {
+        return 0;
+    }
+
+    let stdin = io::stdin();
+    let mut reader = stdin.lock();
+    let mut line = String::new();
+    loop {
+        line.clear();
+        match reader.read_line(&mut line) {
+            Ok(0) => break,
+            Ok(_) => {}
+            Err(_) => break,
+        }
+        let request = line.trim();
+        if request.is_empty() {
+            continue;
+        }
+        let response = handle_request(request);
+        if write_message(&mut output, &response).is_err() {
+            break;
+        }
+    }
+    0
+}
+
+fn write_message(output: &mut impl Write, value: &Value) -> io::Result<()> {
+    serde_json::to_writer(&mut *output, value)?;
+    output.write_all(b"\n")?;
+    output.flush()
+}
+
+fn error_response(id: Value, message: impl Into<String>) -> Value {
+    json!({ "id": id, "ok": false, "error": message.into() })
+}
+
+fn handle_request(line: &str) -> Value {
+    let request: Value = match serde_json::from_str(line) {
+        Ok(value) => value,
+        Err(error) => {
+            return error_response(Value::Null, format!("invalid request JSON: {error}"));
+        }
+    };
+    let id = request.get("id").cloned().unwrap_or(Value::Null);
+    let Some(argv) = request.get("argv").and_then(Value::as_array) else {
+        return error_response(id, "request.argv must be an array of strings");
+    };
+    let mut args = Vec::with_capacity(argv.len());
+    for item in argv {
+        match item.as_str() {
+            Some(value) => args.push(value.to_string()),
+            None => return error_response(id, "request.argv entries must be strings"),
+        }
+    }
+    if args.is_empty() {
+        return error_response(id, "request.argv must not be empty");
+    }
+
+    // `dispatch` already turns probe failures and usage errors into a JSON
+    // payload; keep that payload nested under `result` so the host sees exactly
+    // what one-shot mode would have printed.
+    let (result, _exit_code) = cli::dispatch(&args);
+    json!({ "id": id, "ok": true, "result": result })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn version_request_returns_a_result_payload() {
+        let response = handle_request(r#"{"id":7,"argv":["version"]}"#);
+        assert_eq!(response["id"], 7);
+        assert_eq!(response["ok"], true);
+        assert_eq!(response["result"]["name"], "dsh-probe");
+        assert_eq!(response["result"]["ok"], true);
+    }
+
+    #[test]
+    fn malformed_json_is_rejected_without_panicking() {
+        let response = handle_request("{");
+        assert_eq!(response["ok"], false);
+        assert!(response["error"]
+            .as_str()
+            .unwrap()
+            .contains("invalid request"));
+    }
+
+    #[test]
+    fn non_string_argv_is_rejected() {
+        let response = handle_request(r#"{"id":1,"argv":["performance",3]}"#);
+        assert_eq!(response["ok"], false);
+        assert_eq!(response["id"], 1);
+    }
+
+    #[test]
+    fn usage_errors_stay_inside_the_result() {
+        let response = handle_request(r#"{"id":"x","argv":["not-a-command"]}"#);
+        assert_eq!(response["ok"], true);
+        assert_eq!(response["result"]["ok"], false);
+        assert_eq!(response["result"]["usageError"], true);
+    }
+}

package/src/rust/src/location/linux.rs

@@ -0,0 +1,118 @@
+//! Linux location: GeoClue2 over D-Bus.
+//!
+//! GeoClue is the system location service used by GNOME/KDE. A client asks the
+//! manager for a client object, sets `DesktopId`, calls `Start`, then reads the
+//! `Location` object. Authorization is controlled by the desktop/GeoClue
+//! policy; failures are returned so Node can fall back to IP geolocation.
+
+use std::time::Duration;
+
+use zbus::blocking::{Connection, Proxy};
+use zbus::zvariant::OwnedObjectPath;
+
+use super::{AccessReport, Reading};
+
+const GEOCLUE_SERVICE: &str = "org.freedesktop.GeoClue2";
+const GEOCLUE_MANAGER_PATH: &str = "/org/freedesktop/GeoClue2/Manager";
+const GEOCLUE_MANAGER_INTERFACE: &str = "org.freedesktop.GeoClue2.Manager";
+const GEOCLUE_CLIENT_INTERFACE: &str = "org.freedesktop.GeoClue2.Client";
+const GEOCLUE_LOCATION_INTERFACE: &str = "org.freedesktop.GeoClue2.Location";
+
+fn failure(error: impl std::fmt::Display) -> String {
+    format!("GeoClue: {error}")
+}
+
+pub fn request_access(_open_settings: bool) -> AccessReport {
+    match read() {
+        Ok(_) => AccessReport {
+            access: "allowed",
+            low_integrity: false,
+            opened_settings: false,
+            reason: None,
+        },
+        Err(_) => AccessReport {
+            access: "denied",
+            low_integrity: false,
+            opened_settings: false,
+            reason: Some("unavailable"),
+        },
+    }
+}
+
+pub fn read() -> Result<Reading, String> {
+    let connection = Connection::system()
+        .map_err(|error| format!("system D-Bus unavailable for GeoClue: {error}"))?;
+    let manager = Proxy::new(
+        &connection,
+        GEOCLUE_SERVICE,
+        GEOCLUE_MANAGER_PATH,
+        GEOCLUE_MANAGER_INTERFACE,
+    )
+    .map_err(failure)?;
+    let client_path: OwnedObjectPath = manager.call("CreateClient", &()).map_err(failure)?;
+    let client = Proxy::new(
+        &connection,
+        GEOCLUE_SERVICE,
+        client_path.as_str(),
+        GEOCLUE_CLIENT_INTERFACE,
+    )
+    .map_err(failure)?;
+    client
+        .set_property("DesktopId", "dsh-remote-control")
+        .map_err(failure)?;
+    let _: () = client.call("Start", &()).map_err(failure)?;
+
+    let mut location_path: OwnedObjectPath = client.get_property("Location").map_err(failure)?;
+    // Start() is asynchronous; wait briefly for GeoClue to resolve a location.
+    for _ in 0..50 {
+        if location_path.as_str() != "/" {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(100));
+        location_path = client.get_property("Location").map_err(failure)?;
+    }
+    let result = if location_path.as_str() == "/" {
+        Err("GeoClue did not return a location".to_string())
+    } else {
+        let location = Proxy::new(
+            &connection,
+            GEOCLUE_SERVICE,
+            location_path.as_str(),
+            GEOCLUE_LOCATION_INTERFACE,
+        )
+        .map_err(failure)?;
+        let latitude: f64 = location.get_property("Latitude").map_err(failure)?;
+        let longitude: f64 = location.get_property("Longitude").map_err(failure)?;
+        let accuracy: f64 = location
+            .get_property("Accuracy")
+            .map_err(failure)
+            .unwrap_or(0.0);
+        if !latitude.is_finite()
+            || !longitude.is_finite()
+            || latitude.abs() > 90.0
+            || longitude.abs() > 180.0
+        {
+            Err("GeoClue returned an invalid coordinate".to_string())
+        } else {
+            Ok(Reading {
+                latitude,
+                longitude,
+                accuracy: if accuracy > 0.0 { Some(accuracy) } else { None },
+                source: "linux-geoclue2",
+            })
+        }
+    };
+    let _: () = client.call("Stop", &()).unwrap_or(());
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn geoclue_interfaces_are_named() {
+        assert_eq!(GEOCLUE_SERVICE, "org.freedesktop.GeoClue2");
+        assert!(GEOCLUE_MANAGER_INTERFACE.ends_with("Manager"));
+    }
+}

package/src/rust/src/location/macos.rs

@@ -0,0 +1,26 @@
+//! macOS location (source only, untested).
+//!
+//! CoreLocation only grants authorization to an application bundle that ships
+//! `NSLocationUsageDescription` (and is signed/notarized). A child sidecar
+//! process has no bundle identity, so `CLLocationManager` would be denied. The
+//! probe therefore reports a clear error and Node falls back to IP
+//! geolocation/timezone; manual coordinates remain available in settings.
+
+use super::{AccessReport, Reading};
+
+pub fn request_access(_open_settings: bool) -> AccessReport {
+    AccessReport {
+        access: "denied",
+        low_integrity: false,
+        opened_settings: false,
+        reason: Some("unavailable"),
+    }
+}
+
+pub fn read() -> Result<Reading, String> {
+    Err(
+        "CoreLocation requires an application bundle with a location usage description; \
+         falling back to IP location"
+            .to_string(),
+    )
+}