tunnel-manager 1.0.9__py3-none-any.whl

scripts/validate_a2a_agent.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+import asyncio
+import httpx
+import json
+import uuid
+
+# Configuration
+A2A_URL = (
+    "http://localhost:9002/a2a/"  # Discovered endpoint is POST / based on 405 on GET /
+)
+
+
+async def main():
+    print(f"Validating A2A Agent at {A2A_URL}...")
+
+    questions = [
+        "Run 'ls' command on the remote host and share the output",
+    ]
+
+    async with httpx.AsyncClient(timeout=10000.0) as client:
+        # First, let's verify connectivity and maybe infer output schema
+
+        for q in questions:
+            print(f"\n\n\nUser: {q}")
+            print("--- Sending Request ---")
+
+            # Construct JSON-RPC payload
+            payload = {
+                "jsonrpc": "2.0",
+                "method": "message/send",
+                "params": {
+                    "message": {
+                        "kind": "message",
+                        "role": "user",
+                        "parts": [{"kind": "text", "text": q}],
+                        "messageId": str(uuid.uuid4()),
+                    }
+                },
+                "id": 1,
+            }
+
+            try:
+                # Attempt POST to root
+                url = A2A_URL
+                print(f"Trying POST {url} with JSON-RPC (message/send)...")
+                resp = await client.post(
+                    url, json=payload, headers={"Content-Type": "application/json"}
+                )
+
+                print(f"Status Code: {resp.status_code}")
+                if resp.status_code == 200:
+                    try:
+                        data = resp.json()
+                        print(f"Response (JSON):\n{json.dumps(data, indent=2)}")
+
+                        if "result" in data and "id" in data["result"]:
+                            task_id = data["result"]["id"]
+                            print(
+                                f"\nTask Submitted with ID: {task_id}. Polling for result..."
+                            )
+
+                            # Poll tasks/get
+                            while True:
+                                await asyncio.sleep(2)  # Wait a bit
+                                poll_payload = {
+                                    "jsonrpc": "2.0",
+                                    "method": "tasks/get",
+                                    "params": {"id": task_id},
+                                    "id": 2,
+                                }
+                                poll_resp = await client.post(
+                                    url,
+                                    json=poll_payload,
+                                    headers={"Content-Type": "application/json"},
+                                )
+                                if poll_resp.status_code == 200:
+                                    poll_data = poll_resp.json()
+                                    if "result" in poll_data:
+                                        state = poll_data["result"]["status"]["state"]
+                                        print(f"Task State: {state}")
+                                        if state not in [
+                                            "submitted",
+                                            "running",
+                                            "working",
+                                        ]:  # Assuming terminal states
+                                            print(
+                                                f"\nTask Finished with state: {state}"
+                                            )
+
+                                            # Extract final result
+                                            if "history" in poll_data["result"]:
+                                                history = poll_data["result"]["history"]
+                                                if history:
+                                                    # Find last non-user message
+                                                    last_msg = None
+                                                    for msg in reversed(history):
+                                                        if msg.get("role") != "user":
+                                                            last_msg = msg
+                                                            break
+
+                                                    if last_msg and "parts" in last_msg:
+                                                        print(
+                                                            "\n--- Agent Response ---"
+                                                        )
+                                                        for part in last_msg["parts"]:
+                                                            if "text" in part:
+                                                                print(part["text"])
+                                                            elif "content" in part:
+                                                                print(part["content"])
+                                                    elif last_msg:
+                                                        print(
+                                                            f"Final Message (No parts): {last_msg}"
+                                                        )
+                                                    else:
+                                                        print(
+                                                            "\n--- No Agent Response Found in History ---"
+                                                        )
+
+                                            print(
+                                                f"Full Result Debug:\n{json.dumps(poll_data, indent=2)}"
+                                            )
+                                            break
+                                    else:
+                                        print("Starting polling error key check...")
+                                        if "error" in poll_data:
+                                            print(
+                                                f"Polling Error: {poll_data['error']}"
+                                            )
+                                        break
+                                else:
+                                    print(f"Polling Failed: {poll_resp.status_code}")
+                                    print(f"Polling Error Details: {poll_resp.text}")
+                                    break
+
+                        if "error" in data:
+                            print(f"JSON-RPC Error: {data['error']}")
+                    except json.JSONDecodeError:
+                        print(f"Response (Text):\n{resp.text}")
+                else:
+                    print(f"Error: {resp.status_code}")
+                    print(resp.text)
+
+            except httpx.RequestError as e:
+                print(f"Connection failed to {url}: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scripts/validate_agent.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+import asyncio
+import sys
+from servicenow_api.servicenow_agent import stream_chat, chat, node_chat
+
+
+# Attempt to import assuming dependencies are installed
+import os
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+try:
+    from servicenow_api.servicenow_agent import create_agent
+except ImportError as e:
+    print(f"Import Error: {e}")
+    print("Please install dependencies via `pip install .[all]`")
+    sys.exit(1)
+
+
+async def main():
+    print("Initializing A2A Agent...")
+    try:
+        agent = create_agent(
+            provider="openai",
+            model_id=os.getenv("MODEL_ID", "qwen/qwen3-8b"),
+            base_url=os.getenv(
+                "OPENAI_BASE_URL", "http://localhost:1234/v1"
+            ),  # 127.0.0.1
+            api_key=os.getenv("OPENAI_API_KEY", "llama"),
+            mcp_url=os.getenv("MCP_URL", "http://localhost:8005/mcp"),  # 127.0.0.1
+            mcp_config=None,
+        )
+
+        print("Agent initialized successfully.")
+
+        # Define sample questions
+        questions = [
+            "Can you list the incidents",
+            # "Can you create an incident with the description: Test, Title: Test, ...."
+        ]
+
+        print("\n--- Starting Sample Chat Validation ---\n")
+
+        for q in questions:
+            print(f"\n\n\nUser: {q}")
+            try:
+                # Only run one to test
+                await stream_chat(agent=agent, prompt=q)
+                await chat(agent=agent, prompt=q)
+                await node_chat(agent=agent, prompt=q)
+                if hasattr(agent, "tools"):
+                    print(f"Agent Tools: {[t.__name__ for t in agent.tools]}")
+                elif hasattr(agent, "_tools"):
+                    print(f"Agent Tools: {[t.__name__ for t in agent._tools]}")
+
+            except Exception as e:
+                print(f"\n\nError processing question '{q}': {e}")
+
+    except Exception as e:
+        print(f"Validation failed with error: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_tunnel.py

@@ -0,0 +1,76 @@
+import os
+from tunnel_manager.tunnel_manager import Tunnel
+
+username = os.environ.get("TUNNEL_USERNAME")
+password = os.environ.get("TUNNEL_PASSWORD")
+
+
+def test_password_authentication():
+    print("Testing password-based authentication...")
+    try:
+        # Initialize tunnel with username and password
+        tunnel = Tunnel(
+            remote_host="10.0.0.11",
+            username=username,
+            password=password,
+        )
+
+        # Connect to the remote host
+        tunnel.connect()
+
+        # Run a simple command
+        out, err = tunnel.run_command("whoami; cd ~/Development/; ls -la")
+        print(f"Command 'whoami' output: {out}")
+        if err:
+            print(f"Command error: {err}")
+
+        print(f"Command output: {out}")
+        # Example file transfer (uncomment to test, ensure files exist)
+        tunnel.send_file(
+            "/home/genius/Development/inventory/inventory.yml",
+            "/home/genius/Downloads/remote_test.txt",
+        )
+        tunnel.receive_file(
+            "/home/genius/Downloads/remote_test.txt", "./tests/downloaded_inventory.txt"
+        )
+
+        tunnel.close()
+        print("Password-based authentication test completed successfully.")
+    except Exception as e:
+        print(f"Password-based authentication test failed: {str(e)}")
+
+
+def test_key_authentication():
+    print("\nTesting key-based authentication...")
+    try:
+        # Initialize tunnel with identity file
+        tunnel = Tunnel(
+            remote_host="10.0.0.11",
+            username=username,
+            identity_file=os.path.expanduser("~/.ssh/id_rsa"),
+        )
+
+        # Connect to the remote host
+        tunnel.connect()
+
+        # Run a simple command
+        out, err = tunnel.run_command("whoami")
+        print(f"Command 'whoami' output: {out}")
+        if err:
+            print(f"Command error: {err}")
+
+        # Example file transfer (uncomment to test, ensure files exist)
+        # tunnel.send_file("local_test.txt", "/home/genius/remote_test.txt")
+        # tunnel.receive_file("/home/genius/remote_test.txt", "downloaded_test.txt")
+
+        tunnel.close()
+        print("Key-based authentication test completed successfully.")
+    except Exception as e:
+        print(f"Key-based authentication test failed: {str(e)}")
+
+
+if __name__ == "__main__":
+    print("Starting SSH Tunnel Tests\n")
+    test_password_authentication()
+    test_key_authentication()
+    print("\nAll tests completed.")

tunnel_manager/__init__.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import importlib
+import inspect
+from typing import List
+
+__all__: List[str] = []
+
+# Core modules – always available
+CORE_MODULES = [
+    "tunnel_manager.tunnel_manager_mcp",
+]
+
+# Optional modules
+OPTIONAL_MODULES = {
+    "tunnel_manager.tunnel_manager_agent": "a2a",
+    "tunnel_manager.tunnel_manager_mcp": "mcp",
+}
+
+
+def _import_module_safely(module_name: str):
+    """Try to import a module and return it, or None if not available."""
+    try:
+        return importlib.import_module(module_name)
+    except ImportError:
+        return None
+
+
+def _expose_members(module):
+    """Expose public classes and functions from a module into globals and __all__."""
+    for name, obj in inspect.getmembers(module):
+        if (inspect.isclass(obj) or inspect.isfunction(obj)) and not name.startswith(
+            "_"
+        ):
+            globals()[name] = obj
+            __all__.append(name)
+
+
+# Always import core modules
+for module_name in CORE_MODULES:
+    module = importlib.import_module(module_name)
+    _expose_members(module)
+
+# Conditionally import optional modules
+for module_name, extra_name in OPTIONAL_MODULES.items():
+    module = _import_module_safely(module_name)
+    if module is not None:
+        _expose_members(module)
+        globals()[f"_{extra_name.upper()}_AVAILABLE"] = True
+    else:
+        globals()[f"_{extra_name.upper()}_AVAILABLE"] = False
+
+_MCP_AVAILABLE = OPTIONAL_MODULES.get("tunnel_manager.tunnel_manager_mcp") in [
+    m.__name__ for m in globals().values() if hasattr(m, "__name__")
+]
+_A2A_AVAILABLE = "tunnel_manager.tunnel_manager_agent" in globals()
+
+__all__.extend(["_MCP_AVAILABLE", "_A2A_AVAILABLE"])
+
+
+"""
+tunnel-manager
+
+Tunnel Manager MCP Server
+"""

tunnel_manager/__main__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python
+# coding: utf-8
+from tunnel_manager.tunnel_manager_mcp import tunnel_manager_mcp
+
+if __name__ == "__main__":
+    tunnel_manager_mcp()

tunnel_manager/mcp_config.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "tunnel-manager": {
+      "url": "${MCP_URL:-http://localhost:8000/mcp}",
+      "timeout": 300000
+    }
+  }
+}

