agent-portal-2 0.1.0

package/packages/agent-portal-mcp/agent_portal_mcp/tools/navigation.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Any
+
+from agent_portal_mcp.bridge.runtime_client import AgentPortalRuntimeClient
+from agent_portal_mcp.schemas.actions import McpAction
+from agent_portal_mcp.schemas.results import ToolResult
+from agent_portal_mcp.tools.common import execute_or_queue
+
+
+def navigate_to_url(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    return execute_or_queue(
+        client,
+        "navigate_to_url",
+        McpAction(
+            tool="navigate_to_url",
+            runtime_action_type="open_url",
+            reason=str(args.get("reason", "Navigate to URL")),
+            target=str(args.get("url", "")),
+            risk_hint="low",
+        ),
+    )
+
+
+def click_element(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    return execute_or_queue(
+        client,
+        "click_element",
+        McpAction(
+            tool="click_element",
+            runtime_action_type="click",
+            reason=str(args.get("reason", "Click element")),
+            target=str(args.get("selector", "")),
+            risk_hint="low",
+        ),
+    )
+
+
+def type_text(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    return execute_or_queue(
+        client,
+        "type_text",
+        McpAction(
+            tool="type_text",
+            runtime_action_type="type",
+            reason=str(args.get("reason", "Type text into element")),
+            target=str(args.get("selector", "")),
+            payload=str(args.get("text", "")),
+            risk_hint="medium",
+        ),
+    )
+
+
+def scroll_page(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    return execute_or_queue(
+        client,
+        "scroll_page",
+        McpAction(
+            tool="scroll_page",
+            runtime_action_type="scroll",
+            reason=str(args.get("reason", "Scroll page")),
+            target=str(args["selector"]) if "selector" in args and args["selector"] is not None else None,
+            risk_hint="safe",
+        ),
+    )
+
+
+def hover_element(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    return execute_or_queue(
+        client,
+        "hover_element",
+        McpAction(
+            tool="hover_element",
+            runtime_action_type="hover",
+            reason=str(args.get("reason", "Hover over element")),
+            target=str(args.get("selector", "")),
+            risk_hint="safe",
+        ),
+    )
+
+
+def wait_for_page(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    return execute_or_queue(
+        client,
+        "wait_for_page",
+        McpAction(
+            tool="wait_for_page",
+            runtime_action_type="wait",
+            reason=str(args.get("reason", "Wait for page element")),
+            target=str(args.get("selector", "")),
+            risk_hint="safe",
+        ),
+    )

package/packages/agent-portal-mcp/agent_portal_mcp/tools/reports.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+from agent_portal_mcp.bridge.runtime_client import AgentPortalRuntimeClient
+from agent_portal_mcp.schemas.results import ToolResult
+from agent_portal_mcp.tools.common import build_result
+
+
+def generate_report(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    payload = client.generate_report()
+    return build_result("generate_report", status, None, "completed", "safe", "Generated report.", payload)
+
+
+def list_reports(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    payload = client.list_reports()
+    return build_result("list_reports", status, None, "completed", "safe", "Listed reports.", payload)
+
+
+def read_report(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    payload = client.read_report(str(args.get("report", "")))
+    return build_result("read_report", status, None, "completed", "safe", "Read report.", payload)
+
+
+def export_report(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    payload = client.export_report(
+        str(args.get("report", "")),
+        str(args["destination"]) if "destination" in args and args["destination"] is not None else None,
+    )
+    return build_result("export_report", status, None, "completed", "safe", "Exported report.", payload)

package/packages/agent-portal-mcp/agent_portal_mcp/tools/steering.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Any
+
+from agent_portal_mcp.bridge.runtime_client import AgentPortalRuntimeClient
+from agent_portal_mcp.schemas.results import ToolResult
+from agent_portal_mcp.tools.common import build_result
+
+
+def propose_action(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    action = client.propose_action(
+        str(args.get("action_type", "")),
+        str(args.get("reason", "Propose action")),
+        target=str(args["target"]) if "target" in args and args["target"] is not None else None,
+        payload=str(args["payload"]) if "payload" in args and args["payload"] is not None else None,
+        risk_level=str(args.get("risk", "low")),
+    )
+    mapped_status = "pending_approval" if action.get("status") == "pending" else str(action.get("status", "failed"))
+    return build_result(
+        "propose_action",
+        status,
+        action,
+        mapped_status,  # type: ignore[arg-type]
+        str(action.get("risk_level", "low")),  # type: ignore[arg-type]
+        "Proposed action through the runtime policy engine.",
+        {"action": action},
+    )
+
+
+def approve_action(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    action = client.approve_action(str(args.get("action_id", "")), execute=bool(args.get("execute", True)))
+    return build_result(
+        "approve_action",
+        status,
+        action,
+        "completed" if action.get("status") == "completed" else "pending_approval",
+        str(action.get("risk_level", "low")),  # type: ignore[arg-type]
+        "Approved action through Agent Portal.",
+        {"action": action},
+    )
+
+
+def reject_action(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    action = client.reject_action(str(args.get("action_id", "")), str(args.get("reason", "Rejected by user")))
+    return build_result(
+        "reject_action",
+        status,
+        action,
+        "rejected",
+        str(action.get("risk_level", "low")),  # type: ignore[arg-type]
+        "Rejected action through Agent Portal.",
+        {"action": action},
+    )
+
+
+def pause_agent(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.pause()
+    return build_result("pause_agent", status, None, "completed", "safe", "Paused agent runtime.", status)
+
+
+def resume_agent(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.resume()
+    return build_result("resume_agent", status, None, "completed", "safe", "Resumed agent runtime.", status)
+
+
+def stop_agent(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.stop()
+    return build_result("stop_agent", {"session": {}}, None, "completed", "medium", "Stopped agent runtime.", status)
+
+
+def set_goal(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.set_goal(str(args.get("goal", "")))
+    return build_result("set_goal", status, None, "completed", "safe", "Set current goal.", status)
+
+
+def get_current_goal(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    goal = client.current_goal()
+    return build_result("get_current_goal", status, None, "completed", "safe", "Returned current goal.", goal)
+
+
+def get_action_queue(client: AgentPortalRuntimeClient, _args: dict[str, Any]) -> ToolResult:
+    status = client.status()
+    queue = client.action_queue()
+    return build_result("get_action_queue", status, None, "completed", "safe", "Returned action queue.", queue)
+
+
+def set_action_mode(client: AgentPortalRuntimeClient, args: dict[str, Any]) -> ToolResult:
+    status = client.set_action_mode(str(args.get("mode", "assisted")))
+    return build_result("set_action_mode", status, None, "completed", "medium", "Updated action mode.", status)

package/packages/agent-portal-mcp/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "agent-portal-mcp"
+version = "0.0.2"
+description = "MCP server bridge for Agent Portal."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+  { name = "Magnexis" }
+]
+
+[project.scripts]
+agent-portal-mcp = "agent_portal_mcp.cli:main"
+
+[tool.flit.module]
+name = "agent_portal_mcp"
+
+[build-system]
+requires = ["flit_core>=3.12.0,<4"]
+build-backend = "flit_core.buildapi"

package/packages/agent-portal-mcp/tests/test_doctor.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal_mcp.doctor import run_doctor
+
+
+class McpDoctorTests(unittest.TestCase):
+    def test_doctor_returns_checks(self) -> None:
+        result = run_doctor("http://127.0.0.1:9")
+        self.assertGreater(len(result.checks), 0)
+        self.assertTrue(any(check.name == "tool-registry" for check in result.checks))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/packages/agent-portal-mcp/tests/test_mcp_server.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from agent_portal_mcp.bridge.runtime_client import RuntimeClientError
+from agent_portal_mcp.schemas.results import ToolResult
+from agent_portal_mcp.server import AgentPortalMcpServer
+from agent_portal_mcp.tool_registry import build_tool_registry
+from agent_portal_mcp.tools import browser, inspection, navigation, reports
+
+
+class FakeClient:
+    def __init__(self, risk: str = "low", blocked: bool = False, auto_complete: bool = True) -> None:
+        self.risk = risk
+        self.blocked = blocked
+        self.auto_complete = auto_complete
+        self.token = "super-secret-token"
+
+    def status(self) -> dict[str, object]:
+        return {
+            "session": {"session_id": "session-1", "runtime_status": "idle"},
+            "policy": {"mode": "assisted", "approval_threshold": "medium", "read_only": False},
+        }
+
+    def propose_action(self, action_type: str, reason: str, target=None, payload=None, risk_level="low"):
+        if self.blocked:
+            return {
+                "action_id": "action-1",
+                "action_type": action_type,
+                "status": "blocked",
+                "reason": reason,
+                "target": target,
+                "payload": payload,
+                "risk_level": "blocked",
+                "result": "blocked",
+            }
+        return {
+            "action_id": "action-1",
+            "action_type": action_type,
+            "status": "pending",
+            "reason": reason,
+            "target": target,
+            "payload": payload,
+            "risk_level": self.risk,
+        }
+
+    def approve_action(self, action_id: str, execute: bool = False):
+        return {
+            "action_id": action_id,
+            "status": "completed" if execute and self.auto_complete else "approved",
+            "risk_level": self.risk,
+            "after_screenshot": "after.png",
+        }
+
+    def browser_status(self):
+        return {"connected": True}
+
+    def capture(self, label: str = "capture"):
+        return {"action": {"action_id": "capture-1", "after_screenshot": f"{label}.png"}, "screenshotPath": f"{label}.png", "inspection": {"url": "http://localhost", "title": "Fixture", "dom": "<html></html>", "consoleErrors": [], "networkErrors": []}}
+
+    def read_text(self, selector: str, reason: str):
+        return {"action": {"action_id": "read-1"}, "selector": selector, "text": "hello"}
+
+    def read_dom(self):
+        return {"dom": "<html></html>"}
+
+    def read_accessibility_tree(self):
+        return {"accessibilityTree": {"role": "document"}}
+
+    def read_console_errors(self):
+        return {"consoleErrors": ["error"]}
+
+    def read_network_failures(self):
+        return {"networkFailures": ["GET /api - failed"]}
+
+    def inspect_element(self, selector: str):
+        return {"selector": selector, "visible": True}
+
+    def generate_report(self):
+        return {"reportPath": "report.json"}
+
+    def list_reports(self):
+        return {"reports": [{"name": "report.json"}]}
+
+    def read_report(self, report_name: str):
+        return {"name": report_name}
+
+    def export_report(self, report_name: str, destination=None):
+        return {"exportPath": destination or report_name}
+
+    def health(self):
+        return {"ok": True, "runtimeVersion": "0.0.2"}
+
+
+class McpServerTests(unittest.TestCase):
+    def test_tools_are_registered(self) -> None:
+        registry = build_tool_registry()
+        self.assertIn("browser_open", registry)
+        self.assertIn("capture_screenshot", registry)
+        self.assertIn("approve_action", registry)
+
+    def test_server_initialize_and_list_tools(self) -> None:
+        server = AgentPortalMcpServer()
+        initialize = server.handle_request({"jsonrpc": "2.0", "id": 1, "method": "initialize"})
+        tools = server.handle_request({"jsonrpc": "2.0", "id": 2, "method": "tools/list"})
+        self.assertEqual(initialize["result"]["serverInfo"]["name"], "agent-portal-mcp")
+        self.assertGreater(len(tools["result"]["tools"]), 5)
+
+    def test_browser_open_tool_executes(self) -> None:
+        result = browser.browser_open(FakeClient(), {"url": "http://localhost:3000"})
+        self.assertTrue(result.ok)
+        self.assertEqual(result.status, "completed")
+
+    def test_capture_screenshot_tool_executes(self) -> None:
+        result = inspection.capture_screenshot(FakeClient(), {"label": "home"})
+        self.assertTrue(result.ok)
+        self.assertEqual(result.data["screenshotPath"], "home.png")
+
+    def test_click_element_can_enter_pending_approval(self) -> None:
+        result = navigation.click_element(FakeClient(risk="high"), {"selector": "#danger"})
+        self.assertFalse(result.ok)
+        self.assertEqual(result.status, "pending_approval")
+
+    def test_high_risk_action_can_be_blocked(self) -> None:
+        result = navigation.type_text(
+            FakeClient(blocked=True),
+            {"selector": "#password", "text": "secret", "reason": "Enter password"},
+        )
+        self.assertEqual(result.status, "blocked")
+
+    def test_report_generation_tool(self) -> None:
+        result = reports.generate_report(FakeClient(), {})
+        self.assertEqual(result.data["reportPath"], "report.json")
+
+    def test_token_redaction(self) -> None:
+        server = AgentPortalMcpServer()
+        server.client = FakeClient()  # type: ignore[assignment]
+        redacted = server._redact("token super-secret-token should not leak")
+        self.assertNotIn("super-secret-token", redacted)
+
+    def test_runtime_offline_error(self) -> None:
+        server = AgentPortalMcpServer()
+
+        class OfflineClient:
+            token = None
+
+            def status(self):
+                raise RuntimeClientError("Agent Portal runtime is not running. Start it with: agent-portal start")
+
+        server.client = OfflineClient()  # type: ignore[assignment]
+        result = server.call_tool("browser_status", {})
+        self.assertFalse(result.ok)
+        self.assertIn("agent-portal start", result.message)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/packages/core/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@agent-portal/core",
+  "version": "0.0.2",
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "playwright": "^1.54.1"
+  }
+}