@agentunion/kite 1.2.0 → 1.3.0

package/extensions/services/watchdog/monitor.py

@@ -9,8 +9,6 @@ import json
 import time
 from datetime import datetime, timezone
 
-import httpx
-
 
 # Module health states
 HEALTHY = "healthy"
@@ -68,12 +66,11 @@ class HealthMonitor:
     # Check intervals per resource state
     INTERVALS = {NORMAL: 15, WARNING: 5, CRITICAL: 2}
 
-    def __init__(self, own_token: str, registry_url: str, launcher_url: str,
-                 publish_event=None):
+    def __init__(self, own_token: str, kernel_port: int, publish_event=None):
         self.own_token = own_token
-        self.registry_url = registry_url
-        self.launcher_url = launcher_url
+        self.kernel_port = kernel_port
         self.publish_event = publish_event  # async callable(event_dict)
+        self.rpc_call = None  # set by entry.py: async callable(method, params)
         self.modules: dict[str, ModuleStatus] = {}
         self._running = False
         self._psutil = None  # lazy import
@@ -81,7 +78,7 @@ class HealthMonitor:
         # Restart decision state (module.exiting / module.stopped / module.ready)
         self._exit_intents: dict[str, str] = {}        # module_id -> action from module.exiting
         self._graceful_modules: dict[str, bool] = {     # module_id -> supports graceful shutdown
-            "registry": True, "event_hub": True,        # started before Watchdog, default True
+            "kernel": True,                                # started before Watchdog, default True
         }
         self._system_shutting_down = False
         self._system_ready = False
@@ -91,43 +88,34 @@ class HealthMonitor:
     # ── Module discovery ──
 
     async def discover_modules(self):
-        """Fetch monitored modules from Launcher API + Registry health endpoints."""
-        # Step 1: Get module list with monitor/pid from Launcher API
-        monitored = {}  # name -> {pid, running}
+        """Fetch monitored modules from Launcher + Registry via RPC."""
+        # Step 1: Get module list with monitor/pid from Launcher via RPC
+        monitored = {}  # name -> pid
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.get(
-                    f"{self.launcher_url}/launcher/modules", timeout=5,
-                )
-                if resp.status_code == 200:
-                    for m in resp.json():
-                        name = m.get("name", "")
-                        if name == "watchdog" or not m.get("monitor", True):
-                            continue
-                        if m.get("actual_state", "").startswith("running"):
-                            monitored[name] = m.get("pid")
+            resp = await self.rpc_call("launcher.list_modules", {})
+            result = resp.get("result", {})
+            for m in result.get("modules", []):
+                name = m.get("name", "")
+                if name == "watchdog" or not m.get("monitor", True):
+                    continue
+                if m.get("actual_state", "").startswith("running"):
+                    monitored[name] = m.get("pid")
         except Exception as e:
-            print(f"[watchdog] Launcher API failed: {e}")
+            print(f"[watchdog] Launcher RPC failed: {e}")
             return
 
-        # Step 2: Get health endpoints from Registry
+        # Step 2: Get health endpoints from Registry via RPC
         health_map = {}  # name -> {api_endpoint, health_endpoint}
-        headers = {"Authorization": f"Bearer {self.own_token}"}
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.get(
-                    f"{self.registry_url}/lookup",
-                    params={"field": "health_endpoint"},
-                    headers=headers, timeout=5,
-                )
-                if resp.status_code == 200:
-                    for entry in resp.json():
-                        mid = entry.get("module", "")
-                        if mid in monitored:
-                            health_map[mid] = {
-                                "api_endpoint": entry.get("api_endpoint", ""),
-                                "health_endpoint": entry.get("value", "/health"),
-                            }
+            resp = await self.rpc_call("registry.lookup", {"field": "health_endpoint"})
+            result = resp.get("result", {})
+            for entry in result.get("results", []):
+                mid = entry.get("module", "")
+                if mid in monitored:
+                    health_map[mid] = {
+                        "api_endpoint": entry.get("api_endpoint", ""),
+                        "health_endpoint": entry.get("value", "/health"),
+                    }
         except Exception:
             pass
 
