@agentunion/kite 1.0.5 → 1.0.7

package/core/launcher/module_scanner.py

@@ -34,9 +34,9 @@ class ModuleInfo:
     module_dir: str = ""                # absolute path to the module directory
     launch: LaunchConfig = field(default_factory=LaunchConfig)
 
-    def is_core(self, project_root: str) -> bool:
-        """Core modules live directly under {project_root}/core/."""
-        core_dir = os.path.join(project_root, "core")
+    def is_core(self) -> bool:
+        """Core modules live directly under {KITE_PROJECT}/core/."""
+        core_dir = os.path.join(os.environ["KITE_PROJECT"], "core")
         return os.path.normcase(self.module_dir).startswith(os.path.normcase(core_dir + os.sep))
 
 
@@ -89,18 +89,19 @@ def _parse_frontmatter(text: str) -> dict:
 class ModuleScanner:
     """Discover modules via configurable sources."""
 
-    def __init__(self, project_root: str, discovery: dict = None, launcher_dir: str = ""):
-        self.project_root = project_root
+    def __init__(self, discovery: dict = None, launcher_dir: str = ""):
         self.discovery = discovery
+        project_root = os.environ["KITE_PROJECT"]
         self.launcher_dir = launcher_dir or os.path.join(project_root, "core", "launcher")
 
     def scan(self) -> dict[str, ModuleInfo]:
         """Return dict of {module_name: ModuleInfo}. Duplicate names are skipped."""
         modules = {}
+        project_root = os.environ["KITE_PROJECT"]
 
         # Built-in: always scan core/ (depth 1) and extensions/ (depth 2)
-        self._scan_dir(os.path.join(self.project_root, "core"), 1, modules)
-        self._scan_dir(os.path.join(self.project_root, "extensions"), 2, modules)
+        self._scan_dir(os.path.join(project_root, "core"), 1, modules)
+        self._scan_dir(os.path.join(project_root, "extensions"), 2, modules)
 
         # Extra sources from discovery config
         if self.discovery:
@@ -118,7 +119,7 @@ class ModuleScanner:
                 if not path:
                     continue
                 if not os.path.isabs(path):
-                    path = os.path.join(self.project_root, path)
+                    path = os.path.join(project_root, path)
 
                 if src_type == "scan_dir":
                     max_depth = int(src.get("max_depth", 2))
@@ -156,7 +157,7 @@ class ModuleScanner:
                     if not line or line.startswith("#"):
                         continue
                     if not os.path.isabs(line):
-                        line = os.path.join(self.project_root, line)
+                        line = os.path.join(os.environ["KITE_PROJECT"], line)
                     self._add_module(line, modules)
         except Exception as e:
             print(f"[launcher] WARNING: failed to read module list {list_path}: {e}")

package/core/launcher/process_manager.py

@@ -1,6 +1,11 @@
 """
 Manage child process lifecycle: start, stop, monitor, cleanup leftovers.
 Cross-platform support for Windows, Linux, and macOS.
+
+stdio lifecycle:
+- stdin: write boot_info → keep open (Launcher may send more messages) → close after module.ready
+- stdout: read structured messages + log lines → close after module.ready
+- Structured messages: JSON lines with "kite" field, dispatched via callback
 """
 
 import json
@@ -10,6 +15,7 @@ import sys
 import threading
 import time
 from dataclasses import dataclass, asdict
+from typing import Callable
 
 
 IS_WINDOWS = sys.platform == "win32"
@@ -28,15 +34,19 @@ class ProcessRecord:
 class ProcessManager:
     """Manage child processes for all Kite modules."""
 
-    def __init__(self, project_root: str, kite_token: str, instance_id: str = ""):
-        self.project_root = project_root
+    def __init__(self, kite_token: str, instance_id: str = "",
+                 on_kite_message: Callable[[str, dict], None] | None = None):
+        """
+        Args:
+            on_kite_message: callback(module_name, msg_dict) for structured stdout messages.
+                             Called from stdout reader thread — must be thread-safe.
+        """
         self.kite_token = kite_token
         self.instance_id = instance_id or str(os.getpid())
