solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.2__py3-none-any.whl

solace_agent_mesh/cli/commands/plugin_cmd/catalog_cmd.py

@@ -0,0 +1,139 @@
+import click
+import multiprocessing
+import webbrowser
+import os
+import time
+from pathlib import Path
+from cli.utils import error_exit
+
+config_portal_host = "CONFIG_PORTAL_HOST"
+
+
+def run_flask_plugin_catalog(host, port, shared_data):
+    try:
+        from config_portal.backend.plugin_catalog_server import (
+            create_plugin_catalog_app,
+        )
+        from config_portal.backend.plugin_catalog.constants import (
+            PLUGIN_CATALOG_TEMP_DIR,
+        )
+    except ImportError:
+        click.echo(
+            click.style(
+                "Error: Backend components for plugin catalog not found. Please ensure they are implemented.",
+                fg="red",
+            )
+        )
+        shared_data["status"] = "error_backend_missing"
+        return
+
+    temp_dir = Path(os.path.expanduser(PLUGIN_CATALOG_TEMP_DIR))
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    app = create_plugin_catalog_app(shared_config=shared_data)
+    click.echo(
+        f"Starting Plugin Catalog backend on http://{host}:{port}/?config_mode=pluginCatalog"
+    )
+    try:
+        app.run(host=host, port=port, debug=False)
+    except Exception as e:
+        click.echo(click.style(f"Error starting Flask app: {e}", fg="red"))
+        shared_data["status"] = f"error_flask_start: {e}"
+
+
+@click.command("catalog", help="Launch the SAM Plugin catalog web interface.")
+@click.option(
+    "--port",
+    default=5003,
+    type=int,
+    show_default=True,
+    help="Port to run the plugin catalog web server on.",
+)
+@click.option(
+    "--install-command",
+    "installer_command",
+    help="Command to use to install a python package. Must follow the format 'command {package} args'",
+)
+def catalog(port: int, installer_command: str):
+    """Launches the SAM Plugin catalog web interface."""
+    host = os.environ.get(config_portal_host, "127.0.0.1")
+    try:
+        if installer_command:
+            installer_command.format(package="dummy")  # Test if the command is valid
+            os.environ["SAM_PLUGIN_INSTALL_COMMAND"] = installer_command
+    except (KeyError, ValueError):
+        return error_exit(
+            "Error: The installer command must contain a placeholder '{package}' to be replaced with the actual package name."
+        )
+
+    with multiprocessing.Manager() as manager:
+        shared_data_from_web = manager.dict()
+        shared_data_from_web["status"] = "initializing"
+        _run_flask_target = run_flask_plugin_catalog
+
+        gui_process = multiprocessing.Process(
+            target=_run_flask_target, args=(host, port, shared_data_from_web)
+        )
+        gui_process.start()
+
+        # Give the server a moment to start
+        time.sleep(2)
+
+        if shared_data_from_web.get(
+            "status"
+        ) == "initializing" or shared_data_from_web.get("status", "").startswith(
+            "error_"
+        ):
+            backend_status = shared_data_from_web.get("status", "unknown_error")
+            if backend_status == "initializing":
+                click.echo(
+                    click.style(
+                        f"Plugin catalog backend is starting... If it takes too long, there might be an issue.",
+                        fg="yellow",
+                    )
+                )
+            else:
+                click.echo(
+                    click.style(
+                        f"Plugin catalog backend failed to start properly ({backend_status}). Please check logs.",
+                        fg="red",
+                    )
+                )
+                if gui_process.is_alive():
+                    gui_process.terminate()
+                    gui_process.join(timeout=2)
+                return  # Don't open browser if backend failed
+
+        portal_url = f"http://{host}:{port}/?config_mode=pluginCatalog"
+        click.echo(f"Opening Plugin Catalog at: {portal_url}")
+
+        try:
+            webbrowser.open(portal_url)
+        except Exception:
+            click.echo(
+                click.style(
+                    f"Could not automatically open browser, Please open {portal_url} manually.",
+                    fg="yellow",
+                )
+            )
+
+        try:
+            gui_process.join()
+        except KeyboardInterrupt:
+            click.echo("Plugin Catalog interrupted by user. Shutting down...")
+        finally:
+            if gui_process.is_alive():
+                click.echo("Terminating Plugin Catalog process...")
+                gui_process.terminate()
+                gui_process.join(timeout=5)
+            if gui_process.is_alive():
+                click.echo(
+                    click.style("Forcibly killing Plugin Catalog process.", fg="yellow")
+                )
+                gui_process.kill()
+
+        final_status = shared_data_from_web.get("status", "unknown_exit")
+        if final_status == "shutdown_requested":
+            click.echo("Plugin Catalog closed successfully.")
+        else:
+            click.echo(f"Plugin Catalog exited with status: {final_status}")

