@agentunion/kite 1.4.0 → 1.6.0

package/launcher/logging_setup.py

@@ -14,6 +14,7 @@ from datetime import datetime, timezone
 # ── Timestamped print with delta + color ──
 _builtin_print = builtins.print
 _start_ts = time.monotonic()
+_start_unix = time.time()
 _last_ts = time.monotonic()
 _first_line = True
 _module_last_ts: dict[str, float] = {}
@@ -34,9 +35,21 @@ _log_daily_path = None
 _log_daily_date = ""
 _log_dir = None
 _crash_log_path = None
+_shutdown_log_path = None
+_shutdown_mode = False
 
 _ANSI_RE = re.compile(r"\033\[[0-9;]*m")
 
+# Terminal ring buffer hook — set by Launcher after init
+# Signature: _terminal_hook(ts: float, line: str)
+_terminal_hook = None
+
+
+def set_terminal_hook(fn):
+    """Register a callback to receive every launcher print line."""
+    global _terminal_hook
+    _terminal_hook = fn
+
 def _strip_ansi(s: str) -> str:
     return _ANSI_RE.sub("", s)
 
@@ -207,6 +220,13 @@ def _write_log(plain_line: str):
                     f.write(plain_line)
             except Exception:
                 pass
+        # 退出模式下同时写入 shutdown.log
+        if _shutdown_mode and _shutdown_log_path:
+            try:
+                with open(_shutdown_log_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
 
 
 def _write_crash(exc_type, exc_value, exc_tb,
@@ -369,6 +389,17 @@ def _tprint(*args, **kwargs):
         plain_prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
         _write_log(plain_prefix + _strip_ansi(text) + end)
 
+    if _terminal_hook is not None and plain_text:
+        try:
+            # 传完整带 ANSI 颜色的行（含时间戳前缀），前端负责渲染
+            raw_text = kwargs.get("sep", " ").join(str(a) for a in args)
+            full_line = f"[{elapsed_str:>6}] {ts} {delta_color}{delta_str:>8}{_RESET} " + raw_text
+            # 从 plain_text 提取模块名（如 [launcher]、[kernel] 等）
+            mod = module_name or "launcher"
+            _terminal_hook(mod, time.time(), full_line)
+        except Exception:
+            pass
+
 
 def setup_timestamped_print():
     """Replace builtins.print with timestamped version."""
@@ -377,11 +408,17 @@ def setup_timestamped_print():
 
 def reset_time_baseline():
     """Reset time baseline (used after code stats to exclude that time)."""
-    global _start_ts, _last_ts
+    global _start_ts, _start_unix, _last_ts
     _start_ts = time.monotonic()
+    _start_unix = time.time()
     _last_ts = time.monotonic()
 
 
+def get_start_unix():
+    """Return the Unix timestamp corresponding to _start_ts baseline."""
+    return _start_unix
+
+
 def get_crash_log_path():
     """Get the crash log path for error reporting."""
     return _crash_log_path
@@ -391,3 +428,19 @@ def write_crash_handled(exc_type, exc_value, exc_tb):
     """Write a handled crash to the log."""
     _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=True)
     _print_crash_summary(exc_type, exc_tb)
+
+
+def start_shutdown_logging():
+    """开始退出日志记录（清空 shutdown.log，后续日志双写）"""
+    global _shutdown_mode, _shutdown_log_path
+    if not _log_dir:
+        return
+    _shutdown_log_path = os.path.join(_log_dir, "shutdown.log")
+    try:
+        with open(_shutdown_log_path, "w", encoding="utf-8") as f:
+            pass  # 清空文件
+        _shutdown_mode = True
+    except Exception as e:
+        _builtin_print(f"[launcher] 警告: 无法初始化 shutdown.log: {e}")
+        _shutdown_log_path = None
+

package/launcher/module.md

@@ -4,17 +4,52 @@ display_name: Launcher
 version: '1.0'
 type: infrastructure
 state: enabled
+runtime: python
+entry: entry.py
+display_order: 100
 events:
 - module.started
 - module.stopped
 - module.state_changed
 subscriptions: []
 discovery:
-  test_modules:
+  cwd:
     type: scan_dir
-    path: test_modules
+    path: $KITE_CWD
     enabled: true
+    resolved_path: C:\Users\agentcp\AppData\Roaming\Evol\default\workspace\openclaw-acp-channel\ai-phone-agent\Kite
+  kite_modules:
+    type: scan_dir
+    path: $KITE_MODULES
+    enabled: true
+    resolved_path: C:\Users\agentcp\.kite\modules
+  services:
+    type: scan_dir
+    path: extensions/services
+    enabled: true
+    resolved_path: C:\Users\agentcp\AppData\Roaming\Evol\default\workspace\openclaw-acp-channel\ai-phone-agent\Kite\extensions/services
+  agents:
+    type: scan_dir
+    path: extensions/agents
+    enabled: true
+    resolved_path: C:\Users\agentcp\AppData\Roaming\Evol\default\workspace\openclaw-acp-channel\ai-phone-agent\Kite\extensions/agents
+  channels:
+    type: scan_dir
+    path: extensions/channels
+    enabled: true
+    resolved_path: C:\Users\agentcp\AppData\Roaming\Evol\default\workspace\openclaw-acp-channel\ai-phone-agent\Kite\extensions/channels
+relay:
+  modules:
+  - evol
+  - web
+  - kite_console
+  - gateway
+  token_limits:
+    evol: 100
+    web: 50
+    gateway: 100
 monitor: true
+advertise_ip: 0.0.0.0
 ---
 # Launcher
 

package/launcher/module_scanner.py

@@ -31,6 +31,11 @@ class ModuleInfo:
     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
+    display_order: int = 0              # 0-100, controls display order in module list (0=default, 100=highest)
+    manual_control: bool = True         # whether manual start/stop is allowed (default: True)
+    max_connections: int = 1             # max WebSocket connections to Kernel (1=single, >1=multi)
+    max_instances: int = 1              # max process instances (1=single, >1=multi-instance)
+    instance_elastic: bool = False      # whether Kernel can auto-scale instances based on pressure
     module_dir: str = ""                # absolute path to the module directory
     launch: LaunchConfig = field(default_factory=LaunchConfig)
 
@@ -42,18 +47,23 @@ class ModuleInfo:
                os.path.normcase(self.module_dir) == os.path.normcase(os.path.join(project_root, self.name))
 
 
-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)
+def _parse_frontmatter(text: str) -> tuple[dict, str]:
+    """Parse YAML frontmatter from markdown text. Returns (frontmatter_dict, body_text)."""
+    m = re.match(r'^---\s*\n(.*?)\n---\s*\n?(.*)', text, re.DOTALL)
     if not m:
-        return {}
+        return {}, text
+
     raw = m.group(1)
+    body = m.group(2)
+
     try:
         import yaml
         result = yaml.safe_load(raw)
-        return result if isinstance(result, dict) else {}
+        frontmatter = result if isinstance(result, dict) else {}
+        return frontmatter, body
     except ImportError:
         pass
+
     # Fallback: minimal parser (flat key-value + lists only)
     result = {}
     current_key = None
@@ -85,7 +95,7 @@ def _parse_frontmatter(text: str) -> dict:
         else:
             current_key = None
             current_list = None
-    return result
+    return result, body
 
 
 class ModuleScanner:
@@ -101,14 +111,15 @@ class ModuleScanner:
         modules = {}
         project_root = os.environ["KITE_PROJECT"]
 
-        # Built-in: scan kernel (depth 0) and extensions/ (depth 2)
-        # Note: launcher is not scanned (it's the scanner itself)
+        # Hardcoded: kernel (direct module, not from discovery)
         kernel_dir = os.path.join(project_root, "kernel")
         if os.path.isdir(kernel_dir):
-            self._scan_dir(kernel_dir, 0, modules)
-        self._scan_dir(os.path.join(project_root, "extensions"), 2, modules)
+            self._add_module(kernel_dir, modules)
+
+        scanned_paths = set()  # Track scanned paths to avoid duplicates
+        scanned_paths.add(os.path.normcase(os.path.abspath(kernel_dir)))
 
-        # Extra sources from discovery config
+        # All other directories from discovery config (order = config order)
         if self.discovery:
             for key, src in self.discovery.items():
                 if not isinstance(src, dict):
@@ -120,21 +131,48 @@ class ModuleScanner:
                     continue
 
                 src_type = src.get("type", "")
-                path = src.get("path", "")
+                path = self._resolve_path(src.get("path", ""), project_root)
                 if not path:
                     continue
-                if not os.path.isabs(path):
-                    path = os.path.join(project_root, path)
+
+                # Skip if already scanned
+                norm_path = os.path.normcase(os.path.abspath(path))
+                if norm_path in scanned_paths:
+                    continue
+                scanned_paths.add(norm_path)
+
+                if not os.path.isdir(path):
+                    continue
 
                 if src_type == "scan_dir":
-                    max_depth = int(src.get("max_depth", 2))
-                    self._scan_dir(path, max_depth, modules)
+                    max_depth = int(src.get("max_depth", 1))
+                    self._scan_dir(path, max_depth, modules, scanned_paths)
                 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):