-        # Use centralized data directory management
-        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-        from data_dir import get_launcher_data_dir
-        self.data_dir = get_launcher_data_dir()
-        self.records_path = os.path.join(self.data_dir, f"processes_{self.instance_id}.json")
+        self._on_kite_message = on_kite_message
+        # Use KITE_MODULE_DATA (set by Launcher for itself)
+        self.data_dir = os.environ.get("KITE_MODULE_DATA") or os.path.join(os.environ["KITE_INSTANCE_DIR"], "launcher")
+        self.records_path = os.path.join(self.data_dir, "processes.json")
         self._processes: dict[str, subprocess.Popen] = {}   # name -> Popen
         self._records: dict[str, ProcessRecord] = {}         # name -> record
         os.makedirs(self.data_dir, exist_ok=True)
@@ -44,77 +54,36 @@ class ProcessManager:
     # ── Leftover cleanup ──
 
     def cleanup_leftovers(self):
-        """Scan all processes_*.json files, kill leftovers from dead instances, preserve live ones."""
-        import glob
-
-        # Also clean legacy processes.json (pre-multi-instance)
-        legacy = os.path.join(self.data_dir, "processes.json")
-        patterns = [
-            os.path.join(self.data_dir, "processes_*.json"),
-        ]
-        files = []
-        for p in patterns:
-            files.extend(glob.glob(p))
-        if os.path.isfile(legacy):
-            files.append(legacy)
-
-        registry_data_dir = os.path.join(self.project_root, "core", "registry", "data")
-        # Also check user home registry data dir
-        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-        from data_dir import get_registry_data_dir
-        registry_data_dir_alt = get_registry_data_dir()
-
-        for path in files:
-            if path == self.records_path:
-                continue  # skip our own instance
-
-            # If this is an instance file, check if that Launcher is still alive
-            basename = os.path.basename(path)
-            if basename.startswith("processes_") and basename.endswith(".json"):
-                inst_id = basename[len("processes_"):-len(".json")]
-                try:
-                    if self._is_pid_alive(int(inst_id)):
-                        continue  # that Launcher is still running, skip
-                except (ValueError, TypeError):
-                    pass
+        """Read processes.json in current instance dir, kill leftovers from previous runs."""
+        if not os.path.isfile(self.records_path):
+            return
 
+        try:
+            with open(self.records_path, "r", encoding="utf-8") as f:
+                saved = json.load(f)
+        except Exception:
             try:
-                with open(path, "r", encoding="utf-8") as f:
-                    saved = json.load(f)
-            except Exception:
-                os.remove(path)
+                os.remove(self.records_path)
+            except OSError:
+                pass
+            return
+
+        for entry in saved:
+            pid = entry.get("pid", 0)
+            cmd = entry.get("cmd", [])
+            name = entry.get("name", "?")
+            if not pid:
                 continue
+            if self._is_pid_alive(pid) and self._cmd_matches(pid, cmd):
+                print(f"[launcher] 正在清理残留进程: {name} (PID {pid})")
+                self._force_kill(pid)
+            else:
+                print(f"[launcher] 残留进程 {name} (PID {pid}) 已不存在")
 
-            for entry in saved:
-                pid = entry.get("pid", 0)
-                cmd = entry.get("cmd", [])
-                name = entry.get("name", "?")
-                if not pid:
-                    continue
-                if self._is_pid_alive(pid) and self._cmd_matches(pid, cmd):
-                    print(f"[launcher] Killing leftover process: {name} (PID {pid})")
-                    self._force_kill(pid)
-                else:
-                    print(f"[launcher] Leftover {name} (PID {pid}) already gone")
-
-            os.remove(path)
-
-            # Remove corresponding port file
-            basename = os.path.basename(path)
-            if basename.startswith("processes_") and basename.endswith(".json"):
-                inst_id = basename[len("processes_"):-len(".json")]
-                port_file = os.path.join(registry_data_dir, f"port_{inst_id}.txt")
-                if os.path.isfile(port_file):
-                    os.remove(port_file)
-                # Also check alt location
-                port_file_alt = os.path.join(registry_data_dir_alt, f"port_{inst_id}.txt")
-                if os.path.isfile(port_file_alt):
-                    os.remove(port_file_alt)
-
-            # Also clean legacy port.txt
-            legacy_port = os.path.join(registry_data_dir, "port.txt")
-            if os.path.isfile(legacy_port):
-                os.remove(legacy_port)
+        try:
+            os.remove(self.records_path)
+        except OSError:
+            pass
 
     def _is_pid_alive(self, pid: int) -> bool:
         """Check if a process with given PID exists."""