tunnel_manager/middlewares.py

@@ -0,0 +1,53 @@
+import threading
+from fastmcp.server.middleware import MiddlewareContext, Middleware
+from fastmcp.utilities.logging import get_logger
+
+# Thread-local storage for user token
+local = threading.local()
+logger = get_logger(name="TokenMiddleware")
+
+
+class UserTokenMiddleware(Middleware):
+    def __init__(self, config: dict):
+        self.config = config
+
+    async def on_request(self, context: MiddlewareContext, call_next):
+        logger.debug(f"Delegation enabled: {self.config['enable_delegation']}")
+        if self.config["enable_delegation"]:
+            headers = getattr(context.message, "headers", {})
+            auth = headers.get("Authorization")
+            if auth and auth.startswith("Bearer "):
+                token = auth.split(" ")[1]
+                local.user_token = token
+                local.user_claims = None  # Will be populated by JWTVerifier
+
+                # Extract claims if JWTVerifier already validated
+                if hasattr(context, "auth") and hasattr(context.auth, "claims"):
+                    local.user_claims = context.auth.claims
+                    logger.info(
+                        "Stored JWT claims for delegation",
+                        extra={"subject": context.auth.claims.get("sub")},
+                    )
+                else:
+                    logger.debug("JWT claims not yet available (will be after auth)")
+
+                logger.info("Extracted Bearer token for delegation")
+            else:
+                logger.error("Missing or invalid Authorization header")
+                raise ValueError("Missing or invalid Authorization header")
+        return await call_next(context)
+
+
+class JWTClaimsLoggingMiddleware(Middleware):
+    async def on_response(self, context: MiddlewareContext, call_next):
+        response = await call_next(context)
+        logger.info(f"JWT Response: {response}")
+        if hasattr(context, "auth") and hasattr(context.auth, "claims"):
+            logger.info(
+                "JWT Authentication Success",
+                extra={
+                    "subject": context.auth.claims.get("sub"),
+                    "client_id": context.auth.claims.get("client_id"),
+                    "scopes": context.auth.claims.get("scope"),
+                },
+            )

