fody-agent 0.1.0__py3-none-any.whl

fody_agent/bridge/weixin.py

@@ -0,0 +1,615 @@
+"""
+微信桥接模块 —— 通过腾讯 iLink Bot API 接入个人微信
+
+协议参考：https://www.wechatbot.dev/zh/protocol
+
+使用流程:
+    1. 扫码登录 (get_bot_qrcode → 轮询状态 → 获取 bot_token)
+    2. 长轮询拉取消息 (getupdates)
+    3. 调用 Agent 处理消息
+    4. 回复消息 (sendmessage)
+"""
+
+import asyncio
+import base64
+import json
+import os
+import random
+import struct
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Awaitable, Callable, Union
+
+import aiohttp
+
+from fody_agent.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+ILINK_BASE_URL = "https://ilinkai.weixin.qq.com"
+ILINK_CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c"
+POLL_TIMEOUT = 35  # 长轮询超时时间（秒）
+POLL_INTERVAL = 2  # 临时错误重试间隔（秒）
+MAX_POLL_RETRY = 3  # 连续临时错误重试次数
+
+CREDENTIALS_DIR = Path.home() / ".fody" / "weixin"
+CREDENTIALS_FILE = CREDENTIALS_DIR / "credentials.json"
+CONTEXT_TOKENS_FILE = CREDENTIALS_DIR / "context_tokens.json"
+
+
+@dataclass
+class WeChatCredentials:
+    """微信 iLink Bot 登录凭证"""
+
+    bot_token: str
+    account_id: str
+    user_id: str
+    base_url: str = ILINK_BASE_URL
+    created_at: float = field(default_factory=time.time)
+
+
+@dataclass
+class WeChatMessage:
+    """微信消息"""
+
+    msg_id: str
+    from_user: str
+    content: str
+    context_token: str
+    msg_type: int = 1  # 1=文本
+    timestamp: int = 0
+
+
+def _random_uin() -> str:
+    """生成随机的 X-WECHAT-UIN 头"""
+    uin = random.getrandbits(32)
+    uin_bytes = struct.pack("<I", uin)
+    return base64.b64encode(uin_bytes).decode()
+
+
+def _build_headers(bot_token: str) -> dict:
+    """构建 iLink API 通用请求头"""
+    return {
+        "Content-Type": "application/json",
+        "AuthorizationType": "ilink_bot_token",
+        "Authorization": f"Bearer {bot_token}",
+        "X-WECHAT-UIN": _random_uin(),
+    }
+
+
+def _save_credentials(creds: WeChatCredentials):
+    """保存登录凭证到磁盘"""
+    CREDENTIALS_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CREDENTIALS_FILE, "w", encoding="utf-8") as f:
+        json.dump(
+            {
+                "bot_token": creds.bot_token,
+                "account_id": creds.account_id,
+                "user_id": creds.user_id,
+                "base_url": creds.base_url,
+                "created_at": creds.created_at,
+            },
+            f,
+            ensure_ascii=False,
+            indent=2,
+        )
+    # Windows 没有 chmod，仅确保文件存在
+    logger.info("凭证已保存到 %s", CREDENTIALS_FILE)
+
+
+def _load_credentials() -> WeChatCredentials | None:
+    """从磁盘加载登录凭证"""
+    if not CREDENTIALS_FILE.exists():
+        return None
+    try:
+        with open(CREDENTIALS_FILE, encoding="utf-8") as f:
+            data = json.load(f)
+        return WeChatCredentials(
+            bot_token=data["bot_token"],
+            account_id=data["account_id"],
+            user_id=data.get("user_id", ""),
+            base_url=data.get("base_url", ILINK_BASE_URL),
+            created_at=data.get("created_at", 0),
+        )
+    except (json.JSONDecodeError, KeyError) as e:
+        logger.warning("凭证文件损坏: %s", e)
+        return None
+
+
+def _load_context_tokens() -> dict[str, str]:
+    """加载缓存的 context_token 映射"""
+    if not CONTEXT_TOKENS_FILE.exists():
+        return {}
+    try:
+        with open(CONTEXT_TOKENS_FILE, encoding="utf-8") as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        return {}
+
+
+def _save_context_tokens(tokens: dict[str, str]):
+    """保存 context_token 映射到磁盘"""
+    CREDENTIALS_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONTEXT_TOKENS_FILE, "w", encoding="utf-8") as f:
+        json.dump(tokens, f, ensure_ascii=False, indent=2)
+
+
+async def login_qr(
+    session: aiohttp.ClientSession,
+    base_url: str = ILINK_BASE_URL,
+) -> WeChatCredentials:
+    """扫码登录流程：获取二维码 → 轮询扫码状态 → 获取凭证"""
+    print("\n正在获取微信登录二维码...")
+
+    # Step 1: 获取二维码
+    qr_url = f"{base_url}/ilink/bot/get_bot_qrcode?bot_type=3"
+    async with session.get(qr_url) as resp:
+        if resp.status != 200:
+            raise RuntimeError(f"获取二维码失败: HTTP {resp.status}")
+        data = await resp.json()
+        qrcode_key = data.get("qrcode") or data.get("qrcode_key", "")
+        qrcode_img = data.get("qrcode_img_content", "")
+
+    if not qrcode_key:
+        raise RuntimeError("二维码数据为空")
+
+    # Step 2: 尝试显示二维码
+    try:
+        import qrcode as qrcode_lib
+
+        qr = qrcode_lib.QRCode(border=1)
+        qr.add_data(qrcode_img or qrcode_key)
+        qr.make(fit=True)
+        qr.print_ascii(invert=True)
+    except ImportError:
+        # 没有 qrcode 库，打印 URL
+        print(f"请打开链接扫描二维码: {qrcode_img or qrcode_key}")
+
+    print("\n请使用手机微信扫描上方二维码...")
+    print("（等待扫码确认中，二维码有效期为几分钟）\n")
+
+    # Step 3: 轮询扫码状态
+    status_url = f"{base_url}/ilink/bot/get_qrcode_status"
+    consecutive_errors = 0
+    refresh_count = 0
+
+    while refresh_count < 3:
+        try:
+            async with session.get(
+                f"{status_url}?qrcode={qrcode_key}",
+                headers={"iLink-App-ClientVersion": "1"},
+                timeout=45,
+            ) as resp:
+                status_data = await resp.json()
+        except (asyncio.TimeoutError, aiohttp.ClientError) as e:
+            consecutive_errors += 1
+            if consecutive_errors >= MAX_POLL_RETRY:
+                raise RuntimeError("二维码状态轮询多次失败") from e
+            await asyncio.sleep(POLL_INTERVAL)
+            continue
+
+        consecutive_errors = 0
+        status = status_data.get("status", "")
+
+        if status == "wait":
+            print("  等待扫码...")
+            await asyncio.sleep(1.5)
+        elif status == "scaned":
+            print("  已扫码，请在手机上确认登录...")
+            await asyncio.sleep(1.5)
+        elif status == "confirmed":
+            bot_token = status_data.get("bot_token", "")
+            account_id = status_data.get("ilink_bot_id", "")
+            user_id = status_data.get("ilink_user_id", "")
+            baseurl = status_data.get("baseurl", base_url)
+
+            if not bot_token or not account_id:
+                raise RuntimeError("登录确认但未返回完整凭证")
+
+            print(f"\n✅ 微信登录成功！")
+            print(f"   账号 ID: {account_id}")
+            print(f"   用户 ID: {user_id}")
+
+            creds = WeChatCredentials(
+                bot_token=bot_token,
+                account_id=account_id,
+                user_id=user_id,
+                base_url=baseurl,
+            )
+            _save_credentials(creds)
+            return creds
+        elif status == "expired":
+            refresh_count += 1
+            print(f"  二维码已过期，重新获取 ({refresh_count}/3)...")
+            async with session.get(qr_url) as resp2:
+                data2 = await resp2.json()
+                qrcode_key = data2.get("qrcode") or data2.get("qrcode_key", "")
+                qrcode_img = data2.get("qrcode_img_content", "")
+                if qrcode_img or qrcode_key:
+                    try:
+                        import qrcode as qrcode_lib
+
+                        qr = qrcode_lib.QRCode(border=1)
+                        qr.add_data(qrcode_img or qrcode_key)
+                        qr.make(fit=True)
+                        qr.print_ascii(invert=True)
+                    except ImportError:
+                        print(f"请打开链接扫描二维码: {qrcode_img or qrcode_key}")
+                    print("\n请使用手机微信扫描新二维码...")
+        else:
+            # 未知状态，继续轮询
+            await asyncio.sleep(1)
+
+    raise RuntimeError("二维码多次过期，登录失败")
+
+
+async def send_text(
+    session: aiohttp.ClientSession,
+    bot_token: str,
+    to_user_id: str,
+    text: str,
+    context_token: str,
+    base_url: str = ILINK_BASE_URL,
+) -> bool:
+    """发送文本消息"""
+    # 消息分块（微信限制约 4000 字符）
+    max_len = 3900
+    if len(text) > max_len:
+        chunks = _chunk_text(text, max_len)
+        for i, chunk in enumerate(chunks):
+            if i > 0:
+                await asyncio.sleep(0.3)  # 避免频率限制
+            await _send_single_text(session, bot_token, to_user_id, chunk, context_token, base_url)
+        return True
+    return await _send_single_text(session, bot_token, to_user_id, text, context_token, base_url)
+
+
+async def _send_single_text(
+    session: aiohttp.ClientSession,
+    bot_token: str,
+    to_user_id: str,
+    text: str,
+    context_token: str,
+    base_url: str = ILINK_BASE_URL,
+) -> bool:
+    """发送单条文本消息"""
+    url = f"{base_url}/ilink/bot/sendmessage"
+    headers = _build_headers(bot_token)
+    payload = {
+        "base_info": {"channel_version": "2.0.0"},
+        "msg": {
+            "to_user_id": to_user_id,
+            "context_token": context_token,
+            "item_list": [{"type": 1, "text_item": {"text": text}}],
+        },
+    }
+
+    async with session.post(url, json=payload, headers=headers) as resp:
+        if resp.status == 200:
+            return True
+        body = await resp.text()
+        logger.warning("发送消息失败: HTTP %s, body=%s", resp.status, body)
+        return False
+
+
+def _chunk_text(text: str, max_len: int) -> list[str]:
+    """智能分块，在段落边界处拆分"""
+    if len(text) <= max_len:
+        return [text]
+
+    chunks = []
+    paragraphs = text.split("\n\n")
+    current = ""
+
+    for para in paragraphs:
+        if len(current) + len(para) + 2 <= max_len:
+            current = (current + "\n\n" + para) if current else para
+        else:
+            if current:
+                chunks.append(current)
+            # 如果一个段落本身就超长，按句子拆分
+            if len(para) > max_len:
+                for i in range(0, len(para), max_len):
+                    chunks.append(para[i : i + max_len])
+            else:
+                current = para
+
+    if current:
+        chunks.append(current)
+
+    return chunks
+
+
+async def send_typing(
+    session: aiohttp.ClientSession,
+    bot_token: str,
+    to_user_id: str,
+    typing_ticket: str,
+    status: int = 1,
+    base_url: str = ILINK_BASE_URL,
+) -> bool:
+    """发送正在输入状态"""
+    url = f"{base_url}/ilink/bot/sendtyping"
+    headers = _build_headers(bot_token)
+    payload = {
+        "base_info": {"channel_version": "2.0.0"},
+        "to_user_id": to_user_id,
+        "typing_ticket": typing_ticket,
+        "status": status,
+    }
+
+    async with session.post(url, json=payload, headers=headers) as resp:
+        return resp.status == 200
+
+
+async def get_typing_ticket(
+    session: aiohttp.ClientSession,
+    bot_token: str,
+    to_user_id: str,
+    base_url: str = ILINK_BASE_URL,
+) -> str | None:
+    """获取用户的 typing ticket"""
+    url = f"{base_url}/ilink/bot/getconfig"
+    headers = _build_headers(bot_token)
+    payload = {
+        "base_info": {"channel_version": "2.0.0"},
+        "to_user_id": to_user_id,
+    }
+
+    async with session.post(url, json=payload, headers=headers) as resp:
+        if resp.status == 200:
+            data = await resp.json()
+            return data.get("typing_ticket")
+        return None
+
+
+class WeChatBridge:
+    """微信 iLink Bot 桥接器
+
+    管理扫码登录、长轮询收消息、调用 Agent 处理、回复的完整生命周期。
+    """
+
+    def __init__(
+        self,
+        provider: str = "",
+        model: str = "",
+        dm_policy: str = "open",
+        allowed_users: list[str] | None = None,
+    ):
+        self._provider = provider
+        self._model = model
+        self._dm_policy = dm_policy
+        self._allowed_users = allowed_users or []
+        self._creds: WeChatCredentials | None = None
+        self._context_tokens: dict[str, str] = {}
+        self._session: aiohttp.ClientSession | None = None
+        self._running = False
+        self._msg_dedup: set[str] = set()  # 5分钟去重窗口
+        self._typing_cache: dict[str, str] = {}  # user_id -> typing_ticket
+        self._on_message: Callable[[WeChatMessage], Union[str, None, Awaitable[str | None]]] | None = None
+
+    @property
+    def is_logged_in(self) -> bool:
+        return self._creds is not None
+
+    async def login(self, force: bool = False):
+        """登录微信，如有缓存凭证则复用"""
+        if not force:
+            self._creds = _load_credentials()
+            if self._creds:
+                print(f"  使用缓存的登录凭证（账号: {self._creds.account_id}）")
+                return
+
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+
+        self._creds = await login_qr(self._session)
+        self._context_tokens = _load_context_tokens()
+
+    async def logout(self):
+        """清除登录凭证"""
+        self._creds = None
+        if CREDENTIALS_FILE.exists():
+            CREDENTIALS_FILE.unlink()
+        print("已清除登录凭证")
+
+    async def run(
+        self,
+        on_message: Callable[[WeChatMessage], Union[str, None, Awaitable[str | None]]] | None = None,
+    ):
+        """启动消息监听循环
+
+        Args:
+            on_message: 消息处理回调，接收 WeChatMessage，返回回复文本（None 表示不回复）
+        """
+        if not self._creds:
+            raise RuntimeError("尚未登录，请先调用 login()")
+
+        self._on_message = on_message
+        self._running = True
+
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+
+        print("\n开始监听微信消息...（按 Ctrl+C 停止）\n")
+
+        updates_buf = ""
+        consecutive_errors = 0
+
+        while self._running:
+            try:
+                updates_buf = await self._poll_updates(updates_buf)
+                consecutive_errors = 0
+            except SessionExpiredError:
+                print("\n⚠️ 会话已过期，需要重新登录")
+                self._creds = None
+                break
+            except Exception as e:
+                consecutive_errors += 1
+                wait = min(consecutive_errors * 2, 30)
+                logger.warning("消息轮询异常（第%d次）: %s，%ds后重试", consecutive_errors, e, wait)
+                await asyncio.sleep(wait)
+
+        self._running = False
+
+    async def stop(self):
+        """停止监听循环"""
+        self._running = False
+
+    async def _poll_updates(self, updates_buf: str) -> str:
+        """执行一次长轮询，返回新的 updates_buf"""
+        if not self._creds:
+            raise SessionExpiredError("未登录")
+
+        url = f"{self._creds.base_url}/ilink/bot/getupdates"
+        headers = _build_headers(self._creds.bot_token)
+        payload = {
+            "base_info": {"channel_version": "2.0.0"},
+            "get_updates_buf": updates_buf,
+        }
+
+        async with self._session.post(
+            url, json=payload, headers=headers, timeout=POLL_TIMEOUT + 10
+        ) as resp:
+            data = await resp.json()
+
+        # 检查会话过期
+        errcode = data.get("errcode", 0) or data.get("ret", 0)
+        if errcode == -14:
+            raise SessionExpiredError("会话已过期")
+
+        new_buf = data.get("get_updates_buf", updates_buf)
+        messages = data.get("messages", data.get("data", []))
+
+        for msg_data in messages:
+            await self._handle_message(msg_data)
+
+        return new_buf
+
+    async def _handle_message(self, msg_data: dict):
+        """处理单条消息"""
+        try:
+            msg_id = str(msg_data.get("msg_id", ""))
+            from_user = msg_data.get("from_user", "")
+            content = ""
+            context_token = msg_data.get("context_token", "")
+            msg_type = msg_data.get("msg_type", 0)
+
+            # 提取文本内容
+            item_list = msg_data.get("item_list", [])
+            for item in item_list:
+                if item.get("type") == 1:  # 文本
+                    text_item = item.get("text_item", {})
+                    content = text_item.get("text", "")
+                elif item.get("type") == 2:  # 图片
+                    content = "[图片]"
+                elif item.get("type") == 3:  # 文件
+                    content = f"[文件: {item.get('file_item', {}).get('name', '未知')}]"
+
+            if not msg_id or not from_user:
+                return
+
+            # 去重检查（5分钟滑动窗口）
+            if msg_id in self._msg_dedup:
+                return
+            self._msg_dedup.add(msg_id)
+            # 保持去重集合不超过 1000 项
+            if len(self._msg_dedup) > 1000:
+                self._msg_dedup.clear()
+
+            # 访问策略检查
+            if self._dm_policy == "disabled":
+                return
+            if self._dm_policy == "allowlist" and from_user not in self._allowed_users:
+                logger.info("忽略来自 %s 的消息（不在白名单中）", from_user)
+                return
+
+            message = WeChatMessage(
+                msg_id=msg_id,
+                from_user=from_user,
+                content=content,
+                context_token=context_token,
+                msg_type=msg_type,
+            )
+
+            # 更新 context_token 缓存
+            self._context_tokens[from_user] = context_token
+            _save_context_tokens(self._context_tokens)
+
+            # 打印收到消息
+            print(f"\n[微信消息] 来自 {from_user}: {content[:100]}")
+
+            # 显示正在输入
+            typing_ticket = self._typing_cache.get(from_user)
+            if not typing_ticket:
+                typing_ticket = await get_typing_ticket(
+                    self._session, self._creds.bot_token, from_user, self._creds.base_url
+                )
+                if typing_ticket:
+                    self._typing_cache[from_user] = typing_ticket
+
+            if typing_ticket:
+                await send_typing(
+                    self._session, self._creds.bot_token, from_user, typing_ticket, 1, self._creds.base_url
+                )
+
+            # 调用消息处理回调（支持同步和异步）
+            if self._on_message:
+                try:
+                    result = self._on_message(message)
+                    if isinstance(result, Awaitable):
+                        reply = await result
+                    else:
+                        reply = result
+                except Exception as e:
+                    logger.exception("消息处理回调异常")
+                    reply = f"处理消息时出错: {e}"
+
+                # 停止输入状态
+                if typing_ticket:
+                    await send_typing(
+                        self._session,
+                        self._creds.bot_token,
+                        from_user,
+                        typing_ticket,
+                        2,
+                        self._creds.base_url,
+                    )
+
+                # 发送回复
+                if reply:
+                    success = await send_text(
+                        self._session,
+                        self._creds.bot_token,
+                        from_user,
+                        reply,
+                        context_token,
+                        self._creds.base_url,
+                    )
+                    if success:
+                        print(f"  → 已回复: {reply[:100]}...")
+                    else:
+                        print("  → 回复发送失败")
+
+        except Exception as e:
+            logger.exception("处理消息异常")
+
+    async def close(self):
+        """关闭桥接器，释放资源"""
+        self._running = False
+        if self._session:
+            await self._session.close()
+            self._session = None
+
+    async def __aenter__(self):
+        self._session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()
+
+
+class SessionExpiredError(Exception):
+    """会话过期异常"""
+    pass