feat(tui): add usage overlay and sidebar for displaying usage statistics and tasks

feat(tui): implement status bar with connection and turn state indicators feat(tui): create workflow panel for agent status and progress visualization feat(web): introduce web frontend interface with static file serving feat(ws): add WebSocket interface for real-time communication and session management
2026-07-20 09:04:57 +07:00
parent bceba665c0
commit da2ed6da25
454 changed files with 13979 additions and 29539 deletions
@@ -0,0 +1,121 @@
+//! Bash-shell execution tool with safety filters and optional timeout.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+use std::process::Command;
+use std::time::Duration;
+
+pub struct Bash;
+
+impl Tool for Bash {
+    fn name(&self) -> &'static str {
+        "bash"
+    }
+
+    fn description(&self) -> &'static str {
+        "Execute a shell command via bash -c"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "Shell command to execute"
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Human-readable description of what the command does"
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in milliseconds (default 120000, max 600000)"
+                },
+                "run_in_background": {
+                    "type": "boolean",
+                    "description": "Run the command in the background"
+                }
+            },
+            "required": ["command"]
+        })
+    }
+
+    fn run(&self, _ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let cmd = crate::tools::arg_str(args, "command")?;
+        let timeout_ms = args
+            .get("timeout")
+            .and_then(serde_json::Value::as_u64)
+            .unwrap_or(120_000)
+            .min(600_000);
+
+        // Safety filter: block destructive git operations
+        crate::tools::shell_filter::git::check_git_destructive(&cmd)
+            .map_err(|e| anyhow::anyhow!("blocked: {e}"))?;
+
+        let run_in_background = args
+            .get("run_in_background")
+            .and_then(serde_json::Value::as_bool)
+            .unwrap_or(false);
+
+        if run_in_background {
+            let job = crate::bgbash::job::spawn_bash_job(cmd);
+            return Ok(format!("Background job: {}", job.id));
+        }
+
+        let mut child = Command::new("bash")
+            .arg("-c")
+            .arg(&cmd)
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .spawn()
+            .map_err(|e| anyhow::anyhow!("failed to spawn bash: {e}"))?;
+
+        let start = std::time::Instant::now();
+        let timeout = Duration::from_millis(timeout_ms);
+
+        loop {
+            match child.try_wait() {
+                Ok(Some(status)) => {
+                    let elapsed = start.elapsed().as_secs_f64();
+                    let output = child
+                        .wait_with_output()
+                        .map_err(|e| anyhow::anyhow!("failed to collect output: {e}"))?;
+                    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                    let combined = if stderr.is_empty() {
+                        stdout
+                    } else {
+                        format!("{stdout}\n{stderr}")
+                    };
+                    let trimmed = combined.trim().to_string();
+                    if status.success() {
+                        return Ok(if trimmed.is_empty() {
+                            format!("Command completed in {elapsed:.2}s (exit code 0)")
+                        } else {
+                            format!("{trimmed}\n\nExit code: 0 ({elapsed:.2}s)")
+                        });
+                    }
+                    return Ok(format!(
+                        "{}\n\nExit code: {} ({:.2}s)",
+                        trimmed,
+                        status.code().unwrap_or(-1),
+                        elapsed
+                    ));
+                }
+                Ok(None) => {
+                    if start.elapsed() > timeout {
+                        let _ = child.kill();
+                        let _ = child.wait();
+                        anyhow::bail!("command timed out after {timeout_ms}ms");
+                    }
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+                Err(e) => {
+                    anyhow::bail!("failed to wait for command: {e}");
+                }
+            }
+        }
+    }
+}