@agentunion/kite 1.4.0 → 1.5.0

package/extensions/services/evol/evol_api.py

@@ -0,0 +1,173 @@
+"""
+Evol API 调用封装
+"""
+
+import asyncio
+import json
+import httpx
+from typing import Optional
+
+
+class EvolAPI:
+    """Evol API 客户端"""
+
+    def __init__(self, base_url: str = "https://api.evolai.cn:8550"):
+        self.base_url = base_url
+        self.timeout = 30.0
+
+    def _log_request(self, method: str, url: str, **kwargs):
+        """记录请求日志"""
+        log_data = {
+            "method": method,
+            "url": url,
+        }
+        if "json" in kwargs:
+            # 隐藏敏感信息
+            data = kwargs["json"].copy()
+            if "code" in data:
+                data["code"] = "***"
+            log_data["body"] = data
+        if "headers" in kwargs:
+            headers = kwargs["headers"].copy()
+            if "Authorization" in headers:
+                headers["Authorization"] = "Bearer ***"
+            log_data["headers"] = headers
+
+        print(f"[evol-api] → {method} {url}")
+        print(f"[evol-api]   Request: {json.dumps(log_data, ensure_ascii=False)}")
+
+    def _log_response(self, url: str, status_code: int, response_data: dict):
+        """记录响应日志"""
+        # 隐藏敏感信息
+        safe_data = response_data.copy() if isinstance(response_data, dict) else {}
+        if "data" in safe_data and isinstance(safe_data["data"], dict):
+            data = safe_data["data"].copy()
+            if "token" in data:
+                data["token"] = data["token"][:20] + "..." if data["token"] else None
+            if "apiKey" in data:
+                data["apiKey"] = data["apiKey"][:10] + "..." if data["apiKey"] else None
+            safe_data["data"] = data
+
+        print(f"[evol-api] ← {status_code} {url}")
+        print(f"[evol-api]   Response: {json.dumps(safe_data, ensure_ascii=False)}")
+
+    def _log_error(self, url: str, error: Exception):
+        """记录错误日志"""
+        print(f"[evol-api] ✗ Error {url}: {type(error).__name__}: {str(error)}")
+
+    async def send_sms(self, phone: str) -> dict:
+        """发送短信验证码"""
+        url = f"{self.base_url}/api/auth/sms/send"
+        data = {
+            "phone": phone,
+            "codeType": "LOGIN"
+        }
+
+        self._log_request("POST", url, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, json=data)
+                result = response.json()
+
+                self._log_response(url, response.status_code, result)
+
+                if result.get("code") == 200:
+                    return {"success": True, "msg": result.get("msg", "验证码发送成功")}
+                else:
+                    return {"success": False, "msg": result.get("msg", "发送失败")}
+
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def verify_sms(self, phone: str, code: str) -> dict:
+        """验证短信并登录"""
+        url = f"{self.base_url}/api/auth/sms/login"
+        data = {
+            "phone": phone,
+            "code": code,
+            "source": "WEB"
+        }
+
+        self._log_request("POST", url, json=data)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, json=data)
+                result = response.json()
+
+                self._log_response(url, response.status_code, result)
+
+                if result.get("code") == 200:
+                    return {
+                        "success": True,
+                        "data": result.get("data", {})
+                    }
+                else:
+                    return {"success": False, "msg": result.get("msg", "验证失败")}
+
+        except Exception as e:
+            self._log_error(url, e)
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    async def get_user_info(self, token: str) -> dict:
+        """获取用户信息（带指数退避重试）"""
+        url = f"{self.base_url}/api/auth/sms/userInfo"
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+
+        max_retries = 6
+        base_delay = 0.5  # 第一次重试间隔 0.5 秒
+
+        for attempt in range(max_retries):
+            self._log_request("GET", url, headers=headers)
+
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    response = await client.get(url, headers=headers)
+                    result = response.json()
+
+                    self._log_response(url, response.status_code, result)
+
+                    if result.get("code") == 200:
+                        data = result.get("data", {})
+                        # API Key 在 gatewayInfo 中
+                        gateway_info = data.get("gatewayInfo", {})
+                        api_key = gateway_info.get("apiKey", "")
+
+                        if api_key:
+                            # 有 API Key，直接返回
+                            return {
+                                "success": True,
+                                "data": data
+                            }
+                        else:
+                            # 没有 API Key，重试几次后也返回（不阻塞登录）
+                            if attempt < 3:  # 只重试 3 次
+                                delay = base_delay * (2 ** attempt)
+                                print(f"[evol-api] API Key not ready, retry {attempt + 1}/3 after {delay}s")
+                                await asyncio.sleep(delay)
+                                continue
+                            else:
+                                # 3 次后放弃等待，返回没有 API Key 的数据
+                                print(f"[evol-api] API Key not available after 3 retries, proceeding without it")
+                                return {
+                                    "success": True,
+                                    "data": data
+                                }
+                    else:
+                        return {"success": False, "msg": result.get("msg", "获取失败")}
+
+            except Exception as e:
+                self._log_error(url, e)
+                if attempt < max_retries - 1:
+                    delay = base_delay * (2 ** attempt)
+                    print(f"[evol-api] Network error, retry {attempt + 1}/{max_retries} after {delay}s: {e}")
+                    await asyncio.sleep(delay)
+                    continue
+                else:
+                    return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+        return {"success": False, "msg": "获取用户信息失败，已达最大重试次数"}

