feat: update dependencies, logging, and documentation

- Enable "env-filter" feature for tracing-subscriber in Cargo.toml
- Update README: adjust run command, add Lua and Rust examples, and refine usage details
- Increase delay in Lua example (windows-notepad-helloworld.lua)
- Comment out debug logs in jetkvm_rpc_client.rs for cleaner output
- Enhance keyboard character mapping in src/keyboard.rs with extended punctuation support
- Improve tracing configuration in main.rs to include verbose logging options
- Tidy debug messages in src/rpc_client.rs

Author: Dave Horner

Cargo.lock

@@ -25,7 +25,7 @@ serde_json = "1.0.138"
 tokio = "1.43.0"
 toml = "0.8.20"
 tracing = "0.1.41"
-tracing-subscriber = "0.3.19"
+tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 #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 }

Cargo.toml

@@ -46,62 +46,85 @@ jetkvm_control = "0.1.0"  # or use a git dependency / local path during developm
 3. **Running the Project**
     After setting up your configuration, you can build and run the project with Cargo:
      ```bash
-     cargo run
+     cargo run -- -H 192.168.1.100 lua-examples/windows-notepad-helloworld.lua
      ```
 
-    This will compile the project and start the demo application which:
+    This will compile the project and execute the window-notepad-helloworld.lua example.
   
-        - Connects to the JetKVM service,
-        - Opens a WebRTC DataChannel,
-        - Sends RPC calls to perform actions (e.g., keyboard events, mouse clicks).
+## About the cmdline client
 
-## What's the cmdline client look like
+The client (cargo run/jetkvm_control) is a simple ping if you don't have the `lua` feature enabled.
 
-Right now the client doesn't do anything put ping and display some additional debug.
+If you enable the lua feature; jetkvm_control will expect a lua file to execute.
 
 ```
 A control client for JetKVM over WebRTC.
 
-Usage: jetkvm_control [OPTIONS]
+Usage: jetkvm_control [OPTIONS] <LUA_SCRIPT>
+
+Arguments:
+  <LUA_SCRIPT>  Path to the Lua script to execute
 
 Options:
   -H, --host <HOST>          The host address to connect to
   -p, --port <PORT>          The port number to use
   -a, --api <API>            The API endpoint
   -P, --password <PASSWORD>  The password for authentication
+  -v, --verbose              Enable verbose logging (include logs from webrtc_sctp)
   -h, --help                 Print help
   -V, --version              Print version
 ```
 
 ## What's the code look like
 
-   ```rust
-    let config = JetKvmConfig::load()?;
-    let mut client = JetKvmRpcClient::new(config);
-
-    if let Err(err) = client.connect().await {
-        error!("Failed to connect to RPC server: {:?}", err);
-        std::process::exit(1);
-    }
-    // open notepad and say Hello World, copy and paste.
-    send_windows_key(&client).await.ok();
-    sleep(Duration::from_millis(100)).await;
-    rpc_sendtext(&client, "notepad").await.ok();
-    sleep(Duration::from_millis(100)).await;
-    send_return(&client).await.ok();
-    sleep(Duration::from_millis(100)).await;
-    rpc_sendtext(&client, "Hello World").await.ok();
-    sleep(Duration::from_millis(100)).await;
-    send_ctrl_a(&client).await.ok();
-    sleep(Duration::from_millis(100)).await;
-    send_ctrl_x(&client).await.ok();
-    sleep(Duration::from_millis(100)).await;
-    send_ctrl_v(&client).await.ok();
-    sleep(Duration::from_millis(100)).await;
-    send_return(&client).await.ok();
-    sleep(Duration::from_millis(100)).await;
-    send_ctrl_v(&client).await.ok();
-   ```
+The api is subject to change.
+
+example code for rust:
+```rust
+let config = JetKvmConfig::load()?;
+let mut client = JetKvmRpcClient::new(config);
+
+if let Err(err) = client.connect().await {
+    error!("Failed to connect to RPC server: {:?}", err);
+    std::process::exit(1);
+}
+// open notepad and say Hello World, copy and paste.
+send_windows_key(&client).await.ok();
+sleep(Duration::from_millis(100)).await;
+rpc_sendtext(&client, "notepad").await.ok();
+sleep(Duration::from_millis(100)).await;
+send_return(&client).await.ok();
+sleep(Duration::from_millis(100)).await;
+rpc_sendtext(&client, "Hello World").await.ok();
+sleep(Duration::from_millis(100)).await;
+send_ctrl_a(&client).await.ok();
+sleep(Duration::from_millis(100)).await;
+send_ctrl_x(&client).await.ok();
+sleep(Duration::from_millis(100)).await;
+send_ctrl_v(&client).await.ok();
+sleep(Duration::from_millis(100)).await;
+send_return(&client).await.ok();
+sleep(Duration::from_millis(100)).await;
+send_ctrl_v(&client).await.ok();
+```
+
+example code in lua:
+```lua
+print("Executing Lua script...")
+send_windows_key()
+delay(550)
+send_text("notepad")
+send_return()
+delay(250)
+delay(250)
+send_text("Hello World!")
+send_ctrl_a()
+send_ctrl_c()
+delay(250)
+send_ctrl_v()
+delay(250)
+send_ctrl_v()
+```
 
 Check out the examples folder for additional detail.
 
