@agentunion/kite 1.2.0 → 1.3.1

package/launcher/logging_setup.py

@@ -0,0 +1,289 @@
+"""
+Launcher logging setup: timestamped print, log files, crash logging, exception hooks.
+"""
+import builtins
+import json
+import os
+import re
+import sys
+import threading
+import time
+import traceback
+from datetime import datetime, timezone
+
+# ── Timestamped print with delta + color ──
+_builtin_print = builtins.print
+_start_ts = time.monotonic()
+_last_ts = time.monotonic()
+_first_line = True
+_module_last_ts: dict[str, float] = {}
+
+_MODULE_PREFIX_RE = re.compile(r"^\[([a-z_]+)\]")
+
+# ANSI escape codes
+_DIM    = "\033[90m"
+_GREEN  = "\033[32m"
+_RED    = "\033[91m"
+_ORANGE = "\033[38;5;208m"
+_RESET  = "\033[0m"
+
+# Log file paths
+_log_lock = threading.Lock()
+_log_latest_path = None
+_log_daily_path = None
+_log_daily_date = ""
+_log_dir = None
+_crash_log_path = None
+
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+
+def init_log_files():
+    """Initialize log file paths. Called after KITE_MODULE_DATA is set."""
+    global _log_latest_path, _log_dir, _crash_log_path
+    module_data = os.environ.get("KITE_MODULE_DATA")
+    if not module_data:
+        return
+    _log_dir = os.path.join(module_data, "log")
+    os.makedirs(_log_dir, exist_ok=True)
+
+    suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
+
+    # latest.log — truncate on each startup
+    _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 as e:
+        _builtin_print(f"[launcher] 警告: 无法初始化 {os.path.basename(_log_latest_path)}: {e}")
+        _log_latest_path = None
+
+    # crashes.jsonl — truncate on each startup
+    _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
+
+    # daily log — ensure directory exists
+    _resolve_daily_log_path()
+
+
+def _resolve_daily_log_path():
+    """Resolve the daily log file 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 archive."""
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "module": "launcher",
+        "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"
+
+    # Write to crashes.jsonl (current run)
+    if _crash_log_path:
+        try:
+            with open(_crash_log_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+    # Write to daily archive
+    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."""
+    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 = "[launcher]"
+    if thread_name:
+        print(f"{prefix} {_RED}线程 {thread_name} 崩溃: "
+              f"{exc_type.__name__} in {location}{_RESET}")
+    else:
+        print(f"{prefix} {_RED}崩溃: {exc_type.__name__} in {location}{_RESET}")
+    if _crash_log_path:
+        print(f"{prefix} 崩溃日志: {_crash_log_path}")
+
+
+def setup_exception_hooks():
+    """Set up global exception hooks for launcher process."""
+    _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 with delta tracking."""
+    global _last_ts, _first_line
+    now = time.monotonic()
+    elapsed = now - _start_ts
+
+    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+    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"
+
+    text_for_module = " ".join(str(a) for a in args) if args else ""
+    plain_text = _ANSI_RE.sub("", text_for_module).strip()
+    m = _MODULE_PREFIX_RE.match(plain_text)
+    module_name = m.group(1) if m else None
+
+    if module_name:
+        if module_name in _module_last_ts:
+            delta = now - _module_last_ts[module_name]
+        else:
+            delta = None
+        _module_last_ts[module_name] = now
+    else:
+        delta = now - _last_ts
+    _last_ts = now
+
+    if delta is None:
+        delta_str = ""
+        delta_color = _DIM
+    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"
+
+    if delta is not None:
+        if delta >= 5:
+            delta_color = _RED
+        elif delta >= 1:
+            delta_color = _GREEN
+        else:
+            delta_color = _DIM
+
+    if _first_line:
+        _first_line = False
+        prefix = f"{_ORANGE}[{elapsed_str:>6}] {ts} {delta_str:>8} "
+        _builtin_print(prefix, end="")
+        _builtin_print(*args, end="", **{k: v for k, v in kwargs.items() if k != "end"})
+        _builtin_print(_RESET, end=kwargs.get("end", "\n"))
+    else:
+        prefix = f"[{elapsed_str:>6}] {ts} {delta_color}{delta_str:>8}{_RESET} "
+        _builtin_print(prefix, end="")
+        _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)
+        plain_prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
+        _write_log(plain_prefix + _strip_ansi(text) + end)
+
+
+def setup_timestamped_print():
+    """Replace builtins.print with timestamped version."""
+    builtins.print = _tprint
+
+
+def reset_time_baseline():
+    """Reset time baseline (used after code stats to exclude that time)."""
+    global _start_ts, _last_ts
+    _start_ts = time.monotonic()
+    _last_ts = time.monotonic()
+
+
+def get_crash_log_path():
+    """Get the crash log path for error reporting."""
+    return _crash_log_path
+
+
+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)

package/{core/launcher → launcher}/module_scanner.py

@@ -35,9 +35,11 @@ class ModuleInfo:
     launch: LaunchConfig = field(default_factory=LaunchConfig)
 
     def is_core(self) -> bool:
-        """Core modules live directly under {KITE_PROJECT}/core/."""
-        core_dir = os.path.join(os.environ["KITE_PROJECT"], "core")
-        return os.path.normcase(self.module_dir).startswith(os.path.normcase(core_dir + os.sep))
+        """Core modules (launcher, kernel) live directly under {KITE_PROJECT}/."""
+        project_root = os.environ["KITE_PROJECT"]
+        # Check if module_dir is launcher or kernel at project root
+        return self.name in ("launcher", "kernel") and \
+               os.path.normcase(self.module_dir) == os.path.normcase(os.path.join(project_root, self.name))
 
 
 def _parse_frontmatter(text: str) -> dict:
@@ -92,15 +94,18 @@ class ModuleScanner:
     def __init__(self, discovery: dict = None, launcher_dir: str = ""):
         self.discovery = discovery
         project_root = os.environ["KITE_PROJECT"]
-        self.launcher_dir = launcher_dir or os.path.join(project_root, "core", "launcher")
+        self.launcher_dir = launcher_dir or os.path.join(project_root, "launcher")
 
     def scan(self) -> dict[str, ModuleInfo]:
         """Return dict of {module_name: ModuleInfo}. Duplicate names are skipped."""
         modules = {}
         project_root = os.environ["KITE_PROJECT"]
 
-        # Built-in: always scan core/ (depth 1) and extensions/ (depth 2)
-        self._scan_dir(os.path.join(project_root, "core"), 1, modules)
+        # Built-in: scan kernel (depth 0) and extensions/ (depth 2)
+        # Note: launcher is not scanned (it's the scanner itself)
+        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)
 
         # Extra sources from discovery config

package/main.py

@@ -1,357 +1,18 @@
 """
 Kite development entry point.
-Loads .env, sets KITE_* defaults, parses --debug, starts Launcher.
+1. Run code stats
+2. Start launcher
 """
-import builtins
-import json
-import os
-import re
-import secrets
 import sys
-import threading
-import time
-import traceback
-from datetime import datetime, timezone
+from pathlib import Path
 
-# ── Timestamped print with delta + color ──
-# Covers the entire Launcher process. Child processes (registry, event_hub) are
-# separate PIDs — unaffected. Their stdout is relayed via ProcessManager._read_stdout
-# → print(), so timestamps & deltas are added at the relay point automatically.
+# Add project root to sys.path
+sys.path.insert(0, str(Path(__file__).parent))
 
-_builtin_print = builtins.print
-_start_ts = time.monotonic()
-_last_ts = time.monotonic()
-_first_line = True
-_module_last_ts: dict[str, float] = {}  # module_name -> last print timestamp
+# 1. Run code stats
+from launcher.count_lines import run_stats
+run_stats()
 