package/extensions/services/evol/evol_config.json5

@@ -0,0 +1,29 @@
+{
+  // Web 服务配置
+  server: {
+    host: "0.0.0.0",
+    port: 18766,
+    ssl: false,
+    // SSL 证书路径（如果启用 SSL）
+    ssl_cert: null,
+    ssl_key: null
+  },
+
+  // 静态文件配置
+  static: {
+    directory: "static",
+    cache_max_age: 3600  // 秒
+  },
+
+  // CORS 配置
+  cors: {
+    enabled: false,
+    origins: ["*"]
+  },
+
+  // 日志配置
+  logging: {
+    level: "INFO",
+    format: "%(asctime)s [%(name)s] %(levelname)s: %(message)s"
+  }
+}

package/extensions/services/evol/migrate_tokens.py

@@ -0,0 +1,122 @@
+"""
+迁移工具：将旧的 token 文件转换为 JSONL 格式
+
+使用方法：
+    python migrate_tokens.py
+"""
+
+import json
+import os
+import sys
+
+
+def migrate_kite_tokens(data_dir: str):
+    """迁移 Kite Token 文件格式"""
+    auth_dir = os.path.join(data_dir, "auth")
+    old_file = os.path.join(auth_dir, "kite_tokens.json")
+    new_file = os.path.join(auth_dir, "kite_tokens.jsonl")
+    backup_file = os.path.join(auth_dir, "kite_tokens.json.backup")
+
+    if not os.path.exists(old_file):
+        print(f"Kite tokens 旧文件不存在: {old_file}")
+        return False
+
+    if os.path.exists(new_file):
+        print(f"Kite tokens 新文件已存在: {new_file}")
+        return False
+
+    try:
+        with open(old_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            tokens = data.get("tokens", [])
+    except Exception as e:
+        print(f"读取 Kite tokens 旧文件失败: {e}")
+        return False
+
+    if not tokens:
+        print("Kite tokens 旧文件中没有记录")
+        return False
+
+    print(f"找到 {len(tokens)} 个 Kite Token 记录")
+
+    try:
+        with open(new_file, "w", encoding="utf-8") as f:
+            for token in tokens:
+                token["action"] = "migrated"
+                token["timestamp"] = token.get("createdAt", 0)
+                f.write(json.dumps(token, ensure_ascii=False) + "\n")
+        print(f"成功写入 Kite tokens 新文件: {new_file}")
+    except Exception as e:
+        print(f"写入 Kite tokens 新文件失败: {e}")
+        return False
+
+    try:
+        os.rename(old_file, backup_file)
+        print(f"Kite tokens 旧文件已备份到: {backup_file}")
+    except Exception as e:
+        print(f"备份 Kite tokens 旧文件失败: {e}")
+
+    return True
+
+
+def migrate_evol_token(data_dir: str):
+    """迁移 Evol Token 文件格式"""
+    auth_dir = os.path.join(data_dir, "auth")
+    old_file = os.path.join(auth_dir, "evol_token.json")
+    new_file = os.path.join(auth_dir, "evol_tokens.jsonl")
+    backup_file = os.path.join(auth_dir, "evol_token.json.backup")
+
+    if not os.path.exists(old_file):
+        print(f"Evol token 旧文件不存在: {old_file}")
+        return False
+
+    if os.path.exists(new_file):
+        print(f"Evol token 新文件已存在: {new_file}")
+        return False
+
+    try:
+        with open(old_file, "r", encoding="utf-8") as f:
+            record = json.load(f)
+    except Exception as e:
+        print(f"读取 Evol token 旧文件失败: {e}")
+        return False
+
+    print(f"找到 Evol Token 记录: {record.get('phone', 'unknown')}")
+
+    try:
+        record["action"] = "migrated"
+        record["timestamp"] = record.get("obtainedAt", 0)
+        record["lastUsedAt"] = record.get("obtainedAt", 0)
+
+        with open(new_file, "w", encoding="utf-8") as f:
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")
+        print(f"成功写入 Evol token 新文件: {new_file}")
+    except Exception as e:
+        print(f"写入 Evol token 新文件失败: {e}")
+        return False
+
+    try:
+        os.rename(old_file, backup_file)
+        print(f"Evol token 旧文件已备份到: {backup_file}")
+    except Exception as e:
+        print(f"备份 Evol token 旧文件失败: {e}")
+
+    return True
+
+
+if __name__ == "__main__":
+    data_dir = os.environ.get("KITE_DATA", os.path.expanduser("~/.kite/data"))
+    evol_data_dir = os.path.join(data_dir, "evol")
+
+    print(f"数据目录: {evol_data_dir}")
+    print()
+
+    kite_ok = migrate_kite_tokens(evol_data_dir)
+    print()
+    evol_ok = migrate_evol_token(evol_data_dir)
+    print()
+
+    if kite_ok or evol_ok:
+        print("迁移完成！")
+    else:
+        print("没有需要迁移的文件")

package/extensions/services/evol/module.md

@@ -0,0 +1,32 @@
+---
+name: evol
+display_name: Evol Account Management
+version: '1.0'
+type: service
+state: enabled
+runtime: python
+entry: entry.py
+preferred_port: 18766
+advertise_ip: 0.0.0.0
+display_order: 90
+businesses:
+  - name: relay_service
+    type: relay
+    description: Kernel WebSocket relay service for web clients
+    config_file: relay_config.json5
+---
+
+# Evol 模块
+
+Evol AI 平台账户管理模块。
+
+## 功能
+
+- 手机号短信登录
+- 用户信息查看
+- 积分监控与统计
+- 设备管理
+
+## 端口
+
+默认端口：18766

package/extensions/services/evol/pairing.py

@@ -0,0 +1,250 @@
+"""
+配对码管理模块
+
+负责配对码的生成、验证、使用和 frontend_token 的管理。
+
+零共享代码依赖 - 此文件可以独立拷贝到其他模块使用。
+"""
+
+import json
+import os
+import secrets
+import string
+import time
+from datetime import datetime, timezone
+from typing import Optional
+
+
+class PairingManager:
+    """配对码管理器"""
+
+    def __init__(self, pairing_file: str, code_length: int = 6, token_expiry: int = 2592000):
+        """
+        初始化配对码管理器。
+
+        Args:
+            pairing_file: 配对码文件路径（JSONL 格式）
+            code_length: 配对码长度（默认 6）
+            token_expiry: frontend_token 有效期（秒，默认 30 天）
+        """
+        self.pairing_file = pairing_file
+        self.code_length = code_length
+        self.token_expiry = token_expiry
+
+        # 临时配对码（未持久化）
+        self.pending_codes = {}  # {code: {"role": "admin", "created_at": timestamp}}
+
+        # 确保文件存在
+        if not os.path.exists(pairing_file):
+            os.makedirs(os.path.dirname(pairing_file), exist_ok=True)
+
+    def generate_pairing_code(self, role: str = "admin") -> str:
+        """
+        生成临时配对码（不持久化）。
+
+        Args:
+            role: 用户角色
+
+        Returns:
+            配对码
+        """
+        code = self._generate_code()
+        self.pending_codes[code] = {
+            "role": role,
+            "created_at": time.time()
+        }
+
+        # 清理过期的配对码（超过 5 分钟）
+        self._cleanup_expired_codes()
+
+        return code
+
+    def _cleanup_expired_codes(self):
+        """清理过期的临时配对码"""
+        now = time.time()
+        expired = [
+            code for code, info in self.pending_codes.items()
+            if now - info["created_at"] > 300  # 5 分钟
+        ]
+        for code in expired:
+            del self.pending_codes[code]
+
+    def _ensure_active_code(self):
+        """确保有 active 状态的配对码，如果没有则生成（已废弃）"""
+        pass
+
+    def _print_pairing_code(self, code: str, is_new: bool):
+        """在控制台绿色高亮显示配对码（已废弃，改为通过事件发送给 Launcher）"""
+        pass
+
+    def _create_initial_code(self):
+        """创建初始配对码（已废弃，由 _ensure_active_code 替代）"""
+        pass
+
+    def _generate_code(self) -> str:
+        """生成随机配对码"""
+        chars = string.ascii_uppercase + string.digits
+        return ''.join(secrets.choice(chars) for _ in range(self.code_length))
+
+    def _generate_token(self) -> str:
+        """生成 frontend_token"""
+        return "tok_" + secrets.token_urlsafe(32)
+
+    def _read_codes(self) -> list[dict]:
+        """读取所有配对码记录"""
+        if not os.path.exists(self.pairing_file):
+            return []
+
+        codes = []
+        with open(self.pairing_file, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    try:
+                        codes.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        pass
+        return codes
+
+    def _write_code(self, code_record: dict):
+        """追加配对码记录"""
+        with open(self.pairing_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(code_record, ensure_ascii=False) + "\n")
+
+    def verify_code(self, code: str) -> Optional[dict]:
+        """
+        验证配对码（包括临时配对码和持久化配对码）。
+
+        Args:
+            code: 配对码
+
+        Returns:
+            如果有效，返回配对码信息（包含 role）；否则返回 None
+        """
+        # 先检查临时配对码
+        if code in self.pending_codes:
+            info = self.pending_codes[code]
+            # 检查是否过期（5 分钟）
+            if time.time() - info["created_at"] < 300:
+                return {"code": code, "role": info["role"], "status": "pending"}
+
+        # 再检查持久化配对码（向后兼容）
+        codes = self._read_codes()
+        for record in reversed(codes):
+            if record.get("code") == code and record.get("status") == "active":
+                return record
+
+        return None
+
+    def pair(self, code: str) -> Optional[dict]:
+        """
+        使用配对码进行配对。
+
+        Args:
+            code: 配对码
+
+        Returns:
+            如果成功，返回 {"token": "...", "role": "..."}；否则返回 None
+        """
+        # 验证配对码
+        code_info = self.verify_code(code)
+        if not code_info:
+            return None
+
+        # 生成 frontend_token
+        token = self._generate_token()
+        role = code_info.get("role", "viewer")
+
+        # 持久化保存 token
+        used_record = {
+            "code": code,
+            "role": role,
+            "status": "used",
+            "token": token,
+            "paired_at": datetime.now(timezone.utc).isoformat(),
+            "expires_at": datetime.fromtimestamp(
+                time.time() + self.token_expiry, tz=timezone.utc
+            ).isoformat()
+        }
+        self._write_code(used_record)
+
+        # 从临时配对码中删除
+        if code in self.pending_codes:
+            del self.pending_codes[code]
+
+        return {
+            "token": token,
+            "role": role,
+            "expires_at": used_record["expires_at"]
+        }
+
+    def verify_token(self, token: str) -> Optional[dict]:
+        """
+        验证 frontend_token。
+
+        Args:
+            token: frontend_token
+
+        Returns:
+            如果有效，返回 {"role": "...", "expires_at": "..."}；否则返回 None
+        """
+        codes = self._read_codes()
+
+        # 检查 token 是否被吊销
+        for record in reversed(codes):
+            if record.get("token") == token and record.get("status") == "revoked":
+                return None  # Token 已被吊销
+
+        # 查找 token 对应的记录
+        for record in reversed(codes):
+            if record.get("token") == token and record.get("status") == "used":
+                # 检查是否过期
+                expires_at = record.get("expires_at")
+                if expires_at:
+                    expire_time = datetime.fromisoformat(expires_at)
+                    if datetime.now(timezone.utc) < expire_time:
+                        return {
+                            "role": record.get("role", "viewer"),
+                            "expires_at": expires_at
+                        }
+
+        return None
+
+    def renew_token(self, old_token: str) -> Optional[str]:
+        """
+        续期 frontend_token。
+
+        Args:
+            old_token: 旧的 frontend_token
+
+        Returns:
+            如果成功，返回新的 token；否则返回 None
+        """
+        # 验证旧 token
+        token_info = self.verify_token(old_token)
+        if not token_info:
+            return None
+
+        # 生成新 token
+        new_token = self._generate_token()
+        role = token_info["role"]
+
+        # 写入新 token 记录
+        new_record = {
+            "token": new_token,
+            "role": role,
+            "status": "used",
+            "renewed_from": old_token,
+            "paired_at": datetime.now(timezone.utc).isoformat(),
+            "expires_at": datetime.fromtimestamp(
+                time.time() + self.token_expiry, tz=timezone.utc
+            ).isoformat()
+        }
+        self._write_code(new_record)
+
+        return new_token
+
+    def get_active_codes(self) -> list[dict]:
+        """获取所有 active 状态的配对码"""
+        codes = self._read_codes()
+        return [c for c in codes if c.get("status") == "active"]

package/extensions/services/evol/pairing_codes.jsonl

@@ -0,0 +1 @@
+{"code": "EAJU5I", "role": "admin", "status": "used", "token": "tok_eO59UiqTxQZvUXKPMkLzV293iwQR2EfU806I_4wjuqc", "paired_at": "2026-03-08T13:25:35.375089+00:00", "expires_at": "2026-04-07T13:25:35.375099+00:00"}