@agentunion/kite 1.0.0

package/core/launcher/process_manager.py

@@ -0,0 +1,435 @@
+"""
+Manage child process lifecycle: start, stop, monitor, cleanup leftovers.
+Cross-platform support for Windows, Linux, and macOS.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import threading
+import time
+from dataclasses import dataclass, asdict
+
+
+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, project_root: str, kite_token: str, instance_id: str = ""):
+        self.project_root = project_root
+        self.kite_token = kite_token
+        self.instance_id = instance_id or str(os.getpid())
+        self.data_dir = os.path.join(project_root, "core", "launcher", "data")
+        self.records_path = os.path.join(self.data_dir, f"processes_{self.instance_id}.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):
+        """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")
+
+        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
+
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    saved = json.load(f)
+            except Exception:
+                os.remove(path)
+                continue
+
+            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 clean legacy port.txt
+            legacy_port = os.path.join(registry_data_dir, "port.txt")
+            if os.path.isfile(legacy_port):
+                os.remove(legacy_port)
+
+    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] WARNING: failed to kill 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.
+        """
+        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} already running (PID {proc.pid})")
+                return True
+
+        cmd = self._build_cmd(info)
+        if not cmd:
+            print(f"[launcher] ERROR: cannot build command for {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
+        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] ERROR: failed to start {info.name}: {e}")
+            return False
+
+        # Write boot_info to stdin then close
+        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}")
+
+        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 and prefix with module name
+        t = threading.Thread(
+            target=self._read_stdout, args=(info.name, proc),
+            daemon=True,
+        )
+        t.start()
+
+        print(f"[launcher] Started {info.name} (PID {proc.pid})")
+        return True
+
+    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] WARNING: unknown runtime '{info.runtime}' for {info.name}")
+            return []
+
+    @staticmethod
+    def _read_stdout(name: str, proc: subprocess.Popen):
+        """Read subprocess stdout line by line, prefix with module name."""
+        try:
+            for line in iter(proc.stdout.readline, b""):
+                text = line.decode("utf-8", errors="replace").rstrip()
+                if text:
+                    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
+
+        print(f"[launcher] Stopping {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")
+            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] Stopped {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] Stopping all modules: {', '.join(names)}")
+
+        # Phase 1: send terminate to all
+        for name in names:
+            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] Force killing {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] All modules stopped")
+
+    # ── 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] WARNING: failed to write processes.json: {e}")

package/core/registry/data/port.txt

@@ -0,0 +1 @@
+51279

package/core/registry/data/port_14752.txt

@@ -0,0 +1 @@
+63756

package/core/registry/data/port_484.txt

@@ -0,0 +1 @@
+61190

package/core/registry/entry.py

@@ -0,0 +1,73 @@
+"""
+Registry entry point.
+Reads launcher_token, starts HTTP server on dynamic port, writes port.txt.
+"""
+
+import os
+import sys
+import socket
+
+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(_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 _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 _write_port_file(port: int, instance_id: str = ""):
+    data_dir = os.path.join(_this_dir, "data")
+    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)
+    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")
+        sys.exit(1)
+
+    print(f"[registry] Launcher token received ({len(launcher_token)} chars)")
+
+    # Create store and server
+    store = RegistryStore(launcher_token)
+    server = RegistryServer(store, launcher_token=launcher_token)
+
+    # Bind to dynamic port
+    port = _get_free_port()
+    _write_port_file(port, instance_id)
+
+    print(f"[registry] Starting on {bind_host}:{port}")
+    uvicorn.run(server.app, host=bind_host, port=port, log_level="warning")
+
+
+if __name__ == "__main__":
+    main()

package/core/registry/module.md

@@ -0,0 +1,30 @@
+---
+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） |