solace_agent_mesh/cli/commands/plugin_cmd/create_cmd.py

@@ -0,0 +1,309 @@
+import click
+import pathlib
+from cli.utils import (
+    get_formatted_names,
+    ask_if_not_provided,
+    load_template,
+    error_exit,
+)
+from cli import __version__ as cli_version
+from .official_registry import is_official_plugin
+
+PLUGIN_TYPES = ["agent", "gateway", "custom"]
+
+DEFAULT_PLUGIN_TYPE = "agent"
+DEFAULT_AUTHOR_NAME = "Your Name"
+DEFAULT_AUTHOR_EMAIL = "your.email@example.com"
+DEFAULT_PLUGIN_VERSION = "0.1.0"
+
+
+def ensure_directory_exists(path: pathlib.Path):
+    """Creates a directory if it doesn't exist."""
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def replace_placeholders(content: str, replacements: dict) -> str:
+    """Replaces placeholders in a string."""
+    for placeholder, value in replacements.items():
+        content = content.replace(placeholder, str(value))
+    return content
+
+
+def load_plugin_type_config_template(plugin_type: str, replacement: dict) -> str:
+    """Loads the template for the specified plugin type."""
+    template_name = f"plugin_{plugin_type}_config_template.yaml"
+    try:
+        return load_template(template_name, replace_placeholders, replacement)
+    except FileNotFoundError:
+        error_exit(
+            f"Template file '{template_name}' not found. Please ensure it exists in the templates directory."
+        )
+    except Exception as e:
+        error_exit(f"Error loading template '{template_name}': {e}")
+
+
+def setup_plugin_type_src(plugin_type: str, src_path: pathlib.Path, replacements: dict):
+    """Sets up the source directory for the specified plugin type."""
+
+    # --- Generate __init__.py ---
+    src_init_py_content = ""
+    try:
+        with open(src_path / "__init__.py", "w", encoding="utf-8") as f:
+            f.write(src_init_py_content)
+        click.echo(f"  Created: {src_path / '__init__.py'}")
+    except IOError as e:
+        error_exit(f"Error writing {src_path / '__init__.py'}: {e}")
+
+    if plugin_type == "agent":
+        # --- Generate tools.py ---
+        try:
+            src_tools_py_content = load_template(
+                "plugin_tools_template.py", replace_placeholders, replacements
+            )
+            with open(src_path / "tools.py", "w", encoding="utf-8") as f:
+                f.write(src_tools_py_content)
+            click.echo(f"  Created: {src_path / 'tools.py'}")
+        except FileNotFoundError:
+            error_exit(
+                "Template file 'plugin_tools_template.py' not found. Please ensure it exists in the templates directory."
+            )
+        except IOError as e:
+            error_exit(f"Error writing {src_path / 'tools.py'}: {e}")
+
+    elif plugin_type == "gateway":
+        placeholders = {
+            **replacements,
+            "__GATEWAY_NAME_SNAKE_CASE__": replacements["__PLUGIN_SNAKE_CASE_NAME__"],
+            "__GATEWAY_NAME_PASCAL_CASE__": replacements["__PLUGIN_PASCAL_CASE_NAME__"],
+            "__GATEWAY_NAME_UPPER_CASE__": replacements[
+                "__PLUGIN_UPPER_SNAKE_CASE_NAME__"
+            ],
+            "__GATEWAY_NAME_KEBAB_CASE__": replacements["__PLUGIN_KEBAB_CASE_NAME__"],
+        }
+        # --- Generate app.py ---
+        try:
+            src_gateway_py_content = load_template(
+                "gateway_app_template.py", replace_placeholders, placeholders
+            )
+            with open(src_path / "app.py", "w", encoding="utf-8") as f:
+                f.write(src_gateway_py_content)
+            click.echo(f"  Created: {src_path / 'app.py'}")
+        except FileNotFoundError:
+            error_exit(
+                "Template file 'gateway_app_template.py' not found. Please ensure it exists in the templates directory."
+            )
+        except IOError as e:
+            error_exit(f"Error writing {src_path / 'app.py'}: {e}")
+        # --- Generate gateway_component_template.py ---
+        try:
+            src_gateway_component_py_content = load_template(
+                "gateway_component_template.py", replace_placeholders, placeholders
+            )
+            with open(src_path / "component.py", "w", encoding="utf-8") as f:
+                f.write(src_gateway_component_py_content)
+            click.echo(f"  Created: {src_path / 'component.py'}")
+        except FileNotFoundError:
+            error_exit(
+                "Template file 'gateway_component_template.py' not found. Please ensure it exists in the templates directory."
+            )
+        except IOError as e:
+            error_exit(f"Error writing {src_path / 'component.py'}: {e}")
+
+    elif plugin_type == "custom":
+        # --- generate app.py ---
+        placeholders = {
+            **replacements,
+            "__COMPONENT_PASCAL_CASE_NAME__": replacements[
+                "__PLUGIN_PASCAL_CASE_NAME__"
+            ],
+        }
+        try:
+            src_custom_py_content = load_template(
+                "plugin_custom_template.py", replace_placeholders, placeholders
+            )
+            with open(src_path / "app.py", "w", encoding="utf-8") as f:
+                f.write(src_custom_py_content)
+            click.echo(f"  Created: {src_path / 'app.py'}")
+        except FileNotFoundError:
+            error_exit(
+                "Template file 'plugin_custom_template.py' not found. Please ensure it exists in the templates directory."
+            )
+        except IOError as e:
+            error_exit(f"Error writing {src_path / 'app.py'}: {e}")
+
+
+@click.command("create")
+@click.argument("plugin_name_arg")
+@click.option("--type", "type_opt", help="Plugin type. Options: agent, gateway, custom")
+@click.option("--author-name", "author_name_opt", help="Author's name.")
+@click.option("--author-email", "author_email_opt", help="Author's email.")
+@click.option("--description", "description_opt", help="Plugin description.")
+@click.option("--version", "version_opt", help="Initial plugin version.")
+@click.option(
+    "--skip",
+    is_flag=True,
+    help="Skip interactive prompts and use defaults or provided flags.",
+)
+def create_plugin_cmd(
+    plugin_name_arg: str,
+    type_opt: str,
+    author_name_opt: str,
+    author_email_opt: str,
+    description_opt: str,
+    version_opt: str,
+    skip: bool,
+):
+    """Creates a new SAM plugin directory structure with interactive prompts for metadata."""
+
+    options = {
+        "plugin_name": plugin_name_arg,
+        "type": type_opt,
+        "author_name": author_name_opt,
+        "author_email": author_email_opt,
+        "description": description_opt,
+        "version": version_opt,
+    }
+
+    plugin_formats = get_formatted_names(plugin_name_arg)
+    default_description = f"A SAM plugin: {plugin_formats['SPACED_NAME']}"
+
+    if is_official_plugin(plugin_formats["KEBAB_CASE_NAME"]) or is_official_plugin(
+        plugin_formats["SNAKE_CASE_NAME"]
+    ):
+        error_exit(
+            f"Error: Plugin name '{plugin_name_arg}' conflicts with an official plugin. "
+            f"Please choose a different name."
+        )
+
+    if not skip:
+        click.echo(
+            "Please provide the following details for your new plugin (press Enter to accept defaults):"
+        )
+
+    options["type"] = ask_if_not_provided(
+        options,
+        "type",
+        "Plugin Type",
+        default=DEFAULT_PLUGIN_TYPE,
+        choices=PLUGIN_TYPES,
+        none_interactive=skip,
+    ).lower()
+    if options["type"] not in PLUGIN_TYPES:
+        error_exit(
+            f"Invalid plugin type '{options['type']}'. Must be one of: {', '.join(PLUGIN_TYPES)}."
+        )
+
+    options["author_name"] = ask_if_not_provided(
+        options,
+        "author_name",
+        "Author's Name",
+        default=DEFAULT_AUTHOR_NAME,
+        none_interactive=skip,
+    )
+    options["author_email"] = ask_if_not_provided(
+        options,
+        "author_email",
+        "Author's Email",
+        default=DEFAULT_AUTHOR_EMAIL,
+        none_interactive=skip,
+    )
+    options["description"] = ask_if_not_provided(
+        options,
+        "description",
+        "Plugin Description",
+        default=default_description,
+        none_interactive=skip,
+    )
+    options["version"] = ask_if_not_provided(
+        options,
+        "version",
+        "Initial plugin version",
+        default=DEFAULT_PLUGIN_VERSION,
+        none_interactive=skip,
+    )
+
+    click.echo(f"Creating plugin '{plugin_formats['KEBAB_CASE_NAME']}'...")
+
+    base_plugin_path = pathlib.Path(plugin_formats["KEBAB_CASE_NAME"])
+    src_path = base_plugin_path / "src" / plugin_formats["SNAKE_CASE_NAME"]
+
+    try:
+        ensure_directory_exists(base_plugin_path)
+        ensure_directory_exists(src_path)
+    except Exception as e:
+        error_exit(f"Error creating plugin directories: {e}")
+
+    replacements = {
+        "__PLUGIN_KEBAB_CASE_NAME__": plugin_formats["KEBAB_CASE_NAME"],
+        "__PLUGIN_SNAKE_CASE_NAME__": plugin_formats["SNAKE_CASE_NAME"],
+        "__PLUGIN_UPPER_SNAKE_CASE_NAME__": plugin_formats["SNAKE_UPPER_CASE_NAME"],
+        "__PLUGIN_SPACED_NAME__": plugin_formats["SPACED_NAME"],
+        "__PLUGIN_PASCAL_CASE_NAME__": plugin_formats["PASCAL_CASE_NAME"],
+        "__PLUGIN_AUTHOR_NAME__": options["author_name"],
+        "__PLUGIN_AUTHOR_EMAIL__": options["author_email"],
+        "__PLUGIN_DESCRIPTION__": options["description"],
+        "__PLUGIN_VERSION__": options["version"],
+        "__PLUGIN_META_DATA_TYPE__": options["type"].lower(),
+        "__SAM_VERSION__": cli_version,
+        "__COMPONENT_KEBAB_CASE_NAME__": "__COMPONENT_KEBAB_CASE_NAME__",
+        "__COMPONENT_PASCAL_CASE_NAME__": "__COMPONENT_PASCAL_CASE_NAME__",
+        "__COMPONENT_UPPER_SNAKE_CASE_NAME__": "__COMPONENT_UPPER_SNAKE_CASE_NAME__",
+        "__COMPONENT_SNAKE_CASE_NAME__": "__COMPONENT_SNAKE_CASE_NAME__",
+    }
+
+    # --- Generate config.yaml ---
+    try:
+        config_yaml_content = load_plugin_type_config_template(
+            options["type"], replacements
+        )
+        with open(base_plugin_path / "config.yaml", "w", encoding="utf-8") as f:
+            f.write(config_yaml_content)
+        click.echo(f"  Created: {base_plugin_path / 'config.yaml'}")
+    except IOError as e:
+        error_exit(f"Error writing config.yaml: {e}")
+    except Exception as e:
+        error_exit(f"Error processing config.yaml template: {e}")
+
+    # --- Generate pyproject.toml ---
+    try:
+        pyproject_toml_content = load_template(
+            "plugin_pyproject_template.toml", replace_placeholders, replacements
+        )
+        with open(base_plugin_path / "pyproject.toml", "w", encoding="utf-8") as f:
+            f.write(pyproject_toml_content)
+        click.echo(f"  Created: {base_plugin_path / 'pyproject.toml'}")
+    except FileNotFoundError:
+        error_exit(
+            "Template file 'plugin_pyproject_template.toml' not found. Please ensure it exists in the templates directory."
+        )
+    except IOError as e:
+        error_exit(f"Error writing pyproject.toml: {e}")
+    except Exception as e:
+        error_exit(f"Error processing pyproject.toml template: {e}")
+
+    # --- Generate src directory ---
+    setup_plugin_type_src(options["type"], src_path, replacements)
+
+    # --- Generate README.md ---
+    try:
+        readme_md_content = load_template(
+            "plugin_readme_template.md", replace_placeholders, replacements
+        )
+        with open(base_plugin_path / "README.md", "w", encoding="utf-8") as f:
+            f.write(readme_md_content)
+        click.echo(f"  Created: {base_plugin_path / 'README.md'}")
+    except FileNotFoundError:
+        error_exit(
+            "Template file 'plugin_readme_template.md' not found. Please ensure it exists in the templates directory."
+        )
+    except IOError as e:
+        error_exit(f"Error writing README.md: {e}")
+    except Exception as e:
+        error_exit(f"Error processing README.md template: {e}")
+
+    click.echo(
+        click.style(
+            f"\nPlugin '{plugin_formats['KEBAB_CASE_NAME']}' created successfully at ./{base_plugin_path}",
+            fg="green",
+        )
+    )

