open-swarm 0.1.1743070217__py3-none-any.whl

swarm/extensions/config/server_config.py

@@ -0,0 +1,49 @@
+"""
+Module for managing server configuration files, including saving and validation.
+
+Provides utilities to save configurations to disk and ensure integrity of data.
+"""
+
+import json
+import os
+import logging
+from swarm.utils.redact import redact_sensitive_data
+
+# Initialize logger for this module
+logger = logging.getLogger(__name__)
+DEBUG = os.getenv("DEBUG", "False").lower() in ("true", "1", "t")  # Define DEBUG locally
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+stream_handler = logging.StreamHandler()
+formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+stream_handler.setFormatter(formatter)
+if not logger.handlers:
+    logger.addHandler(stream_handler)
+
+def save_server_config(config: dict, file_path: str = None) -> None:
+    """
+    Saves the server configuration to a JSON file.
+
+    Args:
+        config (dict): The configuration dictionary to save.
+        file_path (str): The path to save the configuration file. Defaults to 'swarm_settings.json' in the current directory.
+
+    Raises:
+        ValueError: If the configuration is not a valid dictionary.
+        OSError: If there are issues writing to the file.
+    """
+    if not isinstance(config, dict):
+        logger.error("Provided configuration is not a dictionary.")
+        raise ValueError("Configuration must be a dictionary.")
+
+    if file_path is None:
+        file_path = os.path.join(os.getcwd(), "swarm_settings.json")
+
+    logger.debug(f"Saving server configuration to {file_path}")
+    try:
+        with open(file_path, "w") as file:
+            json.dump(config, file, indent=4)
+            logger.info(f"Configuration successfully saved to {file_path}")
+            logger.debug(f"Saved configuration: {redact_sensitive_data(config)}")
+    except OSError as e:
+        logger.error(f"Error saving configuration to {file_path}: {e}")
+        raise

swarm/extensions/config/setup_wizard.py

