callback_adapter.py 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315
  1. """WeCom callback-mode adapter (self-built apps): decrypt POSTed XML, queue for the agent, ack at once;
  2. reply later via proactive ``message/send``. Multiple apps are scoped by ``corp_id:user_id``."""
  3. from __future__ import annotations
  4. import asyncio
  5. import logging
  6. import socket as _socket
  7. import time
  8. from typing import Any, Dict, List, Optional
  9. # Untrusted pre-auth bodies are parsed with defusedxml (billion-laughs / XXE).
  10. try:
  11. import defusedxml.ElementTree as ET
  12. DEFUSEDXML_AVAILABLE = True
  13. except ImportError:
  14. ET = None # type: ignore[assignment]
  15. DEFUSEDXML_AVAILABLE = False
  16. try:
  17. from aiohttp import web
  18. AIOHTTP_AVAILABLE = True
  19. except ImportError:
  20. web = None # type: ignore[assignment]
  21. AIOHTTP_AVAILABLE = False
  22. try:
  23. import httpx
  24. HTTPX_AVAILABLE = True
  25. except ImportError:
  26. httpx = None # type: ignore[assignment]
  27. HTTPX_AVAILABLE = False
  28. from gateway.config import Platform, PlatformConfig
  29. from gateway.platforms.base import BasePlatformAdapter, SendResult
  30. from gateway.platforms.event import MessageEvent, MessageType
  31. from gateway.platforms.helpers import MessageDeduplicator, send_chunks
  32. from plugins.platforms.wecom.wecom_crypto import WXBizMsgCrypt, WeComCryptoError
  33. logger = logging.getLogger(__name__)
  34. DEFAULT_HOST = None # dual-stack bind ("0.0.0.0" broke IPv6-only); pin via extra.host
  35. DEFAULT_PORT = 8645
  36. DEFAULT_PATH = "/wecom/callback"
  37. _MAX_BODY = 65_536 # pre-auth body cap: callbacks are small encrypted XML envelopes
  38. ACCESS_TOKEN_TTL_SECONDS = 7200
  39. MESSAGE_DEDUP_TTL_SECONDS = 300
  40. _SEND_URL = "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token="
  41. _TOKEN_URL = "https://qyapi.weixin.qq.com/cgi-bin/gettoken"
  42. def _utf8_len(text: str) -> int:
  43. return len(text.encode("utf-8"))
  44. def check_wecom_callback_requirements() -> bool:
  45. """PASSIVE probe (registry ``check_fn``) — must never install anything."""
  46. return AIOHTTP_AVAILABLE and HTTPX_AVAILABLE and DEFUSEDXML_AVAILABLE
  47. def ensure_wecom_callback_requirements() -> bool:
  48. """ACTIVE lazy-installer (``ensure_deps_fn``): installs ``defusedxml`` and rebinds globals.
  49. Registered as ``ensure_deps_fn``: the registry's ``create_adapter()`` runs it when the passive probe
  50. fails, right before the gateway connects the platform (#79812). Installs ``defusedxml`` (the only
  51. non-core dep; aiohttp/httpx ship with every messaging install) and rebinds the module globals. Before
  52. this hook existed, the passive ``check_fn`` returned False forever on installs without the ``wecom``
  53. extra and the ``platform.wecom_callback`` LAZY_DEPS entry was never exercised.
  54. """
  55. if check_wecom_callback_requirements():
  56. return True
  57. def _import() -> dict:
  58. import defusedxml.ElementTree as _ET
  59. return {"ET": _ET, "DEFUSEDXML_AVAILABLE": True}
  60. try:
  61. from pm.extras import ensure_and_bind
  62. except Exception: # pragma: no cover — defensive
  63. return False
  64. if not ensure_and_bind("wecom", _import, globals()):
  65. return False
  66. return check_wecom_callback_requirements()
  67. def _ack():
  68. return web.Response(text="success", content_type="text/plain")
  69. class WecomCallbackAdapter(BasePlatformAdapter):
  70. # Answers /p/<profile>/... on the default listener for a served secondary (shared_ingress).
  71. serves_profile_prefix: bool = True
  72. # message/send keeps only the first 2048 BYTES of text.content and drops the rest silently.
  73. MAX_MESSAGE_LENGTH = 2048
  74. splits_long_messages = True # send() chunks via truncate_message(MAX_MESSAGE_LENGTH, _utf8_len)
  75. def __init__(self, config: PlatformConfig):
  76. super().__init__(config, Platform.WECOM_CALLBACK)
  77. extra = config.extra or {}
  78. _raw_host = extra.get("host") or DEFAULT_HOST
  79. self._host = str(_raw_host) if _raw_host else None
  80. self._port = int(extra.get("port") or DEFAULT_PORT)
  81. self._path = str(extra.get("path") or DEFAULT_PATH)
  82. self._apps: list[dict[str, Any]] = self._normalize_apps(extra)
  83. self._runner = self._site = self._app = self._http_client = self._poll_task = None
  84. self._message_queue: asyncio.Queue[MessageEvent] = asyncio.Queue()
  85. self._dedup = MessageDeduplicator(ttl_seconds=MESSAGE_DEDUP_TTL_SECONDS)
  86. self._user_app_map: dict[str, str] = {}
  87. self._access_tokens: dict[str, dict[str, Any]] = {}
  88. @staticmethod
  89. def _user_app_key(corp_id: str, user_id: str) -> str:
  90. return f"{corp_id}:{user_id}" if corp_id else user_id
  91. @staticmethod
  92. def _normalize_apps(extra: dict[str, Any]) -> list[dict[str, Any]]:
  93. apps = extra.get("apps")
  94. if isinstance(apps, list) and apps:
  95. return [dict(app) for app in apps if isinstance(app, dict)]
  96. if extra.get("corp_id"):
  97. return [{"name": extra.get("name") or "default", "corp_id": extra.get("corp_id", ""), "corp_secret": extra.get("corp_secret", ""),
  98. "agent_id": str(extra.get("agent_id", "")), "token": extra.get("token", ""), "encoding_aes_key": extra.get("encoding_aes_key", "")}]
  99. return []
  100. async def connect(self, *, is_reconnect: bool = False) -> bool:
  101. del is_reconnect # kwarg MUST exist (GatewayRunner passes it) even though unused
  102. if not self._apps:
  103. logger.warning("[WecomCallback] No callback apps configured")
  104. return False
  105. if not check_wecom_callback_requirements():
  106. logger.warning("[WecomCallback] aiohttp/httpx not installed")
  107. return False
  108. from gateway.platforms.shared_ingress import bind_listener, shared_ingress_profile
  109. if not shared_ingress_profile(self):
  110. try: # quick port-in-use check
  111. with _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) as sock:
  112. sock.settimeout(1)
  113. sock.connect(("127.0.0.1", self._port))
  114. logger.error("[WecomCallback] Port %d already in use", self._port)
  115. return False
  116. except (ConnectionRefusedError, OSError):
  117. pass
  118. try:
  119. # Tighter keepalive so idle CLOSE_WAIT drains promptly (#18451).
  120. from gateway.platforms._http_client_limits import platform_httpx_limits
  121. self._http_client = httpx.AsyncClient(timeout=20.0, limits=platform_httpx_limits())
  122. # client_max_size → 413 before our handler / any signature work runs.
  123. self._app = web.Application(client_max_size=_MAX_BODY)
  124. self._app.router.add_get("/health", self._handle_health)
  125. self._app.router.add_get(self._path, self._handle_verify)
  126. self._app.router.add_post(self._path, self._handle_callback)
  127. # Shared-listener mode (multiplex secondary): no bind; served at /p/<profile>/<path>.
  128. self._runner = await bind_listener(self, self._app, self._host, self._port, self._path)
  129. self._poll_task = asyncio.create_task(self._poll_loop())
  130. self._mark_connected()
  131. if self._runner is not None:
  132. logger.info("[WecomCallback] HTTP server listening on %s:%s%s", self._host, self._port, self._path)
  133. for app in self._apps:
  134. try:
  135. await self._refresh_access_token(app)
  136. except Exception as exc:
  137. logger.warning("[WecomCallback] Initial token refresh failed for app '%s': %s", app.get("name", "default"), exc)
  138. return True
  139. except Exception:
  140. await self._cleanup()
  141. logger.exception("[WecomCallback] Failed to start")
  142. return False
  143. async def disconnect(self) -> None:
  144. self._running = False
  145. if self._poll_task:
  146. self._poll_task.cancel()
  147. try:
  148. await self._poll_task
  149. except asyncio.CancelledError:
  150. pass
  151. self._poll_task = None
  152. await self._cleanup()
  153. self._mark_disconnected()
  154. logger.info("[WecomCallback] Disconnected")
  155. async def _cleanup(self) -> None:
  156. self._site = None
  157. if self._runner:
  158. await self._runner.cleanup()
  159. self._runner = self._app = None
  160. if self._http_client:
  161. await self._http_client.aclose()
  162. self._http_client = None
  163. async def send(self, chat_id: str, content: str, reply_to: Optional[str] = None, metadata: Optional[dict[str, Any]] = None) -> SendResult:
  164. """One text message per MAX_MESSAGE_LENGTH-byte chunk; stops at the first failure."""
  165. app = self._resolve_app_for_chat(chat_id)
  166. chunks = self.truncate_message(content, self.MAX_MESSAGE_LENGTH, len_fn=_utf8_len)
  167. return await send_chunks(chunks, lambda chunk: self._send_text(app, chat_id, chunk))
  168. async def _send_text(self, app: dict[str, Any], chat_id: str, content: str) -> SendResult:
  169. try:
  170. payload = {"touser": chat_id.split(":", 1)[-1], "msgtype": "text", "agentid": int(str(app.get("agent_id") or 0)), "text": {"content": content}, "safe": 0}
  171. for _attempt in range(2):
  172. token = await self._get_access_token(app)
  173. resp = await self._http_client.post(f"{_SEND_URL}{token}", json=payload)
  174. data = resp.json()
  175. errcode = data.get("errcode")
  176. if errcode in {40001, 42001} and _attempt == 0: # token rejected — evict so the retry fetches a fresh one
  177. logger.warning("[WecomCallback] Token rejected for app '%s' (errcode=%s), refreshing", app.get("name", "default"), errcode)
  178. self._access_tokens.pop(app["name"], None)
  179. continue
  180. return SendResult(success=True, message_id=str(data.get("msgid", "")), raw_response=data) if errcode == 0 else SendResult(success=False, error=str(data))
  181. return SendResult(success=False, error="send failed after token refresh")
  182. except Exception as exc:
  183. return SendResult(success=False, error=str(exc))
  184. def _resolve_app_for_chat(self, chat_id: str) -> dict[str, Any]:
  185. app_name = self._user_app_map.get(chat_id)
  186. if not app_name and ":" not in chat_id: # legacy bare user_id — unique match only
  187. matching = [k for k in self._user_app_map if k.endswith(f":{chat_id}")]
  188. app_name = self._user_app_map.get(matching[0]) if len(matching) == 1 else app_name
  189. return self._get_app_by_name(app_name) or self._apps[0]
  190. async def get_chat_info(self, chat_id: str) -> dict[str, Any]:
  191. return {"name": chat_id, "type": "dm"}
  192. async def _handle_health(self, request: web.Request) -> web.Response:
  193. return web.json_response({"status": "ok", "platform": "wecom_callback"})
  194. async def _handle_verify(self, request: web.Request) -> web.Response:
  195. """GET endpoint — WeCom URL verification handshake."""
  196. msg_signature, timestamp, nonce = self._signature_params(request)
  197. echostr = request.query.get("echostr", "")
  198. for app in self._apps:
  199. try:
  200. plain = self._crypt_for_app(app).verify_url(msg_signature, timestamp, nonce, echostr)
  201. return web.Response(text=plain, content_type="text/plain")
  202. except Exception:
  203. continue
  204. return web.Response(status=403, text="signature verification failed")
  205. async def _handle_callback(self, request: web.Request) -> web.Response:
  206. """POST endpoint — receive an encrypted message callback."""
  207. msg_signature, timestamp, nonce = self._signature_params(request)
  208. body_bytes = await request.read() # explicit guard in addition to client_max_size
  209. if len(body_bytes) > _MAX_BODY:
  210. logger.warning("[WecomCallback] Payload too large (%d bytes) — rejected", len(body_bytes))
  211. return web.Response(status=413, text="payload too large")
  212. body = body_bytes.decode("utf-8", errors="replace")
  213. for app in self._apps:
  214. try:
  215. event = self._build_event(app, self._decrypt_request(app, body, msg_signature, timestamp, nonce))
  216. if event is not None:
  217. # WeCom retries callbacks on timeout → duplicate inbound messages.
  218. if event.message_id and self._dedup.is_duplicate(event.message_id):
  219. logger.debug("[WecomCallback] Duplicate MsgId %s, skipping", event.message_id)
  220. return _ack()
  221. if event.source and event.source.user_id:
  222. self._user_app_map[self._user_app_key(str(app.get("corp_id") or ""), event.source.user_id)] = app["name"]
  223. await self._message_queue.put(event)
  224. return _ack() # ack immediately — the reply arrives later via proactive message/send
  225. except WeComCryptoError:
  226. continue
  227. except Exception:
  228. logger.exception("[WecomCallback] Error handling message")
  229. break
  230. return web.Response(status=400, text="invalid callback payload")
  231. @staticmethod
  232. def _signature_params(request: web.Request):
  233. return tuple(request.query.get(k, "") for k in ("msg_signature", "timestamp", "nonce"))
  234. async def _poll_loop(self) -> None:
  235. while True:
  236. event = await self._message_queue.get()
  237. try:
  238. task = asyncio.create_task(self.handle_message(event))
  239. self._background_tasks.add(task)
  240. task.add_done_callback(self._background_tasks.discard)
  241. except Exception:
  242. logger.exception("[WecomCallback] Failed to enqueue event")
  243. def _decrypt_request(self, app: dict[str, Any], body: str, msg_signature: str, timestamp: str, nonce: str) -> str:
  244. encrypt = ET.fromstring(body).findtext("Encrypt", default="")
  245. return self._crypt_for_app(app).decrypt(msg_signature, timestamp, nonce, encrypt).decode("utf-8")
  246. def _build_event(self, app: dict[str, Any], xml_text: str) -> Optional[MessageEvent]:
  247. root = ET.fromstring(xml_text)
  248. msg_type = (root.findtext("MsgType") or "").lower()
  249. # Lifecycle events (enter_agent/subscribe) and non-text types are silently acknowledged.
  250. if msg_type not in {"text", "event"} or (msg_type == "event" and (root.findtext("Event") or "").lower() in {"enter_agent", "subscribe"}):
  251. return None
  252. user_id = root.findtext("FromUserName", default="")
  253. corp_id = root.findtext("ToUserName", default=app.get("corp_id", ""))
  254. content = root.findtext("Content", default="").strip() or ("/start" if msg_type == "event" else "")
  255. msg_id = root.findtext("MsgId") or f"{user_id}:{root.findtext('CreateTime', default='0')}"
  256. source = self.build_source(chat_id=self._user_app_key(corp_id, user_id), chat_name=user_id, chat_type="dm", user_id=user_id, user_name=user_id)
  257. return MessageEvent(text=content, message_type=MessageType.TEXT, source=source, raw_message=xml_text, message_id=msg_id)
  258. def _crypt_for_app(self, app: dict[str, Any]) -> WXBizMsgCrypt:
  259. return WXBizMsgCrypt(token=str(app.get("token") or ""), encoding_aes_key=str(app.get("encoding_aes_key") or ""), receive_id=str(app.get("corp_id") or ""))
  260. def _get_app_by_name(self, name: Optional[str]) -> Optional[dict[str, Any]]:
  261. return next((app for app in self._apps if app.get("name") == name), None) if name else None
  262. async def _get_access_token(self, app: dict[str, Any]) -> str:
  263. cached = self._access_tokens.get(app["name"])
  264. return cached["token"] if cached and cached.get("expires_at", 0) > time.time() + 60 else await self._refresh_access_token(app)
  265. async def _refresh_access_token(self, app: dict[str, Any]) -> str:
  266. resp = await self._http_client.get(_TOKEN_URL, params={"corpid": app.get("corp_id"), "corpsecret": app.get("corp_secret")})
  267. data = resp.json()
  268. if data.get("errcode") != 0:
  269. raise RuntimeError(f"WeCom token refresh failed: {data}")
  270. token = data["access_token"]
  271. expires_in = int(data.get("expires_in", ACCESS_TOKEN_TTL_SECONDS))
  272. self._access_tokens[app["name"]] = {"token": token, "expires_at": time.time() + expires_in}
  273. logger.info("[WecomCallback] Token refreshed for app '%s' (corp=%s), expires in %ss", app.get("name", "default"), app.get("corp_id", ""), expires_in)
  274. return token