tauri-agent-tools 0.3.0 → 0.5.0

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

@@ -1,12 +1,15 @@
 use rand::Rng;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 use std::fs;
-use std::io::Write;
+use std::io::{BufRead, BufReader, Write};
+use std::process::{Command, Stdio};
 use std::sync::{Arc, Condvar, Mutex};
 use std::thread;
 use tauri::{AppHandle, Manager};
 use tiny_http::{Header, Response, Server};
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
 
 #[derive(Deserialize)]
 struct EvalRequest {
@@ -14,11 +17,30 @@ struct EvalRequest {
     token: String,
 }
 
+#[derive(Deserialize)]
+struct LogRequest {
+    token: String,
+}
+
 #[derive(Serialize)]
 struct EvalResponse {
     result: serde_json::Value,
 }
 
+#[derive(Clone, Serialize)]
+pub struct LogEntry {
+    pub timestamp: u64,
+    pub level: String,
+    pub target: String,
+    pub message: String,
+    pub source: String,
+}
+
+#[derive(Serialize)]
+struct LogResponse {
+    entries: Vec<LogEntry>,
+}
+
 #[derive(Serialize)]
 struct TokenFile {
     port: u16,
@@ -26,6 +48,172 @@ struct TokenFile {
     pid: u32,
 }
 
+/// Ring buffer for log entries. Thread-safe, capped at 1000 entries.
+pub struct LogBuffer {
+    entries: Mutex<VecDeque<LogEntry>>,
+}
+
+impl LogBuffer {
+    pub fn new() -> Self {
+        Self {
+            entries: Mutex::new(VecDeque::new()),
+        }
+    }
+
+    pub fn push(&self, entry: LogEntry) {
+        let mut buf = self.entries.lock().unwrap();
+        if buf.len() >= 1000 {
+            buf.pop_front();
+        }
+        buf.push_back(entry);
+    }
+
+    pub fn drain(&self) -> Vec<LogEntry> {
+        let mut buf = self.entries.lock().unwrap();
+        buf.drain(..).collect()
+    }
+}
+
+/// A tracing layer that captures log events into a `LogBuffer`.
+struct BridgeLogLayer {
+    buffer: Arc<LogBuffer>,
+}
+
+impl<S> tracing_subscriber::Layer<S> for BridgeLogLayer
+where
+    S: tracing::Subscriber,
+{
+    fn on_event(
+        &self,
+        event: &tracing::Event<'_>,
+        _ctx: tracing_subscriber::layer::Context<'_, S>,
+    ) {
+        let mut visitor = MessageVisitor {
+            message: String::new(),
+        };
+        event.record(&mut visitor);
+
+        let entry = LogEntry {
+            timestamp: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_millis() as u64,
+            level: event.metadata().level().to_string().to_lowercase(),
+            target: event.metadata().target().to_string(),
+            message: visitor.message,
+            source: "rust".to_string(),
+        };
+
+        self.buffer.push(entry);
+    }
+}
+
+struct MessageVisitor {
+    message: String,
+}
+
+impl tracing::field::Visit for MessageVisitor {
+    fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
+        if field.name() == "message" {
+            self.message = format!("{:?}", value);
+            // Remove surrounding quotes if present
+            if self.message.starts_with('"') && self.message.ends_with('"') {
+                self.message = self.message[1..self.message.len() - 1].to_string();
+            }
+        }
+    }
+
+    fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
+        if field.name() == "message" {
+            self.message = value.to_string();
+        }
+    }
+}
+
+/// Create a tracing layer that captures logs into the given buffer.
+/// Use this if you already have a tracing subscriber and want to add log capture.
+///
+/// ```rust
+/// use tracing_subscriber::layer::SubscriberExt;
+/// use tracing_subscriber::util::SubscriberInitExt;
+///
+/// let buffer = std::sync::Arc::new(dev_bridge::LogBuffer::new());
+/// tracing_subscriber::registry()
+///     .with(dev_bridge::create_log_layer(buffer.clone()))
+///     .with(tracing_subscriber::fmt::layer())
+///     .init();
+/// ```
+pub fn create_log_layer(
+    buffer: Arc<LogBuffer>,
+) -> impl tracing_subscriber::Layer<tracing_subscriber::Registry> {
+    BridgeLogLayer { buffer }
+}
+
+/// Spawn a sidecar process with monitored stdout/stderr.
+/// Lines from stdout are logged as "info", lines from stderr as "warn".
+/// Returns the `std::process::Child` handle.
+pub fn spawn_sidecar_monitored(
+    name: &str,
+    command: &str,
+    args: &[&str],
+    log_buffer: &Arc<LogBuffer>,
+) -> Result<std::process::Child, String> {
+    let mut child = Command::new(command)
+        .args(args)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("Failed to spawn sidecar {name}: {e}"))?;
+
+    let source = format!("sidecar:{name}");
+
+    // Monitor stdout
+    if let Some(stdout) = child.stdout.take() {
+        let buffer = log_buffer.clone();
+        let source = source.clone();
+        thread::spawn(move || {
+            let reader = BufReader::new(stdout);
+            for line in reader.lines() {
+                let Ok(line) = line else { break };
+                buffer.push(LogEntry {
+                    timestamp: std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .unwrap_or_default()
+                        .as_millis() as u64,
+                    level: "info".to_string(),
+                    target: "stdout".to_string(),
+                    message: line,
+                    source: source.clone(),
+                });
+            }
+        });
+    }
+
+    // Monitor stderr
+    if let Some(stderr) = child.stderr.take() {
+        let buffer = log_buffer.clone();
+        let source = source.clone();
+        thread::spawn(move || {
+            let reader = BufReader::new(stderr);
+            for line in reader.lines() {
+                let Ok(line) = line else { break };
+                buffer.push(LogEntry {
+                    timestamp: std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .unwrap_or_default()
+                        .as_millis() as u64,
+                    level: "warn".to_string(),
+                    target: "stderr".to_string(),
+                    message: line,
+                    source: source.clone(),
+                });
+            }
+        });
+    }
+
+    Ok(child)
+}
+
 /// Shared state for pending eval results.
 /// The HTTP handler thread waits on the Condvar; the Tauri command inserts
 /// the result and signals.
