autobots-devtools-shared-lib 0.8.0__tar.gz → 0.9.0__tar.gz

{autobots_devtools_shared_lib-0.8.0 → autobots_devtools_shared_lib-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobots-devtools-shared-lib
-Version: 0.8.0
+Version: 0.9.0
 Summary: Shared library functions to be used for all autobots projects
 License: MIT
 Author: Pralhad

{autobots_devtools_shared_lib-0.8.0 → autobots_devtools_shared_lib-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "autobots-devtools-shared-lib"
-version = "0.8.0"
+version = "0.9.0"
 description = "Shared library functions to be used for all autobots projects"
 readme = "README.md"
 authors = [

{autobots_devtools_shared_lib-0.8.0 → autobots_devtools_shared_lib-0.9.0}/src/autobots_devtools_shared_lib/common/servers/noderedmanagerserver/app.py

@@ -227,7 +227,7 @@ async def create_instance(body: CreateInstanceRequest) -> CreateInstanceResponse
         body.workspace_context,
     )
 
-    # 1. Extract and validate workspace_base_path — used as the instance ID
+    # 1. Extract and validate workspace_base_path
     workspace_base_path: str = (body.workspace_context.get("workspace_base_path") or "").strip()
     if not workspace_base_path:
         raise HTTPException(
@@ -239,7 +239,8 @@ async def create_instance(body: CreateInstanceRequest) -> CreateInstanceResponse
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="workspace_base_path cannot contain '..'",
         )
-    instance_id = workspace_base_path
+    # Instance ID scoped per environment so the same workspace can run multiple environments
+    instance_id = f"{body.environment_name}/{workspace_base_path}"
 
     # 2. Return existing instance if one is already running for this workspace
     if instance_id in _registry:
@@ -302,12 +303,13 @@ async def create_instance(body: CreateInstanceRequest) -> CreateInstanceResponse
 @app.post("/kill-instance")
 async def kill_instance(body: KillInstanceRequest) -> KillInstanceResponse:
     """Kill a running Node-RED instance by workspace_base_path."""
-    instance_id: str = (body.workspace_context.get("workspace_base_path") or "").strip()
-    if not instance_id:
+    workspace_base_path: str = (body.workspace_context.get("workspace_base_path") or "").strip()
+    if not workspace_base_path:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="workspace_context.workspace_base_path is required and cannot be empty.",
         )
+    instance_id = f"{body.environment_name}/{workspace_base_path}"
     logger.info("kill-instance called id=%s", instance_id)
 
     entry = _registry.get(instance_id)

{autobots_devtools_shared_lib-0.8.0 → autobots_devtools_shared_lib-0.9.0}/src/autobots_devtools_shared_lib/common/servers/noderedmanagerserver/models.py

@@ -49,6 +49,7 @@ class KillInstanceRequest(BaseModel):
         description="Workspace scoping context. Must include `workspace_base_path`.",
         json_schema_extra={"examples": [{"workspace_base_path": "alice/my-project-JIRA-42"}]},
     )
+    environment_name: str = Field(..., description="Name of the Node-RED environment to kill.")
 
 
 class KillInstanceResponse(BaseModel):

autobots_devtools_shared_lib-0.9.0/src/autobots_devtools_shared_lib/common/tools/noderedmanager_client_tools.py

