@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/web/entry.py

@@ -1,478 +1,598 @@
-"""
-Web Management entry point.
-Reads boot_info from stdin, registers to Registry, starts web service.
-Serves the full AI Phone Agent web UI and all API endpoints.
-"""
-
-import builtins
-import json
-import os
-import re
-import signal
-import socket
-import sys
-import threading
-import time
-import traceback
-import uuid
-from datetime import datetime, timezone
-
-import asyncio
-import websockets
-import uvicorn
-
-
-# ── Safe stdout/stderr: ignore BrokenPipeError after Launcher closes stdio ──
-
-
-# ── Module configuration ──
-
-def _load_module_config() -> dict:
-    """Load module configuration from module.md frontmatter.
-
-    Returns:
-        Dict with keys: name, preferred_port, advertise_ip
-
-    Raises:
-        SystemExit: If module.md is invalid or name is non-compliant
-    """
-    _this_dir = os.path.dirname(os.path.abspath(__file__))
-    module_md = os.path.join(_this_dir, "module.md")
-
-    # Calculate relative path for error messages
-    project_root = os.environ.get("KITE_PROJECT", "")
-    if project_root and _this_dir.startswith(project_root):
-        rel_path = os.path.relpath(_this_dir, project_root)
-    else:
-        rel_path = _this_dir
-
-    # Default values (will be overridden if valid config exists)
-    result = {
-        "name": "",
-        "preferred_port": 0,
-        "advertise_ip": "0.0.0.0"
-    }
-
-    # Check if module.md exists
-    if not os.path.exists(module_md):
-        print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
-        print(f"  Path: {rel_path}/module.md")
-        print(f"  Reason: File not found")
-        sys.exit(1)
-
-    try:
-        with open(module_md, encoding="utf-8") as f:
-            text = f.read()
-
-        # Extract YAML frontmatter (between --- markers)
-        import re
-        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
-        if not m:
-            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
-            print(f"  Path: {rel_path}/module.md")
-            print(f"  Reason: Missing YAML frontmatter")
-            sys.exit(1)
-
-        # Parse YAML frontmatter
-        try:
-            import yaml
-            fm = yaml.safe_load(m.group(1)) or {}
-        except ImportError:
-            print(f"[{rel_path}] ERROR: PyYAML not installed, cannot parse module.md")
-            sys.exit(1)
-        except Exception as e:
-            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
-            print(f"  Path: {rel_path}/module.md")
-            print(f"  Reason: YAML parse error: {e}")
-            sys.exit(1)
-
-        # Validate 'name' field (required)
-        if "name" not in fm:
-            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
-            print(f"  Path: {rel_path}/module.md")
-            print(f"  Reason: Missing 'name' field")
-            sys.exit(1)
-
-        raw_name = str(fm["name"]).strip()
-
-        if not raw_name:
-            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
-            print(f"  Path: {rel_path}/module.md")
-            print(f"  Reason: Empty module name")
-            sys.exit(1)
-
-        # Validate name characters
-        sanitized = re.sub(r'[^a-zA-Z0-9_\-]', '', raw_name)
-
-        if sanitized != raw_name:
-            invalid_chars = ''.join(sorted(set(c for c in raw_name if c not in sanitized)))
-            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
-            print(f"  Path: {rel_path}/module.md")
-            print(f"  Reason: Invalid characters in name '{raw_name}': {repr(invalid_chars)}")
-            sys.exit(1)
-
-        result["name"] = sanitized
-
-        # Extract optional fields
-        if "preferred_port" in fm:
-            try:
-                result["preferred_port"] = int(fm["preferred_port"])
-            except (ValueError, TypeError):
-                pass
-
-        if "advertise_ip" in fm:
-            result["advertise_ip"] = str(fm["advertise_ip"])
-
-    except SystemExit:
-        raise  # Re-raise exit to prevent catching by outer except
-    except Exception as e:
-        print(f"[{rel_path}] ERROR: Failed to read module.md: {e}")
-        sys.exit(1)
-
-    return result
-
-_module_config = _load_module_config()
-MODULE_NAME = _module_config["name"]
-
-
-class _SafeWriter:
-    """Wraps a stream to silently swallow BrokenPipeError on write/flush."""
-    def __init__(self, stream):
-        self._stream = stream
-
-    def write(self, s):
-        try:
-            self._stream.write(s)
-        except (BrokenPipeError, OSError):
-            pass
-
-    def flush(self):
-        try:
-            self._stream.flush()
-        except (BrokenPipeError, OSError):
-            pass
-
-    def __getattr__(self, name):
-        return getattr(self._stream, name)
-
-sys.stdout = _SafeWriter(sys.stdout)
-sys.stderr = _SafeWriter(sys.stderr)
-
-
-# ── Timestamped print + log file writer ──
-# Independent implementation per module (no shared code dependency)
-
-_builtin_print = builtins.print
-_start_ts = time.monotonic()
-_last_ts = time.monotonic()
-_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
-_log_lock = threading.Lock()
-_log_latest_path = None
-_log_daily_path = None
-_log_daily_date = ""
-_log_dir = None
-_crash_log_path = None
-
-def _strip_ansi(s: str) -> str:
-    return _ANSI_RE.sub("", s)
-
-def _resolve_daily_log_path():
-    """Resolve daily log path based on current date."""
-    global _log_daily_path, _log_daily_date
-    if not _log_dir:
-        return
-    today = datetime.now().strftime("%Y-%m-%d")
-    if today == _log_daily_date and _log_daily_path:
-        return
-    month_dir = os.path.join(_log_dir, today[:7])
-    os.makedirs(month_dir, exist_ok=True)
-    _log_daily_path = os.path.join(month_dir, f"{today}.log")
-    _log_daily_date = today
-
-def _write_log(plain_line: str):
-    """Write a plain-text line to both latest.log and daily log."""
-    with _log_lock:
-        if _log_latest_path:
-            try:
-                with open(_log_latest_path, "a", encoding="utf-8") as f:
-                    f.write(plain_line)
-            except Exception:
-                pass
-        _resolve_daily_log_path()
-        if _log_daily_path:
-            try:
-                with open(_log_daily_path, "a", encoding="utf-8") as f:
-                    f.write(plain_line)
-            except Exception:
-                pass
-
-def _write_crash(exc_type, exc_value, exc_tb, thread_name=None, severity="critical", handled=False):
-    """Write crash record to crashes.jsonl + daily crash archive."""
-    record = {
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "module": MODULE_NAME,
-        "thread": thread_name or threading.current_thread().name,
-        "exception_type": exc_type.__name__ if exc_type else "Unknown",
-        "exception_message": str(exc_value),
-        "traceback": "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
-        "severity": severity,
-        "handled": handled,
-        "process_id": os.getpid(),
-        "platform": sys.platform,
-        "runtime_version": f"Python {sys.version.split()[0]}",
-    }
-
-    if exc_tb:
-        tb_entries = traceback.extract_tb(exc_tb)
-        if tb_entries:
-            last = tb_entries[-1]
-            record["context"] = {
-                "function": last.name,
-                "file": os.path.basename(last.filename),
-                "line": last.lineno,
-            }
-
-    line = json.dumps(record, ensure_ascii=False) + "\n"
-
-    if _crash_log_path:
-        try:
-            with open(_crash_log_path, "a", encoding="utf-8") as f:
-                f.write(line)
-        except Exception:
-            pass
-
-    if _log_dir:
-        try:
-            today = datetime.now().strftime("%Y-%m-%d")
-            archive_dir = os.path.join(_log_dir, "crashes", today[:7])
-            os.makedirs(archive_dir, exist_ok=True)
-            archive_path = os.path.join(archive_dir, f"{today}.jsonl")
-            with open(archive_path, "a", encoding="utf-8") as f:
-                f.write(line)
-        except Exception:
-            pass
-
-def _print_crash_summary(exc_type, exc_tb, thread_name=None):
-    """Print crash summary to console (red highlight)."""
-    RED = "\033[91m"
-    RESET = "\033[0m"
-
-    if exc_tb:
-        tb_entries = traceback.extract_tb(exc_tb)
-        if tb_entries:
-            last = tb_entries[-1]
-            location = f"{os.path.basename(last.filename)}:{last.lineno}"
-        else:
-            location = "unknown"
-    else:
-        location = "unknown"
-
-    prefix = f"[{MODULE_NAME}]"
-    if thread_name:
-        _builtin_print(f"{prefix} {RED}线程 {thread_name} 崩溃: "
-                       f"{exc_type.__name__} in {location}{RESET}")
-    else:
-        _builtin_print(f"{prefix} {RED}崩溃: {exc_type.__name__} in {location}{RESET}")
-    if _crash_log_path:
-        _builtin_print(f"{prefix} 崩溃日志: {_crash_log_path}")
-
-def _setup_exception_hooks():
-    """Set up global exception hooks."""
-    _orig_excepthook = sys.excepthook
-
-    def _excepthook(exc_type, exc_value, exc_tb):
-        _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=False)
-        _print_crash_summary(exc_type, exc_tb)
-        _orig_excepthook(exc_type, exc_value, exc_tb)
-
-    sys.excepthook = _excepthook
-
-    if hasattr(threading, "excepthook"):
-        def _thread_excepthook(args):
-            _write_crash(args.exc_type, args.exc_value, args.exc_traceback,
-                        thread_name=args.thread.name if args.thread else "unknown",
-                        severity="error", handled=False)
-            _print_crash_summary(args.exc_type, args.exc_traceback,
-                                thread_name=args.thread.name if args.thread else None)
-
-        threading.excepthook = _thread_excepthook
-
-def _tprint(*args, **kwargs):
-    """Timestamped print that adds [timestamp] HH:MM:SS.mmm +delta prefix."""
-    global _last_ts
-    now = time.monotonic()
-    elapsed = now - _start_ts
-    delta = now - _last_ts
-    _last_ts = now
-
-    if elapsed < 1:
-        elapsed_str = f"{elapsed * 1000:.0f}ms"
-    elif elapsed < 100:
-        elapsed_str = f"{elapsed:.1f}s"
-    else:
-        elapsed_str = f"{elapsed:.0f}s"
-
-    if delta < 0.001:
-        delta_str = ""
-    elif delta < 1:
-        delta_str = f"+{delta * 1000:.0f}ms"
-    elif delta < 100:
-        delta_str = f"+{delta:.1f}s"
-    else:
-        delta_str = f"+{delta:.0f}s"
-
-    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
-
-    _builtin_print(*args, **kwargs)
-
-    if _log_latest_path or _log_daily_path:
-        sep = kwargs.get("sep", " ")
-        end = kwargs.get("end", "\n")
-        text = sep.join(str(a) for a in args)
-        prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
-        _write_log(prefix + _strip_ansi(text) + end)
-
-builtins.print = _tprint
-
-# Ensure project root (Kite/) is on sys.path
-_this_dir = os.path.dirname(os.path.abspath(__file__))
-_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(os.path.dirname(_this_dir)))
-if _project_root not in sys.path:
-    sys.path.insert(0, _project_root)
-
-# Also add ai-phone-agent root so we can import config, storage, conversation, etc.
-_agent_root = os.path.dirname(_project_root)
-if _agent_root not in sys.path:
-    sys.path.insert(0, _agent_root)
-
-from extensions.services.web.server import WebServer
-
-
-def _fmt_elapsed(t0: float) -> str:
-    d = time.monotonic() - t0
-    if d < 1:
-        return f"{d * 1000:.0f}ms"
-    if d < 10:
-        return f"{d:.1f}s"
-    return f"{d:.0f}s"
-
-
-def _bind_port(preferred: int, host: str, max_attempts: int = 10) -> int | None:
-    """
-    Try to bind to preferred port, then port+1, port+2, ... up to max_attempts.
-    Returns bound port on success, None on failure.
-    """
-    if not preferred:
-        # No preferred port, use OS-assigned
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind((host, 0))
-            return s.getsockname()[1]
-
-    for attempt in range(max_attempts):
-        port = preferred + attempt
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind((host, port))
-                if attempt > 0:
-                    print(f"[web] Bound to port {port} (preferred {preferred} was occupied)")
-                return port
-        except OSError:
-            if attempt < max_attempts - 1:
-                continue
-            else:
-                print(f"[web] ERROR: Failed to bind port after {max_attempts} attempts ({preferred}-{port})")
-                return None
-
-    return None
-
-
-
-
-def main():
-    # Initialize log file paths
-    global _log_dir, _log_latest_path, _crash_log_path
-    module_data = os.environ.get("KITE_MODULE_DATA")
-    if module_data:
-        _log_dir = os.path.join(module_data, "log")
-        os.makedirs(_log_dir, exist_ok=True)
-        suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
-
-        _log_latest_path = os.path.join(_log_dir, f"latest{suffix}.log")
-        try:
-            with open(_log_latest_path, "w", encoding="utf-8") as f:
-                pass
-        except Exception:
-            _log_latest_path = None
-
-        _crash_log_path = os.path.join(_log_dir, f"crashes{suffix}.jsonl")
-        try:
-            with open(_crash_log_path, "w", encoding="utf-8") as f:
-                pass
-        except Exception:
-            _crash_log_path = None
-
-        _resolve_daily_log_path()
-
-    _setup_exception_hooks()
-
-    _t0 = time.monotonic()
-
-    # Read boot_info from stdin (only token)
-    token = ""
-    try:
-        line = sys.stdin.readline().strip()
-        if line:
-            boot_info = json.loads(line)
-            token = boot_info.get("token", "")
-    except Exception:
-        pass
-
-    # Read kernel_port from environment variable
-    kernel_port = int(os.environ.get("KITE_KERNEL_PORT", "0"))
-
-    if not token or not kernel_port:
-        print("[web] ERROR: Missing token or KITE_KERNEL_PORT")
-        sys.exit(1)
-
-    print(f"[web] Token received ({len(token)} chars), kernel port: {kernel_port} ({_fmt_elapsed(_t0)})")
-
-    # Use cached module config (already loaded at module level)
-    host = _module_config["advertise_ip"]
-    port = _bind_port(_module_config["preferred_port"], host)
-
-    # If port binding failed after 10 attempts, exit gracefully
-    if port is None:
-        print("[web] ERROR: Cannot bind to any port, exiting")
-        sys.exit(1)
-
-    server = WebServer(
-        token=token,
-        kernel_port=kernel_port,
-        host=host,
-        port=port,
-        boot_t0=_t0,
-    )
-
-    # Display access URL in green
-    display_host = "localhost" if host == "0.0.0.0" else host
-    url = f"http://{display_host}:{port}"
-    print(f"[web] Starting on {host}:{port} ({_fmt_elapsed(_t0)})")
-    print(f"[web] \033[32m✓ Web UI ready: {url}\033[0m")
-
-    try:
-        config = uvicorn.Config(server.app, host=host, port=port, log_level="warning")
-        uvi_server = uvicorn.Server(config)
-        server._uvicorn_server = uvi_server
-        uvi_server.run()
-    except Exception as e:
-        _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
-        _print_crash_summary(type(e), e.__traceback__)
-        sys.exit(1)
-
-    # Check if server requested exit with non-zero code
-    if server._exit_code != 0:
-        sys.exit(server._exit_code)
-
-
-if __name__ == "__main__":
-    main()
+"""
+Web Management entry point.
+Reads boot_info from stdin, registers to Registry, starts web service.
+Serves the full AI Phone Agent web UI and all API endpoints.
+"""
+
+import builtins
+import json
+import os
+import re
+import signal
+import socket
+import sys
+import threading
+import time
+import traceback
+import uuid
+from datetime import datetime, timezone
+
+import asyncio
+import websockets
+import uvicorn
+
+
+# ── Safe stdout/stderr: ignore BrokenPipeError after Launcher closes stdio ──
+
+
+# ── Module configuration ──
+
+def _load_module_config() -> dict:
+    """Load module configuration from module.md frontmatter.
+
+    Returns:
+        Dict with keys: name, preferred_port, advertise_ip
+
+    Raises:
+        SystemExit: If module.md is invalid or name is non-compliant
+    """
+    _this_dir = os.path.dirname(os.path.abspath(__file__))
+    module_md = os.path.join(_this_dir, "module.md")
+
+    # Calculate relative path for error messages
+    project_root = os.environ.get("KITE_PROJECT", "")
+    if project_root and _this_dir.startswith(project_root):
+        rel_path = os.path.relpath(_this_dir, project_root)
+    else:
+        rel_path = _this_dir
+
+    # Default values (will be overridden if valid config exists)
+    result = {
+        "name": "",
+        "preferred_port": 0,
+        "advertise_ip": "0.0.0.0"
+    }
+
+    # Check if module.md exists
+    if not os.path.exists(module_md):
+        print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+        print(f"  Path: {rel_path}/module.md")
+        print(f"  Reason: File not found")
+        sys.exit(1)
+
+    try:
+        with open(module_md, encoding="utf-8") as f:
+            text = f.read()
+
+        # Extract YAML frontmatter (between --- markers)
+        import re
+        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+        if not m:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Missing YAML frontmatter")
+            sys.exit(1)
+
+        # Parse YAML frontmatter
+        try:
+            import yaml
+            fm = yaml.safe_load(m.group(1)) or {}
+        except ImportError:
+            print(f"[{rel_path}] ERROR: PyYAML not installed, cannot parse module.md")
+            sys.exit(1)
+        except Exception as e:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: YAML parse error: {e}")
+            sys.exit(1)
+
+        # Validate 'name' field (required)
+        if "name" not in fm:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Missing 'name' field")
+            sys.exit(1)
+
+        raw_name = str(fm["name"]).strip()
+
+        if not raw_name:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Empty module name")
+            sys.exit(1)
+
+        # Validate name characters
+        sanitized = re.sub(r'[^a-zA-Z0-9_\-]', '', raw_name)
+
+        if sanitized != raw_name:
+            invalid_chars = ''.join(sorted(set(c for c in raw_name if c not in sanitized)))
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Invalid characters in name '{raw_name}': {repr(invalid_chars)}")
+            sys.exit(1)
+
+        result["name"] = sanitized
+
+        # Extract optional fields
+        if "preferred_port" in fm:
+            try:
+                result["preferred_port"] = int(fm["preferred_port"])
+            except (ValueError, TypeError):
+                pass
+
+        if "advertise_ip" in fm:
+            result["advertise_ip"] = str(fm["advertise_ip"])
+
+        # max_connections（弹性连接上限）
+        try:
+            result["max_connections"] = max(1, min(10, int(fm.get("max_connections", 1))))
+        except (ValueError, TypeError):
+            result["max_connections"] = 1
+        # business_config（从 businesses 数组取第一个 config_file）
+        businesses = fm.get("businesses")
+        if isinstance(businesses, list) and businesses:
+            cfg_file = businesses[0].get("config_file") if isinstance(businesses[0], dict) else None
+            if cfg_file:
+                result["business_config"] = str(cfg_file).strip()
+
+    except SystemExit:
+        raise  # Re-raise exit to prevent catching by outer except
+    except Exception as e:
+        print(f"[{rel_path}] ERROR: Failed to read module.md: {e}")
+        sys.exit(1)
+
+    return result
+
+_module_config = _load_module_config()
+MODULE_NAME = _module_config["name"]
+
+
+class _SafeWriter:
+    """Wraps a stream to silently swallow BrokenPipeError on write/flush."""
+    def __init__(self, stream):
+        self._stream = stream
+
+    def write(self, s):
+        try:
+            self._stream.write(s)
+        except (BrokenPipeError, OSError):
+            pass
+
+    def flush(self):
+        try:
+            self._stream.flush()
+        except (BrokenPipeError, OSError):
+            pass
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+sys.stdout = _SafeWriter(sys.stdout)
+sys.stderr = _SafeWriter(sys.stderr)
+
+
+# ── Timestamped print + log file writer ──
+# Independent implementation per module (no shared code dependency)
+
+_builtin_print = builtins.print
+_start_ts = time.monotonic()
+_last_ts = time.monotonic()
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+_log_lock = threading.Lock()
+_log_latest_path = None
+_log_daily_path = None
+_log_daily_date = ""
+_log_dir = None
+_crash_log_path = None
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+def _resolve_daily_log_path():
+    """Resolve daily log path based on current date."""
+    global _log_daily_path, _log_daily_date
+    if not _log_dir:
+        return
+    today = datetime.now().strftime("%Y-%m-%d")
+    if today == _log_daily_date and _log_daily_path:
+        return
+    month_dir = os.path.join(_log_dir, today[:7])
+    os.makedirs(month_dir, exist_ok=True)
+    _log_daily_path = os.path.join(month_dir, f"{today}.log")
+    _log_daily_date = today
+
+def _write_log(plain_line: str):
+    """Write a plain-text line to both latest.log and daily log."""
+    with _log_lock:
+        if _log_latest_path:
+            try:
+                with open(_log_latest_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+        _resolve_daily_log_path()
+        if _log_daily_path:
+            try:
+                with open(_log_daily_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+
+def _write_crash(exc_type, exc_value, exc_tb, thread_name=None, severity="critical", handled=False):
+    """Write crash record to crashes.jsonl + daily crash archive."""
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "module": MODULE_NAME,
+        "thread": thread_name or threading.current_thread().name,
+        "exception_type": exc_type.__name__ if exc_type else "Unknown",
+        "exception_message": str(exc_value),
+        "traceback": "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
+        "severity": severity,
+        "handled": handled,
+        "process_id": os.getpid(),
+        "platform": sys.platform,
+        "runtime_version": f"Python {sys.version.split()[0]}",
+    }
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            record["context"] = {
+                "function": last.name,
+                "file": os.path.basename(last.filename),
+                "line": last.lineno,
+            }
+
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+
+    if _crash_log_path:
+        try:
+            with open(_crash_log_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+    if _log_dir:
+        try:
+            today = datetime.now().strftime("%Y-%m-%d")
+            archive_dir = os.path.join(_log_dir, "crashes", today[:7])
+            os.makedirs(archive_dir, exist_ok=True)
+            archive_path = os.path.join(archive_dir, f"{today}.jsonl")
+            with open(archive_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+def _print_crash_summary(exc_type, exc_tb, thread_name=None):
+    """Print crash summary to console (red highlight)."""
+    RED = "\033[91m"
+    RESET = "\033[0m"
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            location = f"{os.path.basename(last.filename)}:{last.lineno}"
+        else:
+            location = "unknown"
+    else:
+        location = "unknown"
+
+    prefix = f"[{MODULE_NAME}]"
+    if thread_name:
+        _builtin_print(f"{prefix} {RED}线程 {thread_name} 崩溃: "
+                       f"{exc_type.__name__} in {location}{RESET}")
+    else:
+        _builtin_print(f"{prefix} {RED}崩溃: {exc_type.__name__} in {location}{RESET}")
+    if _crash_log_path:
+        _builtin_print(f"{prefix} 崩溃日志: {_crash_log_path}")
+
+def _setup_exception_hooks():
+    """Set up global exception hooks."""
+    _orig_excepthook = sys.excepthook
+
+    def _excepthook(exc_type, exc_value, exc_tb):
+        _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=False)
+        _print_crash_summary(exc_type, exc_tb)
+        _orig_excepthook(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _excepthook
+
+    if hasattr(threading, "excepthook"):
+        def _thread_excepthook(args):
+            _write_crash(args.exc_type, args.exc_value, args.exc_traceback,
+                        thread_name=args.thread.name if args.thread else "unknown",
+                        severity="error", handled=False)
+            _print_crash_summary(args.exc_type, args.exc_traceback,
+                                thread_name=args.thread.name if args.thread else None)
+
+        threading.excepthook = _thread_excepthook
+
+def _tprint(*args, **kwargs):
+    """Timestamped print that adds [timestamp] HH:MM:SS.mmm +delta prefix."""
+    global _last_ts
+    now = time.monotonic()
+    elapsed = now - _start_ts
+    delta = now - _last_ts
+    _last_ts = now
+
+    if elapsed < 1:
+        elapsed_str = f"{elapsed * 1000:.0f}ms"
+    elif elapsed < 100:
+        elapsed_str = f"{elapsed:.1f}s"
+    else:
+        elapsed_str = f"{elapsed:.0f}s"
+
+    if delta < 0.001:
+        delta_str = ""
+    elif delta < 1:
+        delta_str = f"+{delta * 1000:.0f}ms"
+    elif delta < 100:
+        delta_str = f"+{delta:.1f}s"
+    else:
+        delta_str = f"+{delta:.0f}s"
+
+    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+    _builtin_print(*args, **kwargs)
+
+    if _log_latest_path or _log_daily_path:
+        sep = kwargs.get("sep", " ")
+        end = kwargs.get("end", "\n")
+        text = sep.join(str(a) for a in args)
+        prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
+        _write_log(prefix + _strip_ansi(text) + end)
+
+builtins.print = _tprint
+
+# Ensure project root (Kite/) is on sys.path
+_this_dir = os.path.dirname(os.path.abspath(__file__))
+_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(os.path.dirname(_this_dir)))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+# Also add ai-phone-agent root so we can import config, storage, conversation, etc.
+_agent_root = os.path.dirname(_project_root)
+if _agent_root not in sys.path:
+    sys.path.insert(0, _agent_root)
+
+from extensions.services.web.server import WebServer
+
+
+def _fmt_elapsed(t0: float) -> str:
+    d = time.monotonic() - t0
+    if d < 1:
+        return f"{d * 1000:.0f}ms"
+    if d < 10:
+        return f"{d:.1f}s"
+    return f"{d:.0f}s"
+
+
+def _bind_port(preferred: int, host: str, max_attempts: int = 3) -> int | None:
+    """
+    Try to bind to preferred port, then port+1, port+2, ... up to max_attempts.
+    Returns bound port on success, None on failure.
+    """
+    if not preferred:
+        # No preferred port, use OS-assigned
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            s.bind((host, 0))
+            return s.getsockname()[1]
+
+    for attempt in range(max_attempts):
+        port = preferred + attempt
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind((host, port))
+                if attempt > 0:
+                    print(f"[web] Bound to port {port} (preferred {preferred} was occupied)")
+                return port
+        except OSError as e:
+            if attempt < max_attempts - 1:
+                print(f"[web] Port {port} occupied, trying next port...")
+                continue
+            else:
+                print(f"[web] ERROR: Failed to bind port after {max_attempts} attempts ({preferred}-{preferred + max_attempts - 1})")
+                return None
+
+    return None
+
+
+
+
+def _run_local_mode(kernel_port: int):
+    # Initialize log file paths
+    global _log_dir, _log_latest_path, _crash_log_path
+    module_data = os.environ.get("KITE_MODULE_DATA")
+    if module_data:
+        _log_dir = os.path.join(module_data, "log")
+        os.makedirs(_log_dir, exist_ok=True)
+        suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
+
+        _log_latest_path = os.path.join(_log_dir, f"latest{suffix}.log")
+        try:
+            with open(_log_latest_path, "w", encoding="utf-8") as f:
+                pass
+        except Exception:
+            _log_latest_path = None
+
+        _crash_log_path = os.path.join(_log_dir, f"crashes{suffix}.jsonl")
+        try:
+            with open(_crash_log_path, "w", encoding="utf-8") as f:
+                pass
+        except Exception:
+            _crash_log_path = None
+
+        _resolve_daily_log_path()
+
+    _setup_exception_hooks()
+
+    _t0 = time.monotonic()
+
+    print(f"[web] Kernel port: {kernel_port} ({_fmt_elapsed(_t0)})")
+
+    # Use cached module config (already loaded at module level)
+    host = _module_config["advertise_ip"]
+    port = _bind_port(_module_config["preferred_port"], host)
+
+    # If port binding failed after 10 attempts, exit gracefully
+    if port is None:
+        print("[web] ERROR: Cannot bind to any port, exiting")
+        sys.exit(1)
+
+    # Read token from stdin before creating server
+    line = sys.stdin.readline().strip()
+    if not line:
+        print("[web] ERROR: stdin closed")
+        sys.exit(1)
+
+    try:
+        msg = json.loads(line)
+    except json.JSONDecodeError as e:
+        print(f"[web] ERROR: Invalid JSON from stdin: {e}")
+        sys.exit(1)
+
+    if "error" in msg:
+        print(f"[web] 启动失败: {msg.get('message', 'unknown')}")
+        sys.exit(1)
+
+    token = msg.get("token", "")
+    if not token:
+        print("[web] ERROR: No token in stdin message")
+        sys.exit(1)
+
+    # Create server with token
+    server = WebServer(
+        token=token,
+        kernel_port=kernel_port,
+        host=host,
+        port=port,
+        boot_t0=_t0,
+        max_connections=_module_config.get("max_connections", 1),
+    )
+
+    # Display access URL in green
+    display_host = "localhost" if host == "0.0.0.0" else host
+    url = f"http://{display_host}:{port}"
+    print(f"[web] Starting on {host}:{port} ({_fmt_elapsed(_t0)})")
+    print(f"[web] \033[32m✓ Web UI ready: {url}\033[0m")
+
+    try:
+        config = uvicorn.Config(server.app, host=host, port=port, log_level="warning")
+        uvi_server = uvicorn.Server(config)
+        server._uvicorn_server = uvi_server
+        uvi_server.run()
+    except Exception as e:
+        _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
+        _print_crash_summary(type(e), e.__traceback__)
+        sys.exit(1)
+
+    # Check if server requested exit with non-zero code
+    if server._exit_code != 0:
+        sys.exit(server._exit_code)
+
+
+def _run_remote_mode(gateway_url: str):
+    global _log_dir, _log_latest_path, _crash_log_path
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    data_dir = os.path.join(home, ".kite", "remote", MODULE_NAME)
+    os.makedirs(data_dir, exist_ok=True)
+    _log_dir = os.path.join(data_dir, "log")
+    os.makedirs(_log_dir, exist_ok=True)
+    _log_latest_path = os.path.join(_log_dir, "latest.log")
+    try:
+        with open(_log_latest_path, "w", encoding="utf-8") as f: pass
+    except Exception: _log_latest_path = None
+    _crash_log_path = os.path.join(_log_dir, "crashes.jsonl")
+    try:
+        with open(_crash_log_path, "w", encoding="utf-8") as f: pass
+    except Exception: _crash_log_path = None
+    _resolve_daily_log_path()
+    _setup_exception_hooks()
+
+    _t0 = time.monotonic()
+    kite_token = _get_kite_token(MODULE_NAME, gateway_url)
+    print(f"[{MODULE_NAME}] Remote mode: gateway={gateway_url}")
+
+    host = _module_config["advertise_ip"]
+    port = _bind_port(_module_config["preferred_port"], host)
+    if port is None:
+        print(f"[{MODULE_NAME}] ERROR: Cannot bind to any port")
+        sys.exit(1)
+
+    server = WebServer(
+        token="",
+        kernel_port=0,
+        host=host,
+        port=port,
+        boot_t0=_t0,
+        max_connections=_module_config.get("max_connections", 1),
+        gateway_url=gateway_url,
+        kite_token=kite_token,
+    )
+
+    try:
+        config = uvicorn.Config(server.app, host=host, port=port, log_level="warning")
+        uvi_server = uvicorn.Server(config)
+        server._uvicorn_server = uvi_server
+        uvi_server.run()
+    except Exception as e:
+        _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
+        _print_crash_summary(type(e), e.__traceback__)
+        sys.exit(1)
+    if hasattr(server, '_auth_failed') and server._auth_failed:
+        _clear_token_cache(MODULE_NAME, gateway_url)
+    if server._exit_code != 0:
+        sys.exit(server._exit_code)
+
+
+# ── Token management ──
+
+def _gateway_to_filename(gateway_url: str) -> str:
+    try:
+        from urllib.parse import urlparse
+        parsed = urlparse(gateway_url)
+        host = parsed.hostname or "unknown"
+        port = parsed.port or (443 if parsed.scheme == "wss" else 80)
+        return f"{host}-{port}.json".replace(":", "-").replace("/", "-")
+    except Exception: return "default.json"
+
+def _load_token_cache(module_name: str, gateway_url: str) -> dict | None:
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    token_file = os.path.join(home, ".kite", "remote", module_name, "tokens", _gateway_to_filename(gateway_url))
+    if not os.path.exists(token_file): return None
+    try:
+        with open(token_file, "r") as f: return json.load(f)
+    except Exception: return None
+
+def _clear_token_cache(module_name: str, gateway_url: str):
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    token_file = os.path.join(home, ".kite", "remote", module_name, "tokens", _gateway_to_filename(gateway_url))
+    try: os.remove(token_file)
+    except Exception: pass
+
+def _get_kite_token(module_name: str, gateway_url: str) -> str:
+    token = os.environ.get("KITE_TOKEN")
+    if token: return token
+    cache = _load_token_cache(module_name, gateway_url)
+    if cache: return cache["token"]
+    print(f"[{module_name}] No token for {gateway_url}")
+    print(f"  export KITE_TOKEN=<token>")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    kernel_port = os.environ.get("KITE_KERNEL_PORT")
+    if kernel_port:
+        _run_local_mode(int(kernel_port))
+    else:
+        config = _load_module_config()
+        gateway_url = config.get("gateway_url") or os.environ.get("KITE_GATEWAY_URL")
+        if gateway_url:
+            _run_remote_mode(gateway_url)
+        else:
+            print(f"[{MODULE_NAME}] ERROR: No KITE_KERNEL_PORT and no gateway_url")
+            sys.exit(1)