solidx-agenthub-runtime 0.1.0__py3-none-any.whl

agenthub/__init__.py

@@ -0,0 +1,3 @@
+"""SolidX AgentHub runtime."""
+
+__version__ = "0.1.0"

agenthub/bridge/__init__.py

@@ -0,0 +1 @@
+"""LLM-free, session-scoped MCP access to AgentHub tools."""

agenthub/bridge/audit.py

@@ -0,0 +1,72 @@
+"""Bounded, best-effort audit writes; never capture HTTP streams."""
+
+import asyncio
+import json
+import logging
+import os
+from datetime import timedelta
+
+from sqlalchemy import delete
+
+from agenthub.persistence.models import McpAuditLog, naive_now
+
+
+logger = logging.getLogger(__name__)
+
+
+def payload(value):
+    if value is None or os.getenv("AGENTHUB_MCP_AUDIT_PAYLOADS", "true").lower() != "true":
+        return None
+    text = value if isinstance(value, str) else json.dumps(value, default=str)
+    limit = max(0, int(os.getenv("AGENTHUB_MCP_AUDIT_MAX_CHARS", "100000")))
+    return text if len(text) <= limit else text[:limit] + "...[truncated]"
+
+
+class AuditWriter:
+    def __init__(self, repo):
+        self.repo = repo
+        self.tasks = set()
+
+    def write(self, values):
+        # Map the bridge's audit fields onto Core's ``ss_mcp_audit_log`` columns.
+        code, message = values.get("error_code"), values.get("error_message")
+        if code is not None and not str(code).isdigit():
+            message, code = message or str(code), None
+        user_id = values.get("user_id")
+        row = McpAuditLog(
+            user_id=int(user_id) if str(user_id).isdigit() else None,
+            username=str(values["username"])[:128] if values.get("username") else None,
+            transport="streamable-http", mcp_session_id=values.get("session_id"),
+            client_addr=values.get("client_addr"), method=values["rpc_method"],
+            request_id=values.get("rpc_request_id"), tool_name=values.get("tool_name"),
+            request_params=values.get("request_params"), status=values["status"],
+            response_result=values.get("response_result"),
+            error_code=int(code) if code is not None else None, error_message=message,
+            duration_ms=values.get("duration_ms"))
+        with self.repo.transaction() as db:
+            db.add(row)
+
+    async def _write(self, values):
+        try:
+            await asyncio.to_thread(self.write, values)
+        except Exception:
+            logger.warning("MCP audit write failed")
+
+    def log(self, **values):
+        # Back pressure drops audit entries, not tool responses.
+        if len(self.tasks) >= 1000:
+            logger.warning("MCP audit queue full")
+            return
+        task = asyncio.create_task(self._write(values))
+        self.tasks.add(task)
+        task.add_done_callback(self.tasks.discard)
+
+    async def close(self):
+        if self.tasks:
+            await asyncio.gather(*list(self.tasks))
+
+    def purge(self):
+        days = int(os.getenv("AGENTHUB_MCP_AUDIT_RETENTION_DAYS", "0"))
+        if days > 0:
+            with self.repo.transaction() as db:
+                db.execute(delete(McpAuditLog).where(McpAuditLog.created_at < naive_now() - timedelta(days=days)))

agenthub/bridge/auth.py

