@desklink/host 0.1.0 → 0.1.1

package/engine/src/main.rs

@@ -6,25 +6,75 @@
 //! process, owns its stdin/stdout, and carries the SDP/ICE the engine produces
 //! over whatever authenticated channel it already has.
 
+#[cfg(target_os = "linux")]
 mod capture;
+#[cfg(target_os = "macos")]
+#[path = "capture_mac.rs"]
+mod capture;
+#[cfg(target_os = "linux")]
+mod clipboard;
+#[cfg(target_os = "macos")]
+#[path = "clipboard_mac.rs"]
 mod clipboard;
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 mod convert;
+#[cfg(target_os = "linux")]
 mod encoder;
+#[cfg(all(target_os = "macos", desklink_vpx))]
+mod encoder;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+mod indicator;
+#[cfg(target_os = "linux")]
+mod input;
+#[cfg(target_os = "macos")]
+#[path = "input_mac.rs"]
 mod input;
+#[cfg(target_os = "linux")]
 mod keymap;
+#[cfg(target_os = "macos")]
+#[path = "keymap_mac.rs"]
+mod keymap;
+#[cfg(target_os = "macos")]
+mod mac;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 mod peer;
+#[cfg(target_os = "linux")]
+mod portal;
+#[cfg(target_os = "macos")]
+#[path = "portal_mac.rs"]
 mod portal;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 mod protocol;
+#[cfg(target_os = "linux")]
+mod session;
+#[cfg(all(target_os = "macos", desklink_vpx))]
 mod session;
+#[cfg(target_os = "linux")]
+mod x11;
+#[cfg(target_os = "macos")]
+#[path = "x11_mac.rs"]
 mod x11;
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use anyhow::Result;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use protocol::{ErrorBody, Event, Request, Response};
+#[cfg(target_os = "linux")]
 use std::sync::mpsc as std_mpsc;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use std::time::Duration;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use tokio::sync::mpsc as tokio_mpsc;
 
