add import&status&remove

Author: evanliu048

crates/q_chat/src/cli.rs

@@ -67,7 +67,7 @@ pub struct McpAdd {
     pub profile: Option<String>,
     /// Environment variables to use when launching the server
     #[arg(long, value_parser = parse_env_vars)]
-    pub env: Option<HashMap<String, String>>,
+    pub env: Vec<HashMap<String, String>>,
     /// Server launch timeout, in milliseconds
     #[arg(long)]
     pub timeout: Option<u64>,

crates/q_chat/src/mcp.rs

@@ -7,6 +7,7 @@ use eyre::{
     bail,
 };
 use fig_os_shim::Context;
+use futures::future::ok;
 use tracing::warn;
 
 use crate::cli::{
@@ -44,9 +45,18 @@ pub async fn execute_mcp(args: Mcp) -> Result<ExitCode> {
 pub async fn add_mcp_server(ctx: &Context, args: McpAdd) -> Result<()> {
     let config_path = resolve_scope_profile(ctx, args.scope, args.profile.as_ref())?;
     let mut config: McpServerConfig = serde_json::from_str(&ctx.fs().read_to_string(&config_path).await?)?;
+    let merged_env = if args.env.is_empty() {
+        None
+    } else {
+        let mut map = HashMap::new();
+        for m in args.env {
+            map.extend(m);
+        }
+        Some(map)
+    };
     let val: CustomToolConfig = serde_json::from_value(serde_json::json!({
         "command": args.command,
-        "env": args.env,
+        "env": merged_env,
         "timeout": args.timeout,
     }))?;
     config.mcp_servers.insert(args.name, val);
@@ -58,8 +68,17 @@ pub async fn add_mcp_server(ctx: &Context, args: McpAdd) -> Result<()> {
 pub async fn remove_mcp_server(ctx: &Context, args: McpRemove) -> Result<()> {
     let config_path = resolve_scope_profile(ctx, args.scope, args.profile.as_ref())?;
     let mut config = McpServerConfig::load_from_file(ctx, &config_path).await?;
+
+    let scope = args.scope.unwrap_or(Scope::Workspace);
     match config.mcp_servers.remove(&args.name) {
-        Some(_) => (),
+        Some(_) => {
+            config.save_to_file(ctx, &config_path).await?;
+            println!(
+                "✓ Removed MCP server '{}' from {}",
+                args.name,
+                scope_display(&scope, &args.profile)
+            );
+        },
         None => {
             warn!(?args, "No MCP server found");
         },
@@ -135,19 +154,74 @@ async fn get_mcp_server_configs(
 
 fn scope_display(scope: &Scope, profile: &Option<String>) -> String {
     match scope {
-        Scope::Workspace => "\n📄 workspace".into(),
-        Scope::Global => "\n🌍 global".into(),
-        Scope::Profile => format!("\n👤 profile({})", profile.as_deref().unwrap_or("default")),
+        Scope::Workspace => "📄 workspace".into(),
+        Scope::Global => "🌍 global".into(),
+        Scope::Profile => format!("👤 profile({})", profile.as_deref().unwrap_or("default")),
     }
 }
 
 pub async fn import_mcp_server(ctx: &Context, args: McpImport) -> Result<()> {
     let config_path = resolve_scope_profile(ctx, args.scope, args.profile.as_ref())?;
-    todo!()
+    let mut dst_cfg = if ctx.fs().exists(&config_path) {
+        McpServerConfig::load_from_file(ctx, &config_path).await?
+    } else {
+        McpServerConfig::default()
+    };
+    let expanded = shellexpand::tilde(&args.file);
+    let mut src_path = std::path::PathBuf::from(expanded.as_ref());
+    if src_path.is_relative() {
+        src_path = ctx.env().current_dir()?.join(src_path);
+    }
+
+    let src_content = ctx
+        .fs()
+        .read_to_string(&src_path)
+        .await
+        .map_err(|e| eyre::eyre!("Failed to read source file '{}': {e}", src_path.display()))?;
+    let src_cfg: McpServerConfig = serde_json::from_str(&src_content)
+        .map_err(|e| eyre::eyre!("Invalid MCP JSON in '{}': {e}", src_path.display()))?;
+
+    let before = dst_cfg.mcp_servers.len();
+    for (name, cfg) in src_cfg.mcp_servers {
+        if dst_cfg.mcp_servers.insert(name.clone(), cfg).is_some() {
+            warn!(server = %name, "Overwriting existing MCP server configuration");
+        }
+    }
+    let added = dst_cfg.mcp_servers.len() - before;
+
+    dst_cfg.save_to_file(ctx, &config_path).await?;
+
+    let scope = args.scope.unwrap_or(Scope::Workspace);
+    println!(
+        "✓ Imported {added} MCP server(s) into {:?} scope",
+        scope_display(&scope, &args.profile)
+    );
+    Ok(())
 }
 
 pub async fn get_mcp_server_status(ctx: &Context, name: String) -> Result<()> {
-    todo!()
+    let configs = get_mcp_server_configs(ctx, None, None).await?;
+    for (_, _, _, cfg_opt) in configs {
+        if let Some(cfg) = cfg_opt {
+            if let Some(tool_cfg) = cfg.mcp_servers.get(&name) {
+                println!("MCP Server: {name}");
+                println!("Command    : {}", tool_cfg.command);
+                println!("Timeout    : {} ms", tool_cfg.timeout);
+                println!(
+                    "Env Vars   : {}",
+                    tool_cfg
+                        .env
+                        .as_ref()
+                        .map(|e| e.keys().cloned().collect::<Vec<_>>().join(", "))
+                        .unwrap_or_else(|| "(none)".into())
+                );
+                // todo yifan how can I know the server status
+                println!("Status     : ");
+                return Ok(());
+            }
+        }
+    }
+    bail!("No MCP server named '{name}' found\n")
 }
 
 fn resolve_scope_profile(ctx: &Context, scope: Option<Scope>, profile: Option<&impl AsRef<str>>) -> Result<PathBuf> {