@agentunion/kite 1.3.1 → 1.3.2

package/extensions/services/watchdog/monitor.py

@@ -6,6 +6,9 @@ Launcher handles process-level crashes; Watchdog handles app-level failures
 
 import asyncio
 import json
+import os
+import subprocess
+import sys
 import time
 from datetime import datetime, timezone
 
@@ -85,6 +88,10 @@ class HealthMonitor:
         self._system_ready_event = asyncio.Event()
         self._crash_counts: dict[str, int] = {}         # module_id -> consecutive crash count
 
+        # Launcher loss tracking
+        self._launcher_offline = False
+        self._launcher_had_exiting = False  # True if module.exiting was received for launcher
+
     # ── Module discovery ──
 
     async def discover_modules(self):
@@ -364,6 +371,28 @@ class HealthMonitor:
             self._system_ready_event.set()
             return
 
+        # module.offline — track launcher state
+        if event_type == "module.offline":
+            if module_id == "launcher":
+                print("[watchdog] Received module.offline(launcher)")
+                self._launcher_offline = True
+            return
+
+        # module.shutdown with reason launcher_lost — decide whether to start new instance
+        if event_type == "module.shutdown":
+            reason = data.get("reason", "")
+            if reason == "launcher_lost":
+                print("[watchdog] Received module.shutdown(reason=launcher_lost)")
+                await self._handle_launcher_lost()
+                return
+            target = data.get("module_id", "")
+            if not target:
+                # Broadcast shutdown — check reason
+                if reason == "system_shutdown":
+                    print(f"[watchdog] Received system_shutdown signal")
+                    self._system_shutting_down = True
+            return
+
         if not module_id or module_id == "watchdog":
             return
 
@@ -381,17 +410,18 @@ class HealthMonitor:
             action = data.get("action", "none")
             print(f"[watchdog] Received module.exiting: {module_id}, action={action}")
             self._exit_intents[module_id] = action
+            # Track launcher exiting intent
+            if module_id == "launcher":
+                self._launcher_had_exiting = True
 
         elif event_type == "module.ready":
             graceful = bool(data.get("graceful_shutdown"))
             print(f"[watchdog] Received module.ready: {module_id}, graceful_shutdown={graceful}")
             self._graceful_modules[module_id] = graceful
