@agentunion/kite 1.0.6 → 1.0.7

package/cli.js

@@ -1,70 +1,172 @@
 #!/usr/bin/env node
 /**
- * Kite CLI — Node.js entry point.
- * Generates KITE_TOKEN, spawns the Python launcher, forwards output.
+ * Kite CLI — installer + launcher.
+ *
+ * First run: copies framework code to ~/.kite/versions/{version}/
+ * Subsequent runs: directly starts the installed version.
+ *
+ * Directory structure:
+ *   ~/.kite/
+ *     versions/{ver}/   — framework code (per-version, replaceable)
+ *     modules/          — shared modules (all versions share, user-writable)
+ *     data/             — runtime data (all versions share)
  *
  * Usage:
- *   kite                     # after npm install -g / npm link
+ *   kite                     # start current version
  *   kite --cwd /some/path    # override working directory
- *   node cli.js              # direct execution
- *
- * Environment variables passed to Python:
- *   KITE_HOME  — Kite framework root (where core/, extensions/ live)
- *   KITE_CWD   — directory where user executed the kite command
+ *   kite --use 1.0.6         # use a specific version
  */
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 
-// Parse CLI args
+// Timestamped console.log with delta + color
+const _origLog = console.log.bind(console);
+const _origErr = console.error.bind(console);
+let _lastTs = Date.now();
+const DIM = '\x1b[90m', GREEN = '\x1b[32m', RED = '\x1b[91m', RST = '\x1b[0m';
+
+function _prefix() {
+  const now = Date.now();
+  const delta = now - _lastTs;
+  _lastTs = now;
+  const d = new Date();
+  const ts = d.toTimeString().slice(0, 8) + '.' + String(d.getMilliseconds()).padStart(3, '0');
+  const ds = delta < 1000 ? `+${delta}ms` : `+${(delta / 1000).toFixed(1)}s`;
+  const color = delta >= 5000 ? RED : delta >= 1000 ? GREEN : DIM;
+  return `${ts} ${color}${ds.padStart(8)}${RST} `;
+}
+console.log = (...args) => _origLog(_prefix(), ...args);
+console.error = (...args) => _origErr(_prefix(), ...args);
+
+// ── Paths ──
+const packageDir = fs.realpathSync(__dirname);
+const packageJson = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf-8'));
+const version = packageJson.version;
+const homeDir = process.env.HOME || process.env.USERPROFILE;
+const kiteHome = path.join(homeDir, '.kite');
+const modulesDir = path.join(kiteHome, 'modules');
+const dataDir = path.join(kiteHome, 'data');
+
+// ── Parse CLI args ──
 const args = process.argv.slice(2);
 const pythonArgs = [];
 let cwdOverride = null;
+let useVersion = version;
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--cwd' && args[i + 1]) {
     cwdOverride = path.resolve(args[++i]);
+  } else if (args[i] === '--use' && args[i + 1]) {
+    useVersion = args[++i];
   } else {
     pythonArgs.push(args[i]);
   }
 }
 
-const token = crypto.randomBytes(32).toString('hex');
-const kiteHome = fs.realpathSync(__dirname);
+const versionDir = path.join(kiteHome, 'versions', useVersion);
+
+// ── Install: copy framework to ~/.kite/versions/{ver}/ if needed ──
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      // Skip directories that shouldn't be copied
+      if (['__pycache__', 'node_modules', '.git', 'data'].includes(entry.name)) continue;
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function install() {
+  console.log(`[kite] 安装版本 ${useVersion} 到 ${versionDir}`);
+
+  // Create shared directories
+  fs.mkdirSync(modulesDir, { recursive: true });
+  fs.mkdirSync(dataDir, { recursive: true });
+
+  // Copy framework code from npm package
+  copyDirSync(packageDir, versionDir);
+
+  // Patch launcher module.md: add shared modules path to discovery
+  patchLauncherDiscovery();
+
+  console.log(`[kite] 版本 ${useVersion} 已安装`);
+}
+
+function patchLauncherDiscovery() {
+  const mdPath = path.join(versionDir, 'core', 'launcher', 'module.md');
+  if (!fs.existsSync(mdPath)) return;
+
+  let content = fs.readFileSync(mdPath, 'utf-8');
+
+  // Already patched?
+  if (content.includes('shared_modules')) return;
+
+  // Insert shared_modules discovery entry before the closing ---
+  const entry = [
+    '  shared_modules:',
+    '    type: scan_dir',
+    `    path: "${modulesDir.replace(/\\/g, '/')}"`,
+    '    enabled: true',
+  ].join('\n');
+
+  // Insert after the last discovery entry, before ---
+  content = content.replace(
+    /(discovery:\n(?:[\s\S]*?))(---)/,
+    `$1${entry}\n$2`
+  );
+
+  fs.writeFileSync(mdPath, content, 'utf-8');
+  console.log(`[kite] 已补丁启动器发现路径: ${modulesDir}`);
+}
+
+// ── Main: check version, install if needed, start ──
+
+if (!fs.existsSync(path.join(versionDir, 'main.py'))) {
+  install();
+}
+
 const kiteCwd = cwdOverride || process.cwd();
 
