feat: add lua support with feature flag

- Added a "lua" feature flag to Cargo.toml, making the mlua dependency optional.
- Extended keyboard and mouse modules with conditional Lua function registration.
- Updated main.rs to execute Lua scripts when the "lua" feature is enabled.
- Introduced register_delay and LuaEngine functionality in lua_engine.rs.

Author: davehorner

Cargo.toml

@@ -8,6 +8,9 @@ version = "0.1.0"
 edition = "2021"
 authors = ["David Horner"]
 
+[features]
+default = ["lua"]
+lua = ["mlua"]
 
 
 [dependencies]
@@ -24,6 +27,7 @@ tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 #webrtc = "0.12.0"
 webrtc = { git = "https://github.com/davehorner/webrtc.git", branch = "jetkvm_16_bit_patch", version = "0.12.0" }
+mlua = { version = "0.10.1", features = ["lua54", "vendored", "async", "send", "serialize"], optional = true }
 
 [dev-dependencies]
 regex = "1.11.1"

src/keyboard.rs

@@ -3,6 +3,8 @@ use anyhow::Result as AnyResult;
 use serde_json::{json, Value};
 use tokio::time::{sleep, Duration};
 use tracing::debug;
+use std::sync::Arc;
+use tokio::sync::Mutex;
 
 /// Sends a keyboard report with the given modifier and keys.
 pub async fn rpc_keyboard_report(
@@ -236,3 +238,88 @@ pub async fn send_windows_key(client: &crate::jetkvm_rpc_client::JetKvmRpcClient
 
     Ok(())
 }
+
+/// Registers keyboard functions to the provided Lua context.
+#[cfg(feature = "lua")]
+use mlua::prelude::*;
+#[cfg(feature = "lua")]
+pub fn register_lua(lua: &Lua, client: Arc<Mutex<JetKvmRpcClient>>) -> LuaResult<()> {
+    let send_return_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, ()| {
+            let client = client.clone();
+            async move {
+                send_return(&*client.lock().await).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_return", send_return_fn)?;
+
+    let send_ctrl_a_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, ()| {
+            let client = client.clone();
+            async move {
+                send_ctrl_a(&*client.lock().await).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_ctrl_a", send_ctrl_a_fn)?;
+
+    let send_ctrl_v_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, ()| {
+            let client = client.clone();
+            async move {
+                send_ctrl_v(&*client.lock().await).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_ctrl_v", send_ctrl_v_fn)?;
+
+    let send_ctrl_x_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, ()| {
+            let client = client.clone();
+            async move {
+                send_ctrl_x(&*client.lock().await).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_ctrl_x", send_ctrl_x_fn)?;
+
+    let send_ctrl_c_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, ()| {
+            let client = client.clone();
+            async move {
+                send_ctrl_c(&*client.lock().await).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_ctrl_c", send_ctrl_c_fn)?;
+
+    let send_windows_key_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, ()| {
+            let client = client.clone();
+            async move {
+                send_windows_key(&*client.lock().await).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_windows_key", send_windows_key_fn)?;
+
+    let send_text_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, text: String| {
+            let client = client.clone();
+            async move {
+                rpc_sendtext(&*client.lock().await, &text).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("send_text", send_text_fn)?;
+
+    Ok(())
+}

src/lib.rs

@@ -6,5 +6,6 @@ pub mod keyboard;
 pub mod mouse;
 pub mod rpc_client;
 pub mod system;
+pub mod lua_engine;
 
 pub use jetkvm_rpc_client::JetKvmRpcClient;

src/main.rs

@@ -2,10 +2,8 @@ use anyhow::Result as AnyResult;
 use jetkvm_control::device::{rpc_get_device_id, rpc_ping};
 use jetkvm_control::jetkvm_config::JetKvmConfig;
 use jetkvm_control::jetkvm_rpc_client::JetKvmRpcClient;
-use jetkvm_control::mouse::rpc_abs_mouse_report;
-use jetkvm_control::mouse::*;
 use jetkvm_control::system::rpc_get_edid;
-use tokio::time::{sleep, Duration};
+
 use tracing::{error, info};
 use tracing_subscriber;
 
@@ -32,5 +30,35 @@ async fn main() -> AnyResult<()> {
     let edid = rpc_get_edid(&client).await;
     info!("EDID: {:?}", edid);
 
+    #[cfg(feature = "lua")]
+    {
+        use std::sync::Arc;
+        use tokio::sync::Mutex;
+        use jetkvm_control::lua_engine::LuaEngine;
+        let client_arc = Arc::new(Mutex::new(client));
+    
+        // Create and configure the Lua engine.
+        let lua_engine = LuaEngine::new(client_arc);
+        lua_engine.register_builtin_functions()?;
+    
+        // Optionally, execute a Lua script.
+        let script = r#"
+            print("Executing Lua script...")
+            send_windows_key()
+            delay(250)
+            send_text("notepad")
+            send_return()
+            delay(250)
+            send_text("Hello World!")
+            send_ctrl_a()
+            send_ctrl_c()
+            right_click(100, 200)
+        "#;
+    
+        lua_engine.exec_script(script).await?;
+        info!("Lua script executed successfully."); 
+    }
+
+
     Ok(())
 }

src/mouse.rs

@@ -2,6 +2,8 @@ use crate::jetkvm_rpc_client::JetKvmRpcClient;
 use anyhow::Result as AnyResult;
 use serde_json::{json, Value};
 use tokio::time::{sleep, Duration};
+use std::sync::Arc;
+use tokio::sync::Mutex;
 
 /// Sends an absolute mouse report with x, y coordinates and button state.
 pub async fn rpc_abs_mouse_report(
@@ -202,3 +204,66 @@ pub async fn rpc_left_click_and_drag_to_center(
         .await?;
     Ok(())
 }
+
+/// Registers mouse functions to the provided Lua context.
+#[cfg(feature = "lua")]
+use mlua::prelude::*;
+#[cfg(feature = "lua")]
+pub fn register_lua(lua: &Lua, client: Arc<Mutex<JetKvmRpcClient>>) -> LuaResult<()> {
+    let left_click_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, (x, y): (i64, i64)| {
+            let client = client.clone();
+            async move {
+                rpc_left_click(&*client.lock().await, x, y).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("left_click", left_click_fn)?;
+
+    let right_click_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, (x, y): (i64, i64)| {
+            let client = client.clone();
+            async move {
+                rpc_right_click(&*client.lock().await, x, y).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("right_click", right_click_fn)?;
+
+    let middle_click_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, (x, y): (i64, i64)| {
+            let client = client.clone();
+            async move {
+                rpc_middle_click(&*client.lock().await, x, y).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("middle_click", middle_click_fn)?;
+
+    let move_mouse_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, (x, y): (i64, i64)| {
+            let client = client.clone();
+            async move {
+                rpc_move_mouse(&*client.lock().await, x, y).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("move_mouse", move_mouse_fn)?;
+
+    let double_click_fn = {
+        let client = client.clone();
+        lua.create_async_function(move |_, (x, y): (i64, i64)| {
+            let client = client.clone();
+            async move {
+                rpc_double_click(&*client.lock().await, x, y).await.map_err(mlua::Error::external)
+            }
+        })?
+    };
+    lua.globals().set("double_click", double_click_fn)?;
+
+    Ok(())
+}