-
-        elif event_type == "module.shutdown":
-            reason = data.get("reason", "")
-            if reason == "system_shutdown":
-                print(f"[watchdog] Received system_shutdown signal")
-                self._system_shutting_down = True
+            # Reset launcher loss tracking when launcher reconnects
+            if module_id == "launcher":
+                self._launcher_offline = False
+                self._launcher_had_exiting = False
 
     async def _handle_module_stopped(self, module_id: str, data: dict):
         """Restart decision engine — called when module.stopped is received.
@@ -443,6 +473,82 @@ class HealthMonitor:
                 "message": f"{module_id} exceeded {self.MAX_RESTARTS} crash restarts",
             })
 
+    async def _handle_launcher_lost(self):
+        """Handle launcher_lost: decide whether to start a new Kite instance.
+
+        - If launcher sent module.exiting before going offline → normal exit, follow suit
+        - If launcher did NOT send module.exiting → crash/unexpected, start new instance
+        """
+        if self._launcher_had_exiting:
+            print("[watchdog] Launcher had sent module.exiting before loss → normal exit, following suit")
+            sys.exit(0)
+        else:
+            print("[watchdog] Launcher lost without module.exiting → crash detected, starting new instance")
+            self._start_new_instance()
+            print("[watchdog] New instance started, exiting")
+            sys.exit(0)
+
+    def _start_new_instance(self):
+        """Start a new Kite instance by running python main.py in the project directory."""
+        project_dir = os.environ.get("KITE_PROJECT", "")
+        if not project_dir:
+            print("[watchdog] ERROR: KITE_PROJECT not set, cannot start new instance")
+            return
+
+        main_py = os.path.join(project_dir, "main.py")
+        if not os.path.exists(main_py):
+            print(f"[watchdog] ERROR: {main_py} not found, cannot start new instance")
+            return
+
+        print(f"[watchdog] Starting new Kite instance: python {main_py}")
+        try:
+            # Start detached process with new console window
+            if sys.platform == "win32":
+                # Use 'start' command to force visible console window
+                subprocess.Popen(
+                    ["cmd", "/c", "start", "Kite", sys.executable, main_py],
+                    cwd=project_dir,
+                    shell=False,
+                )
+            elif sys.platform == "darwin":
+                # macOS: use 'open -a Terminal' to launch in new Terminal window
+                subprocess.Popen(
+                    ["open", "-a", "Terminal", main_py],
+                    cwd=project_dir,
+                )
+            else:
+                # Linux: try common terminal emulators
+                terminals = [
+                    ["x-terminal-emulator", "-e"],  # Debian/Ubuntu default
+                    ["gnome-terminal", "--"],       # GNOME
+                    ["konsole", "-e"],              # KDE
+                    ["xterm", "-e"],                # Fallback
+                ]
+                launched = False
+                for term_cmd in terminals:
+                    try:
+                        subprocess.Popen(
+                            term_cmd + [sys.executable, main_py],
+                            cwd=project_dir,
+                            start_new_session=True,
+                        )
+                        launched = True
+                        break
+                    except FileNotFoundError:
+                        continue
+                if not launched:
+                    # Fallback: headless start
+                    print("[watchdog] WARNING: No terminal emulator found, starting headless")
+                    subprocess.Popen(
+                        [sys.executable, main_py],
+                        cwd=project_dir,
+                        start_new_session=True,
+                        stdin=subprocess.DEVNULL,
+                    )
+            print("[watchdog] New Kite instance started successfully")
+        except Exception as e:
+            print(f"[watchdog] Failed to start new instance: {e}")
+
     async def _restart_module_by_id(self, module_id: str, reason: str = "restart"):
         """Restart a module via Launcher RPC by module_id."""
         print(f"[watchdog] Requesting restart for {module_id} (reason={reason})")

package/extensions/services/web/routes/routes_modules.py

@@ -0,0 +1,249 @@
+"""Routes for module management — scan, view, and edit module metadata + config."""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+from fastapi import APIRouter, HTTPException
+
+from routes.schemas import ModuleConfigUpdate, ModuleMetadataUpdate
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["modules"])
+
+# Fields that may NOT be changed via the metadata API
+_READONLY_FIELDS = frozenset({"name", "type", "runtime", "entry"})
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _get_project_root() -> Path:
+    """Return the Kite project root directory."""
+    env = os.environ.get("KITE_PROJECT")
+    if env:
+        return Path(env)
+    # Fallback: __file__ is routes/routes_modules.py → up 5 levels to project root
+    # routes_modules.py → routes/ → web/ → services/ → extensions/ → Kite/
+    return Path(__file__).resolve().parents[4]
+
+
+def _scan_modules() -> list[dict[str, Any]]:
+    """Discover all modules by scanning kernel/ (depth 0) and extensions/ (depth 2)."""
+    root = _get_project_root()
+    found: list[dict[str, Any]] = []
+
+    # 1. kernel/module.md
+    kernel_md = root / "kernel" / "module.md"
+    if kernel_md.is_file():
+        meta, _ = _parse_module_md(kernel_md)
+        if meta:
+            meta["_path"] = str(kernel_md)
+            meta["_dir"] = str(kernel_md.parent)
+            found.append(meta)
+
+    # 2. launcher/module.md
+    launcher_md = root / "launcher" / "module.md"
+    if launcher_md.is_file():
+        meta, _ = _parse_module_md(launcher_md)
+        if meta:
+            meta["_path"] = str(launcher_md)
+            meta["_dir"] = str(launcher_md.parent)
+            found.append(meta)
+
+    # 3. extensions/{category}/{name}/module.md  (depth 2)
+    ext_dir = root / "extensions"
+    if ext_dir.is_dir():
+        for category in sorted(ext_dir.iterdir()):
+            if not category.is_dir() or category.name.startswith("."):
+                continue
+            for mod_dir in sorted(category.iterdir()):
+                if not mod_dir.is_dir() or mod_dir.name.startswith("."):
+                    continue
+                md_path = mod_dir / "module.md"
+                if md_path.is_file():
+                    meta, _ = _parse_module_md(md_path)
+                    if meta:
+                        meta["_path"] = str(md_path)
+                        meta["_dir"] = str(mod_dir)
+                        found.append(meta)
+
+    return found
+
+
+_FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n?(.*)", re.DOTALL)
+
+
+def _parse_module_md(path: Path) -> tuple[dict[str, Any], str]:
+    """Parse YAML frontmatter from a module.md file. Returns (frontmatter_dict, body_str)."""
+    try:
+        text = path.read_text(encoding="utf-8")
+    except Exception as exc:
+        logger.warning("Failed to read %s: %s", path, exc)
+        return {}, ""
+
+    m = _FRONTMATTER_RE.match(text)
+    if not m:
+        return {}, text
+
+    try:
+        fm = yaml.safe_load(m.group(1)) or {}
+    except yaml.YAMLError as exc:
+        logger.warning("Failed to parse frontmatter in %s: %s", path, exc)
+        return {}, text
+
+    return fm, m.group(2)
+
+
+def _write_module_md(path: Path, frontmatter: dict[str, Any], body: str) -> None:
+    """Write frontmatter + body back to module.md."""
+    fm_str = yaml.dump(frontmatter, allow_unicode=True, sort_keys=False, default_flow_style=False).rstrip()
+    content = f"---\n{fm_str}\n---\n{body}"
+    path.write_text(content, encoding="utf-8")
+
+
+def _find_module(name: str) -> dict[str, Any] | None:
+    """Find a single module by name."""
+    for m in _scan_modules():
+        if m.get("name") == name:
+            return m
+    return None
+
+
+def _deep_merge(base: dict, overlay: dict) -> dict:
+    """Recursively merge overlay into base (mutates base)."""
+    for k, v in overlay.items():
+        if k in base and isinstance(base[k], dict) and isinstance(v, dict):
+            _deep_merge(base[k], v)
+        else:
+            base[k] = v
+    return base
+
+
+# ---------------------------------------------------------------------------
+# API endpoints
+# ---------------------------------------------------------------------------
+
+@router.get("/modules")
+async def list_modules():
+    """List all discovered modules."""
+    modules = _scan_modules()
+    result = []
+    for m in modules:
+        mod_dir = Path(m["_dir"])
+        has_config = (mod_dir / "config.yaml").is_file()
+        result.append({
+            "name": m.get("name", ""),
+            "display_name": m.get("display_name", ""),
+            "type": m.get("type", ""),
+            "state": m.get("state", "enabled"),
+            "version": m.get("version", ""),
+            "runtime": m.get("runtime", ""),
+            "preferred_port": m.get("preferred_port"),
+            "monitor": m.get("monitor"),
+            "has_config": has_config,
+        })
+    return result
+
+
+@router.get("/modules/{name}")
+async def get_module(name: str):
+    """Get module details including config.yaml content (if any)."""
+    m = _find_module(name)
+    if not m:
+        raise HTTPException(404, f"Module not found: {name}")
+
+    mod_dir = Path(m["_dir"])
+    md_path = Path(m["_path"])
+
+    # Parse full frontmatter
+    frontmatter, _ = _parse_module_md(md_path)
+
+    # Read config.yaml if present
+    config = None
+    config_path = mod_dir / "config.yaml"
+    if config_path.is_file():
+        try:
+            config = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+        except Exception as exc:
+            logger.warning("Failed to read config.yaml for %s: %s", name, exc)
+
+    return {
+        "name": frontmatter.get("name", name),
+        "display_name": frontmatter.get("display_name", ""),
+        "type": frontmatter.get("type", ""),
+        "state": frontmatter.get("state", "enabled"),
+        "version": frontmatter.get("version", ""),
+        "runtime": frontmatter.get("runtime", ""),
+        "entry": frontmatter.get("entry", ""),
+        "preferred_port": frontmatter.get("preferred_port"),
+        "advertise_ip": frontmatter.get("advertise_ip"),
+        "monitor": frontmatter.get("monitor"),
+        "events": frontmatter.get("events"),
+        "subscriptions": frontmatter.get("subscriptions"),
+        "depends_on": frontmatter.get("depends_on"),
+        "has_config": config is not None,
+        "config": config,
+    }
+
+
+@router.put("/modules/{name}/metadata")
+async def update_module_metadata(name: str, update: ModuleMetadataUpdate):
+    """Update module.md frontmatter (whitelisted fields only)."""
+    m = _find_module(name)
+    if not m:
+        raise HTTPException(404, f"Module not found: {name}")
+
+    md_path = Path(m["_path"])
+    frontmatter, body = _parse_module_md(md_path)
+    if not frontmatter:
+        raise HTTPException(500, "Failed to parse module.md frontmatter")
+
+    # Apply only non-None fields, excluding readonly
+    changes = update.model_dump(exclude_none=True)
+    for key in list(changes.keys()):
+        if key in _READONLY_FIELDS:
+            continue
+        frontmatter[key] = changes[key]
+
+    _write_module_md(md_path, frontmatter, body)
+    return {"ok": True, "name": name}
+
+
+@router.put("/modules/{name}/config")
+async def update_module_config(name: str, update: ModuleConfigUpdate):
+    """Deep-merge update into module's config.yaml."""
+    m = _find_module(name)
+    if not m:
+        raise HTTPException(404, f"Module not found: {name}")
+
+    mod_dir = Path(m["_dir"])
+    config_path = mod_dir / "config.yaml"
+
+    # Read existing config
+    existing: dict[str, Any] = {}
+    if config_path.is_file():
+        try:
+            existing = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+        except Exception:
+            pass
+
+    # Deep merge
+    overlay = update.model_dump(exclude_none=True)
+    # Remove pydantic internal keys
+    overlay.pop("model_config", None)
+    _deep_merge(existing, overlay)
+
+    # Write back
+    config_path.write_text(
+        yaml.dump(existing, allow_unicode=True, sort_keys=False, default_flow_style=False),
+        encoding="utf-8",
+    )
+    return {"ok": True, "name": name, "config": existing}