@@ -0,0 +1,98 @@
+"""Bearer authentication and workspace binding for each HTTP request."""
+
+import asyncio
+import hashlib
+import re
+from dataclasses import dataclass, field
+
+from starlette.responses import JSONResponse
+
+from agenthub.bridge.sessions import resolve
+
+
+@dataclass
+class BridgeContext:
+    agent_id: int | str
+    principal: object
+    session: object
+    explicit: bool = False
+    credential_kind: str = "jwt"
+    credential_fingerprint: str = ""
+    client_addr: str | None = None
+    process_id: str | None = None
+    client_info: dict = field(default_factory=dict)
+    audit_arguments: object = None
+    audit_response: object = None
+    human_request_id: str | None = None
+
+    def clean(self, value):
+        import json
+        text = json.dumps(value, default=str)
+        for credential in (self.principal.access_token, self.principal.api_key):
+            if credential:
+                text = text.replace(credential, "[REDACTED]")
+        return json.loads(text)
+
+
+class BridgeAuth:
+    def __init__(self, app, manager, audit):
+        self.app, self.manager, self.audit = app, manager, audit
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+        match = re.fullmatch(r"/mcp/agents/([^/]+)(?:/sessions/([^/]+))?/?", scope["path"])
+        if not match:
+            await JSONResponse({"error": "MCP endpoint not found"}, 404)(scope, receive, send)
+            return
+        agent_id, sid = match.groups()
+        try:
+            agent_id = int(agent_id)
+        except ValueError:
+            await JSONResponse({"error": "MCP endpoint not found"}, 404)(scope, receive, send)
+            return
+        headers = dict(scope.get("headers", ()))
+        auth = headers.get(b"authorization", b"").decode("latin-1")
+        api_key = headers.get(b"solidx-api-key", b"").decode("latin-1") or None
+        token = auth[7:].strip() if auth.startswith("Bearer ") else None
+        principal = None
+        kind = "api_key" if api_key else "jwt"
+        status, message = 401, "Invalid credentials"
+        try:
+            if token and not api_key:
+                try:
+                    principal = await asyncio.to_thread(self.manager.identity.validate, token=token)
+                except Exception:
+                    # Bearer API keys are a compatibility extension, not OAuth.
+                    principal = await asyncio.to_thread(self.manager.identity.validate, api_key=token)
+                    kind = "api_key"
+            elif api_key and not token:
+                principal = await asyncio.to_thread(self.manager.identity.validate, api_key=api_key)
+            else:
+                raise PermissionError("Missing or ambiguous credential")
+        except Exception:
+            pass
+        if principal:
+            try:
+                session = await asyncio.to_thread(resolve, self.manager.repo, agent_id, principal, sid)
+            except PermissionError:
+                status, message = 403, "Agent or session access denied"
+            except LookupError:
+                status, message = 404, "Agent or session unavailable"
+            else:
+                scoped = BridgeContext(
+                    agent_id, principal, session, bool(sid), kind,
+                    hashlib.sha256((api_key or token).encode()).hexdigest()[:16],
+                    (scope.get("client") or (None,))[0],
+                )
+                inner = dict(scope)
+                inner["bridge_context"] = scoped
+                inner["path"], inner["raw_path"], inner["root_path"] = "/", b"/", ""
+                await self.app(inner, receive, send)
+                return
+        self.audit.log(agent_id=agent_id, user_id=principal.id if principal else None,
+                       rpc_method="auth.denied", status="denied", error_code=str(status),
+                       error_message=message, client_addr=(scope.get("client") or (None,))[0])
+        await JSONResponse({"error": message}, status, headers={"WWW-Authenticate": "Bearer"} if status == 401
+                           else {})(scope, receive, send)

agenthub/bridge/local.py