@@ -229,13 +198,14 @@ class ProcessManager:
                 import signal
                 os.kill(pid, signal.SIGKILL)
         except Exception as e:
-            print(f"[launcher] WARNING: failed to kill PID {pid}: {e}")
+            print(f"[launcher] 警告: 强制终止 PID {pid} 失败: {e}")
 
     # ── Start module ──
 
     def start_module(self, info, boot_info: dict = None) -> bool:
         """Start a module as a subprocess. Returns True on success.
         If boot_info is provided, it is written as JSON to the child's stdin pipe.
+        stdin is kept open after boot_info for Launcher to send additional messages.
         """
         from .module_scanner import ModuleInfo
         info: ModuleInfo
@@ -243,17 +213,18 @@ class ProcessManager:
         if info.name in self._processes:
             proc = self._processes[info.name]
             if proc.poll() is None:
-                print(f"[launcher] {info.name} already running (PID {proc.pid})")
+                print(f"[launcher] {info.name} 已在运行 (PID {proc.pid})")
                 return True
 
         cmd = self._build_cmd(info)
         if not cmd:
-            print(f"[launcher] ERROR: cannot build command for {info.name}")
+            print(f"[launcher] 错误: 无法构建 {info.name} 的启动命令")
             return False
 
         env = os.environ.copy()
         env["PYTHONUTF8"] = "1"           # Force UTF-8 in child Python processes
         env["PYTHONUNBUFFERED"] = "1"     # Disable output buffering for real-time logs
+        env["KITE_MODULE_DATA"] = os.path.join(os.environ["KITE_INSTANCE_DIR"], info.name)
         if info.launch.env:
             env.update(info.launch.env)
 
@@ -278,17 +249,16 @@ class ProcessManager:
                 creationflags=creation_flags,
             )
         except Exception as e:
-            print(f"[launcher] ERROR: failed to start {info.name}: {e}")
+            print(f"[launcher] 错误: 启动 {info.name} 失败: {e}")
             return False
 
-        # Write boot_info to stdin then close
+        # Write boot_info to stdin — keep stdin open for additional messages
         if use_stdin and proc.stdin:
             try:
                 proc.stdin.write(json.dumps(boot_info).encode() + b"\n")
                 proc.stdin.flush()
-                proc.stdin.close()
             except Exception as e:
-                print(f"[launcher] WARNING: failed to write boot_info to {info.name}: {e}")
+                print(f"[launcher] 警告: 向 {info.name} 写入 boot_info 失败: {e}")
 
         self._processes[info.name] = proc
         self._records[info.name] = ProcessRecord(
@@ -299,16 +269,50 @@ class ProcessManager:
             started_at=time.time(),
         )
 
-        # Daemon thread to read stdout and prefix with module name
+        # Daemon thread to read stdout: structured messages + log lines
         t = threading.Thread(
             target=self._read_stdout, args=(info.name, proc),
             daemon=True,
         )
         t.start()
 
-        print(f"[launcher] Started {info.name} (PID {proc.pid})")
+        print(f"[launcher] 已启动 {info.name} (PID {proc.pid})")
         return True
 