package/extensions/services/web/routes/schemas.py

@@ -214,3 +214,25 @@ class ConfigUpdate(BaseModel):
     """Arbitrary config update payload — accepts any key/value pairs."""
 
     model_config = {"extra": "allow"}
+
+
+# ---------------------------------------------------------------------------
+# Modules
+# ---------------------------------------------------------------------------
+
+class ModuleMetadataUpdate(BaseModel):
+    """可更新的 module.md frontmatter 字段."""
+    display_name: Optional[str] = None
+    version: Optional[str] = None
+    state: Optional[str] = None          # enabled | manual | disabled
+    preferred_port: Optional[int] = None
+    advertise_ip: Optional[str] = None
+    monitor: Optional[bool] = None
+    events: Optional[list[str]] = None
+    subscriptions: Optional[list[str]] = None
+    depends_on: Optional[list[str]] = None
+
+
+class ModuleConfigUpdate(BaseModel):
+    """config.yaml 更新，接受任意 key/value."""
+    model_config = {"extra": "allow"}

package/extensions/services/web/server.py

@@ -30,6 +30,7 @@ from routes.routes_contacts import router as contacts_router
 from routes.routes_stats import router as stats_router
 from routes.routes_voicechat import router as voicechat_router
 from routes.routes_devlog import router as devlog_router
