@agentunion/kite 1.4.0 → 1.5.0

package/extensions/channels/acp_channel/server.py

@@ -89,7 +89,7 @@ class AcpChannelServer:
         """Single WebSocket session: connect, subscribe, register, ready, receive loop."""
         url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=acp_channel"
         print(f"[acp_channel] Connecting to Kernel (port {self.kernel_port})")
-        async with websockets.connect(url, open_timeout=3, ping_interval=20, ping_timeout=20, close_timeout=10) as ws:
+        async with websockets.connect(url, open_timeout=3, ping_interval=None, close_timeout=10) as ws:
             self._ws = ws
             elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
             elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
@@ -119,17 +119,18 @@ class AcpChannelServer:
 
             # Step 3: Publish module.ready (every reconnect)
             if not self._shutting_down:
+                startup_time = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 await self._rpc_call(ws, "event.publish", {
                     "event_id": str(uuid.uuid4()),
                     "event": "module.ready",
                     "data": {
                         "module_id": "acp_channel",
                         "graceful_shutdown": True,
+                        "startup_time": startup_time,
                     },
                 })
-                elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
-                elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-                print(f"[acp_channel] module.ready published{elapsed_str}")
+                elapsed_str = self._fmt_elapsed(self.boot_t0)
+                print(f"[acp_channel] module.ready published ({elapsed_str})")
 
             # Receive loop
             # CRITICAL: RPC 死锁防范
@@ -138,9 +139,6 @@ class AcpChannelServer:
             # - 如果接收循环被 await handler 阻塞，出站响应永远收不到 → 超时死锁
             # - 事件通知和 RPC 响应可以同步处理（它们不会反向调用 rpc_call）
 
-            # Start heartbeat loop
-            heartbeat_task = asyncio.create_task(self._heartbeat_loop(ws))
-
             async for raw in ws:
                 try:
                     msg = json.loads(raw)
@@ -157,6 +155,11 @@ class AcpChannelServer:
                         event_type = params.get("event", "")
                         data = params.get("data", {})
 
+                        # Handle system.ping event
+                        if event_type == "system.ping":
+                            await self._handle_ping_event(data)
+                            continue
+
                         # Layer 1: 处理订阅的事件
                         if event_type == "module.shutdown":
                             target = data.get("module_id", "")
@@ -223,16 +226,29 @@ class AcpChannelServer:
             msg["params"] = params
         await ws.send(json.dumps(msg))
 
-    async def _heartbeat_loop(self, ws):
-        """Send registry.heartbeat every 30 seconds to prevent TTL expiration."""
-        while True:
-            try:
-                await asyncio.sleep(30)
-                if not self._shutting_down:
-                    await self._rpc_call(ws, "registry.heartbeat", {"module_id": "acp_channel"})
-            except Exception as e:
-                print(f"[acp_channel] Heartbeat error: {e}")
-                break
+    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._rpc_call(self._ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
+            "event": "system.pong",
+            "data": {
+                "module_id": "acp_channel",
+                "ping_time": t1,
+                "pong_time": t2,
+            },
+        })
+
+    def _fmt_elapsed(self, t0: float) -> str:
+        """Format elapsed time since t0."""
+        d = time.monotonic() - t0 if t0 else 0
+        if d < 1:
+            return f"{d * 1000:.0f}ms"
+        if d < 10:
+            return f"{d:.1f}s"
+        return f"{d:.0f}s"
 
     async def _publish_event(self, event: dict):
         """Publish an event via JSON-RPC event.publish."""

package/extensions/services/backup/entry.py

@@ -494,7 +494,7 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
     ws_url = f"ws://127.0.0.1:{kernel_port}/ws?token={token}&id=backup"
     print(f"[backup] Connecting to Kernel: {ws_url}")
 
-    async with websockets.connect(ws_url, open_timeout=5, ping_interval=20, ping_timeout=20, close_timeout=10) as ws:
+    async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
         _ws_global = ws
         print(f"[backup] Connected to Kernel ({_fmt_elapsed(_t0)})")
 
@@ -541,12 +541,14 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
 
         # Publish module.ready (every reconnect)
         if not _shutting_down:
+            startup_time = time.monotonic() - _t0
             await _rpc_call(ws, "event.publish", {
                 "event_id": str(uuid.uuid4()),
                 "event": "module.ready",
                 "data": {
                     "module_id": "backup",
                     "graceful_shutdown": True,
+                    "startup_time": startup_time,
                 },
             })
             print(f"[backup] module.ready published ({_fmt_elapsed(_t0)})")
@@ -554,9 +556,6 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
         # Start test event loop in background
         test_task = asyncio.create_task(_test_event_loop(ws))
 
-        # Start heartbeat loop
-        heartbeat_task = asyncio.create_task(_heartbeat_loop(ws))
-
         # Message loop: handle incoming RPC + events
         # CRITICAL: RPC 死锁防范
         # - 入站 RPC 请求必须用 create_task() 异步执行，不可 await
@@ -592,18 +591,6 @@ async def _rpc_call(ws, method: str, params: dict = None):
     await ws.send(json.dumps(msg))
 
 
-async def _heartbeat_loop(ws):
-    """Send registry.heartbeat every 30 seconds to prevent TTL expiration."""
-    while True:
-        try:
-            await asyncio.sleep(30)
-            if not _shutting_down:
-                await _rpc_call(ws, "registry.heartbeat", {"module_id": "backup"})
-        except Exception as e:
-            print(f"[backup] Heartbeat error: {e}")
-            break
-
-
 async def _publish_event(ws, event: dict):
     """Publish an event via RPC event.publish."""
     await _rpc_call(ws, "event.publish", {
@@ -613,12 +600,32 @@ async def _publish_event(ws, event: dict):
     })
 
 
