@agentunion/kite 1.0.6 → 1.0.7

package/core/registry/server.py

@@ -2,7 +2,11 @@
 Registry HTTP server.
 7 endpoints: /modules, /lookup, /get/{path}, /tokens, /verify, /query, /health.
 All endpoints except /health require Bearer token auth.
-Connects to Event Hub to publish module lifecycle events.
+
+Delayed ready mechanism (mechanism 7):
+  Registry does NOT send module.ready immediately after HTTP starts.
+  When Event Hub registers (POST /modules with metadata.ws_endpoint),
+  Registry connects to Event Hub WS and then sends module.ready.
 """
 
 import asyncio
@@ -20,15 +24,19 @@ from .store import RegistryStore
 class RegistryServer:
     """FastAPI-based Registry HTTP server."""
 
-    def __init__(self, store: RegistryStore, launcher_token: str = ""):
+    def __init__(self, store: RegistryStore, launcher_token: str = "", advertise_ip: str = "127.0.0.1"):
         self.store = store
         self.launcher_token = launcher_token
+        self.advertise_ip = advertise_ip
+        self.port: int = 0  # set by entry.py before uvicorn.run
         self.app = self._create_app()
         self._ttl_task: asyncio.Task | None = None
         # Event Hub WebSocket
         self._event_hub_ws_url: str = ""
         self._ws: object | None = None
         self._ws_task: asyncio.Task | None = None
+        self._event_hub_connected = False
+        self._ready_sent = False
 
     def _extract_token(self, request: Request) -> str:
         """Extract Bearer token from Authorization header."""
@@ -51,13 +59,12 @@ class RegistryServer:
         if not self.store.is_launcher(token):
             raise HTTPException(status_code=403, detail="Only Launcher may call this endpoint")
 
-    # ── Event Hub connection ──
+    # ── Event Hub connection + delayed ready ──
 
     async def _try_connect_event_hub(self):
-        """Check if Event Hub is registered and connect if not already connected."""
-        if self._ws:
+        """Event Hub just registered — connect to it and send module.ready."""
+        if self._event_hub_connected:
             return
-        # Look up Event Hub ws_endpoint from our own store
         eh = self.store.modules.get("event_hub")
         if not eh:
             return
@@ -78,17 +85,24 @@ class RegistryServer:
             except Exception as e:
                 print(f"[registry] Event Hub connection error: {e}")
             self._ws = None
+            self._event_hub_connected = False
             await asyncio.sleep(5)
 
     async def _ws_connect(self):
-        """Single WebSocket session."""
-        # Use registry's own per-module token (registered by Launcher via /tokens)
-        # to avoid conflicting with Launcher's connection (same launcher_token → same module_id)
+        """Single WebSocket session. On first connect, send module.ready."""
+        # Use registry's own per-module token to avoid conflicting with Launcher's connection
         token = self.store.token_map.get("registry", "") or self.launcher_token
         ws_url = f"{self._event_hub_ws_url}?token={token}"
-        async with websockets.connect(ws_url) as ws:
+        async with websockets.connect(ws_url, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
             self._ws = ws
+            self._event_hub_connected = True
             print("[registry] Connected to Event Hub")
+
+            # Send module.ready on first successful connection (delayed ready mechanism)
+            if not self._ready_sent:
+                self._ready_sent = True
+                await self._send_module_ready()
+
             async for raw in ws:
                 try:
                     msg = json.loads(raw)
@@ -98,6 +112,26 @@ class RegistryServer:
                 if msg_type == "error":
                     print(f"[registry] Event Hub error: {msg.get('message')}")
 
+    async def _send_module_ready(self):
+        """Send module.ready event to Event Hub. Launcher is listening for this."""
+        from datetime import datetime, timezone
+        msg = {
+            "type": "event",
+            "event_id": str(uuid.uuid4()),
+            "event": "module.ready",
+            "source": "registry",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "data": {
+                "module_id": "registry",
+                "api_endpoint": f"http://{self.advertise_ip}:{self.port}",
+            },
+        }
+        try:
+            await self._ws.send(json.dumps(msg))
+            print("[registry] Sent module.ready")
+        except Exception as e:
+            print(f"[registry] Failed to send module.ready: {e}")
+
     async def _publish_event(self, event_type: str, data: dict):
         """Publish event to Event Hub. Best-effort, no-op if not connected."""
         if not self._ws:
@@ -153,8 +187,9 @@ class RegistryServer:
                 if result.get("ok"):
                     mid = body["module_id"]
                     await server._publish_event("module.registered", {"module_id": mid})
-                    # If Event Hub just registered, try connecting
-                    if mid == "event_hub":
+                    # If Event Hub just registered, connect and send module.ready
+                    ws_endpoint = (body.get("metadata") or {}).get("ws_endpoint")
+                    if ws_endpoint and mid == "event_hub":
                         await server._try_connect_event_hub()
                 return result
 
@@ -222,8 +257,6 @@ class RegistryServer:
             return {"ok": False}
 
         # ── 6. POST /query (stub) ──
-        # TODO: implement LLM semantic query per design §5.1
-        #       accept {"question": "..."}, search registry with LLM, return matched modules/tools
 
         @app.post("/query")
         async def query(request: Request):

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,11 +19,15 @@ 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."""
+        if self.is_debug and token:
+            return "debug"
         if token == self.launcher_token:
             return "launcher"
         for mid, tok in self.token_map.items():

