solace-agent-mesh 1.11.2__py3-none-any.whl

solace_agent_mesh/cli/commands/init_cmd/webui_gateway_step.py

@@ -0,0 +1,215 @@
+import click
+from pathlib import Path
+
+from ...utils import ask_if_not_provided, ask_yes_no_question, load_template
+
+
+WEBUI_GATEWAY_DEFAULTS = {
+    "webui_frontend_welcome_message": "",
+    "webui_frontend_bot_name": "Solace Agent Mesh",
+    "webui_frontend_logo_url": "",
+    "webui_frontend_collect_feedback": False,
+    "webui_session_secret_key": "please_change_me_in",
+    "webui_fastapi_host": "127.0.0.1",
+    "webui_fastapi_port": 8000,
+    "webui_fastapi_https_port": 8443,
+    "webui_ssl_keyfile": "",
+    "webui_ssl_certfile": "",
+    "webui_ssl_keyfile_password": "",
+    "webui_enable_embed_resolution": True,
+}
+
+
+def create_webui_gateway_config(
+    project_root: Path, options: dict, skip_interactive: bool, default_values: dict
+) -> bool:
+    """
+    Gathers WebUI Gateway options and creates the configuration file (configs/gateways/webui.yaml)
+    if the user opts in. It customizes the template based on user input or defaults.
+    Returns True on success or if skipped, False on failure.
+    """
+    click.echo("Configuring Web UI Gateway options...")
+
+    add_gateway = options.get("add_webui_gateway")
+    if not skip_interactive and add_gateway is None:
+        add_gateway = default_values.get("add_webui_gateway", True)
+    elif add_gateway is None:
+        add_gateway = default_values.get("add_webui_gateway", True)
+
+    options["add_webui_gateway"] = add_gateway
+
+    if not add_gateway:
+        click.echo(click.style("  Skipping Web UI Gateway file creation.", fg="yellow"))
+        return True
+
+    options["webui_session_secret_key"] = ask_if_not_provided(
+        options,
+        "webui_session_secret_key",
+        "Enter Web UI Session Secret Key",
+        default=default_values.get(
+            "webui_session_secret_key",
+            WEBUI_GATEWAY_DEFAULTS["webui_session_secret_key"],
+        ),
+        none_interactive=skip_interactive,
+        hide_input=True,
+    )
+    options["webui_fastapi_host"] = ask_if_not_provided(
+        options,
+        "webui_fastapi_host",
+        "Enter Web UI FastAPI Host",
+        default=default_values.get(
+            "webui_fastapi_host", WEBUI_GATEWAY_DEFAULTS["webui_fastapi_host"]
+        ),
+        none_interactive=skip_interactive,
+    )
+    options["webui_fastapi_port"] = ask_if_not_provided(
+        options,
+        "webui_fastapi_port",
+        "Enter Web UI FastAPI Port",
+        default=default_values.get(
+            "webui_fastapi_port", WEBUI_GATEWAY_DEFAULTS["webui_fastapi_port"]
+        ),
+        none_interactive=skip_interactive,
+    )
+    options["webui_fastapi_https_port"] = ask_if_not_provided(
+        options,
+        "webui_fastapi_https_port",
+        "Enter Web UI FastAPI HTTPS Port",
+        default=default_values.get("webui_fastapi_https_port", 8443),
+        none_interactive=skip_interactive,
+    )
+    options["webui_enable_embed_resolution"] = ask_if_not_provided(
+        options,
+        "webui_enable_embed_resolution",
+        "Enable Embed Resolution for Web UI? (true/false)",
+        default=default_values.get(
+            "webui_enable_embed_resolution",
+            WEBUI_GATEWAY_DEFAULTS["webui_enable_embed_resolution"],
+        ),
+        none_interactive=skip_interactive,
+        is_bool=True,
+    )
+    options["webui_ssl_keyfile"] = ask_if_not_provided(
+        options,
+        "webui_ssl_keyfile",
+        "Enter SSL Key File Path",
+        default=default_values.get("webui_ssl_keyfile", ""),
+        none_interactive=skip_interactive,
+    )
+    options["webui_ssl_certfile"] = ask_if_not_provided(
+        options,
+        "webui_ssl_certfile",
+        "Enter SSL Certificate File Path",
+        default=default_values.get("webui_ssl_certfile", ""),
+        none_interactive=skip_interactive,
+    )
+    options["webui_ssl_keyfile_password"] = ask_if_not_provided(
+        options,
+        "webui_ssl_keyfile_password",
+        "Enter SSL Key File Passphrase",
+        default=default_values.get("webui_ssl_keyfile_password", ""),
+        none_interactive=skip_interactive,
+        hide_input=True,
+    )
+
+    options["webui_frontend_welcome_message"] = ask_if_not_provided(
+        options,
+        "webui_frontend_welcome_message",
+        "Enter Frontend Welcome Message for Web UI",
+        default=default_values.get(
+            "webui_frontend_welcome_message",
+            WEBUI_GATEWAY_DEFAULTS["webui_frontend_welcome_message"],
+        ),
+        none_interactive=skip_interactive,
+    )
+    options["webui_frontend_bot_name"] = ask_if_not_provided(
+        options,
+        "webui_frontend_bot_name",
+        "Enter Frontend Bot Name for Web UI",
+        default=default_values.get(
+            "webui_frontend_bot_name", WEBUI_GATEWAY_DEFAULTS["webui_frontend_bot_name"]
+        ),
+        none_interactive=skip_interactive,
+    )
+    options["webui_frontend_logo_url"] = ask_if_not_provided(
+        options,
+        "webui_frontend_logo_url",
+        "Enter Frontend Logo URL (PNG, SVG, JPG or data URI)",
+        default=default_values.get(
+            "webui_frontend_logo_url", WEBUI_GATEWAY_DEFAULTS["webui_frontend_logo_url"]
+        ),
+        none_interactive=skip_interactive,
+    )
+    options["webui_frontend_collect_feedback"] = ask_if_not_provided(
+        options,
+        "webui_frontend_collect_feedback",
+        "Enable Frontend Feedback Collection for Web UI? (true/false)",
+        default=default_values.get(
+            "webui_frontend_collect_feedback",
+            WEBUI_GATEWAY_DEFAULTS["webui_frontend_collect_feedback"],
+        ),
+        none_interactive=skip_interactive,
+        is_bool=True,
+    )
+
+    click.echo("Creating Web UI Gateway configuration file...")
+    destination_path = project_root / "configs" / "gateways" / "webui.yaml"
+
+    try:
+        template_content = load_template("webui.yaml")
+        
+        session_service_lines = [
+            f'type: "sql"',
+            'database_url: "${WEB_UI_GATEWAY_DATABASE_URL, sqlite:///webui_gateway.db}"',
+            f'default_behavior: "PERSISTENT"',
+        ]
+        session_service_block = "\n" + "\n".join(
+            [f"        {line}" for line in session_service_lines]
+        )
+        
+        replacements = {
+            "__FRONTEND_WELCOME_MESSAGE__": str(
+                options.get("webui_frontend_welcome_message", '${FRONTEND_WELCOME_MESSAGE, "Hello, how can I assist you?"}')
+            ),
+            "__FRONTEND_BOT_NAME__": str(
+                options.get("webui_frontend_bot_name", "${FRONTEND_BOT_NAME, Solace Agent Mesh}")
+            ),
+            "__FRONTEND_LOGO_URL__": str(
+                options.get("webui_frontend_logo_url", "${WEBUI_FRONTEND_LOGO_URL}")
+            ),
+            "__FRONTEND_COLLECT_FEEDBACK__": str(
+                options.get("webui_frontend_collect_feedback", "${FRONTEND_COLLECT_FEEDBACK, false}")
+            ).lower(),
+            "__SESSION_SERVICE__": session_service_block,
+        }
+
+        modified_content = template_content
+        for placeholder, value in replacements.items():
+            if value is not None:
+                modified_content = modified_content.replace(placeholder, str(value))
+
+        destination_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(destination_path, "w", encoding="utf-8") as f:
+            f.write(modified_content)
+
+        click.echo(f"  Created: {destination_path.relative_to(project_root)}")
+        return True
+
+    except FileNotFoundError:
+        click.echo(click.style("Error: Template file not found.", fg="red"), err=True)
+        return False
+    except IOError as e:
+        click.echo(
+            click.style(f"Error writing file {destination_path}: {e}", fg="red"),
+            err=True,
+        )
+        return False
+    except Exception as e:
+        click.echo(
+            click.style(
+                f"An unexpected error occurred during Web UI Gateway configuration: {e}",
+                fg="red",
+            ),
+            err=True,
+        )
+        return False

