@agentunion/kite 1.4.0 → 1.6.0

package/core/env_checker.py

@@ -0,0 +1,586 @@
+"""
+Kite 环境检查器（版本锁定）
+
+负责检查和准备 Python 运行环境：
+1. 检查 Python 版本是否与 python_version.json 一致
+2. 检查虚拟环境是否存在
+3. 检查依赖库是否与 dependencies_lock.json 一致
+4. 维护状态记录文件 ~/.kite/env_status.json
+
+状态记录机制：
+- 成功时：记录 status = "success"，下次启动跳过检查
+- 失败时：记录 status = "failed" + 结构化错误信息，下次启动进行完整诊断
+"""
+
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+
+def get_kite_data_path() -> Path:
+    """获取 KITE_DATA 路径"""
+    return Path.home() / ".kite"
+
+
+def get_venv_path() -> Path:
+    """获取虚拟环境路径"""
+    return get_kite_data_path() / "venv"
+
+
+def get_status_file_path() -> Path:
+    """获取状态记录文件路径"""
+    return get_kite_data_path() / "env_status.json"
+
+
+def get_requirements_path() -> Path:
+    """获取 requirements.txt 路径（已废弃，使用 dependencies_lock.json）"""
+    return Path(__file__).parent.parent / "requirements.txt"
+
+
+def get_dependencies_lock_path() -> Path:
+    """获取依赖锁定文件路径"""
+    return Path(__file__).parent.parent / "dependencies_lock.json"
+
+
+def get_python_version_file_path() -> Path:
+    """获取 Python 版本文件路径"""
+    return Path(__file__).parent.parent / "python_version.json"
+
+
+def load_dependencies_lock() -> Optional[Dict]:
+    """加载依赖锁定文件"""
+    lock_file = get_dependencies_lock_path()
+
+    if not lock_file.exists():
+        return None
+
+    try:
+        with open(lock_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"[环境检查] 读取依赖锁定文件失败: {e}")
+        return None
+
+
+def get_required_python_version() -> Optional[str]:
+    """获取要求的 Python 版本"""
+    version_file = get_python_version_file_path()
+
+    if not version_file.exists():
+        return None
+
+    try:
+        with open(version_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data.get("version")
+    except Exception as e:
+        print(f"[环境检查] 读取 Python 版本文件失败: {e}")
+        return None
+
+
+def calculate_requirements_hash() -> str:
+    """计算 dependencies_lock.json 的 hash"""
+    lock_file = get_dependencies_lock_path()
+
+    if not lock_file.exists():
+        return ""
+
+    with open(lock_file, "rb") as f:
+        return hashlib.sha256(f.read()).hexdigest()[:16]
+
+
+def load_status() -> Optional[Dict]:
+    """加载状态记录"""
+    status_file = get_status_file_path()
+
+    if not status_file.exists():
+        return None
+
+    try:
+        with open(status_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"[环境检查] 读取状态文件失败: {e}")
+        return None
+
+
+def save_status(status_data: Dict):
+    """保存状态记录"""
+    status_file = get_status_file_path()
+    status_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(status_file, "w", encoding="utf-8") as f:
+        json.dump(status_data, f, indent=2, ensure_ascii=False)
+
+
+def check_python_version() -> Tuple[bool, str, str]:
+    """
+    检查 Python 版本是否与要求一致
+
+    Returns:
+        (is_match, current_version, required_version)
+    """
+    current_version = sys.version_info
+    current_version_str = f"{current_version.major}.{current_version.minor}.{current_version.micro}"
+
+    required_version = get_required_python_version()
+
+    if not required_version:
+        # 没有版本要求文件，降级为 3.8+ 检查
+        if current_version.major == 3 and current_version.minor >= 8:
+            return True, current_version_str, "3.8+"
+        else:
+            return False, current_version_str, "3.8+"
+
+    # 精确版本匹配
+    if current_version_str == required_version:
+        return True, current_version_str, required_version
+    else:
+        return False, current_version_str, required_version
+
+
+def check_venv_exists() -> Tuple[bool, str]:
+    """检查虚拟环境是否存在"""
+    venv_path = get_venv_path()
+
+    if not venv_path.exists():
+        return False, "虚拟环境目录不存在"
+
+    # 检查关键文件
+    if os.name == "nt":  # Windows
+        python_exe = venv_path / "Scripts" / "python.exe"
+        pip_exe = venv_path / "Scripts" / "pip.exe"
+    else:  # Linux / macOS
+        python_exe = venv_path / "bin" / "python"
+        pip_exe = venv_path / "bin" / "pip"
+
+    if not python_exe.exists():
+        return False, "虚拟环境 python 不存在"
+
+    if not pip_exe.exists():
+        return False, "虚拟环境 pip 不存在"
+
+    return True, "虚拟环境正常"
+
+
+def create_venv() -> bool:
+    """创建虚拟环境"""
+    venv_path = get_venv_path()
+
+    print(f"[环境检查] 正在创建虚拟环境: {venv_path}")
+
+    try:
+        venv_path.parent.mkdir(parents=True, exist_ok=True)
+
+        subprocess.run(
+            [sys.executable, "-m", "venv", str(venv_path)],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+
+        print(f"[环境检查] 虚拟环境创建成功")
+        return True
+
+    except subprocess.CalledProcessError as e:
+        print(f"[环境检查] 虚拟环境创建失败: {e.stderr}")
+        return False
+
+
+def get_venv_pip() -> Path:
+    """获取虚拟环境的 pip 路径"""
+    venv_path = get_venv_path()
+
+    if os.name == "nt":  # Windows
+        return venv_path / "Scripts" / "pip.exe"
+    else:  # Linux / macOS
+        return venv_path / "bin" / "pip"
+
+
+def check_dependencies_installed() -> Tuple[bool, str, Dict]:
+    """
+    检查依赖是否与 dependencies_lock.json 一致
+
+    Returns:
+        (all_ok, message, details)
+    """
+    lock_data = load_dependencies_lock()
+
+    if not lock_data:
+        return True, "无依赖锁定文件", {}
+
+    dependencies = lock_data.get("dependencies", {})
+
+    if not dependencies:
+        return True, "无依赖要求", {}
+
+    pip_path = get_venv_pip()
+
+    if not pip_path.exists():
+        return False, "pip 不存在", {}
+
+    # 检查每个依赖（使用虚拟环境的 pip）
+    missing = []
+    version_mismatch = []
+
+    for package_name, package_info in dependencies.items():
+        required_version = package_info.get("version")
+
+        # 使用虚拟环境的 pip show 检查包
+        try:
+            result = subprocess.run(
+                [str(pip_path), "show", package_name],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+
+            if result.returncode != 0:
+                # 包不存在
+                missing.append({
+                    "package": package_name,
+                    "required": required_version
+                })
+            else:
+                # 解析 pip show 输出获取版本
+                installed_version = None
+                for line in result.stdout.split('\n'):
+                    if line.startswith('Version:'):
+                        installed_version = line.split(':', 1)[1].strip()
+                        break
+
+                if installed_version and installed_version != required_version:
+                    version_mismatch.append({
+                        "package": package_name,
+                        "required": required_version,
+                        "installed": installed_version
+                    })
+
+        except subprocess.TimeoutExpired:
+            # 超时视为缺失
+            missing.append({
+                "package": package_name,
+                "required": required_version
+            })
+        except Exception:
+            # 其他错误视为缺失
+            missing.append({
+                "package": package_name,
+                "required": required_version
+            })
+
+    if missing or version_mismatch:
+        details = {
+            "missing": missing,
+            "version_mismatch": version_mismatch
+        }
+
+        msg_parts = []
+        if missing:
+            msg_parts.append(f"{len(missing)} 个缺失")
+        if version_mismatch:
+            msg_parts.append(f"{len(version_mismatch)} 个版本不匹配")
+
+        return False, ", ".join(msg_parts), details
+
+    return True, "依赖正常", {}
+
+
+def verify_imports() -> Tuple[bool, str, list]:
+    """
+    验证关键依赖是否能被 import
+
+    Returns:
+        (all_ok, message, failed_list)
+    """
+    lock_data = load_dependencies_lock()
+
+    if not lock_data:
+        return True, "无依赖锁定文件", []
+
+    dependencies = lock_data.get("dependencies", {})
+
+    if not dependencies:
+        return True, "无依赖要求", []
+
+    # import 名称映射（与 scan_dependencies.py 保持一致）
+    IMPORT_TO_PACKAGE = {
+        'yaml': 'pyyaml',
+        'dotenv': 'python-dotenv',
+        'cv2': 'opencv-python',
+        'PIL': 'pillow',
+        'sklearn': 'scikit-learn',
+        'bs4': 'beautifulsoup4',
+        'dateutil': 'python-dateutil',
+        'OpenSSL': 'pyopenssl',
+        'nacl': 'pynacl',
+        'jwt': 'pyjwt',
+        'Crypto': 'pycryptodome',
+        'magic': 'python-magic',
+        'docx': 'python-docx',
+        'MySQLdb': 'mysqlclient',
+        'psycopg2': 'psycopg2-binary',
+        'bson': 'pymongo',
+        'serial': 'pyserial',
+        'gi': 'pygobject',
+    }
+
+    # 反向映射：package -> import
+    PACKAGE_TO_IMPORT = {v: k for k, v in IMPORT_TO_PACKAGE.items()}
+
+    # 关键依赖（kernel/launcher 必需）
+    critical_packages = {'pyyaml', 'fastapi', 'uvicorn', 'starlette', 'websockets', 'pydantic'}
+
+    failed = []
+
+    for package_name in dependencies.keys():
+        # 只验证关键依赖
+        if package_name not in critical_packages:
+            continue
+
+        # 获取 import 名称
+        import_name = PACKAGE_TO_IMPORT.get(package_name, package_name)
+
+        try:
+            __import__(import_name)
+        except ImportError as e:
+            failed.append({
+                "package": package_name,
+                "import_name": import_name,
+                "error": str(e)
+            })
+        except Exception as e:
+            # 其他异常也记录
+            failed.append({
+                "package": package_name,
+                "import_name": import_name,
+                "error": f"Unexpected error: {e}"
+            })
+
+    if failed:
+        msg = f"{len(failed)} 个关键依赖无法导入"
+        return False, msg, failed
+
+    return True, "导入验证通过", []
+
+
+def install_dependencies() -> bool:
+    """安装依赖（根据 dependencies_lock.json）"""
+    lock_data = load_dependencies_lock()
+
+    if not lock_data:
+        print("[环境检查] 无依赖锁定文件，跳过依赖安装")
+        return True
+
+    dependencies = lock_data.get("dependencies", {})
+
+    if not dependencies:
+        print("[环境检查] 无依赖要求，跳过依赖安装")
+        return True
+
+    pip_path = get_venv_pip()
+
+    if not pip_path.exists():
+        print(f"[环境检查] pip 不存在: {pip_path}")
+        return False
+
+    print(f"[环境检查] 正在安装 {len(dependencies)} 个依赖...")
+
+    # 构建安装列表
+    install_list = [
+        f"{package}=={info['version']}"
+        for package, info in dependencies.items()
+    ]
+
+    try:
+        subprocess.run(
+            [str(pip_path), "install"] + install_list,
+            check=True,
+            capture_output=False,  # 显示安装进度
+            text=True
+        )
+
+        print("[环境检查] 依赖安装完成")
+        return True
+
+    except subprocess.CalledProcessError as e:
+        print(f"[环境检查] 依赖安装失败")
+        return False
+
+
+def run_full_check() -> Tuple[bool, Dict]:
+    """运行完整的环境检查"""
+    print("[环境检查] 开始完整诊断...")
+
+    # 1. 检查 Python 版本
+    py_ok, py_version, required_version = check_python_version()
+    if not py_ok:
+        error_data = {
+            "type": "wrong_version",
+            "message": f"Python 版本不匹配: {py_version}（需要 {required_version}）",
+            "details": {
+                "current": py_version,
+                "required": required_version
+            }
+        }
+        return False, error_data
+
+    print(f"[环境检查] ✓ Python 版本: {py_version}")
+
+    # 2. 检查虚拟环境
+    venv_ok, venv_msg = check_venv_exists()
+    if not venv_ok:
+        print(f"[环境检查] ✗ 虚拟环境: {venv_msg}")
+
+        # 尝试创建虚拟环境
+        if not create_venv():
+            error_data = {
+                "type": "venv_failed",
+                "message": "虚拟环境创建失败",
+                "details": {"reason": venv_msg}
+            }
+            return False, error_data
+
+        venv_ok, venv_msg = check_venv_exists()
+
+    print(f"[环境检查] ✓ 虚拟环境: {venv_msg}")
+
+    # 3. 检查依赖
+    deps_ok, deps_msg, deps_details = check_dependencies_installed()
+    if not deps_ok:
+        print(f"[环境检查] ✗ 依赖库: {deps_msg}")
+
+        if deps_details:
+            if deps_details.get("missing"):
+                print(f"  缺失: {len(deps_details['missing'])} 个")
+            if deps_details.get("version_mismatch"):
+                print(f"  版本不匹配: {len(deps_details['version_mismatch'])} 个")
+
+        # 尝试安装依赖
+        if not install_dependencies():
+            error_data = {
+                "type": "missing_dependencies",
+                "message": "依赖安装失败",
+                "details": deps_details
+            }
+            return False, error_data
+
+        deps_ok, deps_msg, deps_details = check_dependencies_installed()
+
+    print(f"[环境检查] ✓ 依赖库: {deps_msg}")
+
+    # 4. 验证关键依赖能否导入
+    import_ok, import_msg, import_failed = verify_imports()
+    if not import_ok:
+        print(f"[环境检查] ✗ 导入验证: {import_msg}")
+
+        if import_failed:
+            for item in import_failed:
+                print(f"  {item['package']} ({item['import_name']}): {item['error']}")
+
+        error_data = {
+            "type": "import_failed",
+            "message": "关键依赖无法导入",
+            "details": {"failed": import_failed}
+        }
+        return False, error_data
+
+    print(f"[环境检查] ✓ 导入验证: {import_msg}")
+
+    print("[环境检查] 完整诊断通过")
+    return True, {}
+
+
+def should_run_full_check(status: Optional[Dict]) -> Tuple[bool, str]:
+    """判断是否需要运行完整检查"""
+
+    # 1. 状态文件不存在
+    if status is None:
+        return True, "首次运行"
+
+    # 2. 上次检查失败
+    if status.get("status") != "success":
+        return True, "上次检查失败"
+
+    # 3. dependencies_lock.json hash 变化
+    current_hash = calculate_requirements_hash()
+    saved_hash = status.get("dependencies", {}).get("lock_hash", "")
+
+    if current_hash != saved_hash:
+        return True, "依赖锁定文件已更新"
+
+    # 4. 虚拟环境目录被删除
+    venv_ok, _ = check_venv_exists()
+    if not venv_ok:
+        return True, "虚拟环境不存在"
+
+    return False, "环境正常"
+
+
+def check_environment() -> bool:
+    """
+    检查环境是否就绪
+
+    Returns:
+        True if ready, False otherwise
+    """
+    # 1. 加载状态
+    status = load_status()
+
+    # 2. 判断是否需要完整检查
+    need_check, reason = should_run_full_check(status)
+
+    if not need_check:
+        print(f"[环境检查] 跳过检查（{reason}）")
+        return True
+
+    print(f"[环境检查] 需要完整检查（{reason}）")
+
+    # 3. 运行完整检查
+    success, error_data = run_full_check()
+
+    # 4. 保存状态
+    py_ok, py_version, required_version = check_python_version()
+    venv_path = get_venv_path()
+
+    status_data = {
+        "version": "1.0",
+        "last_check": datetime.now(timezone.utc).isoformat(),
+        "status": "success" if success else "failed",
+        "python": {
+            "path": str(venv_path / ("Scripts/python.exe" if os.name == "nt" else "bin/python")),
+            "version": py_version,
+            "required_version": required_version,
+            "system_python": sys.executable
+        },
+        "venv": {
+            "path": str(venv_path),
+            "exists": venv_path.exists(),
+            "valid": success
+        },
+        "dependencies": {
+            "installed": success,
+            "lock_hash": calculate_requirements_hash()
+        },
+        "error": error_data if not success else None
+    }
+
+    save_status(status_data)
+
+    if success:
+        print("[环境检查] 环境就绪")
+    else:
+        print(f"[环境检查] 环境检查失败: {error_data.get('message')}")
+
+    return success
+
+
+if __name__ == "__main__":
+    # 可以单独运行此脚本进行环境检查
+    success = check_environment()
+    sys.exit(0 if success else 1)

package/dependencies_lock.json

@@ -0,0 +1,128 @@
+{
+  "scan_time": "2026-03-08T16:23:35.649703+00:00",
+  "python_version": "3.13.12",
+  "dependencies": {
+    "agentcp": {
+      "version": "0.1.47",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "aiofiles": {
+      "version": "25.1.0",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "aiohttp": {
+      "version": "3.13.3",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "certifi": {
+      "version": "2025.4.26",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "cryptography": {
+      "version": "44.0.3",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "python-dotenv": {
+      "version": "1.1.0",
+      "used_by": [
+        "launcher",
+        "extensions"
+      ]
+    },
+    "fastapi": {
+      "version": "0.124.4",
+      "used_by": [
+        "kernel",
+        "extensions"
+      ]
+    },
+    "flask": {
+      "version": "3.0.0",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "httpx": {
+      "version": "0.28.1",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "json5": {
+      "version": "0.13.0",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "openai": {
+      "version": "1.78.1",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "psutil": {
+      "version": "7.2.2",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "pydantic": {
+      "version": "2.11.4",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "requests": {
+      "version": "2.32.3",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "starlette": {
+      "version": "0.50.0",
+      "used_by": [
+        "kernel",
+        "extensions"
+      ]
+    },
+    "uvicorn": {
+      "version": "0.38.0",
+      "used_by": [
+        "kernel",
+        "extensions"
+      ]
+    },
+    "websocket-client": {
+      "version": "1.8.0",
+      "used_by": [
+        "extensions"
+      ]
+    },
+    "websockets": {
+      "version": "15.0.1",
+      "used_by": [
+        "launcher",
+        "extensions"
+      ]
+    },
+    "pyyaml": {
+      "version": "6.0.3",
+      "used_by": [
+        "kernel",
+        "launcher",
+        "extensions",
+        "kite_cli"
+      ]
+    }
+  }
+}