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

solace_agent_mesh/config_portal/backend/server.py

@@ -2,273 +2,642 @@ import sys
 from flask import Flask, jsonify, request, send_from_directory, send_file
 from flask_cors import CORS
 import os
-import sys
-from solace_agent_mesh.config_portal.backend.common import default_options, CONTAINER_RUN_COMMAND 
+from pathlib import Path
+from .common import (
+    INIT_DEFAULT,
+    CONTAINER_RUN_COMMAND,
+    AGENT_DEFAULTS,
+    GATEWAY_DEFAULTS,
+    USE_DEFAULT_SHARED_ARTIFACT,
+)
 from cli.utils import get_formatted_names
+
 import shutil
 import litellm
-from solace.messaging.messaging_service import MessagingService
-from solace.messaging.config.retry_strategy import RetryStrategy
-from solace.messaging.errors.pubsubplus_client_error import PubSubPlusClientError
-import certifi
-
-litellm.suppress_debug_info = True
+from collections import defaultdict
 
-#disable flask startup banner
 import logging
-log = logging.getLogger('werkzeug')
+
+log = logging.getLogger("werkzeug")
 log.disabled = True
-cli = sys.modules['flask.cli']
-cli.show_server_banner = lambda *x: None
+cli_flask = sys.modules["flask.cli"]
+cli_flask.show_server_banner = lambda *x: None
+litellm.suppress_debug_info = True
+
+config_portal_host = "CONFIG_PORTAL_HOST"
+
+try:
+    from solace_agent_mesh.agent.tools.registry import tool_registry
+except ImportError as err:
+    try:
+        from src.solace_agent_mesh.agent.tools.registry import tool_registry
+    except ImportError as exc:
+        log.error(
+            "Importing tool_registry failed. Ensure all the dependencies are installed and the import paths are correct, Error: %s",
+            str(err),
+        )
+        raise err from exc
+
+def get_agent_field_definitions():
+    fields = []
+    fields.append(
+        {
+            "name": "agent_name",
+            "label": "Agent Name",
+            "type": "text",
+            "required": True,
+            "description": "Unique name for this agent (will be CamelCased).",
+            "default": "MyNewAgent",
+        }
+    )
+    fields.append(
+        {
+            "name": "namespace",
+            "label": "A2A Namespace",
+            "type": "text",
+            "default": AGENT_DEFAULTS["namespace"],
+            "description": "A2A topic namespace (e.g., myorg/dev). Can use ${NAMESPACE}.",
+        }
+    )
+    fields.append(
+        {
+            "name": "supports_streaming",
+            "label": "Supports Streaming",
+            "type": "boolean",
+            "default": AGENT_DEFAULTS["supports_streaming"],
+        }
+    )
+    fields.append(
+        {
+            "name": "model_type",
+            "label": "Model Type",
+            "type": "select",
+            "options": [
+                "planning",
+                "general",
+                "image_gen",
+                "report_gen",
+                "multimodal",
+                "gemini_pro",
+            ],
+            "default": AGENT_DEFAULTS["model_type"],
+        }
+    )
+    fields.append(
+        {
+            "name": "instruction",
+            "label": "Instruction",
+            "type": "textarea",
+            "default": AGENT_DEFAULTS["instruction"].replace(
+                "__AGENT_NAME__", "__AGENT_NAME__"
+            ),
+            "description": "System instruction for the agent.",
+        }
+    )
+
+    fields.append(
+        {
+            "name": "session_service_type",
+            "label": "Session Service Type",
+            "type": "select",
+            "options": ["memory", "vertex_rag"],
+            "default": AGENT_DEFAULTS["session_service_type"],
+        }
+    )
+    fields.append(
+        {
+            "name": "session_service_behavior",
+            "label": "Session Service Behavior",
+            "type": "select",
+            "options": ["PERSISTENT", "RUN_BASED"],
+            "default": AGENT_DEFAULTS["session_service_behavior"],
+        }
+    )
+
+    fields.append(
+        {
+            "name": "artifact_service_type",
+            "label": "Artifact Service Type",
+            "type": "select",
+            "options": ["memory", "filesystem", "gcs"],
+            "default": AGENT_DEFAULTS["artifact_service_type"],
+        }
+    )
+    fields.append(
+        {
+            "name": "artifact_service_base_path",
+            "label": "Artifact Service Base Path (if filesystem)",
+            "type": "text",
+            "default": AGENT_DEFAULTS["artifact_service_base_path"],
+            "condition": {"field": "artifact_service_type", "value": "filesystem"},
+        }
+    )
+    fields.append(
+        {
+            "name": "artifact_service_scope",
+            "label": "Artifact Service Scope",
+            "type": "select",
+            "options": ["namespace", "app", "custom"],
+            "default": AGENT_DEFAULTS["artifact_service_scope"],
+        }
+    )
+
+    fields.append(
+        {
+            "name": "artifact_handling_mode",
+            "label": "Artifact Handling Mode",
+            "type": "select",
+            "options": ["ignore", "embed", "reference"],
+            "default": AGENT_DEFAULTS["artifact_handling_mode"],
+        }
+    )
+    fields.append(
+        {
+            "name": "enable_embed_resolution",
+            "label": "Enable Embed Resolution",
+            "type": "boolean",
+            "default": AGENT_DEFAULTS["enable_embed_resolution"],
+        }
+    )
+    fields.append(
+        {
+            "name": "enable_artifact_content_instruction",
+            "label": "Enable Artifact Content Instruction",
+            "type": "boolean",
+            "default": AGENT_DEFAULTS["enable_artifact_content_instruction"],
+        }
+    )
+    fields.append(
+        {
+            "name": "agent_card_description",
+            "label": "Agent Card Description",
+            "type": "textarea",
+            "default": AGENT_DEFAULTS["agent_card_description"],
+        }
+    )
+    fields.append(
+        {
+            "name": "agent_card_default_input_modes_str",
+            "label": "Agent Card Default Input Modes (comma-sep)",
+            "type": "text",
+            "default": ",".join(AGENT_DEFAULTS["agent_card_default_input_modes"]),
+        }
+    )
+    fields.append(
+        {
+            "name": "agent_card_default_output_modes_str",
+            "label": "Agent Card Default Output Modes (comma-sep)",
+            "type": "text",
+            "default": ",".join(AGENT_DEFAULTS["agent_card_default_output_modes"]),
+        }
+    )
+
+    fields.append(
+        {
+            "name": "agent_card_publishing_interval",
+            "label": "Agent Card Publishing Interval (s)",
+            "type": "number",
+            "default": AGENT_DEFAULTS["agent_card_publishing_interval"],
+        }
+    )
+    fields.append(
+        {
+            "name": "agent_discovery_enabled",
+            "label": "Enable Agent Discovery",
+            "type": "boolean",
+            "default": AGENT_DEFAULTS["agent_discovery_enabled"],
+        }
+    )
+
+    fields.append(
+        {
+            "name": "inter_agent_communication_allow_list_str",
+            "label": "Inter-Agent Allow List (comma-sep)",
+            "type": "text",
+            "default": ",".join(AGENT_DEFAULTS["inter_agent_communication_allow_list"]),
+        }
+    )
+    fields.append(
+        {
+            "name": "inter_agent_communication_deny_list_str",
+            "label": "Inter-Agent Deny List (comma-sep)",
+            "type": "text",
+            "default": ",".join(AGENT_DEFAULTS["inter_agent_communication_deny_list"]),
+        }
+    )
+    fields.append(
+        {
+            "name": "inter_agent_communication_timeout",
+            "label": "Inter-Agent Timeout (s)",
+            "type": "number",
+            "default": AGENT_DEFAULTS["inter_agent_communication_timeout"],
+        }
+    )
+
+    return fields
+
 
 def create_app(shared_config=None):
     """Factory function that creates the Flask application with configuration injected"""
     app = Flask(__name__)
