open-swarm 0.1.1745274976__py3-none-any.whl → 0.1.1748636259__py3-none-any.whl

swarm/extensions/config/config_loader.py

@@ -1,114 +1,208 @@
-import json
+"""
+Configuration Loader for Open Swarm MCP Framework.
+"""
+
 import os
-from pathlib import Path
+import json
+import re
 import logging
-from typing import Dict, Any, Optional
+from typing import Any, Dict, List, Tuple, Optional
+from pathlib import Path
+from dotenv import load_dotenv
+try: from .server_config import save_server_config
+except ImportError: save_server_config = None
+
+SWARM_DEBUG = os.getenv("SWARM_DEBUG", "False").lower() in ("true", "1", "yes")
+try: from swarm.settings import BASE_DIR
+except ImportError: BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+from swarm.utils.redact import redact_sensitive_data
 
 logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG if SWARM_DEBUG else logging.INFO)
 
-DEFAULT_CONFIG_FILENAME = "swarm_config.json"
-
-# --- find_config_file, load_config, save_config, validate_config, get_profile_from_config, _substitute_env_vars_recursive ---
-# (Keep these functions as they were)
-def find_config_file( specific_path: Optional[str]=None, start_dir: Optional[Path]=None, default_dir: Optional[Path]=None,) -> Optional[Path]:
-    # 1. XDG config path
-    xdg_config = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))) / "swarm" / DEFAULT_CONFIG_FILENAME
-    if xdg_config.is_file():
-        logger.debug(f"Found config XDG: {xdg_config}")
-        return xdg_config.resolve()
-    # 2. User-specified path
-    if specific_path:
-        p = Path(specific_path)
-        return p.resolve() if p.is_file() else logger.warning(f"Specified config path DNE: {specific_path}") or None # Fall through
-    # 3. Upwards from start_dir
-    if start_dir:
-        current = start_dir.resolve()
-        while current != current.parent:
-            if (cp := current / DEFAULT_CONFIG_FILENAME).is_file():
-                logger.debug(f"Found config upwards: {cp}")
-                return cp.resolve()
-            current = current.parent
-        if (cp := current / DEFAULT_CONFIG_FILENAME).is_file():
-            logger.debug(f"Found config at root: {cp}")
-            return cp.resolve()
-    # 4. Default dir
-    if default_dir and (cp := default_dir.resolve() / DEFAULT_CONFIG_FILENAME).is_file():
-        logger.debug(f"Found config default: {cp}")
-        return cp.resolve()
-    # 5. CWD
-    cwd = Path.cwd()
-    if start_dir is None or cwd != start_dir.resolve():
-        if (cp := cwd / DEFAULT_CONFIG_FILENAME).is_file():
-            logger.debug(f"Found config cwd: {cp}")
-            return cp.resolve()
-    logger.debug(f"Config '{DEFAULT_CONFIG_FILENAME}' not found.")
-    return None
-
-def load_config(config_path: Path) -> Dict[str, Any]:
-    logger.debug(f"Loading config from {config_path}")
+# Add handler only if needed, DO NOT set handler level conditionally here
+if not logger.handlers and not logging.getLogger().hasHandlers():
+    stream_handler = logging.StreamHandler()
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s")
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+    # --- REMOVED CONDITIONAL HANDLER LEVEL SETTING ---
+    # if not SWARM_DEBUG:
+    #     stream_handler.setLevel(logging.WARNING)
+
+config: Dict[str, Any] = {}
+load_dotenv()
+logger.debug("Environment variables potentially loaded from .env file.")
+
+def process_config(config_dict: dict) -> dict:
+    """Processes config: resolves placeholders, merges external MCP."""
     try:
-        with open(config_path, 'r') as f: config = json.load(f)
-        logger.info(f"Loaded config from {config_path}"); validate_config(config); return config
-    except FileNotFoundError: logger.error(f"Config DNE: {config_path}"); raise
-    except json.JSONDecodeError as e: logger.error(f"JSON error {config_path}: {e}"); raise ValueError(f"Invalid JSON: {config_path}") from e
-    except Exception as e: logger.error(f"Load error {config_path}: {e}"); raise
-
-def save_config(config: Dict[str, Any], config_path: Path):
-    logger.info(f"Saving config to {config_path}")
-    try: config_path.parent.mkdir(parents=True,exist_ok=True); f = config_path.open('w'); json.dump(config, f, indent=4); f.close(); logger.debug("Save OK.")
-    except Exception as e: logger.error(f"Save failed {config_path}: {e}", exc_info=True); raise
-
-def validate_config(config: Dict[str, Any]):
-    logger.debug("Validating config structure...")
-    if "llm" not in config or not isinstance(config["llm"],dict): raise ValueError("Config 'llm' section missing/malformed.")
-    for name, prof in config.get("llm",{}).items():
-        if not isinstance(prof,dict): raise ValueError(f"LLM profile '{name}' not dict.")
-    logger.debug("Config basic structure OK.")
-
-def get_profile_from_config(config: Dict[str, Any], profile_name: str) -> Dict[str, Any]:
-    profile_data = config.get("llm", {}).get(profile_name)
-    if profile_data is None: raise ValueError(f"LLM profile '{profile_name}' not found.")
-    if not isinstance(profile_data, dict): raise ValueError(f"LLM profile '{profile_name}' not dict.")
-    return _substitute_env_vars_recursive(profile_data)
-
-def _substitute_env_vars_recursive(data: Any) -> Any:
-    if isinstance(data,dict): return {k:_substitute_env_vars_recursive(v) for k,v in data.items()}
-    if isinstance(data,list): return [_substitute_env_vars_recursive(i) for i in data]
-    if isinstance(data,str): return os.path.expandvars(data)
-    return data
-
-def _substitute_env_vars(data: Any) -> Any:
-    """Public API: Recursively substitute environment variables in dict, list, str."""
-    return _substitute_env_vars_recursive(data)
-
-def create_default_config(config_path: Path):
-    """Creates a default configuration file with valid JSON."""
-    default_config = {
-        "llm": {
-            "default": {
-                "provider": "openai",
-                "model": "gpt-4o",
-                "api_key": "${OPENAI_API_KEY}",
-                "base_url": None,
-                "description": "Default OpenAI profile. Requires OPENAI_API_KEY env var."
-            },
-            "ollama_example": {
-                 "provider": "ollama",
-                 "model": "llama3",
-                 "api_key": "ollama", # Usually not needed
-                 "base_url": "http://localhost:11434",
-                 "description": "Example for local Ollama Llama 3 model."
-            }
-        },
-        "agents": {},
-        "settings": {
-             "default_markdown_output": True
-        }
-    }
-    logger.info(f"Creating default configuration file at {config_path}")
+        resolved_config = resolve_placeholders(config_dict)
+        if logger.isEnabledFor(logging.DEBUG): logger.debug("Config after resolving placeholders: " + json.dumps(redact_sensitive_data(resolved_config), indent=2))
+        disable_merge = os.getenv("DISABLE_MCP_MERGE", "false").lower() in ("true", "1", "yes")
+        if not disable_merge:
+            if os.name == "nt": external_mcp_path = Path(os.getenv("APPDATA", Path.home())) / "Claude" / "claude_desktop_config.json"
+            else: external_mcp_path = Path.home() / ".vscode-server" / "data" / "User" / "globalStorage" / "rooveterinaryinc.roo-cline" / "settings" / "cline_mcp_settings.json"
+            if external_mcp_path.exists():
+                logger.info(f"Found external MCP settings file at: {external_mcp_path}")
+                try:
+                    with open(external_mcp_path, "r", encoding='utf-8') as mcp_file: external_mcp_config = json.load(mcp_file)
+                    if logger.isEnabledFor(logging.DEBUG): logger.debug("Loaded external MCP settings: " + json.dumps(redact_sensitive_data(external_mcp_config), indent=2))
+                    main_mcp_servers = resolved_config.get("mcpServers", {}); external_mcp_servers = external_mcp_config.get("mcpServers", {})
+                    merged_mcp_servers = main_mcp_servers.copy(); servers_added_count = 0
+                    for name, server_cfg in external_mcp_servers.items():
+                        if name not in merged_mcp_servers and not server_cfg.get("disabled", False): merged_mcp_servers[name] = server_cfg; servers_added_count += 1
+                    if servers_added_count > 0: resolved_config["mcpServers"] = merged_mcp_servers; logger.info(f"Merged {servers_added_count} MCP servers.");
+                    else: logger.debug("No new MCP servers added from external settings.")
+                except Exception as merge_err: logger.error(f"Failed to load/merge MCP settings from '{external_mcp_path}': {merge_err}", exc_info=logger.isEnabledFor(logging.DEBUG))
+            else: logger.debug(f"External MCP settings file not found at {external_mcp_path}. Skipping merge.")
+        else: logger.debug("MCP settings merge disabled.")
+    except Exception as e: logger.error(f"Failed during config processing: {e}", exc_info=logger.isEnabledFor(logging.DEBUG)); raise
+    globals()["config"] = resolved_config
+    return resolved_config
+
+def resolve_placeholders(obj: Any) -> Any:
+    """Recursively resolve ${VAR_NAME} placeholders."""
+    if isinstance(obj, dict): return {k: resolve_placeholders(v) for k, v in obj.items()}
+    elif isinstance(obj, list): return [resolve_placeholders(item) for item in obj]
+    elif isinstance(obj, str):
+        pattern = re.compile(r'\$\{(\w+(?:[_-]\w+)*)\}')
+        resolved_string = obj; any_unresolved = False
+        for var_name in pattern.findall(obj):
+            env_value = os.getenv(var_name); placeholder = f'${{{var_name}}}'
+            if env_value is None:
+                log_level = logging.DEBUG
+                if resolved_string == placeholder:
+                     log_level = logging.WARNING
+                     resolved_string = None
+                     any_unresolved = True
+                     logger.log(log_level, f"Env var '{var_name}' not set for placeholder '{placeholder}'. Resolving to None.")
+                     return None
+                else:
+                    resolved_string = resolved_string.replace(placeholder, "")
+                    any_unresolved = True
+                    logger.log(log_level, f"Env var '{var_name}' not set for placeholder '{placeholder}'. Removing from string.")
+            else:
+                 resolved_string = resolved_string.replace(placeholder, env_value)
+                 if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Resolved placeholder '{placeholder}' using env var '{var_name}'.")
+        if any_unresolved and resolved_string is not None:
+             logger.debug(f"String '{obj}' contained unresolved placeholders. Result: '{resolved_string}'")
+        return resolved_string
+    else: return obj
+
+def load_server_config(file_path: Optional[str] = None) -> dict:
+    """Loads, resolves, and merges server config from JSON file."""
+    config_path: Optional[Path] = None
+    if file_path:
+         path_obj = Path(file_path)
+         if path_obj.is_file(): config_path = path_obj; logger.info(f"Using provided config file path: {config_path}")
+         else: logger.warning(f"Provided path '{file_path}' not found. Searching standard locations.")
+    if not config_path:
+        standard_paths = [ Path.cwd() / "swarm_config.json", Path(BASE_DIR) / "swarm_config.json", Path.home() / ".swarm" / "swarm_config.json" ]
+        config_path = next((p for p in standard_paths if p.is_file()), None)
+        if not config_path: raise FileNotFoundError(f"Config file 'swarm_config.json' not found. Checked: {[str(p) for p in standard_paths]}")
+        logger.info(f"Using config file found at: {config_path}")
     try:
-        save_config(default_config, config_path) # Use save_config to write valid JSON
-        logger.debug("Default configuration file created successfully.")
-    except Exception as e:
-        logger.error(f"Failed to create default config file at {config_path}: {e}", exc_info=True)
-        raise
+        raw_config = json.loads(config_path.read_text(encoding='utf-8'))
+        if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Raw config loaded: {redact_sensitive_data(raw_config)}")
+        processed_config = process_config(raw_config)
+        globals()["config"] = processed_config
+        logger.info(f"Config loaded and processed from {config_path}")
+        return processed_config
+    except json.JSONDecodeError as e: logger.critical(f"Invalid JSON in {config_path}: {e}"); raise ValueError(f"Invalid JSON") from e
+    except Exception as e: logger.critical(f"Failed to read/process config {config_path}: {e}"); raise ValueError("Failed to load/process config") from e
+
+def load_llm_config(config_dict: Optional[Dict[str, Any]] = None, llm_name: Optional[str] = None) -> Dict[str, Any]:
+    """Loads, validates, and resolves API keys for a specific LLM profile."""
+    if config_dict is None:
+        global_config = globals().get("config")
+        if not global_config:
+             try: config_dict = load_server_config(); globals()["config"] = config_dict
+             except Exception as e: raise ValueError("Global config not loaded and no config_dict provided.") from e
+        else: config_dict = global_config
+
+    target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
+    logger.debug(f"LOAD_LLM: Loading profile: '{target_llm_name}'.")
+
+    resolved_config = resolve_placeholders(config_dict)
+    llm_profiles = resolved_config.get("llm", {})
+    if not isinstance(llm_profiles, dict): raise ValueError("'llm' section must be a dictionary.")
+
+    llm_config = llm_profiles.get(target_llm_name)
+    config_source = f"config file ('{target_llm_name}')"
+    logger.debug(f"LOAD_LLM: Initial lookup for '{target_llm_name}': {'Found' if llm_config else 'Missing'}")
+
+    if not llm_config:
+        logger.warning(f"LOAD_LLM: Config for '{target_llm_name}' not found. Generating fallback.")
+        config_source = "fallback generation"
+        fb_provider = os.getenv("DEFAULT_LLM_PROVIDER", "openai"); fb_model = os.getenv("DEFAULT_LLM_MODEL", "gpt-4o")
+        llm_config = { "provider": fb_provider, "model": fb_model, "api_key": None, "base_url": None }
+        logger.debug(f"LOAD_LLM: Generated fallback core config: {llm_config}")
+
+    if not isinstance(llm_config, dict): raise ValueError(f"LLM profile '{target_llm_name}' must be a dictionary.")
+
+    final_api_key = llm_config.get("api_key"); key_log_source = f"{config_source} (resolved)" if final_api_key else config_source
+    provider = llm_config.get("provider"); api_key_required = llm_config.get("api_key_required", True)
+    logger.debug(f"LOAD_LLM: Initial key from {key_log_source}: {'****' if final_api_key else 'None'}. Required={api_key_required}")
+
+    logger.debug(f"LOAD_LLM: Checking ENV vars for potential override.")
+    specific_env_var_name = f"{provider.upper()}_API_KEY" if provider else "PROVIDER_API_KEY"
+    common_fallback_var = "OPENAI_API_KEY"
+    specific_key_from_env = os.getenv(specific_env_var_name); fallback_key_from_env = os.getenv(common_fallback_var)
+    logger.debug(f"LOAD_LLM: Env Check: Specific ('{specific_env_var_name}')={'****' if specific_key_from_env else 'None'}, Fallback ('{common_fallback_var}')={'****' if fallback_key_from_env else 'None'}")
+
+    if specific_key_from_env:
+        if final_api_key != specific_key_from_env: logger.info(f"LOAD_LLM: Overriding key with env var '{specific_env_var_name}'.")
+        final_api_key = specific_key_from_env; key_log_source = f"env var '{specific_env_var_name}'"
+    elif fallback_key_from_env:
+        if not specific_key_from_env or specific_env_var_name == common_fallback_var:
+            if final_api_key != fallback_key_from_env: logger.info(f"LOAD_LLM: Overriding key with fallback env var '{common_fallback_var}'.")
+            final_api_key = fallback_key_from_env; key_log_source = f"env var '{common_fallback_var}'"
+        else: logger.debug(f"LOAD_LLM: Specific env key '{specific_env_var_name}' unset, NOT using fallback.")
+    else: logger.debug(f"LOAD_LLM: No relevant API key found in environment variables.")
+
+    key_is_still_missing_or_empty = final_api_key is None or (isinstance(final_api_key, str) and not final_api_key.strip())
+    logger.debug(f"LOAD_LLM: Key after env check: {'****' if final_api_key else 'None'}. Source: {key_log_source}. Still MissingOrEmpty={key_is_still_missing_or_empty}")
+
+    if key_is_still_missing_or_empty:
+        if api_key_required and not os.getenv("SUPPRESS_DUMMY_KEY"):
+             final_api_key = "sk-DUMMYKEY"; key_log_source = "dummy key"; logger.warning(f"LOAD_LLM: Applying dummy key for '{target_llm_name}'.")
+        elif api_key_required:
+             key_log_source = "MISSING - ERROR"; raise ValueError(f"Required API key for LLM profile '{target_llm_name}' is missing.")
+        else: key_log_source = "Not Required/Not Found"
+
+    final_llm_config = llm_config.copy(); final_llm_config["api_key"] = final_api_key; final_llm_config["_log_key_source"] = key_log_source
+    logger.debug(f"LOAD_LLM: Returning final config for '{target_llm_name}': {redact_sensitive_data(final_llm_config)}")
+    return final_llm_config
+
+def get_llm_model(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -> str:
+    target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
+    try: llm_config = load_llm_config(config_dict, target_llm_name)
+    except ValueError as e: raise ValueError(f"Could not load config for LLM '{target_llm_name}': {e}") from e
+    model_name = llm_config.get("model")
+    if not model_name or not isinstance(model_name, str): raise ValueError(f"'model' name missing/invalid for LLM '{target_llm_name}'.")
+    logger.debug(f"Retrieved model name '{model_name}' for LLM '{target_llm_name}'")
+    return model_name
+
+def load_and_validate_llm(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -> Dict[str, Any]:
+    target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
+    logger.debug(f"Loading and validating LLM (via load_llm_config) for profile: {target_llm_name}")
+    return load_llm_config(config_dict, target_llm_name)
+
+def get_server_params(server_config: Dict[str, Any], server_name: str) -> Optional[Dict[str, Any]]:
+    """Extracts and validates parameters needed to start an MCP server."""
+    command = server_config.get("command"); args = server_config.get("args", []); config_env = server_config.get("env", {})
+    if not command: logger.error(f"MCP server '{server_name}' missing 'command'."); return None
+    if not isinstance(args, list): logger.error(f"MCP server '{server_name}' 'args' must be list."); return None
+    if not isinstance(config_env, dict): logger.error(f"MCP server '{server_name}' 'env' must be dict."); return None
+    env = {**os.environ.copy(), **config_env}; valid_env = {}
+    for k, v in env.items():
+        if v is None: logger.warning(f"Env var '{k}' for MCP server '{server_name}' resolved to None. Omitting.")
+        else: valid_env[k] = str(v)
+    return {"command": command, "args": args, "env": valid_env}
+
+def list_mcp_servers(config_dict: Dict[str, Any]) -> List[str]:
+     """Returns a list of configured MCP server names."""
+     return list(config_dict.get("mcpServers", {}).keys())
+

swarm/{core → extensions/config}/config_manager.py

@@ -6,11 +6,17 @@ import sys
 import logging
 from typing import Any, Dict
 
-from swarm.core.server_config import load_server_config, save_server_config
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    resolve_placeholders
+)
 from swarm.utils.color_utils import color_text
 from swarm.settings import DEBUG
-from swarm.core.utils.logger import *
-from swarm.extensions.cli.utils.prompt_user import prompt_user
+from swarm.extensions.cli.utils import (
+    prompt_user,
+    log_and_exit,
+    display_message
+)
 
 # Initialize logger for this module
 logger = logging.getLogger(__name__)
@@ -23,24 +29,6 @@ if not logger.handlers:
 
 CONFIG_BACKUP_SUFFIX = ".backup"
 
-def resolve_placeholders(config):
-    # Recursively resolve placeholders in the config dict (env vars, etc.)
-    import os
-    import re
-    pattern = re.compile(r'\$\{([^}]+)\}')
-    def _resolve(val):
-        if isinstance(val, str):
-            def replacer(match):
-                var = match.group(1)
-                return os.environ.get(var, match.group(0))
-            return pattern.sub(replacer, val)
-        elif isinstance(val, dict):
-            return {k: _resolve(v) for k, v in val.items()}
-        elif isinstance(val, list):
-            return [_resolve(v) for v in val]
-        return val
-    return _resolve(config)
-
 def backup_configuration(config_path: str) -> None:
     """
     Create a backup of the existing configuration file.
@@ -52,10 +40,10 @@ def backup_configuration(config_path: str) -> None:
     try:
         shutil.copy(config_path, backup_path)
         logger.info(f"Configuration backup created at '{backup_path}'")
-        print(f"Backup of configuration created at '{backup_path}'")
+        display_message(f"Backup of configuration created at '{backup_path}'", "info")
     except Exception as e:
         logger.error(f"Failed to create configuration backup: {e}")
-        print(f"Failed to create backup: {e}")
+        display_message(f"Failed to create backup: {e}", "error")
         sys.exit(1)
 
 def load_config(config_path: str) -> Dict[str, Any]:
@@ -78,11 +66,11 @@ def load_config(config_path: str) -> Dict[str, Any]:
             logger.debug(f"Raw configuration loaded: {config}")
     except FileNotFoundError:
         logger.error(f"Configuration file not found at {config_path}")
-        print(f"Configuration file not found at {config_path}")
+        display_message(f"Configuration file not found at {config_path}", "error")
         sys.exit(1)
     except json.JSONDecodeError as e:
         logger.error(f"Invalid JSON in configuration file {config_path}: {e}")
-        print(f"Invalid JSON in configuration file {config_path}: {e}")
+        display_message(f"Invalid JSON in configuration file {config_path}: {e}", "error")
         sys.exit(1)
 
     # Resolve placeholders recursively
@@ -91,7 +79,7 @@ def load_config(config_path: str) -> Dict[str, Any]:
         logger.debug(f"Configuration after resolving placeholders: {resolved_config}")
     except Exception as e:
         logger.error(f"Failed to resolve placeholders in configuration: {e}")
-        print(f"Failed to resolve placeholders in configuration: {e}")
+        display_message(f"Failed to resolve placeholders in configuration: {e}", "error")
         sys.exit(1)
 
     return resolved_config
@@ -111,10 +99,10 @@ def save_config(config_path: str, config: Dict[str, Any]) -> None:
         with open(config_path, "w") as f:
             json.dump(config, f, indent=4)
         logger.info(f"Configuration saved to '{config_path}'")
-        print(f"Configuration saved to '{config_path}'")
+        display_message(f"Configuration saved to '{config_path}'", "info")
     except Exception as e:
         logger.error(f"Failed to save configuration: {e}")
-        print(f"Failed to save configuration: {e}")
+        display_message(f"Failed to save configuration: {e}", "error")
         sys.exit(1)
 
 def add_llm(config_path: str) -> None:
@@ -125,20 +113,20 @@ def add_llm(config_path: str) -> None:
         config_path (str): Path to the configuration file.
     """
     config = load_config(config_path)
-    print("Starting the process to add a new LLM.")
+    display_message("Starting the process to add a new LLM.", "info")
 
     while True:
         llm_name = prompt_user("Enter the name of the new LLM (or type 'done' to finish)").strip()
-        print(f"User entered LLM name: {llm_name}")
+        display_message(f"User entered LLM name: {llm_name}", "info")
         if llm_name.lower() == 'done':
-            print("Finished adding LLMs.")
+            display_message("Finished adding LLMs.", "info")
             break
         if not llm_name:
-            print("LLM name cannot be empty.")
+            display_message("LLM name cannot be empty.", "error")
             continue
 
         if llm_name in config.get("llm", {}):
-            print(f"LLM '{llm_name}' already exists.")
+            display_message(f"LLM '{llm_name}' already exists.", "warning")
             continue
 
         llm = {}
@@ -154,16 +142,16 @@ def add_llm(config_path: str) -> None:
             temperature_input = prompt_user("Enter the temperature (e.g., 0.7)").strip()
             llm["temperature"] = float(temperature_input)
         except ValueError:
-            print("Invalid temperature value. Using default 0.7.")
+            display_message("Invalid temperature value. Using default 0.7.", "warning")
             llm["temperature"] = 0.7
 
         config.setdefault("llm", {})[llm_name] = llm
         logger.info(f"Added LLM '{llm_name}' to configuration.")
-        print(f"LLM '{llm_name}' added.")
+        display_message(f"LLM '{llm_name}' added.", "info")
 
     backup_configuration(config_path)
     save_config(config_path, config)
-    print("LLM configuration process completed.")
+    display_message("LLM configuration process completed.", "info")
 
 def remove_llm(config_path: str, llm_name: str) -> None:
     """
@@ -176,18 +164,18 @@ def remove_llm(config_path: str, llm_name: str) -> None:
     config = load_config(config_path)
 
     if llm_name not in config.get("llm", {}):
-        print(f"LLM '{llm_name}' does not exist.")
+        display_message(f"LLM '{llm_name}' does not exist.", "error")
         return
 
     confirm = prompt_user(f"Are you sure you want to remove LLM '{llm_name}'? (yes/no)").strip().lower()
     if confirm not in ['yes', 'y']:
-        print("Operation cancelled.")
+        display_message("Operation cancelled.", "warning")
         return
 
     del config["llm"][llm_name]
     backup_configuration(config_path)
     save_config(config_path, config)
-    print(f"LLM '{llm_name}' has been removed.")
+    display_message(f"LLM '{llm_name}' has been removed.", "info")
     logger.info(f"Removed LLM '{llm_name}' from configuration.")
 
 def add_mcp_server(config_path: str) -> None:
@@ -198,20 +186,20 @@ def add_mcp_server(config_path: str) -> None:
         config_path (str): Path to the configuration file.
     """
     config = load_config(config_path)
-    print("Starting the process to add a new MCP server.")
+    display_message("Starting the process to add a new MCP server.", "info")
 
     while True:
         server_name = prompt_user("Enter the name of the new MCP server (or type 'done' to finish)").strip()
-        print(f"User entered MCP server name: {server_name}")
+        display_message(f"User entered MCP server name: {server_name}", "info")
         if server_name.lower() == 'done':
-            print("Finished adding MCP servers.")
+            display_message("Finished adding MCP servers.", "info")
             break
         if not server_name:
-            print("Server name cannot be empty.")
+            display_message("Server name cannot be empty.", "error")
             continue
 
         if server_name in config.get("mcpServers", {}):
-            print(f"MCP server '{server_name}' already exists.")
+            display_message(f"MCP server '{server_name}' already exists.", "warning")
             continue
 
         server = {}
@@ -222,7 +210,7 @@ def add_mcp_server(config_path: str) -> None:
             if not isinstance(server["args"], list):
                 raise ValueError
         except ValueError:
-            print("Invalid arguments format. Using an empty list.")
+            display_message("Invalid arguments format. Using an empty list.", "warning")
             server["args"] = []
 
         env_vars = {}
@@ -238,11 +226,11 @@ def add_mcp_server(config_path: str) -> None:
 
         config.setdefault("mcpServers", {})[server_name] = server
         logger.info(f"Added MCP server '{server_name}' to configuration.")
-        print(f"MCP server '{server_name}' added.")
+        display_message(f"MCP server '{server_name}' added.", "info")
 
     backup_configuration(config_path)
     save_config(config_path, config)
-    print("MCP server configuration process completed.")
+    display_message("MCP server configuration process completed.", "info")
 
 def remove_mcp_server(config_path: str, server_name: str) -> None:
     """
@@ -255,16 +243,16 @@ def remove_mcp_server(config_path: str, server_name: str) -> None:
     config = load_config(config_path)
 
     if server_name not in config.get("mcpServers", {}):
-        print(f"MCP server '{server_name}' does not exist.")
+        display_message(f"MCP server '{server_name}' does not exist.", "error")
         return
 
     confirm = prompt_user(f"Are you sure you want to remove MCP server '{server_name}'? (yes/no)").strip().lower()
     if confirm not in ['yes', 'y']:
-        print("Operation cancelled.")
+        display_message("Operation cancelled.", "warning")
         return
 
     del config["mcpServers"][server_name]
     backup_configuration(config_path)
     save_config(config_path, config)
-    print(f"MCP server '{server_name}' has been removed.")
+    display_message(f"MCP server '{server_name}' has been removed.", "info")
     logger.info(f"Removed MCP server '{server_name}' from configuration.")

swarm/{core → extensions/config}/server_config.py

@@ -47,35 +47,3 @@ def save_server_config(config: dict, file_path: str = None) -> None:
     except OSError as e:
         logger.error(f"Error saving configuration to {file_path}: {e}")
         raise
-
-def load_server_config(file_path: str = None) -> dict:
-    """
-    Loads the server configuration from a JSON file.
-
-    Args:
-        file_path (str): The path to the configuration file. Defaults to 'swarm_settings.json' in the current directory.
-
-    Returns:
-        dict: The loaded configuration dictionary.
-
-    Raises:
-        FileNotFoundError: If the configuration file does not exist.
-        ValueError: If the configuration is not a valid dictionary or JSON is invalid.
-    """
-    if file_path is None:
-        file_path = os.path.join(os.getcwd(), "swarm_settings.json")
-    logger.debug(f"Loading server configuration from {file_path}")
-    try:
-        with open(file_path, "r") as file:
-            config = json.load(file)
-            if not isinstance(config, dict):
-                logger.error("Loaded configuration is not a dictionary.")
-                raise ValueError("Configuration must be a dictionary.")
-            logger.debug(f"Loaded configuration: {redact_sensitive_data(config)}")
-            return config
-    except FileNotFoundError as e:
-        logger.error(f"Configuration file not found: {file_path}")
-        raise
-    except json.JSONDecodeError as e:
-        logger.error(f"Invalid JSON in configuration file {file_path}: {e}")
-        raise ValueError(f"Invalid JSON in configuration file: {e}")

swarm/extensions/launchers/build_launchers.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+import PyInstaller.__main__
+
+def build_executable(script, output_name):
+    PyInstaller.__main__.run([
+        script,
+        "--onefile",
+        "--name", output_name,
+        "--add-data", "swarm_config.json:."  # Adjust if additional data is needed
+    ])
+
+if __name__ == "__main__":
+    build_executable("launchers/swarm_cli.py", "swarm-cli")
+    build_executable("launchers/swarm_rest.py", "swarm-rest")