-console.log(`[main] KITE_TOKEN generated (${token.length} chars)`);
-console.log(`[main] KITE_HOME: ${kiteHome}`);
-console.log(`[main] KITE_CWD:  ${kiteCwd}`);
+console.log(`[kite] 版本:     ${useVersion}`);
+console.log(`[kite] 项目:     ${versionDir}`);
+console.log(`[kite] 工作目录: ${kiteCwd}`);
 
-// Spawn Python using package mode: python -m Kite
-// PYTHONPATH points to Kite's parent so "import Kite" / "python -m Kite" works
-const kiteParent = path.dirname(kiteHome);
 const env = {
   ...process.env,
-  KITE_HOME: kiteHome,
+  KITE_PROJECT: versionDir,
   KITE_CWD: kiteCwd,
-  PYTHONPATH: kiteParent + (process.env.PYTHONPATH ? path.delimiter + process.env.PYTHONPATH : ''),
+  KITE_WORKSPACE: path.join(kiteHome, 'workspace'),
+  KITE_DATA: dataDir,
+  KITE_MODULES: modulesDir,
+  KITE_REPO: path.join(kiteHome, 'repo'),
+  KITE_VERSION: useVersion,
+  KITE_ENV: 'production',
   PYTHONUTF8: '1',
 };
 
 const python = process.platform === 'win32' ? 'python' : 'python3';
 const child = spawn(
   python,
-  [path.join(kiteHome, 'main.py'), ...pythonArgs],
-  { cwd: kiteHome, env, stdio: 'inherit' }
+  [path.join(versionDir, 'main.py'), ...pythonArgs],
+  { cwd: versionDir, env, stdio: 'inherit' }
 );
 
 child.on('error', err => {
-  console.error(`[main] Failed to start Python: ${err.message}`);
-  console.error(`[main] Make sure '${python}' is in PATH and dependencies are installed`);
+  console.error(`[kite] 启动 Python 失败: ${err.message}`);
+  console.error(`[kite] 请确认 '${python}' 在 PATH 中且依赖已安装`);
   process.exit(1);
 });
 
 child.on('exit', code => process.exit(code ?? 0));
 
-// Forward signals for graceful shutdown
 for (const sig of ['SIGINT', 'SIGTERM']) {
   process.on(sig, () => child.kill(sig));
 }

package/core/event_hub/entry.py

@@ -1,19 +1,22 @@
 """
 Event Hub entry point.
-Reads boot_info from stdin, starts FastAPI server, registers to Registry.
+Reads token from stdin boot_info, reads launcher_ws_token from stdin second line,
+starts FastAPI server, outputs ws_endpoint via stdout, waits for Launcher to connect,
+then registers to Registry after stdio disconnect.
 """
 
 import json
 import os
+import re
 import socket
 import sys
+import threading
 
-import httpx
 import uvicorn
 
-# Ensure project root is on sys.path
+# Ensure project root is on sys.path (set by main.py or cli.js)
 _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(_this_dir))
 if _project_root not in sys.path:
     sys.path.insert(0, _project_root)
 
@@ -21,91 +24,132 @@ from core.event_hub.hub import EventHub
 from core.event_hub.server import EventHubServer
 
 