@@ -135,9 +158,8 @@ JetKVM **relies heavily on WebRTC** for real-time communication, but we encounte
 - The Cargo.toml points to the patched https://github.com/davehorner/webrtc/tree/jetkvm_16_bit_patch
 
 ## Note
-  - Password-based authentication is functional.
+  - Password-less and Password-based local authentication have been tested functional.
   - Cloud integration and ICE/STUN support are not implemented yet.
-  - Password-less authentication has not been tested.
   - Contributions for these features are welcome!
 
 ## License

README.md

@@ -1,6 +1,6 @@
 print("Executing Lua script...")
 send_windows_key()
-delay(250)
+delay(550)
 send_text("notepad")
 send_return()
 delay(250)

lua-examples/windows-notepad-helloworld.lua

@@ -110,16 +110,16 @@ impl JetKvmRpcClient {
 
         // 7. Send the offer to the server.
         let url = self.config.session_url();
-        debug!("Sending SDP Offer to {}", url);
+        //debug!("Sending SDP Offer to {}", url);
 
         let response = http_client.post(&url).json(&session_request).send().await?;
         let response_text = response.text().await?;
-        debug!("Received SDP Answer response: {}", response_text);
+        //debug!("Received SDP Answer response: {}", response_text);
 
         let session_response: WebRTCSessionResponse = serde_json::from_str(&response_text)?;
         let decoded_answer = general_purpose::STANDARD.decode(session_response.sd)?;
         let answer_value: Value = serde_json::from_slice(&decoded_answer)?;
-        debug!("Decoded SDP answer: {}", answer_value);
+        //debug!("Decoded SDP answer: {}", answer_value);
 
         let sdp_field = answer_value
             .get("sdp")

src/jetkvm_rpc_client.rs

@@ -20,31 +20,71 @@ pub async fn rpc_keyboard_report(
 }
 
 /// Convert an ASCII character into a (modifier, keycode) pair, following HID usage tables.
-/// Currently supports letters and digits only.
-/// - For lowercase letters, modifier = 0, keycode = 0x04 + (c - 'a').
-/// - For uppercase letters, modifier = 0x02 (shift), keycode = same as lowercase.
-/// - For digits: '1' to '9' map to 0x1E..0x26, '0' maps to 0x27.
+///
+/// For letters:
+/// - Lowercase: modifier = 0, keycode = 0x04 + (c - 'a').
+/// - Uppercase: modifier = 0x02 (shift), keycode = same as lowercase.
+///
+/// For digits:
+/// - '1' to '9': keycodes 0x1E to 0x26 respectively,
+/// - '0': keycode 0x27.
+///
+/// For space:
+/// - Keycode is 0x2C with no modifier.
+///
+/// For common punctuation and symbols, the mapping is defined in a static table.
+///
+/// Returns `None` if the character is not supported.
 fn char_to_hid(c: char) -> Option<(u8, u8)> {
     if c.is_ascii_alphabetic() {
-        let base = 0x04;
-        if c.is_ascii_lowercase() {
-            Some((0, (c as u8) - b'a' + base))
-        } else {
-            // Uppercase letters require SHIFT (modifier 0x02)
-            Some((0x02, (c.to_ascii_lowercase() as u8) - b'a' + base))
-        }
+        let shift = if c.is_ascii_uppercase() { 0x02 } else { 0 };
+        Some((shift, (c.to_ascii_lowercase() as u8) - b'a' + 0x04))
     } else if c.is_ascii_digit() {
         if c == '0' {
             Some((0, 0x27))
         } else {
             Some((0, (c as u8) - b'1' + 0x1E))
         }
     } else if c == ' ' {
-        // HID usage for space is 0x2C, no modifier.
+        // HID usage for space.
         Some((0, 0x2C))
     } else {
-        // Extend with additional mappings as needed.
-        None
+        // Mapping for additional punctuation and symbols.
+        const MAP: &[(char, (u8, u8))] = &[
+            ('!', (0x02, 0x1E)), // Shift + '1'
+            ('@', (0x02, 0x1F)), // Shift + '2'
+            ('#', (0x02, 0x20)), // Shift + '3'
+            ('$', (0x02, 0x21)), // Shift + '4'
+            ('%', (0x02, 0x22)), // Shift + '5'
+            ('^', (0x02, 0x23)), // Shift + '6'
+            ('&', (0x02, 0x24)), // Shift + '7'
+            ('*', (0x02, 0x25)), // Shift + '8'
+            ('(', (0x02, 0x26)), // Shift + '9'
+            (')', (0x02, 0x27)), // Shift + '0'
+            ('-', (0, 0x2D)),
+            ('_', (0x02, 0x2D)),
+            ('=', (0, 0x2E)),
+            ('+', (0x02, 0x2E)),
+            ('[', (0, 0x2F)),
+            ('{', (0x02, 0x2F)),
+            (']', (0, 0x30)),
+            ('}', (0x02, 0x30)),
+            ('\\', (0, 0x31)),
+            ('|', (0x02, 0x31)),
+            (';', (0, 0x33)),
+            (':', (0x02, 0x33)),
+            ('\'', (0, 0x34)),
+            ('"', (0x02, 0x34)),
+            ('`', (0, 0x35)),
+            ('~', (0x02, 0x35)),
+            (',', (0, 0x36)),
+            ('<', (0x02, 0x36)),
+            ('.', (0, 0x37)),
+            ('>', (0x02, 0x37)),
+            ('/', (0, 0x38)),
+            ('?', (0x02, 0x38)),
+        ];
+        MAP.iter().find_map(|&(ch, pair)| if ch == c { Some(pair) } else { None })
     }
 }
 

src/keyboard.rs

@@ -2,9 +2,9 @@ use anyhow::Result as AnyResult;
 use clap::{CommandFactory, Parser};
 use jetkvm_control::jetkvm_config::JetKvmConfig;
 use jetkvm_control::jetkvm_rpc_client::JetKvmRpcClient;
-use tokio::time::{sleep, Duration};
 use tracing::{error, info, warn};
-use tracing_subscriber;
+use tracing_subscriber::{fmt, EnvFilter, registry};
+use tracing_subscriber::prelude::*;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -25,6 +25,10 @@ struct CliConfig {
     #[arg(short = 'P', long)]
     password: Option<String>,
 
+    /// Enable verbose logging (include logs from webrtc_sctp).
+    #[arg(short = 'v', long)]
+    verbose: bool,
+
     // When the "lua" feature is enabled, the first positional argument is the Lua script path.
     #[cfg(feature = "lua")]
     /// Path to the Lua script to execute.
@@ -59,15 +63,36 @@ fn load_and_override_config(cli_config: &CliConfig) -> JetKvmConfig {
 
 #[tokio::main]
 async fn main() -> AnyResult<()> {
-    tracing_subscriber::fmt()
-        .with_max_level(tracing::Level::DEBUG)
-        .init();
-    info!("Starting jetkvm_control demo...");
-
     // Parse CLI arguments.
     let cli_config = CliConfig::parse();
     info!("CLI config provided: {:?}", cli_config);
 
+    // Build a filter string: by default, disable webrtc_sctp logging,
+    // but if verbose is enabled, include all logs.
+    let filter_directive = if cli_config.verbose {
+        "debug"
+    } else {
+        "debug,\
+         webrtc_sctp=off,\
+         webrtc::peer_connection=off,\
+         webrtc_dtls=off,\
+         webrtc_mdns=off,\
+         hyper_util::client=off,\
+         webrtc_data::data_channel=off,\
+         webrtc_ice=off"
+    };
+
+    // Initialize tracing subscriber with the constructed filter.
+    // Create an EnvFilter using the directive.
+    let env_filter = EnvFilter::new(filter_directive);
+
+    // Build a subscriber with the filter layer and formatting layer.
+    registry()
+        .with(env_filter)
+        .with(fmt::layer())
+        .init();
+    info!("Starting jetkvm_control demo...");
+
     // Load configuration from file (or default) and override with CLI options.
     let config = load_and_override_config(&cli_config);