+from routes.routes_modules import router as modules_router
 
 logger = logging.getLogger(__name__)
 
@@ -46,7 +47,6 @@ class WebServer:
         self._ws_task: asyncio.Task | None = None
         self._test_task: asyncio.Task | None = None
         self._ws: object | None = None
-        self._ready_sent = False
         self._shutting_down = False
         self._uvicorn_server = None  # set by entry.py for graceful shutdown
         self._start_time = time.time()
@@ -142,6 +142,7 @@ class WebServer:
         app.include_router(stats_router, prefix="/api")
         app.include_router(voicechat_router)  # no prefix (has own /ws/ and /api/ paths)
         app.include_router(devlog_router, prefix="/api")
+        app.include_router(modules_router, prefix="/api")
 
         # Serve frontend static files
         static_dir = Path(__file__).parent / "static"
@@ -154,21 +155,34 @@ class WebServer:
 
     async def _ws_loop(self):
         """Connect to Kernel, subscribe, register, and listen. Reconnect on failure."""
-        retry_delay = 0.5  # start with 0.5s
-        max_delay = 30  # cap at 30s
+        retry_delay = 0.3
+        max_delay = 5.0
+        max_retries = 10
+        attempt = 0
         while not self._shutting_down:
             try:
                 await self._ws_connect()
