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

package/src/rust/src/notifications/linux.rs

@@ -0,0 +1,276 @@
+//! Linux notification probe: watch `org.freedesktop.Notifications`.
+//!
+//! `Notify` is a method call to the desktop notification daemon, so a normal
+//! D-Bus client cannot observe it. The probe turns its connection into a bus
+//! monitor with `org.freedesktop.DBus.Monitoring.BecomeMonitor` (the same
+//! mechanism `dbus-monitor` uses) and filters for `Notify` calls.
+//!
+//! `notifications watch` streams one JSON snapshot per notification, which is
+//! what the Node service consumes. `notifications` samples a short window and
+//! returns whatever arrived in it (there is no portable history API).
+
+use std::collections::HashMap;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::mpsc::{channel, Receiver};
+use std::time::{Duration, Instant};
+
+use zbus::blocking::{Connection, MessageIterator};
+use zbus::message::Message;
+use zbus::zvariant::OwnedValue;
+
+use super::{snapshot_json, NotificationItem, Snapshot, SnapshotResult};
+use crate::cli::CliResult;
+use crate::util;
+
+pub const SOURCE: &str = "linux-dbus-notifications";
+pub const LIVE_ONLY: bool = true;
+
+const SNAPSHOT_WINDOW_MS: u64 = 1200;
+const MAX_ICON_BYTES: u64 = 512 * 1024;
+const NOTIFY_RULE: &str =
+    "type='method_call',interface='org.freedesktop.Notifications',member='Notify'";
+
+/// D-Bus `Notify` signature: susssasa{sv}i.
+type NotifyBody = (
+    String,
+    u32,
+    String,
+    String,
+    String,
+    Vec<String>,
+    HashMap<String, OwnedValue>,
+    i32,
+);
+
+fn monitor() -> Result<Receiver<Message>, String> {
+    let connection =
+        Connection::session().map_err(|error| format!("D-Bus session unavailable: {error}"))?;
+    connection
+        .call_method(
+            Some("org.freedesktop.DBus"),
+            "/org/freedesktop/DBus",
+            Some("org.freedesktop.DBus.Monitoring"),
+            "BecomeMonitor",
+            &(&[NOTIFY_RULE] as &[&str], 0u32),
+        )
+        .map_err(|error| format!("could not monitor org.freedesktop.Notifications: {error}"))?;
+
+    let (sender, receiver) = channel();
+    std::thread::spawn(move || {
+        let iterator = MessageIterator::from(connection);
+        for message in iterator {
+            let Ok(message) = message else {
+                break;
+            };
+            if sender.send(message).is_err() {
+                break;
+            }
+        }
+    });
+    Ok(receiver)
+}
+
+fn read_icon_source(source: &str) -> Option<String> {
+    let source = source.trim();
+    if source.is_empty() {
+        return None;
+    }
+    let path: PathBuf = if source.starts_with("file://") {
+        util::file_url_to_path(source)?
+    } else {
+        PathBuf::from(source)
+    };
+    if !path.is_absolute() {
+        // A themed icon name (for example "firefox") is not a file path.
+        return None;
+    }
+    util::file_image_data_url(&path, MAX_ICON_BYTES)
+}
+
+fn hint_string(hints: &HashMap<String, OwnedValue>, key: &str) -> Option<String> {
+    let value = hints.get(key)?.try_clone().ok()?;
+    String::try_from(value).ok()
+}
+
+fn hint_icon(hints: &HashMap<String, OwnedValue>) -> Option<String> {
+    for key in ["image-path", "image_path", "imagePath"] {
+        if let Some(source) = hint_string(hints, key) {
+            if let Some(icon) = read_icon_source(&source) {
+                return Some(icon);
+            }
+        }
+    }
+    None
+}
+
+fn item_from_message(message: &Message, counter: u64) -> Option<NotificationItem> {
+    let header = message.header();
+    if header.member().map(|member| member.as_str()) != Some("Notify") {
+        return None;
+    }
+    let body: NotifyBody = message.body().deserialize().ok()?;
+    let (app_name, _replaces_id, app_icon, summary, body_text, _actions, hints, _timeout) = body;
+    let app_name = app_name.trim();
+    let app_name = if app_name.is_empty() {
+        "通知".to_string()
+    } else {
+        app_name.to_string()
+    };
+    let title = if summary.trim().is_empty() {
+        app_name.clone()
+    } else {
+        summary.trim().to_string()
+    };
+    let body_text = body_text.trim().to_string();
+    let avatar = read_icon_source(&app_icon).or_else(|| hint_icon(&hints));
+    let has_image = avatar.is_some()
+        || hints.contains_key("image-data")
+        || hints.contains_key("image_data")
+        || hints.contains_key("image-path")
+        || hints.contains_key("image_path");
+    let received_at = util::now_ms();
+    Some(NotificationItem {
+        id: format!("{received_at}-{counter}"),
+        app_key: app_name.clone(),
+        app_name,
+        title: super::truncate(&title, 160),
+        body: super::truncate(&body_text, 260),
+        avatar,
+        has_image,
+        received_at,
+        is_group: false,
+    })
+}
+
+fn push_item(items: &mut Vec<NotificationItem>, item: NotificationItem, limit: usize) {
+    items.insert(0, item);
+    items.truncate(limit);
+}
+
+/// Sample live notifications for a short window.
+pub fn read(limit: usize) -> SnapshotResult {
+    let receiver = monitor()?;
+    let deadline = Instant::now() + Duration::from_millis(SNAPSHOT_WINDOW_MS);
+    let mut items = Vec::new();
+    let mut counter = 0_u64;
+    loop {
+        let remaining = deadline.saturating_duration_since(Instant::now());
+        if remaining.is_zero() {
+            break;
+        }
+        match receiver.recv_timeout(remaining) {
+            Ok(message) => {
+                if let Some(item) = item_from_message(&message, counter) {
+                    counter += 1;
+                    push_item(&mut items, item, limit);
+                }
+            }
+            Err(_) => break,
+        }
+    }
+    Ok(Snapshot {
+        source: SOURCE,
+        live_only: LIVE_ONLY,
+        notifications: items,
+        updated_at: util::now_ms(),
+    })
+}
+
+fn print_json(value: &serde_json::Value) {
+    match serde_json::to_string(value) {
+        Ok(line) => {
+            println!("{line}");
+            let _ = std::io::stdout().flush();
+        }
+        Err(error) => {
+            eprintln!("could not encode notification snapshot: {error}");
+        }
+    }
+}
+
+fn print_snapshot(snapshot: &Snapshot, limit: usize) {
+    print_json(&snapshot_json(snapshot, limit, util::now_ms()));
+}
+
+/// Print the notification-shaped error and exit; the Node service reads the
+/// error from the stream instead of the generic CLI error envelope.
+fn fail(error: &str, limit: usize) -> ! {
+    print_json(&super::error_json(
+        error,
+        SOURCE,
+        LIVE_ONLY,
+        limit,
+        util::now_ms(),
+    ));
+    std::process::exit(1);
+}
+
+/// Stream snapshots until the monitor connection closes.
+pub fn watch(limit: usize) -> CliResult {
+    let receiver = match monitor() {
+        Ok(receiver) => receiver,
+        Err(error) => fail(&error, limit),
+    };
+    let mut items: Vec<NotificationItem> = Vec::new();
+    let mut counter = 0_u64;
+    print_snapshot(
+        &Snapshot {
+            source: SOURCE,
+            live_only: LIVE_ONLY,
+            notifications: Vec::new(),
+            updated_at: util::now_ms(),
+        },
+        limit,
+    );
+    for message in receiver {
+        if let Some(item) = item_from_message(&message, counter) {
+            counter += 1;
+            push_item(&mut items, item, limit);
+            print_snapshot(
+                &Snapshot {
+                    source: SOURCE,
+                    live_only: LIVE_ONLY,
+                    notifications: items.clone(),
+                    updated_at: util::now_ms(),
+                },
+                limit,
+            );
+        }
+    }
+    fail("notification monitor ended (D-Bus session closed)", limit)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ignores_themed_icon_names_and_missing_files() {
+        assert!(read_icon_source("firefox").is_none());
+        assert!(read_icon_source("/nonexistent/dsh-probe/icon.png").is_none());
+    }
+
+    #[test]
+    fn keeps_only_the_most_recent_items() {
+        let mut items = Vec::new();
+        for index in 0..3 {
+            push_item(
+                &mut items,
+                NotificationItem {
+                    id: index.to_string(),
+                    ..Default::default()
+                },
+                2,
+            );
+        }
+        assert_eq!(items.len(), 2);
+        assert_eq!(items[0].id, "2");
+    }
+
+    #[test]
+    fn notification_rule_targets_notify_calls() {
+        assert!(NOTIFY_RULE.contains("member='Notify'"));
+        assert!(NOTIFY_RULE.contains("org.freedesktop.Notifications"));
+    }
+}