@@ -0,0 +1,123 @@
+"""Disk-mode MCP backend: one local user, in-process tools, prompt-only approvals."""
+
+import asyncio
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from threading import RLock
+from types import SimpleNamespace
+from uuid import uuid4
+
+from agenthub.bridge.auth import BridgeContext
+from agenthub.bridge.tool_session import PROMPT_APPROVALS, ToolSession, catalog
+from agenthub.tools.executor import ParkSession
+from agenthub.tools.loader import ToolRegistry
+
+LOCAL_PRINCIPAL = SimpleNamespace(id="local", username="local", role_ids=(), access_token=None, api_key=None)
+
+
+class LocalAudit:
+    def __init__(self, store=None):
+        self.store = store
+        if store:
+            with store.lock, store.db:
+                store.db.execute("CREATE TABLE IF NOT EXISTS mcp_calls "
+                                 "(id INTEGER PRIMARY KEY, session_id TEXT, data TEXT, created_at TEXT)")
+
+    def log(self, **values):
+        if not self.store:
+            return
+        with self.store.lock, self.store.db:
+            self.store.db.execute("INSERT INTO mcp_calls (session_id, data, created_at) VALUES (?, ?, ?)",
+                                  (values.get("session_id"), json.dumps(values, default=str),
+                                   datetime.now(timezone.utc).isoformat()))
+
+    async def close(self):
+        return None
+
+
+class LocalBridge:
+    # No AgentHub UI exists in disk mode, so approvals must arrive through MCP elicitation.
+    out_of_band_approvals = False
+
+    def __init__(self, spec, store=None):
+        self.spec = spec
+        self.registry = ToolRegistry(spec.tools)
+        self.audit = LocalAudit(store)
+        self.lock = RLock()
+        self.pending = {}
+        self.session = self._new_session()
+
+    def _new_session(self):
+        return ToolSession(self.spec, self.registry, str(uuid4()))
+
+    def _principal(self):
+        return {"id": LOCAL_PRINCIPAL.id, "username": LOCAL_PRINCIPAL.username, "role_ids": ()}
+
+    def scope(self, ctx):
+        # The audit middleware and handlers must share one mutable scope per request.
+        scope = getattr(ctx, "_agenthub_scope", None)
+        if scope is None:
+            scope = BridgeContext(self.spec.agent_id, LOCAL_PRINCIPAL, SimpleNamespace(id=self.session.id),
+                                  credential_kind="local")
+            ctx._agenthub_scope = scope
+        return scope
+
+    async def catalog(self, scope):
+        return self.session.redact(catalog(self.spec, self.registry, PROMPT_APPROVALS), {})
+
+    async def call(self, scope, name, arguments):
+        session = self.session
+        action = {"tool_name": name, "arguments": arguments, "tool_call_id": str(uuid4())}
+        redacted = session.redact(arguments, self._principal())
+        scope.audit_arguments = redacted
+        try:
+            output = await asyncio.to_thread(session.call, action, self._principal())
+        except ParkSession as pause:
+            rid = str(uuid4())
+            ttl = int(os.getenv("AGENTHUB_MCP_APPROVAL_TTL", "900"))
+            with self.lock:
+                self.pending = {k: v for k, v in self.pending.items()
+                                if v["expires_at"] > datetime.now(timezone.utc)}
+                self.pending[rid] = {"session": session, "action": action, "status": "pending",
+                                     "expires_at": datetime.now(timezone.utc) + timedelta(seconds=ttl)}
+            scope.human_request_id = rid
+            return {"status": "approval_required", "request_id": rid, "question": pause.question}
+        return {"status": "error" if output["returncode"] else "ok", "output": output["output"]}
+
+    async def answer(self, scope, rid, approve):
+        with self.lock:
+            request = self.pending.get(rid)
+            if not request or request["session"] is not self.session or request["status"] != "pending":
+                raise PermissionError("Invalid approval request")
+            request["status"] = "approved" if approve else "rejected"
+
+    async def resume(self, scope, rid):
+        scope.human_request_id = rid
+        with self.lock:
+            request = self.pending.get(rid)
+            if not request or request["session"] is not self.session:
+                return {"status": "error", "output": '{"error":"Request not found"}'}
+            if "result" in request:
+                return request["result"]
+            if request["status"] == "pending" and datetime.now(timezone.utc) >= request["expires_at"]:
+                request["status"] = "expired"
+            if request["status"] != "approved":
+                return {"status": request["status"]}
+            request["status"] = "executing"
+        result = await asyncio.to_thread(request["session"].call, request["action"], self._principal(),
+                                         approved=True)
+        output = {"status": "error" if result["returncode"] else "ok", "output": result["output"]}
+        with self.lock:
+            request["status"], request["result"] = "executed", output
+        return output
+
+    async def rotate(self, scope):
+        with self.lock:
+            self.session = self._new_session()
+            self.pending.clear()
+        scope.session = SimpleNamespace(id=self.session.id)
+        return {"status": "ok", "output": json.dumps({"session_id": self.session.id})}
+
+    async def close(self):
+        return None

agenthub/bridge/router.py