@@ -215,28 +203,27 @@ class HealthMonitor:
     # ── Restart via Launcher API ──
 
     async def _restart_module(self, status: ModuleStatus):
-        """Restart a module via Launcher API."""
+        """Restart a module via Launcher RPC."""
         mid = status.module_id
         print(f"[watchdog] Restarting {mid} (attempt {status.restarted_count + 1}/{self.MAX_RESTARTS})")
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.post(
-                    f"{self.launcher_url}/launcher/modules/{mid}/restart",
-                    json={"reason": "resource_critical" if status.resource_state == CRITICAL else "restart"},
-                    timeout=15,
-                )
-                if resp.status_code == 200:
-                    status.restarted_count += 1
-                    status.fail_count = 0
-                    print(f"[watchdog] {mid} restart requested")
-                    if status.restarted_count >= self.ALERT_AFTER_RESTARTS:
-                        await self._publish("watchdog.alert", {
-                            "module_id": mid,
-                            "restarted_count": status.restarted_count,
-                            "message": f"{mid} has been restarted {status.restarted_count} times",
-                        })
-                else:
-                    print(f"[watchdog] {mid} restart failed: HTTP {resp.status_code}")
+            resp = await self.rpc_call("launcher.restart_module", {
+                "name": mid,
+                "reason": "resource_critical" if status.resource_state == CRITICAL else "restart",
+            })
+            result = resp.get("result", {})
+            if result.get("status") == "restarted":
+                status.restarted_count += 1
+                status.fail_count = 0
+                print(f"[watchdog] {mid} restart requested")
+                if status.restarted_count >= self.ALERT_AFTER_RESTARTS:
+                    await self._publish("watchdog.alert", {
+                        "module_id": mid,
+                        "restarted_count": status.restarted_count,
+                        "message": f"{mid} has been restarted {status.restarted_count} times",
+                    })
+            else:
+                print(f"[watchdog] {mid} restart failed: {result}")
         except Exception as e:
             print(f"[watchdog] {mid} restart error: {e}")
 
@@ -366,7 +353,7 @@ class HealthMonitor:
     # ── Incoming event handler ──
 
     async def handle_event(self, msg: dict):
-        """Handle events from Event Hub — restart decisions + health tracking."""
+        """Handle events from Kernel — restart decisions + health tracking."""
         event_type = msg.get("event", "")
         data = msg.get("data", {})
         module_id = data.get("module_id", "")
@@ -457,19 +444,18 @@ class HealthMonitor:
             })
 
     async def _restart_module_by_id(self, module_id: str, reason: str = "restart"):
-        """Restart a module via Launcher API by module_id."""
+        """Restart a module via Launcher RPC by module_id."""
         print(f"[watchdog] Requesting restart for {module_id} (reason={reason})")
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.post(
-                    f"{self.launcher_url}/launcher/modules/{module_id}/restart",
-                    json={"reason": reason},
-                    timeout=15,
-                )
-                if resp.status_code == 200:
-                    print(f"[watchdog] {module_id} restart requested successfully")
-                else:
-                    print(f"[watchdog] {module_id} restart failed: HTTP {resp.status_code}")
+            resp = await self.rpc_call("launcher.restart_module", {
+                "name": module_id,
+                "reason": reason,
+            })
+            result = resp.get("result", {})
+            if result.get("status") == "restarted":
+                print(f"[watchdog] {module_id} restart requested successfully")
+            else:
+                print(f"[watchdog] {module_id} restart failed: {result}")
         except Exception as e:
             print(f"[watchdog] {module_id} restart error: {e}")
 

package/extensions/services/web/entry.py

@@ -17,7 +17,8 @@ import traceback
 import uuid
 from datetime import datetime, timezone
 
-import httpx
+import asyncio
+import websockets
 import uvicorn
 
 
@@ -300,77 +301,6 @@ def _bind_port(preferred: int, host: str, max_attempts: int = 10) -> int | None:
     return None
 
 