package/src/rust/src/notifications/macos.rs

@@ -0,0 +1,382 @@
+//! macOS notification probe: read the Notification Center database.
+//!
+//! Source only: this module is type-checked with `--features macos-check` but has
+//! not been run on macOS. Notification Center stores a binary property list per
+//! record; it is parsed in-process (no `plutil`/AppleScript fallback).
+//!
+//! Reading the database requires Full Disk Access for the DSH host. When access
+//! is denied the probe returns a clear error instead of partial/fake data.
+
+use std::path::PathBuf;
+
+use plist::{Dictionary, Value};
+use rusqlite::{types::ValueRef, Connection, OpenFlags};
+
+use super::{truncate, NotificationItem, Snapshot, SnapshotResult};
+use crate::cli::{CliError, CliResult};
+use crate::util;
+
+pub const SOURCE: &str = "macos-notification-center";
+pub const LIVE_ONLY: bool = false;
+
+pub fn watch(_limit: usize) -> CliResult {
+    Err(CliError::usage(
+        "notifications watch is available on Linux only".to_string(),
+    ))
+}
+
+const APP_LABELS: &[(&str, &str)] = &[
+    ("com.apple.Music", "音乐"),
+    ("com.apple.iTunes", "音乐"),
+    ("com.spotify.client", "Spotify"),
+    ("com.tencent.xinWeChat", "微信"),
+    ("com.tencent.qq", "QQ"),
+    ("com.microsoft.teams2", "Microsoft Teams"),
+    ("com.microsoft.Outlook", "Outlook"),
+    ("com.google.Chrome", "Google Chrome"),
+    ("com.apple.Safari", "Safari"),
+    ("com.apple.mail", "邮件"),
+    ("com.apple.reminders", "提醒事项"),
+    ("com.apple.iCal", "日历"),
+];
+
+fn database_path() -> Option<PathBuf> {
+    util::home_dir().map(|home| {
+        home.join("Library")
+            .join("Group Containers")
+            .join("group.com.apple.usernoted")
+            .join("db2")
+            .join("db")
+    })
+}
+
+fn quote(identifier: &str) -> String {
+    format!("\"{}\"", identifier.replace('"', "\"\""))
+}
+
+fn value_string(value: ValueRef<'_>) -> Option<String> {
+    match value {
+        ValueRef::Text(bytes) => Some(String::from_utf8_lossy(bytes).into_owned()),
+        ValueRef::Integer(number) => Some(number.to_string()),
+        ValueRef::Real(number) => Some(number.to_string()),
+        _ => None,
+    }
+}
+
+fn value_bytes(value: ValueRef<'_>) -> Option<Vec<u8>> {
+    match value {
+        ValueRef::Blob(bytes) => Some(bytes.to_vec()),
+        ValueRef::Text(bytes) => Some(bytes.to_vec()),
+        _ => None,
+    }
+}
+
+fn tables(connection: &Connection) -> Vec<String> {
+    let Ok(mut statement) =
+        connection.prepare("select name from sqlite_master where type = 'table'")
+    else {
+        return Vec::new();
+    };
+    let Ok(rows) = statement.query_map([], |row| row.get::<_, String>(0)) else {
+        return Vec::new();
+    };
+    rows.flatten().collect()
+}
+
+fn columns(connection: &Connection, table: &str) -> Vec<String> {
+    let sql = format!("pragma table_info({})", quote(table));
+    let Ok(mut statement) = connection.prepare(&sql) else {
+        return Vec::new();
+    };
+    let Ok(rows) = statement.query_map([], |row| row.get::<_, String>(1)) else {
+        return Vec::new();
+    };
+    rows.flatten().collect()
+}
+
+fn pick_column<'a>(columns: &'a [String], predicate: impl Fn(&str) -> bool) -> Option<&'a str> {
+    columns
+        .iter()
+        .find(|name| predicate(&name.to_lowercase()))
+        .map(String::as_str)
+}
+
+fn app_name(app_key: &str, app_table_names: &std::collections::HashMap<String, String>) -> String {
+    if let Some(name) = app_table_names.get(app_key) {
+        return name.clone();
+    }
+    if let Some((_, label)) = APP_LABELS.iter().find(|(key, _)| *key == app_key) {
+        return (*label).to_string();
+    }
+    app_key
+        .split('.')
+        .filter(|part| !part.is_empty())
+        .next_back()
+        .unwrap_or("macOS")
+        .to_string()
+}
+
+fn pick_string(dictionary: &Dictionary, keys: &[&str]) -> String {
+    for key in keys {
+        let Some(value) = dictionary.get(key) else {
+            continue;
+        };
+        if let Some(text) = value.as_string() {
+            if !text.trim().is_empty() {
+                return text.trim().to_string();
+            }
+        }
+        if let Some(inner) = value.as_dictionary() {
+            for inner_key in ["string", "stringValue"] {
+                if let Some(text) = inner.get(inner_key).and_then(Value::as_string) {
+                    if !text.trim().is_empty() {
+                        return text.trim().to_string();
+                    }
+                }
+            }
+        }
+    }
+    String::new()
+}
+
+fn parse_payload(payload: &[u8]) -> Option<(String, String, String)> {
+    let value = Value::from_reader(std::io::Cursor::new(payload)).ok()?;
+    let root = value.as_dictionary()?;
+    let request = root
+        .get("req")
+        .and_then(Value::as_dictionary)
+        .unwrap_or(root);
+    Some((
+        pick_string(request, &["titl", "title"]),
+        pick_string(request, &["subt", "subtitle"]),
+        pick_string(request, &["body", "mess"]),
+    ))
+}
+
+fn apple_time_to_ms(value: ValueRef<'_>) -> Option<i64> {
+    let number = match value {
+        ValueRef::Integer(number) => number as f64,
+        ValueRef::Real(number) => number,
+        ValueRef::Text(bytes) => String::from_utf8_lossy(bytes).trim().parse::<f64>().ok()?,
+        _ => return None,
+    };
+    if !number.is_finite() || number <= 0.0 {
+        return None;
+    }
+    let seconds = if number > 10_000_000_000.0 {
+        number / 1000.0
+    } else {
+        number
+    };
+    Some(((seconds + 978_307_200.0) * 1000.0).round() as i64)
+}
+
+pub fn read(limit: usize) -> SnapshotResult {
+    let source = database_path().ok_or_else(|| "home directory not found".to_string())?;
+    if !source.is_file() {
+        return Err("Notification Center database not found".to_string());
+    }
+    let temp = util::TempDir::create("dsh-probe-nc")?;
+    let target = temp.path().join("db");
+    util::copy_sqlite_database(&source, &target)?;
+    let connection = Connection::open_with_flags(&target, OpenFlags::SQLITE_OPEN_READ_ONLY)
+        .map_err(|error| {
+            format!(
+                "Notification Center is not readable (grant Full Disk Access to the DSH host): {error}"
+            )
+        })?;
+
+    let table_names = tables(&connection);
+    let record_table = table_names
+        .iter()
+        .find(|name| name.eq_ignore_ascii_case("record"))
+        .or_else(|| {
+            table_names
+                .iter()
+                .find(|name| name.to_lowercase().contains("record"))
+        })
+        .ok_or_else(|| "Notification Center record table not found".to_string())?
+        .clone();
+    let record_columns = columns(&connection, &record_table);
+    let data_column = pick_column(&record_columns, |name| {
+        name == "data" || name == "plist" || name == "record"
+    })
+    .or_else(|| pick_column(&record_columns, |name| name.contains("data")))
+    .ok_or_else(|| "Notification Center payload column not found".to_string())?
+    .to_string();
+    let app_column = pick_column(&record_columns, |name| {
+        (name.contains("app") && (name.contains("id") || name.contains("bundle")))
+            || name.contains("bundle")
+    })
+    .map(str::to_string);
+    let date_column = pick_column(&record_columns, |name| {
+        name.contains("deliver") || name.contains("date") || name.contains("time")
+    })
+    .map(str::to_string);
+
+    let mut select = format!("{} as payload", quote(&data_column));
+    select.push_str(&format!(
+        ", {} as appId",
+        app_column
+            .as_deref()
+            .map(quote)
+            .unwrap_or_else(|| "''".to_string())
+    ));
+    select.push_str(&format!(
+        ", {} as deliveredAt",
+        date_column
+            .as_deref()
+            .map(quote)
+            .unwrap_or_else(|| "0".to_string())
+    ));
+    let order = date_column
+        .as_deref()
+        .map(quote)
+        .unwrap_or_else(|| "rowid".to_string());
+    let sql = format!(
+        "select {select} from {} order by {order} desc limit ?1",
+        quote(&record_table)
+    );
+    let fetch = (limit.saturating_mul(3)).max(24) as i64;
+    let mut statement = connection
+        .prepare(&sql)
+        .map_err(|error| format!("notification query failed: {error}"))?;
+    let rows = statement
+        .query_map([fetch], |row| {
+            Ok((
+                value_bytes(row.get_ref(0)?).unwrap_or_default(),
+                value_string(row.get_ref(1)?).unwrap_or_default(),
+                apple_time_to_ms(row.get_ref(2)?),
+            ))
+        })
+        .map_err(|error| format!("notification query failed: {error}"))?;
+
+    let mut app_table_names = std::collections::HashMap::new();
+    if let Some(app_table) = table_names
+        .iter()
+        .find(|name| name.eq_ignore_ascii_case("app"))
+    {
+        let app_columns = columns(&connection, app_table);
+        let id_column = pick_column(&app_columns, |name| {
+            name.contains("identifier") || name.contains("bundle")
+        });
+        let name_column = pick_column(&app_columns, |name| {
+            name.contains("name") || name.contains("display")
+        });
+        if let (Some(id_column), Some(name_column)) = (id_column, name_column) {
+            let sql = format!(
+                "select {}, {} from {}",
+                quote(id_column),
+                quote(name_column),
+                quote(app_table)
+            );
+            if let Ok(mut app_statement) = connection.prepare(&sql) {
+                if let Ok(app_rows) = app_statement.query_map([], |row| {
+                    Ok((
+                        value_string(row.get_ref(0)?).unwrap_or_default(),
+                        value_string(row.get_ref(1)?).unwrap_or_default(),
+                    ))
+                }) {
+                    for (key, name) in app_rows.flatten() {
+                        if !key.is_empty() && !name.is_empty() {
+                            app_table_names.insert(key, name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let now = util::now_ms();
+    let mut notifications = Vec::new();
+    for (payload, app_id, delivered_at) in rows.flatten() {
+        if payload.is_empty() {
+            continue;
+        }
+        let Some((title, subtitle, body)) = parse_payload(&payload) else {
+            continue;
+        };
+        if title.is_empty() && body.is_empty() && subtitle.is_empty() {
+            continue;
+        }
+        let app_key = if app_id.trim().is_empty() {
+            "macOS".to_string()
+        } else {
+            app_id.trim().to_string()
+        };
+        let app_name = app_name(&app_key, &app_table_names);
+        let title = if title.is_empty() {
+            app_name.clone()
+        } else {
+            title
+        };
+        let body = [subtitle, body]
+            .into_iter()
+            .filter(|part| !part.is_empty())
+            .collect::<Vec<_>>()
+            .join("  ");
+        let received_at = delivered_at.unwrap_or(now);
+        notifications.push(NotificationItem {
+            id: format!("{received_at}-{}", notifications.len()),
+            app_key,
+            app_name,
+            title: truncate(&title, 160),
+            body: truncate(&body, 260),
+            avatar: None,
+            has_image: false,
+            received_at,
+            is_group: false,
+        });
+        if notifications.len() >= limit {
+            break;
+        }
+    }
+
+    Ok(Snapshot {
+        source: SOURCE,
+        live_only: LIVE_ONLY,
+        notifications,
+        updated_at: now,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn converts_apple_epoch_times() {
+        // 2024-01-01T00:00:00Z is 726_537_600 seconds after the 2001 epoch.
+        assert_eq!(
+            apple_time_to_ms(ValueRef::Real(726_537_600.0)),
+            Some(1_704_067_200_000)
+        );
+        // Millisecond values are detected and normalized.
+        assert_eq!(
+            apple_time_to_ms(ValueRef::Integer(1_704_067_200_000)),
+            Some(1_704_067_200_000)
+        );
+    }
+
+    #[test]
+    fn picks_nested_plist_strings() {
+        let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict><key>req</key><dict>
+<key>titl</key><dict><key>string</key><string>Hello</string></dict>
+<key>body</key><string>World</string>
+</dict></dict></plist>"#;
+        let value = Value::from_reader(std::io::Cursor::new(plist.as_bytes())).unwrap();
+        let root = value.as_dictionary().unwrap();
+        let request = root.get("req").and_then(Value::as_dictionary).unwrap();
+        assert_eq!(pick_string(request, &["titl"]), "Hello");
+        assert_eq!(pick_string(request, &["body"]), "World");
+    }
+
+    #[test]
+    fn derives_app_names() {
+        let names = std::collections::HashMap::new();
+        assert_eq!(app_name("com.apple.Music", &names), "音乐");
+        assert_eq!(app_name("com.example.SomeApp", &names), "SomeApp");
+    }
+}