feat(keyboard): add send_key_combinations API and Lua binding

- Implemented a new send_key_combinations function in src/keyboard.rs to simulate key press sequences via RPC.
- Introduced the KeyCombo struct (with Debug) to encapsulate key press details (modifier, keys, hold, wait).
- Updated README.md with usage examples for the new function.
- Added Lua examples (windows-exit_notepad.lua and updated windows-notepad-helloworld.lua) to demonstrate key combination usage.

Author: Dave Horner

README.md

@@ -132,6 +132,11 @@ delay(250)
 send_ctrl_v()
 delay(250)
 send_ctrl_v()
+send_key_combinations({
+    { modifier = 0x04, keys = {0x3D}, hold = 100, wait = 1000 }, -- Alt+F4
+    { modifier = 0, keys = {0x4F}, wait = 250 }, -- Right arrow
+    { modifier = 0, keys = {0x28} },  -- Return (Enter)
+})
 ```
 
 Check out the examples folder for additional detail.

lua-examples/windows-exit_notepad.lua

@@ -0,0 +1,9 @@
+print("Executing Lua script...")
+-- for i = 1, 10 do
+   send_key_combinations({
+       { modifier = 0x04, keys = {0x3D}, hold = 100, wait = 1000 } -- Alt+F4
+       { modifier = 0, keys = {0x4F}, hold = 100, wait = 550 }, -- Right arrow
+    -- { modifier = 0, keys = {0x4F}, hold = 100, wait = 50 }, -- Right arrow again (cancel button)
+       { modifier = 0, keys = {0x28}, hold = 100, wait = 50 }  -- Return (Enter)
+   })
+-- end

lua-examples/windows-notepad-helloworld.lua

@@ -12,4 +12,8 @@ delay(250)
 send_ctrl_v()
 delay(250)
 send_ctrl_v()
-
+send_key_combinations({
+    { modifier = 0x04, keys = {0x3D}, hold = 100, wait = 1000 }, -- Alt+F4
+    { modifier = 0, keys = {0x4F}, wait = 250 }, -- Right arrow
+    { modifier = 0, keys = {0x28} },  -- Return (Enter)
+})

src/keyboard.rs

@@ -280,6 +280,69 @@ pub async fn send_windows_key(client: &crate::jetkvm_rpc_client::JetKvmRpcClient
     Ok(())
 }
 
+/// Represents a key combination for a remote KVM device.
+/// 
+/// This struct defines the information required to simulate a key press event:
+/// - `modifier`: A bitmask representing modifier keys (e.g., Ctrl, Alt).
+/// - `keys`: A list of key codes to be pressed.
+/// - `hold`: The duration (in milliseconds) to hold the key press (defaults to 100 ms).
+/// - `wait`: The delay (in milliseconds) after releasing the keys before proceeding to the next combination (defaults to 10 ms).
+#[derive(Debug)]
+struct KeyCombo {
+    modifier: u64,
+    keys: Vec<u8>,
+    hold: u64, // how long to hold the key press (in ms), defaults to 100 ms
+    wait: u64, // delay after releasing keys before next combo (in ms), defaults to 10 ms
+}
+
+/// Sends a series of key combinations to the remote KVM device via RPC.
+///
+/// This asynchronous function processes each key combination in the provided list by:
+/// 1. Sending a `keyboardReport` RPC that presses the specified keys along with any modifier keys.
+/// 2. Waiting for the duration specified in `combo.hold` to simulate holding the keys down.
+/// 3. Sending another `keyboardReport` RPC to release all keys.
+/// 4. Waiting for the duration specified in `combo.wait` before moving to the next combination.
+///
+/// # Parameters
+/// - `client`: A reference to the `JetKvmRpcClient` that is used to send RPC commands.
+/// - `combos`: A vector of `KeyCombo` structs, where each struct contains:
+///   - `modifier`: The modifier key(s) (like Ctrl, Alt, etc.) to apply.
+///   - `keys`: The list of keys to be pressed.
+///   - `hold`: The duration (in milliseconds) to hold the keys down.
+///   - `wait`: The duration (in milliseconds) to wait after releasing the keys.
+///
+/// # Returns
+/// Returns `Ok(())` if all key combinations are successfully processed, or an error if any RPC call fails.
+async fn send_key_combinations(client: &JetKvmRpcClient, combos: Vec<KeyCombo>) -> AnyResult<()> {
+    for combo in combos {
+        // Press the keys with the specified modifier.
+        client
+            .send_rpc(
+                "keyboardReport",
+                json!({
+                    "modifier": combo.modifier,
+                    "keys": combo.keys,
+                }),
+            )
+            .await?;
+        // Hold the key for the specified duration.
+        sleep(Duration::from_millis(combo.hold)).await;
+        // Release all keys.
+        client
+            .send_rpc(
+                "keyboardReport",
+                json!({
+                    "modifier": 0,
+                    "keys": [],
+                }),
+            )
+            .await?;
+        // Wait after releasing keys before proceeding.
+        sleep(Duration::from_millis(combo.wait)).await;
+    }
+    Ok(())
+}
+
 /// Registers keyboard functions to the provided Lua context.
 #[cfg(feature = "lua")]
 use mlua::prelude::*;
@@ -376,5 +439,37 @@ pub fn register_lua(lua: &Lua, client: Arc<Mutex<JetKvmRpcClient>>) -> LuaResult
     };
     lua.globals().set("send_text", send_text_fn)?;
 
+    let send_key_combinations_fn = {
+        let value = client.clone();
+        // The async function returns a Result; we unwrap it here.
+        lua.create_async_function(move |_, combos: mlua::Table| {
+            let client = value.clone();
+            async move {
+                let mut key_combos = Vec::new();
+                // Expecting combos to be an array of tables.
+                for pair in combos.sequence_values::<mlua::Table>() {
+                    let combo_table = pair?;
+                    let modifier: u64 = combo_table.get("modifier")?;
+                    let keys: Vec<u8> = combo_table.get("keys")?;
+                    // Optional fields: default to hold = 100 ms and wait = 10 ms.
+                    let hold: u64 = combo_table.get("hold").unwrap_or(100);
+                    let wait: u64 = combo_table.get("wait").unwrap_or(10);
+                    key_combos.push(KeyCombo {
+                        modifier,
+                        keys,
+                        hold,
+                        wait,
+                    });
+                }
+                send_key_combinations(&*client.lock().await, key_combos)
+                    .await
+                    .map_err(mlua::Error::external)
+            }
+        })
+    }?;
+
+    lua.globals()
+        .set("send_key_combinations", send_key_combinations_fn)?;
+
     Ok(())
 }