-def _register_to_registry(client: httpx.Client, token: str, registry_url: str, host: str, port: int):
-    payload = {
-        "action": "register",
-        "module_id": "web",
-        "module_type": "service",
-        "name": "Web Management",
-        "api_endpoint": f"http://127.0.0.1:{port}",
-        "health_endpoint": "/health",
-        "events_publish": {
-            "web.test": {"description": "Test event from web module"},
-        },
-        "events_subscribe": [
-            "module.started",
-            "module.stopped",
-            "module.shutdown",
-        ],
-    }
-    headers = {"Authorization": f"Bearer {token}"}
-    try:
-        resp = client.post(f"{registry_url}/modules", json=payload, headers=headers)
-        if resp.status_code == 200:
-            pass  # timing printed in main()
-        else:
-            print(f"[web] WARNING: Registry returned {resp.status_code}")
-    except Exception as e:
-        print(f"[web] WARNING: Registry registration failed: {e}")
-
-
-def _get_event_hub_ws(client: httpx.Client, token: str, registry_url: str) -> str:
-    """Discover Event Hub WebSocket endpoint from Registry, with retry."""
-    headers = {"Authorization": f"Bearer {token}"}
-    deadline = time.time() + 10
-    while time.time() < deadline:
-        try:
-            resp = client.get(
-                f"{registry_url}/get/event_hub.metadata.ws_endpoint",
-                headers=headers,
-            )
-            if resp.status_code == 200:
-                val = resp.json()
-                if val:
-                    return val
-        except Exception:
-            pass
-        time.sleep(0.2)
-    return ""
-
-
-def _send_exiting_event(ws_url: str, token: str, reason: str):
-    """Send module.exiting event to Event Hub before exit. Best-effort, non-blocking."""
-    try:
-        import websockets.sync.client as ws_sync
-        url = f"{ws_url}?token={token}&id=web"
-        with ws_sync.connect(url, close_timeout=3) as ws:
-            msg = {
-                "type": "event",
-                "event_id": str(uuid.uuid4()),
-                "event": "module.exiting",
-                "source": "web",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "data": {
-                    "module_id": "web",
-                    "reason": reason,
-                    "action": "none",
-                },
-            }
-            ws.send(json.dumps(msg))
-            # Brief wait for delivery
-            time.sleep(0.3)
-    except Exception as e:
-        print(f"[web] WARNING: Could not send module.exiting: {e}")
 
 
 def main():
@@ -412,55 +342,28 @@ def main():
     except Exception:
         pass
 
-    # Read registry_port from environment variable
-    registry_port = int(os.environ.get("KITE_REGISTRY_PORT", "0"))
+    # Read kernel_port from environment variable
+    kernel_port = int(os.environ.get("KITE_KERNEL_PORT", "0"))
 
-    if not token or not registry_port:
-        print("[web] ERROR: Missing token or KITE_REGISTRY_PORT")
+    if not token or not kernel_port:
+        print("[web] ERROR: Missing token or KITE_KERNEL_PORT")
         sys.exit(1)
 
-    print(f"[web] Token received ({len(token)} chars), registry port: {registry_port} ({_fmt_elapsed(_t0)})")
+    print(f"[web] Token received ({len(token)} chars), kernel port: {kernel_port} ({_fmt_elapsed(_t0)})")
 
     # Read preferred_port from module.md
     md_cfg = _read_module_md()
     host = md_cfg["advertise_ip"]
     port = _bind_port(md_cfg["preferred_port"], host)
 
-    registry_url = f"http://127.0.0.1:{registry_port}"
-
-    # If port binding failed after 10 attempts, exit gracefully (no watchdog restart)
+    # If port binding failed after 10 attempts, exit gracefully
     if port is None:
-        print("[web] ERROR: Cannot bind to any port, attempting graceful exit")
-
-        # Try to discover Event Hub and send module.exiting event
-        client = httpx.Client(timeout=5)
-        event_hub_ws = _get_event_hub_ws(client, token, registry_url)
-        client.close()
-
-        if event_hub_ws:
-            reason = f"Port binding failed after 10 attempts ({md_cfg['preferred_port']}-{md_cfg['preferred_port']+9})"
-            _send_exiting_event(event_hub_ws, token, reason)
-            print("[web] module.exiting event sent")
-        else:
-            print("[web] WARNING: Could not discover Event Hub, exiting without event")
-
-        sys.exit(1)  # Exit code 1 = startup failure
-
-    # Register and discover Event Hub synchronously before starting uvicorn
-    client = httpx.Client(timeout=5)
-    _register_to_registry(client, token, registry_url, host, port)
-    print(f"[web] Registered to Registry ({_fmt_elapsed(_t0)})")
-    event_hub_ws = _get_event_hub_ws(client, token, registry_url)
-    if not event_hub_ws:
-        print("[web] WARNING: Could not discover Event Hub WS, events disabled")
-    else:
-        print(f"[web] Discovered Event Hub: {event_hub_ws}")
-    client.close()
+        print("[web] ERROR: Cannot bind to any port, exiting")
+        sys.exit(1)
 
     server = WebServer(
         token=token,
-        registry_url=registry_url,
-        event_hub_ws=event_hub_ws,
+        kernel_port=kernel_port,
         host=host,
         port=port,
         boot_t0=_t0,

package/extensions/services/web/server.py

@@ -2,8 +2,7 @@
 Web Management HTTP server.
 Full web UI with all AI Phone Agent API endpoints.
 Exposes /health, /status, static frontend, and all /api/* routes.
-Connects to Event Hub via WebSocket for event publishing and subscription.
-Sends periodic heartbeat to Registry and test events to Event Hub.
+Connects to Kernel via WebSocket JSON-RPC 2.0 for event publishing and subscription.
 """
 
 import asyncio
@@ -14,7 +13,6 @@ import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 
-import httpx
 import websockets
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
@@ -38,17 +36,14 @@ logger = logging.getLogger(__name__)
 
 class WebServer:
 
-    def __init__(self, token: str = "", registry_url: str = "",
-                 event_hub_ws: str = "",
+    def __init__(self, token: str = "", kernel_port: int = 0,
                  host: str = "0.0.0.0", port: int = 0, boot_t0: float = 0):
         self.token = token
-        self.registry_url = registry_url
-        self.event_hub_ws = event_hub_ws
+        self.kernel_port = kernel_port
         self.host = host
         self.port = port
         self.boot_t0 = boot_t0
         self._ws_task: asyncio.Task | None = None
-        self._heartbeat_task: asyncio.Task | None = None
         self._test_task: asyncio.Task | None = None
         self._ws: object | None = None
         self._ready_sent = False
@@ -102,15 +97,12 @@ class WebServer:
             logger.info("Web Management: managers initialized")
 
             # Start background tasks directly
-            server._heartbeat_task = asyncio.create_task(server._heartbeat_loop())
-            if server.event_hub_ws:
+            if server.kernel_port:
                 server._ws_task = asyncio.create_task(server._ws_loop())
             server._test_task = asyncio.create_task(server._test_event_loop())
 
         @app.on_event("shutdown")
         async def _shutdown():
-            if server._heartbeat_task:
-                server._heartbeat_task.cancel()
             if server._ws_task:
                 server._ws_task.cancel()
             if server._test_task:
@@ -127,7 +119,7 @@ class WebServer:
             return {
                 "status": "healthy",
                 "details": {
-                    "event_hub_connected": server._ws is not None,
+                    "kernel_connected": server._ws is not None,
                     "uptime_seconds": round(time.time() - server._start_time),
                 },
             }
@@ -158,10 +150,10 @@ class WebServer:
 
         return app
 
-    # ── Event Hub WebSocket client ──
+    # ── Kernel WebSocket client ──
 
     async def _ws_loop(self):
-        """Connect to Event Hub, subscribe, and listen. Reconnect on failure."""
+        """Connect to Kernel, subscribe, register, and listen. Reconnect on failure."""
         retry_delay = 0.5  # start with 0.5s
         max_delay = 30  # cap at 30s
         while not self._shutting_down:
@@ -171,7 +163,7 @@ class WebServer:
             except asyncio.CancelledError:
                 return
             except Exception as e:
-                print(f"[web] Event Hub connection error: {e}, retrying in {retry_delay:.1f}s")
+                print(f"[web] Kernel connection error: {e}, retrying in {retry_delay:.1f}s")
             self._ws = None
             if self._shutting_down:
                 return
@@ -179,35 +171,52 @@ class WebServer:
             retry_delay = min(retry_delay * 2, max_delay)  # exponential backoff
 
     async def _ws_connect(self):
-        """Single WebSocket session: connect, subscribe, receive loop."""
-        url = f"{self.event_hub_ws}?token={self.token}&id=web"
-        print(f"[web] WS connecting to {self.event_hub_ws}")
-        async with websockets.connect(url, open_timeout=3, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
+        """Single WebSocket session: connect, register, subscribe, receive loop."""
+        url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=web"
+        print(f"[web] WS connecting to Kernel")
+        async with websockets.connect(url, open_timeout=5, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
             self._ws = ws
             elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
             elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-            print(f"[web] Connected to Event Hub{elapsed_str}")
+            print(f"[web] Connected to Kernel{elapsed_str}")
+
+            # Subscribe to events
+            await self._rpc_call(ws, "event.subscribe", {
+                "events": [
+                    "module.started",
+                    "module.stopped",
+                    "module.shutdown",
+                ],
+            })
 
-            # Subscribe to module lifecycle events + shutdown
-            await ws.send(json.dumps({
-                "type": "subscribe",
-                "events": ["module.started", "module.stopped", "module.shutdown"],
-            }))
+            # Register to Kernel Registry via RPC
+            await self._rpc_call(ws, "registry.register", {
+                "module_id": "web",
+                "module_type": "service",
+                "api_endpoint": f"http://127.0.0.1:{self.port}",
+                "health_endpoint": "/health",
+                "events_publish": {
+                    "web.test": {"description": "Test event from web module"},
+                    "web.started": {"description": "Web UI started with access URL"},
+                },
+                "events_subscribe": [
+                    "module.started",
+                    "module.stopped",
+                    "module.shutdown",
+                ],
+            })
+            print(f"[web] Registered to Kernel{elapsed_str}")
 
             # Send module.ready (once) so Launcher knows we're up
             if not self._ready_sent:
-                ready_msg = {
-                    "type": "event",
+                await self._rpc_call(ws, "event.publish", {
                     "event_id": str(uuid.uuid4()),
                     "event": "module.ready",
-                    "source": "web",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "data": {
                         "module_id": "web",
                         "graceful_shutdown": True,
                     },
-                }
-                await ws.send(json.dumps(ready_msg))
+                })
                 self._ready_sent = True
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
@@ -225,7 +234,6 @@ class WebServer:
                         "port": self.port,
                     },
                 })
-                print(f"[web] \033[32m✓ Web UI ready: {access_url}\033[0m")
 
             # Receive loop
             async for raw in ws:
@@ -235,22 +243,84 @@ class WebServer:
                     continue
 
                 try:
-                    msg_type = msg.get("type", "")
-                    if msg_type == "event":
-                        event_name = msg.get("event", "")
-                        if event_name == "module.shutdown":
-                            target = (msg.get("data") if isinstance(msg.get("data"), dict) else {}).get("module_id", "")
-                            if target == "web":
-                                await self._handle_shutdown(ws)
-                                return
-                    elif msg_type == "ack":
-                        pass  # publish confirmed
-                    elif msg_type == "error":
-                        print(f"[web] Event Hub error: {msg.get('message')}")
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+
+                    if has_method and not has_id:
+                        # Event Notification
+                        await self._handle_event_notification(msg)
+                    elif has_method and has_id:
+                        # Incoming RPC request
+                        await self._handle_rpc_request(ws, msg)
+                    # Ignore RPC responses (we don't await them in this simple impl)
                 except Exception as e:
-                    print(f"[web] 事件处理异常（已忽略）: {e}")
+                    print(f"[web] 消息处理异常（已忽略）: {e}")
+
+    async def _rpc_call(self, ws, method: str, params: dict = None):
+        """Send a JSON-RPC 2.0 request (fire-and-forget, no response awaited)."""
+        msg = {"jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": method}
+        if params:
+            msg["params"] = params
+        await ws.send(json.dumps(msg))
+
+    async def _handle_event_notification(self, msg: dict):
+        """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
+        params = msg.get("params", {})
+        event_type = params.get("event", "")
+        data = params.get("data", {})
+
+        # Special handling for module.shutdown targeting web
+        if event_type == "module.shutdown" and data.get("module_id") == "web":
+            await self._handle_shutdown()
+            return
+
+        # Log other events
+        print(f"[web] Event received: {event_type}")
+
+    async def _handle_rpc_request(self, ws, msg: dict):
+        """Handle an incoming RPC request (web.* methods)."""
+        rpc_id = msg.get("id", "")
+        method = msg.get("method", "")
+        params = msg.get("params", {})
+
+        handlers = {
+            "health": lambda p: self._rpc_health(),
+            "status": lambda p: self._rpc_status(),
+        }
+        handler = handlers.get(method)
+        if handler:
+            try:
+                result = await handler(params)
+                await ws.send(json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}))
+            except Exception as e:
+                await ws.send(json.dumps({
+                    "jsonrpc": "2.0", "id": rpc_id,
+                    "error": {"code": -32603, "message": str(e)},
+                }))
+        else:
+            await ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": rpc_id,
+                "error": {"code": -32601, "message": f"Method not found: {method}"},
+            }))
+
+    async def _rpc_health(self) -> dict:
+        """RPC handler for web.health."""
+        return {
+            "status": "healthy",
+            "details": {
+                "uptime_seconds": round(time.time() - self._start_time),
+            },
+        }
+
+    async def _rpc_status(self) -> dict:
+        """RPC handler for web.status."""
+        return {
+            "module": "web",
+            "status": "running",
+            "uptime_seconds": round(time.time() - self._start_time),
+        }
 
-    async def _handle_shutdown(self, ws):
+    async def _handle_shutdown(self):
         """Handle module.shutdown: ack → cleanup → ready → exit."""
         print("[web] Received module.shutdown")
         self._shutting_down = True
@@ -263,8 +333,6 @@ class WebServer:
         print("[web] shutdown ack sent")
 
         # Step 2: Cleanup (cancel background tasks)
-        if self._heartbeat_task:
-            self._heartbeat_task.cancel()
         if self._test_task:
             self._test_task.cancel()
         if self.bt_manager:
@@ -282,39 +350,14 @@ class WebServer:
             self._uvicorn_server.should_exit = True
 
     async def _publish_event(self, event: dict):
-        """Publish an event to Event Hub via WebSocket."""
+        """Publish an event via RPC event.publish."""
         if not self._ws:
             return
-        msg = {
-            "type": "event",
+        await self._rpc_call(self._ws, "event.publish", {
             "event_id": str(uuid.uuid4()),
             "event": event.get("event", ""),
-            "source": "web",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
             "data": event.get("data", {}),
-        }
-        try:
-            await self._ws.send(json.dumps(msg))
-        except Exception as e:
-            print(f"[web] Failed to publish event: {e}")
-
-    # ── Heartbeat to Registry ──
-
-    async def _heartbeat_loop(self):
-        """Send heartbeat to Registry every 30 seconds."""
-        while True:
-            await asyncio.sleep(30)
-            try:
-                async with httpx.AsyncClient() as client:
-                    await client.post(
-                        f"{self.registry_url}/modules",
-                        json={"action": "heartbeat", "module_id": "web"},
-                        headers={"Authorization": f"Bearer {self.token}"},
-                        timeout=5,
-                    )
-                print("[web] heartbeat sent")
-            except Exception:
-                pass
+        })
 
     # ── Test event loop ──