@aliwey/bmo 2.0.0

package/core/bfp_agent.py

@@ -0,0 +1,98 @@
+"""
+BFP Agent — orchestrates BFP identity, card, transport, discovery, and relay communication.
+Started automatically when BMO boots.
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from core.bfp_identity import get_did, sign, verify
+from core.bfp_agent_card import get_signed_card, serve_agent_card, generate_agent_card
+from core.bfp_transport import BFPServer, BFPClient
+from core.bfp_a2a_bridge import get_a2a_agent_card, start_a2a_endpoint
+from core.bfp_connector import BFPConnector
+from core.bfp_discovery import BFPDiscovery
+
+logger = logging.getLogger(__name__)
+
+
+class BFPAgent:
+    """Manages BFP lifecycle within BMO."""
+
+    def __init__(self):
+        self.did = get_did()
+        self.card = get_signed_card()
+        self.bfp_server: Optional[BFPServer] = None
+        self.a2a_server = None
+        self.connector = BFPConnector()
+        self.discovery: Optional[BFPDiscovery] = None
+        self.relay_url: Optional[str] = None
+        self._running = False
+
+    @property
+    def is_running(self):
+        return self._running
+
+    async def start(self, bfp_port: int = 8765, a2a_port: int = 8766, relay_url: str = None):
+        """Start BFP server, A2A bridge, and optionally connect to relay."""
+        self.bfp_server = BFPServer(port=bfp_port)
+        # BFPServer.start() is synchronous — it spawns a daemon thread internally
+        self.bfp_server.start()
+        try:
+            self.a2a_server = start_a2a_endpoint(port=a2a_port)
+            if asyncio.iscoroutine(self.a2a_server):
+                self.a2a_server = await self.a2a_server
+        except Exception as e:
+            logger.warning("A2A endpoint start failed (non-fatal): %s", e)
+            self.a2a_server = None
+        if relay_url:
+            self.relay_url = relay_url
+            self.discovery = BFPDiscovery(relay_url)
+            try:
+                await self.connector.connect(relay_url, on_message=self._on_relay_message)
+            except Exception as e:
+                logger.warning("BFP relay not available (non-fatal): %s", e)
+        self._running = True
+        logger.info("BFP Agent started — DID: %s", self.did)
+
+    async def stop(self):
+        """Shut down BFP servers gracefully."""
+        if self.connector:
+            await self.connector.disconnect()
+        if self.bfp_server:
+            await self.bfp_server.stop()
+        if hasattr(self, 'a2a_server') and self.a2a_server:
+            import threading
+            threading.Thread(target=self.a2a_server.shutdown, daemon=True).start()
+        self._running = False
+        logger.info("BFP Agent stopped")
+
+    async def _on_relay_message(self, from_did: str, task_id: str, result: str):
+        logger.info("BFP relay message from %s — task %s: %s", from_did, task_id, result[:100])
+
+    def get_status(self) -> dict:
+        """Return BFP status for /bfp status command."""
+        return {
+            "did": self.did,
+            "running": self._running,
+            "connected_to_relay": self.connector.is_connected,
+            "relay_url": self.relay_url,
+            "bfp_port": self.bfp_server.get_port() if self.bfp_server else None,
+            "capabilities": [c["name"] for c in self.card.get("capabilities", [])],
+        }
+
+    async def find_agents(self, capability: str = None) -> list[dict]:
+        if not self.connector.is_connected:
+            raise RuntimeError("Not connected to relay — BFP relay required for discovery")
+        return await self.connector.find_agents(capability)
+
+    async def delegate(self, target_did: str, task_data: dict) -> dict:
+        if not self.connector.is_connected:
+            raise RuntimeError("Not connected to relay")
+        return await self.connector.delegate(target_did, task_data)
+
+    async def talk(self, target_did: str, message: str) -> str:
+        if not self.connector.is_connected:
+            raise RuntimeError("Not connected to relay")
+        return await self.connector.talk(target_did, message)

package/core/bfp_agent_card.py

@@ -0,0 +1,161 @@
+"""
+BFP Agent Card system - Phase 2 of BMO Friendship Protocol
+A2A-compatible agent card generation, caching, and serving
+"""
+
+import json
+import logging
+import threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from pathlib import Path
+
+from config.settings import DATA_DIR
+from core.bfp_identity import get_did, sign, verify, get_agent_card as _get_did_card
+
+logger = logging.getLogger(__name__)
+
+BFP_DIR = DATA_DIR / "bfp"
+CARD_FILE = BFP_DIR / "signed-card.json"
+
+AGENT_NAME = "BMO-Aliwey"
+AGENT_VERSION = "1.0.0"
+AGENT_HUMAN = "Aliwey"
+
+DEFAULT_CAPABILITIES = [
+    {"id": "code", "name": "Code Assistant", "description": "Write, debug, refactor code"},
+    {"id": "research", "name": "Research", "description": "Web search and analysis"},
+    {"id": "files", "name": "File Operations", "description": "Read, write, edit files"},
+    {"id": "web", "name": "Web Access", "description": "Fetch URLs and browse the web"},
+    {"id": "terminal", "name": "Terminal", "description": "Execute shell commands"},
+    {"id": "memory", "name": "Memory", "description": "Store and recall information"},
+]
+
+DEFAULT_ENDPOINTS = [
+    {"type": "ws", "url": None, "description": "WebSocket for direct BFP communication"},
+    {"type": "a2a", "url": None, "description": "A2A-compatible HTTP endpoint"},
+]
+
+_signed_card = None
+_lock = threading.Lock()
+
+
+def get_capabilities() -> list:
+    return list(DEFAULT_CAPABILITIES)
+
+
+def add_capability(cap_id: str, name: str, desc: str):
+    caps = get_capabilities()
+    for c in caps:
+        if c["id"] == cap_id:
+            c["name"] = name
+            c["description"] = desc
+            break
+    else:
+        caps.append({"id": cap_id, "name": name, "description": desc})
+    global _signed_card
+    _signed_card = None
+    generate_agent_card()
+
+
+def generate_agent_card(endpoints: list = None) -> dict:
+    did = get_did()
+    card = {
+        "did": did,
+        "name": AGENT_NAME,
+        "version": AGENT_VERSION,
+        "human": AGENT_HUMAN,
+        "capabilities": get_capabilities(),
+        "endpoints": endpoints or list(DEFAULT_ENDPOINTS),
+        "publicKey": did.replace("did:bfp:", ""),
+    }
+    signed = sign(card)
+    BFP_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CARD_FILE, "w") as f:
+        json.dump(signed, f, indent=2)
+    global _signed_card
+    _signed_card = signed
+    return signed
+
+
+def get_signed_card() -> dict:
+    global _signed_card
+    if _signed_card is not None:
+        return _signed_card
+    with _lock:
+        if _signed_card is not None:
+            return _signed_card
+        if CARD_FILE.exists():
+            with open(CARD_FILE) as f:
+                _signed_card = json.load(f)
+            return _signed_card
+        return generate_agent_card()
+
+
+def to_a2a_format(card: dict) -> dict:
+    return {
+        "name": card.get("name", AGENT_NAME),
+        "description": f"BFP Agent: {card.get('name', AGENT_NAME)}",
+        "url": None,
+        "skills": [
+            {"id": c["id"], "name": c["name"], "description": c["description"]}
+            for c in card.get("capabilities", [])
+        ],
+        "authentication": {"schemes": ["did:bfp"]},
+        "version": card.get("version", AGENT_VERSION),
+    }
+
+
+class AgentCardHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        if self.path == "/.well-known/agent-card.json":
+            card = get_signed_card()
+            body = json.dumps(card).encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def do_OPTIONS(self):
+        self.send_response(204)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.end_headers()
+
+    def log_message(self, fmt, *args):
+        logger.debug("AgentCard: %s", fmt % args)
+
+
+class AgentCardServer:
+    def __init__(self, host: str = "0.0.0.0", port: int = 8765):
+        self.host = host
+        self.port = port
+        self.server = HTTPServer((host, port), AgentCardHandler)
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+
+    def start(self):
+        self.thread.start()
+        logger.info("Agent Card server listening on %s:%s", self.host, self.port)
+
+    def stop(self):
+        self.server.shutdown()
+        logger.info("Agent Card server stopped")
+
+
+_server_instance = None
+
+
+def serve_agent_card(host: str = "0.0.0.0", port: int = 8765):
+    global _server_instance
+    if _server_instance is not None:
+        return _server_instance
+    _server_instance = AgentCardServer(host, port)
+    _server_instance.start()
+    return _server_instance

package/core/bfp_connector.py

@@ -0,0 +1,177 @@
+"""BFP Connector — high-level relay-based agent communication.
+
+Manages a persistent WebSocket connection to the BFP relay for:
+  - Discovery (find agents by capability)
+  - Message passing (send/receive through relay, no NAT issues)
+  - Task delegation and response
+"""
+
+import asyncio
+import json
+import logging
+import uuid
+from typing import Callable, Optional
+
+import websockets
+
+from core.bfp_discovery import BFPDiscovery
+from core.bfp_identity import get_did
+from core.bfp_agent_card import get_capabilities
+from core.bfp_tasks import create_task, get_task, process_task
+
+logger = logging.getLogger(__name__)
+
+
+class BFPConnector:
+    """Persistent relay connection for discovery + message passing.
+
+    Flow:
+      1. connect(relay_url) → opens WebSocket to relay, registers DID
+      2. find_agents(capability) → REST query to relay directory
+      3. send(target_did, payload) → relay forwards to target's WS connection
+      4. Incoming messages from relay are dispatched to on_message handler
+    """
+
+    def __init__(self):
+        self.my_did = get_did()
+        self.relay_url = None
+        self._ws = None
+        self._reader_task = None
+        self._running = False
+        self._pending: dict[str, asyncio.Future] = {}
+        self._on_message: Optional[Callable] = None
+        self._inbox: asyncio.Queue = asyncio.Queue()
+        self._reconnect_task = None
+
+    @property
+    def is_connected(self) -> bool:
+        return self._running and self._ws is not None
+
+    async def connect(self, relay_url: str, on_message: Callable = None):
+        """Open persistent WS to relay and register."""
+        self.relay_url = relay_url.rstrip("/")
+        self._on_message = on_message
+        ws_url = self.relay_url.replace("http://", "ws://").replace("https://", "wss://") + "/ws"
+        self._ws = await websockets.connect(ws_url)
+        self._running = True
+
+        caps = [c["id"] for c in get_capabilities()]
+        await self._ws.send(json.dumps({
+            "action": "register",
+            "did": self.my_did,
+            "endpoint": f"relay:{self.relay_url}",
+            "capabilities": caps,
+            "name": "BMO",
+        }))
+        resp = json.loads(await self._ws.recv())
+        logger.info("BFP relay register: %s", resp.get("status", "ok"))
+
+        self._reader_task = asyncio.create_task(self._reader())
+        logger.info("BFP connector connected to relay %s", relay_url)
+
+    async def _reader(self):
+        try:
+            async for raw in self._ws:
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+                msg_type = msg.get("type", "")
+
+                if msg_type == "relay_message":
+                    request_id = msg.get("requestId", "")
+                    from_did = msg.get("fromDid", "")
+                    payload = msg.get("payload", {})
+                    await self._handle_incoming(from_did, payload, request_id)
+                elif msg_type == "send_result":
+                    request_id = msg.get("requestId", "")
+                    future = self._pending.get(request_id)
+                    if future and not future.done():
+                        future.set_result(msg)
+                elif msg_type == "agent_list":
+                    pass
+        except websockets.exceptions.ConnectionClosed:
+            logger.warning("BFP relay WS disconnected")
+        finally:
+            self._running = False
+            if self._reconnect_task is None:
+                self._reconnect_task = asyncio.create_task(self._reconnect_loop())
+
+    async def _handle_incoming(self, from_did: str, payload: dict, request_id: str):
+        task_data = payload.get("params", {}).get("task", payload)
+        task_id = create_task(task_data, from_did)
+        task = get_task(task_id)
+        result = task.get("result", "") if task else ""
+
+        if request_id and self._ws and not self._ws.closed:
+            await self._ws.send(json.dumps({
+                "action": "relay_response",
+                "requestId": request_id,
+                "payload": {"task_id": task_id, "result": result, "from": self.my_did},
+            }))
+
+        if self._on_message:
+            await self._on_message(from_did, task_id, result)
+
+    async def _reconnect_loop(self):
+        await asyncio.sleep(5)
+        while not self._running:
+            try:
+                await self.connect(self.relay_url, self._on_message)
+                logger.info("BFP reconnected to relay")
+                self._reconnect_task = None
+                return
+            except Exception as e:
+                logger.warning("BFP reconnect failed: %s, retry in 10s", e)
+                await asyncio.sleep(10)
+
+    async def send(self, target_did: str, payload: dict, timeout: float = 60.0) -> dict:
+        if not self._ws or self._ws.closed:
+            raise RuntimeError("Not connected to relay")
+        request_id = f"bfp-{uuid.uuid4().hex[:12]}"
+        future = asyncio.get_event_loop().create_future()
+        self._pending[request_id] = future
+        try:
+            await self._ws.send(json.dumps({
+                "action": "send",
+                "targetDid": target_did,
+                "fromDid": self.my_did,
+                "payload": payload,
+                "requestId": request_id,
+            }))
+            result = await asyncio.wait_for(future, timeout=timeout)
+            return result.get("response", {})
+        finally:
+            self._pending.pop(request_id, None)
+
+    async def delegate(self, target_did: str, task_data: dict) -> dict:
+        return await self.send(target_did, {
+            "method": "bfp.delegate",
+            "params": {
+                "from": self.my_did,
+                "to": target_did,
+                "task": task_data,
+            },
+        })
+
+    async def find_agents(self, capability: str = None) -> list[dict]:
+        discovery = BFPDiscovery(self.relay_url)
+        try:
+            if capability:
+                return await discovery.find_by_capability(capability)
+            return await discovery.list_all()
+        finally:
+            await discovery.close()
+
+    async def talk(self, target_did: str, message: str) -> str:
+        result = await self.delegate(target_did, {"query": message, "action": "talk"})
+        return result.get("result", "")
+
+    async def disconnect(self):
+        self._running = False
+        if self._reader_task:
+            self._reader_task.cancel()
+            self._reader_task = None
+        if self._ws:
+            await self._ws.close()
+            self._ws = None

package/core/bfp_discovery.py

@@ -0,0 +1,105 @@
+"""BFP Discovery — Cloudflare Workers registry client.
+
+REST client for registering, resolving, and finding agents by capability
+through the BFP Registry (Cloudflare Workers KV).
+
+Registry URL: https://bfp-registry.aliwey.workers.dev
+              (override via BFP_REGISTRY_URL env var or bmo_init config)
+"""
+
+import logging
+import os
+from typing import Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Default public registry — hosted on Cloudflare Workers (free tier)
+DEFAULT_REGISTRY_URL = "https://bfp-registry.aliwey.workers.dev"
+
+
+class BFPDiscovery:
+    """Client for the BFP Registry (Cloudflare Workers KV)."""
+
+    def __init__(self, relay_url: str = None):
+        # relay_url kept for backward compat but we use the registry URL
+        self.relay_url = relay_url  # local relay WebSocket URL (if any)
+        self.registry_url = (
+            os.getenv("BFP_REGISTRY_URL") or DEFAULT_REGISTRY_URL
+        ).rstrip("/")
+        self._http = httpx.AsyncClient(timeout=10.0)
+
+    # ── Registry (Cloudflare Workers) ─────────────────────────────────────────
+
+    async def register(
+        self,
+        did: str,
+        endpoint: str,
+        caps: list,
+        public_key: str = None,     # unused by Workers registry, kept for compat
+        name: str = None,           # unused by Workers registry, kept for compat
+    ) -> dict:
+        resp = await self._http.post(f"{self.registry_url}/register", json={
+            "did": did,
+            "endpoint": endpoint,
+            "caps": caps,
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    async def unregister(self, did: str) -> None:
+        try:
+            resp = await self._http.post(f"{self.registry_url}/unregister", json={"did": did})
+            resp.raise_for_status()
+        except Exception as e:
+            logger.warning(f"BFP unregister failed: {e}")
+
+    async def lookup(self, did: str) -> Optional[dict]:
+        """Resolve a DID to its current endpoint and capabilities."""
+        try:
+            resp = await self._http.get(f"{self.registry_url}/lookup", params={"did": did})
+            if resp.status_code == 404:
+                return None
+            resp.raise_for_status()
+            return resp.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return None
+            raise
+
+    # kept for backward compat (old code calls resolve(), new calls lookup())
+    async def resolve(self, did: str) -> Optional[dict]:
+        return await self.lookup(did)
+
+    async def find_agents(self, capability: str = None) -> list[dict]:
+        """Find online agents by capability (or list all if no capability given)."""
+        params = {"capability": capability} if capability else {}
+        resp = await self._http.get(f"{self.registry_url}/list", params=params)
+        resp.raise_for_status()
+        data = resp.json()
+        # Registry returns a list; old relay returned {"agents": [...]}
+        if isinstance(data, list):
+            return data
+        return data.get("agents", [])
+
+    # kept for backward compat (old code calls find_by_capability)
+    async def find_by_capability(self, capability: str) -> list[dict]:
+        return await self.find_agents(capability)
+
+    async def list_all(self) -> list[dict]:
+        resp = await self._http.get(f"{self.registry_url}/list")
+        resp.raise_for_status()
+        result = resp.json()
+        if isinstance(result, list):
+            return result
+        return result.get("agents", [])
+
+    async def health(self) -> dict:
+        """Check registry health."""
+        resp = await self._http.get(f"{self.registry_url}/health")
+        resp.raise_for_status()
+        return resp.json()
+
+    async def close(self):
+        await self._http.aclose()

package/core/bfp_identity.py

@@ -0,0 +1,83 @@
+import json
+import os
+from pathlib import Path
+
+import base58
+from nacl.encoding import RawEncoder
+from nacl.signing import SigningKey, VerifyKey
+
+from config.settings import DATA_DIR
+
+
+BFP_DIR = DATA_DIR / "bfp"
+IDENTITY_KEY_FILE = BFP_DIR / "identity.key"
+AGENT_CARD_FILE = BFP_DIR / "agent-card.json"
+
+_signing_key: SigningKey | None = None
+_verify_key: VerifyKey | None = None
+_did: str | None = None
+
+
+def _ensure_identity():
+    global _signing_key, _verify_key, _did
+    if _signing_key is not None:
+        return
+
+    BFP_DIR.mkdir(parents=True, exist_ok=True)
+
+    if IDENTITY_KEY_FILE.exists():
+        seed = IDENTITY_KEY_FILE.read_bytes()
+    else:
+        seed = os.urandom(32)
+        IDENTITY_KEY_FILE.write_bytes(seed)
+
+    _signing_key = SigningKey(seed, encoder=RawEncoder)
+    _verify_key = _signing_key.verify_key
+    pub_bytes = _verify_key.encode(encoder=RawEncoder)
+    _did = "did:bfp:" + base58.b58encode(pub_bytes).decode("ascii")
+
+
+def get_did() -> str:
+    _ensure_identity()
+    return _did
+
+
+def sign(data: dict) -> dict:
+    _ensure_identity()
+    payload = json.dumps(data, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    signed = _signing_key.sign(payload, encoder=RawEncoder)
+    return {**data, "signature": base58.b58encode(signed.signature).decode("ascii")}
+
+
+def verify(did: str, data: dict) -> bool:
+    if "signature" not in data:
+        return False
+    signature_b58 = data["signature"]
+    remaining = {k: v for k, v in data.items() if k != "signature"}
+    payload = json.dumps(remaining, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    try:
+        if not did.startswith("did:bfp:"):
+            return False
+        pub_b58 = did[len("did:bfp:"):]
+        pub_bytes = base58.b58decode(pub_b58)
+        sig_bytes = base58.b58decode(signature_b58)
+        verify_key = VerifyKey(pub_bytes)
+        verify_key.verify(payload, sig_bytes)
+        return True
+    except Exception:
+        return False
+
+
+def get_agent_card() -> dict:
+    _ensure_identity()
+    if AGENT_CARD_FILE.exists():
+        return json.loads(AGENT_CARD_FILE.read_text("utf-8"))
+    pub_bytes = _verify_key.encode(encoder=RawEncoder)
+    card = {
+        "did": _did,
+        "name": "BMO",
+        "version": "1.0.0",
+        "publicKey": base58.b58encode(pub_bytes).decode("ascii"),
+    }
+    AGENT_CARD_FILE.write_text(json.dumps(card, indent=2), "utf-8")
+    return card

package/core/bfp_tasks.py

@@ -0,0 +1,70 @@
+"""Shared task registry for BFP delegation.
+
+Both the WebSocket transport server and the A2A HTTP bridge use this
+module to create, track, and process delegated tasks — no WebSocket
+loopback required.
+"""
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+_tasks: dict[str, dict] = {}
+
+
+def create_task(task_data: dict, source_did: str) -> str:
+    task_id = f"task-{uuid.uuid4().hex[:12]}"
+    now = datetime.now(timezone.utc).isoformat()
+    _tasks[task_id] = {
+        "id": task_id,
+        "source": source_did,
+        "data": task_data,
+        "status": "pending",
+        "result": None,
+        "error": None,
+        "created_at": now,
+        "updated_at": now,
+        "completed_at": None,
+    }
+    logger.info("Task %s created by %s", task_id, source_did)
+    process_task(task_id)
+    return task_id
+
+
+def get_task(task_id: str) -> Optional[dict]:
+    return _tasks.get(task_id)
+
+
+def update_task(task_id: str, status: str, result: str = None, error: str = None):
+    task = _tasks.get(task_id)
+    if task is None:
+        return
+    task["status"] = status
+    task["updated_at"] = datetime.now(timezone.utc).isoformat()
+    if result is not None:
+        task["result"] = result
+    if error is not None:
+        task["error"] = error
+    if status in ("completed", "failed", "cancelled"):
+        task["completed_at"] = task["updated_at"]
+
+
+def process_task(task_id: str) -> None:
+    """Process a task — currently auto-completes with placeholder.
+
+    In the future this will route through BMO's engine or dispatch to
+    worker processes for real execution.
+    """
+    task = _tasks.get(task_id)
+    if task is None or task["status"] != "pending":
+        return
+    task["status"] = "processing"
+    task["updated_at"] = datetime.now(timezone.utc).isoformat()
+    task["status"] = "completed"
+    task["result"] = f"Delegated task processed. Payload: {task['data']}"
+    task["completed_at"] = datetime.now(timezone.utc).isoformat()
+    task["updated_at"] = task["completed_at"]
+    logger.info("Task %s completed", task_id)