+    def write_stdin(self, name: str, data: dict) -> bool:
+        """Write a structured JSON message to a module's stdin.
+        Used by Launcher to send additional messages after boot_info (e.g. launcher_ws_token).
+        Returns True on success.
+        """
+        proc = self._processes.get(name)
+        if not proc or not proc.stdin or proc.stdin.closed:
+            return False
+        try:
+            proc.stdin.write(json.dumps(data).encode() + b"\n")
+            proc.stdin.flush()
+            return True
+        except Exception as e:
+            print(f"[launcher] 警告: 向 {name} 写入 stdin 失败: {e}")
+            return False
+
+    def close_stdio(self, name: str):
+        """Close stdin and stdout for a module. Called by Launcher after module.ready → module.started.
+        stdout reader thread will exit naturally when stdout is closed.
+        """
+        proc = self._processes.get(name)
+        if not proc:
+            return
+        if proc.stdin and not proc.stdin.closed:
+            try:
+                proc.stdin.close()
+            except Exception:
+                pass
+        if proc.stdout and not proc.stdout.closed:
+            try:
+                proc.stdout.close()
+            except Exception:
+                pass
+
     def _build_cmd(self, info) -> list:
         """Build the command list based on module runtime.
 
@@ -329,16 +333,32 @@ class ProcessManager:
         elif info.runtime == "binary":
             return [os.path.join(info.module_dir, info.entry)]
         else:
-            print(f"[launcher] WARNING: unknown runtime '{info.runtime}' for {info.name}")
+            print(f"[launcher] 警告: 未知运行时 '{info.runtime}'，模块 {info.name}")
             return []
 
-    @staticmethod
-    def _read_stdout(name: str, proc: subprocess.Popen):
-        """Read subprocess stdout line by line, prefix with module name."""
+    def _read_stdout(self, name: str, proc: subprocess.Popen):
+        """Read subprocess stdout line by line.
+        Lines containing a JSON object with "kite" field are dispatched as structured messages.
+        All other lines are printed as log output with module name prefix.
+        """
         try:
             for line in iter(proc.stdout.readline, b""):
                 text = line.decode("utf-8", errors="replace").rstrip()
-                if text:
+                if not text:
+                    continue
+                # Try to parse as structured kite message
+                if self._on_kite_message and text.startswith("{"):
+                    try:
+                        msg = json.loads(text)
+                        if isinstance(msg, dict) and "kite" in msg:
+                            self._on_kite_message(name, msg)
+                            continue
+                    except (json.JSONDecodeError, KeyError):
+                        pass
+                # Regular log line — avoid double prefix if module already added [name]
+                if text.startswith(f"[{name}]"):
+                    print(text)
+                else:
                     print(f"[{name}] {text}")
         except Exception:
             pass
@@ -353,12 +373,15 @@ class ProcessManager:
             self._records.pop(name, None)
             return True
 
-        print(f"[launcher] Stopping {name} (PID {proc.pid})...")
+        # Close stdio before terminating
+        self.close_stdio(name)
+
+        print(f"[launcher] 正在停止 {name} (PID {proc.pid})...")
         proc.terminate()
         try:
             proc.wait(timeout=timeout)
         except subprocess.TimeoutExpired:
-            print(f"[launcher] {name} did not exit in {timeout}s, force killing")
+            print(f"[launcher] {name} 在 {timeout}s 内未退出，强制终止")
             proc.kill()
             try:
                 proc.wait(timeout=3)
@@ -367,7 +390,7 @@ class ProcessManager:
 
         self._processes.pop(name, None)
         self._records.pop(name, None)
-        print(f"[launcher] Stopped {name}")
+        print(f"[launcher] 已停止 {name}")
         return True
 
     def stop_all(self, timeout: float = 10):
@@ -376,10 +399,11 @@ class ProcessManager:
             return
 
         names = list(self._processes.keys())
-        print(f"[launcher] Stopping all modules: {', '.join(names)}")
+        print(f"[launcher] 正在停止所有模块: {', '.join(names)}")
 
-        # Phase 1: send terminate to all
+        # Phase 1: close stdio and send terminate to all
         for name in names:
+            self.close_stdio(name)
             proc = self._processes.get(name)
             if proc and proc.poll() is None:
                 proc.terminate()
@@ -400,7 +424,7 @@ class ProcessManager:
         for name in names:
             proc = self._processes.get(name)
             if proc and proc.poll() is None:
-                print(f"[launcher] Force killing {name} (PID {proc.pid})")
+                print(f"[launcher] 强制终止 {name} (PID {proc.pid})")
                 proc.kill()
                 try:
                     proc.wait(timeout=3)
@@ -409,7 +433,7 @@ class ProcessManager:
 
         self._processes.clear()
         self._records.clear()
-        print("[launcher] All modules stopped")
+        print("[launcher] 所有模块已停止")
 
     # ── Persistence & monitoring ──
 
@@ -443,4 +467,4 @@ class ProcessManager:
             with open(self.records_path, "w", encoding="utf-8") as f:
                 json.dump(data, f, indent=2)
         except Exception as e:
-            print(f"[launcher] WARNING: failed to write processes.json: {e}")
+            print(f"[launcher] 警告: 写入 processes.json 失败: {e}")

package/core/registry/entry.py

@@ -1,17 +1,19 @@
 """
 Registry entry point.
