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

package/src/rust/src/location/mod.rs

@@ -0,0 +1,170 @@
+//! Current location from each platform's system location API.
+//!
+//! * Windows: WinRT `Windows.Devices.Geolocation.Geolocator`, plus an explicit
+//!   permission-request command that reports privacy/integrity blockers.
+//! * Linux: GeoClue2 (`org.freedesktop.GeoClue2`) over the session/system bus
+//! * macOS: CoreLocation requires an app bundle/usage description, which a
+//!   sidecar process cannot provide; returns a clear error so Node can fall
+//!   back to IP geolocation. Source only, untested.
+//!
+//! The Node weather service treats this as a best-effort first step and falls
+//! back to IP geolocation / timezone.
+
+use serde_json::{json, Value};
+
+use crate::cli::{action_of, has_flag, CliError, CliResult};
+
+#[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;
+
+#[derive(Debug, Clone)]
+pub struct Reading {
+    pub latitude: f64,
+    pub longitude: f64,
+    pub accuracy: Option<f64>,
+    pub source: &'static str,
+}
+
+/// The outcome of asking the OS for location permission.
+#[derive(Debug, Clone)]
+pub struct AccessReport {
+    /// `allowed`, `denied`, `unspecified`, `unknown` or `unsupported`.
+    pub access: &'static str,
+    /// The process runs at the Low integrity level (Windows only).
+    pub low_integrity: bool,
+    /// The privacy settings page was opened for the user.
+    pub opened_settings: bool,
+    /// Machine-readable blocker: `low-integrity`, `privacy-denied`,
+    /// `unspecified`, `request-failed`, `unavailable`.
+    pub reason: Option<&'static str>,
+}
+
+fn reading_json(reading: &Reading, sampled_at: i64) -> Value {
+    json!({
+        "ok": true,
+        "available": true,
+        "latitude": reading.latitude,
+        "longitude": reading.longitude,
+        "accuracy": reading.accuracy,
+        "source": reading.source,
+        "error": null,
+        "sampledAt": sampled_at,
+    })
+}
+
+fn error_json(error: &str, sampled_at: i64) -> Value {
+    json!({
+        "ok": false,
+        "available": false,
+        "latitude": null,
+        "longitude": null,
+        "accuracy": null,
+        "source": "none",
+        "error": error,
+        "sampledAt": sampled_at,
+    })
+}
+
+fn access_json(report: &AccessReport, sampled_at: i64) -> Value {
+    json!({
+        "ok": true,
+        "available": report.access == "allowed",
+        "access": report.access,
+        "allowed": report.access == "allowed",
+        "lowIntegrity": report.low_integrity,
+        "openedSettings": report.opened_settings,
+        "reason": report.reason,
+        "sampledAt": sampled_at,
+    })
+}
+
+pub fn read_json(sampled_at: i64) -> Value {
+    match platform::read() {
+        Ok(reading) => reading_json(&reading, sampled_at),
+        Err(error) => error_json(&error, sampled_at),
+    }
+}
+
+/// Ask for location permission. The platform module owns the consent flow
+/// (Windows) or reports whether a location can be read at all.
+fn request_access(open_settings: bool) -> AccessReport {
+    platform::request_access(open_settings)
+}
+
+pub fn cli(args: &[String], started_at: i64) -> CliResult {
+    match action_of(args).as_str() {
+        "read" => Ok(read_json(started_at)),
+        "request" => Ok(access_json(
+            &request_access(has_flag(args, "--open-settings")),
+            started_at,
+        )),
+        other => Err(CliError::usage(format!(
+            "unsupported location action: {other} (expected read, request)"
+        ))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn success_shape_is_camel_case() {
+        let value = reading_json(
+            &Reading {
+                latitude: 31.2,
+                longitude: 121.5,
+                accuracy: Some(12.0),
+                source: "test",
+            },
+            5,
+        );
+        assert_eq!(value["ok"], true);
+        assert_eq!(value["latitude"], 31.2);
+        assert_eq!(value["longitude"], 121.5);
+        assert_eq!(value["source"], "test");
+        assert_eq!(value["sampledAt"], 5);
+    }
+
+    #[test]
+    fn error_shape_is_clean() {
+        let value = error_json("no location", 6);
+        assert_eq!(value["ok"], false);
+        assert_eq!(value["available"], false);
+        assert_eq!(value["latitude"], serde_json::Value::Null);
+        assert_eq!(value["error"], "no location");
+    }
+
+    #[test]
+    fn access_shape_reports_the_blocker() {
+        let value = access_json(
+            &AccessReport {
+                access: "denied",
+                low_integrity: true,
+                opened_settings: true,
+                reason: Some("low-integrity"),
+            },
+            7,
+        );
+        assert_eq!(value["ok"], true);
+        assert_eq!(value["available"], false);
+        assert_eq!(value["access"], "denied");
+        assert_eq!(value["allowed"], false);
+        assert_eq!(value["lowIntegrity"], true);
+        assert_eq!(value["openedSettings"], true);
+        assert_eq!(value["reason"], "low-integrity");
+        assert_eq!(value["sampledAt"], 7);
+    }
+}

package/src/rust/src/location/windows.rs

@@ -0,0 +1,205 @@
+//! Windows location: WinRT `Windows.Devices.Geolocation.Geolocator`.
+//!
+//! This is the same system API the old PowerShell probe used, now called from
+//! Rust. Access can be denied by the Windows privacy settings *or* because the
+//! process runs below the Medium integrity level (a Low mandatory label on the
+//! plugin directory is enough), which Windows treats as untrusted for location.
+//! `request_access` reports both cases and can open the privacy settings page
+//! for the user.
+
+use std::mem::{size_of, size_of_val};
+
+use windows::core::PCWSTR;
+use windows::Devices::Geolocation::{GeolocationAccessStatus, Geolocator, PositionAccuracy};
+use windows::Foundation::TimeSpan;
+use windows::Win32::Foundation::{CloseHandle, HANDLE};
+use windows::Win32::Security::{
+    GetSidSubAuthority, GetSidSubAuthorityCount, GetTokenInformation, TokenIntegrityLevel,
+    TOKEN_MANDATORY_LABEL, TOKEN_QUERY,
+};
+use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
+use windows::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};
+use windows::Win32::UI::Shell::ShellExecuteW;
+use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNORMAL;
+
+use super::{AccessReport, Reading};
+
+const REQUEST_TIMEOUT: TimeSpan = TimeSpan {
+    // 8 seconds in 100 ns ticks.
+    Duration: 80_000_000,
+};
+const MAXIMUM_AGE: TimeSpan = TimeSpan {
+    // 10 minutes in 100 ns ticks.
+    Duration: 6_000_000_000,
+};
+/// `SECURITY_MANDATORY_MEDIUM_RID`; anything below it is Low/Untrusted.
+const SECURITY_MANDATORY_MEDIUM_RID: u32 = 0x2000;
+
+fn ensure_com() {
+    static ONCE: std::sync::Once = std::sync::Once::new();
+    ONCE.call_once(|| unsafe {
+        // S_FALSE / RPC_E_CHANGED_MODE are harmless.
+        let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
+    });
+}
+
+fn access_status() -> Result<GeolocationAccessStatus, String> {
+    ensure_com();
+    Geolocator::RequestAccessAsync()
+        .map_err(|error| format!("geolocation request failed: {error}"))?
+        .join()
+        .map_err(|error| format!("geolocation access request failed: {error}"))
+}
+
+/// Whether this process is running at the Low integrity level. Windows refuses
+/// location access to Low-integrity processes even when the privacy settings
+/// allow desktop apps, so this distinction matters for the hint shown in the UI.
+fn is_low_integrity() -> bool {
+    unsafe {
+        let mut token = HANDLE::default();
+        if OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token).is_err() {
+            return false;
+        }
+        let mut size = 0_u32;
+        let _ = GetTokenInformation(token, TokenIntegrityLevel, None, 0, &mut size);
+        if size == 0 {
+            let _ = CloseHandle(token);
+            return false;
+        }
+        // `GetTokenInformation` writes a TOKEN_MANDATORY_LABEL followed by the
+        // SID; use word-aligned storage so the cast below is well defined.
+        let words = (size as usize).div_ceil(size_of::<usize>()).max(1);
+        let mut buffer = vec![0_usize; words];
+        let query = GetTokenInformation(
+            token,
+            TokenIntegrityLevel,
+            Some(buffer.as_mut_ptr() as *mut core::ffi::c_void),
+            size_of_val(&buffer[..]) as u32,
+            &mut size,
+        );
+        let _ = CloseHandle(token);
+        if query.is_err() {
+            return false;
+        }
+        let label = &*(buffer.as_ptr() as *const TOKEN_MANDATORY_LABEL);
+        let sid = label.Label.Sid;
+        if sid.is_invalid() {
+            return false;
+        }
+        let count = GetSidSubAuthorityCount(sid);
+        if count.is_null() || *count == 0 {
+            return false;
+        }
+        let rid = GetSidSubAuthority(sid, 0);
+        if rid.is_null() {
+            return false;
+        }
+        *rid < SECURITY_MANDATORY_MEDIUM_RID
+    }
+}
+
+/// Open `Settings > Privacy & security > Location` so the user can grant access.
+fn open_location_settings() -> bool {
+    unsafe {
+        let result = ShellExecuteW(
+            None,
+            windows::core::w!("open"),
+            windows::core::w!("ms-settings:privacy-location"),
+            PCWSTR::null(),
+            PCWSTR::null(),
+            SW_SHOWNORMAL,
+        );
+        result.0 as isize > 32
+    }
+}
+
+/// Ask the OS for location permission and report the exact blocker.
+pub fn request_access(open_settings: bool) -> AccessReport {
+    let low_integrity = is_low_integrity();
+    let (access, reason) = match access_status() {
+        Ok(status) if status == GeolocationAccessStatus::Allowed => ("allowed", None),
+        Ok(status) if status == GeolocationAccessStatus::Denied => {
+            ("denied", Some("privacy-denied"))
+        }
+        Ok(_) => ("unspecified", Some("unspecified")),
+        Err(_) => ("unknown", Some("request-failed")),
+    };
+    let reason = if access == "denied" && low_integrity {
+        Some("low-integrity")
+    } else {
+        reason
+    };
+    let opened_settings = open_settings && access != "allowed" && open_location_settings();
+    AccessReport {
+        access,
+        low_integrity,
+        opened_settings,
+        reason,
+    }
+}
+
+pub fn read() -> Result<Reading, String> {
+    let access = access_status()?;
+    if access != GeolocationAccessStatus::Allowed {
+        let label = if access == GeolocationAccessStatus::Denied {
+            "denied"
+        } else {
+            "not granted"
+        };
+        if is_low_integrity() {
+            return Err(format!(
+                "Windows location access {label}: dsh-probe is running at low integrity, and Windows blocks location for low-integrity processes; rebuild the probe into a normal-integrity directory or open the location settings"
+            ));
+        }
+        return Err(format!(
+            "Windows location access {label}; enable Settings > Privacy > Location (desktop apps) or use the location permission request in the weather settings"
+        ));
+    }
+    let locator =
+        Geolocator::new().map_err(|error| format!("could not create Geolocator: {error}"))?;
+    let _ = locator.SetDesiredAccuracy(PositionAccuracy::High);
+    let position = locator
+        .GetGeopositionAsyncWithAgeAndTimeout(MAXIMUM_AGE, REQUEST_TIMEOUT)
+        .map_err(|error| format!("could not request a position: {error}"))?
+        .join()
+        .map_err(|error| format!("could not read a position: {error}"))?;
+    let coordinate = position
+        .Coordinate()
+        .map_err(|error| format!("position has no coordinate: {error}"))?;
+    let point = coordinate
+        .Point()
+        .map_err(|error| format!("coordinate has no point: {error}"))?;
+    let basic = point
+        .Position()
+        .map_err(|error| format!("point has no position: {error}"))?;
+    let accuracy = coordinate.Accuracy().ok();
+    if !basic.Latitude.is_finite()
+        || !basic.Longitude.is_finite()
+        || basic.Latitude.abs() > 90.0
+        || basic.Longitude.abs() > 180.0
+    {
+        return Err("Windows returned an invalid coordinate".to_string());
+    }
+    Ok(Reading {
+        latitude: basic.Latitude,
+        longitude: basic.Longitude,
+        accuracy,
+        source: "windows-geolocation",
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn recovers_from_com_initialization() {
+        ensure_com();
+        ensure_com();
+    }
+
+    #[test]
+    fn integrity_probe_returns_a_bool() {
+        let _ = is_low_integrity();
+    }
+}

package/src/rust/src/main.rs

@@ -0,0 +1,42 @@
+//! `dsh-probe`: native OS probe sidecar for the DSH LAN console.
+//!
+//! The Node host executes this binary with a subcommand and parses one line of
+//! JSON from stdout. Native OS APIs are used per platform:
+//!   * Windows: WinRT SMTC, Core Audio (WASAPI endpoint), Win32 power info
+//!   * Linux:   MPRIS over D-Bus (zbus), wpctl/pactl/amixer, /proc + sysfs
+//!   * macOS:   nowplaying-cli/osascript (source only, untested)
+//!
+//! WASM is deliberately not used: WinRT, Core Audio, D-Bus and IOKit are not
+//! reachable from a WebAssembly sandbox.
+
+mod cli;
+mod daemon;
+mod location;
+mod media;
+mod notifications;
+mod perf;
+mod util;
+mod volume;
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    // The long-lived mode must own stdout (JSON lines) and stdin (requests);
+    // it never returns through the one-shot printing path below.
+    if args.first().map(String::as_str) == Some("daemon") {
+        std::process::exit(daemon::run());
+    }
+    let (value, exit_code) = cli::dispatch(&args);
+    match serde_json::to_string(&value) {
+        Ok(text) => println!("{text}"),
+        Err(error) => {
+            // serde_json only fails here if a custom value contains invalid data;
+            // still emit something the bridge can parse.
+            println!(
+                "{{\"ok\":false,\"error\":{}}}",
+                serde_json::Value::String(format!("failed to encode probe result: {error}"))
+            );
+            std::process::exit(1);
+        }
+    }
+    std::process::exit(exit_code);
+}