@agentunion/kite 1.3.2 → 1.5.0

package/launcher/logging_setup.py

@@ -50,6 +50,9 @@ def init_log_files():
     _log_dir = os.path.join(module_data, "log")
     os.makedirs(_log_dir, exist_ok=True)
 
+    # Clean up orphaned instance log files before initializing
+    _cleanup_orphaned_logs()
+
     suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
 
     # latest.log — truncate on each startup
@@ -73,6 +76,107 @@ def init_log_files():
     _resolve_daily_log_path()
 
 
+def _cleanup_orphaned_logs():
+    """Clean up log files from dead instances (files with ~N suffix whose launcher is not running)."""
+    if not _log_dir or not os.path.isdir(_log_dir):
+        return
+
+    try:
+        # Get state directory path
+        module_data = os.environ.get("KITE_MODULE_DATA")
+        if not module_data:
+            return
+        state_dir = os.path.join(os.path.dirname(module_data), "state")
+
+        # Scan for files with ~N suffix
+        import glob
+        orphaned_files = []
+
+        for pattern in ["latest~*.log", "crashes~*.jsonl"]:
+            for filepath in glob.glob(os.path.join(_log_dir, pattern)):
+                basename = os.path.basename(filepath)
+                # Extract instance number from filename
+                instance_num = _extract_instance_num(basename)
+                if instance_num is None:
+                    continue
+
+                # Check if corresponding launcher is still running
+                if not _is_instance_alive(state_dir, instance_num):
+                    orphaned_files.append(filepath)
+
+        # Delete orphaned files
+        if orphaned_files:
+            _builtin_print(f"[launcher] 清理 {len(orphaned_files)} 个孤儿日志文件:")
+            for filepath in orphaned_files:
+                try:
+                    os.remove(filepath)
+                    _builtin_print(f"[launcher]   已删除: {os.path.basename(filepath)}")
+                except Exception as e:
+                    _builtin_print(f"[launcher]   删除失败 {os.path.basename(filepath)}: {e}")
+
+    except Exception as e:
+        _builtin_print(f"[launcher] 清理孤儿日志文件时出错: {e}")
+
+
+def _extract_instance_num(filename: str) -> int | None:
+    """Extract instance number from log filename. Returns None if not a valid instance file."""
+    import re
+    # Match patterns like "latest~2.log" or "crashes~3.jsonl"
+    m = re.match(r"^(?:latest|crashes)~(\d+)\.(log|jsonl)$", filename)
+    return int(m.group(1)) if m else None
+
+
+def _is_instance_alive(state_dir: str, instance_num: int) -> bool:
+    """Check if a launcher instance is still running by checking its processes file and PID."""
+    if not os.path.isdir(state_dir):
+        return False
+
+    # Determine processes filename
+    if instance_num == 1:
+        processes_file = os.path.join(state_dir, "processes.json")
+    else:
+        processes_file = os.path.join(state_dir, f"processes~{instance_num}.json")
+
+    # If processes file doesn't exist, instance is dead
+    if not os.path.isfile(processes_file):
+        return False
+
+    # Read launcher_pid from processes file
+    try:
+        import json
+        with open(processes_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        launcher_pid = data.get("launcher_pid")
+        if not launcher_pid:
+            return False
+
+        # Check if process is still running
+        return _is_process_running(launcher_pid)
+    except Exception:
+        return False
+
+
+def _is_process_running(pid: int) -> bool:
+    """Check if a process with given PID is running (cross-platform)."""
+    try:
+        if sys.platform == "win32":
+            # Windows: use tasklist
+            import subprocess
+            result = subprocess.run(
+                ["tasklist", "/FI", f"PID eq {pid}", "/NH"],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            return str(pid) in result.stdout
+        else:
+            # Unix: send signal 0
+            os.kill(pid, 0)
+            return True
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
 def _resolve_daily_log_path():
     """Resolve the daily log file path based on current date."""
     global _log_daily_path, _log_daily_date

package/launcher/module.md

@@ -1,37 +1,46 @@
----
-name: launcher
-display_name: "Launcher"
-version: "1.0"
-type: infrastructure
-state: enabled
-events:
-  - module.started
-  - module.stopped
-  - module.state_changed
-subscriptions: []
-discovery:
-  test_modules:
-    type: scan_dir
-    path: test_modules
-    enabled: true
----
-
-# Launcher
-
-Kite 系统的启动器和进程管理器。与 main.py 在同一进程中运行，是整个系统的入口和控制台。
-
-## 职责
-
-- 启动 Registry，等待就绪
-- 扫描 core/ 和 extensions/ 下的模块
-- 并行启动 state: enabled 的模块
-- 监控子进程状态，core 模块崩溃触发全量重启
-- 提供 Launcher API 供其他模块启停管理
-- 优雅退出时清理所有子进程
-
-## API
-
-- `GET /launcher/modules` — 列出所有模块及状态
-- `POST /launcher/modules/{name}/start` — 启动模块
-- `POST /launcher/modules/{name}/stop` — 停止模块
-- `PUT /launcher/modules/{name}/state` — 修改模块 state
+---
+name: launcher
+display_name: Launcher
+version: '1.0'
+type: infrastructure
+state: enabled
+events:
+- module.started
+- module.stopped
+- module.state_changed
+subscriptions: []
+discovery:
+  test_modules:
+    type: scan_dir
+    path: test_modules
+    enabled: true
+relay:
+  # 允许申请动态 Token 的模块白名单
+  modules:
+    - evol
+    - web
+  # 每个 relay 模块的 Token 限额
+  token_limits:
+    evol: 100
+    web: 50
+monitor: true
+---
+# Launcher
+
+Kite 系统的启动器和进程管理器。与 main.py 在同一进程中运行，是整个系统的入口和控制台。
+
+## 职责
+
+- 启动 Registry，等待就绪
+- 扫描 core/ 和 extensions/ 下的模块
+- 并行启动 state: enabled 的模块
+- 监控子进程状态，core 模块崩溃触发全量重启
+- 提供 Launcher API 供其他模块启停管理
+- 优雅退出时清理所有子进程
+
+## API
+
+- `GET /launcher/modules` — 列出所有模块及状态
+- `POST /launcher/modules/{name}/start` — 启动模块
+- `POST /launcher/modules/{name}/stop` — 停止模块
+- `PUT /launcher/modules/{name}/state` — 修改模块 state

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,17 +1,25 @@
 {
   "name": "@agentunion/kite",
-  "version": "1.3.2",
+  "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

package/scripts/env-manager.js

@@ -0,0 +1,328 @@
+/**
+ * Kite 环境管理模块
+ *
+ * 负责在 Node.js 层检查和准备 Python 环境
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync, spawnSync } = require('child_process');
+
+// 颜色输出
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m'
+};
+
+function log(msg, color = 'reset') {
+  console.log(`${colors[color]}[Kite Env]${colors.reset} ${msg}`);
+}
+
+function error(msg) {
+  console.error(`${colors.red}[Kite Env Error]${colors.reset} ${msg}`);
+}
+
+/**
+ * 获取 KITE_DATA 路径
+ */
+function getKiteDataPath() {
+  return path.join(os.homedir(), '.kite');
+}
+
+/**
+ * 获取环境状态文件路径
+ */
+function getEnvStatusPath() {
+  return path.join(getKiteDataPath(), 'env_status.json');
+}
+
+/**
+ * 读取环境状态
+ */
+function loadEnvStatus() {
+  const statusFile = getEnvStatusPath();
+
+  if (!fs.existsSync(statusFile)) {
+    return null;
+  }
+
+  try {
+    const data = fs.readFileSync(statusFile, 'utf-8');
+    return JSON.parse(data);
+  } catch (e) {
+    error(`读取环境状态失败: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * 检查是否需要准备 Python
+ */
+function needsPythonSetup(versionDir) {
+  const pythonVersionFile = path.join(versionDir, 'python_version.json');
+
+  if (!fs.existsSync(pythonVersionFile)) {
+    return false; // 没有版本要求文件，跳过
+  }
+
+  try {
+    const versionData = JSON.parse(fs.readFileSync(pythonVersionFile, 'utf-8'));
+    const requiredVersion = versionData.version;
+
+    // 检测系统 Python
+    const pythonCommands = ['python3', 'python'];
+
+    for (const cmd of pythonCommands) {
+      try {
+        const version = execSync(`${cmd} --version`, {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'ignore']
+        }).trim();
+
+        const match = version.match(/Python (\d+\.\d+\.\d+)/);
+        if (match && match[1] === requiredVersion) {
+          return false; // 找到匹配的 Python 版本
+        }
+      } catch (e) {
+        // 命令不存在，继续
+      }
+    }
+
+    return true; // 没有找到匹配的 Python 版本
+  } catch (e) {
+    error(`检查 Python 版本失败: ${e.message}`);
+    return true; // 出错时保守处理，执行安装
+  }
+}
+
+/**
+ * 准备 Python 环境
+ */
+function setupPython(versionDir) {
+  log('准备 Python 环境...', 'cyan');
+
+  const setupScript = path.join(versionDir, 'scripts', 'setup-python-env.js');
+
+  if (!fs.existsSync(setupScript)) {
+    error('setup-python-env.js 不存在');
+    return false;
+  }
+
+  try {
+    execSync(`node "${setupScript}"`, {
+      stdio: 'inherit',
+      cwd: versionDir
+    });
+    return true;
+  } catch (e) {
+    error('Python 环境准备失败');
+    return false;
+  }
+}
+
+/**
+ * 检查是否需要准备虚拟环境
+ */
+function needsVenvSetup(status) {
+  // 1. 状态文件不存在
+  if (!status) {
+    return true;
+  }
+
+  // 2. 上次检查失败
+  if (status.status !== 'success') {
+    return true;
+  }
+
+  // 3. 虚拟环境不存在
+  const venvPath = path.join(getKiteDataPath(), 'venv');
+  if (!fs.existsSync(venvPath)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * 检查是否需要安装依赖
+ */
+function needsDepsInstall(status) {
+  // 1. 状态文件不存在
+  if (!status) {
+    return true;
+  }
+
+  // 2. 上次检查失败
+  if (status.status !== 'success') {
+    return true;
+  }
+
+  // 3. 依赖未安装
+  if (!status.dependencies || !status.dependencies.installed) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * 准备虚拟环境
+ */
+function setupVenv(versionDir) {
+  log('准备虚拟环境...', 'cyan');
+
+  const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+
+  try {
+    const result = spawnSync(
+      pythonCmd,
+      ['-m', 'kite_cli', 'venv-setup'],
+      {
+        cwd: versionDir,
+        stdio: 'inherit',
+        encoding: 'utf-8',
+        env: {
+          ...process.env,
+          PYTHONPATH: versionDir
+        }
+      }
+    );
+
+    return result.status === 0;
+  } catch (e) {
+    error('虚拟环境准备失败');
+    return false;
+  }
+}
+
+/**
+ * 安装依赖
+ */
+function installDeps(versionDir) {
+  log('安装依赖库...', 'cyan');
+
+  const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+
+  try {
+    const result = spawnSync(
+      pythonCmd,
+      ['-m', 'kite_cli', 'deps-install'],
+      {
+        cwd: versionDir,
+        stdio: 'inherit',
+        encoding: 'utf-8',
+        env: {
+          ...process.env,
+          PYTHONPATH: versionDir
+        }
+      }
+    );
+
+    return result.status === 0;
+  } catch (e) {
+    error('依赖安装失败');
+    return false;
+  }
+}
+
+/**
+ * 完整的环境检查和准备流程（三步）
+ */
+function ensureEnvironment(versionDir) {
+  log('检查环境...', 'cyan');
+
+  // 1. 读取环境状态
+  const status = loadEnvStatus();
+
+  // 步骤 1: 检查是否需要准备 Python
+  if (needsPythonSetup(versionDir)) {
+    log('步骤 1/3: 准备 Python 环境', 'yellow');
+
+    if (!setupPython(versionDir)) {
+      error('Python 环境准备失败，无法启动 Kite');
+      markEnvFailed('python_setup_failed');
+      return false;
+    }
+
+    log('Python 环境准备完成', 'green');
+  } else {
+    log('步骤 1/3: Python 环境已就绪', 'green');
+  }
+
+  // 步骤 2: 检查是否需要准备虚拟环境
+  if (needsVenvSetup(status)) {
+    log('步骤 2/3: 准备虚拟环境', 'yellow');
+
+    if (!setupVenv(versionDir)) {
+      error('虚拟环境准备失败，无法启动 Kite');
+      markEnvFailed('venv_setup_failed');
+      return false;
+    }
+
+    log('虚拟环境准备完成', 'green');
+  } else {
+    log('步骤 2/3: 虚拟环境已就绪', 'green');
+  }
+
+  // 步骤 3: 检查是否需要安装依赖
+  if (needsDepsInstall(status)) {
+    log('步骤 3/3: 安装依赖库', 'yellow');
+
+    if (!installDeps(versionDir)) {
+      error('依赖安装失败，无法启动 Kite');
+      markEnvFailed('deps_install_failed');
+      return false;
+    }
+
+    log('依赖安装完成', 'green');
+  } else {
+    log('步骤 3/3: 依赖库已就绪', 'green');
+  }
+
+  log('环境准备完成', 'green');
+  return true;
+}
+
+/**
+ * 标记环境失败（用于异常处理）
+ */
+function markEnvFailed(reason) {
+  const statusFile = getEnvStatusPath();
+  const statusData = {
+    version: '1.0',
+    last_check: new Date().toISOString(),
+    status: 'failed',
+    error: {
+      type: reason,
+      message: '环境准备失败',
+      timestamp: new Date().toISOString()
+    }
+  };
+
+  try {
+    const kiteData = getKiteDataPath();
+    if (!fs.existsSync(kiteData)) {
+      fs.mkdirSync(kiteData, { recursive: true });
+    }
+
+    fs.writeFileSync(statusFile, JSON.stringify(statusData, null, 2));
+  } catch (e) {
+    error(`无法写入状态文件: ${e.message}`);
+  }
+}
+
+module.exports = {
+  ensureEnvironment,
+  loadEnvStatus,
+  needsPythonSetup,
+  needsVenvSetup,
+  needsDepsInstall,
+  setupPython,
+  setupVenv,
+  installDeps,
+  markEnvFailed
+};