-    CORS(app, resources={r"/api/*": {"origins": ["http://localhost:5174", "http://127.0.0.1:5174"]}})
+    CORS(app, resources={r"/api/*": {"origins": "*"}})
 
-    EXCLUDE_OPTIONS = ["config_dir", "module_dir", "env_file", "build_dir", "container_engine", "rest_api_enabled",
-                     "rest_api_server_input_port", "rest_api_server_host", "rest_api_server_input_endpoint", 
-                     "rest_api_gateway_name", "webui_enabled", "webui_listen_port", "webui_host"]
+    EXCLUDE_OPTIONS = ["container_engine"]
 
-    @app.route('/api/default_options', methods=['GET'])
+    @app.route("/api/default_options", methods=["GET"])
     def get_default_options():
-        """Endpoint that returns the default options for form initialization"""
-        path = request.args.get('path', 'advanced')
-        
-        modified_default_options = default_options.copy()
-        
-        # Base exclusions for all paths
+        """Endpoint that returns the default options for form initialization (init flow)"""
+        path = request.args.get("path", "advanced")
+
+        modified_default_options = INIT_DEFAULT.copy()
+
         base_exclude_options = EXCLUDE_OPTIONS.copy()
-        
-        # Additional exclusions for quick path
         quick_path_exclude_options = [
-            "namespace", "broker_type", "broker_url", "broker_vpn",
-            "broker_username", "broker_password", "container_engine",
-            "built_in_agent", "file_service_provider", "file_service_config"
+            "broker_url",
+            "broker_vpn",
+            "broker_username",
+            "broker_password",
+            "container_engine",
         ]
