@desklink/host 0.3.0 → 0.4.0

package/engine/src/win.rs

@@ -0,0 +1,110 @@
+//! Windows host command entry point; native desktop access remains unavailable.
+
+use serde_json::{json, Value};
+
+pub fn capabilities() -> Value {
+    let mut value = json!({
+        "protocol": 3,
+        "engine": format!("desklink-host/{}", env!("CARGO_PKG_VERSION")),
+        "platform": "windows",
+        "session": { "kind": "windows" },
+        "x11": { "available": false },
+        "capture": {
+            "mechanism": "unavailable",
+            "backends": [],
+            "formats": [],
+            "cursor": "unavailable",
+            "cursor_modes": [],
+            "audio": false,
+            "displays": crate::portal::displays(),
+            "grant": "unavailable",
+            "unavailable_reason": {
+                "reason": crate::capture::unavailable_reason(),
+                "remedy": "Use a future Windows capture-enabled build."
+            }
+        },
+        "encode": {
+            "codecs": [],
+            "hardware": false,
+            "unavailable_reason": {
+                "reason": "Windows encoding is not implemented in this build; libvpx is not linked.",
+                "remedy": "Use a future Windows VP9-enabled build."
+            }
+        },
+        "encoded": { "codecs": [] },
+        "input": {
+            "mechanism": "unavailable",
+            "pointer": false,
+            "wheel": false,
+            "keyboard": false,
+            "text": [],
+            "layout": crate::keymap::keyboard_layout(),
+            "grant": "unavailable",
+            "unavailable_reason": {
+                "reason": crate::input::unavailable_reason(),
+                "remedy": "Use a future Windows input-enabled build."
+            }
+        },
+        "clipboard": {
+            "read": false,
+            "write": false,
+            "mime": [],
+            "maxBytes": crate::clipboard::MAX_CLIPBOARD_BYTES,
+            "unavailable_reason": {
+                "reason": "Windows clipboard transfer is not implemented in this build.",
+                "remedy": "Use a future Windows clipboard-enabled build."
+            }
+        }
+    });
+    if cfg!(desklink_vpx) {
+        value["encode"] = json!({"codecs": ["vp9"], "hardware": false,
+            "h264": {"encoder": null, "hardware": false}});
+        value["encoded"] = json!({"codecs": ["h264"]});
+    }
+    value
+}
+
+pub fn run() -> i32 {
+    let command = std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| String::from("help"));
+    match command.as_str() {
+        "version" | "--version" | "-V" => println!("{}", env!("CARGO_PKG_VERSION")),
+        "capabilities" => {
+            #[cfg(desklink_vpx)]
+            let value = crate::session::capabilities();
+            #[cfg(not(desklink_vpx))]
+            let value = capabilities();
+            println!("{}", serde_json::to_string_pretty(&value).unwrap());
+        }
+        "serve" => {
+            #[cfg(desklink_vpx)]
+            {
+                let runtime = match tokio::runtime::Builder::new_multi_thread()
+                    .enable_all()
+                    .build()
+                {
+                    Ok(runtime) => runtime,
+                    Err(error) => {
+                        eprintln!("error: cannot start the runtime: {error}");
+                        return 1;
+                    }
+                };
+                return crate::report(runtime.block_on(crate::serve()));
+            }
+            #[cfg(not(desklink_vpx))]
+            {
+                eprintln!("serve requires a VP9-enabled build; set DESKLINK_VPX_STATIC_DIR when building on Windows");
+                return 1;
+            }
+        }
+        "help" | "--help" | "-h" => {
+            println!("desklink-host — Windows host preview\n\nCommands: version, capabilities, serve\nWindows session serving requires a static libvpx build.");
+        }
+        _ => {
+            eprintln!("unknown command: {command}; run desklink-host --help");
+            return 2;
+        }
+    }
+    0
+}

package/engine/src/x11.rs

@@ -112,6 +112,14 @@ impl X11Desktop {
         })
     }
 
+    pub fn input_available(&self) -> bool {
+        self.connection
+            .xtest_get_version(2, 2)
+            .ok()
+            .and_then(|cookie| cookie.reply().ok())
+            .is_some()
+    }
+
     /// Allocate one MIT-SHM segment for the full root and map it here. Any
     /// failure means "no SHM on this server", never an error: the caller
     /// falls back to socket GetImage and reports it via [`Self::capture_path`].
