@agentunion/kite 1.0.7 → 1.3.0

package/core/launcher/process_manager.py

@@ -1,470 +0,0 @@
-"""
-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
-import os
-import subprocess
-import sys
-import threading
-import time
-from dataclasses import dataclass, asdict
-from typing import Callable
-
-
-IS_WINDOWS = sys.platform == "win32"
-IS_MACOS = sys.platform == "darwin"
-
-
-@dataclass
-class ProcessRecord:
-    name: str
-    pid: int
-    cmd: list
-    module_dir: str
-    started_at: float
-
-
-class ProcessManager:
-    """Manage child processes for all Kite modules."""
-
-    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())
-        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)
-
-    # ── Leftover cleanup ──
-
-    def cleanup_leftovers(self):
-        """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:
-                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}) 已不存在")
-
-        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."""
-        if IS_WINDOWS:
-            try:
-                result = subprocess.run(
-                    ["tasklist", "/FI", f"PID eq {pid}", "/NH"],
-                    capture_output=True, text=True, timeout=5,
-                )
-                return str(pid) in result.stdout
-            except Exception:
-                return False
-        else:
-            try:
-                os.kill(pid, 0)
-                return True
-            except OSError:
-                return False
-
-    def _cmd_matches(self, pid: int, expected_cmd: list) -> bool:
-        """Verify the process command line matches what we expect (prevent killing recycled PIDs).
-        Uses multi-strategy fallback per platform for robustness.
-        """
-        if not expected_cmd:
-            return False
-        cmdline = self._get_process_cmdline(pid)
-        if cmdline:
-            return expected_cmd[-1] in cmdline
-        # Degraded fallback: match executable image name only
-        return self._exe_name_matches(pid, expected_cmd)
-
-    def _get_process_cmdline(self, pid: int) -> str:
-        """Get full command line of a process. Returns empty string on failure."""
-        if IS_WINDOWS:
-            for method in (self._win_powershell_cmdline, self._win_wmic_cmdline):
-                result = method(pid)
-                if result:
-                    return result
-            return ""
-        elif IS_MACOS:
-            try:
-                r = subprocess.run(["ps", "-p", str(pid), "-o", "command="],
-                                   capture_output=True, text=True, timeout=5)
-                return r.stdout.strip()
-            except Exception:
-                return ""
-        else:
-            # Linux: /proc first, ps fallback
-            try:
-                with open(f"/proc/{pid}/cmdline", "r") as f:
-                    return f.read()
-            except Exception:
-                pass
-            try:
-                r = subprocess.run(["ps", "-p", str(pid), "-o", "args="],
-                                   capture_output=True, text=True, timeout=5)
-                return r.stdout.strip()
-            except Exception:
-                return ""
-
-    def _win_powershell_cmdline(self, pid: int) -> str:
-        """Windows: Get cmdline via PowerShell Get-CimInstance (modern, replaces wmic)."""
-        try:
-            r = subprocess.run(
-                ["powershell", "-NoProfile", "-Command",
-                 f"(Get-CimInstance Win32_Process -Filter 'ProcessId={pid}').CommandLine"],
-                capture_output=True, text=True, timeout=8,
-            )
-            return r.stdout.strip()
-        except Exception:
-            return ""
-
-    def _win_wmic_cmdline(self, pid: int) -> str:
-        """Windows: Get cmdline via wmic (legacy fallback, deprecated but widely available)."""
-        try:
-            r = subprocess.run(
-                ["wmic", "process", "where", f"ProcessId={pid}",
-                 "get", "CommandLine", "/value"],
-                capture_output=True, text=True, timeout=5,
-            )
-            return r.stdout.strip()
-        except Exception:
-            return ""
-
-    def _exe_name_matches(self, pid: int, expected_cmd: list) -> bool:
-        """Last resort: check if process image name matches expected executable."""
-        exe = os.path.basename(expected_cmd[0]).lower()
-        if exe.endswith(".exe"):
-            exe = exe[:-4]
-        if IS_WINDOWS:
-            try:
-                r = subprocess.run(["tasklist", "/FI", f"PID eq {pid}", "/FO", "CSV", "/NH"],
-                                   capture_output=True, text=True, timeout=5)
-                return exe in r.stdout.lower()
-            except Exception:
-                return False
-        else:
-            try:
-                r = subprocess.run(["ps", "-p", str(pid), "-o", "comm="],
-                                   capture_output=True, text=True, timeout=5)
-                return exe in r.stdout.lower()
-            except Exception:
-                return False
-
-    def _force_kill(self, pid: int):
-        """Force kill a process by PID."""
-        try:
-            if IS_WINDOWS:
-                subprocess.run(["taskkill", "/F", "/PID", str(pid)],
-                               capture_output=True, timeout=5)
-            else:
-                import signal
-                os.kill(pid, signal.SIGKILL)
-        except Exception as 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
-
-        if info.name in self._processes:
-            proc = self._processes[info.name]
-            if proc.poll() is None:
-                print(f"[launcher] {info.name} 已在运行 (PID {proc.pid})")
-                return True
-
-        cmd = self._build_cmd(info)
-        if not cmd:
-            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)
-
-        creation_flags = 0
-        if IS_WINDOWS:
-            creation_flags = subprocess.CREATE_NO_WINDOW
-
-        use_stdin = boot_info is not None and info.launch.boot_stdin
-
-        cwd = info.module_dir
-        if info.launch.cwd:
-            cwd = os.path.normpath(os.path.join(info.module_dir, info.launch.cwd))
-
-        try:
-            proc = subprocess.Popen(
-                cmd,
-                cwd=cwd,
-                env=env,
-                stdin=subprocess.PIPE if use_stdin else None,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                creationflags=creation_flags,
-            )
-        except Exception as e:
-            print(f"[launcher] 错误: 启动 {info.name} 失败: {e}")
-            return False
-
-        # 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()
-            except Exception as e:
-                print(f"[launcher] 警告: 向 {info.name} 写入 boot_info 失败: {e}")
-
-        self._processes[info.name] = proc
-        self._records[info.name] = ProcessRecord(
-            name=info.name,
-            pid=proc.pid,
-            cmd=cmd,
-            module_dir=info.module_dir,
-            started_at=time.time(),
-        )
-
-        # 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] 已启动 {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.
-
-        For python/node: if entry starts with '-m ', use package mode (e.g. python -m pkg).
-        Otherwise use script file mode (e.g. python entry.py).
-        """
-        if info.launch.cmd:
-            return list(info.launch.cmd)
-
-        if info.runtime == "python":
-            if info.entry.startswith("-m "):
-                return [sys.executable] + info.entry.split()
-            return [sys.executable, os.path.join(info.module_dir, info.entry)]
-        elif info.runtime == "node":
-            if info.entry.startswith("-e ") or info.entry.startswith("--eval "):
-                return ["node"] + info.entry.split()
-            return ["node", os.path.join(info.module_dir, info.entry)]
-        elif info.runtime == "binary":
-            return [os.path.join(info.module_dir, info.entry)]
-        else:
-            print(f"[launcher] 警告: 未知运行时 '{info.runtime}'，模块 {info.name}")
-            return []
-
-    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 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
-
-    # ── Stop module ──
-
-    def stop_module(self, name: str, timeout: float = 5) -> bool:
-        """Stop a module by name. Returns True if stopped successfully."""
-        proc = self._processes.get(name)
-        if not proc or proc.poll() is not None:
-            self._processes.pop(name, None)
-            self._records.pop(name, None)
-            return True
-
-        # 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} 在 {timeout}s 内未退出，强制终止")
-            proc.kill()
-            try:
-                proc.wait(timeout=3)
-            except subprocess.TimeoutExpired:
-                self._force_kill(proc.pid)
-
-        self._processes.pop(name, None)
-        self._records.pop(name, None)
-        print(f"[launcher] 已停止 {name}")
-        return True
-
-    def stop_all(self, timeout: float = 10):
-        """Stop all managed processes. Terminate first, force kill after timeout."""
-        if not self._processes:
-            return
-
-        names = list(self._processes.keys())
-        print(f"[launcher] 正在停止所有模块: {', '.join(names)}")
-
-        # 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()
-
-        # Phase 2: wait for all to exit
-        deadline = time.time() + timeout
-        for name in names:
-            proc = self._processes.get(name)
-            if not proc:
-                continue
-            remaining = max(0.1, deadline - time.time())
-            try:
-                proc.wait(timeout=remaining)
-            except subprocess.TimeoutExpired:
-                pass
-
-        # Phase 3: force kill survivors
-        for name in names:
-            proc = self._processes.get(name)
-            if proc and proc.poll() is None:
-                print(f"[launcher] 强制终止 {name} (PID {proc.pid})")
-                proc.kill()
-                try:
-                    proc.wait(timeout=3)
-                except subprocess.TimeoutExpired:
-                    self._force_kill(proc.pid)
-
-        self._processes.clear()
-        self._records.clear()
-        print("[launcher] 所有模块已停止")
-
-    # ── Persistence & monitoring ──
-
-    def persist_records(self):
-        """Write current process records to processes.json."""
-        data = [asdict(r) for r in self._records.values()]
-        self._write_records_file(data)
-
-    def check_exited(self) -> list[tuple[str, int]]:
-        """Non-blocking check for exited child processes. Returns [(name, returncode)]."""
-        exited = []
-        for name in list(self._processes.keys()):
-            proc = self._processes[name]
-            rc = proc.poll()
-            if rc is not None:
-                exited.append((name, rc))
-                self._processes.pop(name, None)
-                self._records.pop(name, None)
-        return exited
-
-    def get_record(self, name: str) -> ProcessRecord | None:
-        return self._records.get(name)
-
-    def is_running(self, name: str) -> bool:
-        proc = self._processes.get(name)
-        return proc is not None and proc.poll() is None
-
-    def _write_records_file(self, data: list):
-        """Write data list to processes.json."""
-        try:
-            with open(self.records_path, "w", encoding="utf-8") as f:
-                json.dump(data, f, indent=2)
-        except Exception as e:
-            print(f"[launcher] 警告: 写入 processes.json 失败: {e}")