-        
-        # Apply exclusions based on path
+
         exclude_options = base_exclude_options.copy()
-        if path == 'quick':
+        if path == "quick":
             exclude_options.extend(quick_path_exclude_options)
-        
-        # Remove excluded options
+            modified_default_options["dev_mode"] = True
+            modified_default_options["broker_type"] = "3"
         for option in exclude_options:
             modified_default_options.pop(option, None)
-        
-        return jsonify({
-            "default_options": modified_default_options,
-            "status": "success"
-        })
 
-    @app.route('/api/save_config', methods=['POST'])
-    def save_config():
+        return jsonify(
+            {"default_options": modified_default_options, "status": "success"}
+        )
+
+    @app.route("/api/form_schema", methods=["GET"])
+    def get_form_schema():
+        """
+        Endpoint that returns defaults and field definitions for a given component type.
+        """
+        component_type = request.args.get("type", "agent")
+
+        if component_type == "agent":
+            return jsonify(
+                {
+                    "status": "success",
+                    "schema_type": "agent",
+                    "defaults": AGENT_DEFAULTS,
+                    "field_definitions": get_agent_field_definitions(),
+                }
+            )
+        elif component_type == "gateway":
+            return jsonify(
+                {
+                    "status": "success",
+                    "schema_type": "gateway",
+                    "defaults": GATEWAY_DEFAULTS,
+                    "meta": {
+                        "artifact_service_types": [
+                            USE_DEFAULT_SHARED_ARTIFACT,
+                            "memory",
+                            "filesystem",
+                            "gcs",
+                        ],
+                        "artifact_service_scopes": ["namespace", "app", "custom"],
+                    },
+                }
+            )
+        else:
+            return (
+                jsonify({"status": "error", "message": "Invalid component type"}),
+                400,
+            )
+
+    @app.route("/api/available_tools", methods=["GET"])
+    def get_available_tools():
+        """
+        Endpoint that returns a structured list of all available built-in tools and groups.
+        """
+        try:
+            all_tools = tool_registry.get_all_tools()
+
+            groups = defaultdict(lambda: {"description": "", "tools": []})
+            tools_map = {}
+
+            group_descriptions = {
+                "artifact_management": "Creating, loading, and managing files and artifacts.",
+                "data_analysis": "Querying, transforming, and visualizing data.",
+                "general": "General purpose utilities like file conversion and diagram generation.",
+                "web": "Interacting with web resources via HTTP requests.",
+                "audio": "Generating and transcribing audio content.",
+                "image": "Generating, describing, and editing images.",
+                "test": "Tools for testing and development purposes.",
+            }
+
+            for tool in sorted(all_tools, key=lambda t: (t.category, t.name)):
+                groups[tool.category]["tools"].append(tool.name)
+                if not groups[tool.category]["description"]:
+                    groups[tool.category]["description"] = group_descriptions.get(
+                        tool.category,
+                        f"Tools related to {tool.category.replace('_', ' ').title()}.",
+                    )
+                tools_map[tool.name] = {
+                    "description": tool.description,
+                    "category": tool.category,
+                }
+
+            return jsonify(
+                {"status": "success", "groups": dict(groups), "tools": tools_map}
+            )
+        except Exception as e:
+            app.logger.error(f"Error in get_available_tools: {e}", exc_info=True)
+            return jsonify({"status": "error", "message": str(e)}), 500
+
+    @app.route("/api/save_gateway_config", methods=["POST"])
+    def save_gateway_config_route():
+        """
+        Accepts gateway configuration from frontend and passes it back to CLI via shared_config.
+        """
+        try:
+            data = request.json
+            if not data:
+                return jsonify({"status": "error", "message": "No data received"}), 400
+
+            gateway_name_input = data.get("gateway_name_input")
+            config_options = data.get("config")
+
+            if not gateway_name_input or not isinstance(config_options, dict):
+                return (
+                    jsonify(
+                        {
+                            "status": "error",
+                            "message": "Missing gateway_name_input or config data",
+                        }
+                    ),
+                    400,
+                )
+
+            if "namespace" not in config_options:
+                config_options["namespace"] = GATEWAY_DEFAULTS.get(
+                    "namespace", "${NAMESPACE}"
+                )
+
+            if shared_config is not None:
+                shared_config["status"] = "success_from_gui_save"
+                shared_config["gateway_name_input"] = gateway_name_input
+                shared_config["config"] = config_options
+
+            return jsonify(
+                {
+                    "status": "success",
+                    "message": "Gateway configuration data received by server. CLI will process.",
+                }
+            )
+
+        except Exception as e:
+            app.logger.error(f"Error in save_gateway_config_route: {e}", exc_info=True)
+            if shared_config is not None:
+                shared_config["status"] = "error_in_gui_save"
+                shared_config["message"] = str(e)
+            return jsonify({"status": "error", "message": str(e)}), 500
+
+    @app.route("/api/save_agent_config", methods=["POST"])
+    def save_agent_config_route():
         """
-        Endpoint that accepts configuration data from the frontend,
-        merges it with default options, and updates the shared configuration.
+        Accepts agent configuration from frontend and passes it back to CLI via shared_config.
         """