@@ -235,6 +243,13 @@ impl X11Desktop {
         max_width: usize,
         max_height: usize,
     ) -> Result<(I420, Vec<u8>)> {
+        let raw = self.capture_raw()?;
+        let frame = self.convert(&raw, max_width, max_height)?;
+        Ok((frame, raw))
+    }
+
+    /// The root image as `width * 4`-byte BGRX rows at the screen's own size.
+    pub fn capture_raw(&mut self) -> Result<Vec<u8>> {
         // The server's depth is the only field that can tell us how the pixel is
         // packed; the engine assumes the byte order every TrueColor server uses.
         let _ = self.depth;
@@ -242,7 +257,7 @@ impl X11Desktop {
         // Prefer MIT-SHM. A segment that worked at connect can still break
         // later (revoked by the server); that degrades to the socket path,
         // which keeps capturing, instead of stalling on failing grabs.
-        if let Ok(output) = self.capture_shm(stride, max_width, max_height) {
+        if let Ok(output) = self.capture_shm(stride) {
             return Ok(output);
         }
         self.shm = None;
@@ -268,35 +283,34 @@ impl X11Desktop {
                 self.height
             );
         }
+        Ok(image.data)
+    }
+
+    /// Downscale a [`Self::capture_raw`] image into the caller's box as I420.
+    pub fn convert(&self, raw: &[u8], max_width: usize, max_height: usize) -> Result<I420> {
         let (width, height) = fit(self.width, self.height, max_width, max_height);
-        let frame = to_i420(
-            &image.data,
+        to_i420(
+            raw,
             self.width,
             self.height,
-            stride,
+            self.width * 4,
             crate::convert::PixelFormat::Bgrx,
             width,
             height,
         )
-        .context("the captured X11 pixels are not a format this engine can read")?;
-        Ok((frame, image.data))
+        .context("the captured X11 pixels are not a format this engine can read")
     }
 
     /// One MIT-SHM grab into the reused segment. The caller tears the
     /// segment down on any error and falls back to the socket path.
-    fn capture_shm(
-        &self,
-        stride: usize,
-        max_width: usize,
-        max_height: usize,
-    ) -> Result<(I420, Vec<u8>)> {
+    fn capture_shm(&self, stride: usize) -> Result<Vec<u8>> {
         let (seg, ptr, len) = match &self.shm {
             Some(shm) => (shm.seg, shm.ptr, shm.len),
             None => anyhow::bail!("no MIT-SHM segment"),
         };
         // MIT-SHM: the server writes the root straight into our mapping;
         // the reply only signals completion. The segment is reused, so
-        // copy out through the conversion below before the next grab.
+        // copy out before the next grab.
         self.connection
             .shm_get_image(
                 self.root,
@@ -325,22 +339,8 @@ impl X11Desktop {
             );
         }
         // Copy out of the reused segment before the next grab overwrites
-        // it; the caller samples these full-screen rows into the frame's
-        // geometry. This copy is inherent to SHM; the socket arm below
-        // moves its reply instead.
-        let owned = pixels.to_vec();
-        let (width, height) = fit(self.width, self.height, max_width, max_height);
-        let frame = to_i420(
-            &owned,
-            self.width,
-            self.height,
-            stride,
-            crate::convert::PixelFormat::Bgrx,
-            width,
-            height,
-        )
-        .context("the captured X11 pixels are not a format this engine can read")?;
-        Ok((frame, owned))
+        // it. This copy is inherent to SHM; the socket arm moves its reply.
+        Ok(pixels.to_vec())
     }
 
     fn flush(&self) -> Result<()> {
@@ -349,6 +349,21 @@ impl X11Desktop {
             .context("the X11 connection dropped")
     }
 
+    /// Query the root pointer independently of pixel damage. GetImage and
+    /// MIT-SHM do not contain the server cursor and we never composite it.
+    pub fn cursor_position(&self) -> Result<(i32, i32, bool)> {
+        let pointer = self.connection.query_pointer(self.root)?.reply()?;
+        Ok((
+            i32::from(pointer.root_x),
+            i32::from(pointer.root_y),
+            pointer.same_screen
+                && pointer.root_x >= 0
+                && pointer.root_y >= 0
+                && (pointer.root_x as usize) < self.width
+                && (pointer.root_y as usize) < self.height,
+        ))
+    }
+
     pub fn move_pointer(&self, x: i64, y: i64) -> Result<()> {
         let (x, y) = self.clamp(x, y);
         self.connection

package/engine/src/x11_mac.rs

@@ -18,6 +18,10 @@ impl X11Desktop {
         (0, 0)
     }
 
+    pub fn input_available(&self) -> bool {
+        false
+    }
+
     pub fn capture_with_pixels(&mut self, _: usize, _: usize) -> Result<(I420, Vec<u8>)> {
         bail!("the X11 backend is only available on Linux")
     }

package/examples/reference-client.html

@@ -269,14 +269,12 @@ async function start() {
     const capabilities = await request('capabilities');
     const clipboardAvailable = capabilities.clipboard?.read === true && capabilities.clipboard?.write === true;
     const controlAvailable = capabilities.input?.pointer === true && capabilities.input?.keyboard === true;
-    const permissions = ['view'];
-    if (controlAvailable) permissions.push('control');
-    if (clipboardAvailable) permissions.push('clipboard');
-    const session = await request('session.open', { permissions });
+    // The bridge token is the pairing: a paired session has view, input and clipboard.
+    const session = await request('session.open', {});
     currentSessionId = session.sessionId;
     keyboard.disabled = !controlAvailable;
     keyboardButton.disabled = !controlAvailable;
-    keyboardButton.title = controlAvailable ? '' : capabilities.input?.unavailable_reason?.remedy ?? 'This session is view-only';
+    keyboardButton.title = controlAvailable ? '' : capabilities.input?.unavailable_reason?.remedy ?? 'Input is unavailable on this machine';
     video.style.pointerEvents = controlAvailable ? 'auto' : 'none';
     copy.hidden = !clipboardAvailable;
     paste.hidden = !clipboardAvailable;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@desklink/host",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "license": "Apache-2.0",
     "description": "Per-user, on-demand desktop capture, encode and input engine with a versioned local control protocol",
     "type": "module",
@@ -30,10 +30,10 @@
         "node": ">=22"
     },
     "dependencies": {
-        "ws": "^8.18.0"
+        "ws": "8.21.3"
     },
     "optionalDependencies": {
-        "@desklink/host-linux-x64-gnu": "0.3.0",
-        "@desklink/host-darwin-arm64": "0.3.0"
+        "@desklink/host-linux-x64-gnu": "0.4.0",
+        "@desklink/host-darwin-arm64": "0.4.0"
     }
 }