fix: Remove profile scope from mcp commands (#1846)

Author: chaynabors

crates/chat-cli/src/cli/chat/cli.rs

@@ -60,14 +60,9 @@ pub struct McpAdd {
     /// The command used to launch the server
     #[arg(long)]
     pub command: String,
-    /// Where to add the server to. For profile scope, the name of the profile must specified with
-    /// --profile.
+    /// Where to add the server to.
     #[arg(long, value_enum)]
     pub scope: Option<Scope>,
-    /// Name of the profile to add the server config to. Not compatible with workspace scope or
-    /// global scope.
-    #[arg(long)]
-    pub profile: Option<String>,
     /// Environment variables to use when launching the server
     #[arg(long, value_parser = parse_env_vars)]
     pub env: Vec<HashMap<String, String>>,
@@ -85,15 +80,13 @@ pub struct McpRemove {
     pub name: String,
     #[arg(long, value_enum)]
     pub scope: Option<Scope>,
-    #[arg(long)]
-    pub profile: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Args)]
 pub struct McpList {
     #[arg(value_enum)]
     pub scope: Option<Scope>,
-    #[arg(long)]
+    #[arg(long, hide = true)]
     pub profile: Option<String>,
 }
 
@@ -103,8 +96,6 @@ pub struct McpImport {
     pub file: String,
     #[arg(value_enum)]
     pub scope: Option<Scope>,
-    #[arg(long)]
-    pub profile: Option<String>,
     /// Overwrite an existing server with the same name
     #[arg(long, default_value_t = false)]
     pub force: bool,
@@ -113,15 +104,13 @@ pub struct McpImport {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
 pub enum Scope {
     Workspace,
-    Profile,
     Global,
 }
 
 impl std::fmt::Display for Scope {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Scope::Workspace => write!(f, "workspace"),
-            Scope::Profile => write!(f, "profile"),
             Scope::Global => write!(f, "global"),
         }
     }

crates/chat-cli/src/cli/chat/mcp.rs

@@ -11,7 +11,6 @@ use eyre::{
     Result,
     bail,
 };
-use tokio::fs;
 use tracing::warn;
 
 use crate::cli::chat::cli::{
@@ -25,7 +24,6 @@ use crate::cli::chat::cli::{
 use crate::cli::chat::tool_manager::{
     McpServerConfig,
     global_mcp_config_path,
-    profile_mcp_config_path,
     workspace_mcp_config_path,
 };
 use crate::cli::chat::tools::custom_tool::{
@@ -34,7 +32,6 @@ use crate::cli::chat::tools::custom_tool::{
 };
 use crate::cli::chat::util::shared_writer::SharedWriter;
 use crate::platform::Context;
-use crate::util::directories::chat_profiles_dir;
 
 pub async fn execute_mcp(args: Mcp) -> Result<ExitCode> {
     let ctx = Context::new();
@@ -54,9 +51,9 @@ pub async fn execute_mcp(args: Mcp) -> Result<ExitCode> {
 
 pub async fn add_mcp_server(ctx: &Context, output: &mut SharedWriter, args: McpAdd) -> Result<()> {
     let scope = args.scope.unwrap_or(Scope::Workspace);
-    let config_path = resolve_scope_profile(ctx, args.scope, args.profile.as_ref())?;
+    let config_path = resolve_scope_profile(ctx, args.scope)?;
 
-    let mut config: McpServerConfig = ensure_config_file(ctx, &config_path, scope, output).await?;
+    let mut config: McpServerConfig = ensure_config_file(ctx, &config_path, output).await?;
 
     if config.mcp_servers.contains_key(&args.name) && !args.force {
         bail!(
@@ -85,14 +82,14 @@ pub async fn add_mcp_server(ctx: &Context, output: &mut SharedWriter, args: McpA
         output,
         "✓ Added MCP server '{}' to {}\n",
         args.name,
-        scope_display(&scope, &args.profile)
+        scope_display(&scope)
     )?;
     Ok(())
 }
 
 pub async fn remove_mcp_server(ctx: &Context, output: &mut SharedWriter, args: McpRemove) -> Result<()> {
     let scope = args.scope.unwrap_or(Scope::Workspace);
-    let config_path = resolve_scope_profile(ctx, args.scope, args.profile.as_ref())?;
+    let config_path = resolve_scope_profile(ctx, args.scope)?;
 
     if !ctx.fs().exists(&config_path) {
         writeln!(output, "\nNo MCP server configurations found.\n")?;
@@ -107,31 +104,31 @@ pub async fn remove_mcp_server(ctx: &Context, output: &mut SharedWriter, args: M
                 output,
                 "\n✓ Removed MCP server '{}' from {}\n",
                 args.name,
-                scope_display(&scope, &args.profile)
+                scope_display(&scope)
             )?;
         },
         None => {
             writeln!(
                 output,
                 "\nNo MCP server named '{}' found in {}\n",
                 args.name,
-                scope_display(&scope, &args.profile)
+                scope_display(&scope)
             )?;
         },
     }
     Ok(())
 }
 
 pub async fn list_mcp_server(ctx: &Context, output: &mut SharedWriter, args: McpList) -> Result<()> {
-    let configs = get_mcp_server_configs(ctx, args.scope, args.profile).await?;
+    let configs = get_mcp_server_configs(ctx, args.scope).await?;
     if configs.is_empty() {
         writeln!(output, "No MCP server configurations found.\n")?;
         return Ok(());
     }
 
-    for (scope, profile, path, cfg_opt) in configs {
+    for (scope, path, cfg_opt) in configs {
         writeln!(output)?;
-        writeln!(output, "{}:\n  {}", scope_display(&scope, &profile), path.display())?;
+        writeln!(output, "{}:\n  {}", scope_display(&scope), path.display())?;
         match cfg_opt {
             Some(cfg) if !cfg.mcp_servers.is_empty() => {
                 for (name, tool_cfg) in &cfg.mcp_servers {
@@ -149,8 +146,8 @@ pub async fn list_mcp_server(ctx: &Context, output: &mut SharedWriter, args: Mcp
 
 pub async fn import_mcp_server(ctx: &Context, output: &mut SharedWriter, args: McpImport) -> Result<()> {
     let scope: Scope = args.scope.unwrap_or(Scope::Workspace);
-    let config_path = resolve_scope_profile(ctx, args.scope, args.profile.as_ref())?;
-    let mut dst_cfg = ensure_config_file(ctx, &config_path, scope, output).await?;
+    let config_path = resolve_scope_profile(ctx, args.scope)?;
+    let mut dst_cfg = ensure_config_file(ctx, &config_path, output).await?;
 
     let src_path = expand_path(ctx, &args.file)?;
     let src_cfg: McpServerConfig = McpServerConfig::load_from_file(ctx, &src_path).await?;
@@ -178,22 +175,22 @@ pub async fn import_mcp_server(ctx: &Context, output: &mut SharedWriter, args: M
     writeln!(
         output,
         "✓ Imported {added} MCP server(s) into {}\n",
-        scope_display(&scope, &args.profile)
+        scope_display(&scope)
     )?;
     Ok(())
 }
 
 pub async fn get_mcp_server_status(ctx: &Context, output: &mut SharedWriter, name: String) -> Result<()> {
-    let configs = get_mcp_server_configs(ctx, None, None).await?;
+    let configs = get_mcp_server_configs(ctx, None).await?;
     let mut found = false;
 
-    for (sc, prof, path, cfg_opt) in configs {
+    for (sc, path, cfg_opt) in configs {
         if let Some(cfg) = cfg_opt.and_then(|c| c.mcp_servers.get(&name).cloned()) {
             found = true;
             execute!(
                 output,
                 style::Print("\n─────────────\n"),
-                style::Print(format!("Scope   : {}\n", scope_display(&sc, &prof))),
+                style::Print(format!("Scope   : {}\n", scope_display(&sc))),
                 style::Print(format!("File    : {}\n", path.display())),
                 style::Print(format!("Command : {}\n", cfg.command)),
                 style::Print(format!("Timeout : {} ms\n", cfg.timeout)),
@@ -217,43 +214,16 @@ pub async fn get_mcp_server_status(ctx: &Context, output: &mut SharedWriter, nam
 async fn get_mcp_server_configs(
     ctx: &Context,
     scope: Option<Scope>,
-    profile: Option<String>,
-) -> Result<Vec<(Scope, Option<String>, PathBuf, Option<McpServerConfig>)>> {
-    let all_profiles = if matches!((scope, &profile), (None, None)) {
-        let mut v = Vec::new();
-        if let Ok(dir) = chat_profiles_dir(ctx) {
-            let mut rd = fs::read_dir(dir).await?;
-            while let Some(e) = rd.next_entry().await? {
-                if e.file_type().await?.is_dir() {
-                    if let Some(n) = e.file_name().to_str() {
-                        v.push(n.to_owned());
-                    }
-                }
-            }
-        }
-        v
-    } else {
-        Vec::new()
-    };
-
+) -> Result<Vec<(Scope, PathBuf, Option<McpServerConfig>)>> {
     let mut targets = Vec::new();
-    match (scope, profile) {
-        (Some(Scope::Workspace), _) => targets.push((Scope::Workspace, None)),
-        (Some(Scope::Global), _) => targets.push((Scope::Global, None)),
-        (Some(Scope::Profile), Some(p)) => targets.push((Scope::Profile, Some(p))),
-        (None, Some(p)) => targets.push((Scope::Profile, Some(p))),
-        (None, None) => {
-            targets.extend([(Scope::Workspace, None), (Scope::Global, None)]);
-            for p in all_profiles {
-                targets.push((Scope::Profile, Some(p)));
-            }
-        },
-        (Some(Scope::Profile), None) => bail!("profile must be specified for scope: profile"),
+    match scope {
+        Some(scope) => targets.push(scope),
+        None => targets.extend([Scope::Workspace, Scope::Global]),
     }
 
     let mut results = Vec::new();
-    for (sc, prof) in targets {
-        let path = resolve_scope_profile(ctx, Some(sc), prof.as_ref())?;
+    for sc in targets {
+        let path = resolve_scope_profile(ctx, Some(sc))?;
         let cfg_opt = if ctx.fs().exists(&path) {
             match McpServerConfig::load_from_file(ctx, &path).await {
                 Ok(cfg) => Some(cfg),
@@ -265,25 +235,22 @@ async fn get_mcp_server_configs(
         } else {
             None
         };
-        results.push((sc, prof.clone(), path, cfg_opt));
+        results.push((sc, path, cfg_opt));
     }
     Ok(results)
 }
 
-fn scope_display(scope: &Scope, profile: &Option<String>) -> String {
+fn scope_display(scope: &Scope) -> String {
     match scope {
         Scope::Workspace => "📄 workspace".into(),
         Scope::Global => "🌍 global".into(),
-        Scope::Profile => format!("👤 profile({})", profile.as_deref().unwrap_or("default")),
     }
 }
 
-fn resolve_scope_profile(ctx: &Context, scope: Option<Scope>, profile: Option<&impl AsRef<str>>) -> Result<PathBuf> {
-    Ok(match (scope, profile) {
-        (None | Some(Scope::Workspace), _) => workspace_mcp_config_path(ctx)?,
-        (Some(Scope::Global), _) => global_mcp_config_path(ctx)?,
-        (Some(scope @ Scope::Profile), None) => bail!("profile must be specified for scope: {scope}"),
-        (_, Some(profile)) => profile_mcp_config_path(ctx, profile)?,
+fn resolve_scope_profile(ctx: &Context, scope: Option<Scope>) -> Result<PathBuf> {
+    Ok(match scope {
+        Some(Scope::Global) => global_mcp_config_path(ctx)?,
+        _ => workspace_mcp_config_path(ctx)?,
     })
 }
 
@@ -296,19 +263,15 @@ fn expand_path(ctx: &Context, p: &str) -> Result<PathBuf> {
     Ok(path)
 }
 
-async fn ensure_config_file(
-    ctx: &Context,
-    path: &PathBuf,
-    scope: Scope,
-    out: &mut SharedWriter,
-) -> Result<McpServerConfig> {
-    if !ctx.fs().exists(path) && scope != Scope::Profile {
+async fn ensure_config_file(ctx: &Context, path: &PathBuf, out: &mut SharedWriter) -> Result<McpServerConfig> {
+    if !ctx.fs().exists(path) {
         if let Some(parent) = path.parent() {
             ctx.fs().create_dir_all(parent).await?;
         }
         McpServerConfig::default().save_to_file(ctx, path).await?;
         writeln!(out, "\n📁 Created MCP config in '{}'", path.display())?;
     }
+
     load_cfg(ctx, path).await
 }
 
@@ -327,34 +290,24 @@ mod tests {
     #[test]
     fn test_scope_and_profile_defaults_to_workspace() {
         let ctx = Context::new();
-        let path = resolve_scope_profile(&ctx, None, None::<&String>).unwrap();
+        let path = resolve_scope_profile(&ctx, None).unwrap();
         assert_eq!(
             path.to_str(),
             workspace_mcp_config_path(&ctx).unwrap().to_str(),
             "No scope or profile should default to the workspace path"
         );
     }
 
-    #[test]
-    fn test_resolve_profile_without_name_err() {
-        let ctx = Context::new();
-        assert!(resolve_scope_profile(&ctx, Some(Scope::Profile), None::<&String>).is_err());
-    }
-
     #[test]
     fn test_resolve_paths() {
         let ctx = Context::new();
         // workspace
-        let p = resolve_scope_profile(&ctx, Some(Scope::Workspace), None::<&String>).unwrap();
+        let p = resolve_scope_profile(&ctx, Some(Scope::Workspace)).unwrap();
         assert_eq!(p, workspace_mcp_config_path(&ctx).unwrap());
 
         // global
-        let p = resolve_scope_profile(&ctx, Some(Scope::Global), None::<&String>).unwrap();
+        let p = resolve_scope_profile(&ctx, Some(Scope::Global)).unwrap();
         assert_eq!(p, global_mcp_config_path(&ctx).unwrap());
-
-        // profile
-        let p = resolve_scope_profile(&ctx, Some(Scope::Profile), Some(&"qa")).unwrap();
-        assert_eq!(p, profile_mcp_config_path(&ctx, "qa").unwrap(), "profile path mismatch");
     }
 
     #[ignore = "TODO: fix in CI"]
@@ -364,9 +317,7 @@ mod tests {
         let mut out = SharedWriter::null();
         let path = workspace_mcp_config_path(&ctx).unwrap();
 
-        let cfg = super::ensure_config_file(&ctx, &path, Scope::Workspace, &mut out)
-            .await
-            .unwrap();
+        let cfg = super::ensure_config_file(&ctx, &path, &mut out).await.unwrap();
         assert!(path.exists(), "config file should be created");
         assert!(cfg.mcp_servers.is_empty());
     }
@@ -388,7 +339,6 @@ mod tests {
             env: vec![],
             timeout: None,
             scope: None,
-            profile: None,
             force: false,
         };
         add_mcp_server(&ctx, &mut out, add_args).await.unwrap();
@@ -401,7 +351,6 @@ mod tests {
         let rm_args = McpRemove {
             name: "local".into(),
             scope: None,
-            profile: None,
         };
         remove_mcp_server(&ctx, &mut out, rm_args).await.unwrap();
 

crates/chat-cli/src/cli/chat/tool_manager.rs

@@ -87,10 +87,7 @@ use crate::mcp_client::{
 };
 use crate::platform::Context;
 use crate::telemetry::TelemetryThread;
-use crate::util::directories::{
-    chat_profiles_dir,
-    home_dir,
-};
+use crate::util::directories::home_dir;
 
 const NAMESPACE_DELIMITER: &str = "___";
 // This applies for both mcp server and tool name since in the end the tool name as seen by the
@@ -102,10 +99,6 @@ pub fn workspace_mcp_config_path(ctx: &Context) -> eyre::Result<PathBuf> {
     Ok(ctx.env().current_dir()?.join(".amazonq").join("mcp.json"))
 }
 
-pub fn profile_mcp_config_path(ctx: &Context, profile_name: impl AsRef<str>) -> eyre::Result<PathBuf> {
-    Ok(chat_profiles_dir(ctx)?.join(profile_name.as_ref()).join("mcp.json"))
-}
-
 pub fn global_mcp_config_path(ctx: &Context) -> eyre::Result<PathBuf> {
     Ok(home_dir(ctx)?.join(".aws").join("amazonq").join("mcp.json"))
 }