@agentunion/kite 1.4.0 → 1.5.0

package/kite_cli/main.py

@@ -6,7 +6,7 @@ from kite_cli import __version__
 from kite_cli.utils.i18n import t
 
 
-KNOWN_COMMANDS = ["install", "uninstall", "update", "list", "search", "info", "log", "rollback", "clean", "doctor", "history"]
+KNOWN_COMMANDS = ["install", "uninstall", "update", "list", "search", "info", "log", "rollback", "clean", "doctor", "history", "prepare", "env-check", "venv-setup", "deps-install"]
 
 
 class SilentArgumentParser(argparse.ArgumentParser):
@@ -46,6 +46,10 @@ Kite CLI v{__version__} — 模块安装管理工具
   rollback              回滚最后一次操作
   clean                 清理临时文件和缓存
   doctor                检查下载工具状态
+  prepare               打包前准备（扫描依赖，生成锁定文件）
+  env-check             环境检查（虚拟环境和依赖库）
+  venv-setup            创建虚拟环境
+  deps-install          安装依赖库
 
 全局选项:
   -h, -H, --help        显示此帮助信息
@@ -218,6 +222,18 @@ def main():
     # doctor 命令
     doctor_parser = subparsers.add_parser("doctor", help="检查下载工具状态", add_help=True)
 
+    # prepare 命令
+    prepare_parser = subparsers.add_parser("prepare", help="打包前准备（扫描依赖）", add_help=True)
+
+    # env-check 命令
+    env_check_parser = subparsers.add_parser("env-check", help="环境检查（虚拟环境和依赖库）", add_help=True)
+
+    # venv-setup 命令
+    venv_setup_parser = subparsers.add_parser("venv-setup", help="创建虚拟环境", add_help=True)
+
+    # deps-install 命令
+    deps_install_parser = subparsers.add_parser("deps-install", help="安装依赖库", add_help=True)
+
     args, unknown = parser.parse_known_args()
 
     # 处理全局 --help / --version
@@ -280,6 +296,18 @@ def main():
     elif args.command == "doctor":
         from kite_cli.commands.doctor import run_doctor
         return run_doctor(args)
+    elif args.command == "prepare":
+        from kite_cli.commands.prepare import run_prepare
+        return run_prepare(args)
+    elif args.command == "env-check":
+        from kite_cli.commands.env_check import run_env_check
+        return run_env_check(args)
+    elif args.command == "venv-setup":
+        from kite_cli.commands.venv_setup import run_venv_setup
+        return run_venv_setup(args)
+    elif args.command == "deps-install":
+        from kite_cli.commands.deps_install import run_deps_install
+        return run_deps_install(args)
     else:
         print(f"未知命令: {args.command}")
         return 1

package/launcher/entry.py

@@ -73,16 +73,25 @@ class Launcher:
             discovery=self._load_discovery(),
         )
 
+        # Load relay configuration
+        relay_config = self._load_relay_config()
+        self._relay_modules = relay_config.get("modules", [])
+        self._relay_token_limits = relay_config.get("token_limits", {})
+
         self.kernel_port: int = 0
         self.modules: dict[str, ModuleInfo] = {}
         self._shutdown_event = asyncio.Event()
         self._thread_shutdown = threading.Event()
         self._shutdown_complete = threading.Event()  # Set when normal shutdown finishes
         self._module_tokens: dict[str, str] = {}  # module_name -> per-module token
+        self._client_tokens: dict[str, str] = {}  # virtual module_id -> kernel_token (for relay modules)
 
         # Three-layer state model: desired_state per module
         self._desired_states: dict[str, str] = {}  # module_name -> "running" | "stopped"
 
+        # Relay module configuration (already loaded above, don't reinitialize)
+        # self._relay_modules and self._relay_token_limits are set in lines 78-79
+
         # Kernel WebSocket client
         self._ws: object | None = None
         self._ws_task: asyncio.Task | None = None
@@ -526,10 +535,14 @@ class Launcher:
             ready = await self._wait_event("module.ready", "kernel", timeout=15)
             if ready:
                 self._graceful_modules["kernel"] = bool(ready.get("graceful_shutdown"))