@@ -0,0 +1,134 @@
+"""LangChain tools wrapping Node-RED instance manager REST API endpoints."""
+
+from langchain.tools import ToolException, ToolRuntime, tool
+
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+from autobots_devtools_shared_lib.common.utils.noderedmanager_client_utils import (
+    create_instance,
+    get_health,
+    kill_instance,
+    list_instances,
+)
+from autobots_devtools_shared_lib.dynagent.models.state import Dynagent
+
+logger = get_logger(__name__)
+
+
+def _session_id_from_runtime(runtime: ToolRuntime[None, Dynagent] | None) -> str | None:
+    """Extract session_id from runtime state if available."""
+    if runtime is None:
+        return None
+    state = runtime.state
+    if state is None:
+        return None
+    session_id = state.get("session_id")
+    if not isinstance(session_id, str) or not session_id:
+        return None
+    return session_id
+
+
+def _check_result(result: str, operation: str) -> None:
+    """If result is an error message, log and raise ToolException."""
+    if result.strip().startswith("Error "):
+        logger.warning("[tools] %s failed: %s", operation, result)
+        raise ToolException(result)
+
+
+@tool
+def get_health_tool(runtime: ToolRuntime[None, Dynagent] | None = None) -> str:
+    """Get the health status of the Node-RED instance manager server."""
+    logger.info("[tools] Getting Node-RED manager health")
+    try:
+        result = get_health(session_id=_session_id_from_runtime(runtime))
+        _check_result(result, "get_health")
+    except ToolException:
+        raise
+    except Exception as e:
+        logger.exception("[tools] get_health_tool failed")
+        raise ToolException(f"Error getting health: {e!s}") from e
+    else:
+        return result
+
+
+@tool
+def list_instances_tool(runtime: ToolRuntime[None, Dynagent] | None = None) -> str:
+    """List all currently running Node-RED instances."""
+    logger.info("[tools] Listing Node-RED instances")
+    try:
+        result = list_instances(session_id=_session_id_from_runtime(runtime))
+        _check_result(result, "list_instances")
+    except ToolException:
+        raise
+    except Exception as e:
+        logger.exception("[tools] list_instances_tool failed")
+        raise ToolException(f"Error listing instances: {e!s}") from e
+    else:
+        return result
+
+
+@tool
+def create_instance_tool(
+    runtime: ToolRuntime[None, Dynagent],
+    workspace_base_path: str = "",
+    flows_json_path: str = "",
+    environment_name: str = "",
+) -> str:
+    """
+    Launch a new Node-RED instance for the given workspace.
+
+    Returns the instance id and URL. If an instance already exists for this workspace,
+    the existing one is returned without launching a new process.
+    """
+    logger.info(
+        "[tools] Creating Node-RED instance workspace=%r flows=%r environment=%r",
+        workspace_base_path,
+        flows_json_path,
+        environment_name,
+    )
+    try:
+        result = create_instance(
+            workspace_base_path,
+            flows_json_path,
+            environment_name,
+            session_id=_session_id_from_runtime(runtime),
+        )
+        _check_result(result, "create_instance")
+    except ToolException:
+        raise
+    except Exception as e:
+        logger.exception("[tools] create_instance_tool failed workspace=%r", workspace_base_path)
+        raise ToolException(f"Error creating instance: {e!s}") from e
+    else:
+        return result
+
+
+@tool
+def kill_instance_tool(
+    runtime: ToolRuntime[None, Dynagent],
+    workspace_base_path: str = "",
+    environment_name: str = "",
+) -> str:
+    """Kill the running Node-RED instance for the given workspace and environment."""
+    logger.info(
+        "[tools] Killing Node-RED instance workspace=%r environment=%r",
+        workspace_base_path,
+        environment_name,
+    )
+    try:
+        result = kill_instance(
+            workspace_base_path,
+            environment_name,
+            session_id=_session_id_from_runtime(runtime),
+        )
+        _check_result(result, "kill_instance")
+    except ToolException:
+        raise
+    except Exception as e:
+        logger.exception(
+            "[tools] kill_instance_tool failed workspace=%r environment=%r",
+            workspace_base_path,
+            environment_name,
+        )
+        raise ToolException(f"Error killing instance: {e!s}") from e
+    else:
+        return result

autobots_devtools_shared_lib-0.9.0/src/autobots_devtools_shared_lib/common/utils/noderedmanager_client_utils.py