solace_agent_mesh/cli/commands/plugin_cmd/__init__.py

@@ -0,0 +1,20 @@
+import click
+
+from .create_cmd import create_plugin_cmd
+from .install_cmd import install_plugin_cmd
+from .add_cmd import add_plugin_component_cmd
+from .build_cmd import build_plugin_cmd
+from .catalog_cmd import catalog
+
+
+@click.group("plugin")
+def plugin():
+    """Manage SAM plugins: create, add components, and build."""
+    pass
+
+
+plugin.add_command(create_plugin_cmd, name="create")
+plugin.add_command(install_plugin_cmd, name="install")
+plugin.add_command(add_plugin_component_cmd, name="add")
+plugin.add_command(build_plugin_cmd, name="build")
+plugin.add_command(catalog, name="catalog")

solace_agent_mesh/cli/commands/plugin_cmd/add_cmd.py

@@ -0,0 +1,137 @@
+import click
+import pathlib
+import toml
+
+from cli.utils import get_formatted_names, error_exit
+from .install_cmd import install_plugin
+
+
+def ensure_directory_exists(path: pathlib.Path):
+    """Creates a directory if it doesn't exist."""
+    path.mkdir(parents=True, exist_ok=True)
+
+def _get_plugin_type_from_pyproject(source_path: pathlib.Path) -> str | None:
+    """Reads pyproject.toml from source_path and returns the plugin type."""
+    pyproject_path = source_path / "pyproject.toml"
+    if not pyproject_path.is_file():
+        click.echo(
+            click.style(
+                f"Warning: pyproject.toml not found at {pyproject_path}. Cannot determine plugin type automatically.",
+                fg="yellow",
+            )
+        )
+        return None
+    try:
+        with open(pyproject_path, "r", encoding="utf-8") as f:
+            data = toml.load(f)
+        project_name = data.get("project", {}).get("name", "").strip().replace("-", "_")
+        plugin_type = (
+            data.get("tool", {}).get(project_name, {}).get("metadata", {}).get("type")
+        )
+        if plugin_type:
+            return plugin_type.strip()
+        click.echo(
+            click.style(
+                f"Warning: Could not find plugin type for '{project_name}' in {pyproject_path}.",
+                fg="yellow",
+            )
+        )
+        return None
+    except Exception as e:
+        click.echo(click.style(f"Error parsing {pyproject_path}: {e}", fg="red"))
+        return None
+
+
+
+@click.command("add")
+@click.argument("component_name")
+@click.option(
+    "--plugin",
+    "plugin_source",
+    required=True,
+    help="Plugin source: installed module name, local path, or Git URL.",
+)
+@click.option(
+    "--install-command",
+    "installer_command",
+    help="Command to use to install a python package. Must follow the format 'command {package} args', by default 'pip3 install {package}'. Can also be set through the environment variable SAM_PLUGIN_INSTALL_COMMAND.",
+)
+def add_plugin_component_cmd(
+    component_name: str, plugin_source: str, installer_command: str | None = None
+):
+    """Installs the plugin and creates a new component instance from a specified plugin source."""
+
+    click.echo(
+        f"Attempting to add component '{component_name}' using plugin source '{plugin_source}'..."
+    )
+
+    module_name, plugin_path = install_plugin(plugin_source, installer_command)
+
+    plugin_config_path = plugin_path / "config.yaml"
+    plugin_pyproject_path = plugin_path / "pyproject.toml"
+
+    if not plugin_pyproject_path.is_file():
+        return error_exit(
+            f"Error: pyproject.toml not found in plugin '{module_name}' at expected path {plugin_pyproject_path}"
+        )
+
+    if not plugin_config_path.is_file():
+        return error_exit(
+            f"Error: config.yaml not found in plugin '{module_name}' at expected path {plugin_config_path}"
+        )
+    try:
+        plugin_config_content = plugin_config_path.read_text(encoding="utf-8")
+    except Exception as e:
+        return error_exit(
+            f"Error reading plugin config.yaml from {plugin_config_path}: {e}"
+        )
+
+    component_formats = get_formatted_names(component_name)
+
+    component_replacements = {
+        "__COMPONENT_SNAKE_CASE_NAME__": component_formats["SNAKE_CASE_NAME"],
+        "__COMPONENT_UPPER_SNAKE_CASE_NAME__": component_formats[
+            "SNAKE_UPPER_CASE_NAME"
+        ],
+        "__COMPONENT_KEBAB_CASE_NAME__": component_formats["KEBAB_CASE_NAME"],
+        "__COMPONENT_PASCAL_CASE_NAME__": component_formats["PASCAL_CASE_NAME"],
+        "__COMPONENT_SPACED_NAME__": component_formats["SPACED_NAME"],
+        "__COMPONENT_SPACED_CAPITALIZED_NAME__": component_formats[
+            "SPACED_CAPITALIZED_NAME"
+        ]
+    }
+
+    processed_config_content = plugin_config_content
+    for placeholder, value in component_replacements.items():
+        processed_config_content = processed_config_content.replace(placeholder, value)
+
+    plugin_type = _get_plugin_type_from_pyproject(plugin_path)
+    if plugin_type == "agent" or plugin_type == "tool":
+        target_dir = pathlib.Path("configs/agents")
+    elif plugin_type == "gateway":
+        target_dir = pathlib.Path("configs/gateways")
+    else:
+        target_dir = pathlib.Path("configs/plugins")
+
+    try:
+        ensure_directory_exists(target_dir)
+    except Exception as e:
+        return error_exit(f"Error creating target directory {target_dir}: {e}")
+
+    target_filename = f"{component_formats['KEBAB_CASE_NAME']}.yaml"
+    target_path = target_dir / target_filename
+
+    try:
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(processed_config_content)
+        click.echo(f"  Created component configuration: {target_path}")
+        click.echo(
+            click.style(
+                f"Component '{component_name}' created successfully from plugin '{module_name}'.",
+                fg="green",
+            )
+        )
+    except IOError as e:
+        return error_exit(
+            f"Error writing component configuration file {target_path}: {e}"
+        )