+async def _handle_ping_event(data: dict):
+    """Handle system.ping event and reply with system.pong."""
+    t1 = data.get("ping_time")
+    t2 = time.time()
+
+    await _publish_event(_ws_global, {
+        "event": "system.pong",
+        "data": {
+            "module_id": MODULE_NAME,
+            "ping_time": t1,
+            "pong_time": t2,
+        },
+    })
+
+
 async def _handle_event_notification(msg: dict):
     """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
     params = msg.get("params", {})
     event_type = params.get("event", "")
     data = params.get("data", {})
 
+    # Handle system.ping event
+    if event_type == "system.ping":
+        await _handle_ping_event(data)
+        return
+
     # Special handling for module.shutdown
     if event_type == "module.shutdown":
         target = data.get("module_id", "")

package/extensions/services/evol/auth_manager.py

@@ -0,0 +1,443 @@
+"""
+认证管理模块 - Token 缓存、验证、吊销
+
+使用 JSONL 格式存储 Token 历史记录，每次变更追加一条记录。
+查询时使用每个 Token 的最新记录。
+"""
+
+import json
+import os
+import secrets
+import time
+from datetime import datetime, timezone
+from typing import Optional
+
+
+class AuthManager:
+    """认证管理器"""
+
+    def __init__(self, data_dir: str):
+        """
+        初始化认证管理器
+
+        Args:
+            data_dir: 数据目录（$KITE_DATA/evol）
+        """
+        self.data_dir = data_dir
+        self.auth_dir = os.path.join(data_dir, "auth")
+        os.makedirs(self.auth_dir, exist_ok=True)
+
+        self.evol_tokens_file = os.path.join(self.auth_dir, "evol_tokens.jsonl")
+        self.kite_tokens_file = os.path.join(self.auth_dir, "kite_tokens.jsonl")
+
+        self.kite_token_ttl = 30 * 24 * 3600  # 30 days
+        self.evol_token_ttl = 7 * 24 * 3600   # 7 days
+        self.token_update_interval = 24 * 3600  # 1 day - Token 更新间隔
+
+        # 内存缓存
+        self._kite_tokens_cache = None
+        self._kite_tokens_cache_time = 0
+        self._evol_tokens_cache = {}  # 改为字典：{phone: record}
+        self._evol_tokens_cache_time = 0
+        self.cache_ttl = 60 * 60  # 1 小时缓存
+
+    def save_evol_token(self, phone: str, token: str, data: dict):
+        """保存 Evol Token 到 JSONL"""
+        now = time.time()
+        record = {
+            "phone": phone,
+            "token": token,
+            "action": "login",
+            "obtainedAt": now,
+            "obtainedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "expiresAt": now + self.evol_token_ttl,
+            "expiresAt_human": datetime.fromtimestamp(now + self.evol_token_ttl, timezone.utc).isoformat(),
+            "lastUsedAt": now,
+            "lastUsedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "userInfo": data.get("userInfo", {}),
+            "accountInfo": data.get("accountInfo", {}),
+            "teamInfo": data.get("teamInfo", {}),
+            "gatewayInfo": data.get("gatewayInfo", {}),
+            "timestamp": now
+        }
+
+        self._append_evol_record(record)
+        # 清除缓存
+        self._evol_tokens_cache = {}
+        self._evol_tokens_cache_time = 0
+
+    def get_evol_token(self, phone: str) -> Optional[dict]:
+        """获取指定手机号的最新 Evol Token（带缓存）"""
+        now = time.time()
+
+        # 检查缓存是否有效
+        if self._evol_tokens_cache and (now - self._evol_tokens_cache_time < self.cache_ttl):
+            return self._evol_tokens_cache.get(phone)
+
+        # 从文件读取所有 Evol Token
+        if not os.path.exists(self.evol_tokens_file):
+            return None
+
+        try:
+            # 按 phone 分组，保留每个 phone 的最新记录
+            phone_tokens = {}
+            with open(self.evol_tokens_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        record = json.loads(line)
+                        record_phone = record.get("phone")
+                        if not record_phone:
+                            continue
+                        # 使用最新的记录（后面的覆盖前面的）
+                        phone_tokens[record_phone] = record
+                    except json.JSONDecodeError:
+                        continue
+
+            # 过滤掉已过期和已登出的 token
+            valid_tokens = {}
+            for p, record in phone_tokens.items():
+                # 检查是否登出
+                if record.get("action") == "logout":
+                    continue
+                # 检查是否过期
+                if time.time() > record.get("expiresAt", 0):
+                    continue
+                valid_tokens[p] = record
+
+            # 更新缓存
+            self._evol_tokens_cache = valid_tokens
+            self._evol_tokens_cache_time = now
+
+            return valid_tokens.get(phone)
+
+        except Exception:
+            return None
+
+    def update_evol_token_usage(self, phone: str):
+        """更新 Evol Token 使用时间（超过 1 天才记录）"""
+        latest_record = self.get_evol_token(phone)
+        if not latest_record:
+            return
+
+        now = time.time()
+        last_used = latest_record.get("lastUsedAt", 0)
+
+        # 如果距离上次使用不到 1 天，不记录
+        if now - last_used < self.token_update_interval:
+            return
+
+        # 追加使用记录
+        record = {
+            "phone": phone,
+            "token": latest_record.get("token"),
+            "action": "used",
+            "obtainedAt": latest_record.get("obtainedAt"),
+            "obtainedAt_human": latest_record.get("obtainedAt_human"),
+            "expiresAt": latest_record.get("expiresAt"),
+            "expiresAt_human": latest_record.get("expiresAt_human"),
+            "lastUsedAt": now,
+            "lastUsedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "userInfo": latest_record.get("userInfo", {}),
+            "accountInfo": latest_record.get("accountInfo", {}),
+            "teamInfo": latest_record.get("teamInfo", {}),
+            "gatewayInfo": latest_record.get("gatewayInfo", {}),
+            "timestamp": now
+        }
+
+        self._append_evol_record(record)
+        # 清除缓存
+        self._evol_tokens_cache = {}
+        self._evol_tokens_cache_time = 0
+
+    def _append_evol_record(self, record: dict):
+        """追加 Evol Token 记录到 JSONL"""
+        try:
+            with open(self.evol_tokens_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(record, ensure_ascii=False) + "\n")
+        except Exception as e:
+            print(f"[auth] Failed to append evol token record: {e}")
+
+    def revoke_evol_token(self, phone: str):
+        """吊销 Evol Token（追加 logout 记录）"""
+        latest_record = self.get_evol_token(phone)
+        if not latest_record:
+            return
+
+        now = time.time()
+        record = {
+            "phone": phone,
+            "token": latest_record.get("token"),
+            "action": "logout",
+            "obtainedAt": latest_record.get("obtainedAt"),
+            "obtainedAt_human": latest_record.get("obtainedAt_human"),
+            "expiresAt": latest_record.get("expiresAt"),
+            "expiresAt_human": latest_record.get("expiresAt_human"),
+            "lastUsedAt": now,
+            "lastUsedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "userInfo": latest_record.get("userInfo", {}),
+            "accountInfo": latest_record.get("accountInfo", {}),
+            "teamInfo": latest_record.get("teamInfo", {}),
+            "gatewayInfo": latest_record.get("gatewayInfo", {}),
+            "timestamp": now
+        }
+
+        self._append_evol_record(record)
+        # 清除缓存
+        self._evol_tokens_cache = {}
+        self._evol_tokens_cache_time = 0
+
+    def generate_kite_token(self, device_info: dict) -> str:
+        """生成 Kite Token 并追加到 JSONL"""
+        token = "kite_" + secrets.token_urlsafe(32)
+        now = time.time()
+
+        record = {
+            "token": token,
+            "deviceId": device_info.get("deviceId", "unknown"),
+            "deviceName": device_info.get("deviceName", "Unknown Device"),
+            "phone": None,  # 初始未绑定手机号
+            "action": "created",
+            "createdAt": now,
+            "createdAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "lastUsedAt": now,
+            "lastUsedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "expiresAt": now + self.kite_token_ttl,
+            "expiresAt_human": datetime.fromtimestamp(now + self.kite_token_ttl, timezone.utc).isoformat(),
+            "isValid": True,
+            "timestamp": now
+        }
+
+        # 追加到 JSONL
+        self._append_token_record(record)
+        # 清除缓存
+        self._kite_tokens_cache = None
+        self._kite_tokens_cache_time = 0
+
+        return token
+
+    def verify_kite_token(self, token: str) -> bool:
+        """验证 Kite Token 并更新使用时间（超过 1 天才记录）"""
+        latest_tokens = self._get_latest_tokens()
+        now = time.time()
+
+        token_info = latest_tokens.get(token)
+        if not token_info:
+            return False
+
+        if not token_info.get("isValid", True):
+            return False
+
+        if now > token_info.get("expiresAt", 0):
+            return False
+
+        # 检查距离上次使用是否超过 1 天
+        last_used = token_info.get("lastUsedAt", 0)
+        if now - last_used < self.token_update_interval:
+            # 不到 1 天，不记录
+            return True
+
+        # 追加使用记录
+        expires_at = now + self.kite_token_ttl
+        record = {
+            "token": token,
+            "deviceId": token_info.get("deviceId"),
+            "deviceName": token_info.get("deviceName"),
+            "phone": token_info.get("phone"),  # 保留绑定的手机号
+            "action": "used",
+            "createdAt": token_info.get("createdAt"),
+            "createdAt_human": token_info.get("createdAt_human"),
+            "lastUsedAt": now,
+            "lastUsedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "expiresAt": expires_at,
+            "expiresAt_human": datetime.fromtimestamp(expires_at, timezone.utc).isoformat(),
+            "isValid": True,
+            "timestamp": now
+        }
+        self._append_token_record(record)
+        # 清除缓存
+        self._kite_tokens_cache = None
+        self._kite_tokens_cache_time = 0
+
+        return True
+
+    def revoke_kite_token(self, token: str):
+        """吊销 Kite Token"""
+        latest_tokens = self._get_latest_tokens()
+        token_info = latest_tokens.get(token)
+
+        if not token_info:
+            return
+
+        now = time.time()
+        record = {
+            "token": token,
+            "deviceId": token_info.get("deviceId"),
+            "deviceName": token_info.get("deviceName"),
+            "phone": token_info.get("phone"),  # 保留绑定的手机号
+            "action": "revoked",
+            "createdAt": token_info.get("createdAt"),
+            "createdAt_human": token_info.get("createdAt_human"),
+            "lastUsedAt": token_info.get("lastUsedAt"),
+            "lastUsedAt_human": token_info.get("lastUsedAt_human"),
+            "expiresAt": token_info.get("expiresAt"),
+            "expiresAt_human": token_info.get("expiresAt_human"),
+            "isValid": False,
+            "timestamp": now
+        }
+        self._append_token_record(record)
+        # 清除缓存
+        self._kite_tokens_cache = None
+        self._kite_tokens_cache_time = 0
+
+    def bind_kite_token_to_phone(self, token: str, phone: str):
+        """绑定 Kite Token 到手机号"""
+        latest_tokens = self._get_latest_tokens()
+        token_info = latest_tokens.get(token)
+
+        if not token_info:
+            raise ValueError(f"Token not found: {token}")
+
+        # 如果已经绑定到同一个手机号，不需要重复记录
+        if token_info.get("phone") == phone:
+            return
+
+        now = time.time()
+        record = {
+            "token": token,
+            "deviceId": token_info.get("deviceId"),
+            "deviceName": token_info.get("deviceName"),
+            "phone": phone,  # 绑定手机号
+            "action": "bound",
+            "createdAt": token_info.get("createdAt"),
+            "createdAt_human": token_info.get("createdAt_human"),
+            "lastUsedAt": now,
+            "lastUsedAt_human": datetime.fromtimestamp(now, timezone.utc).isoformat(),
+            "expiresAt": token_info.get("expiresAt"),
+            "expiresAt_human": token_info.get("expiresAt_human"),
+            "isValid": token_info.get("isValid", True),
+            "timestamp": now
+        }
+        self._append_token_record(record)
+        # 清除缓存
+        self._kite_tokens_cache = None
+        self._kite_tokens_cache_time = 0
+
+    def get_phone_by_kite_token(self, token: str) -> Optional[str]:
+        """根据 Kite Token 获取绑定的手机号"""
+        latest_tokens = self._get_latest_tokens()
+        token_info = latest_tokens.get(token)
+
+        if not token_info:
+            return None
+
+        return token_info.get("phone")
+
+    def list_all_evol_tokens(self) -> list:
+        """列出所有有效的 Evol Token（用于前端显示）"""
+        if not os.path.exists(self.evol_tokens_file):
+            return []
+
+        try:
+            # 按 phone 分组，保留每个 phone 的最新记录
+            phone_tokens = {}
+            with open(self.evol_tokens_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        record = json.loads(line)
+                        record_phone = record.get("phone")
+                        if not record_phone:
+                            continue
+                        # 使用最新的记录（后面的覆盖前面的）
+                        phone_tokens[record_phone] = record
+                    except json.JSONDecodeError:
+                        continue
+
+            # 过滤掉已过期和已登出的 token，返回列表
+            valid_tokens = []
+            for phone, record in phone_tokens.items():
+                # 检查是否登出
+                if record.get("action") == "logout":
+                    continue
+                # 检查是否过期
+                if time.time() > record.get("expiresAt", 0):
+                    continue
+                valid_tokens.append(record)
+
+            return valid_tokens
+
+        except Exception:
+            return []
+
+    def list_devices(self, current_token: str) -> list:
+        """列出所有已配对设备"""
+        latest_tokens = self._get_latest_tokens()
+        devices = []
+
+        for token, info in latest_tokens.items():
+            devices.append({
+                "deviceId": info.get("deviceId"),
+                "deviceName": info.get("deviceName"),
+                "createdAt": info.get("createdAt"),
+                "lastUsedAt": info.get("lastUsedAt"),
+                "expiresAt": info.get("expiresAt"),
+                "isValid": info.get("isValid", True),
+                "isCurrent": token == current_token
+            })
+
+        return devices
+
+    def _get_latest_tokens(self) -> dict:
+        """
+        获取所有 Token 的最新状态（带缓存）
+
+        Returns:
+            {token: latest_record} 字典
+        """
+        now = time.time()
+
+        # 检查缓存是否有效
+        if self._kite_tokens_cache and (now - self._kite_tokens_cache_time < self.cache_ttl):
+            return self._kite_tokens_cache
+
+        # 从文件读取
+        if not os.path.exists(self.kite_tokens_file):
+            return {}
+
+        tokens = {}
+        try:
+            with open(self.kite_tokens_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    try:
+                        record = json.loads(line)
+                        token = record.get("token")
+                        if token:
+                            # 使用最新的记录（后面的覆盖前面的）
+                            tokens[token] = record
+                    except json.JSONDecodeError:
+                        continue
+        except Exception:
+            return {}
+
+        # 更新缓存
+        self._kite_tokens_cache = tokens
+        self._kite_tokens_cache_time = now
+
+        return tokens
+
+    def _append_token_record(self, record: dict):
+        """追加 Token 记录到 JSONL"""
+        try:
+            with open(self.kite_tokens_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(record, ensure_ascii=False) + "\n")
+        except Exception as e:
+            print(f"[auth] Failed to append token record: {e}")