@agentunion/kite 1.0.6 → 1.2.0

package/core/registry/store.py

@@ -5,6 +5,7 @@ No persistence — Registry crash triggers Kite full restart, all modules re-reg
 """
 
 import fnmatch
+import os
 import time
 from typing import Any
 
@@ -18,20 +19,30 @@ class RegistryStore:
         self.heartbeats: dict[str, float] = {}     # module_id -> last heartbeat timestamp
         self.ttl = 60           # seconds before marking offline
         self.heartbeat_interval = 30
+        self.is_debug = os.environ.get("KITE_DEBUG") == "1"
 
     # ── Token verification ──
 
     def verify_token(self, token: str) -> str | None:
-        """Return module_id if token is valid, None otherwise."""
+        """Return module_id if token is valid, None otherwise.
+        In debug mode (KITE_DEBUG=1), any non-empty token is accepted,
+        but known tokens still resolve to their proper module_id first."""
         if token == self.launcher_token:
             return "launcher"
         for mid, tok in self.token_map.items():
             if token == tok:
                 return mid
+        if self.is_debug and token:
+            return "debug"
         return None
 
     def is_launcher(self, token: str) -> bool:
-        return token == self.launcher_token
+        """Check if token belongs to Launcher. In debug mode, also accept any token."""
+        if token == self.launcher_token:
+            return True
+        if self.is_debug and token:
+            return True
+        return False
 
     def register_tokens(self, mapping: dict[str, str]):
         """Register module_id -> token mapping. Only Launcher may call this."""

package/extensions/agents/__init__.py

@@ -0,0 +1 @@
+

package/extensions/agents/assistant/__init__.py

@@ -0,0 +1 @@
+

package/extensions/agents/assistant/entry.py

@@ -0,0 +1,380 @@
+"""
+Assistant entry point.
+Reads boot_info from stdin, registers to Registry, starts assistant agent.
+"""
+
+import builtins
+import json
+import os
+import socket
+import sys
+import threading
+import re
+import time
+from datetime import datetime, timezone
+
+import httpx
+import uvicorn
+
+
+# ── Safe stdout/stderr: ignore BrokenPipeError after Launcher closes stdio ──
+
+
+# ── Module configuration ──
+MODULE_NAME = "assistant"
+
+
+class _SafeWriter:
+    """Wraps a stream to silently swallow BrokenPipeError on write/flush."""
+    def __init__(self, stream):
+        self._stream = stream
+
+    def write(self, s):
+        try:
+            self._stream.write(s)
+        except (BrokenPipeError, OSError):
+            pass
+
+    def flush(self):
+        try:
+            self._stream.flush()
+        except (BrokenPipeError, OSError):
+            pass
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+sys.stdout = _SafeWriter(sys.stdout)
+sys.stderr = _SafeWriter(sys.stderr)
+
+
+# ── Timestamped print + log file writer ──
+# Independent implementation per module (no shared code dependency)
+
+_builtin_print = builtins.print
+_start_ts = time.monotonic()
+_last_ts = time.monotonic()
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+_log_lock = threading.Lock()
+_log_latest_path = None
+_log_daily_path = None
+_log_daily_date = ""
+_log_dir = None
+_crash_log_path = None
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+def _resolve_daily_log_path():
+    """Resolve daily log path based on current date."""
+    global _log_daily_path, _log_daily_date
+    if not _log_dir:
+        return
+    today = datetime.now().strftime("%Y-%m-%d")
+    if today == _log_daily_date and _log_daily_path:
+        return
+    month_dir = os.path.join(_log_dir, today[:7])
+    os.makedirs(month_dir, exist_ok=True)
+    _log_daily_path = os.path.join(month_dir, f"{today}.log")
+    _log_daily_date = today
+
+def _write_log(plain_line: str):
+    """Write a plain-text line to both latest.log and daily log."""
+    with _log_lock:
+        if _log_latest_path:
+            try:
+                with open(_log_latest_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+        _resolve_daily_log_path()
+        if _log_daily_path:
+            try:
+                with open(_log_daily_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+
+def _write_crash(exc_type, exc_value, exc_tb, thread_name=None, severity="critical", handled=False):
+    """Write crash record to crashes.jsonl + daily crash archive."""
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "module": MODULE_NAME,
+        "thread": thread_name or threading.current_thread().name,
+        "exception_type": exc_type.__name__ if exc_type else "Unknown",
+        "exception_message": str(exc_value),
+        "traceback": "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
+        "severity": severity,
+        "handled": handled,
+        "process_id": os.getpid(),
+        "platform": sys.platform,
+        "runtime_version": f"Python {sys.version.split()[0]}",
+    }
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            record["context"] = {
+                "function": last.name,
+                "file": os.path.basename(last.filename),
+                "line": last.lineno,
+            }
+
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+
+    if _crash_log_path:
+        try:
+            with open(_crash_log_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+    if _log_dir:
+        try:
+            today = datetime.now().strftime("%Y-%m-%d")
+            archive_dir = os.path.join(_log_dir, "crashes", today[:7])
+            os.makedirs(archive_dir, exist_ok=True)
+            archive_path = os.path.join(archive_dir, f"{today}.jsonl")
+            with open(archive_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+def _print_crash_summary(exc_type, exc_tb, thread_name=None):
+    """Print crash summary to console (red highlight)."""
+    RED = "\033[91m"
+    RESET = "\033[0m"
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            location = f"{os.path.basename(last.filename)}:{last.lineno}"
+        else:
+            location = "unknown"
+    else:
+        location = "unknown"
+
+    prefix = f"[{MODULE_NAME}]"
+    if thread_name:
+        _builtin_print(f"{prefix} {RED}线程 {thread_name} 崩溃: "
+                       f"{exc_type.__name__} in {location}{RESET}")
+    else:
+        _builtin_print(f"{prefix} {RED}崩溃: {exc_type.__name__} in {location}{RESET}")
+    if _crash_log_path:
+        _builtin_print(f"{prefix} 崩溃日志: {_crash_log_path}")
+
+def _setup_exception_hooks():
+    """Set up global exception hooks."""
+    _orig_excepthook = sys.excepthook
+
+    def _excepthook(exc_type, exc_value, exc_tb):
+        _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=False)
+        _print_crash_summary(exc_type, exc_tb)
+        _orig_excepthook(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _excepthook
+
+    if hasattr(threading, "excepthook"):
+        def _thread_excepthook(args):
+            _write_crash(args.exc_type, args.exc_value, args.exc_traceback,
+                        thread_name=args.thread.name if args.thread else "unknown",
+                        severity="error", handled=False)
+            _print_crash_summary(args.exc_type, args.exc_traceback,
+                                thread_name=args.thread.name if args.thread else None)
+
+        threading.excepthook = _thread_excepthook
+
+def _tprint(*args, **kwargs):
+    """Timestamped print that adds [timestamp] HH:MM:SS.mmm +delta prefix."""
+    global _last_ts
+    now = time.monotonic()
+    elapsed = now - _start_ts
+    delta = now - _last_ts
+    _last_ts = now
+
+    if elapsed < 1:
+        elapsed_str = f"{elapsed * 1000:.0f}ms"
+    elif elapsed < 100:
+        elapsed_str = f"{elapsed:.1f}s"
+    else:
+        elapsed_str = f"{elapsed:.0f}s"
+
+    if delta < 0.001:
+        delta_str = ""
+    elif delta < 1:
+        delta_str = f"+{delta * 1000:.0f}ms"
+    elif delta < 100:
+        delta_str = f"+{delta:.1f}s"
+    else:
+        delta_str = f"+{delta:.0f}s"
+
+    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+    _builtin_print(*args, **kwargs)
+
+    if _log_latest_path or _log_daily_path:
+        sep = kwargs.get("sep", " ")
+        end = kwargs.get("end", "\n")
+        text = sep.join(str(a) for a in args)
+        prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
+        _write_log(prefix + _strip_ansi(text) + end)
+
+builtins.print = _tprint
+
+# Ensure project root is on sys.path (set by main.py or cli.js)
+_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from extensions.agents.assistant.server import AssistantServer
+
+
+def _fmt_elapsed(t0: float) -> str:
+    d = time.monotonic() - t0
+    if d < 1:
+        return f"{d * 1000:.0f}ms"
+    if d < 10:
+        return f"{d:.1f}s"
+    return f"{d:.0f}s"
+
+
+def _get_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _register_to_registry(client: httpx.Client, token: str, registry_url: str, port: int):
+    payload = {
+        "action": "register",
+        "module_id": "assistant",
+        "module_type": "agent",
+        "name": "Assistant",
+        "api_endpoint": f"http://127.0.0.1:{port}",
+        "health_endpoint": "/health",
+        "events_publish": {
+            "assistant.test": {"description": "Test event from assistant 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"[assistant] WARNING: Registry returned {resp.status_code}")
+    except Exception as e:
+        print(f"[assistant] 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."""
+    import time
+    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 main():
+    # Initialize log file paths
+    global _log_dir, _log_latest_path, _crash_log_path
+    module_data = os.environ.get("KITE_MODULE_DATA")
+    if module_data:
+        _log_dir = os.path.join(module_data, "log")
+        os.makedirs(_log_dir, exist_ok=True)
+        suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
+
+        _log_latest_path = os.path.join(_log_dir, f"latest{suffix}.log")
+        try:
+            with open(_log_latest_path, "w", encoding="utf-8") as f:
+                pass
+        except Exception:
+            _log_latest_path = None
+
+        _crash_log_path = os.path.join(_log_dir, f"crashes{suffix}.jsonl")
+        try:
+            with open(_crash_log_path, "w", encoding="utf-8") as f:
+                pass
+        except Exception:
+            _crash_log_path = None
+
+        _resolve_daily_log_path()
+
+    _setup_exception_hooks()
+
+    _t0 = time.monotonic()
+
+    # Read boot_info from stdin (only token)
+    token = ""
+    try:
+        line = sys.stdin.readline().strip()
+        if line:
+            boot_info = json.loads(line)
+            token = boot_info.get("token", "")
+    except Exception:
+        pass
+
+    # Read registry_port from environment variable
+    registry_port = int(os.environ.get("KITE_REGISTRY_PORT", "0"))
+
+    if not token or not registry_port:
+        print("[assistant] ERROR: Missing token or KITE_REGISTRY_PORT")
+        sys.exit(1)
+
+    print(f"[assistant] Token received ({len(token)} chars), registry port: {registry_port} ({_fmt_elapsed(_t0)})")
+
+    registry_url = f"http://127.0.0.1:{registry_port}"
+    port = _get_free_port()
+
+    # Register and discover Event Hub synchronously before starting uvicorn
+    client = httpx.Client(timeout=5)
+    _register_to_registry(client, token, registry_url, port)
+    print(f"[assistant] Registered to Registry ({_fmt_elapsed(_t0)})")
+    event_hub_ws = _get_event_hub_ws(client, token, registry_url)
+    if not event_hub_ws:
+        print("[assistant] WARNING: Could not discover Event Hub WS, events disabled")
+    else:
+        print(f"[assistant] Discovered Event Hub: {event_hub_ws}")
+    client.close()
+
+    server = AssistantServer(
+        token=token,
+        registry_url=registry_url,
+        event_hub_ws=event_hub_ws,
+        boot_t0=_t0,
+    )
+
+    print(f"[assistant] Starting on port {port} ({_fmt_elapsed(_t0)})")
+    try:
+        config = uvicorn.Config(server.app, host="127.0.0.1", port=port, log_level="warning")
+        uvi_server = uvicorn.Server(config)
+        server._uvicorn_server = uvi_server
+        uvi_server.run()
+    except Exception as e:
+        _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
+        _print_crash_summary(type(e), e.__traceback__)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/extensions/agents/assistant/module.md

