@agentunion/kite 1.0.0

package/core/launcher/module.md

@@ -0,0 +1,37 @@
+---
+name: launcher
+display_name: "Launcher"
+version: "1.0"
+type: infrastructure
+state: enabled
+events:
+  - module.started
+  - module.stopped
+  - module.state_changed
+subscriptions: []
+discovery:
+  test_modules:
+    type: scan_dir
+    path: test_modules
+    enabled: true
+---
+
+# Launcher
+
+Kite 系统的启动器和进程管理器。与 main.py 在同一进程中运行，是整个系统的入口和控制台。
+
+## 职责
+
+- 启动 Registry，等待就绪
+- 扫描 core/ 和 extensions/ 下的模块
+- 并行启动 state: enabled 的模块
+- 监控子进程状态，core 模块崩溃触发全量重启
+- 提供 Launcher API 供其他模块启停管理
+- 优雅退出时清理所有子进程
+
+## API
+
+- `GET /launcher/modules` — 列出所有模块及状态
+- `POST /launcher/modules/{name}/start` — 启动模块
+- `POST /launcher/modules/{name}/stop` — 停止模块
+- `PUT /launcher/modules/{name}/state` — 修改模块 state

package/core/launcher/module_scanner.py

@@ -0,0 +1,253 @@
+"""
+Discover modules via configurable sources (scan_dir / module_list).
+Parse module.md YAML frontmatter to build ModuleInfo objects.
+"""
+
+import os
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class LaunchConfig:
+    cmd: list = field(default_factory=list)    # custom command, overrides runtime+entry
+    env: dict = field(default_factory=dict)    # extra env vars, merged into process env
+    cwd: str = ""                              # working dir, relative to module_dir
+    boot_stdin: bool = True                    # whether to pass boot_info via stdin
+    timeout: int = 30                          # seconds to wait for module.ready
+
+
+@dataclass
+class ModuleInfo:
+    name: str
+    display_name: str = ""
+    version: str = "1.0"
+    type: str = "infrastructure"        # infrastructure | channel | agent | service | kernel
+    state: str = "enabled"              # enabled | manual | disabled
+    runtime: str = "python"             # python | node | binary
+    entry: str = "entry.py"
+    events: list = field(default_factory=list)
+    subscriptions: list = field(default_factory=list)
+    preferred_port: int = 0             # 0 = OS assigns; non-zero = try this port first
+    depends_on: list = field(default_factory=list)  # module names this module depends on
+    monitor: bool = True                # whether Watchdog should monitor this module
+    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")
+        return os.path.normcase(self.module_dir).startswith(os.path.normcase(core_dir + os.sep))
+
+
+def _parse_frontmatter(text: str) -> dict:
+    """Parse YAML frontmatter from markdown text. Uses PyYAML if available."""
+    m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+    if not m:
+        return {}
+    raw = m.group(1)
+    try:
+        import yaml
+        result = yaml.safe_load(raw)
+        return result if isinstance(result, dict) else {}
+    except ImportError:
+        pass
+    # Fallback: minimal parser (flat key-value + lists only)
+    result = {}
+    current_key = None
+    current_list = None
+    for line in raw.split('\n'):
+        stripped = line.strip()
+        if not stripped or stripped.startswith('#'):
+            continue
+        if stripped.startswith('- ') and current_key is not None and current_list is not None:
+            current_list.append(stripped[2:].strip().strip('"').strip("'"))
+            continue
+        if ':' in stripped:
+            key, _, val = stripped.partition(':')
+            key = key.strip()
+            val = val.strip().strip('"').strip("'")
+            if val:
+                if val == '[]':
+                    result[key] = []
+                    current_key = key
+                    current_list = None
+                else:
+                    result[key] = val
+                    current_key = key
+                    current_list = None
+            else:
+                current_key = key
+                current_list = []
+                result[key] = current_list
+        else:
+            current_key = None
+            current_list = None
+    return result
+
+
+class ModuleScanner:
+    """Discover modules via configurable sources."""
+
+    def __init__(self, project_root: str, discovery: dict = None, launcher_dir: str = ""):
+        self.project_root = project_root
+        self.discovery = discovery
+        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 = {}
+
+        # 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)
+
+        # Extra sources from discovery config
+        if self.discovery:
+            for key, src in self.discovery.items():
+                if not isinstance(src, dict):
+                    continue
+                enabled = src.get("enabled", True)
+                if isinstance(enabled, str):
+                    enabled = enabled.lower() not in ("false", "0", "no")
+                if not enabled:
+                    continue
+
+                src_type = src.get("type", "")
+                path = src.get("path", "")
+                if not path:
+                    continue
+                if not os.path.isabs(path):
+                    path = os.path.join(self.project_root, path)
+
+                if src_type == "scan_dir":
+                    max_depth = int(src.get("max_depth", 2))
+                    self._scan_dir(path, max_depth, modules)
+                elif src_type == "module_list":
+                    self._load_list(path, modules)
+
+        return modules
+
+    def _scan_dir(self, base: str, max_depth: int, modules: dict, depth: int = 0):
+        """Recursively scan for module.md up to max_depth levels."""
+        if not os.path.isdir(base) or depth > max_depth:
+            return
+        for name in os.listdir(base):
+            sub = os.path.join(base, name)
+            if not os.path.isdir(sub):
+                continue
+            # Skip launcher itself
+            if os.path.normcase(os.path.abspath(sub)) == os.path.normcase(os.path.abspath(self.launcher_dir)):
+                continue
+            if os.path.isfile(os.path.join(sub, "module.md")):
+                self._add_module(sub, modules)
+            elif depth + 1 <= max_depth:
+                self._scan_dir(sub, max_depth, depth=depth + 1, modules=modules)
+
+    def _load_list(self, list_path: str, modules: dict):
+        """Load modules from a list file (one directory path per line)."""
+        if not os.path.isfile(list_path):
+            print(f"[launcher] WARNING: module list not found: {list_path}")
+            return
+        try:
+            with open(list_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#"):
+                        continue
+                    if not os.path.isabs(line):
+                        line = os.path.join(self.project_root, line)
+                    self._add_module(line, modules)
+        except Exception as e:
+            print(f"[launcher] WARNING: failed to read module list {list_path}: {e}")
+
+    def _add_module(self, mod_dir: str, modules: dict):
+        """Load a module and add it if name is unique."""
+        info = self._try_load(mod_dir)
+        if not info:
+            return
+        if info.name in modules:
+            print(f"[launcher] WARNING: duplicate module '{info.name}' at {mod_dir}, skipped")
+            return
+        modules[info.name] = info
+
+    def _try_load(self, mod_dir: str) -> ModuleInfo | None:
+        """Try to load a ModuleInfo from a directory containing module.md."""
+        if not os.path.isdir(mod_dir):
+            return None
+        md_path = os.path.join(mod_dir, "module.md")
+        if not os.path.isfile(md_path):
+            return None
+
+        try:
+            with open(md_path, "r", encoding="utf-8") as f:
+                text = f.read()
+        except Exception as e:
+            print(f"[launcher] WARNING: failed to read {md_path}: {e}")
+            return None
+
+        fm = _parse_frontmatter(text)
+        if not fm.get("name"):
+            print(f"[launcher] WARNING: module.md missing 'name' in {mod_dir}")
+            return None
+
+        events = fm.get("events", [])
+        subs = fm.get("subscriptions", [])
+        if isinstance(events, str):
+            events = [events]
+        if isinstance(subs, str):
+            subs = [subs]
+
+        try:
+            preferred_port = int(fm.get("preferred_port", 0))
+        except (ValueError, TypeError):
+            preferred_port = 0
+
+        depends_on = fm.get("depends_on", [])
+        if isinstance(depends_on, str):
+            depends_on = [depends_on]
+
+        monitor_val = fm.get("monitor", "true")
+        monitor = str(monitor_val).lower() not in ("false", "0", "no")
+
+        # Parse optional launch config
+        launch_raw = fm.get("launch", {})
+        if not isinstance(launch_raw, dict):
+            launch_raw = {}
+        launch_cmd = launch_raw.get("cmd", [])
+        if isinstance(launch_cmd, str):
+            launch_cmd = [launch_cmd]
+        launch_env = launch_raw.get("env", {})
+        if not isinstance(launch_env, dict):
+            launch_env = {}
+        launch_cwd = str(launch_raw.get("cwd", ""))
+        boot_stdin_val = launch_raw.get("boot_stdin", True)
+        launch_boot_stdin = str(boot_stdin_val).lower() not in ("false", "0", "no")
+        try:
+            launch_timeout = max(1, int(launch_raw.get("timeout", 30)))
+        except (ValueError, TypeError):
+            launch_timeout = 30
+        launch = LaunchConfig(
+            cmd=launch_cmd,
+            env=launch_env,
+            cwd=launch_cwd,
+            boot_stdin=launch_boot_stdin,
+            timeout=launch_timeout,
+        )
+
+        return ModuleInfo(
+            name=fm["name"],
+            display_name=fm.get("display_name", fm["name"]),
+            version=fm.get("version", "1.0"),
+            type=fm.get("type", "infrastructure"),
+            state=fm.get("state", "enabled"),
+            runtime=fm.get("runtime", "python"),
+            entry=fm.get("entry", "entry.py"),
+            events=events,
+            subscriptions=subs,
+            preferred_port=preferred_port,
+            depends_on=depends_on,
+            monitor=monitor,
+            module_dir=mod_dir,
+            launch=launch,
+        )