-# Regex to extract [module_name] prefix from print text
-_MODULE_PREFIX_RE = re.compile(r"^\[([a-z_]+)\]")
-
-# ANSI escape codes
-_DIM    = "\033[90m"        # gray
-_GREEN  = "\033[32m"        # green
-_RED    = "\033[91m"        # red
-_ORANGE = "\033[38;5;208m"  # orange — first line highlight
-_RESET  = "\033[0m"
-
-# ── Log file paths ──
-# Initialized lazily after KITE_MODULE_DATA is resolved (see _init_log_files).
-# We store paths (not handles) and open/write/close on each log line to avoid
-# holding file handles for the entire process lifetime.
-_log_lock = threading.Lock()
-_log_latest_path = None   # path to latest.log
-_log_daily_path = None    # path to {YYYY-MM}/{YYYY-MM-DD}.log
-_log_daily_date = ""      # current date string to detect day rollover
-_log_dir = None           # base log directory
-
-# Crash log paths
-_crash_log_path = None    # path to crashes.jsonl (current run)
-
-# Strip ANSI escape sequences for plain-text log files
-_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
-
-def _strip_ansi(s: str) -> str:
-    return _ANSI_RE.sub("", s)
-
-
-def _init_log_files():
-    """Initialize log file paths. Called after KITE_MODULE_DATA is set."""
-    global _log_latest_path, _log_dir, _crash_log_path
-    module_data = os.environ.get("KITE_MODULE_DATA")
-    if not module_data:
-        return
-    _log_dir = os.path.join(module_data, "log")
-    os.makedirs(_log_dir, exist_ok=True)
-
-    suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
-
-    # latest.log — truncate on each startup (write empty to clear)
-    _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  # truncate
-    except Exception as e:
-        _builtin_print(f"[launcher] 警告: 无法初始化 {os.path.basename(_log_latest_path)}: {e}")
-        _log_latest_path = None
-
-    # crashes.jsonl — truncate on each startup
-    _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  # truncate
-    except Exception:
-        _crash_log_path = None
-
-    # daily log — ensure directory exists
-    _resolve_daily_log_path()
-
-
-def _resolve_daily_log_path():
-    """Resolve the daily log file 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])  # YYYY-MM
-    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 (open-write-close)."""
-    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
-        # Check daily rotation
-        _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 archive."""
-    record = {
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "module": "launcher",
-        "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"
-
-    # 1. Write to crashes.jsonl (current run)
-    if _crash_log_path:
-        try:
-            with open(_crash_log_path, "a", encoding="utf-8") as f:
-                f.write(line)
-        except Exception:
-            pass
-
-    # 2. Write to daily archive
-    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)."""
-    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 = "[launcher]"
-    if thread_name:
-        print(f"{prefix} {_RED}线程 {thread_name} 崩溃: "
-              f"{exc_type.__name__} in {location}{_RESET}")
-    else:
-        print(f"{prefix} {_RED}崩溃: {exc_type.__name__} in {location}{_RESET}")
-    if _crash_log_path:
-        print(f"{prefix} 崩溃日志: {_crash_log_path}")
-
-
-def _setup_exception_hooks():
-    """Set up global exception hooks for launcher process."""
-    _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):
-    global _last_ts, _first_line
-    now = time.monotonic()
-    elapsed = now - _start_ts
-
-    # Timestamp
-    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
-
-    # Format elapsed string (time since startup)
-    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"
-
-    # Extract module prefix from text for per-module delta tracking
-    text_for_module = " ".join(str(a) for a in args) if args else ""
-    plain_text = _ANSI_RE.sub("", text_for_module).strip()
-    m = _MODULE_PREFIX_RE.match(plain_text)
-    module_name = m.group(1) if m else None
-
-    if module_name:
-        # Per-module delta: interval since this module's last print
-        if module_name in _module_last_ts:
-            delta = now - _module_last_ts[module_name]
-        else:
-            delta = None  # first line for this module — no delta
-        _module_last_ts[module_name] = now
-    else:
-        # Fallback: global last-line delta
-        delta = now - _last_ts
-    _last_ts = now
-
-    # Format delta string
-    if delta is None:
-        delta_str = ""
-        delta_color = _DIM
-    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"
-
-    # Color for delta: gray < 1s, green 1–5s, red > 5s
-    if delta is not None:
-        if delta >= 5:
-            delta_color = _RED
-        elif delta >= 1:
-            delta_color = _GREEN
-        else:
-            delta_color = _DIM
-
-    # First line: entire line in orange
-    if _first_line:
-        _first_line = False
-        prefix = f"{_ORANGE}[{elapsed_str:>6}] {ts} {delta_str:>8} "
-        _builtin_print(prefix, end="")
-        _builtin_print(*args, end="", **{k: v for k, v in kwargs.items() if k != "end"})
-        _builtin_print(_RESET, end=kwargs.get("end", "\n"))
-    else:
-        prefix = f"[{elapsed_str:>6}] {ts} {delta_color}{delta_str:>8}{_RESET} "
-        _builtin_print(prefix, end="")
-        _builtin_print(*args, **kwargs)
-
-    # Write to log files (plain text, no ANSI)
-    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)
-        plain_prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
-        _write_log(plain_prefix + _strip_ansi(text) + end)
-
-builtins.print = _tprint
-
-# Load .env (development convenience, not required in production)
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except ImportError:
-    pass
-
-# Resolve project root (directory containing this file)
-_project_root = os.path.dirname(os.path.abspath(__file__))
-
-# Home base for Kite data
-_home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
-_kite_home = os.path.join(_home, ".kite")
-
-# Set KITE_* defaults (only if not already set by cli.js or .env)
-_defaults = {
-    "KITE_PROJECT": _project_root,
-    "KITE_CWD": os.getcwd(),
-    "KITE_WORKSPACE": os.path.join(_kite_home, "workspace"),
-    "KITE_DATA": os.path.join(_kite_home, "data"),
-    "KITE_MODULES": os.path.join(_kite_home, "modules"),
-    "KITE_REPO": os.path.join(_kite_home, "repo"),
-    "KITE_ENV": "development",
-}
-for key, value in _defaults.items():
-    if not os.environ.get(key):
-        os.environ[key] = value
-
-# Parse --debug flag
-if "--debug" in sys.argv:
-    os.environ["KITE_DEBUG"] = "1"
-    sys.argv.remove("--debug")
-
-# Ensure project root is on sys.path
-sys.path.insert(0, os.environ["KITE_PROJECT"])
-
-_builtin_print("[launcher] 正在加载模块...")
-from core.launcher.entry import Launcher
-
-
-def main():
-    # Reset timing baseline to exclude import overhead
-    global _start_ts, _last_ts
-    _start_ts = time.monotonic()
-    _last_ts = time.monotonic()
-
-    token = secrets.token_hex(32)
-    launcher = Launcher(kite_token=token)
-    # KITE_MODULE_DATA is now set by constructor — initialize log files
-    _init_log_files()
-    _setup_exception_hooks()
-    # First lines in both console AND log file
-    print("[launcher] Kite 启动中...")
-    log_dir = os.path.join(os.environ.get("KITE_MODULE_DATA", ""), "log")
-    print(f"[launcher] 日志: {log_dir}")
-    try:
-        launcher.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 __name__ == "__main__":
-    main()
+# 2. Start launcher
+from launcher.entry import start_launcher
+start_launcher()