@@ -0,0 +1,22 @@
+---
+name: assistant
+display_name: Assistant
+version: "1.0"
+type: agent
+state: enabled
+runtime: python
+entry: entry.py
+events:
+  - assistant.test
+subscriptions:
+  - module.started
+  - module.stopped
+  - module.shutdown
+---
+
+# Assistant（AI 助手代理）
+
+AI 助手代理模块，负责对话管理和任务执行。
+
+- 对话管理 — 处理用户对话请求并生成响应
+- 事件通知 — 通过 Event Hub 发布助手状态事件

package/extensions/agents/assistant/server.py

@@ -0,0 +1,236 @@
+"""
+Assistant HTTP server.
+Exposes /health and /status endpoints.
+Connects to Event Hub via WebSocket for event publishing and subscription.
+Sends periodic heartbeat to Registry and test events to Event Hub.
+"""
+
+import asyncio
+import json
+import time
+import uuid
+from datetime import datetime, timezone
+
+import httpx
+import websockets
+from fastapi import FastAPI
+
+
+class AssistantServer:
+
+    def __init__(self, token: str = "", registry_url: str = "",
+                 event_hub_ws: str = "", boot_t0: float = 0):
+        self.token = token
+        self.registry_url = registry_url
+        self.event_hub_ws = event_hub_ws
+        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
+        self._shutting_down = False
+        self._uvicorn_server = None  # set by entry.py for graceful shutdown
+        self._start_time = time.time()
+        self.app = self._create_app()
+
+    def _create_app(self) -> FastAPI:
+        app = FastAPI(title="Kite Assistant", docs_url=None, redoc_url=None)
+        server = self
+
+        @app.on_event("startup")
+        async def _startup():
+            server._heartbeat_task = asyncio.create_task(server._heartbeat_loop())
+            if server.event_hub_ws:
+                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:
+                server._test_task.cancel()
+            if server._ws:
+                await server._ws.close()
+            print("[assistant] Shutdown complete")
+
+        @app.get("/health")
+        async def health():
+            return {
+                "status": "healthy",
+                "details": {
+                    "event_hub_connected": server._ws is not None,
+                    "uptime_seconds": round(time.time() - server._start_time),
+                },
+            }
+
+        @app.get("/status")
+        async def status():
+            return {
+                "module": "assistant",
+                "status": "running",
+                "event_hub_connected": server._ws is not None,
+                "uptime_seconds": round(time.time() - server._start_time),
+            }
+
+        return app
+
+    # ── Event Hub WebSocket client ──
+
+    async def _ws_loop(self):
+        """Connect to Event Hub, subscribe, and listen. Reconnect on failure."""
+        retry_delay = 0.5  # start with 0.5s
+        max_delay = 30  # cap at 30s
+        while not self._shutting_down:
+            try:
+                await self._ws_connect()
+            except asyncio.CancelledError:
+                return
+                retry_delay = 0.5  # reset on successful connection
+            except Exception as e:
+                print(f"[assistant] Event Hub connection error: {e}, retrying in {retry_delay:.1f}s")
+            self._ws = None
+            if self._shutting_down:
+                return
+            await asyncio.sleep(retry_delay)
+            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=assistant"
+        print(f"[assistant] 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:
+            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"[assistant] Connected to Event Hub{elapsed_str}")
+
+            # Subscribe to module lifecycle events + shutdown
+            await ws.send(json.dumps({
+                "type": "subscribe",
+                "events": ["module.started", "module.stopped", "module.shutdown"],
+            }))
+
+            # Send module.ready (once) so Launcher knows we're up
+            if not self._ready_sent:
+                ready_msg = {
+                    "type": "event",
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.ready",
+                    "source": "assistant",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "data": {
+                        "module_id": "assistant",
+                        "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 ""
+                print(f"[assistant] module.ready sent{elapsed_str}")
+
+            # Receive loop
+            async for raw in ws:
+                try:
+                    msg = json.loads(raw)
+                except (json.JSONDecodeError, TypeError):
+                    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 == "assistant":
+                                await self._handle_shutdown(ws)
+                                return
+                    elif msg_type == "ack":
+                        pass  # publish confirmed
+                    elif msg_type == "error":
+                        print(f"[assistant] Event Hub error: {msg.get('message')}")
+                except Exception as e:
+                    print(f"[assistant] 事件处理异常（已忽略）: {e}")
+
+    async def _handle_shutdown(self, ws):
+        """Handle module.shutdown: ack → cleanup → ready → exit."""
+        print("[assistant] Received module.shutdown")
+        self._shutting_down = True
+
+        # Step 1: Send ack
+        await self._publish_event({
+            "event": "module.shutdown.ack",
+            "data": {"module_id": "assistant", "estimated_cleanup": 2},
+        })
+        print("[assistant] 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()
+
+        # Step 3: Send ready (before closing WS!)
+        await self._publish_event({
+            "event": "module.shutdown.ready",
+            "data": {"module_id": "assistant"},
+        })
+        print("[assistant] Shutdown complete")
+
+        # Step 4: Trigger uvicorn exit (WS will close when uvicorn shuts down)
+        if self._uvicorn_server:
+            self._uvicorn_server.should_exit = True
+
+    async def _publish_event(self, event: dict):
+        """Publish an event to Event Hub via WebSocket."""
+        if not self._ws:
+            return
+        msg = {
+            "type": "event",
+            "event_id": str(uuid.uuid4()),
+            "event": event.get("event", ""),
+            "source": "assistant",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "data": event.get("data", {}),
+        }
+        try:
+            await self._ws.send(json.dumps(msg))
+        except Exception as e:
+            print(f"[assistant] 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": "assistant"},
+                        headers={"Authorization": f"Bearer {self.token}"},
+                        timeout=5,
+                    )
+                print("[assistant] heartbeat sent")
+            except Exception:
+                pass
+
+    # ── Test event loop ──
+
+    async def _test_event_loop(self):
+        """Publish a test event every 10 seconds."""
+        while True:
+            await asyncio.sleep(10)
+            await self._publish_event({
+                "event": "assistant.test",
+                "data": {
+                    "message": "test event from assistant",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            })
+            print("[assistant] test event published")

package/extensions/channels/__init__.py

@@ -0,0 +1 @@
+

package/extensions/channels/acp_channel/__init__.py

@@ -0,0 +1 @@
+