@desklink/host 0.5.3 → 0.5.6

package/engine/src/input.rs

@@ -300,68 +300,3 @@ impl Drop for InputDevices {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn button_numbers_map_to_the_expected_pointer_buttons() {
-        assert_eq!(Button::from_number(1), Button::Left);
-        assert_eq!(Button::from_number(2), Button::Middle);
-        assert_eq!(Button::from_number(3), Button::Right);
-        assert_eq!(Button::from_number(9), Button::Left);
-    }
-
-    #[test]
-    fn held_state_releases_exactly_what_this_session_pressed() {
-        let mut held = HeldState::default();
-        held.key(29, true); // left ctrl
-        held.key(46, true); // c
-        held.button(Button::Left, true);
-        // A repeat press is the same press, not a second one, so the plan still
-        // releases it exactly once.
-        held.key(29, true);
-
-        let (buttons, keys) = held.release_plan();
-        assert_eq!(buttons, vec![Button::Left]);
-        assert_eq!(keys, vec![29, 46]);
-        assert!(
-            held.release_plan().1.is_empty(),
-            "releasing twice releases nothing"
-        );
-    }
-
-    #[test]
-    fn an_explicit_release_leaves_only_what_is_still_pressed() {
-        let mut held = HeldState::default();
-        held.key(29, true);
-        held.key(46, true);
-        held.key(46, false);
-        let (buttons, keys) = held.release_plan();
-        assert!(buttons.is_empty());
-        assert_eq!(keys, vec![29]);
-    }
-
-    /// Proving the backend is really available here is the point: if this host
-    /// cannot create the devices, the engine must say so rather than offer a
-    /// control surface that does nothing.
-    #[test]
-    fn this_host_can_create_and_destroy_the_virtual_devices() {
-        // This touches the real desktop when uinput is writable. Ordinary
-        // suites must never create devices on the owner's active session.
-        if std::env::var("DESKLINK_TEST_UINPUT").as_deref() != Ok("1") {
-            return;
-        }
-        match InputDevices::create(2560, 1440) {
-            Ok(_devices) => {}
-            Err(error) => {
-                let unavailable = probe().unwrap_err();
-                assert!(
-                    error.to_string().contains(&unavailable.reason),
-                    "a creation failure must be the reported availability problem"
-                );
-            }
-        }
-    }
-}

package/engine/src/input_mac.rs

@@ -299,14 +299,3 @@ impl InputDevices {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn command_key_uses_quartz_command_flag() {
-        assert_eq!(modifier_flag(keycode::LEFT_META), 0x100000);
-        assert_eq!(modifier_flag(0), 0);
-    }
-}

package/engine/src/keeper.rs