tunnel_manager/skills/tunnel-manager-remote-access/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: tunnel-manager-remote-access
+description: Tunnel Manager Remote Access capabilities for A2A Agent.
+---
+### Overview
+This skill provides access to remote_access operations.
+
+### Capabilities
+- **run_command_on_remote_host**: Run shell command on remote host. Expected return object type: dict
+- **send_file_to_remote_host**: Upload file to remote host. Expected return object type: dict
+- **receive_file_from_remote_host**: Download file from remote host. Expected return object type: dict
+- **check_ssh_server**: Check SSH server status. Expected return object type: dict
+- **test_key_auth**: Test key-based auth. Expected return object type: dict
+- **setup_passwordless_ssh**: Setup passwordless SSH. Expected return object type: dict
+- **copy_ssh_config**: Copy SSH config to remote host. Expected return object type: dict
+- **rotate_ssh_key**: Rotate SSH key on remote host. Expected return object type: dict
+- **remove_host_key**: Remove host key from known_hosts. Expected return object type: dict
+- **configure_key_auth_on_inventory**: Setup passwordless SSH for all hosts in group. Expected return object type: dict
+- **run_command_on_inventory**: Run command on all hosts in group. Expected return object type: dict
+- **copy_ssh_config_on_inventory**: Copy SSH config to all hosts in YAML group. Expected return object type: dict
+- **rotate_ssh_key_on_inventory**: Rotate SSH keys for all hosts in YAML group. Expected return object type: dict
+- **send_file_to_inventory**: Upload a file to all hosts in the specified inventory group. Expected return object type: dict
+- **receive_file_from_inventory**: Download a file from all hosts in the specified inventory group. Expected return object type: dict
+
+### Common Tools
+- `run_command_on_remote_host`: Run shell command on remote host. Expected return object type: dict
+- `send_file_to_remote_host`: Upload file to remote host. Expected return object type: dict
+- `receive_file_from_remote_host`: Download file from remote host. Expected return object type: dict
+- `check_ssh_server`: Check SSH server status. Expected return object type: dict
+- `test_key_auth`: Test key-based auth. Expected return object type: dict
+- `setup_passwordless_ssh`: Setup passwordless SSH. Expected return object type: dict
+- `copy_ssh_config`: Copy SSH config to remote host. Expected return object type: dict
+- `rotate_ssh_key`: Rotate SSH key on remote host. Expected return object type: dict
+- `remove_host_key`: Remove host key from known_hosts. Expected return object type: dict
+- `configure_key_auth_on_inventory`: Setup passwordless SSH for all hosts in group. Expected return object type: dict
+- `run_command_on_inventory`: Run command on all hosts in group. Expected return object type: dict
+- `copy_ssh_config_on_inventory`: Copy SSH config to all hosts in YAML group. Expected return object type: dict
+- `rotate_ssh_key_on_inventory`: Rotate SSH keys for all hosts in YAML group. Expected return object type: dict
+- `send_file_to_inventory`: Upload a file to all hosts in the specified inventory group. Expected return object type: dict
+- `receive_file_from_inventory`: Download a file from all hosts in the specified inventory group. Expected return object type: dict
+
+### Usage Rules
+- Use these tools when the user requests actions related to **remote_access**.
+- Always interpret the output of these tools to provide a concise summary to the user.
+
+### Example Prompts
+- "Please run command on remote host"
+- "Please receive file from inventory"
+- "Please remove host key"
+- "Please copy ssh config"
+- "Please run command on inventory"