package/{core → extensions}/event_hub_bench/entry.py

@@ -8,7 +8,6 @@ import json
 import os
 import platform
 import sys
-import threading
 import time
 from datetime import datetime, timezone
 
@@ -18,12 +17,16 @@ import uuid
 import httpx
 import websockets
 
-_this_dir = os.path.dirname(os.path.abspath(__file__))
-_project_root = os.path.dirname(os.path.dirname(_this_dir))
+_project_root = os.environ.get("KITE_PROJECT") or 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)
 
-RESULTS_DIR = os.path.join(_project_root, "core", "event_hub", "bench_results")
+# Results go to KITE_MODULE_DATA (set by Launcher per module)
+# Fallback to source tree for standalone runs
+RESULTS_DIR = os.environ.get("KITE_MODULE_DATA") or os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "core", "event_hub", "bench_results",
+)
 TAG = "[event_hub_bench]"
 
 
@@ -34,7 +37,7 @@ def _discover_hub(registry_url: str, token: str, timeout: float = 30) -> str | N
     while time.time() < deadline:
         try:
             resp = httpx.get(
-                f"{registry_url}/lookup/event_hub",
+                f"{registry_url}/get/event_hub",
                 headers=headers, timeout=5,
             )
             if resp.status_code == 200:
@@ -335,20 +338,25 @@ async def _run(ws_url: str, token: str):
 
 
 def main():
-    # Read boot_info from stdin
+    # Read boot_info from stdin (only token)
     token = ""
-    registry_port = 0
     try:
         line = sys.stdin.readline().strip()
         if line:
             boot = json.loads(line)
             token = boot.get("token", "")
-            registry_port = boot.get("registry_port", 0)
     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(f"{TAG} ERROR: Missing token or registry_port")
+        print(f"{TAG} ERROR: Missing token or KITE_REGISTRY_PORT")
+        sys.exit(1)
+
+    if os.environ.get("KITE_DEBUG") != "1":
+        print(f"{TAG} ERROR: Benchmark requires KITE_DEBUG=1 (multiple clients share one token)")
         sys.exit(1)
 
     registry_url = f"http://127.0.0.1:{registry_port}"

package/{core → extensions}/event_hub_bench/module.md

@@ -18,8 +18,9 @@ subscriptions: []
 - 通过 Registry 发现 Event Hub，以真实模块身份连接
 - 多线程模拟多个 publisher/subscriber 压测 hub
 - 监控 hub 进程 CPU/内存占用
-- 结果保存到 `core/event_hub/bench_results/`
+- 结果保存到 `KITE_MODULE_DATA/`
 - 测试完成后自动退出
+- 需要 `KITE_DEBUG=1`（多客户端共用一个 token）
 
 启用：将 `state` 改为 `enabled`
 停用：将 `state` 改为 `disabled`

package/extensions/services/watchdog/entry.py

@@ -11,9 +11,8 @@ import sys
 import httpx
 import uvicorn
 
-# Ensure project root is on sys.path
-_this_dir = os.path.dirname(os.path.abspath(__file__))
-_project_root = os.path.dirname(os.path.dirname(os.path.dirname(_this_dir)))
+# 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)
 