@@ -483,140 +483,3 @@ fn fatal(out: &mut impl Write, error: &str) -> Result<()> {
     write_line(out, &serde_json::json!({ "error": error }).to_string())?;
     Err(anyhow!("{error}"))
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn content_fills_the_screen_and_helpers_are_parked() {
-        assert_eq!(kiosk_geometry(1240, 760, 1280, 800), (0, 0, 1280, 800));
-        // Exactly at the limit is content; one pixel under is not.
-        assert_eq!(kiosk_geometry(120, 120, 1280, 800), (0, 0, 1280, 800));
-        assert_eq!(
-            kiosk_geometry(119, 800, 1280, 800),
-            (i32::from(PARKED_XY), i32::from(PARKED_XY), 119, 800)
-        );
-        assert_eq!(
-            kiosk_geometry(1000, 24, 1280, 800),
-            (i32::from(PARKED_XY), i32::from(PARKED_XY), 1000, 24)
-        );
-    }
-
-    #[test]
-    fn wm_class_reads_the_class_not_the_instance() {
-        assert_eq!(
-            decode_wm_class(b"google-chrome\0Google-chrome\0"),
-            Some(String::from("Google-chrome"))
-        );
-        assert_eq!(decode_wm_class(b"instance-only\0"), None);
-        assert_eq!(decode_wm_class(b""), None);
-    }
-
-    #[test]
-    fn titles_come_from_either_name_property_and_blank_is_none() {
-        assert_eq!(
-            decode_title("Pricing — Acme Store"),
-            Some(String::from("Pricing — Acme Store"))
-        );
-        assert_eq!(
-            decode_title("PPF probe - Google Chrome"),
-            Some(String::from("PPF probe - Google Chrome"))
-        );
-        assert_eq!(decode_title("   "), None);
-        assert_eq!(decode_title(""), None);
-        assert_eq!(
-            decode_title(&latin1(b"Gr\xf6\xdfe")),
-            Some(String::from("Gr\u{00f6}\u{00df}e"))
-        );
-    }
-
-    #[test]
-    fn the_report_line_is_exactly_the_promised_shape() {
-        let line = window_line(&[KeeperWindow {
-            id: 0x0040_0001,
-            title: Some(String::from("PPF probe - Google Chrome")),
-            class: Some(String::from("Google-chrome")),
-            pid: Some(1003571),
-            width: 1280,
-            height: 800,
-        }]);
-        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
-        assert_eq!(
-            parsed,
-            serde_json::json!({
-                "windows": [{
-                    "id": 0x40_0001_u64,
-                    "title": "PPF probe - Google Chrome",
-                    "class": "Google-chrome",
-                    "pid": 1003571,
-                    "width": 1280,
-                    "height": 800,
-                }]
-            })
-        );
-        assert_eq!(window_line(&[]), r#"{"windows":[]}"#);
-    }
-
-    #[test]
-    fn missing_fields_are_null_not_absent() {
-        let line = window_line(&[KeeperWindow {
-            id: 7,
-            title: None,
-            class: None,
-            pid: None,
-            width: 100,
-            height: 100,
-        }]);
-        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
-        let window = &parsed["windows"][0];
-        assert_eq!(window["title"], serde_json::Value::Null);
-        assert_eq!(window["class"], serde_json::Value::Null);
-        assert_eq!(window["pid"], serde_json::Value::Null);
-        assert!(window.get("width").is_some());
-    }
-
-    #[test]
-    fn an_unopenable_display_is_refused_in_one_error_line() {
-        let mut out = Vec::new();
-        assert!(keep(Some("not a display"), &mut out).is_err());
-        let line: serde_json::Value =
-            serde_json::from_str(&String::from_utf8(out).unwrap()).unwrap();
-        assert!(line["error"]
-            .as_str()
-            .is_some_and(|error| !error.is_empty()));
-    }
-
-    #[test]
-    fn a_refused_keeper_says_why_in_its_error_line() {
-        let mut out = Vec::new();
-        let error = fatal(&mut out, "another window manager").unwrap_err();
-        assert_eq!(error.to_string(), "another window manager");
-        assert_eq!(
-            String::from_utf8(out).unwrap(),
-            "{\"error\":\"another window manager\"}\n"
-        );
-    }
-
-    #[test]
-    fn the_display_flag_has_one_spelling() {
-        let flag = |args: &[&str]| {
-            display_argument(
-                &args
-                    .iter()
-                    .map(|arg| String::from(*arg))
-                    .collect::<Vec<_>>(),
-            )
-        };
-        assert_eq!(flag(&["--display", ":42"]), Some(String::from(":42")));
-        assert_eq!(
-            flag(&["--display", ":42", "--x"]),
-            Some(String::from(":42"))
-        );
-        assert_eq!(flag(&[]), None);
-        assert_eq!(flag(&["--display"]), None);
-        // The undocumented `--display=:42` spelling is not a display: `keep`
-        // refuses it rather than guessing what was meant.
-        assert_eq!(flag(&["--display=:42"]), None);
-    }
-}

package/engine/src/keymap.rs

@@ -254,110 +254,3 @@ impl Layout {
         (plan, unreachable)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_layout_that_comes_from_the_environment_is_the_one_compiled() {
-        let names = LayoutNames::from_lookup(|key| match key {
-            "XKB_DEFAULT_LAYOUT" => Some(String::from("de")),
-            _ => None,
-        });
-        assert_eq!(names.identity(), "de");
-
-        let layout = Layout::from_names(&names).expect("the German keymap should compile");
-        let (plan, unreachable) = layout.plan_text("z");
-        assert!(
-            unreachable.is_empty(),
-            "z should be reachable: {unreachable:?}"
-        );
-        // QWERTZ puts z where a US layout puts y, so the compiled keymap is the
-        // environment's, not the library default.
-        assert_eq!(plan[0][0].code, 21, "z must sit on the y key position");
-    }
-
-    #[test]
-    fn a_session_with_no_layout_variable_reports_the_library_default() {
-        assert_eq!(LayoutNames::from_lookup(|_| None).identity(), "us");
-    }
-
-    #[test]
-    fn a_character_is_planned_as_a_real_key_event_on_the_compiled_layout() {
-        let layout = Layout::from_names(&LayoutNames::from_lookup(|_| None))
-            .expect("a keymap should compile");
-        let (plan, unreachable) = layout.plan_text("aA.\n");
-        assert!(
-            unreachable.is_empty(),
-            "ASCII should be reachable: {unreachable:?}"
-        );
-        assert_eq!(plan.len(), 4);
-        assert!(!plan[0][0].shift, "lower-case a needs no shift");
-        assert!(
-            plan[1][0].shift,
-            "upper-case A needs shift on any normal layout"
-        );
-        assert_eq!(plan[0][0].code, plan[1][0].code, "both letters share a key");
-        // The plan is evdev, but the real injector expects Moonlight/VK codes.
-        // Passing Linux N (49) straight through instead presses VK_1.
-        let native: Vec<_> = plan
-            .iter()
-            .flatten()
-            .map(|stroke| crate::input::native_keycode(stroke.code).unwrap())
-            .collect();
-        assert_eq!(native, [0x41, 0x41, 0xBE, 0x0D]);
-        assert_eq!(
-            crate::input::native_keycode(plan[1][0].modifiers()[0]).unwrap(),
-            0x10
-        );
-        assert_eq!(
-            crate::input::native_keycode(modifier_key("Control").unwrap()).unwrap(),
-            0x11
-        );
-    }
-
-    #[test]
-    fn named_keys_and_modifiers_resolve_to_linux_key_codes() {
-        assert_eq!(named_key("Enter").unwrap().code, keycode::ENTER);
-        assert_eq!(named_key("ArrowLeft").unwrap().code, keycode::LEFT);
-        for (name, code) in [
-            ("Delete", keycode::DELETE), ("Home", keycode::HOME), ("End", keycode::END),
-            ("PageUp", keycode::PAGE_UP), ("PageDown", keycode::PAGE_DOWN),
-            ("F1", keycode::F1), ("F2", keycode::F2), ("F3", keycode::F3),
-            ("F4", keycode::F4), ("F5", keycode::F5), ("F6", keycode::F6),
-            ("F7", keycode::F7), ("F8", keycode::F8), ("F9", keycode::F9),
-            ("F10", keycode::F10), ("F11", keycode::F11), ("F12", keycode::F12),
-        ] {
-            assert_eq!(named_key(name).unwrap().code, code);
-            assert!(crate::input::native_keycode(code).is_ok(), "{name} must reach inputtino");
-        }
-        assert_eq!(modifier_key("Control"), Some(keycode::LEFT_CTRL));
-        assert_eq!(modifier_key("Alt"), Some(keycode::LEFT_ALT));
-        assert_eq!(modifier_key("Super"), Some(keycode::LEFT_META));
-        assert!(named_key("Frobnicate").is_none());
-        assert!(modifier_key("Hyper").is_none());
-    }
-
-    #[test]
-    fn text_this_layout_cannot_produce_is_reported_not_invented() {
-        let layout = Layout::from_environment().unwrap();
-        let (_, unreachable) = layout.plan_text("\u{1F600}");
-        assert_eq!(unreachable, "\u{1F600}");
-    }
-
-    #[test]
-    fn a_symbol_only_reachable_beyond_four_levels_is_refused() {
-        let names = LayoutNames::from_lookup(|key| match key {
-            "XKB_DEFAULT_LAYOUT" => Some(String::from("de")),
-            "XKB_DEFAULT_VARIANT" => Some(String::from("neo")),
-            _ => None,
-        });
-        let layout = Layout::from_names(&names).expect("the Neo keymap should compile");
-        assert!(
-            layout.keystroke_for_char('\u{a3}').is_none(),
-            "the pound sign sits on a level this engine cannot press"
-        );
-        assert!(layout.keystroke_for_char('6').is_some());
-    }
-}

package/engine/src/keymap_mac.rs

@@ -182,28 +182,3 @@ fn us_ansi_key(character: char) -> Option<(i16, bool)> {
         _ => return None,
     })
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn maps_common_ascii_to_ansi_virtual_keys() {
-        let layout = Layout::from_environment().unwrap();
-        let lower = layout.keystroke_for_char('a').unwrap();
-        let upper = layout.keystroke_for_char('A').unwrap();
-        assert_eq!(lower.code, 0);
-        assert_eq!(upper.code, lower.code);
-        assert!(upper.shift);
-        assert_eq!(layout.keystroke_for_char('!').unwrap().code, 18);
-        assert!(layout.keystroke_for_char('\u{1f600}').is_none());
-    }
-
-    #[test]
-    fn resolves_mac_named_keys_and_modifiers() {
-        assert_eq!(named_key("Return").unwrap().code, 36);
-        assert_eq!(named_key("ArrowLeft").unwrap().code, 123);
-        assert_eq!(modifier_key("Command"), Some(55));
-        assert!(named_key("Frobnicate").is_none());
-    }
-}