+        try:
+            data = request.json
+            if not data:
+                return jsonify({"status": "error", "message": "No data received"}), 400
+
+            agent_name_input = data.get("agent_name_input")
+            config_options = data.get("config")
+
+            if not agent_name_input or not config_options:
+                return (
+                    jsonify(
+                        {
+                            "status": "error",
+                            "message": "Missing agent_name_input or config data",
+                        }
+                    ),
+                    400,
+                )
+
+            str_list_keys_to_process = {
+                "agent_card_default_input_modes_str": "agent_card_default_input_modes",
+                "agent_card_default_output_modes_str": "agent_card_default_output_modes",
+                "inter_agent_communication_allow_list_str": "inter_agent_communication_allow_list",
+                "inter_agent_communication_deny_list_str": "inter_agent_communication_deny_list",
+            }
+            processed_options = config_options.copy()
+            for key_str, original_key in str_list_keys_to_process.items():
+                if key_str in processed_options and isinstance(
+                    processed_options[key_str], str
+                ):
+                    processed_options[original_key] = [
+                        s.strip()
+                        for s in processed_options[key_str].split(",")
+                        if s.strip()
+                    ]
+                elif original_key not in processed_options:
+                    processed_options[original_key] = []
+
+            if "agent_card_skills" in processed_options and isinstance(
+                processed_options["agent_card_skills"], list
+            ):
+                if "agent_card_skills_str" in processed_options:
+                    del processed_options["agent_card_skills_str"]
+            elif "agent_card_skills_str" in processed_options and isinstance(
+                processed_options["agent_card_skills_str"], str
+            ):
+                try:
+                    import json
+
+                    parsed_skills = json.loads(
+                        processed_options["agent_card_skills_str"]
+                    )
+                    if isinstance(parsed_skills, list):
+                        processed_options["agent_card_skills"] = parsed_skills
+                    else:
+                        app.logger.warn(
+                            f"Parsed agent_card_skills_str was not a list: {parsed_skills}. Defaulting to empty list."
+                        )
+                        processed_options["agent_card_skills"] = []
+                except json.JSONDecodeError:
+                    app.logger.warn(
+                        f"Could not parse agent_card_skills_str: {processed_options['agent_card_skills_str']}. Defaulting to empty list."
+                    )
+                    processed_options["agent_card_skills"] = []
+            elif "agent_card_skills" not in processed_options:
+                processed_options["agent_card_skills"] = []
+
+            formatted_names = get_formatted_names(agent_name_input)
+            processed_options["agent_name"] = formatted_names["PASCAL_CASE_NAME"]
+            if shared_config is not None:
+                shared_config["status"] = "success_from_gui_save"
+                shared_config["agent_name_input"] = agent_name_input
+                shared_config["config"] = processed_options
+            return jsonify(
+                {
+                    "status": "success",
+                    "message": "Agent configuration data received by server. CLI will process.",
+                }
+            )
+
+        except Exception as e:
+            app.logger.error(f"Error in save_agent_config_route: {e}", exc_info=True)
+            if shared_config is not None:
+                shared_config["status"] = "error_in_gui_save"
+                shared_config["message"] = str(e)
+            return jsonify({"status": "error", "message": str(e)}), 500
+
+    @app.route("/api/save_config", methods=["POST"])
+    def save_config():
         try:
             received_data = request.json