-                retry_delay = 0.5  # reset on successful connection
+                retry_delay = 0.3  # reset on successful connection
+                attempt = 0
             except asyncio.CancelledError:
                 return
             except Exception as e:
-                print(f"[web] Kernel connection error: {e}, retrying in {retry_delay:.1f}s")
+                attempt += 1
+                # Auth failure — don't retry
+                if hasattr(e, 'rcvd') and e.rcvd is not None:
+                    code = e.rcvd.code if hasattr(e.rcvd, 'code') else 0
+                    if code in (4001, 4003):
+                        print(f"[web] Kernel 认证失败 (code {code})，退出")
+                        import sys; sys.exit(1)
+                if attempt >= max_retries:
+                    print(f"[web] Kernel 重连失败 {max_retries} 次，退出")
+                    import sys; sys.exit(1)
+                print(f"[web] Kernel connection error: {e}, retrying in {retry_delay:.1f}s ({attempt}/{max_retries})")
             self._ws = None
             if self._shutting_down:
                 return
             await asyncio.sleep(retry_delay)
-            retry_delay = min(retry_delay * 2, max_delay)  # exponential backoff
+            retry_delay = min(retry_delay * 2, max_delay)
 
     async def _ws_connect(self):
         """Single WebSocket session: connect, register, subscribe, receive loop."""
@@ -207,8 +221,8 @@ class WebServer:
             })
             print(f"[web] Registered to Kernel{elapsed_str}")
 
-            # Send module.ready (once) so Launcher knows we're up
-            if not self._ready_sent:
+            # Send module.ready (every reconnect, not just first time)
+            if not self._shutting_down:
                 await self._rpc_call(ws, "event.publish", {
                     "event_id": str(uuid.uuid4()),
                     "event": "module.ready",
@@ -217,7 +231,6 @@ class WebServer:
                         "graceful_shutdown": True,
                     },
                 })
-                self._ready_sent = True
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
                 print(f"[web] module.ready sent{elapsed_str}")
@@ -269,10 +282,14 @@ class WebServer:
         event_type = params.get("event", "")
         data = params.get("data", {})
 
-        # Special handling for module.shutdown targeting web
-        if event_type == "module.shutdown" and data.get("module_id") == "web":
-            await self._handle_shutdown()
-            return
+        # Special handling for module.shutdown
+        if event_type == "module.shutdown":
+            target = data.get("module_id", "")
+            reason = data.get("reason", "")
+            # Handle both targeted shutdown (module_id == "web") and broadcast shutdown (no module_id or launcher_lost)
+            if target == "web" or not target or reason == "launcher_lost":
+                await self._handle_shutdown()
+                return
 
         # Log other events
         print(f"[web] Event received: {event_type}")
@@ -321,10 +338,16 @@ class WebServer:
         }
 
     async def _handle_shutdown(self):
-        """Handle module.shutdown: ack → cleanup → ready → exit."""
+        """Handle module.shutdown: exiting → ack → cleanup → ready → exit."""
         print("[web] Received module.shutdown")
         self._shutting_down = True
 