@@ -0,0 +1,103 @@
+# src/swarm/extensions/config/setup_wizard.py
+
+import os
+import json
+from typing import Dict, Any
+
+def run_setup_wizard(config_path: str, blueprints_metadata: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Runs the interactive setup wizard.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        blueprints_metadata (Dict[str, Dict[str, Any]]): Metadata for available blueprints.
+
+    Returns:
+        Dict[str, Any]: Updated configuration.
+    """
+    config = {
+        "llm_providers": {},
+        "mcpServers": {}
+    }
+
+    # Configure LLM settings
+    print("Configuring LLM providers:")
+    while True:
+        provider_name = input("Enter the name of the LLM provider to add (e.g., 'openai', 'ollama'), or type 'done' to finish: ").strip()
+        if provider_name.lower() in ['done', 'exit', 'quit']:
+            break
+        if not provider_name:
+            print("Provider name cannot be empty.")
+            continue
+        if provider_name in config["llm_providers"]:
+            print(f"LLM provider '{provider_name}' already exists.")
+            continue
+
+        provider = {}
+        provider["provider"] = input("Enter the provider identifier (e.g., 'openai', 'ollama'): ").strip()
+        provider["model"] = input("Enter the model name (e.g., 'gpt-4'): ").strip()
+        provider["base_url"] = input("Enter the base URL for the API (e.g., 'https://api.openai.com/v1'): ").strip()
+        provider["api_key"] = input("Enter the environment variable for the API key (e.g., 'OPENAI_API_KEY') [Leave empty if not required]: ").strip()
+        temperature_input = input("Enter the temperature for the model (e.g., 0.7): ").strip()
+        try:
+            provider["temperature"] = float(temperature_input)
+        except ValueError:
+            print("Invalid temperature value. Using default 0.7.")
+            provider["temperature"] = 0.7
+
+        config["llm_providers"][provider_name] = provider
+        print(f"LLM provider '{provider_name}' added successfully.\n")
+
+    # Select a default LLM provider
+    if config["llm_providers"]:
+        print("\nAvailable LLM Providers:")
+        for idx, provider in enumerate(config["llm_providers"].keys(), start=1):
+            print(f"{idx}. {provider}")
+        while True:
+            try:
+                default_choice = input("Enter the number of the LLM provider to set as default: ").strip()
+                default_choice = int(default_choice)
+                if 1 <= default_choice <= len(config["llm_providers"]):
+                    default_provider = list(config["llm_providers"].keys())[default_choice - 1]
+                    config["llm_providers"]["default"] = config["llm_providers"][default_provider]
+                    print(f"Default LLM provider set to '{default_provider}'.\n")
+                    break
+                else:
+                    print(f"Please enter a number between 1 and {len(config['llm_providers'])}.")
+            except ValueError:
+                print("Invalid input. Please enter a valid number.")
+    else:
+        print("No LLM providers configured.")
+
+    # Select a blueprint
+    print("\nAvailable Blueprints:")
+    for idx, (key, metadata) in enumerate(blueprints_metadata.items(), start=1):
+        print(f"{idx}. {key}: {metadata.get('title', 'No title')} - {metadata.get('description', 'No description')}")
+
+    while True:
+        try:
+            blueprint_choice = input("\nEnter the number of the blueprint to use (0 to skip): ").strip()
+            if blueprint_choice.lower() in ["q", "quit", "exit"]:  # Handle exit inputs
+                print("Exiting blueprint selection.")
+                break
+
+            blueprint_choice = int(blueprint_choice)
+            if blueprint_choice == 0:
+                print("No blueprint selected.")
+                break
+            elif 1 <= blueprint_choice <= len(blueprints_metadata):
+                selected_blueprint_key = list(blueprints_metadata.keys())[blueprint_choice - 1]
+                config["blueprint"] = selected_blueprint_key
+                print(f"Selected Blueprint: {selected_blueprint_key}\n")
+                break
+            else:
+                print(f"Invalid selection. Please enter a number between 0 and {len(blueprints_metadata)}.")
+        except ValueError:
+            print("Invalid input. Please enter a valid number.")
+
+    # Save configuration
+    with open(config_path, "w") as config_file:
+        json.dump(config, config_file, indent=4)
+    print(f"Configuration saved to {config_path}.\n")
+
+    return config

swarm/extensions/config/utils/logger.py

@@ -0,0 +1,36 @@
+# src/swarm/config/utils/logger.py
+
+import logging
+from typing import Optional
+
+def setup_logger(name: str, level: int = logging.DEBUG, log_file: Optional[str] = None) -> logging.Logger:
+    """
+    Sets up and returns a logger with the specified name and level.
+
+    Args:
+        name (str): The name of the logger.
+        level (int, optional): Logging level. Defaults to logging.DEBUG.
+        log_file (str, optional): File path to log to. If None, logs to console. Defaults to None.
+
+    Returns:
+        logging.Logger: Configured logger instance.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    # Prevent adding multiple handlers to the logger
+    if not logger.handlers:
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        
+        if log_file:
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setLevel(level)
+            file_handler.setFormatter(formatter)
+            logger.addHandler(file_handler)
+        
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+    
+    return logger

swarm/extensions/launchers/__init__.py

@@ -0,0 +1 @@
+# This file makes the launchers folder a Python package.

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")

swarm/extensions/launchers/build_swarm_wrapper.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+import PyInstaller.__main__
+
+PyInstaller.__main__.run([
+    "swarm_wrapper.py",
+    "--onefile",
+    "--name", "swarm-wrapper",
+    "--distpath", "~/bin",
+    "--workpath", "build",
+    "--specpath", "."
+])
+

swarm/extensions/launchers/swarm_api.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import argparse
+import subprocess
+import sys
+from os import path, listdir, makedirs
+
+def main():
+    parser = argparse.ArgumentParser(description="Swarm REST Launcher")
+    parser.add_argument("--blueprint", required=True, help="Comma-separated blueprint file paths or names for configuration purposes")
+    parser.add_argument("--port", type=int, default=8000, help="Port to run the REST server")
+    parser.add_argument("--config", default="~/.swarm/swarm_config.json", help="Configuration file path")
+    parser.add_argument("--daemon", action="store_true", help="Run in daemon mode and print process id")
+    args = parser.parse_args()
+
+    # Split blueprints by comma and strip whitespace
+    bp_list = [bp.strip() for bp in args.blueprint.split(",") if bp.strip()]
+    blueprint_paths = []
+    for bp_arg in bp_list:
+        resolved = None
+        if path.exists(bp_arg):
+            if path.isdir(bp_arg):
+                resolved = bp_arg
+                print(f"Using blueprint directory: {resolved}")
+            else:
+                resolved = bp_arg
+                print(f"Using blueprint file: {resolved}")
+        else:
+            managed_path = path.expanduser("~/.swarm/blueprints/" + bp_arg)
+            if path.isdir(managed_path):
+                matches = [f for f in listdir(managed_path) if f.startswith("blueprint_") and f.endswith(".py")]
+                if not matches:
+                    print("Error: No blueprint file found in managed directory:", managed_path)
+                    sys.exit(1)
+                resolved = path.join(managed_path, matches[0])
+                print(f"Using managed blueprint: {resolved}")
+            else:
+                print("Warning: Blueprint not found:", bp_arg, "- skipping.")
+                continue
+        if resolved:
+            blueprint_paths.append(resolved)
+
+    if not blueprint_paths:
+        print("Error: No valid blueprints found.")
+        sys.exit(1)
+    print("Blueprints to be configured:")
+    for bp in blueprint_paths:
+        print(" -", bp)
+
+    config_path = path.expanduser(args.config)
+    if not path.exists(config_path):
+        makedirs(path.dirname(config_path), exist_ok=True)
+        with open(config_path, 'w') as f:
+            f.write("{}")
+        print("Default config file created at:", config_path)
+
+    print("Launching Django server on port 0.0.0.0:{}".format(args.port))
+    try:
+        if args.daemon:
+            proc = subprocess.Popen(["python", "manage.py", "runserver", f"0.0.0.0:{args.port}"])
+            print("Running in daemon mode. Process ID:", proc.pid)
+        else:
+            subprocess.run(["python", "manage.py", "runserver", f"0.0.0.0:{args.port}"], check=True)
+    except subprocess.CalledProcessError as e:
+        print("Error launching Django server:", e)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

swarm/extensions/launchers/swarm_cli.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+import argparse
+import importlib.util
+import os
+import sys
+import subprocess
+import shutil
+import json
+import PyInstaller.__main__
+
+def resolve_env_vars(data):
+    if isinstance(data, dict):
+        return {k: resolve_env_vars(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [resolve_env_vars(item) for item in data]
+    elif isinstance(data, str):
+        return os.path.expandvars(data)
+    else:
+        return data
+
+MANAGED_DIR = os.path.expanduser("~/.swarm/blueprints")
+BIN_DIR = os.path.expanduser("~/.swarm/bin")
+
+def ensure_managed_dir():
+    if not os.path.exists(MANAGED_DIR):
+        os.makedirs(MANAGED_DIR, exist_ok=True)
+    if not os.path.exists(BIN_DIR):
+        os.makedirs(BIN_DIR, exist_ok=True)
+
+def add_blueprint(source_path, blueprint_name=None):
+    source_path = os.path.normpath(source_path)
+    if not os.path.exists(source_path):
+        print("Error: source file/directory does not exist:", source_path)
+        sys.exit(1)
+    if os.path.isdir(source_path):
+        if not blueprint_name:
+            blueprint_name = os.path.basename(os.path.normpath(source_path))
+        target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+        os.makedirs(target_dir, exist_ok=True)
+        for root, dirs, files in os.walk(source_path):
+            rel_path = os.path.relpath(root, source_path)
+            dest_root = os.path.join(target_dir, rel_path) if rel_path != '.' else target_dir
+            os.makedirs(dest_root, exist_ok=True)
+            for file in files:
+                shutil.copy2(os.path.join(root, file), os.path.join(dest_root, file))
+        print(f"Blueprint '{blueprint_name}' added successfully to {target_dir}.")
+    else:
+        blueprint_file = source_path
+        if not blueprint_name:
+            base = os.path.basename(blueprint_file)
+            if base.startswith("blueprint_") and base.endswith(".py"):
+                blueprint_name = base[len("blueprint_"):-3]
+            else:
+                blueprint_name = os.path.splitext(base)[0]
+        target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+        os.makedirs(target_dir, exist_ok=True)
+        target_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+        shutil.copy2(blueprint_file, target_file)
+        print(f"Blueprint '{blueprint_name}' added successfully to {target_dir}.")
+
+def list_blueprints():
+    ensure_managed_dir()
+    entries = os.listdir(MANAGED_DIR)
+    blueprints = [d for d in entries if os.path.isdir(os.path.join(MANAGED_DIR, d))]
+    if blueprints:
+        print("Registered blueprints:")
+        for bp in blueprints:
+            print(" -", bp)
+    else:
+        print("No blueprints registered.")
+
+def delete_blueprint(blueprint_name):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    if os.path.exists(target_dir) and os.path.isdir(target_dir):
+        shutil.rmtree(target_dir)
+        print(f"Blueprint '{blueprint_name}' deleted successfully.")
+    else:
+        print(f"Error: Blueprint '{blueprint_name}' does not exist.")
+        sys.exit(1)
+
+def run_blueprint(blueprint_name):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+    if not os.path.exists(blueprint_file):
+        print(f"Error: Blueprint file not found for '{blueprint_name}'. Install it using 'swarm-cli add <path>'.")
+        sys.exit(1)
+    spec = importlib.util.spec_from_file_location("blueprint_module", blueprint_file)
+    if spec is None or spec.loader is None:
+        print("Error: Failed to load blueprint module from:", blueprint_file)
+        sys.exit(1)
+    blueprint = importlib.util.module_from_spec(spec)
+    loader = spec.loader
+    src_path = os.path.join(os.getcwd(), "src")
+    if src_path not in sys.path:
+        sys.path.insert(0, src_path)
+    loader.exec_module(blueprint)
+    if hasattr(blueprint, "main"):
+        blueprint.main()
+    else:
+        print("Error: The blueprint does not have a main() function.")
+        sys.exit(1)
+
+def install_blueprint(blueprint_name):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+    if not os.path.exists(blueprint_file):
+        print(f"Error: Blueprint '{blueprint_name}' is not registered. Add it using 'swarm-cli add <path>'.")
+        sys.exit(1)
+    cli_name = blueprint_name  # Use blueprint_name as default cli_name for simplicity
+    try:
+        PyInstaller.__main__.run([
+            blueprint_file,
+            "--onefile",
+            "--name", cli_name,
+            "--distpath", BIN_DIR,
+            "--workpath", os.path.join(target_dir, "build"),
+            "--specpath", target_dir
+        ])
+    except KeyboardInterrupt:
+        print("Installation aborted by user request.")
+        sys.exit(1)
+    print(f"Blueprint '{blueprint_name}' installed as CLI utility '{cli_name}' at: {os.path.join(BIN_DIR, cli_name)}")
+
+def uninstall_blueprint(blueprint_name, blueprint_only=False, wrapper_only=False):
+    target_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(target_dir, f"blueprint_{blueprint_name}.py")
+    cli_name = blueprint_name  # Default to blueprint_name for uninstall
+    cli_path = os.path.join(BIN_DIR, cli_name)
+    removed = False
+    
+    if not blueprint_only and not wrapper_only:  # Remove both by default
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+            print(f"Blueprint '{blueprint_name}' removed from {MANAGED_DIR}.")
+            removed = True
+        if os.path.exists(cli_path):
+            os.remove(cli_path)
+            print(f"Wrapper '{cli_name}' removed from {BIN_DIR}.")
+            removed = True
+    elif blueprint_only:
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+            print(f"Blueprint '{blueprint_name}' removed from {MANAGED_DIR}.")
+            removed = True
+    elif wrapper_only:
+        if os.path.exists(cli_path):
+            os.remove(cli_path)
+            print(f"Wrapper '{cli_name}' removed from {BIN_DIR}.")
+            removed = True
+    
+    if not removed:
+        print(f"Error: Nothing to uninstall for '{blueprint_name}' with specified options.")
+        sys.exit(1)
+
+def main():
+    os.environ.pop("SWARM_BLUEPRINTS", None)
+    parser = argparse.ArgumentParser(
+        description="Swarm CLI Launcher\n\nSubcommands:\n"
+                    "  add     : Add a blueprint to the managed directory.\n"
+                    "  list    : List registered blueprints.\n"
+                    "  delete  : Delete a registered blueprint.\n"
+                    "  run     : Run a blueprint by name.\n"
+                    "  install : Install a blueprint as a CLI utility with PyInstaller.\n"
+                    "  uninstall : Uninstall a blueprint and/or its CLI wrapper.\n"
+                    "  migrate : Apply Django database migrations.\n"
+                    "  config  : Manage swarm configuration (LLM and MCP servers).",
+        formatter_class=argparse.RawTextHelpFormatter)
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Available subcommands")
+    
+    parser_add = subparsers.add_parser("add", help="Add a blueprint from a file or directory.")
+    parser_add.add_argument("source", help="Source blueprint file or directory.")
+    parser_add.add_argument("--name", help="Optional blueprint name. If not provided, inferred from filename.")
+    
+    parser_list = subparsers.add_parser("list", help="List registered blueprints.")
+    
+    parser_delete = subparsers.add_parser("delete", help="Delete a registered blueprint by name.")
+    parser_delete.add_argument("name", help="Blueprint name to delete.")
+    
+    parser_run = subparsers.add_parser("run", help="Run a blueprint by name.")
+    parser_run.add_argument("name", help="Blueprint name to run.")
+    parser_run.add_argument("--config", default="~/.swarm/swarm_config.json", help="Path to configuration file.")
+    
+    parser_install = subparsers.add_parser("install", help="Install a blueprint as a CLI utility with PyInstaller.")
+    parser_install.add_argument("name", help="Blueprint name to install as a CLI utility.")
+    
+    parser_uninstall = subparsers.add_parser("uninstall", help="Uninstall a blueprint and/or its CLI wrapper.")
+    parser_uninstall.add_argument("name", help="Blueprint name to uninstall.")
+    parser_uninstall.add_argument("--blueprint-only", action="store_true", help="Remove only the blueprint directory.")
+    parser_uninstall.add_argument("--wrapper-only", action="store_true", help="Remove only the CLI wrapper.")
+    
+    parser_migrate = subparsers.add_parser("migrate", help="Apply Django database migrations.")
+    
+    parser_config = subparsers.add_parser("config", help="Manage swarm configuration (LLM and MCP servers).")
+    parser_config.add_argument("action", choices=["add", "list", "remove"], help="Action to perform on configuration")
+    parser_config.add_argument("--section", required=True, choices=["llm", "mcpServers"], help="Configuration section to manage")
+    parser_config.add_argument("--name", help="Name of the configuration entry (required for add and remove)")
+    parser_config.add_argument("--json", help="JSON string for configuration entry (required for add)")
+    parser_config.add_argument("--config", default="~/.swarm/swarm_config.json", help="Path to configuration file")
+    
+    args = parser.parse_args()
+    ensure_managed_dir()
+    
+    if args.command == "add":
+        add_blueprint(args.source, args.name)
+    elif args.command == "list":
+        list_blueprints()
+    elif args.command == "delete":
+        delete_blueprint(args.name)
+    elif args.command == "run":
+        config_path = os.path.expanduser(args.config)
+        if not os.path.exists(config_path):
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            default_config = {"llm": {}, "mcpServers": {}}
+            with open(config_path, 'w') as f:
+                json.dump(default_config, f, indent=4)
+            print("Default config file created at:", config_path)
+        run_blueprint(args.name)
+    elif args.command == "install":
+        install_blueprint(args.name)
+    elif args.command == "uninstall":
+        uninstall_blueprint(args.name, args.blueprint_only, args.wrapper_only)
+    elif args.command == "migrate":
+        try:
+            subprocess.run(["python", "manage.py", "migrate"], check=True)
+            print("Migrations applied successfully.")
+        except subprocess.CalledProcessError as e:
+            print("Error applying migrations:", e)
+            sys.exit(1)
+    elif args.command == "config":
+        config_path = os.path.expanduser(args.config)
+        if not os.path.exists(config_path):
+            default_conf = {"llm": {}, "mcpServers": {}}
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            with open(config_path, "w") as f:
+                json.dump(default_conf, f, indent=4)
+            print("Default config file created at:", config_path)
+            config = default_conf
+        else:
+            try:
+                with open(config_path, "r") as f:
+                    config = json.load(f)
+            except json.JSONDecodeError:
+                print("Error: Invalid configuration file.")
+                sys.exit(1)
+        section = args.section
+        if args.action == "list":
+            entries = config.get(section, {})
+            if entries:
+                print(f"Entries in {section}:")
+                for key, value in entries.items():
+                    print(f" - {key}: {json.dumps(value, indent=4)}")
+            else:
+                print(f"No entries found in {section}.")
+        elif args.action == "add":
+            if args.section == "mcpServers" and not args.name:
+                if not args.json:
+                    print("Error: --json is required for adding an mcpServers block when --name is omitted.")
+                    sys.exit(1)
+                try:
+                    update_data = json.loads(args.json)
+                except json.JSONDecodeError:
+                    print("Error: --json must be a valid JSON string.")
+                    sys.exit(1)
+                if "mcpServers" not in update_data:
+                    print("Error: JSON block must contain 'mcpServers' key for merging.")
+                    sys.exit(1)
+                config.setdefault("mcpServers", {})
+                config["mcpServers"].update(update_data["mcpServers"])
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+                print("MCP servers updated in configuration.")
+            else:
+                if not args.name or not args.json:
+                    print("Error: --name and --json are required for adding an entry.")
+                    sys.exit(1)
+                try:
+                    entry_data = json.loads(args.json)
+                except json.JSONDecodeError:
+                    print("Error: --json must be a valid JSON string.")
+                    sys.exit(1)
+                config.setdefault(section, {})[args.name] = entry_data
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+                print(f"Entry '{args.name}' added to {section} in configuration.")
+        elif args.action == "remove":
+            if not args.name:
+                print("Error: --name is required for removing an entry.")
+                sys.exit(1)
+            if args.name in config.get(section, {}):
+                del config[section][args.name]
+                with open(config_path, "w") as f:
+                    json.dump(config, f, indent=4)
+                print(f"Entry '{args.name}' removed from {section} in configuration.")
+            else:
+                print(f"Error: Entry '{args.name}' not found in {section}.")
+                sys.exit(1)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

swarm/extensions/launchers/swarm_wrapper.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+import os
+import sys
+import subprocess
+
+MANAGED_DIR = os.path.expanduser("~/.swarm/blueprints")
+BIN_DIR = os.path.expanduser("~/.swarm/bin")
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: swarm-wrapper <cli_name> [args...]")
+        sys.exit(1)
+    
+    cli_name = sys.argv[1]
+    blueprint_name = cli_name  # Default assumption; could map via config if needed
+    blueprint_dir = os.path.join(MANAGED_DIR, blueprint_name)
+    blueprint_file = os.path.join(blueprint_dir, f"blueprint_{blueprint_name}.py")
+    cli_path = os.path.join(BIN_DIR, cli_name)
+    
+    if os.path.exists(cli_path):
+        # Run the installed CLI
+        subprocess.run([cli_path] + sys.argv[2:], check=False)
+    else:
+        print(f"Error: Blueprint '{blueprint_name}' not installed for CLI '{cli_name}'.")
+        print(f"Please install it using: swarm-cli add <path_to_{blueprint_name}> && swarm-cli install {blueprint_name}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

swarm/extensions/mcp/__init__.py

@@ -0,0 +1 @@
+# This is the __init__.py for the 'mcp' package.

swarm/extensions/mcp/cache_utils.py

@@ -0,0 +1,36 @@
+# cache_utils.py
+
+from typing import Any
+
+class DummyCache:
+    """A dummy cache that performs no operations."""
+    def get(self, key: str, default: Any = None) -> Any:
+        return default
+
+    def set(self, key: str, value: Any, timeout: int = None) -> None:
+        pass
+
+def get_cache():
+    """
+    Attempts to retrieve Django's cache. If Django isn't available or configured,
+    returns a DummyCache instance.
+    """
+    try:
+        # Intentionally commented out Django imports to avoid mandatory dependency for now
+        # import django
+        # from django.conf import settings
+        # from django.core.cache import cache as django_cache
+        # from django.core.exceptions import ImproperlyConfigured
+
+        # if not settings.configured:
+        #     # Django settings are not configured; return DummyCache
+        #     return DummyCache()
+
+        # return django_cache
+        # For now, always return DummyCache until Django integration is confirmed/required
+        return DummyCache()
+
+
+    except (ImportError): # Removed ImproperlyConfigured as Django is not imported
+        # Django is not installed or not properly configured; use DummyCache
+        return DummyCache()