anveesa 0.4.1 → 0.4.3

package/Cargo.lock

@@ -60,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.4.1"
+version = "0.4.3"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.4.1"
+version = "0.4.3"
 edition = "2024"
 default-run = "anveesa"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {

package/src/config.rs

@@ -174,6 +174,23 @@ pub struct AppConfig {
 
     #[serde(default)]
     pub providers: BTreeMap<String, ProviderConfig>,
+
+    /// MCP servers to connect to on startup.
+    /// Example config:
+    ///   [mcp.filesystem]
+    ///   command = "npx"
+    ///   args = ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub mcp: BTreeMap<String, McpServerConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct McpServerConfig {
+    pub command: String,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: BTreeMap<String, String>,
 }
 
 impl AppConfig {
@@ -351,6 +368,7 @@ impl AppConfig {
         Self {
             default_provider: Some("sumopod".to_string()),
             providers,
+            mcp: BTreeMap::new(),
         }
     }
 
@@ -375,6 +393,7 @@ impl AppConfig {
             self.default_provider = user_config.default_provider;
         }
         self.providers.extend(user_config.providers);
+        self.mcp.extend(user_config.mcp);
     }
 
     pub fn provider_name<'a>(&'a self, requested: Option<&'a str>) -> Result<&'a str> {
@@ -620,6 +639,7 @@ fn load_user_config_for_write(path: &Path) -> Result<AppConfig> {
         return Ok(AppConfig {
             default_provider: Some("sumopod".to_string()),
             providers: BTreeMap::new(),
+            mcp: BTreeMap::new(),
         });
     }
 

package/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod cli;
 pub mod config;
+pub mod mcp;
 pub mod provider;
 pub mod tools;
 pub mod tui;
@@ -154,6 +155,14 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
 
     // ── TUI mode ──────────────────────────────────────────────────────────────
     if is_tty {
+        // Connect to any configured MCP servers.
+        let mcp_manager = if !config.mcp.is_empty() {
+            let m = mcp::McpManager::connect(&config.mcp).await;
+            Some(std::sync::Arc::new(m))
+        } else {
+            None
+        };
+
         // Spawn a background task to read keyboard events (crossterm::event::read is blocking).
         let (key_tx, key_rx) = tokio::sync::mpsc::unbounded_channel();
         tokio::task::spawn_blocking(move || {
@@ -183,6 +192,7 @@ async fn run_interactive(options: AskOptions) -> Result<()> {
             workspace_context,
             policy,
             key_rx,
+            mcp_manager,
         );
 
         tui::run(app).await?;
@@ -624,6 +634,7 @@ async fn ask_streaming(
         workspace_context: workspace_context.map(str::to_string),
         history: history.to_vec(),
         image,
+        mcp: None, // REPL path: MCP not yet wired here
     };
 
     let result = provider::ask(config, &provider_name, request, policy, &tx).await;
@@ -1764,16 +1775,20 @@ fn read_prompt_line(
                 buffer.clear_all();
                 display_rows = redraw!();
             }
-            22 if images_available => {
-                // Ctrl+V — paste image from clipboard
-                match grab_clipboard_image() {
-                    Some(img) => {
+            22 => {
+                // Ctrl+V — universal paste: image first, then clipboard text
+                if images_available {
+                    if let Some(img) = grab_clipboard_image() {
                         ctrl_v_image = Some(img);
                         display_rows = redraw!();
+                        continue;
                     }
-                    None => {
-                        print!("\x07");
-                        let _ = io::stdout().flush();
+                }
+                // Fall back to clipboard text via pbpaste / xclip
+                if let Some(text) = read_clipboard_text() {
+                    if !text.is_empty() {
+                        buffer.push_text(&text.replace('\r', "\n"));
+                        display_rows = redraw!();
                     }
                 }
             }
@@ -2313,6 +2328,31 @@ fn repl_history_path() -> Option<PathBuf> {
     Some(dir.join("history"))
 }
 
+pub fn read_clipboard_text() -> Option<String> {
+    #[cfg(target_os = "macos")]
+    {
+        let out = std::process::Command::new("pbpaste").output().ok()?;
+        if out.status.success() {
+            let text = String::from_utf8_lossy(&out.stdout).into_owned();
+            if !text.is_empty() { return Some(text); }
+        }
+    }
+    #[cfg(not(target_os = "macos"))]
+    for (cmd, args) in &[
+        ("wl-paste", vec!["--no-newline"]),
+        ("xclip",   vec!["-o", "-selection", "clipboard"]),
+        ("xsel",    vec!["--clipboard", "--output"]),
+    ] {
+        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
+            if out.status.success() {
+                let text = String::from_utf8_lossy(&out.stdout).into_owned();
+                if !text.is_empty() { return Some(text); }
+            }
+        }
+    }
+    None
+}
+
 pub fn unix_now() -> u64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)

package/src/mcp.rs

@@ -0,0 +1,237 @@
+//! MCP (Model Context Protocol) client — connects to external tool servers
+//! over JSON-RPC / stdio, discovers their tools, and routes calls to them.
+
+use std::collections::BTreeMap;
+
+use anyhow::{Context, Result, bail};
+use serde_json::{Value, json};
+use tokio::{
+    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
+    process::Child,
+    sync::Mutex,
+};
+
+use crate::config::McpServerConfig;
+
+// ── Tool definition exposed to the rest of anveesa ───────────────────────────
+
+#[derive(Debug, Clone)]
+pub struct McpTool {
+    /// Namespaced as mcp__{server}__{original_name}
+    pub name: String,
+    pub description: String,
+    pub input_schema: Value,
+    pub server: String,
+    pub original_name: String,
+}
+
+impl McpTool {
+    /// Convert to an OpenAI-compatible function definition.
+    pub fn to_definition(&self) -> Value {
+        json!({
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": format!("[MCP:{}] {}", self.server, self.description),
+                "parameters": self.input_schema,
+            }
+        })
+    }
+}
+
+// ── Single MCP server connection ──────────────────────────────────────────────
+
+struct McpServer {
+    name: String,
+    stdin: Mutex<tokio::process::ChildStdin>,
+    stdout: Mutex<BufReader<tokio::process::ChildStdout>>,
+    next_id: Mutex<u64>,
+    _child: Child,
+}
+
+impl McpServer {
+    async fn connect(name: &str, cfg: &McpServerConfig) -> Result<(Self, Vec<McpTool>)> {
+        let mut child = tokio::process::Command::new(&cfg.command)
+            .args(&cfg.args)
+            .envs(&cfg.env)
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::null())
+            .kill_on_drop(true)
+            .spawn()
+            .with_context(|| format!("failed to start MCP server '{name}' ({})", cfg.command))?;
+
+        let stdin = child.stdin.take().context("MCP server has no stdin")?;
+        let stdout = BufReader::new(child.stdout.take().context("MCP server has no stdout")?);
+
+        let server = Self {
+            name: name.to_string(),
+            stdin: Mutex::new(stdin),
+            stdout: Mutex::new(stdout),
+            next_id: Mutex::new(1),
+            _child: child,
+        };
+
+        server.initialize().await?;
+        let tools = server.list_tools().await?;
+        Ok((server, tools))
+    }
+
+    async fn send_msg(&self, msg: Value) -> Result<()> {
+        let line = serde_json::to_string(&msg)? + "\n";
+        let mut stdin = self.stdin.lock().await;
+        stdin.write_all(line.as_bytes()).await?;
+        stdin.flush().await?;
+        Ok(())
+    }
+
+    async fn recv_msg(&self) -> Result<Value> {
+        let mut stdout = self.stdout.lock().await;
+        let mut line = String::new();
+        stdout.read_line(&mut line).await.context("MCP server closed")?;
+        if line.is_empty() { bail!("MCP server closed connection"); }
+        Ok(serde_json::from_str(line.trim())?)
+    }
+
+    async fn request(&self, method: &str, params: Value) -> Result<Value> {
+        let id = {
+            let mut n = self.next_id.lock().await;
+            let v = *n;
+            *n += 1;
+            v
+        };
+        self.send_msg(json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params })).await?;
+
+        // Drain notifications until we get our response id
+        loop {
+            let resp = self.recv_msg().await?;
+            if resp.get("id").and_then(|v| v.as_u64()) == Some(id) {
+                if let Some(err) = resp.get("error") {
+                    bail!("MCP error from '{}': {}", self.name, err);
+                }
+                return Ok(resp["result"].clone());
+            }
+            // Drop unmatched messages (notifications, other ids)
+        }
+    }
+
+    async fn notify(&self, method: &str, params: Value) -> Result<()> {
+        self.send_msg(json!({ "jsonrpc": "2.0", "method": method, "params": params })).await
+    }
+
+    async fn initialize(&self) -> Result<()> {
+        self.request("initialize", json!({
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": { "name": "anveesa", "version": env!("CARGO_PKG_VERSION") }
+        })).await?;
+        self.notify("notifications/initialized", json!({})).await?;
+        Ok(())
+    }
+
+    async fn list_tools(&self) -> Result<Vec<McpTool>> {
+        let result = self.request("tools/list", json!({})).await?;
+        let raw = result["tools"].as_array().cloned().unwrap_or_default();
+        Ok(raw.into_iter().filter_map(|t| {
+            let original_name = t["name"].as_str()?.to_string();
+            let description = t["description"].as_str().unwrap_or("").to_string();
+            let input_schema = t.get("inputSchema").cloned().unwrap_or(json!({"type":"object","properties":{}}));
+            let safe_server = self.name.replace('-', "_").replace('.', "_");
+            Some(McpTool {
+                name: format!("mcp__{safe_server}__{original_name}"),
+                description,
+                input_schema,
+                server: self.name.clone(),
+                original_name,
+            })
+        }).collect())
+    }
+
+    async fn call_tool(&self, original_name: &str, arguments: Value) -> Result<String> {
+        let result = self.request("tools/call", json!({
+            "name": original_name,
+            "arguments": arguments,
+        })).await?;
+
+        // MCP returns content as an array of typed blocks
+        let content = result["content"].as_array().cloned().unwrap_or_default();
+        let text = content.iter()
+            .filter_map(|c| {
+                match c["type"].as_str() {
+                    Some("text") => c["text"].as_str().map(str::to_string),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let is_error = result["isError"].as_bool().unwrap_or(false);
+        Ok(json!({ "ok": !is_error, "result": text }).to_string())
+    }
+}
+
+// ── McpManager — holds all connected servers ──────────────────────────────────
+
+pub struct McpManager {
+    servers: Vec<(McpServer, Vec<McpTool>)>,
+}
+
+impl std::fmt::Debug for McpManager {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let names: Vec<&str> = self.servers.iter().map(|(s, _)| s.name.as_str()).collect();
+        write!(f, "McpManager {{ servers: {:?} }}", names)
+    }
+}
+
+impl McpManager {
+    /// Connect to all configured MCP servers. Errors for individual servers are
+    /// logged and skipped so one broken server doesn't block startup.
+    pub async fn connect(configs: &BTreeMap<String, McpServerConfig>) -> Self {
+        let mut servers = Vec::new();
+        for (name, cfg) in configs {
+            match McpServer::connect(name, cfg).await {
+                Ok(pair) => {
+                    eprintln!("\x1b[2m  MCP: connected to '{name}' ({} tools)\x1b[0m",
+                        pair.1.len());
+                    servers.push(pair);
+                }
+                Err(e) => {
+                    eprintln!("\x1b[33m  MCP: failed to connect to '{name}': {e:#}\x1b[0m");
+                }
+            }
+        }
+        Self { servers }
+    }
+
+    /// All tool definitions from all connected servers.
+    pub fn tool_definitions(&self) -> Vec<Value> {
+        self.servers.iter()
+            .flat_map(|(_, tools)| tools.iter().map(|t| t.to_definition()))
+            .collect()
+    }
+
+    /// All tool names from all connected servers.
+    pub fn tool_names(&self) -> Vec<String> {
+        self.servers.iter()
+            .flat_map(|(_, tools)| tools.iter().map(|t| t.name.clone()))
+            .collect()
+    }
+
+    /// Dispatch a call to the appropriate MCP server.
+    pub async fn call(&self, tool_name: &str, arguments: &str) -> Option<String> {
+        let args: Value = serde_json::from_str(arguments).unwrap_or(json!({}));
+        for (server, tools) in &self.servers {
+            if let Some(tool) = tools.iter().find(|t| t.name == tool_name) {
+                return Some(match server.call_tool(&tool.original_name, args).await {
+                    Ok(r) => r,
+                    Err(e) => json!({ "ok": false, "error": e.to_string() }).to_string(),
+                });
+            }
+        }
+        None
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.servers.is_empty()
+    }
+}

package/src/provider/command.rs

@@ -222,6 +222,7 @@ mod tests {
             workspace_context: None,
             history: vec![],
             image: None,
+            mcp: None,
         }
     }
 

package/src/provider/mod.rs

@@ -1,5 +1,5 @@
 mod command;
-mod openai_compatible;
+pub mod openai_compatible;
 
 use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
@@ -51,6 +51,8 @@ pub struct PromptRequest {
     pub history: Vec<ChatMessage>,
     /// Optional image grabbed from the clipboard for the current turn only.
     pub image: Option<ImageAttachment>,
+    /// Connected MCP servers (runtime only, not part of session history).
+    pub mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
 }
 
 /// How tool calls that modify the system (write/edit/run) should be handled.

package/src/provider/openai_compatible.rs

@@ -86,7 +86,11 @@ pub async fn ask(
             body["max_tokens"] = json!(max_tokens);
         }
         if tools_enabled {
-            body["tools"] = json!(tools::definitions(policy.allows_write_tools()));
+            let mut defs = tools::definitions(policy.allows_write_tools());
+            if let Some(m) = &request.mcp {
+                defs.extend(m.tool_definitions());
+            }
+            body["tools"] = json!(defs);
             body["tool_choice"] = json!("auto");
         }
 
@@ -168,7 +172,7 @@ pub async fn ask(
 
         messages.push(assistant_tool_message(&state));
         for call in &state.tool_calls {
-            let content = dispatch_tool(call, policy, &mut approval_state, events).await;
+            let content = dispatch_tool(call, policy, &mut approval_state, events, request.mcp.as_deref()).await;
             messages.push(json!({
                 "role": "tool",
                 "tool_call_id": call.id,
@@ -209,7 +213,28 @@ async fn dispatch_tool(
     policy: ApprovalPolicy,
     approval_state: &mut ToolApprovalState,
     events: &UnboundedSender<StreamEvent>,
+    mcp: Option<&crate::mcp::McpManager>,
 ) -> String {
+    // Route MCP tools directly — no approval policy, no filesystem restrictions.
+    if tools::is_mcp_tool(&call.name) {
+        let summary = format!("mcp {}", &call.name[5..]); // strip "mcp__"
+        let _ = events.send(StreamEvent::ToolCall { summary: summary.clone() });
+        let result = if let Some(m) = mcp {
+            m.call(&call.name, &call.arguments).await
+                .unwrap_or_else(|| serde_json::json!({ "ok": false, "error": "server not found" }).to_string())
+        } else {
+            serde_json::json!({ "ok": false, "error": "MCP not configured" }).to_string()
+        };
+        let (ok, err) = parse_tool_result_status(&result);
+        let _ = events.send(StreamEvent::ToolResult {
+            summary,
+            ok,
+            elapsed_ms: 0,
+            error: err,
+        });
+        return result;
+    }
+
     let summary = tools::describe_call(&call.name, &call.arguments);
 
     // Plan tools — display only, no approval or filesystem access needed.
@@ -316,6 +341,10 @@ async fn dispatch_tool(
     result
 }
 
+pub fn parse_tool_result_status_pub(result: &str) -> (bool, Option<String>) {
+    parse_tool_result_status(result)
+}
+
 fn parse_tool_result_status(result: &str) -> (bool, Option<String>) {
     let Ok(json) = serde_json::from_str::<Value>(result) else {
         return (true, None);