-                print("[launcher] Kernel 已就绪")
+                # Use startup_time from module.ready event
+                startup_time = ready.get("startup_time", time.monotonic() - t_ws)
+                self._ready_times["kernel"] = startup_time
+                startup_str = f"{startup_time:.3f}s" if startup_time < 10 else f"{startup_time:.2f}s"
+                print(f"[launcher] Kernel 已就绪 ({startup_str})")
             else:
                 print("\033[91m[launcher] 警告: Kernel 在 15s 内未发送 module.ready\033[0m")
-            self._ready_times["kernel"] = time.monotonic() - t_ws
+                self._ready_times["kernel"] = time.monotonic() - t_ws
 
         await asyncio.gather(
             _scan_and_generate_tokens(),
@@ -630,7 +643,7 @@ class Launcher:
         launcher_token = self._module_tokens.get("launcher", "")
         ws_url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={launcher_token}&id=launcher"
         t_ws_connect = time.monotonic()
-        async with websockets.connect(ws_url, open_timeout=3, ping_interval=20, ping_timeout=20, close_timeout=10) as ws:
+        async with websockets.connect(ws_url, open_timeout=3, ping_interval=None, close_timeout=10) as ws:
             self._ws = ws
             _ws_s = time.monotonic() - t_ws_connect
             print(f"[launcher] 已连接到 Kernel ({self._fmt_elapsed(_ws_s)})")
@@ -664,6 +677,7 @@ class Launcher:
                                 "restart_launcher": {"method": "restart_launcher", "description": "重启 Launcher"},
                                 "rescan": {"method": "rescan", "description": "重新扫描模块"},
                                 "shutdown": {"method": "shutdown", "description": "关闭系统"},
+                                "request_client_token": {"method": "request_client_token", "description": "为 Web 客户端申请 Kernel Token"},
                             },
                             "module": {
                                 "config": {
@@ -692,10 +706,14 @@ class Launcher:
                 print("[launcher] 已注册到 Kernel")
 
                 # Publish module.ready for Launcher itself (every reconnect)
+                startup_time = time.monotonic() - self._t_start
                 await self._publish_event("module.ready", {
                     "module_id": "launcher",
                     "graceful_shutdown": True,
+                    "startup_time": startup_time,
                 })
+                # Record launcher's own startup time
+                self._ready_times["launcher"] = startup_time
 
                 # Signal that connection is ready (after subscription and registration)
                 if self._ws_connected:
@@ -775,6 +793,17 @@ class Launcher:
             self._rpc_results[rpc_id] = msg
             waiter.set()
 
+    async def _handle_ping_event(self, data: dict):
+        """Handle system.ping event and reply with system.pong."""
+        t1 = data.get("ping_time")
+        t2 = time.time()
+
+        await self._publish_event("system.pong", {
+            "module_id": "launcher",
+            "ping_time": t1,
+            "pong_time": t2,
+        })
+
     async def _handle_event_notification(self, msg: dict):
         """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
         params = msg.get("params", {})
@@ -783,6 +812,11 @@ class Launcher:
         data = params.get("data") if isinstance(params.get("data"), dict) else {}
         ts = params.get("timestamp", "")
 
+        # Handle system.ping event
+        if event == "system.ping":
+            await self._handle_ping_event(data)
+            return
+
         # Trigger event waiters
         module_id = data.get("module_id", "")
         waiter_key = f"{event}:{module_id}"
@@ -794,6 +828,14 @@ class Launcher:
 
         # module.exiting also wakes module.ready waiter
         if event == "module.exiting" and module_id:
+            # 处理 token 释放（如果是虚拟模块且标记了 token_revoked）
+            token_revoked = data.get("token_revoked", False)
+            if token_revoked and module_id in self._client_tokens:
+                del self._client_tokens[module_id]
+                print(f"[launcher] Token revoked for {module_id}")
+                # 记录审计日志
+                self._log_token_request("system", module_id, "revoke", True)
+
             ready_key = f"module.ready:{module_id}"
             ready_waiter = self._event_waiters.get(ready_key)
             if ready_waiter:
@@ -863,9 +905,11 @@ class Launcher:
             if step == "code_generated":
                 code = data.get("code", "")
                 expires_in = data.get("expires_in", 300)
+                module_id = data.get("module_id", "unknown")
                 if code:
                     print(f"[launcher] {GREEN}配对码: {code}{RESET}")
                     print(f"[launcher] {GREEN}有效期: {expires_in} 秒{RESET}")
+                    print(f"[launcher] {GREEN}来源模块: {module_id}{RESET}")
                     print(f"[launcher] {GREEN}访问 Web 界面时使用此配对码进行配对{RESET}")
 
             elif step == "pairing":
@@ -922,6 +966,8 @@ class Launcher:
             "get_module_config":    self._rpc_get_module_config,
             "update_module_config": self._rpc_update_module_config,
             "reset_module_config":  self._rpc_reset_module_config,
+            "request_client_token": self._rpc_request_client_token,
+            "release_client_token": self._rpc_release_client_token,
         }
         handler = handlers.get(method)
         if handler:
@@ -943,10 +989,30 @@ class Launcher:
 
     async def _rpc_list_modules(self, params: dict) -> dict:
         """List all modules and their current status."""
+        # Get ping/pong latencies from Kernel
+        latencies = {}
+        try:
+            latencies_resp = await self._rpc_call(self._ws, "kernel.latencies", {}, timeout=2)
+            if "result" in latencies_resp:
+                latencies = latencies_resp["result"].get("latencies", {})
+        except Exception as e:
+            print(f"[launcher] Failed to get latencies: {e}")
+
+        current_time = time.time()
         result = []
         for name, info in self.modules.items():
             running = self.process_manager.is_running(name)
             rec = self.process_manager.get_record(name)
+
+            # Get latency info for this module
+            latency_info = latencies.get(name, {})
+            ping_status = latency_info.get("status", "never")
+
+            # Calculate uptime (running time in seconds)
+            uptime_seconds = None
+            if running and rec and rec.started_at:
+                uptime_seconds = current_time - rec.started_at
+
             result.append({
                 "name": name,
                 "display_name": info.display_name,
@@ -956,10 +1022,20 @@ class Launcher:
                 "runtime": info.runtime,
                 "preferred_port": info.preferred_port,
                 "monitor": info.monitor,
+                "display_order": info.display_order,
                 "desired_state": self._desired_states.get(name, "stopped"),
                 "actual_state": f"running({rec.pid})" if running and rec else "stopped",
                 "pid": rec.pid if running and rec else None,
+                "startup_time": self._ready_times.get(name),  # Module startup time in seconds
+                "uptime_seconds": uptime_seconds,  # Running time in seconds
+                "ping_status": ping_status,
+                "ping_outbound_ms": latency_info.get("outbound"),
+                "ping_inbound_ms": latency_info.get("inbound"),
             })
+
+        # Sort by display_order (descending), then by name (ascending)
+        result.sort(key=lambda m: (-m["display_order"], m["name"]))
+
         return {"modules": result}
 
     async def _rpc_start_module(self, params: dict) -> dict:
@@ -1864,8 +1940,11 @@ class Launcher:
             print(f"[launcher] 模块 '{info.name}' 主动退出: {reason} ({elapsed:.2f}s)")
         elif ready:
             self._graceful_modules[info.name] = bool(ready.get("graceful_shutdown"))
-            self._ready_times[info.name] = elapsed
-            print(f"[launcher] 模块 '{info.name}' 已就绪 ({elapsed:.2f}s)")
+            # Use startup_time from module.ready event (module's self-reported startup time)
+            startup_time = ready.get("startup_time", elapsed)
+            self._ready_times[info.name] = startup_time
+            startup_str = f"{startup_time:.3f}s" if startup_time < 10 else f"{startup_time:.2f}s"
+            print(f"[launcher] 模块 '{info.name}' 已就绪 ({startup_str})")
         else:
             print(f"\033[91m[launcher] 警告: '{info.name}' 在 {timeout}s 内未发送 module.ready\033[0m")
 
@@ -2150,9 +2229,6 @@ class Launcher:
             started_at=self._start_unix,
         )
         running.append(("launcher", launcher_info, launcher_rec))
-        # Launcher is ready immediately (ready_time = 0)
-        if "launcher" not in self._ready_times:
-            self._ready_times["launcher"] = 0.0
 
         for name, info in self.modules.items():
             rec = self.process_manager.get_record(name)
@@ -2223,7 +2299,16 @@ class Launcher:
         for name, info, rec in running_sorted:
             label = info.display_name or name
             ready_t = self._ready_times.get(name)
-            time_str = f"{ready_t:.2f}s" if ready_t is not None else "—"
+            # Format startup time with ms/s auto-switch
+            if ready_t is not None:
+                if ready_t < 1:
+                    time_str = f"{ready_t * 1000:.0f}ms"
+                elif ready_t < 10:
+                    time_str = f"{ready_t:.2f}s"
+                else:
+                    time_str = f"{ready_t:.1f}s"
+            else:
+                time_str = "—"
 
             # Calculate elapsed from start
             if ready_t is not None and hasattr(self, '_start_unix'):
@@ -2295,18 +2380,53 @@ class Launcher:
 
         lines.append(f"{G}  Kernel WS: ws://127.0.0.1:{self.kernel_port}/ws   实例: {self.instance_id}{R}")
 
-        # Query Kernel for web module's api_endpoint via RPC
-        web_url = ""
-        if self._ws:
-            try:
-                resp = await self._rpc_call(self._ws, "registry.get", {"path": "web.api_endpoint"}, timeout=3)
-                val = resp.get("result", {}).get("value")
-                if val and isinstance(val, str):
-                    web_url = val.replace("://127.0.0.1:", "://localhost:")
-            except Exception:
-                pass
-        if web_url:
-            lines.append(f"{B}  Web 管理后台: {web_url}{R}")
+        # Check if web or evol modules are running and display their URLs
+        RED = "\033[91m"
+        running_names = {name for name, _, _ in running}
+
+        # Check web module
+        if "web" in running_names:
+            web_url = ""
+            web_error = ""
+            if self._ws:
+                try:
+                    resp = await self._rpc_call(self._ws, "registry.get", {"path": "web.api_endpoint"}, timeout=3)
+                    val = resp.get("result", {}).get("value")
+                    if val and isinstance(val, str):
+                        web_url = val.replace("://127.0.0.1:", "://localhost:")
+                    else:
+                        web_error = "未注册到 Kernel Registry"
+                except Exception as e:
+                    web_error = f"查询失败: {str(e)}"
+            else:
+                web_error = "Kernel 连接不可用"
+
+            if web_url:
+                lines.append(f"{B}  Web 管理后台: {web_url}{R}")
+            else:
+                lines.append(f"{RED}  Web 管理后台: {web_error}{R}")
+
+        # Check evol module
+        if "evol" in running_names:
+            evol_url = ""
+            evol_error = ""
+            if self._ws:
+                try:
+                    resp = await self._rpc_call(self._ws, "registry.get", {"path": "evol.api_endpoint"}, timeout=3)
+                    val = resp.get("result", {}).get("value")
+                    if val and isinstance(val, str):
+                        evol_url = val.replace("://127.0.0.1:", "://localhost:")
+                    else:
+                        evol_error = "未注册到 Kernel Registry"
+                except Exception as e:
+                    evol_error = f"查询失败: {str(e)}"
+            else:
+                evol_error = "Kernel 连接不可用"
+
+            if evol_url:
+                lines.append(f"{B}  Evol: {evol_url}{R}")
+            else:
+                lines.append(f"{RED}  Evol: {evol_error}{R}")
 
         # Instance info
         instances = self.process_manager.get_alive_instances()
@@ -2370,6 +2490,155 @@ class Launcher:
 
         print("\n".join(lines))
 
+    async def _rpc_request_client_token(self, params: dict) -> dict:
+        """为 relay 模块申请虚拟客户端 Token.
+
+        Args:
+            params: {
+                "module_id": str - 虚拟模块 ID (如 "web-client-a3f9e2")
+                "_caller_id": str - 调用者模块 ID (由 Kernel 注入)
+            }
+
+        Returns:
+            {
+                "token": str - Kernel Token (64 字符 hex)
+                "module_id": str - 虚拟模块 ID
+            }
+
+        Raises:
+            PermissionError: 调用者不在白名单中
+            ValueError: module_id 格式不合法或已存在
+            RuntimeError: Token 限额已满
+        """
+        import re
+
+        # 1. 获取调用者 ID
+        caller_id = params.get("_caller_id")
+        if not caller_id:
+            raise PermissionError("Missing _caller_id in params")
+
+        # 2. 权限检查
+        if caller_id not in self._relay_modules:
+            print(f"[launcher] DEBUG: 权限检查失败 - caller_id={caller_id}, relay_modules={self._relay_modules}")
+            raise PermissionError(f"Permission denied: {caller_id} not in relay_modules whitelist")
+
+        # 3. 参数验证
+        module_id = params.get("module_id")
+        if not module_id:
+            raise ValueError("module_id is required")
+
+        # 4. 命名规范验证
+        expected_prefix = f"{caller_id}-client-"
+        if not module_id.startswith(expected_prefix):
+            raise ValueError(f"module_id must start with {expected_prefix}")
+
+        suffix = module_id[len(expected_prefix):]
+        if not re.match(r'^[a-zA-Z0-9_-]+$', suffix):
+            raise ValueError("Invalid module_id suffix")
+
+        # 5. 检查是否已存在（幂等）
+        if module_id in self._client_tokens:
+            print(f"[launcher] Token already exists for {module_id}, returning existing token")
+            return {
+                "token": self._client_tokens[module_id],
+                "module_id": module_id
+            }
+
+        # 6. 检查限额
+        limit = self._relay_token_limits.get(caller_id, 100)
+        current_count = sum(1 for mid in self._client_tokens if mid.startswith(expected_prefix))
+        if current_count >= limit:
+            raise RuntimeError(f"Token limit reached: {current_count}/{limit}")
+
+        # 7. 生成 token
+        token = secrets.token_hex(32)
+
+        # 8. 注册到 Kernel
+        try:
+            result = await self._rpc_call(self._ws, "kernel.register_tokens", {module_id: token})
+            if "error" in result:
+                raise RuntimeError(f"Failed to register token: {result['error'].get('message', '')}")
+        except Exception as e:
+            raise RuntimeError(f"Failed to register token to Kernel: {e}")
+
+        # 9. 保存到本地映射
+        self._client_tokens[module_id] = token
+
+        # 10. 记录审计日志
+        self._log_token_request(caller_id, module_id, "request", True)
+
+        print(f"[launcher] Token generated for {module_id} (caller: {caller_id})")
+
+        return {
+            "token": token,
+            "module_id": module_id
+        }
+
+    async def _rpc_release_client_token(self, params: dict) -> dict:
+        """释放虚拟客户端 Token (可选).
+
+        Args:
+            params: {
+                "module_id": str - 虚拟模块 ID
+                "_caller_id": str - 调用者模块 ID (由 Kernel 注入)
+            }
+
+        Returns:
+            {}
+
+        Raises:
+            PermissionError: 调用者不在白名单中或 module_id 不属于调用者
+            ValueError: module_id 格式不合法
+        """
+        # 1. 获取调用者 ID
+        caller_id = params.get("_caller_id")
+        if not caller_id:
+            raise PermissionError("Missing _caller_id in params")
+
+        # 2. 权限检查
+        if caller_id not in self._relay_modules:
+            print(f"[launcher] DEBUG: 权限检查失败 - caller_id={caller_id}, relay_modules={self._relay_modules}")
+            raise PermissionError(f"Permission denied: {caller_id} not in relay_modules whitelist")
+
+        # 3. 参数验证
+        module_id = params.get("module_id")
+        if not module_id:
+            raise ValueError("module_id is required")
+
+        # 4. 验证所有权
+        expected_prefix = f"{caller_id}-client-"
+        if not module_id.startswith(expected_prefix):
+            raise ValueError(f"module_id does not belong to {caller_id}")
+
+        # 5. 删除 token
+        if module_id in self._client_tokens:
+            del self._client_tokens[module_id]
+            print(f"[launcher] Token released for {module_id} (caller: {caller_id})")
+
+        # 6. 记录审计日志
+        self._log_token_request(caller_id, module_id, "release", True)
+
+        return {}
+
+    def _log_token_request(self, caller_id: str, module_id: str, action: str, success: bool):
+        """记录 Token 申请/释放审计日志."""
+        from datetime import datetime, timezone
+        record = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "caller_id": caller_id,
+            "module_id": module_id,
+            "action": action,
+            "success": success
+        }
+        try:
+            log_dir = os.path.join(os.environ.get("KITE_MODULE_DATA", ""), "log")
+            os.makedirs(log_dir, exist_ok=True)
+            log_file = os.path.join(log_dir, "token_requests.jsonl")
+            with open(log_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(record, ensure_ascii=False) + "\n")
+        except Exception as e:
+            print(f"[launcher] 警告: 写入 token 审计日志失败: {e}")
+
     # ── Utilities ──
 
     def _load_discovery(self) -> dict | None:
@@ -2385,6 +2654,22 @@ class Launcher:
             print(f"[launcher] 警告: 读取发现配置失败: {e}")
         return None
 
+    def _load_relay_config(self) -> dict:
+        """Read relay config from launcher's own module.md."""
+        md_path = os.path.join(os.environ["KITE_PROJECT"], "launcher", "module.md")
+        try:
+            with open(md_path, "r", encoding="utf-8") as f:
+                fm = _parse_frontmatter(f.read())
+            relay = fm.get("relay")
+            if isinstance(relay, dict) and relay:
+                print(f"[launcher] Relay 配置已加载: modules={relay.get('modules')}, token_limits={relay.get('token_limits')}")
+                return relay
+            else:
+                print(f"[launcher] 警告: relay 配置为空或格式错误")
+        except Exception as e:
+            print(f"[launcher] 警告: 读取 relay 配置失败: {e}")
+        return {}
+
     def _log_lifecycle(self, event: str, module: str, **extra):
         """Append one JSONL line to lifecycle.jsonl."""
         from datetime import datetime, timezone

package/launcher/module.md

@@ -14,6 +14,15 @@ discovery:
     type: scan_dir
     path: test_modules
     enabled: true
+relay:
+  # 允许申请动态 Token 的模块白名单
+  modules:
+    - evol
+    - web
+  # 每个 relay 模块的 Token 限额
+  token_limits:
+    evol: 100
+    web: 50
 monitor: true
 ---
 # Launcher

package/launcher/module_scanner.py

@@ -31,6 +31,7 @@ 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)
     module_dir: str = ""                # absolute path to the module directory
     launch: LaunchConfig = field(default_factory=LaunchConfig)
 
@@ -105,7 +106,8 @@ class ModuleScanner:
         # 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)
+            # Kernel is at project root, check it directly
+            self._add_module(kernel_dir, modules)
         self._scan_dir(os.path.join(project_root, "extensions"), 2, modules)
 
         # Extra sources from discovery config
@@ -216,6 +218,13 @@ 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 optional launch config
         launch_raw = fm.get("launch", {})
         if not isinstance(launch_raw, dict):
@@ -254,6 +263,7 @@ class ModuleScanner:
             preferred_port=preferred_port,
             depends_on=depends_on,
             monitor=monitor,
+            display_order=display_order,
             module_dir=mod_dir,
             launch=launch,
         )