-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(token: str, registry_url: str, port: int, advertise_ip: str = "127.0.0.1"):
-    """Synchronous registration to Registry at startup."""
-    payload = {
-        "action": "register",
-        "module_id": "event_hub",
-        "module_type": "infrastructure",
-        "name": "Event Hub",
-        "api_endpoint": f"http://{advertise_ip}:{port}",
-        "health_endpoint": "/health",
-        "metadata": {
-            "ws_endpoint": f"ws://{advertise_ip}:{port}/ws",
-        },
-    }
-    headers = {"Authorization": f"Bearer {token}"}
-    resp = httpx.post(
-        f"{registry_url}/modules",
-        json=payload,
-        headers=headers,
-        timeout=5,
-    )
-    if resp.status_code == 200:
-        print(f"[event_hub] Registered to Registry")
-    else:
-        print(f"[event_hub] WARNING: Registry returned {resp.status_code}")
-
-
-def _read_test_mode() -> bool:
-    """Read test_mode from module.md frontmatter."""
+def _read_module_md() -> dict:
+    """Read preferred_port, advertise_ip from own module.md."""
     md_path = os.path.join(_this_dir, "module.md")
+    result = {"preferred_port": 0, "advertise_ip": "127.0.0.1"}
     try:
         with open(md_path, encoding="utf-8") as f:
             text = f.read()
-        import re, yaml
         m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
         if m:
-            fm = yaml.safe_load(m.group(1)) or {}
-            return bool(fm.get("test_mode", False))
+            try:
+                import yaml
+                fm = yaml.safe_load(m.group(1)) or {}
+            except ImportError:
+                fm = {}
+            result["preferred_port"] = int(fm.get("preferred_port", 0))
+            result["advertise_ip"] = fm.get("advertise_ip", "127.0.0.1")
     except Exception:
         pass
-    return False
+    return result
+
+
+def _bind_port(preferred: int, host: str) -> int:
+    """Try preferred port first, fall back to OS-assigned."""
+    if preferred:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind((host, preferred))
+                return preferred
+        except OSError:
+            pass
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind((host, 0))
+        return s.getsockname()[1]
+
+
+def _read_stdin_kite_message() -> dict | None:
+    """Read a structured kite message from stdin (second line after boot_info).
+    Uses a short timeout thread to avoid blocking forever if Launcher doesn't send.
+    """
+    result = [None]
+
+    def _read():
+        try:
+            line = sys.stdin.readline().strip()
+            if line:
+                msg = json.loads(line)
+                if isinstance(msg, dict) and "kite" in msg:
+                    result[0] = msg
+        except Exception:
+            pass
+
+    t = threading.Thread(target=_read, daemon=True)
+    t.start()
+    t.join(timeout=5)
+    return result[0]
 
 
 def main():
-    # Read boot_info from stdin
+    # Kite environment
+    kite_instance = os.environ.get("KITE_INSTANCE", "")
+    is_debug = os.environ.get("KITE_DEBUG") == "1"
+
+    # Step 1: Read token from stdin boot_info
     token = ""
-    registry_port = 0
-    bind_host = "127.0.0.1"
-    advertise_ip = "127.0.0.1"
     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)
-            bind_host = boot_info.get("bind", "127.0.0.1")
-            advertise_ip = boot_info.get("advertise_ip", "127.0.0.1")
     except Exception:
         pass
 
-    if not token or not registry_port:
-        print("[event_hub] ERROR: Missing token or registry_port in boot_info")
+    if not token:
+        print("[event_hub] 错误: boot_info 中缺少令牌")
         sys.exit(1)
 
-    print(f"[event_hub] Token received ({len(token)} chars), registry port: {registry_port}")
+    # Step 2: Read launcher_ws_token from stdin (second line, structured kite message)
+    launcher_ws_token = ""
+    kite_msg = _read_stdin_kite_message()
+    if kite_msg and kite_msg.get("kite") == "launcher_ws_token":
+        launcher_ws_token = kite_msg.get("launcher_ws_token", "")
 
+    if launcher_ws_token:
+        print(f"[event_hub] 已收到启动器 WS 令牌 ({len(launcher_ws_token)} 字符)")
+    else:
+        print("[event_hub] 警告: 未收到 launcher_ws_token，启动器引导认证已禁用")
+
+    # Step 3: Read registry_port from environment variable
+    registry_port = int(os.environ.get("KITE_REGISTRY_PORT", "0"))
+    if not registry_port:
+        print("[event_hub] 错误: KITE_REGISTRY_PORT 未设置")
+        sys.exit(1)
+
+    print(f"[event_hub] 已收到令牌 ({len(token)} 字符)，Registry 端口: {registry_port}")
+
+    # Step 4: Read config from own module.md
+    md_config = _read_module_md()
+    advertise_ip = md_config["advertise_ip"]
+    preferred_port = md_config["preferred_port"]
+
+    # Step 5: Bind port and create server
+    bind_host = advertise_ip
+    port = _bind_port(preferred_port, bind_host)
     registry_url = f"http://127.0.0.1:{registry_port}"