@@ -93,20 +92,25 @@ def _get_event_hub_ws(token: str, registry_url: str) -> str:
 
 
 def main():
-    # Read boot_info from stdin
+    # Kite environment
+    kite_instance = os.environ.get("KITE_INSTANCE", "")
+    is_debug = os.environ.get("KITE_DEBUG") == "1"
+
+    # Read boot_info from stdin (only token)
     token = ""
-    registry_port = 0
     try:
         line = sys.stdin.readline().strip()
         if line:
             boot_info = json.loads(line)
             token = boot_info.get("token", "")
-            registry_port = boot_info.get("registry_port", 0)
     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("[watchdog] ERROR: Missing token or registry_port in boot_info")
+        print("[watchdog] ERROR: Missing token or KITE_REGISTRY_PORT")
         sys.exit(1)
 
     print(f"[watchdog] Token received ({len(token)} chars), registry port: {registry_port}")

package/extensions/services/watchdog/server.py

@@ -93,7 +93,7 @@ class WatchdogServer:
     async def _ws_connect(self):
         """Single WebSocket session: connect, subscribe, receive loop."""
         url = f"{self.event_hub_ws}?token={self.token}"
-        async with websockets.connect(url) as ws:
+        async with websockets.connect(url, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
             self._ws = ws
             print("[watchdog] Connected to Event Hub")
 

package/main.py

@@ -1,16 +1,216 @@
+"""
+Kite development entry point.
+Loads .env, sets KITE_* defaults, parses --debug, starts Launcher.
+"""
+import atexit
+import builtins
+import os
 import secrets
 import sys
-import os
+import threading
+import time
+from datetime import datetime
+
+# ── Timestamped print with delta + color ──
+# Covers the entire Launcher process. Child processes (registry, event_hub) are
+# separate PIDs — unaffected. Their stdout is relayed via ProcessManager._read_stdout
+# → print(), so timestamps & deltas are added at the relay point automatically.
+
+_builtin_print = builtins.print
+_last_ts = time.monotonic()
+
+# ANSI escape codes
+_DIM   = "\033[90m"   # gray  — fast, normal
+_GREEN = "\033[32m"   # green — noticeable but expected (subprocess launch, network wait)
+_RED   = "\033[91m"   # red   — abnormally slow, likely a problem
+_RESET = "\033[0m"
+
+# ── Log file handles ──
+# Initialized lazily after KITE_MODULE_DATA is resolved (see _init_log_files)
+_log_lock = threading.Lock()
+_log_latest = None    # file handle: latest.log (cleared each startup)
+_log_daily = None     # file handle: {YYYY-MM}/{YYYY-MM-DD}.log (append)
+_log_daily_date = ""  # current date string to detect day rollover
+
+# Strip ANSI escape sequences for plain-text log files
+import re
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+
+def _init_log_files():
+    """Initialize log file handles. Called after KITE_MODULE_DATA is set."""
+    global _log_latest, _log_daily, _log_daily_date
+    module_data = os.environ.get("KITE_MODULE_DATA")
+    if not module_data:
+        return
+    log_dir = os.path.join(module_data, "log")
+    os.makedirs(log_dir, exist_ok=True)
+
+    # latest.log — truncate on each startup
+    try:
+        _log_latest = open(os.path.join(log_dir, "latest.log"), "w", encoding="utf-8")
+    except Exception as e:
+        _builtin_print(f"[launcher] 警告: 无法打开 latest.log: {e}")
+
+    # daily log — append
+    _open_daily_log(log_dir)
+
+
+def _open_daily_log(log_dir: str = None):
+    """Open (or rotate) the daily log file based on current date."""
+    global _log_daily, _log_daily_date
+    today = datetime.now().strftime("%Y-%m-%d")
+    if today == _log_daily_date and _log_daily:
+        return
+    if _log_daily:
+        try:
+            _log_daily.close()
+        except Exception:
+            pass
+    if not log_dir:
+        module_data = os.environ.get("KITE_MODULE_DATA")
+        if not module_data:
+            return
+        log_dir = os.path.join(module_data, "log")
+    month_dir = os.path.join(log_dir, today[:7])  # YYYY-MM
+    os.makedirs(month_dir, exist_ok=True)
+    try:
+        _log_daily = open(os.path.join(month_dir, f"{today}.log"), "a", encoding="utf-8")
+        _log_daily_date = today
+    except Exception as e:
+        _builtin_print(f"[launcher] 警告: 无法打开每日日志: {e}")
+
+
+def _write_log(plain_line: str):
+    """Write a plain-text line to both latest.log and daily log."""
+    global _log_daily
+    with _log_lock:
+        if _log_latest:
+            try:
+                _log_latest.write(plain_line)
+                _log_latest.flush()
+            except Exception:
+                pass
+        # Check daily rotation
+        today = datetime.now().strftime("%Y-%m-%d")
+        if today != _log_daily_date:
+            _open_daily_log()
+        if _log_daily:
+            try:
+                _log_daily.write(plain_line)
+                _log_daily.flush()
+            except Exception:
+                pass
+
+
+def _close_log_files():
+    """Flush and close log files on exit."""
+    global _log_latest, _log_daily
+    for f in (_log_latest, _log_daily):
+        if f:
+            try:
+                f.flush()
+                f.close()
+            except Exception:
+                pass
+    _log_latest = None
+    _log_daily = None
+
+atexit.register(_close_log_files)
+
+
+def _tprint(*args, **kwargs):
+    global _last_ts
+    now = time.monotonic()
+    delta = now - _last_ts
+    _last_ts = now
+
+    # Timestamp
+    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+    # Format delta string
+    if 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"
+
+    # Color: gray < 1s, green 1–5s, red > 5s
+    if delta >= 5:
+        color = _RED
+    elif delta >= 1:
+        color = _GREEN
+    else:
+        color = _DIM
+
+    prefix = f"{ts} {color}{delta_str:>8}{_RESET} "
+    _builtin_print(prefix, end="")
+    _builtin_print(*args, **kwargs)
+
+    # Write to log files (plain text, no ANSI)
+    if _log_latest or _log_daily:
+        sep = kwargs.get("sep", " ")
+        end = kwargs.get("end", "\n")
+        text = sep.join(str(a) for a in args)
+        plain_prefix = f"{ts} {delta_str:>8} "
+        _write_log(plain_prefix + text + end)
+
+builtins.print = _tprint
+
+# Load .env (development convenience, not required in production)
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+# Resolve project root (directory containing this file)
+_project_root = os.path.dirname(os.path.abspath(__file__))
+
+# Home base for Kite data
+_home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+_kite_home = os.path.join(_home, ".kite")
+
+# Set KITE_* defaults (only if not already set by cli.js or .env)
+_defaults = {
+    "KITE_PROJECT": _project_root,
+    "KITE_CWD": os.getcwd(),
+    "KITE_WORKSPACE": os.path.join(_kite_home, "workspace"),
+    "KITE_DATA": os.path.join(_kite_home, "data"),
+    "KITE_MODULES": os.path.join(_kite_home, "modules"),
+    "KITE_REPO": os.path.join(_kite_home, "repo"),
+    "KITE_ENV": "development",
+}
+for key, value in _defaults.items():
+    if not os.environ.get(key):
+        os.environ[key] = value
+
+# Parse --debug flag
+if "--debug" in sys.argv:
+    os.environ["KITE_DEBUG"] = "1"
+    sys.argv.remove("--debug")
 
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+# Ensure project root is on sys.path
+sys.path.insert(0, os.environ["KITE_PROJECT"])
 
 from core.launcher.entry import Launcher
 
 
 def main():
     token = secrets.token_hex(32)
-    print(f"[main] KITE_TOKEN generated ({len(token)} chars)")
-    Launcher(kite_token=token).run()
+    print(f"[main] KITE_TOKEN 已生成 ({len(token)} 字符)")
+    env = os.environ.get("KITE_ENV", "development")
+    debug = os.environ.get("KITE_DEBUG") == "1"
+    print(f"[main] 环境={env}, 调试={debug}, 项目={os.environ['KITE_PROJECT']}")
+    launcher = Launcher(kite_token=token)
+    # KITE_MODULE_DATA is now set — initialize log files
+    _init_log_files()
+    print(f"[main] 日志文件已初始化: {os.environ.get('KITE_MODULE_DATA', '')}/log/")
+    launcher.run()
 
 
 if __name__ == "__main__":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentunion/kite",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Kite framework launcher — start Kite from anywhere",
   "bin": {
     "kite": "./cli.js"
@@ -11,7 +11,16 @@
     "__main__.py",
     "__init__.py",
     "core/**",
-    "extensions/**"
+    "extensions/**",
+    "!**/__pycache__",
+    "!**/__pycache__/**",
+    "!**/*.pyc",
+    "!**/data",
+    "!**/data/**",
+    "!**/bench_results",
+    "!**/bench_results/**",
+    "!core/event_hub_bench",
+    "!core/event_hub_bench/**"
   ],
   "engines": {
     "node": ">=16"

package/core/data_dir.py

@@ -1,62 +0,0 @@
-"""
-Data directory management for Kite.
-When installed globally via npm, use ~/.kite/ for runtime data.
-When running locally, use project_root/core/*/data/.
-"""
-import os
-import sys
-
-
-def get_data_root() -> str:
-    """Get the root directory for runtime data.
-
-    Returns:
-        - ~/.kite/ if installed globally (no write permission to install dir)
-        - project_root if running locally (development mode)
-    """
-    # Check if we're in a global npm install (no write permission)
-    project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-    test_file = os.path.join(project_root, "core", "launcher", "data", ".write_test")
-
-    try:
-        os.makedirs(os.path.dirname(test_file), exist_ok=True)
-        with open(test_file, "w") as f:
-            f.write("test")
-        os.remove(test_file)
-        # Write permission OK, use project_root
-        return project_root
-    except (OSError, PermissionError):
-        # No write permission, use user home
-        home = os.path.expanduser("~")
-        kite_home = os.path.join(home, ".kite")
-        os.makedirs(kite_home, exist_ok=True)
-        return kite_home
-
-
-def get_launcher_data_dir() -> str:
-    """Get launcher data directory."""
-    root = get_data_root()
-    if root.endswith(".kite"):
-        # User home mode: ~/.kite/launcher/
-        return os.path.join(root, "launcher")
-    else:
-        # Project mode: project_root/core/launcher/data/
-        return os.path.join(root, "core", "launcher", "data")
-
-
-def get_registry_data_dir() -> str:
-    """Get registry data directory."""
-    root = get_data_root()
-    if root.endswith(".kite"):
-        return os.path.join(root, "registry")
-    else:
-        return os.path.join(root, "core", "registry", "data")
-
-
-def get_event_hub_data_dir() -> str:
-    """Get event hub data directory."""
-    root = get_data_root()
-    if root.endswith(".kite"):
-        return os.path.join(root, "event_hub")
-    else:
-        return os.path.join(root, "core", "event_hub", "data")

package/core/event_hub/bench_results/2026-02-28_13-26-48.json

@@ -1,51 +0,0 @@
-{
-  "timestamp": "2026-02-28T13:26:48.644977",
-  "env": {
-    "platform": "win32",
-    "python": "3.13.12"
-  },
-  "throughput": {
-    "events": 10000,
-    "send_rate": 13121,
-    "client_recv": 10000,
-    "hub_queued": 10000,
-    "hub_routed": 10000,
-    "send_time": 0.76,
-    "recv_time": 1.59
-  },
-  "latency": {
-    "samples": 200,
-    "avg_ms": 0.69,
-    "p50_ms": 0.65,
-    "p95_ms": 0.92,
-    "p99_ms": 1.27
-  },
-  "fanout_1": {
-    "subs": 1,
-    "events": 2000,
-    "send_rate": 17292,
-    "avg_recv": 2000,
-    "min_recv": 2000
-  },
-  "fanout_10": {
-    "subs": 10,
-    "events": 2000,
-    "send_rate": 18074,
-    "avg_recv": 2000,
-    "min_recv": 2000
-  },
-  "fanout_50": {
-    "subs": 50,
-    "events": 2000,
-    "send_rate": 6138,
-    "avg_recv": 2000,
-    "min_recv": 2000
-  },
-  "hub_counters": {
-    "events_received": 16200,
-    "events_routed": 132200,
-    "events_queued": 132200,
-    "events_deduplicated": 0,
-    "errors": 0
-  }
-}