-Reads launcher_token, starts HTTP server on dynamic port, writes port.txt.
+Reads token from stdin boot_info, starts HTTP server on dynamic port,
+outputs port via stdout structured message, waits for Event Hub to trigger module.ready.
 """
 
+import json
 import os
 import sys
 import socket
 
 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)
 
@@ -19,54 +21,88 @@ from core.registry.store import RegistryStore
 from core.registry.server import RegistryServer
 
 
-def _get_free_port() -> int:
+def _read_module_md() -> dict:
+    """Read preferred_port and 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, "r", encoding="utf-8") as f:
+            text = f.read()
+        import re
+        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+        if m:
+            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 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(("127.0.0.1", 0))
+        s.bind((host, 0))
         return s.getsockname()[1]
 
 
-def _write_port_file(port: int, instance_id: str = ""):
-    from core.data_dir import get_registry_data_dir
-    data_dir = get_registry_data_dir()
-    os.makedirs(data_dir, exist_ok=True)
-    filename = f"port_{instance_id}.txt" if instance_id else "port.txt"
-    port_file = os.path.join(data_dir, filename)
-    with open(port_file, "w") as f:
-        f.write(str(port))
-    print(f"[registry] Port written to {port_file}")
-
-
 def main():
-    # Read launcher_token and config from stdin (boot_info JSON pipe)
+    # 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 (only token)
     launcher_token = ""
-    bind_host = "127.0.0.1"
-    instance_id = ""
     try:
-        import json
         line = sys.stdin.readline().strip()
         if line:
             boot_info = json.loads(line)
             launcher_token = boot_info.get("token", "")
-            bind_host = boot_info.get("bind", "127.0.0.1")
-            instance_id = boot_info.get("instance_id", "")
     except Exception:
         pass
 
     if not launcher_token:
-        print("[registry] ERROR: No launcher token provided via stdin boot_info")
+        print("[registry] 错误: 未通过 stdin boot_info 提供启动器令牌")
         sys.exit(1)
 
-    print(f"[registry] Launcher token received ({len(launcher_token)} chars)")
+    print(f"[registry] 已收到启动器令牌 ({len(launcher_token)} 字符)")
 
-    # Create store and server
+    if is_debug:
+        print("[registry] 调试模式已启用 (KITE_DEBUG=1)，接受所有令牌")
+
+    # Step 2: Read config from own module.md
+    md_config = _read_module_md()
+    advertise_ip = md_config["advertise_ip"]
+    preferred_port = md_config["preferred_port"]
+
+    # Step 3: Create store and server
     store = RegistryStore(launcher_token)
-    server = RegistryServer(store, launcher_token=launcher_token)
+    server = RegistryServer(store, launcher_token=launcher_token, advertise_ip=advertise_ip)
+
+    # Step 4: Bind port
+    bind_host = advertise_ip
+    port = _bind_port(preferred_port, bind_host)
+
+    # Step 5: Output port via stdout structured message (Launcher reads this)
+    # This message proves HTTP is about to start — Launcher uses it as readiness signal
+    print(json.dumps({"kite": "port", "port": port}), flush=True)
+
+    print(f"[registry] 启动中 {bind_host}:{port}")
 
-    # Bind to dynamic port
-    port = _get_free_port()
-    _write_port_file(port, instance_id)
+    # Store port and advertise_ip for module.ready event later
+    server.port = port
 
-    print(f"[registry] Starting on {bind_host}:{port}")
     uvicorn.run(server.app, host=bind_host, port=port, log_level="warning")