-    port = _get_free_port()
 
-    # Register to Registry
-    _register_to_registry(token, registry_url, port, advertise_ip)
+    if is_debug:
+        print("[event_hub] 调试模式已启用 (KITE_DEBUG=1)，接受所有令牌")
 
-    # Create hub and server
-    test_mode = _read_test_mode()
-    if test_mode:
-        print("[event_hub] WARNING: test_mode enabled, all tokens accepted")
     hub = EventHub()
-    server = EventHubServer(hub, own_token=token, registry_url=registry_url, test_mode=test_mode)
+    server = EventHubServer(
+        hub,
+        own_token=token,
+        registry_url=registry_url,
+        launcher_ws_token=launcher_ws_token,
+        advertise_ip=advertise_ip,
+        port=port,
+    )
+
+    # Step 6: Output ws_endpoint via stdout (Launcher reads this)
+    ws_endpoint = f"ws://{advertise_ip}:{port}/ws"
+    print(json.dumps({"kite": "ws_endpoint", "ws_endpoint": ws_endpoint}), flush=True)
 
-    print(f"[event_hub] Starting on {bind_host}:{port}")
+    # Step 7: Start HTTP + WS server
+    # Launcher will connect with launcher_ws_token → Event Hub sends module.ready → stdio disconnect
+    # After stdio disconnect, Event Hub registers to Registry (done by server on_launcher_connected callback)
+    print(f"[event_hub] 启动中 {bind_host}:{port}")
     uvicorn.run(server.app, host=bind_host, port=port, log_level="warning")
 
 

package/core/event_hub/module.md

@@ -8,7 +8,6 @@ runtime: python
 entry: entry.py
 events: []
 subscriptions: []
-test_mode: true
 ---
 
 # Event Hub

package/core/event_hub/server.py

@@ -2,9 +2,17 @@
 Event Hub HTTP + WebSocket server.
 FastAPI app: /ws (WebSocket), /health, /stats.
 30s timer for heartbeat renewal + dedup cleanup.