package/engine/src/mac.rs

@@ -184,6 +184,7 @@ fn capabilities() -> Value {
             "formats": ["bgra"],
             "cursor": "embedded",
             "cursor_modes": ["embedded"],
+            // ScreenCaptureKit audio is not wired up; macOS is out of scope.
             "audio": false,
             "displays": displays(),
             "grant": if capture_granted { "granted" } else { "missing-screen-recording" },
@@ -717,31 +718,3 @@ pub fn run() -> i32 {
     }
     0
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[cfg(desklink_vpx)]
-    #[test]
-    fn session_capabilities_are_non_prompting_and_expose_mac_features() {
-        let value = crate::session::capabilities();
-        assert_eq!(value["protocol"], crate::protocol::PROTOCOL_VERSION);
-        assert_eq!(value["platform"], "macos");
-        assert_eq!(value["capture"]["mechanism"], "screencapturekit");
-        assert_eq!(value["encode"]["codecs"][0], "vp9", "VP9 is always offered");
-        // Every Mac this engine runs on has a hardware H.264 encoder.
-        assert_eq!(value["encode"]["codecs"][1], "h264");
-        assert_eq!(value["encode"]["h264"]["encoder"], "videotoolbox");
-        assert!(value["capture"]["displays"].is_array());
-        assert!(value["clipboard"]["read"].as_bool().unwrap());
-        assert!(matches!(
-            value["capture"]["grant"].as_str(),
-            Some("granted" | "missing-screen-recording")
-        ));
-        assert!(matches!(
-            value["input"]["grant"].as_str(),
-            Some("granted" | "missing-accessibility")
-        ));
-    }
-}