@@ -47,8 +235,9 @@ pub fn __dev_bridge_result(
 }
 
 /// Start the development bridge HTTP server.
-/// Returns the port number on success.
-pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
+/// Returns the port number and log buffer on success.
+/// The log buffer can be used with `spawn_sidecar_monitored()` to capture sidecar output.
+pub fn start_bridge(app: &AppHandle) -> Result<(u16, Arc<LogBuffer>), String> {
     let server =
         Server::http("127.0.0.1:0").map_err(|e| format!("Failed to start bridge: {e}"))?;
     let port = server
@@ -80,6 +269,13 @@ pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
         let _ = fs::remove_file(&cleanup_path);
     });
 
+    // Create log buffer and install tracing layer
+    let log_buffer = Arc::new(LogBuffer::new());
+    let layer = BridgeLogLayer {
+        buffer: log_buffer.clone(),
+    };
+    let _ = tracing_subscriber::registry().with(layer).try_init();
+
     // Create shared pending-results state and register it with Tauri
     let pending = Arc::new(PendingResults {
         results: Mutex::new(HashMap::new()),
@@ -89,13 +285,17 @@ pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
 
     let app_handle = app.clone();
     let expected_token = token.clone();
+    let server_log_buffer = log_buffer.clone();
 
     thread::spawn(move || {
         // Keep _guard alive for the lifetime of the server thread
         let _cleanup = _guard;
 
         for request in server.incoming_requests() {
-            if request.method().as_str() != "POST" || request.url() != "/eval" {
+            let is_post = request.method().as_str() == "POST";
+            let url = request.url().to_string();
+
+            if !is_post || (url != "/eval" && url != "/logs") {
                 let _ = request.respond(Response::from_string("Not found").with_status_code(404));
                 continue;
             }
@@ -108,7 +308,32 @@ pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
                 continue;
             }
 
-            // Parse request
+            // Handle /logs endpoint
+            if url == "/logs" {
+                let log_req: LogRequest = match serde_json::from_str(&body) {
+                    Ok(r) => r,
+                    Err(_) => {
+                        let _ = request
+                            .respond(Response::from_string("Invalid JSON").with_status_code(400));
+                        continue;
+                    }
+                };
+
+                if log_req.token != expected_token {
+                    let _ = request
+                        .respond(Response::from_string("Unauthorized").with_status_code(401));
+                    continue;
+                }
+
+                let entries = server_log_buffer.drain();
+                let resp = LogResponse { entries };
+                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));
+                continue;
+            }
+
+            // Handle /eval endpoint
             let eval_req: EvalRequest = match serde_json::from_str(&body) {
                 Ok(r) => r,
                 Err(_) => {
@@ -214,5 +439,5 @@ pub fn start_bridge(app: &AppHandle) -> Result<u16, String> {
     eprintln!("Dev bridge started on port {port}");
     eprintln!("Token file: {token_path}");
 
-    Ok(port)
+    Ok((port, log_buffer))
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-agent-tools",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Agent-driven inspection toolkit for Tauri desktop apps",
   "type": "module",
   "bin": {
@@ -13,7 +13,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "dev": "tsc --watch",
-    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit && eslint src/",
     "lint:fix": "eslint src/ --fix",
     "prepublishOnly": "npm run build"
   },
@@ -43,7 +44,8 @@
     "access": "public"
   },
   "dependencies": {
-    "commander": "^14.0.0"
+    "commander": "^14.0.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",

package/rust-bridge/README.md

@@ -14,6 +14,8 @@ serde_json = "1"
 scopeguard = "1"
 rand = "0.8"
 uuid = { version = "1", features = ["v4"] }
+tracing = "0.1"
+tracing-subscriber = "0.3"
 ```
 
 ### 2. Copy the bridge module
@@ -39,7 +41,7 @@ fn main() {
     builder
         .setup(|app| {
             if cfg!(debug_assertions) {
-                if let Err(e) = dev_bridge::start_bridge(app.handle()) {
+                if let Err(e) = dev_bridge::start_bridge(app.handle()).map(|_| ()) {
                     eprintln!("Warning: Failed to start dev bridge: {e}");
                 }
             }
@@ -80,10 +82,12 @@ 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 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
+4. Requests are `POST /eval { js, token }` (JS evaluation) or `POST /logs { token }` (Rust log retrieval)
+5. For `/eval`, the bridge injects JS into the webview
+6. 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
+7. The HTTP handler thread waits for the result (up to 5 seconds) and returns it as JSON
+8. For `/logs`, the bridge drains its ring buffer of captured `tracing` events and returns them as JSON
+9. The token file is cleaned up when the app exits
 
 ## Security