package/core/registry/entry.py

@@ -1,110 +0,0 @@
-"""
-Registry entry point.
-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 (set by main.py or cli.js)
-_this_dir = os.path.dirname(os.path.abspath(__file__))
-_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)
-
-from core.registry.store import RegistryStore
-from core.registry.server import RegistryServer
-
-
-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((host, 0))
-        return s.getsockname()[1]
-
-
-def main():
-    # 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 = ""
-    try:
-        line = sys.stdin.readline().strip()
-        if line:
-            boot_info = json.loads(line)
-            launcher_token = boot_info.get("token", "")
-    except Exception:
-        pass
-
-    if not launcher_token:
-        print("[registry] 错误: 未通过 stdin boot_info 提供启动器令牌")
-        sys.exit(1)
-
-    print(f"[registry] 已收到启动器令牌 ({len(launcher_token)} 字符)")
-
-    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, 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}")
-
-    # Store port and advertise_ip for module.ready event later
-    server.port = port
-
-    uvicorn.run(server.app, host=bind_host, port=port, log_level="warning")
-
-
-if __name__ == "__main__":
-    main()

package/core/registry/module.md

@@ -1,30 +0,0 @@
----
-name: registry
-display_name: Registry
-type: infrastructure
-state: enabled
-runtime: python
-entry: entry.py
----
-
-# Registry
-
-Kite 系统注册中心，第一个启动的核心模块。
-
-## 职责
-
-- 服务注册与发现（所有模块的"电话簿"）
-- 能力索引（工具、Hook、事件的聚合查询）
-- 通用字段查询（glob 模式匹配）
-- 心跳 TTL 管理
-
-## API
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| POST | `/modules` | 模块生命周期（register / deregister / heartbeat） |
-| GET | `/lookup` | 通用搜索（三参数均支持 glob） |
-| GET | `/get/{path}` | 按路径精确读取注册内容 |
-| POST | `/tokens` | 注册 token 映射（仅 Launcher） |
-| POST | `/query` | LLM 自然语言查询（待实现） |
-| GET | `/health` | 健康检查（无需 token） |