solace-agent-mesh 0.0.1__py3-none-any.whl → 0.1.1__py3-none-any.whl

solace_agent_mesh/cli/commands/visualizer.py

@@ -0,0 +1,138 @@
+import os
+import http.server
+import socketserver
+import socket
+import click
+import json
+
+from cli.utils import get_cli_root_dir, log_error
+
+
+def get_local_ip():
+    """Get the local IP address of the machine."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        # Connect to an external address, doesn't send any packets, just determines IP
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+    except Exception:
+        ip = "localhost"
+    finally:
+        s.close()
+    return ip
+
+
+def get_wss_url(url: str) -> str:
+    """Get the WSS URL from a WS URL."""
+    if url.startswith("ws://") or url.startswith("wss://"):
+        return url
+    elif url.startswith("tcp://"):
+        url = url.replace("tcp://", "ws://")
+        # Change port to 443
+        if len(url.split(":")) > 1:
+            url = url.split(":")
+            url[-1] = "443"
+            url = ":".join(url)
+    elif url.startswith("tcps://"):
+        url = url.replace("tcps://", "wss://")
+        # Change port to 443
+        if len(url.split(":")) > 1:
+            url = url.split(":")
+            url[-1] = "443"
+            url = ":".join(url)
+    return url
+
+
+def visualizer_command(port, find_unused_port=False, host=False, use_env=False):
+    """Runs a GUI web-based visualizer for inspecting events inside the solace agent mesh."""
+    config = click.get_current_context().obj["solace_agent_mesh"]
+    if use_env:
+        try:
+            from dotenv import load_dotenv
+
+            env_file = config["env_file"]
+            load_dotenv(env_file, override=True)
+        except ImportError:
+            log_error(
+                "Failed to import dotenv. Please install it using 'pip install python-dotenv'"
+            )
+            return 1
+        except Exception as e:
+            log_error(f"Failed to load environment variables. {e}")
+            return 1
+
+    visualizer_directory = os.path.join(get_cli_root_dir(), "assets", "web-visualizer")
+    # Check if the visualizer directory exists
+    if not os.path.exists(visualizer_directory):
+        visualizer_directory = os.path.join(
+            get_cli_root_dir(), "web-visualizer", "dist"
+        )
+        if not os.path.exists(visualizer_directory):
+            log_error("Error: Built Web-Visualizer directory not found.")
+            return 1
+
+    # Find an unused port if the specified port is in use
+    while True:
+        # Check if port is available
+        try:
+            with socketserver.TCPServer(("localhost", port), None) as s:
+                pass
+        except OSError:
+            log_error(f"Error: Port {port} is already in use.")
+            if find_unused_port:
+                port += 1
+                click.echo(f"Trying port {port}...")
+                continue
+            else:
+                return 1
+        break
+
+    # Change the current working directory to the visualizer directory
+    os.chdir(visualizer_directory)
+
+    # Write the Solace broker configuration to a file for client pickup
+    config = {
+        "url": get_wss_url(os.getenv("SOLACE_BROKER_URL", "")),
+        "username": os.getenv("SOLACE_BROKER_USERNAME", ""),
+        "password": os.getenv("SOLACE_BROKER_PASSWORD", ""),
+        "vpn": os.getenv("SOLACE_BROKER_VPN", ""),
+        "namespace": os.getenv("SOLACE_AGENT_MESH_NAMESPACE", ""),
+    }
+    with open("config.json", "w") as f:
+        json.dump(config, f)
+
+    # Set up a handler to serve files from the specified directory
+    handler = http.server.SimpleHTTPRequestHandler
+
+    # Determine the host binding
+    if host:
+        # Bind to '0.0.0.0' to expose to the network
+        bind_address = "0.0.0.0"
+        local_ip = get_local_ip()  # Get local network IP address
+    else:
+        # Bind to 'localhost' to restrict access to the local machine
+        bind_address = "localhost"
+        local_ip = "localhost"
+
+    # Start the server
+    with socketserver.TCPServer((bind_address, port), handler) as httpd:
+        click.echo(f"Serving solace-agent-mesh web-visualizer.")
+        click.echo(
+            click.style(f"\tLocal: http://localhost:{port}", bold=True, fg="blue")
+        )
+        click.echo(
+            click.style(
+                "\tNetwork: "
+                + (f"http://{local_ip}:{port}" if host else "use --host to expose"),
+                bold=True,
+                fg="blue",
+            )
+        )
+        click.echo("Press Ctrl+C to stop the server.")
+        try:
+            httpd.serve_forever()
+        except KeyboardInterrupt:
+            click.echo("Shutting down server.")
+            httpd.shutdown()
+        finally:
+            os.remove("config.json")

solace_agent_mesh/cli/config.py

@@ -0,0 +1,81 @@
+import os
+from ruamel.yaml import YAML
+
+# Initialize a YAML object
+yaml = YAML()
+yaml.preserve_quotes = True  # To preserve quotes in the YAML
+
+from cli.utils import merge_dicts, load_template, remove_duplicate
+
+
+class Config:
+    default_config_file = "solace-agent-mesh-default.yaml"
+    user_config_file = "solace-agent-mesh.yaml"
+    user_plugin_config_file = "solace-agent-mesh-plugin.yaml"
+    default_plugin_config_file = "solace-agent-mesh-plugin-default.yaml"
+
+    @staticmethod
+    def get_default_config():
+        loaded_config = load_template(Config.default_config_file)
+        return yaml.load(loaded_config)
+
+    @staticmethod
+    def get_default_plugin_config():
+        loaded_config = load_template(Config.default_plugin_config_file)
+        return yaml.load(loaded_config)
+
+    @staticmethod
+    def get_user_config(config_file=None):
+        config_file_path = config_file or Config.user_config_file
+        if os.path.exists(config_file_path):
+            with open(config_file_path, "r", encoding="utf-8") as f:
+                return yaml.load(f) or {}
+        return {}
+
+    @staticmethod
+    def get_user_plugin_config(config_file=None):
+        config_file_path = config_file or Config.user_plugin_config_file
+        if os.path.exists(config_file_path):
+            with open(config_file_path, "r", encoding="utf-8") as f:
+                return yaml.load(f) or {}
+        return {}
+
+    @staticmethod
+    def get_config(config_file=None):
+        user_config = Config.get_user_config(config_file)
+        default_config = Config.get_default_config()
+        # Merge user config with default config
+        merged_config = merge_dicts(default_config, user_config)
+        merged_config["solace_agent_mesh"]["built_in"]["agents"] = remove_duplicate(
+            merged_config["solace_agent_mesh"]["built_in"]["agents"],
+            lambda agent: agent.get("name"),
+        )
+        return merged_config
+
+    @staticmethod
+    def get_plugin_config(config_file=None):
+        user_config = Config.get_user_plugin_config(config_file)
+        default_config = Config.get_default_plugin_config()
+        # Merge user config with default config
+        merged_config = merge_dicts(default_config, user_config)
+        return merged_config
+
+    @staticmethod
+    def is_plugin_project():
+        return os.path.exists(Config.user_plugin_config_file)
+
+    @staticmethod
+    @staticmethod
+    def write_config(config, path=None):
+        if not path:
+            path = Config.user_config_file
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(config, f)
+
+    @staticmethod
+    def load_config(path=None):
+        if not path:
+            path = Config.user_config_file
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                return yaml.load(f)

solace_agent_mesh/cli/main.py

@@ -0,0 +1,306 @@
+import click
+import os
+import sys
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.dirname(SCRIPT_DIR))
+
+from cli.config import Config
+from cli.commands.config import config_command
+from cli.commands.add import add_command
+from cli.commands.build import build_command
+from cli.commands.run import run_command
+from cli.commands.visualizer import visualizer_command
+from cli.commands.init import init_command
+from cli.commands.plugin import plugin_command
+from cli.commands.chat import chat_command
+from cli import __version__
+
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.version_option(__version__)
+@click.pass_context
+@click.option(
+    "-c",
+    "--config-file",
+    type=click.Path(),
+    help="Path to solace-agent-mesh.yaml file. By default, it looks for the file in the current directory.",
+)
+def cli(ctx=None, config_file=None):
+    """Solace Agent Mesh CLI application.
+
+    This cli application can be used to create, build, and run Solace Agent Mesh systems.
+    """
+    try:
+        ctx.obj = Config.get_config(config_file)
+    except Exception as e:
+        click.echo(f"Failed to load configurations: {e}")
+        sys.exit(1)
+
+
+@cli.group()
+def add():
+    """
+    Creates a template for an agent or gateway.
+    """
+    pass
+
+
+@cli.command()
+@click.option(
+    "-y", default=False, is_flag=True, help="Skip confirmation and build immediately."
+)
+@click.option(
+    "-N",
+    "--no-init",
+    default=False,
+    is_flag=True,
+    help="Skip running the init command if not already run.",
+)
+def build(y, no_init):
+    """Build the Solace Agent Mesh application."""
+    return build_command(skip_without_asking=y, no_init=no_init)
+
+
+@cli.command()
+@click.option(
+    "-e",
+    "--use-env",
+    default=False,
+    is_flag=True,
+    help="Loads the environment variables file defined in the config.",
+)
+@click.option(
+    "-s",
+    "--skip",
+    help="Exclude file from the list of files to run.",
+    multiple=True,
+)
+@click.argument("files", nargs=-1, type=click.Path())
+@click.option(
+    "-q",
+    "--quick-build",
+    default=False,
+    is_flag=True,
+    help="Uses default behavior for init and build command if not have already been run.",
+)
+@click.option(
+    "-i",
+    "--ignore-build",
+    default=False,
+    is_flag=True,
+    help="Skips running the build command if build directory does not exist. Mutally exclusive with --force-build.",
+)
+@click.option(
+    "-b",
+    "--force-build",
+    default=False,
+    is_flag=True,
+    help="Runs the build command first regardless of the build directory. Mutually exclusive with --ignore-build.",
+)
+def run(use_env, files, skip, quick_build, ignore_build, force_build):
+    """Run the Solace Agent Mesh application.
+
+    FILES: Config files to run. Uses all the yaml files in the build directory if not provided.
+    """
+    return run_command(
+        use_env, list(files), list(skip), quick_build, ignore_build, force_build
+    )
+
+
+@cli.command()
+def config():
+    """Update the config file with newly added default settings."""
+    return config_command()
+
+
+@cli.command()
+@click.option(
+    "-p", "--port", default=8080, help="Port number to run the visualizer on."
+)
+@click.option(
+    "-f",
+    "--find-unused-port",
+    default=False,
+    is_flag=True,
+    help="If port is in use, Uses the next available port.",
+)
+@click.option(
+    "-h",
+    "--host",
+    default=False,
+    is_flag=True,
+    help="Expose the visualizer to the network.",
+)
+@click.option(
+    "-e",
+    "--use-env",
+    default=False,
+    is_flag=True,
+    help="Loads the environment variables file defined in the config.",
+)
+def visualize(port, find_unused_port, host, use_env):
+    """Runs a web GUI visualizer for inspecting stimuli inside the solace agent mesh."""
+    return visualizer_command(port, find_unused_port, host, use_env)
+
+
+@cli.command()
+@click.option(
+    "--skip",
+    is_flag=True,
+    default=False,
+    help="Non-interactive mode. Skip all the prompts, Uses provided options and default values.",
+)
+@click.option(
+    "--namespace",
+    help="project namespace",
+)
+@click.option(
+    "--config-dir",
+    help="base directory for config files",
+)
+@click.option(
+    "--module-dir",
+    help="base directory for python modules",
+)
+@click.option(
+    "--build-dir",
+    help="base directory for the build output",
+)
+@click.option(
+    "--env-file",
+    help="environment file path",
+)
+@click.option(
+    "--broker-type",
+    help="broker type to use (container, solace, dev_broker)",
+)
+@click.option(
+    "--broker-url",
+    help="Solace broker url endpoint",
+)
+@click.option(
+    "--broker-vpn",
+    help="Solace broker vpn name",
+)
+@click.option(
+    "--broker-username",
+    help="Solace broker username",
+)
+@click.option(
+    "--broker-password",
+    help="Solace broker password",
+)
+@click.option(
+    "--container-engine",
+    help="container engine to use (podman, docker)",
+)
+@click.option(
+    "--llm-model-name",
+    help="LLM model name to use",
+)
+@click.option(
+    "--llm-endpoint-url",
+    help="LLM endpoint URL",
+)
+@click.option(
+    "--llm-api-key",
+    help="LLM API Key",
+)
+@click.option(
+    "--embedding-model-name",
+    help="Embedding model name to use",
+)
+@click.option(
+    "--embedding-endpoint-url",
+    help="Embedding endpoint URL",
+)
+@click.option(
+    "--embedding-api-key",
+    help="Embedding API Key",
+)
+@click.option(
+    "--built-in-agent",
+    help="Built-in agents to use, multiple values can be provided (global, image_processing, ...)",
+    multiple=True,
+)
+@click.option(
+    "--file-service-provider",
+    help="File service provider to use (volume, bucket)",
+)
+@click.option(
+    "--file-service-config",
+    help="Key value pairs for file service configuration (eg directory=/path/to/volume)",
+    multiple=True,
+)
+@click.option(
+    "--env-var",
+    help="Adds Key value pairs to the env file (eg key=value)",
+    multiple=True,
+)
+@click.option(
+    "--rest-api-enabled",
+    is_flag=True,
+    default=None,
+    help="Enable/disable REST API Interface",
+)
+@click.option(
+    "--rest-api-server-input-port",
+    help="REST API server port",
+)
+@click.option(
+    "--rest-api-server-host",
+    help="REST API server host",
+)
+@click.option(
+    "--rest-api-server-input-endpoint",
+    help="REST API endpoint",
+)
+@click.option(
+    "--rest-api-gateway-name",
+    help="Name for the REST API gateway",
+)
+@click.option(
+    "--webui-enabled",
+    is_flag=True,
+    default=None,
+    help="Enable/disable Web UI",
+)
+@click.option(
+    "--webui-listen-port",
+    help="Web UI server listen port",
+)
+@click.option(
+    "--webui-host",
+    help="Web UI server host",
+)
+def init(**kwargs):
+    """
+    Initialize the Solace Agent Mesh application.
+    """
+    return init_command(kwargs)
+
+
+@cli.group()
+def plugin():
+    """Manage plugins - Create, build, add, and remove plugins."""
+    pass
+
+
+@cli.group()
+def chat():
+    """Start chatting with the Solace Agent Mesh application."""
+    pass
+
+
+def main():
+    add_command(add)
+    plugin_command(plugin)
+    chat_command(chat)
+    cli()
+
+
+if __name__ == "__main__":
+    main()