@@ -0,0 +1,220 @@
+"""HTTP client utilities for the Node-RED instance manager server REST API."""
+
+import os
+
+import httpx
+
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+from autobots_devtools_shared_lib.common.observability.trace_propagation import traced_http_call
+
+logger = get_logger(__name__)
+
+NODE_RED_MANAGER_HOST = os.getenv("NODE_RED_MANAGER_HOST", "localhost")
+NODE_RED_MANAGER_PORT = os.getenv("NODE_RED_MANAGER_PORT", "9003")
+NODE_RED_MANAGER_BASE_URL = f"http://{NODE_RED_MANAGER_HOST}:{NODE_RED_MANAGER_PORT}"
+
+
+def get_health(session_id: str | None = None) -> str:
+    """
+    Get the health status of the Node-RED manager server.
+
+    Args:
+        session_id: Optional session ID for trace correlation.
+
+    Returns:
+        String representation of health info (status, running_instances, available_environments).
+    """
+    logger.info("Getting Node-RED manager health")
+    try:
+        with (
+            traced_http_call("noderedManagerGetHealth", session_id=session_id) as trace_headers,
+            httpx.Client() as client,
+        ):
+            response = client.get(
+                f"{NODE_RED_MANAGER_BASE_URL}/health",
+                headers=trace_headers,
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            result = response.json()
+    except httpx.HTTPStatusError as e:
+        logger.exception(
+            "HTTP error getting Node-RED manager health: %s - %s",
+            e.response.status_code,
+            e.response.text,
+        )
+        return f"Error getting health: HTTP {e.response.status_code} - {e.response.text}"
+    except Exception as e:
+        logger.exception("Error getting Node-RED manager health")
+        return f"Error getting health: {e!s}"
+    else:
+        logger.info("Node-RED manager health: %s", result.get("status"))
+        return str(result)
+
+
+def list_instances(session_id: str | None = None) -> str:
+    """
+    List all currently running Node-RED instances.
+
+    Args:
+        session_id: Optional session ID for trace correlation.
+
+    Returns:
+        String representation of the instances list with count.
+    """
+    logger.info("Listing Node-RED instances")
+    try:
+        with (
+            traced_http_call("noderedManagerListInstances", session_id=session_id) as trace_headers,
+            httpx.Client() as client,
+        ):
+            response = client.get(
+                f"{NODE_RED_MANAGER_BASE_URL}/instances",
+                headers=trace_headers,
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            result = response.json()
+    except httpx.HTTPStatusError as e:
+        logger.exception(
+            "HTTP error listing Node-RED instances: %s - %s",
+            e.response.status_code,
+            e.response.text,
+        )
+        return f"Error listing instances: HTTP {e.response.status_code} - {e.response.text}"
+    except Exception as e:
+        logger.exception("Error listing Node-RED instances")
+        return f"Error listing instances: {e!s}"
+    else:
+        instances = result.get("instances", [])
+        logger.info("Listed %d Node-RED instance(s)", len(instances))
+        return str(result)
+
+
+def create_instance(
+    workspace_base_path: str,
+    flows_json_path: str,
+    environment_name: str,
+    session_id: str | None = None,
+) -> str:
+    """
+    Launch a new Node-RED instance (or return an existing one for the same workspace+environment).
+
+    The instance ID is scoped as ``environment_name/workspace_base_path`` so the same workspace
+    can run multiple environments simultaneously.
+
+    Args:
+        workspace_base_path: Workspace path (e.g. 'user/repo-JIRA-42').
+        flows_json_path: Relative path to flows.json within the workspace directory.
+        environment_name: Name of the Node-RED environment template to use.
+        session_id: Optional session ID for trace correlation.
+
+    Returns:
+        Success message with instance id and url.
+    """
+    logger.info(
+        "Creating Node-RED instance workspace=%r flows=%r environment=%r",
+        workspace_base_path,
+        flows_json_path,
+        environment_name,
+    )
+    try:
+        payload = {
+            "workspace_context": {"workspace_base_path": workspace_base_path},
+            "flows_json_path": flows_json_path,
+            "environment_name": environment_name,
+        }
+        with (
+            traced_http_call(
+                "noderedManagerCreateInstance", session_id=session_id
+            ) as trace_headers,
+            httpx.Client() as client,
+        ):
+            response = client.post(
+                f"{NODE_RED_MANAGER_BASE_URL}/create-instance",
+                json=payload,
+                headers=trace_headers,
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            result = response.json()
+    except httpx.HTTPStatusError as e:
+        logger.exception(
+            "HTTP error creating Node-RED instance workspace=%r: %s - %s",
+            workspace_base_path,
+            e.response.status_code,
+            e.response.text,
+        )
+        return f"Error creating instance: HTTP {e.response.status_code} - {e.response.text}"
+    except Exception as e:
+        logger.exception("Error creating Node-RED instance workspace=%r", workspace_base_path)
+        return f"Error creating instance: {e!s}"
+    else:
+        logger.info(
+            "Node-RED instance created/reused: id=%s url=%s", result.get("id"), result.get("url")
+        )
+        return f"Instance created: id={result['id']} url={result['url']}"
+
+
+def kill_instance(
+    workspace_base_path: str,
+    environment_name: str,
+    session_id: str | None = None,
+) -> str:
+    """
+    Kill a running Node-RED instance by workspace_base_path and environment_name.
+
+    Args:
+        workspace_base_path: Workspace path identifying the instance to kill.
+        environment_name: Environment name of the instance to kill.
+        session_id: Optional session ID for trace correlation.
+
+    Returns:
+        Success message from the server.
+    """
+    logger.info(
+        "Killing Node-RED instance workspace=%r environment=%r",
+        workspace_base_path,
+        environment_name,
+    )
+    try:
+        payload = {
+            "workspace_context": {"workspace_base_path": workspace_base_path},
+            "environment_name": environment_name,
+        }
+        with (
+            traced_http_call("noderedManagerKillInstance", session_id=session_id) as trace_headers,
+            httpx.Client() as client,
+        ):
+            response = client.post(
+                f"{NODE_RED_MANAGER_BASE_URL}/kill-instance",
+                json=payload,
+                headers=trace_headers,
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            result = response.json()
+    except httpx.HTTPStatusError as e:
+        logger.exception(
+            "HTTP error killing Node-RED instance workspace=%r: %s - %s",
+            workspace_base_path,
+            e.response.status_code,
+            e.response.text,
+        )
+        return f"Error killing instance: HTTP {e.response.status_code} - {e.response.text}"
+    except Exception as e:
+        logger.exception(
+            "Error killing Node-RED instance workspace=%r environment=%r",
+            workspace_base_path,
+            environment_name,
+        )
+        return f"Error killing instance: {e!s}"
+    else:
+        message = result.get("message", "Instance killed successfully")
+        logger.info(
+            "Node-RED instance killed workspace=%r environment=%r: %s",
+            workspace_base_path,
+            environment_name,
+            message,
+        )
+        return message