package/engine/src/main.rs

@@ -6,6 +6,8 @@
 //! 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 audio;
 #[cfg(target_os = "linux")]
 mod capture;
 #[cfg(target_os = "macos")]
@@ -574,6 +576,15 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.frame.changed",
             serde_json::json!({ "sessionId": session_id, "seq": seq, "damage": damage, "timestamp_us": timestamp_us }),
         ),
+        session::SessionEvent::Audio {
+            seq,
+            timestamp_us,
+            bytes,
+            gap_micros,
+        } => (
+            "session.audio.changed",
+            serde_json::json!({ "sessionId": session_id, "seq": seq, "timestamp_us": timestamp_us, "bytes": bytes, "gap_ms": gap_micros / 1000 }),
+        ),
         session::SessionEvent::Input { input } => (
             "session.input",
             serde_json::json!({ "sessionId": session_id, "input": input }),
@@ -658,6 +669,7 @@ async fn dispatch(
                 loopback_tcp: params.loopback_tcp,
                 agent_indicator: params.agent_indicator,
                 local_frames: params.local_frames,
+                audio: params.audio,
                 ice_servers: params
                     .ice_servers
                     .into_iter()
@@ -684,6 +696,7 @@ async fn dispatch(
                 "geometry": session.geometry(),
                 "cursor": session.cursor_info(),
                 "agentIndicator": session.agent_indicator(),
+                "audio": session.audio_info(),
             });
             *current = Some(session);
             Ok(result)
@@ -787,6 +800,15 @@ async fn dispatch(
                 .frame(params.since, &params.path, params.region)
                 .map_err(|error| ErrorBody::new(error.code, error.message))
         }
+        "session.audio" => {
+            let session = require_session(current)?;
+            let params: protocol::AudioParams = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, None)?;
+            session
+                .audio(&params.path, params.max_bytes)
+                .map_err(|error| ErrorBody::new(error.code, error.message))
+        }
         "session.feed" => {
             let session = require_session(current)?;
             let params: protocol::FeedParams = serde_json::from_value(request.params.clone())