+    @staticmethod
+    def _resolve_path(path: str, project_root: str) -> str:
+        """Resolve path with env var substitution."""
+        if not path:
+            return ""
+        # Substitute env vars like $KITE_CWD, $KITE_MODULES
+        if path.startswith("$"):
+            parts = path.split("/", 1) if "/" in path else path.split("\\", 1) if "\\" in path else [path]
+            var_name = parts[0][1:]  # Remove $
+            var_value = os.environ.get(var_name, "")
+            if not var_value:
+                return ""
+            if len(parts) > 1:
+                path = os.path.join(var_value, parts[1])
+            else:
+                path = var_value
+        elif not os.path.isabs(path):
+            path = os.path.join(project_root, path)
+        return path
+
+    def _scan_dir(self, base: str, max_depth: int, modules: dict, scanned_paths: set, depth: int = 0):
         """Recursively scan for module.md up to max_depth levels."""
         if not os.path.isdir(base) or depth > max_depth:
             return
@@ -142,13 +180,21 @@ class ModuleScanner:
             sub = os.path.join(base, name)
             if not os.path.isdir(sub):
                 continue
+
+            # Skip if already scanned
+            norm_sub = os.path.normcase(os.path.abspath(sub))
+            if norm_sub in scanned_paths:
+                continue
+
             # Skip launcher itself
-            if os.path.normcase(os.path.abspath(sub)) == os.path.normcase(os.path.abspath(self.launcher_dir)):
+            if norm_sub == os.path.normcase(os.path.abspath(self.launcher_dir)):
                 continue
+
             if os.path.isfile(os.path.join(sub, "module.md")):
+                scanned_paths.add(norm_sub)
                 self._add_module(sub, modules)
             elif depth + 1 <= max_depth:
-                self._scan_dir(sub, max_depth, depth=depth + 1, modules=modules)
+                self._scan_dir(sub, max_depth, modules, scanned_paths, depth=depth + 1)
 
     def _load_list(self, list_path: str, modules: dict):
         """Load modules from a list file (one directory path per line)."""
@@ -192,7 +238,7 @@ class ModuleScanner:
             print(f"[launcher] WARNING: failed to read {md_path}: {e}")
             return None
 
-        fm = _parse_frontmatter(text)
+        fm, _ = _parse_frontmatter(text)
         if not fm.get("name"):
             print(f"[launcher] WARNING: module.md missing 'name' in {mod_dir}")
             return None
@@ -216,6 +262,33 @@ class ModuleScanner:
         monitor_val = fm.get("monitor", "true")
         monitor = str(monitor_val).lower() not in ("false", "0", "no")
 
+        # Parse display_order (0-100, default 0)
+        try:
+            display_order = int(fm.get("display_order", 0))
+            display_order = max(0, min(100, display_order))  # Clamp to [0, 100]
+        except (ValueError, TypeError):
+            display_order = 0
+
+        # Parse max_connections (1-10, default 1)
+        try:
+            max_connections = int(fm.get("max_connections", 1))
+            max_connections = max(1, min(10, max_connections))  # Clamp to [1, 10]
+        except (ValueError, TypeError):
+            max_connections = 1
+
+        # Parse max_instances (1-10, default 1; >10 resets to 1 as safety valve)
+        try:
+            max_instances = int(fm.get("max_instances", 1))
+            if max_instances > 10:
+                max_instances = 1  # 离谱的值说明配置者不理解该参数，回到安全的单实例
+            max_instances = max(1, max_instances)
+        except (ValueError, TypeError):
+            max_instances = 1
+
+        # Parse instance_elastic (default false)
+        instance_elastic_val = fm.get("instance_elastic", False)
+        instance_elastic = str(instance_elastic_val).lower() in ("true", "1", "yes")
+
         # Parse optional launch config
         launch_raw = fm.get("launch", {})
         if not isinstance(launch_raw, dict):
@@ -241,6 +314,11 @@ class ModuleScanner:
             timeout=launch_timeout,
         )
 
+        # Parse manual_control (default: True)
+        manual_control = fm.get("manual_control", True)
+        if not isinstance(manual_control, bool):
+            manual_control = True
+
         return ModuleInfo(
             name=fm["name"],
             display_name=fm.get("display_name", fm["name"]),
@@ -254,6 +332,11 @@ class ModuleScanner:
             preferred_port=preferred_port,
             depends_on=depends_on,
             monitor=monitor,
+            display_order=display_order,
+            manual_control=manual_control,
+            max_connections=max_connections,
+            max_instances=max_instances,
+            instance_elastic=instance_elastic,
             module_dir=mod_dir,
             launch=launch,
         )