-            force = received_data.pop('force', False)
+            force = received_data.pop("force", False)
 
             if not received_data:
                 return jsonify({"status": "error", "message": "No data received"}), 400
-            
-            complete_config = default_options.copy()
-            
-            # Update with the received data
+
+            complete_config = INIT_DEFAULT.copy()
             for key, value in received_data.items():
                 if key in complete_config or key:
                     complete_config[key] = value
-            
-            config_directory = complete_config["config_dir"]
-            formatted_name = get_formatted_names(complete_config["rest_api_gateway_name"])
-            gateway_directory = os.path.join(
-            config_directory, "gateways", formatted_name["SNAKE_CASE_NAME"]
-            )
-
-            #Handle the case where the gateway directory for rest already exists
-            if os.path.exists(gateway_directory) and not force:
-                return jsonify({"status": "ask_confirmation", "message": f"Gateway directory {gateway_directory} already exists, it will be overwritten."}), 400
-            elif os.path.exists(gateway_directory) and force:
-                shutil.rmtree(gateway_directory)
 
-            # Update the shared configuration if it exists
             if shared_config is not None:
                 for key, value in complete_config.items():
                     shared_config[key] = value
-            
-            return jsonify({
-                "status": "success",
-            })
-            
+
+            return jsonify({"status": "success"})
+
         except Exception as e:
+            app.logger.error(f"Error in save_config: {e}", exc_info=True)
             return jsonify({"status": "error", "message": str(e)}), 500
-    
-    @app.route('/api/test_llm_config', methods=['POST'])
+
+    @app.route("/api/test_llm_config", methods=["POST"])
     def test_llm_config():
-        """
-        Endpoint that tests the LLM configuration given by the users"""
         llm_config = request.json
