tauri-agent-tools 0.1.0 → 0.2.0

package/.agents/skills/tauri-agent-tools/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: tauri-agent-tools
 description: CLI for inspecting Tauri desktop apps — DOM queries, screenshots, IPC/console monitoring, storage, and page state
-version: 0.1.0
+version: 0.2.0
 tags: [tauri, desktop, debugging, screenshot, dom, inspection]
 ---
 

package/.agents/skills/tauri-bridge-setup/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: tauri-bridge-setup
 description: How to add the tauri-agent-tools Rust dev bridge to a Tauri application
-version: 0.1.0
+version: 0.2.0
 tags: [tauri, rust, bridge, setup, integration]
 ---
 
@@ -21,6 +21,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 scopeguard = "1"
 rand = "0.8"
+uuid = { version = "1", features = ["v4"] }
 ```
 
 ## Step 2 — Copy the bridge module
@@ -43,13 +44,21 @@ cp node_modules/tauri-agent-tools/examples/tauri-bridge/src/dev_bridge.rs src-ta
 
 ## Step 3 — Wire up in main.rs
 
-Add the module declaration and start the bridge in your `src-tauri/src/main.rs`:
+Add the module declaration, register the bridge command, and start the bridge in your `src-tauri/src/main.rs`:
 
 ```rust
 mod dev_bridge;
 
 fn main() {
-    tauri::Builder::default()
+    let mut builder = tauri::Builder::default();
+
+    if cfg!(debug_assertions) {
+        builder = builder.invoke_handler(tauri::generate_handler![
+            dev_bridge::__dev_bridge_result
+        ]);
+    }
+
+    builder
         .setup(|app| {
             if cfg!(debug_assertions) {
                 if let Err(e) = dev_bridge::start_bridge(app.handle()) {
@@ -63,6 +72,16 @@ fn main() {
 }
 ```
 
+If you already have an `.invoke_handler()` with your own commands, merge them into one handler:
+
+```rust
+builder = builder.invoke_handler(tauri::generate_handler![
+    your_command_one,
+    your_command_two,
+    dev_bridge::__dev_bridge_result,
+]);
+```
+
 If you already have a `.setup()` call, add the `if cfg!(debug_assertions) { ... }` block inside it.
 
 ## Step 4 — Verify

package/examples/tauri-bridge/Cargo.toml

@@ -11,3 +11,4 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 scopeguard = "1"
 rand = "0.8"
+uuid = { version = "1", features = ["v4"] }

package/examples/tauri-bridge/src/dev_bridge.rs

@@ -1,8 +1,9 @@
 use rand::Rng;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::fs;
 use std::io::Write;
-use std::sync::Arc;
+use std::sync::{Arc, Condvar, Mutex};
 use std::thread;
 use tauri::{AppHandle, Manager};
 use tiny_http::{Header, Response, Server};
@@ -25,10 +26,31 @@ struct TokenFile {
     pid: u32,
 }
 
+/// Shared state for pending eval results.
+/// The HTTP handler thread waits on the Condvar; the Tauri command inserts
+/// the result and signals.
+pub struct PendingResults {
+    results: Mutex<HashMap<String, serde_json::Value>>,
+    notify: Condvar,
+}
+
+/// Tauri command invoked from injected JS to deliver eval results back to Rust.
+#[tauri::command]
+pub fn __dev_bridge_result(
+    id: String,
+    value: serde_json::Value,
+    state: tauri::State<'_, Arc<PendingResults>>,
+) {
+    let mut results = state.results.lock().unwrap();
+    results.insert(id, value);
+    state.notify.notify_all();
+}
+
 /// Start the development bridge HTTP server.
 /// Returns the port number on success.
 pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
-    let server = Server::http("127.0.0.1:0").map_err(|e| format!("Failed to start bridge: {e}"))?;
+    let server =
+        Server::http("127.0.0.1:0").map_err(|e| format!("Failed to start bridge: {e}"))?;
     let port = server
         .server_addr()
         .to_ip()
@@ -58,6 +80,13 @@ pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
         let _ = fs::remove_file(&cleanup_path);
     });
 
+    // Create shared pending-results state and register it with Tauri
+    let pending = Arc::new(PendingResults {
+        results: Mutex::new(HashMap::new()),
+        notify: Condvar::new(),
+    });
+    app.manage(pending.clone());
+
     let app_handle = app.clone();
     let expected_token = token.clone();
 
@@ -96,45 +125,88 @@ pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
                 continue;
             }
 
-            // Evaluate JS in webview
-            let (tx, rx) = std::sync::mpsc::channel();
-            let js = eval_req.js.clone();
+            // Evaluate JS in webview via callback pattern
+            let request_id = uuid::Uuid::new_v4().to_string();
 
             if let Some(window) = app_handle.get_webview_window("main") {
-                let _ = window.eval(&format!(
+                // Build JS that evaluates the expression, then calls back into Rust
+                // via __TAURI__.core.invoke() to deliver the result.
+                let callback_js = format!(
                     r#"
-                    try {{
-                        const __result = eval({js});
-                        window.__tauriDevBridgeResult = __result;
-                    }} catch(e) {{
-                        window.__tauriDevBridgeResult = "ERROR: " + e.message;
-                    }}
+                    (async () => {{
+                        try {{
+                            let __result = await eval({js});
+                            if (typeof __result === "undefined") {{
+                                __result = null;
+                            }} else if (typeof __result === "object" && __result !== null) {{
+                                __result = JSON.stringify(__result);
+                            }} else if (typeof __result !== "string") {{
+                                __result = String(__result);
+                            }}
+                            await window.__TAURI__.core.invoke("__dev_bridge_result", {{
+                                id: {id},
+                                value: __result
+                            }});
+                        }} catch(e) {{
+                            await window.__TAURI__.core.invoke("__dev_bridge_result", {{
+                                id: {id},
+                                value: "ERROR: " + e.message
+                            }});
+                        }}
+                    }})();
                     "#,
-                    js = serde_json::to_string(&js).unwrap()
-                ));
-
-                // Give the webview a moment to evaluate
-                thread::sleep(std::time::Duration::from_millis(50));
-
-                // For simplicity, return the JS expression — in production,
-                // use a Tauri command callback to get the actual result
-                let _ = tx.send(serde_json::Value::String(js));
-            } else {
-                let _ = tx.send(serde_json::Value::Null);
-            }
-
-            match rx.recv_timeout(std::time::Duration::from_secs(5)) {
-                Ok(result) => {
-                    let resp = EvalResponse { result };
-                    let json = serde_json::to_string(&resp).unwrap();
-                    let header =
-                        Header::from_bytes("Content-Type", "application/json").unwrap();
-                    let _ = request.respond(Response::from_string(json).with_header(header));
-                }
-                Err(_) => {
-                    let _ = request
-                        .respond(Response::from_string("Eval timeout").with_status_code(504));
+                    js = serde_json::to_string(&eval_req.js).unwrap(),
+                    id = serde_json::to_string(&request_id).unwrap(),
+                );
+
+                let _ = window.eval(&callback_js);
+
+                // Wait for the result with a 5-second timeout
+                let mut results = pending.results.lock().unwrap();
+                let deadline = std::time::Duration::from_secs(5);
+                let start = std::time::Instant::now();
+
+                loop {
+                    if let Some(value) = results.remove(&request_id) {
+                        let resp = EvalResponse { result: value };
+                        let json = serde_json::to_string(&resp).unwrap();
+                        let header =
+                            Header::from_bytes("Content-Type", "application/json").unwrap();
+                        let _ =
+                            request.respond(Response::from_string(json).with_header(header));
+                        break;
+                    }
+
+                    let elapsed = start.elapsed();
+                    if elapsed >= deadline {
+                        // Timeout — clean up and respond with 504
+                        results.remove(&request_id);
+                        let _ = request.respond(
+                            Response::from_string("Eval timeout").with_status_code(504),
+                        );
+                        break;
+                    }
+
+                    let remaining = deadline - elapsed;
+                    let (guard, timeout_result) =
+                        pending.notify.wait_timeout(results, remaining).unwrap();
+                    results = guard;
+
+                    if timeout_result.timed_out() && !results.contains_key(&request_id) {
+                        results.remove(&request_id);
+                        let _ = request.respond(
+                            Response::from_string("Eval timeout").with_status_code(504),
+                        );
+                        break;
+                    }
                 }
+            } else {
+                let resp = EvalResponse {
+                    result: serde_json::Value::Null,
+                };
+                let json = serde_json::to_string(&resp).unwrap();
+                let header = Header::from_bytes("Content-Type", "application/json").unwrap();
+                let _ = request.respond(Response::from_string(json).with_header(header));
             }
         }
     });

package/examples/tauri-bridge/src/main.rs

@@ -1,9 +1,16 @@
 mod dev_bridge;
 
 fn main() {
-    tauri::Builder::default()
+    let mut builder = tauri::Builder::default();
+
+    if cfg!(debug_assertions) {
+        builder = builder.invoke_handler(tauri::generate_handler![
+            dev_bridge::__dev_bridge_result
+        ]);
+    }
+
+    builder
         .setup(|app| {
-            // Only start bridge in development
             if cfg!(debug_assertions) {
                 if let Err(e) = dev_bridge::start_bridge(app.handle()) {
                     eprintln!("Warning: Failed to start dev bridge: {e}");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-agent-tools",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Agent-driven inspection toolkit for Tauri desktop apps",
   "type": "module",
   "bin": {

package/rust-bridge/README.md

@@ -13,21 +13,30 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 scopeguard = "1"
 rand = "0.8"
+uuid = { version = "1", features = ["v4"] }
 ```
 
 ### 2. Copy the bridge module
 
 Copy `examples/tauri-bridge/src/dev_bridge.rs` into your Tauri project's `src/` directory.
 
-### 3. Start the bridge in your app
+### 3. Wire up in main.rs
 
-In your `main.rs` or app setup:
+In your `main.rs`, register the bridge's Tauri command and start the bridge during setup:
 
 ```rust
 mod dev_bridge;
 
 fn main() {
-    tauri::Builder::default()
+    let mut builder = tauri::Builder::default();
+
+    if cfg!(debug_assertions) {
+        builder = builder.invoke_handler(tauri::generate_handler![
+            dev_bridge::__dev_bridge_result
+        ]);
+    }
+
+    builder
         .setup(|app| {
             if cfg!(debug_assertions) {
                 if let Err(e) = dev_bridge::start_bridge(app.handle()) {
@@ -41,6 +50,16 @@ fn main() {
 }
 ```
 
+> **Note:** If your app already uses `.invoke_handler()` with its own commands, merge them into one handler:
+> ```rust
+> builder = builder.invoke_handler(tauri::generate_handler![
+>     your_command_one,
+>     your_command_two,
+>     dev_bridge::__dev_bridge_result,
+> ]);
+> ```
+> Tauri only supports a single `invoke_handler` per builder — commands from multiple calls won't merge.
+
 ### 4. Use tauri-agent-tools
 
 The bridge writes a token file to `/tmp/tauri-dev-bridge-<pid>.token` which `tauri-agent-tools` auto-discovers:
@@ -61,8 +80,10 @@ tauri-agent-tools eval "document.title"
 1. Bridge starts an HTTP server on a random localhost port
 2. A token file with `{ port, token, pid }` is written to `/tmp/`
 3. `tauri-agent-tools` discovers the token file and authenticates via the token
-4. Requests are `POST /eval { js, token }` — the bridge evaluates JS in the webview
-5. The token file is cleaned up when the app exits
+4. Requests are `POST /eval { js, token }` — the bridge injects JS into the webview
+5. The injected JS evaluates the expression, then calls back into Rust via `window.__TAURI__.core.invoke("__dev_bridge_result", { id, value })` to deliver the result
+6. The HTTP handler thread waits for the result (up to 5 seconds) and returns it as JSON
+7. The token file is cleaned up when the app exits
 
 ## Security