+#[cfg(target_os = "linux")]
+unsafe extern "C" {
+    fn desklink_agent_overlay_main(display: *const std::ffi::c_char) -> i32;
+    fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32) -> i32;
+}
+
+#[cfg(target_os = "linux")]
 fn main() {
     let args: Vec<String> = std::env::args().skip(1).collect();
     let command = args.first().map(String::as_str).unwrap_or("help");
@@ -43,6 +93,20 @@ fn main() {
             println!("{}", env!("CARGO_PKG_VERSION"));
             0
         }
+        "agent-overlay" => {
+            let display = args.get(1).map(String::as_str).unwrap_or("");
+            let display = std::ffi::CString::new(display).expect("valid X display");
+            unsafe { desklink_agent_overlay_main(display.as_ptr()) }
+        }
+        "agent-overlay-wayland" => {
+            let width = args.get(1).and_then(|v| v.parse().ok()).unwrap_or(0);
+            let height = args.get(2).and_then(|v| v.parse().ok()).unwrap_or(0);
+            if width <= 0 || height <= 0 {
+                2
+            } else {
+                unsafe { desklink_agent_overlay_wayland(width, height) }
+            }
+        }
         "capabilities" => {
             println!(
                 "{}",
@@ -72,6 +136,7 @@ fn main() {
     std::process::exit(code);
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn report(result: Result<()>) -> i32 {
     match result {
         Ok(()) => 0,
@@ -82,6 +147,7 @@ fn report(result: Result<()>) -> i32 {
     }
 }
 
+#[cfg(target_os = "linux")]
 fn print_help() {
     println!(
         "desklink-host {}
@@ -105,6 +171,7 @@ anything. See docs/PROTOCOL.md for the protocol.",
 
 /// Deliberately does not perform the change. Kernel input access is a privileged
 /// decision, so the engine explains it and stops; the user runs the command.
+#[cfg(target_os = "linux")]
 fn print_input_setup() {
     match input::probe() {
         Ok(()) => {
@@ -154,6 +221,7 @@ fn print_input_setup() {
 
 /// Start the portal session, capture a few frames, and print what actually
 /// arrived. This is the diagnostic to run when the picture does not appear.
+#[cfg(target_os = "linux")]
 async fn probe(seconds: Option<u64>, display: Option<&str>) -> Result<()> {
     let seconds = seconds.unwrap_or(3);
     match display {
@@ -164,6 +232,7 @@ async fn probe(seconds: Option<u64>, display: Option<&str>) -> Result<()> {
 
 /// Read a named X display's root window for a few seconds. The frame shape is
 /// reported as a coarse checksum so a flat or unreadable screen is visible.
+#[cfg(target_os = "linux")]
 fn probe_x11(display: &str, seconds: u64) -> Result<()> {
     let mut desktop = crate::x11::X11Desktop::connect(Some(display))?;
     let (width, height) = desktop.screen_size();
@@ -195,6 +264,7 @@ fn probe_x11(display: &str, seconds: u64) -> Result<()> {
 
 /// A cheap fingerprint of a frame, enough to tell "the screen changed" from
 /// "the screen is one flat colour".
+#[cfg(target_os = "linux")]
 fn frame_shape(frame: &crate::convert::I420) -> u64 {
     frame
         .y_plane()
@@ -207,6 +277,7 @@ fn frame_shape(frame: &crate::convert::I420) -> u64 {
         })
 }
 
+#[cfg(target_os = "linux")]
 async fn probe_portal(seconds: u64) -> Result<()> {
     let portal = portal::open(None).await?;
     eprintln!("portal source: {:?}", portal.source);
@@ -217,9 +288,11 @@ async fn probe_portal(seconds: u64) -> Result<()> {
         0,
         0,
         30,
-        Box::new(move |frame, seq| {
+        Box::new(move |frame, seq, _raw| {
             let _ = tx.send((frame.width, frame.height, seq));
         }),
+        None,
+        Box::new(|reason| eprintln!("{reason}")),
     )?;
 
     let deadline = std::time::Instant::now() + Duration::from_secs(seconds);
@@ -253,6 +326,7 @@ async fn probe_portal(seconds: u64) -> Result<()> {
 }
 
 /// The local control protocol loop.
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 async fn serve() -> Result<()> {
     let (out_tx, mut out_rx) = tokio_mpsc::unbounded_channel::<String>();
     let writer = tokio::spawn(async move {
@@ -343,6 +417,7 @@ async fn serve() -> Result<()> {
     Ok(())
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn render_event(notice: session::Notice) -> Option<String> {
     let session::Notice { session_id, event } = notice;
     let (name, params) = match event {
@@ -373,10 +448,18 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.state",
             serde_json::json!({ "sessionId": session_id, "capture": capture, "transport": transport, "firstFrame": first_frame }),
         ),
+        session::SessionEvent::Frame { seq, damage } => (
+            "session.frame.changed",
+            serde_json::json!({ "sessionId": session_id, "seq": seq, "damage": damage }),
+        ),
         session::SessionEvent::RestoreToken(token) => (
             "session.restoreToken",
             serde_json::json!({ "sessionId": session_id, "token": token }),
         ),
+        session::SessionEvent::CaptureStopped { reason } => (
+            "session.capture.stopped",
+            serde_json::json!({ "sessionId": session_id, "reason": reason }),
+        ),
         session::SessionEvent::Revoked { reason } => (
             "session.revoked",
             serde_json::json!({ "sessionId": session_id, "reason": reason }),
@@ -389,6 +472,7 @@ fn render_event(notice: session::Notice) -> Option<String> {
     .ok()
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 async fn dispatch(
     request: &Request,
     hello_seen: &mut bool,
@@ -439,6 +523,7 @@ async fn dispatch(
                 restore_token: params.restore_token,
                 ttl: params.ttl_seconds.map(Duration::from_secs),
                 loopback_tcp: params.loopback_tcp,
+                agent_indicator: params.agent_indicator,
                 ice_servers: params
                     .ice_servers
                     .into_iter()
@@ -518,6 +603,28 @@ async fn dispatch(
                 .map_err(|reason| ErrorBody::new("clipboard", reason))?;
             Ok(serde_json::json!({ "written": true }))
         }
+        "session.frame" => {
+            let session = require_session(current)?;
+            let params: protocol::FrameParams = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, None)?;
+            if params.after_seq.is_some()
+                || params.still_ms.is_some()
+                || params.timeout_ms.is_some()
+            {
+                session
+                    .wait_frame(
+                        params.after_seq,
+                        params.still_ms,
+                        params.timeout_ms.unwrap_or(5000),
+                    )
+                    .await
+                    .map_err(|error| ErrorBody::new(error.code, error.message))?;
+            }
+            session
+                .frame(params.since, &params.path, params.region)
+                .map_err(|error| ErrorBody::new(error.code, error.message))
+        }
         "session.metrics" => {
             let session = require_session(current)?;
             Ok(serde_json::to_value(session.metrics()).unwrap_or(serde_json::Value::Null))
@@ -538,6 +645,7 @@ async fn dispatch(
     }
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn require_session(
     current: &mut Option<session::Session>,
 ) -> std::result::Result<&mut session::Session, ErrorBody> {
@@ -548,6 +656,7 @@ fn require_session(
 
 /// A late message for a session that has already ended must not revive it, and a
 /// message for a different session must not reach this one.
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn check_session(
     session: &session::Session,
     id: &str,
@@ -567,7 +676,12 @@ fn check_session(
     Ok(())
 }
 
-#[cfg(test)]
+#[cfg(target_os = "macos")]
+fn main() {
+    std::process::exit(mac::run());
+}
+
+#[cfg(all(test, target_os = "linux"))]
 mod tests {
     use super::*;
 

package/engine/src/portal.rs

@@ -42,6 +42,10 @@ pub struct PortalSession {
 /// `restore_token` is a token from an earlier session; supplying it lets a
 /// backend skip the picker when its policy allows it. The returned token must be
 /// persisted by the consumer and is single-use.
+pub async fn open_display(_: Option<u32>) -> Result<PortalSession> {
+    anyhow::bail!("display selection is only supported on macOS")
+}
+
 pub async fn open(restore_token: Option<&str>) -> Result<PortalSession> {
     let proxy = Screencast::new()
         .await

package/engine/src/portal_mac.rs

@@ -0,0 +1,68 @@
+use anyhow::{bail, Result};
+use serde_json::Value;
+
+/// A selected macOS display. `node_id` is its CoreGraphics display identifier.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct SelectedSource {
+    pub node_id: u32,
+    pub width: i32,
+    pub height: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub position: Option<(i32, i32)>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source_type: Option<String>,
+    pub origin_x: i32,
+    pub origin_y: i32,
+}
+
+pub struct PortalSession {
+    pub source: SelectedSource,
+    pub restore_token: Option<String>,
+}
+
+pub async fn open(_restore_token: Option<&str>) -> Result<PortalSession> {
+    open_display_inner(None)
+}
+
+pub async fn open_display(display_id: Option<u32>) -> Result<PortalSession> {
+    open_display_inner(display_id)
+}
+
+fn open_display_inner(display_id: Option<u32>) -> Result<PortalSession> {
+    if !unsafe { crate::mac::CGPreflightScreenCaptureAccess() } {
+        crate::mac::request_screen_capture_content().map_err(anyhow::Error::msg)?;
+        if !unsafe { crate::mac::CGPreflightScreenCaptureAccess() } {
+            bail!("capture-permission: allow {} in System Settings › Privacy & Security › Screen & System Audio Recording, then reconnect", crate::mac::tcc_responsible_app_name());
+        }
+    }
+    let displays = crate::mac::displays();
+    let selected = displays
+        .iter()
+        .find(|display| {
+            display_id.is_some_and(|id| display["id"].as_u64() == Some(id as u64))
+                || (display_id.is_none() && display["main"] == true)
+        })
+        .or_else(|| display_id.is_none().then(|| displays.first()).flatten())
+        .ok_or_else(|| anyhow::anyhow!("no active display is available on the Mac"))?;
+    let origin_x = selected
+        .pointer("/origin/x")
+        .and_then(Value::as_f64)
+        .unwrap_or(0.0) as i32;
+    let origin_y = selected
+        .pointer("/origin/y")
+        .and_then(Value::as_f64)
+        .unwrap_or(0.0) as i32;
+    let source = SelectedSource {
+        node_id: selected["id"].as_u64().unwrap_or_default() as u32,
+        width: selected["width"].as_u64().unwrap_or_default() as i32,
+        height: selected["height"].as_u64().unwrap_or_default() as i32,
+        position: Some((origin_x, origin_y)),
+        source_type: Some(String::from("display")),
+        origin_x,
+        origin_y,
+    };
+    Ok(PortalSession {
+        source,
+        restore_token: None,
+    })
+}

package/engine/src/protocol.rs

@@ -3,7 +3,7 @@
 
 use serde::{Deserialize, Serialize};
 
-pub const PROTOCOL_VERSION: u32 = 2;
+pub const PROTOCOL_VERSION: u32 = 3;
 
 /// A request from the consumer to the engine.
 #[derive(Debug, Deserialize)]
@@ -81,6 +81,10 @@ pub struct IceServerParam {
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum SourceRequest {
     Portal,
+    Display {
+        #[serde(default)]
+        display_id: Option<u32>,
+    },
     X11 {
         #[serde(default)]
         display: Option<String>,
@@ -112,6 +116,9 @@ pub struct OpenParams {
     /// whose only way here is a local forward (an SSH tunnel).
     #[serde(default)]
     pub loopback_tcp: bool,
+    /// Show local, capture-excluded feedback for an agent controlling this session.
+    #[serde(default)]
+    pub agent_indicator: bool,
 }
 
 /// The encode box when the consumer names none: a desktop's own pixels up to
@@ -130,6 +137,23 @@ fn default_fps() -> u32 {
     30
 }
 
+#[derive(Debug, Deserialize)]
+pub struct FrameParams {
+    pub session_id: String,
+    #[serde(default)]
+    pub since: Option<u64>,
+    #[serde(default)]
+    pub after_seq: Option<u64>,
+    #[serde(default)]
+    pub still_ms: Option<u64>,
+    #[serde(default)]
+    pub timeout_ms: Option<u64>,
+    #[serde(default)]
+    pub path: String,
+    #[serde(default)]
+    pub region: Option<[usize; 4]>,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct SessionRef {
     pub session_id: String,
@@ -316,6 +340,21 @@ mod tests {
         assert!(serde_json::from_str::<ControlMessage>(r#"{"kind":"teleport"}"#).is_err());
     }
 
+    #[test]
+    fn display_source_round_trips_its_explicit_id() {
+        let request: SourceRequest = serde_json::from_value(serde_json::json!({
+            "kind": "display",
+            "display_id": 42
+        }))
+        .unwrap();
+        assert!(matches!(
+            request,
+            SourceRequest::Display {
+                display_id: Some(42)
+            }
+        ));
+    }
+
     #[test]
     fn open_defaults_keep_the_desktops_own_pixels_up_to_4k() {
         let params: OpenParams =
@@ -327,5 +366,13 @@ mod tests {
             "the engine sizes the rate to the surface"
         );
         assert_eq!(params.max_fps, 30);
+        assert!(
+            !params.agent_indicator,
+            "human control has no overlay by default"
+        );
+        let agent: OpenParams =
+            serde_json::from_str(r#"{"permissions":["view","control"],"agent_indicator":true}"#)
+                .unwrap();
+        assert!(agent.agent_indicator);
     }
 }