-
-        #check for all values
-        if not llm_config.get("model") or not llm_config.get("api_key") or not llm_config.get("base_url"):
-            return jsonify({"status": "error", "message": "Please provide all the required values"}), 400
-
+        if (
+            not llm_config.get("model")
+            or not llm_config.get("api_key")
+            or not llm_config.get("base_url")
+        ):
+            return (
+                jsonify(
+                    {
+                        "status": "error",
+                        "message": "Please provide all the required values",
+                    }
+                ),
+                400,
+            )
         try:
             response = litellm.completion(
                 model=llm_config.get("model"),
                 api_key=llm_config.get("api_key"),
                 base_url=llm_config.get("base_url"),
-                messages=[{"role":"user","content": "Say OK"}]
-                )
+                messages=[{"role": "user", "content": "Say OK"}],
+            )
             message = response.get("choices")[0].get("message")
-
             if message is not None:
                 return jsonify({"status": "success", "message": message.content}), 200
             else:
                 raise ValueError("No response from LLM")
-        except Exception:  
+        except Exception:
             return jsonify({"status": "error", "message": "No response from LLM."}), 400
 
-    @app.route('/api/test_broker_connection', methods=['POST'])
-    def test_broker_connection():
-        try:
-            broker_details = request.json
-            if not all(k in broker_details for k in ["broker_url", "broker_vpn", "broker_username", "broker_password"]):
-                return jsonify({"status": "error", "message": "Missing required broker details."}), 400
-
-            broker_props = {
-                "solace.messaging.transport.host": broker_details.get("broker_url"),
-                "solace.messaging.service.vpn-name": broker_details.get("broker_vpn"),
-                "solace.messaging.authentication.scheme.basic.username": broker_details.get("broker_username"),
-                "solace.messaging.authentication.scheme.basic.password": broker_details.get("broker_password"),
-                "solace.messaging.tls.trust-store-path":  os.environ.get("TRUST_STORE")
-                                                        or os.path.dirname(certifi.where())
-                                                        or "/usr/share/ca-certificates/mozilla/",
-            }
-
-            retry_count = 1
-            retry_interval = 3000
-
-            messaging_service = MessagingService.builder().from_properties(broker_props) \
-                .with_connection_retry_strategy(
-                    RetryStrategy.parametrized_retry(retry_count, retry_interval)
-                ).build()
-
-            try:
-                messaging_service.connect()
-                messaging_service.disconnect()
-                return jsonify({"status": "success", "message": "Successfully connected to the Solace broker."}), 200
-            except PubSubPlusClientError as e:
-                return jsonify({"status": "error", "message": f"Connection failed: {str(e)}"}), 400
-            except Exception as e:
-                return jsonify({"status": "error", "message": f"An unexpected error occurred: {str(e)}"}), 500
-
-        except Exception as e:
-            # Catch errors in request processing or setup
-            return jsonify({"status": "error", "message": f"Server error: {str(e)}"}), 500
-
-
-    @app.route('/api/runcontainer', methods=['POST'])
+    @app.route("/api/runcontainer", methods=["POST"])
     def runcontainer():
         try:
             data = request.json or {}
-            
-            # Check if the user has podman or docker installed
             has_podman = shutil.which("podman") is not None
             has_docker = shutil.which("docker") is not None
-            
             if not has_podman and not has_docker:
-                return jsonify({
-                    "status": "error", 
-                    "message": "You need to have either podman or docker installed to use the container broker."
-                }), 400
-            
-            # Determine which container engine to use
-            container_engine = data.get('container_engine')
-            
-            # If both are available, default to podman
+                return (
+                    jsonify(
+                        {
+                            "status": "error",
+                            "message": "You need to have either podman or docker installed.",
+                        }
+                    ),
+                    400,
+                )
+
+            container_engine = data.get("container_engine")
             if not container_engine and has_podman and has_docker:
                 container_engine = "podman"
-            # If only one is available, use that one
             elif not container_engine:
                 container_engine = "podman" if has_podman else "docker"
-            
-            # Validate the container engine selection
+
             if container_engine not in ["podman", "docker"]:
-                return jsonify({
-                    "status": "error", 
-                    "message": f"Invalid container engine: {container_engine}. Must be 'podman' or 'docker'."
-                }), 400
-            
+                return jsonify({"status": "error", "message": "Invalid engine."}), 400
             if container_engine == "podman" and not has_podman:
-                return jsonify({
-                    "status": "error", 
-                    "message": "Podman was selected but is not installed on this system."
-                }), 400
-            
+                return (
+                    jsonify({"status": "error", "message": "Podman not installed."}),
+                    400,
+                )
             if container_engine == "docker" and not has_docker:
-                return jsonify({
-                    "status": "error", 
-                    "message": "Docker was selected but is not installed on this system."
-                }), 400
-            
-            # Run command for the container start
+                return (
+                    jsonify({"status": "error", "message": "Docker not installed."}),
+                    400,
+                )
+
             command = container_engine + CONTAINER_RUN_COMMAND
-            
-            # Execute the command and capture exit code
             response_status = os.system(command)
-            
+
             if response_status != 0:
-                return jsonify({
-                    "status": "error", 
-                    "message": f"Failed to start container. Exit code: {response_status}"
-                }), 500
-            
-            return jsonify({
-                "status": "success",
-                "message": f"Successfully started Solace PubSub+ broker container using {container_engine}",
-                "container_engine": container_engine
-            })
-            
+                return (
+                    jsonify(
+                        {
+                            "status": "error",
+                            "message": "The creation of a new container failed. You can try switching to dev mode or existing broker mode. You can also check this url to find possible solutions https://docs.solace.com/Software-Broker/Container-Tasks/rootless-containers.htm#rootful-versus-rootless-containers",
+                        }
+                    ),
+                    500,
+                )
+            return jsonify(
+                {
+                    "status": "success",
+                    "message": f"Started container via {container_engine}",
+                    "container_engine": container_engine,
+                }
+            )
         except Exception as e:
             return jsonify({"status": "error", "message": str(e)}), 500
 
-
-    @app.route('/api/shutdown', methods=['POST'])
+    @app.route("/api/shutdown", methods=["POST"])
     def shutdown():
         """Kills this Flask process immediately"""
         response = jsonify({"message": "Server shutting down...", "status": "success"})
-        os._exit(0) 
+        os._exit(0)
         return response
-        
 
+    frontend_static_dir = (
+        Path(__file__).resolve().parent.parent / "frontend" / "static" / "client"
+    )
 
     @app.route("/assets/<path:path>")
     def serve_assets(path):
-        return send_from_directory("../frontend/static/client/assets", path)
+        return send_from_directory(frontend_static_dir / "assets", path)
 
     @app.route("/static/client/<path:path>")
     def serve_client_files(path):
-        return send_from_directory("../frontend/static/client", path)
+        return send_from_directory(frontend_static_dir, path)
 
     @app.route("/", defaults={"path": ""})
-    def serve(path):
-        return send_file("../frontend/static/client/index.html")
-
     @app.route("/<path:path>")
-    def serve_files(path):
-        if path.endswith(('.png', '.jpg', '.jpeg', '.gif', '.ico')):
-            return send_from_directory("../frontend/static/client", path)
-        return send_file("../frontend/static/client/index.html")
-    
+    def serve_index(path):
+        if os.path.splitext(path)[1] and os.path.exists(frontend_static_dir / path):
+            return send_from_directory(frontend_static_dir, path)
+        return send_file(frontend_static_dir / "index.html")
+
     return app
 
+
 def run_flask(host="127.0.0.1", port=5002, shared_config=None):
-    """
-    Run the Flask development server with dependency-injected shared configuration.
-    """
+    host = os.environ.get(config_portal_host, host)
     app = create_app(shared_config)
+    app.logger.setLevel(logging.INFO)
+    app.logger.info(f"Starting Flask app on {host}:{port}")
     app.run(host=host, port=port, debug=False, use_reloader=False)
-