+        # Step 0: Send module.exiting
+        await self._publish_event({
+            "event": "module.exiting",
+            "data": {"module_id": "web", "action": "none"},
+        })
+
         # Step 1: Send ack
         await self._publish_event({
             "event": "module.shutdown.ack",

package/extensions/services/web/static/css/style.css

@@ -1062,3 +1062,100 @@ html, body {
 .toggle-switch-label input:checked + .toggle-switch::after {
   transform: translateX(16px);
 }
+
+/* ===== MODULES PAGE ===== */
+.modules-grid {
+  display: grid; grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
+  gap: 16px;
+}
+.module-card {
+  background: var(--white); border-radius: var(--radius);
+  box-shadow: var(--shadow); padding: 16px; cursor: pointer;
+  border: 2px solid transparent; transition: all .15s;
+}
+.module-card:hover {
+  border-color: var(--primary); box-shadow: var(--shadow-md);
+}
+.module-card-header {
+  display: flex; align-items: center; gap: 8px; margin-bottom: 10px;
+}
+.module-card-name {
+  font-size: 16px; font-weight: 600; color: var(--gray-900);
+  margin-bottom: 2px;
+}
+.module-card-display-name {
+  font-size: 12px; color: var(--gray-500); margin-bottom: 10px;
+  min-height: 16px;
+}
+.module-card-footer {
+  display: flex; align-items: center; gap: 8px;
+  min-height: 20px;
+}
+.module-version {
+  font-size: 11px; color: var(--gray-400); font-weight: 500;
+}
+
+/* Module type badges */
+.module-type-badge {
+  display: inline-block; padding: 2px 8px; border-radius: 10px;
+  font-size: 11px; font-weight: 600; text-transform: lowercase;
+  background: var(--gray-100); color: var(--gray-500);
+}
+.module-type-badge.type-infrastructure { background: #f3e8ff; color: #7c3aed; }
+.module-type-badge.type-service { background: var(--primary-light); color: var(--primary); }
+.module-type-badge.type-channel { background: var(--success-light); color: var(--success); }
+.module-type-badge.type-agent { background: #fff7ed; color: #ea580c; }
+.module-type-badge.type-tool { background: var(--gray-100); color: var(--gray-500); }
+
+/* Module state dots */
+.module-state-dot {
+  display: inline-block; width: 10px; height: 10px; border-radius: 50%;
+  flex-shrink: 0; background: var(--gray-300);
+}
+.module-state-dot.enabled { background: var(--success); }
+.module-state-dot.manual { background: var(--warning); }
+.module-state-dot.disabled { background: var(--gray-300); }
+
+/* Config tree */
+.config-tree-group {
+  margin-bottom: 4px;
+}
+.config-tree-key {
+  font-size: 13px; font-weight: 600; color: var(--gray-700);
+  padding: 6px 8px; cursor: pointer; border-radius: 4px;
+  user-select: none; display: flex; align-items: center; gap: 4px;
+}
+.config-tree-key::before {
+  content: '\25BE'; font-size: 10px; color: var(--gray-400);
+  display: inline-block; transition: transform .15s;
+}
+.config-tree-group.collapsed .config-tree-key::before {
+  transform: rotate(-90deg);
+}
+.config-tree-key:hover { background: var(--gray-50); }
+.config-tree-nested {
+  margin-left: 12px; padding-left: 12px;
+  border-left: 2px solid var(--gray-200);
+}
+.config-tree-group.collapsed .config-tree-nested { display: none; }
+.config-tree-leaf {
+  display: flex; align-items: center; gap: 10px;
+  padding: 4px 8px; margin-bottom: 2px;
+}
+.config-tree-label {
+  font-size: 13px; color: var(--gray-600); min-width: 140px;
+  font-weight: 500; flex-shrink: 0;
+}
+.config-tree-input {
+  flex: 1; padding: 5px 10px; border: 1px solid var(--gray-300);
+  border-radius: 6px; font-size: 13px; color: var(--gray-800);
+  background: var(--white); transition: border-color .15s;
+  min-width: 0;
+}
+.config-tree-input:focus {
+  outline: none; border-color: var(--primary);
+  box-shadow: 0 0 0 3px rgba(59,130,246,.15);
+}
+.config-tree-checkbox {
+  width: 16px; height: 16px; cursor: pointer;
+}