solace_agent_mesh/cli/commands/plugin_cmd/official_registry.py

@@ -0,0 +1,175 @@
+import httpx
+from pathlib import Path
+from functools import lru_cache
+from typing import Dict, Optional
+import click
+from config_portal.backend.plugin_catalog.constants import (
+    DEFAULT_OFFICIAL_REGISTRY_URL,
+    OFFICIAL_REGISTRY_GIT_BRANCH,
+)
+
+IGNORE_SUB_DIRS = [".git", "__pycache__", ".venv", "node_modules", ".vscode", ".github"]
+
+
+@lru_cache(maxsize=1)
+def get_official_plugins() -> Dict[str, str]:
+    """
+    Fetches the list of official plugins from the default registry.
+
+    Returns:
+        Dict[str, str]: A mapping of plugin names to their full URLs/paths
+    """
+    registry_url = DEFAULT_OFFICIAL_REGISTRY_URL
+
+    if _is_github_url(registry_url):
+        return _fetch_github_plugins(registry_url, branch=OFFICIAL_REGISTRY_GIT_BRANCH)
+    else:
+        return _fetch_local_plugins(registry_url)
+
+
+def _is_github_url(url: str) -> bool:
+    """Check if the URL is a GitHub repository URL."""
+    return url.startswith("https://github.com/") or url.startswith("http://github.com/")
+
+
+def _fetch_github_plugins(github_url: str, branch: str = None) -> Dict[str, str]:
+    """
+    Fetch plugin list from GitHub repository using the GitHub API.
+
+    Args:
+        github_url: GitHub repository URL
+        branch: Optional branch name to fetch plugins from
+
+    Returns:
+        Dict[str, str]: Mapping of plugin names to their full GitHub URLs
+    """
+    try:
+        if github_url.endswith(".git"):
+            github_url = github_url[:-4]
+
+        parts = (
+            github_url.replace("https://github.com/", "")
+            .replace("http://github.com/", "")
+            .split("/")
+        )
+        if len(parts) < 2:
+            click.echo(
+                click.style(f"Error: Invalid GitHub URL format: {github_url}", fg="red")
+            )
+            return {}
+
+        owner, repo = parts[0], parts[1]
+        api_url = f"https://api.github.com/repos/{owner}/{repo}/contents"
+        if branch:
+            api_url += f"?ref={branch}"
+
+        with httpx.Client() as client:
+            response = client.get(api_url, timeout=10.0)
+            response.raise_for_status()
+
+        contents = response.json()
+
+        plugins = {}
+        for item in contents:
+            if item.get("type") == "dir" and item["name"] not in IGNORE_SUB_DIRS:
+                plugin_name = item["name"]
+                plugin_url = f"git+{github_url}"
+                if branch:
+                    plugin_url += f"@{branch}"
+                plugin_url += f"#subdirectory={plugin_name}"
+                plugins[plugin_name] = plugin_url
+
+        return plugins
+
+    except httpx.RequestError as e:
+        click.echo(click.style(f"Error fetching plugins from GitHub: {e}", fg="red"))
+        return {}
+    except httpx.HTTPStatusError as e:
+        click.echo(
+            click.style(f"HTTP error fetching plugins from GitHub: {e}", fg="red")
+        )
+        return {}
+    except Exception as e:
+        click.echo(
+            click.style(f"Unexpected error fetching plugins from GitHub: {e}", fg="red")
+        )
+        return {}
+
+
+def _fetch_local_plugins(local_path: str) -> Dict[str, str]:
+    """
+    Fetch plugin list from local filesystem.
+
+    Args:
+        local_path: Local directory path
+
+    Returns:
+        Dict[str, str]: Mapping of plugin names to their full local paths
+    """
+    try:
+        path = Path(local_path).expanduser().resolve()
+
+        if not path.exists():
+            click.echo(
+                click.style(
+                    f"Error: Local plugin registry path does not exist: {path}",
+                    fg="red",
+                )
+            )
+            return {}
+
+        if not path.is_dir():
+            click.echo(
+                click.style(
+                    f"Error: Local plugin registry path is not a directory: {path}",
+                    fg="red",
+                )
+            )
+            return {}
+
+        plugins = {}
+        for item in path.iterdir():
+            if item.is_dir() and item.name not in IGNORE_SUB_DIRS:
+                plugin_name = item.name
+                plugins[plugin_name] = str(item)
+
+        return plugins
+
+    except Exception as e:
+        click.echo(
+            click.style(f"Error fetching plugins from local path: {e}", fg="red")
+        )
+        return {}
+
+
+def is_official_plugin(plugin_name: str) -> bool:
+    """
+    Check if a plugin name is an official plugin.
+
+    Args:
+        plugin_name: Name of the plugin to check
+
+    Returns:
+        bool: True if the plugin is official, False otherwise
+    """
+    official_plugins = get_official_plugins()
+    return plugin_name in official_plugins
+
+
+def get_official_plugin_url(plugin_name: str) -> Optional[str]:
+    """
+    Get the full URL/path for an official plugin.
+
+    Args:
+        plugin_name: Name of the official plugin
+
+    Returns:
+        Optional[str]: Full URL/path if plugin is official, None otherwise
+    """
+    # if the plugin_name is a git path, url, or a local path, it can't be an official plugin
+    if plugin_name.startswith(
+        ("git+", "http://", "https://", "file://", "/", "./", "../", "~/")
+    ):
+        return False
+    official_plugins = get_official_plugins()
+    return official_plugins.get(plugin_name)