package/main.py

@@ -2,12 +2,15 @@
 Kite development entry point.
 1. Run code stats
 2. Start launcher
+
+注意：环境检查已在 Node.js 层（cli.js）完成
 """
 import sys
 from pathlib import Path
 
 # Add project root to sys.path
-sys.path.insert(0, str(Path(__file__).parent))
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
 
 # 1. Run code stats
 from launcher.count_lines import run_stats

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "@agentunion/kite",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Kite framework launcher — start Kite from anywhere",
   "bin": {
     "kite": "./cli.js"
   },
+  "scripts": {
+    "postinstall": "node scripts/setup-python-env.js"
+  },
   "files": [
     "cli.js",
     "main.py",
+    "requirements.txt",
+    "python_version.json",
+    "dependencies_lock.json",
     "launcher/**",
     "kernel/**",
     "extensions/**",
     "kite_cli/**",
     "scripts/**",
+    "core/**",
     "CHANGELOG.md",
     "!**/__pycache__",
     "!**/__pycache__/**",

package/python_version.json

@@ -0,0 +1,4 @@
+{
+  "version": "3.13.12",
+  "note": "此文件在开发环境打包时生成，记录开发环境的 Python 版本。生产环境必须使用相同版本。"
+}

package/requirements.txt

@@ -0,0 +1,38 @@
+# Kite 框架核心依赖
+# 安装方法：pip install -r requirements.txt
+
+# Web 框架
+fastapi>=0.115.0
+uvicorn>=0.32.0
+starlette>=0.41.0
+
+# WebSocket
+websockets>=13.0
+
+# HTTP 客户端
+httpx>=0.27.0
+aiohttp>=3.10.0
+requests>=2.32.0
+
+# 配置解析
+json5>=0.9.25
+pyyaml>=6.0.2
+python-dotenv>=1.0.0
+
+# 数据验证
+pydantic>=2.9.0
+
+# 异步 IO
+aiofiles>=24.1.0
+
+# 进程管理
+psutil>=6.1.0
+
+# 加密
+cryptography>=43.0.0
+
+# 进度条
+tqdm>=4.66.0
+
+# 类型扩展
+typing-extensions>=4.12.0