solace_agent_mesh/cli/commands/plugin_cmd/build_cmd.py

@@ -0,0 +1,86 @@
+import click
+import subprocess
+import os
+from pathlib import Path
+from cli.utils import error_exit
+
+
+@click.command("build")
+@click.argument(
+    "plugin_path_arg",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+    default=".",
+    metavar="PLUGIN_PATH",
+)
+def build_plugin_cmd(plugin_path_arg: str):
+    """
+    Builds the SAM plugin in the specified directory (defaults to current directory).
+    This command requires the 'build' package to be installed (pip install build).
+    """
+    target_path = Path(plugin_path_arg)
+    pyproject_file = target_path / "pyproject.toml"
+
+    if not pyproject_file.is_file():
+        click.echo(
+            click.style(f"Error: pyproject.toml not found in {target_path}", fg="red")
+        )
+        click.echo(
+            click.style(
+                "Please ensure you are in the root directory of the plugin or provide the correct path.",
+                fg="yellow",
+            )
+        )
+        error_exit()
+
+    click.echo(f"Building plugin in {target_path}...")
+    click.echo(
+        click.style(
+            "Note: This command uses 'python -m build'. Ensure 'build' package is installed ('pip install build').",
+            fg="cyan",
+        )
+    )
+
+    original_cwd = Path.cwd()
+    error_exit_msg = None
+    try:
+        os.chdir(target_path)
+        process = subprocess.run(
+            ["python", "-m", "build"], capture_output=True, text=True, check=False
+        )
+
+        if process.stdout:
+            click.echo("--- Build Output ---")
+            click.echo(process.stdout)
+            click.echo("--- End of Build Output ---")
+
+        if process.stderr:
+            click.echo(click.style("--- Build Errors/Warnings ---", fg="yellow"))
+            click.echo(click.style(process.stderr, fg="yellow"))
+            click.echo(click.style("--- End of Build Errors/Warnings ---", fg="yellow"))
+
+        if process.returncode == 0:
+            dist_path = target_path / "dist"
+            click.echo(
+                click.style(
+                    f"Plugin built successfully! Artifacts are in: {dist_path}",
+                    fg="green",
+                )
+            )
+            if dist_path.exists() and dist_path.is_dir():
+                click.echo("Generated files:")
+                for item in sorted(dist_path.iterdir()):
+                    click.echo(f"  - {item.name}")
+        else:
+            error_exit_msg = (
+                f"Error: 'python -m build' failed with exit code {process.returncode}."
+            )
+            error_exit_msg += "\nPlease check the build output above for details."
+
+    except FileNotFoundError:
+        error_exit_msg = f"Error: Python executable not found. Ensure Python is installed and in your PATH."
+    except Exception as e:
+        error_exit_msg = f"An unexpected error occurred during the build process: {e}"
+    finally:
+        os.chdir(original_cwd)
+        if error_exit_msg:
+            error_exit(error_exit_msg)

solace_agent_mesh/cli/commands/plugin_cmd/catalog_cmd.py

@@ -0,0 +1,144 @@
+import click
+import multiprocessing
+import webbrowser
+import os
+import time
+from pathlib import Path
+from cli.utils import error_exit, wait_for_server
+
+
+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(
+    "-p",
+    "--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:
+            if wait_for_server(portal_url):
+                webbrowser.open(portal_url)
+            else:
+                raise TimeoutError("Server did not start in time.")
+        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}")