+
+Launcher bootstrap sequence:
+  Launcher connects with launcher_ws_token → Event Hub verifies locally →
+  sends module.ready → registers to Registry.
 """
 
 import asyncio
+import json
+import os
+import uuid
+from datetime import datetime, timezone
 
 import httpx
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
@@ -14,20 +22,33 @@ from .hub import EventHub
 
 class EventHubServer:
 
-    def __init__(self, hub: EventHub, own_token: str, registry_url: str, test_mode: bool = False):
+    def __init__(self, hub: EventHub, own_token: str, registry_url: str,
+                 launcher_ws_token: str = "",
+                 advertise_ip: str = "127.0.0.1", port: int = 0):
         self.hub = hub
         self.own_token = own_token
         self.registry_url = registry_url
-        self.test_mode = test_mode
+        self.is_debug = os.environ.get("KITE_DEBUG") == "1"
+        self.launcher_ws_token = launcher_ws_token
+        self.advertise_ip = advertise_ip
+        self.port = port
         self._timer_task: asyncio.Task | None = None
+        self._launcher_connected = False
+        self._registered_to_registry = False
         self.app = self._create_app()
 
-    # ── Token verification via Registry ──
+    # ── Token verification ──
 
     async def _verify_token(self, token: str, module_id_hint: str = "") -> str | None:
-        """Call Registry POST /verify to validate a module token. Returns module_id or None."""
-        if self.test_mode:
-            return module_id_hint or token[:32] or "test_module"
+        """Verify a token. Launcher's launcher_ws_token is verified locally.
+        Other tokens are verified via Registry POST /verify.
+        In debug mode (KITE_DEBUG=1), any non-empty token is accepted."""
+        if self.is_debug and token:
+            return module_id_hint or "debug"
+        # Local verification for Launcher bootstrap (before Registry registration)
+        if self.launcher_ws_token and token == self.launcher_ws_token:
+            return "launcher"
+        # Normal verification via Registry
         try:
             async with httpx.AsyncClient() as client:
                 resp = await client.post(
@@ -44,6 +65,62 @@ class EventHubServer:
             print(f"[event_hub] Token verification failed: {e}")
         return None
 
+    # ── Launcher bootstrap ──
+
+    async def _on_launcher_connected(self, ws: WebSocket):
+        """Called on first Launcher WS connect. Sends module.ready, then registers to Registry."""
+        self._launcher_connected = True
+        msg = {
+            "type": "event",
+            "event_id": str(uuid.uuid4()),
+            "event": "module.ready",
+            "source": "event_hub",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "data": {
+                "module_id": "event_hub",
+                "ws_endpoint": f"ws://{self.advertise_ip}:{self.port}/ws",
+            },
+        }
+        try:
+            await ws.send_text(json.dumps(msg))
+            print("[event_hub] Sent module.ready to Launcher")
+        except Exception as e:
+            print(f"[event_hub] Failed to send module.ready: {e}")
+        # Register to Registry in background
+        asyncio.create_task(self._register_to_registry())
+
+    async def _register_to_registry(self):
+        """Register to Registry. Triggered after Launcher connects."""
+        if self._registered_to_registry:
+            return
+        payload = {
+            "action": "register",
+            "module_id": "event_hub",
+            "module_type": "infrastructure",
+            "name": "Event Hub",
+            "api_endpoint": f"http://{self.advertise_ip}:{self.port}",
+            "health_endpoint": "/health",
+            "metadata": {
+                "ws_endpoint": f"ws://{self.advertise_ip}:{self.port}/ws",
+            },
+        }
+        headers = {"Authorization": f"Bearer {self.own_token}"}
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(
+                    f"{self.registry_url}/modules",
+                    json=payload,
+                    headers=headers,
+                    timeout=5,
+                )
+                if resp.status_code == 200:
+                    self._registered_to_registry = True
+                    print("[event_hub] Registered to Registry")
+                else:
+                    print(f"[event_hub] WARNING: Registry returned {resp.status_code}")
+        except Exception as e:
+            print(f"[event_hub] WARNING: Failed to register to Registry: {e}")
+
     # ── App factory ──
 
     def _create_app(self) -> FastAPI:
@@ -53,14 +130,11 @@ class EventHubServer:
         @app.on_event("startup")
         async def _startup():
             server._timer_task = asyncio.create_task(server._timer_loop())
-            server._test_task = asyncio.create_task(server._test_event_loop())
 
         @app.on_event("shutdown")
         async def _shutdown():
             if server._timer_task:
                 server._timer_task.cancel()
-            if hasattr(server, '_test_task') and server._test_task:
-                server._test_task.cancel()
 
         # ── WebSocket endpoint ──
 
@@ -70,12 +144,23 @@ class EventHubServer:
             mid_hint = ws.query_params.get("id", "")
             module_id = await server._verify_token(token, mid_hint)
             if not module_id:
+                # Must accept before close — Starlette drops TCP without close frame otherwise,
+                # causing websockets 15.x clients to get "no close frame received or sent" errors.
+                await ws.accept()
+                print(f"[event_hub] 认证失败: token={token[:8]}... hint={mid_hint}")
                 await ws.close(code=4001, reason="Authentication failed")
                 return
 
             await ws.accept()
             server.hub.add_connection(module_id, ws)
 
+            # Launcher bootstrap: first connection triggers module.ready + Registry registration
+            if (module_id == "launcher"
+                    and not server._launcher_connected
+                    and server.launcher_ws_token
+                    and token == server.launcher_ws_token):
+                await server._on_launcher_connected(ws)
+
             try:
                 while True:
                     raw = await ws.receive_text()
@@ -104,10 +189,9 @@ class EventHubServer:
     async def _timer_loop(self):
         while True:
             await asyncio.sleep(30)
-            # Dedup cleanup (offload to thread to avoid blocking event loop)
             await asyncio.get_event_loop().run_in_executor(None, self.hub.dedup.cleanup)
-            # Heartbeat to Registry
-            await self._heartbeat()
+            if self._registered_to_registry:
+                await self._heartbeat()
 
     async def _heartbeat(self):
         try:
@@ -120,19 +204,3 @@ class EventHubServer:
                 )
         except Exception:
             pass
-
-    async def _test_event_loop(self):
-        """Publish a test event every 5 seconds via internal routing."""
-        import uuid
-        from datetime import datetime, timezone
-        while True:
-            await asyncio.sleep(5)
-            msg = {
-                "type": "event",
-                "event_id": str(uuid.uuid4()),
-                "event": "event_hub.test",
-                "source": "event_hub",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "data": {"message": "heartbeat from event_hub"},
-            }
-            await self.hub._route_event("event_hub", msg)