@@ -0,0 +1,62 @@
+"""Route tools to secret-bearing agent processes without retrying mutations."""
+
+import asyncio
+import json
+import os
+from time import monotonic
+from uuid import uuid4
+
+import httpx
+from sqlalchemy import select
+
+from agenthub.bridge.signing import agent_key, sign
+from agenthub.persistence.models import AgentProcess
+
+
+class ProcessRouter:
+    def __init__(self, manager):
+        self.manager = manager
+        self.client = httpx.AsyncClient(timeout=int(os.getenv("AGENTHUB_TOOL_TIMEOUT", "120")) + 30,
+                                        trust_env=False)
+        self.catalogs = {}
+
+    def process(self, agent_id, version):
+        with self.manager.repo.sessions() as db:
+            row = db.scalar(select(AgentProcess).where(
+                AgentProcess.agent_id == agent_id, AgentProcess.status == "ready", AgentProcess.config_version == version
+            ).order_by(AgentProcess.running_turns, AgentProcess.id))
+        return row or self.manager.spawn(agent_id)
+
+    async def rpc(self, scope, method, path, data=None):
+        process = await asyncio.to_thread(self.process, scope.agent_id, scope.session.config_version)
+        scope.process_id = process.process_id
+        body = json.dumps(data, separators=(",", ":")).encode() if data is not None else b""
+        key = agent_key(os.environ["AGENTHUB_MANAGER_INTERNAL_TOKEN"], scope.agent_id)
+        response = await self.client.request(
+            method, f"http://127.0.0.1:{process.port}{path}", content=body,
+            headers={"X-AgentHub-Bridge": sign(key, method, path, body), "Content-Type": "application/json"}
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def catalog(self, scope):
+        key = (scope.agent_id, scope.session.config_version)
+        cached = self.catalogs.get(key)
+        if cached and cached[0] > monotonic():
+            return cached[1]
+        value = await self.rpc(scope, "GET", "/internal/bridge/catalog")
+        if value["config_version"] != scope.session.config_version:
+            raise RuntimeError("Catalog configuration changed")
+        self.catalogs[key] = (monotonic() + 30, value)
+        return value
+
+    async def call(self, scope, name, arguments):
+        return await self.rpc(scope, "POST", f"/internal/bridge/sessions/{scope.session.id}/call", {
+            "tool": name, "arguments": arguments, "call_id": str(uuid4()),
+            "principal": scope.principal.snapshot(), "client": scope.client_info,
+        })
+
+    async def resume(self, scope, request_id):
+        return await self.rpc(scope, "POST", f"/internal/bridge/requests/{request_id}/execute", {
+            "principal": scope.principal.snapshot(), "session_id": scope.session.id,
+        })

agenthub/bridge/routes.py

@@ -0,0 +1,120 @@
+"""Manager REST discovery, explicit workspace creation, and restricted audit reads."""
+
+import os
+from datetime import timedelta
+from urllib.parse import quote
+
+from fastapi import Depends, HTTPException
+from sqlalchemy import select
+
+from agenthub.bridge.auth import BridgeAuth
+from agenthub.bridge.server import build_server, http_app
+from agenthub.bridge.service import BridgeService
+from agenthub.bridge.sessions import access, expired, resolve
+from agenthub.persistence.models import AgentRegistry, McpAuditLog, AgentSession, now
+from agenthub.persistence.repository import session_by_uid
+
+
+def attach_manager_bridge(app, manager, principal, require_admin):
+    master = os.environ["AGENTHUB_MANAGER_INTERNAL_TOKEN"]
+    if len(master.encode()) < 32:
+        # The SDK derives its request-state key from this token and rejects shorter keys.
+        raise RuntimeError("AGENTHUB_MANAGER_INTERNAL_TOKEN must be at least 32 bytes to enable the MCP bridge")
+    service = BridgeService(manager)
+    app.state.bridge = service
+    sdk_app = http_app(build_server(service, state_key=master))
+    app.mount("/mcp", BridgeAuth(sdk_app, manager, service.audit))
+
+    def url(agent_id, sid=None):
+        base = os.getenv("AGENTHUB_MCP_PUBLIC_URL", "http://127.0.0.1:9000").rstrip("/")
+        path = f"{base}/mcp/agents/{quote(str(agent_id), safe='')}"
+        return path + (f"/sessions/{sid}" if sid else "")
+
+    def allowed(agent_id, user):
+        try:
+            with manager.repo.sessions() as db:
+                return access(db, agent_id, user)
+        except PermissionError:
+            raise HTTPException(403, "Agent role is required") from None
+        except LookupError:
+            raise HTTPException(404, "Agent not active") from None
+
+    @app.get("/api/mcp/agents")
+    def agents(user=Depends(principal)):
+        with manager.repo.sessions() as db:
+            rows = db.scalars(select(AgentRegistry).where(AgentRegistry.status == "active", AgentRegistry.deleted_at.is_(None))
+                              .order_by(AgentRegistry.name)).all()
+            result = []
+            for row in rows:
+                try:
+                    access(db, row.id, user)
+                except PermissionError:
+                    continue
+                result.append({"id": row.id, "name": row.name, "title": row.title, "mcpUrl": url(row.id)})
+            return result
+
+    @app.post("/api/agents/{agent_id}/mcp-sessions")
+    def create_session(agent_id: int, user=Depends(principal)):
+        allowed(agent_id, user)
+        row = resolve(manager.repo, agent_id, user, explicit=True)
+        return {"sessionId": row.id, "mcpUrl": url(agent_id, row.id)}
+
+    @app.get("/api/mcp/agents/{agent_id}/client-config")
+    def client_config(agent_id: int, client: str = "codex", user=Depends(principal)):
+        allowed(agent_id, user)
+        endpoint = url(agent_id)
+        if client == "codex":
+            return {"format": "toml", "config": f'[mcp_servers.agenthub]\nurl = "{endpoint}"\n'
+                    'bearer_token_env_var = "AGENTHUB_MCP_TOKEN"\ntool_timeout_sec = 150\n'}
+        if client == "claude-desktop":
+            return {"format": "json", "config": {"mcpServers": {"agenthub": {
+                "command": "npx", "args": ["mcp-remote", endpoint, "--header",
+                                         "Authorization: Bearer ${AGENTHUB_MCP_TOKEN}"]}}},
+                    "note": "Set AGENTHUB_MCP_TOKEN in the desktop process environment. OAuth is not available."}
+        if client in {"claude-code", "cursor", "copilot", "vscode"}:
+            return {"format": "connection", "url": endpoint, "transport": "streamable-http",
+                    "header": "Authorization", "credential_env": "AGENTHUB_MCP_TOKEN",
+                    "note": "Configure an env-backed bearer header using the client's supported syntax. "
+                            "Never paste credentials into checked-in files."}
+        raise HTTPException(422, "Unknown MCP client")
+
+    def calls(user, sid=None, agent=None, user_id=None, after=0):
+        query = select(McpAuditLog).where(McpAuditLog.id > after)
+        if sid:
+            query = query.where(McpAuditLog.mcp_session_id == sid)
+        if agent:
+            # Core's audit table has no agent column; the MCP session carries it.
+            query = query.where(McpAuditLog.mcp_session_id.in_(
+                select(AgentSession.session_id).where(AgentSession.agent_id == agent)))
+        if user_id:
+            query = query.where(McpAuditLog.user_id == user_id)
+        with manager.repo.sessions() as db:
+            rows = db.scalars(query.order_by(McpAuditLog.id).limit(200)).all()
+            return [{column.name: getattr(row, column.name) for column in McpAuditLog.__table__.columns} for row in rows]
+
+    @app.get("/api/mcp/calls")
+    def admin_calls(agent: int | None = None, user: int | None = None, session: str | None = None,
+                    after: int = 0, caller=Depends(require_admin)):
+        return calls(caller, session, agent, user, after)
+
+    @app.get("/api/sessions/{session_id}/mcp-calls")
+    def session_calls(session_id: str, after: int = 0, user=Depends(principal)):
+        with manager.repo.sessions() as db:
+            row = session_by_uid(db, session_id)
+            if not row or row.trigger != "mcp":
+                raise HTTPException(404, "MCP session not found")
+            if str(row.user_id) != user.id:
+                raise HTTPException(403, "Session belongs to another user")
+        return calls(user, session_id, after=after)
+
+    return service, sdk_app
+
+
+def expire_sessions(repo):
+    with repo.transaction() as db:
+        rows = db.scalars(select(AgentSession).where(AgentSession.trigger == "mcp",
+                                                  AgentSession.status.in_(("active", "awaiting_approval")))).all()
+        for row in rows:
+            if expired(row):
+                row.status, row.ended_at = "expired", now()
+    return now() + timedelta(days=1)