feat(channels): add wecom / wecom-app / weixin IM channels (M1.5)
- base.py: IMChannel protocol + InboundMessage + shared helpers (split_message_text utf-8 byte-safe, clean_control_chars ZWSP hygiene) - editable_stream.py: create-edit-flush streaming fallback pattern - wecom.py: aibot WebSocket long-connection (replyStream streaming, allowlist, reconnect backoff, auth-failure terminal) - wecom_app.py: self-built app HTTP callback (stdlib server, WXBizMsgCrypt AES-CBC round-trip, access_token cache, media download; works in both WeCom client and WeChat via WeChat-plugin, no streaming on this path) - weixin.py: WeChat bot QR login + getupdates long-poll + sendmessage - tests: 28 passed (mock transports, crypt roundtrip, stream coalesce) Ported from dsh-im (xmanrui) protocol facts and resilience patterns.
This commit is contained in:
1 parent
bf8748b21b
commit
d698ae8a60
7 files changed
+1184
No files matched your search
@@ -0,0 +1,15 @@
|
|||||||
|
"""IM channel implementations (peer front-ends to the NATS channel)."""
|
||||||
|
|
||||||
|
from .base import IMChannel, InboundMessage
|
||||||
|
from .wecom import WecomAibotChannel
|
||||||
|
from .wecom_app import WecomAppChannel
|
||||||
|
from .weixin import WeixinApiError, WeixinChannel
|
||||||
|
|
||||||
|
__all__ = [
|
||||||
|
"IMChannel",
|
||||||
|
"InboundMessage",
|
||||||
|
"WecomAibotChannel",
|
||||||
|
"WecomAppChannel",
|
||||||
|
"WeixinChannel",
|
||||||
|
"WeixinApiError",
|
||||||
|
]
|
||||||
@@ -0,0 +1,115 @@
|
|||||||
|
"""Channel abstraction: every inbound/outbound front-end implements this.
|
||||||
|
|
||||||
|
A channel is identified by (channel, chat_id). All hub logic (session
|
||||||
|
binding, agent routing, permissions) is channel-agnostic.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from dataclasses import dataclass, field
|
||||||
|
from typing import Any, Callable, Protocol
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# inbound message
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class InboundMessage:
|
||||||
|
channel: str # "wecom" | "wecom-app" | "weixin" | "nats"
|
||||||
|
chat_id: str # chat/user identifier within the channel
|
||||||
|
user_id: str # sender identity (for ACL)
|
||||||
|
text: str = ""
|
||||||
|
images: list[bytes] = field(default_factory=list) # raw bytes
|
||||||
|
image_mime: str = "image/png"
|
||||||
|
raw: dict[str, Any] = field(default_factory=dict)
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class ChannelUserRef:
|
||||||
|
channel: str
|
||||||
|
chat_id: str
|
||||||
|
user_id: str = ""
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# outbound event sink — channels decide how to present progress
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
EventSink = Callable[[str, str, dict[str, Any]], None]
|
||||||
|
"""sink(chat_id, kind, payload); kind in:
|
||||||
|
"delta" - text chunk (streaming append)
|
||||||
|
"replace" - full replacement of current bubble text
|
||||||
|
"status" - transient status line (tool running, thinking...)
|
||||||
|
"final" - terminal text for the turn
|
||||||
|
"permission" - permission request payload (needs user decision)
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
class IMChannel(Protocol):
|
||||||
|
"""Lifecycle + IO contract for all IM front-ends."""
|
||||||
|
|
||||||
|
name: str
|
||||||
|
|
||||||
|
def start(self) -> None: ...
|
||||||
|
def stop(self) -> None: ...
|
||||||
|
|
||||||
|
def on_message(self, cb: Callable[[InboundMessage], None]) -> None: ...
|
||||||
|
def set_event_sink(self, sink: EventSink) -> None: ...
|
||||||
|
|
||||||
|
def reply(self, chat_id: str, text: str) -> None: ...
|
||||||
|
def push_event(self, chat_id: str, kind: str, payload: dict[str, Any]) -> None: ...
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# helpers shared by channels
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
def split_message_text(value: str, limit: int) -> list[str]:
|
||||||
|
"""Split text into chunks <= limit chars, preferring \\n then space breaks.
|
||||||
|
|
||||||
|
Mirrors dsh-im shared/editable-message-stream.splitMessageText.
|
||||||
|
"""
|
||||||
|
text = (value or "").strip()
|
||||||
|
if not text:
|
||||||
|
return []
|
||||||
|
chunks: list[str] = []
|
||||||
|
remaining = text
|
||||||
|
while len(remaining.encode("utf-8")) > limit:
|
||||||
|
# operate on utf-8 byte budget like WeCom requires
|
||||||
|
cut = _byte_safe_cut(remaining, limit)
|
||||||
|
chunks.append(remaining[:cut].strip())
|
||||||
|
remaining = remaining[cut:].lstrip()
|
||||||
|
if remaining:
|
||||||
|
chunks.append(remaining)
|
||||||
|
return chunks
|
||||||
|
|
||||||
|
|
||||||
|
def _byte_safe_cut(text: str, byte_limit: int) -> int:
|
||||||
|
"""Largest char index whose utf-8 prefix fits byte_limit, cut at \\n/space if reasonable."""
|
||||||
|
cut = len(text)
|
||||||
|
acc = 0
|
||||||
|
for i, ch in enumerate(text):
|
||||||
|
w = 1 if ord(ch) < 0x80 else (2 if ord(ch) < 0x800 else (3 if ord(ch) < 0x10000 else 4))
|
||||||
|
if acc + w > byte_limit:
|
||||||
|
cut = i
|
||||||
|
break
|
||||||
|
acc += w
|
||||||
|
window = text[:cut]
|
||||||
|
nl = window.rfind("\n")
|
||||||
|
if nl >= int(cut * 0.55):
|
||||||
|
return nl
|
||||||
|
sp = window.rfind(" ")
|
||||||
|
if sp >= int(cut * 0.55):
|
||||||
|
return sp
|
||||||
|
return cut
|
||||||
|
|
||||||
|
|
||||||
|
def clean_control_chars(value: str, max_len: int = 80) -> str:
|
||||||
|
"""Strip Cc/Cf (zero-width etc.) — WeCom/ZWSP hygiene."""
|
||||||
|
out = []
|
||||||
|
for ch in (value or "")[: max_len * 4]:
|
||||||
|
o = ord(ch)
|
||||||
|
if o in (0x200B, 0x200C, 0x200D, 0xFEFF) or (o < 0x20 and ch not in "\n\t"):
|
||||||
|
continue # drop, don't substitute
|
||||||
|
out.append(ch)
|
||||||
|
return "".join(out).strip()[:max_len]
|
||||||
@@ -0,0 +1,114 @@
|
|||||||
|
"""Editable-message stream: create one bubble, edit it periodically, flush remainder.
|
||||||
|
|
||||||
|
Generic pattern for platforms with an "edit message" API (WeCom template
|
||||||
|
card update / aibot replyStream / any edit endpoint). Mirrors dsh-im's
|
||||||
|
shared/editable-message-stream.
|
||||||
|
|
||||||
|
Usage:
|
||||||
|
stream = EditableMessageStream(
|
||||||
|
create=lambda text: api.send(chat_id, text), # -> msg_id
|
||||||
|
edit=lambda msg_id, text: api.edit(msg_id, text),
|
||||||
|
send_remainder=lambda text: api.send(chat_id, text),
|
||||||
|
limit=4000, update_interval_ms=800,
|
||||||
|
)
|
||||||
|
stream.append("chunk...") # call from event thread
|
||||||
|
stream.close() # final flush
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
from typing import Any, Callable
|
||||||
|
|
||||||
|
from .base import split_message_text
|
||||||
|
|
||||||
|
|
||||||
|
class EditableMessageStream:
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
create: Callable[[str], Any],
|
||||||
|
edit: Callable[[Any, str], Any],
|
||||||
|
send_remainder: Callable[[str], Any] | None = None,
|
||||||
|
limit: int = 4000,
|
||||||
|
update_interval_s: float = 0.8,
|
||||||
|
initial_text: str = "正在处理…",
|
||||||
|
on_error: Callable[[Exception], None] | None = None,
|
||||||
|
):
|
||||||
|
self._create = create
|
||||||
|
self._edit = edit
|
||||||
|
self._send_remainder = send_remainder
|
||||||
|
self._limit = limit
|
||||||
|
self._interval = update_interval_s
|
||||||
|
self._on_error = on_error
|
||||||
|
self._msg_id: Any = None
|
||||||
|
self._buffer: list[str] = []
|
||||||
|
self._sent_text = ""
|
||||||
|
self._lock = threading.Lock()
|
||||||
|
self._last_edit = 0.0
|
||||||
|
self._closed = False
|
||||||
|
self._started = False
|
||||||
|
|
||||||
|
def _safe(self, fn, *args):
|
||||||
|
try:
|
||||||
|
return fn(*args)
|
||||||
|
except Exception as e: # noqa: BLE001 - delivery errors must not kill the turn
|
||||||
|
if self._on_error:
|
||||||
|
try:
|
||||||
|
self._on_error(e)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
def append(self, text: str) -> None:
|
||||||
|
if self._closed or not text:
|
||||||
|
return
|
||||||
|
with self._lock:
|
||||||
|
self._buffer.append(text)
|
||||||
|
pending = self._sent_text + "".join(self._buffer)
|
||||||
|
now = time.monotonic()
|
||||||
|
if self._msg_id is None:
|
||||||
|
if not self._started:
|
||||||
|
self._started = True
|
||||||
|
self._msg_id = self._safe(self._create, initial_bubble(pending))
|
||||||
|
self._last_edit = now
|
||||||
|
return
|
||||||
|
if now - self._last_edit >= self._interval:
|
||||||
|
self._flush_locked(pending, now)
|
||||||
|
|
||||||
|
def _flush_locked(self, pending: str, now: float) -> None:
|
||||||
|
shown = pending[: self._limit * 4]
|
||||||
|
if len(shown.encode("utf-8")) > self._limit:
|
||||||
|
shown = shown[: max(1, self._limit // 4) * 4]
|
||||||
|
# re-trim to a char count whose utf-8 fits
|
||||||
|
while len(shown.encode("utf-8")) > self._limit and shown:
|
||||||
|
shown = shown[:-1]
|
||||||
|
self._safe(self._edit, self._msg_id, shown)
|
||||||
|
self._sent_text = pending
|
||||||
|
self._buffer.clear()
|
||||||
|
self._last_edit = now
|
||||||
|
|
||||||
|
def close(self, final_text: str | None = None) -> None:
|
||||||
|
with self._lock:
|
||||||
|
if self._closed:
|
||||||
|
return
|
||||||
|
self._closed = True
|
||||||
|
pending = self._sent_text + "".join(self._buffer)
|
||||||
|
self._buffer.clear()
|
||||||
|
text = final_text if final_text is not None else pending
|
||||||
|
if not text:
|
||||||
|
return
|
||||||
|
# if too long for one bubble: edit remainder into follow-up messages
|
||||||
|
chunks = split_message_text(text, self._limit)
|
||||||
|
if self._msg_id is None:
|
||||||
|
for c in chunks:
|
||||||
|
self._safe(self._create, c)
|
||||||
|
return
|
||||||
|
first, rest = (chunks[0], chunks[1:]) if chunks else ("", [])
|
||||||
|
self._safe(self._edit, self._msg_id, first)
|
||||||
|
send = self._send_remainder or self._create
|
||||||
|
for c in rest:
|
||||||
|
self._safe(send, c)
|
||||||
|
|
||||||
|
|
||||||
|
def initial_bubble(pending: str) -> str:
|
||||||
|
return (pending[:120] + "…") if pending else "正在处理…"
|
||||||
@@ -0,0 +1,244 @@
|
|||||||
|
"""WeCom aibot channel: official WebSocket long-connection via @wecom aibot API.
|
||||||
|
|
||||||
|
Python port of dsh-im src/channels/wecom (runtime/bridge patterns), speaking
|
||||||
|
the aibot WebSocket protocol directly:
|
||||||
|
- wss long connection, auth handshake with bot token/secret
|
||||||
|
- client.replyStream(frame, reqId, chunk, finished) for streaming replies
|
||||||
|
- client.sendMessage(chatId, {msgtype}) for active sends
|
||||||
|
- reconnect with backoff; auth-failure is terminal
|
||||||
|
|
||||||
|
Config (dict):
|
||||||
|
bot_id: str
|
||||||
|
secret: str
|
||||||
|
domain: str = "https://open.weixin.qq.com" # aibot gateway
|
||||||
|
connect_timeout_s: float = 20
|
||||||
|
max_reconnect_attempts: int = 10
|
||||||
|
reply_timeout_s: float = 600
|
||||||
|
allowed_users: list[str] = [] # empty = allow all
|
||||||
|
|
||||||
|
Note: requires `websockets` (or aiohttp) at runtime; M1.5 ships with a
|
||||||
|
mockable transport so tests run without the real gateway.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import json
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
import uuid
|
||||||
|
from typing import Any, Callable
|
||||||
|
|
||||||
|
from .base import IMChannel, InboundMessage, clean_control_chars, split_message_text
|
||||||
|
|
||||||
|
# aibot protocol message types (subset used here)
|
||||||
|
MT_REPLY_STREAM = "reply_stream"
|
||||||
|
MT_SEND_MESSAGE = "send_message"
|
||||||
|
|
||||||
|
|
||||||
|
class WecomAibotChannel:
|
||||||
|
name = "wecom"
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
config: dict[str, Any],
|
||||||
|
ws_factory: Callable[[dict[str, Any]], Any] | None = None,
|
||||||
|
logger: Any = None,
|
||||||
|
):
|
||||||
|
self.bot_id = config["bot_id"]
|
||||||
|
self.secret = config["secret"]
|
||||||
|
self.domain = config.get("domain", "https://open.weixin.qq.com")
|
||||||
|
self.connect_timeout_s = float(config.get("connect_timeout_s", 20))
|
||||||
|
self.max_reconnect = int(config.get("max_reconnect_attempts", 10))
|
||||||
|
self.reply_timeout_s = float(config.get("reply_timeout_s", 600))
|
||||||
|
self.allowed_users = set(config.get("allowed_users") or [])
|
||||||
|
self._ws_factory = ws_factory # returns object with send/recv/close
|
||||||
|
self._logger = logger or _default_logger()
|
||||||
|
self._msg_cb: Callable[[InboundMessage], None] | None = None
|
||||||
|
self._sink: Callable[[str, str, dict], None] | None = None
|
||||||
|
self._stop = threading.Event()
|
||||||
|
self._thread: threading.Thread | None = None
|
||||||
|
self._ws = None # current socket (set by _connect_and_serve)
|
||||||
|
# frame -> stream state for streaming replies
|
||||||
|
self._streams: dict[str, dict] = {}
|
||||||
|
self._stream_lock = threading.Lock()
|
||||||
|
|
||||||
|
# -- IMChannel ---------------------------------------------------------
|
||||||
|
def start(self) -> None:
|
||||||
|
self._stop.clear()
|
||||||
|
self._thread = threading.Thread(target=self._run, name="wecom-aibot", daemon=True)
|
||||||
|
self._thread.start()
|
||||||
|
|
||||||
|
def stop(self) -> None:
|
||||||
|
self._stop.set()
|
||||||
|
|
||||||
|
def on_message(self, cb: Callable[[InboundMessage], None]) -> None:
|
||||||
|
self._msg_cb = cb
|
||||||
|
|
||||||
|
def set_event_sink(self, sink: Callable[[str, str, dict], None]) -> None:
|
||||||
|
self._sink = sink
|
||||||
|
|
||||||
|
# -- connection loop ---------------------------------------------------
|
||||||
|
def _run(self) -> None:
|
||||||
|
attempt = 0
|
||||||
|
while not self._stop.is_set():
|
||||||
|
try:
|
||||||
|
self._connect_and_serve()
|
||||||
|
attempt = 0
|
||||||
|
except _AuthFailure as e:
|
||||||
|
self._logger.error(f"[wecom] auth failed, giving up: {e}")
|
||||||
|
return
|
||||||
|
except Exception as e: # noqa: BLE001
|
||||||
|
attempt += 1
|
||||||
|
if attempt > self.max_reconnect:
|
||||||
|
self._logger.error(f"[wecom] reconnect exhausted ({attempt}): {e}")
|
||||||
|
return
|
||||||
|
delay = min(2**attempt, 30)
|
||||||
|
self._logger.warning(f"[wecom] disconnected ({e}); retry {attempt}/{self.max_reconnect} in {delay}s")
|
||||||
|
self._stop.wait(delay)
|
||||||
|
|
||||||
|
def _connect_and_serve(self) -> None:
|
||||||
|
if self._ws_factory is None:
|
||||||
|
raise RuntimeError("wecom channel requires a ws_factory (real or mock transport)")
|
||||||
|
ws = self._ws_factory(
|
||||||
|
{
|
||||||
|
"bot_id": self.bot_id,
|
||||||
|
"secret": self.secret,
|
||||||
|
"domain": self.domain,
|
||||||
|
"timeout_s": self.connect_timeout_s,
|
||||||
|
}
|
||||||
|
)
|
||||||
|
ws.connect()
|
||||||
|
self._ws = ws
|
||||||
|
self._logger.info("[wecom] WebSocket authenticated")
|
||||||
|
try:
|
||||||
|
while not self._stop.is_set():
|
||||||
|
raw = ws.recv(timeout=1.0)
|
||||||
|
if raw is None:
|
||||||
|
continue
|
||||||
|
msg = json.loads(raw)
|
||||||
|
self._dispatch(msg, ws)
|
||||||
|
finally:
|
||||||
|
try:
|
||||||
|
ws.close()
|
||||||
|
except Exception: # noqa: BLE001
|
||||||
|
pass
|
||||||
|
|
||||||
|
# -- inbound -----------------------------------------------------------
|
||||||
|
def _dispatch(self, msg: dict[str, Any], ws: Any) -> None:
|
||||||
|
# aibot frames carry a callback payload; adapt per real protocol fields
|
||||||
|
frame_id = msg.get("frame_id") or msg.get("msgid") or uuid.uuid4().hex
|
||||||
|
body = msg.get("body") or msg
|
||||||
|
sender = (body.get("from") or {}).get("userid") or body.get("sender") or ""
|
||||||
|
chat_id = body.get("chatid") or body.get("chat_id") or sender
|
||||||
|
if self.allowed_users and sender and sender not in self.allowed_users:
|
||||||
|
self._logger.warning(f"[wecom] user {sender} not allowed, dropped")
|
||||||
|
return
|
||||||
|
text = ""
|
||||||
|
images: list[bytes] = []
|
||||||
|
msgtype = body.get("msgtype", "text")
|
||||||
|
if msgtype == "text":
|
||||||
|
text = (body.get("text") or {}).get("content", "")
|
||||||
|
elif msgtype == "image":
|
||||||
|
b64 = (body.get("image") or {}).get("base64", "")
|
||||||
|
if b64:
|
||||||
|
import base64
|
||||||
|
|
||||||
|
images.append(base64.b64decode(b64))
|
||||||
|
elif msgtype == "markdown":
|
||||||
|
text = (body.get("markdown") or {}).get("content", "")
|
||||||
|
text = clean_control_chars(text, max_len=100000).strip() if text else ""
|
||||||
|
if not text and not images:
|
||||||
|
return
|
||||||
|
if self._msg_cb:
|
||||||
|
self._msg_cb(
|
||||||
|
InboundMessage(
|
||||||
|
channel=self.name,
|
||||||
|
chat_id=str(chat_id),
|
||||||
|
user_id=str(sender),
|
||||||
|
text=text,
|
||||||
|
images=images,
|
||||||
|
raw={"frame_id": frame_id, "msg": msg},
|
||||||
|
)
|
||||||
|
)
|
||||||
|
|
||||||
|
# -- outbound ----------------------------------------------------------
|
||||||
|
def reply(self, chat_id: str, text: str) -> None:
|
||||||
|
for chunk in split_message_text(text, 4000):
|
||||||
|
self._send({"type": MT_SEND_MESSAGE, "chatid": chat_id, "msgtype": "markdown", "markdown": {"content": chunk}})
|
||||||
|
|
||||||
|
def push_event(self, chat_id: str, kind: str, payload: dict[str, Any]) -> None:
|
||||||
|
if kind == "delta":
|
||||||
|
self._stream_append(chat_id, str(payload.get("text", "")))
|
||||||
|
elif kind == "status":
|
||||||
|
# transient status → only reflected in the bubble text when no deltas yet
|
||||||
|
self._stream_ensure(chat_id, str(payload.get("text", "")))
|
||||||
|
elif kind == "final":
|
||||||
|
self._stream_close(chat_id, str(payload.get("text", "")))
|
||||||
|
elif kind == "permission":
|
||||||
|
self.reply(chat_id, _permission_text(payload))
|
||||||
|
# "replace" treated as delta reset for now
|
||||||
|
|
||||||
|
# -- streaming state ---------------------------------------------------
|
||||||
|
def _stream_key_states(self, chat_id: str) -> dict:
|
||||||
|
with self._stream_lock:
|
||||||
|
return self._streams.setdefault(chat_id, {"req_id": uuid.uuid4().hex, "buf": "", "sent": False})
|
||||||
|
|
||||||
|
def _stream_ensure(self, chat_id: str, text: str) -> None:
|
||||||
|
st = self._stream_key_states(chat_id)
|
||||||
|
if not st["sent"]:
|
||||||
|
self._reply_stream(chat_id, st, text or "正在处理…", finished=False)
|
||||||
|
|
||||||
|
def _stream_append(self, chat_id: str, text: str) -> None:
|
||||||
|
st = self._stream_key_states(chat_id)
|
||||||
|
st["buf"] += text
|
||||||
|
# rate: push edits at most every 0.8s (like dsh-im update_interval)
|
||||||
|
now = time.monotonic()
|
||||||
|
if now - st.get("last", 0) >= 0.8:
|
||||||
|
st["last"] = now
|
||||||
|
self._reply_stream(chat_id, st, st["buf"][-4000:], finished=False)
|
||||||
|
|
||||||
|
def _stream_close(self, chat_id: str, final_text: str) -> None:
|
||||||
|
st = self._stream_key_states(chat_id)
|
||||||
|
text = final_text or st["buf"]
|
||||||
|
self._reply_stream(chat_id, st, text, finished=True)
|
||||||
|
with self._stream_lock:
|
||||||
|
self._streams.pop(chat_id, None)
|
||||||
|
|
||||||
|
def _reply_stream(self, chat_id: str, st: dict, text: str, finished: bool) -> None:
|
||||||
|
self._send(
|
||||||
|
{
|
||||||
|
"type": MT_REPLY_STREAM,
|
||||||
|
"chatid": chat_id,
|
||||||
|
"req_id": st["req_id"],
|
||||||
|
"content": text,
|
||||||
|
"finished": finished,
|
||||||
|
}
|
||||||
|
)
|
||||||
|
if finished:
|
||||||
|
st["sent"] = True
|
||||||
|
|
||||||
|
def _send(self, obj: dict) -> None:
|
||||||
|
ws = getattr(self, "_ws", None)
|
||||||
|
if ws is None:
|
||||||
|
self._logger.warning("[wecom] send skipped, not connected")
|
||||||
|
return
|
||||||
|
ws.send(json.dumps(obj, ensure_ascii=False))
|
||||||
|
|
||||||
|
|
||||||
|
class _AuthFailure(Exception):
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def _permission_text(payload: dict[str, Any]) -> str:
|
||||||
|
title = payload.get("title") or payload.get("tool", "operation")
|
||||||
|
return (
|
||||||
|
f"⚠️ 权限请求:{title}\n"
|
||||||
|
f"回复「允许」执行;其他回复视为拒绝。\n"
|
||||||
|
f"请求 ID:{payload.get('request_id', '')}"
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def _default_logger():
|
||||||
|
import logging
|
||||||
|
|
||||||
|
return logging.getLogger("agenthub.wecom")
|
||||||
@@ -0,0 +1,317 @@
|
|||||||
|
"""WeCom 自建应用 channel: HTTP callback + qyapi.weixin.qq.com APIs.
|
||||||
|
|
||||||
|
Port of dsh-im src/channels/wecom-app. Works in BOTH WeCom client and
|
||||||
|
WeChat (via 企业微信后台的「微信插件」) — same conversation, both ends.
|
||||||
|
|
||||||
|
Protocol facts (from dsh-im docs/企业微信自建应用接入.md):
|
||||||
|
- callback: GET verify (echostr decrypt) + POST encrypted XML/JSON messages
|
||||||
|
- APIs: access_token (2h TTL, corp_id+secret), send message, upload media
|
||||||
|
- errors: 60020 = trusted-IP missing, 41004 = bad secret
|
||||||
|
- streaming: WeChat side has NO edit API -> always whole-message delivery;
|
||||||
|
WeCom client side also whole-message for self-built apps (aibot has
|
||||||
|
replyStream, self-built does not)
|
||||||
|
- http server runs in-thread (stdlib), no external web framework needed
|
||||||
|
|
||||||
|
Config (dict):
|
||||||
|
corp_id, agent_id, secret, token, encoding_aes_key
|
||||||
|
callback_listen_host: str = "127.0.0.1"
|
||||||
|
callback_listen_port: int = 30987
|
||||||
|
callback_base_url: str = "" # public base (IP:port or domain)
|
||||||
|
api_proxy: str = "" # optional reverse proxy for qyapi
|
||||||
|
allowed_users: list[str] = []
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import base64
|
||||||
|
import hashlib
|
||||||
|
import json
|
||||||
|
import socket
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
import urllib.parse
|
||||||
|
import urllib.request
|
||||||
|
import xml.etree.ElementTree as ET
|
||||||
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||||
|
from typing import Any, Callable
|
||||||
|
|
||||||
|
from .base import IMChannel, InboundMessage, clean_control_chars, split_message_text
|
||||||
|
|
||||||
|
QYAPI = "https://qyapi.weixin.qq.com"
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# WXBizMsgCrypt equivalent (stdlib) — SHA1 sig + AES-CBC msg encryption
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class WxBizError(Exception):
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
class WxMsgCrypt:
|
||||||
|
"""企业微信消息加解密(sha1 签名 + AES-256-CBC,PKCS7,base64)."""
|
||||||
|
|
||||||
|
def __init__(self, token: str, encoding_aes_key: str, corp_id: str):
|
||||||
|
self.token = token
|
||||||
|
self.corp_id = corp_id
|
||||||
|
key = base64.b64decode(encoding_aes_key + "=")
|
||||||
|
if len(key) != 32:
|
||||||
|
raise WxBizError("EncodingAESKey invalid")
|
||||||
|
self.key = key
|
||||||
|
|
||||||
|
def _sign(self, timestamp: str, nonce: str, encrypt: str) -> str:
|
||||||
|
raw = "".join(sorted([self.token, timestamp, nonce, encrypt]))
|
||||||
|
return hashlib.sha1(raw.encode()).hexdigest()
|
||||||
|
|
||||||
|
def verify_url(self, msg_signature: str, timestamp: str, nonce: str, echostr: str) -> str:
|
||||||
|
"""Decrypt echostr for URL verification; raises WxBizError on mismatch."""
|
||||||
|
if self._sign(timestamp, nonce, echostr) != msg_signature:
|
||||||
|
raise WxBizError("signature mismatch (verify URL)")
|
||||||
|
plain = self._decrypt(echostr)
|
||||||
|
return plain
|
||||||
|
|
||||||
|
def decrypt_msg(self, msg_signature: str, timestamp: str, nonce: str, encrypt: str) -> str:
|
||||||
|
if self._sign(timestamp, nonce, encrypt) != msg_signature:
|
||||||
|
raise WxBizError("signature mismatch (msg)")
|
||||||
|
return self._decrypt(encrypt)
|
||||||
|
|
||||||
|
def encrypt_msg(self, plain: str, nonce: str, timestamp: str | None = None) -> str:
|
||||||
|
import os
|
||||||
|
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
|
||||||
|
|
||||||
|
ts = timestamp or str(int(time.time()))
|
||||||
|
rnd = os.urandom(16)
|
||||||
|
msg_bytes = plain.encode()
|
||||||
|
# 16B rnd + 4B network-order len + msg + corp_id + PKCS7 to 32-block
|
||||||
|
raw = (
|
||||||
|
rnd
|
||||||
|
+ len(msg_bytes).to_bytes(4, "big")
|
||||||
|
+ msg_bytes
|
||||||
|
+ self.corp_id.encode()
|
||||||
|
)
|
||||||
|
pad = 32 - (len(raw) % 32)
|
||||||
|
raw += bytes([pad]) * pad
|
||||||
|
cipher = Cipher(algorithms.AES(self.key), modes.CBC(self.key[:16]))
|
||||||
|
enc = cipher.encryptor()
|
||||||
|
encrypted = enc.update(raw) + enc.finalize()
|
||||||
|
b64 = base64.b64encode(encrypted).decode()
|
||||||
|
sig = self._sign(ts, nonce, b64)
|
||||||
|
return json.dumps({"encrypt": b64, "msgsignature": sig, "timestamp": ts, "nonce": nonce})
|
||||||
|
|
||||||
|
def _decrypt(self, b64: str) -> str:
|
||||||
|
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
|
||||||
|
|
||||||
|
data = base64.b64decode(b64)
|
||||||
|
if len(data) % 16 or len(data) < 32:
|
||||||
|
raise WxBizError("bad encrypted payload length")
|
||||||
|
cipher = Cipher(algorithms.AES(self.key), modes.CBC(self.key[:16]))
|
||||||
|
dec = cipher.decryptor()
|
||||||
|
raw = dec.update(data) + dec.finalize()
|
||||||
|
pad = raw[-1]
|
||||||
|
if not 1 <= pad <= 32:
|
||||||
|
raise WxBizError("bad PKCS7 padding")
|
||||||
|
raw = raw[:-pad]
|
||||||
|
msg_len = int.from_bytes(raw[16:20], "big")
|
||||||
|
corp = raw[20 + msg_len :].decode()
|
||||||
|
if corp != self.corp_id:
|
||||||
|
raise WxBizError(f"corp_id mismatch: {corp}")
|
||||||
|
return raw[20 : 20 + msg_len].decode()
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# channel
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class WecomAppChannel:
|
||||||
|
name = "wecom-app"
|
||||||
|
|
||||||
|
def __init__(self, config: dict[str, Any], logger: Any = None):
|
||||||
|
self.corp_id = config["corp_id"]
|
||||||
|
self.agent_id = str(config["agent_id"])
|
||||||
|
self.secret = config["secret"]
|
||||||
|
self.token = config["token"]
|
||||||
|
self.aes_key = config["encoding_aes_key"]
|
||||||
|
self.host = config.get("callback_listen_host", "127.0.0.1")
|
||||||
|
self.port = int(config.get("callback_listen_port", 30987))
|
||||||
|
self.api_base = (config.get("api_proxy") or QYAPI).rstrip("/")
|
||||||
|
self.allowed_users = set(config.get("allowed_users") or [])
|
||||||
|
|
||||||
|
self.crypt = WxMsgCrypt(self.token, self.aes_key, self.corp_id)
|
||||||
|
self._msg_cb: Callable[[InboundMessage], None] | None = None
|
||||||
|
self._logger = logger or _log()
|
||||||
|
self._server: ThreadingHTTPServer | None = None
|
||||||
|
self._thread: threading.Thread | None = None
|
||||||
|
self._stop = threading.Event()
|
||||||
|
self._access_token: str = ""
|
||||||
|
self._token_exp: float = 0
|
||||||
|
self._token_lock = threading.Lock()
|
||||||
|
self._external = self # for handler closure
|
||||||
|
|
||||||
|
# -- IMChannel ---------------------------------------------------------
|
||||||
|
def start(self) -> None:
|
||||||
|
outer = self
|
||||||
|
|
||||||
|
class Handler(BaseHTTPRequestHandler):
|
||||||
|
def log_message(self, format, *args): # noqa: A002 - stdlib signature
|
||||||
|
pass
|
||||||
|
|
||||||
|
def do_GET(self):
|
||||||
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
||||||
|
ms, ts, nc = q.get("msg_signature", [""])[0], q.get("timestamp", [""])[0], q.get("nonce", [""])[0]
|
||||||
|
echo = q.get("echostr", [""])[0]
|
||||||
|
try:
|
||||||
|
plain = outer.crypt.verify_url(ms, ts, nc, echo)
|
||||||
|
self._respond(200, plain.encode())
|
||||||
|
except WxBizError as e:
|
||||||
|
outer._logger.warning(f"[wecom-app] URL verify failed: {e}")
|
||||||
|
self._respond(403, b"verify failed")
|
||||||
|
|
||||||
|
def do_POST(self):
|
||||||
|
length = int(self.headers.get("Content-Length", 0))
|
||||||
|
body = self.rfile.read(length)
|
||||||
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
||||||
|
ms = q.get("msg_signature", [""])[0]
|
||||||
|
ts = q.get("timestamp", [""])[0]
|
||||||
|
nc = q.get("nonce", [""])[0]
|
||||||
|
self._respond(200, b"success") # ack fast, process async
|
||||||
|
try:
|
||||||
|
encrypt = _extract_encrypt(body)
|
||||||
|
plain_xml = outer.crypt.decrypt_msg(ms, ts, nc, encrypt)
|
||||||
|
outer._on_plain_xml(plain_xml)
|
||||||
|
except Exception as e: # noqa: BLE001
|
||||||
|
outer._logger.error(f"[wecom-app] msg processing failed: {e}")
|
||||||
|
|
||||||
|
def _respond(self, code: int, data: bytes):
|
||||||
|
self.send_response(code)
|
||||||
|
self.send_header("Content-Type", "text/plain; charset=utf-8")
|
||||||
|
self.send_header("Content-Length", str(len(data)))
|
||||||
|
self.end_headers()
|
||||||
|
self.wfile.write(data)
|
||||||
|
|
||||||
|
self._server = ThreadingHTTPServer((self.host, self.port), Handler)
|
||||||
|
self._thread = threading.Thread(target=self._server.serve_forever, name="wecom-app-callback", daemon=True)
|
||||||
|
self._thread.start()
|
||||||
|
self._logger.info(f"[wecom-app] callback server on {self.host}:{self.port}")
|
||||||
|
|
||||||
|
def stop(self) -> None:
|
||||||
|
self._stop.set()
|
||||||
|
if self._server:
|
||||||
|
self._server.shutdown()
|
||||||
|
|
||||||
|
def on_message(self, cb: Callable[[InboundMessage], None]) -> None:
|
||||||
|
self._msg_cb = cb
|
||||||
|
|
||||||
|
def set_event_sink(self, sink: Callable[[str, str, dict], None]) -> None:
|
||||||
|
self._sink = sink
|
||||||
|
|
||||||
|
# -- inbound -----------------------------------------------------------
|
||||||
|
def _on_plain_xml(self, xml_text: str) -> None:
|
||||||
|
root = ET.fromstring(xml_text)
|
||||||
|
get = lambda tag: (root.findtext(tag) or "").strip() # noqa: E731
|
||||||
|
sender = get("FromUserName")
|
||||||
|
if self.allowed_users and sender not in self.allowed_users:
|
||||||
|
return
|
||||||
|
msgtype = get("MsgType")
|
||||||
|
text, images = "", []
|
||||||
|
if msgtype == "text":
|
||||||
|
text = get("Content")
|
||||||
|
elif msgtype == "image":
|
||||||
|
data = self._download_media(get("PicUrl"))
|
||||||
|
if data:
|
||||||
|
images.append(data)
|
||||||
|
elif msgtype in ("voice", "video", "location"):
|
||||||
|
text = f"[{msgtype} message omitted]" # M1.5 scope: text/image only
|
||||||
|
text = clean_control_chars(text, max_len=100000).strip()
|
||||||
|
if not text and not images:
|
||||||
|
return
|
||||||
|
if self._msg_cb:
|
||||||
|
self._msg_cb(
|
||||||
|
InboundMessage(
|
||||||
|
channel=self.name,
|
||||||
|
chat_id=sender, # self-built app: 1:1 by user
|
||||||
|
user_id=sender,
|
||||||
|
text=text,
|
||||||
|
images=images,
|
||||||
|
raw={"msg_id": get("MsgID"), "msg_type": msgtype},
|
||||||
|
)
|
||||||
|
)
|
||||||
|
|
||||||
|
# -- outbound ----------------------------------------------------------
|
||||||
|
def get_access_token(self) -> str:
|
||||||
|
with self._token_lock:
|
||||||
|
if self._access_token and time.monotonic() < self._token_exp:
|
||||||
|
return self._access_token
|
||||||
|
url = (
|
||||||
|
f"{self.api_base}/cgi-bin/gettoken"
|
||||||
|
f"?corpid={urllib.parse.quote(self.corp_id)}&corpsecret={urllib.parse.quote(self.secret)}"
|
||||||
|
)
|
||||||
|
with urllib.request.urlopen(url, timeout=10) as resp:
|
||||||
|
d = json.loads(resp.read())
|
||||||
|
if d.get("errcode"):
|
||||||
|
raise RuntimeError(f"gettoken failed: {d}")
|
||||||
|
self._access_token = d["access_token"]
|
||||||
|
self._token_exp = time.monotonic() + int(d.get("expires_in", 7200)) - 120
|
||||||
|
return self._access_token
|
||||||
|
|
||||||
|
def reply(self, chat_id: str, text: str) -> None:
|
||||||
|
for chunk in split_message_text(text, 2000): # self-built markdown limit
|
||||||
|
self._api(
|
||||||
|
"/cgi-bin/message/send",
|
||||||
|
{
|
||||||
|
"touser": chat_id,
|
||||||
|
"msgtype": "markdown",
|
||||||
|
"agentid": self.agent_id,
|
||||||
|
"markdown": {"content": chunk},
|
||||||
|
},
|
||||||
|
)
|
||||||
|
|
||||||
|
def push_event(self, chat_id: str, kind: str, payload: dict[str, Any]) -> None:
|
||||||
|
# Self-built apps have no edit API: coalesce deltas, deliver on final.
|
||||||
|
if kind == "delta":
|
||||||
|
return # accumulate in session layer; final carries full text
|
||||||
|
if kind == "final":
|
||||||
|
self.reply(chat_id, str(payload.get("text", "")))
|
||||||
|
elif kind == "status":
|
||||||
|
pass # no transient surface on this channel
|
||||||
|
elif kind == "permission":
|
||||||
|
self.reply(chat_id, _permission_text(payload))
|
||||||
|
|
||||||
|
# -- helpers -----------------------------------------------------------
|
||||||
|
def _api(self, path: str, payload: dict) -> dict:
|
||||||
|
url = f"{self.api_base}{path}?access_token={self.get_access_token()}"
|
||||||
|
req = urllib.request.Request(
|
||||||
|
url, data=json.dumps(payload, ensure_ascii=False).encode(), headers={"Content-Type": "application/json"}
|
||||||
|
)
|
||||||
|
with urllib.request.urlopen(req, timeout=15) as resp:
|
||||||
|
d = json.loads(resp.read())
|
||||||
|
if d.get("errcode") not in (0, None):
|
||||||
|
raise RuntimeError(f"{path} -> {d}")
|
||||||
|
return d
|
||||||
|
|
||||||
|
def _download_media(self, url: str) -> bytes | None:
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(url, timeout=15) as resp:
|
||||||
|
return resp.read()
|
||||||
|
except Exception as e: # noqa: BLE001
|
||||||
|
self._logger.warning(f"[wecom-app] media download failed: {e}")
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
def _extract_encrypt(body: bytes) -> str:
|
||||||
|
"""Callback body may be XML (<Encrypt>) or JSON ({"encrypt": ...})."""
|
||||||
|
text = body.decode("utf-8", "replace").lstrip()
|
||||||
|
if text.startswith("<"):
|
||||||
|
root = ET.fromstring(text)
|
||||||
|
return (root.findtext("Encrypt") or "").strip()
|
||||||
|
return (json.loads(text)).get("encrypt", "")
|
||||||
|
|
||||||
|
|
||||||
|
def _permission_text(payload: dict[str, Any]) -> str:
|
||||||
|
title = payload.get("title") or payload.get("tool", "operation")
|
||||||
|
return f"⚠️ 权限请求:{title}\n回复「允许」执行;其他回复视为拒绝。"
|
||||||
|
|
||||||
|
|
||||||
|
def _log():
|
||||||
|
import logging
|
||||||
|
|
||||||
|
return logging.getLogger("agenthub.wecom-app")
|
||||||
@@ -0,0 +1,208 @@
|
|||||||
|
"""WeChat 智能机器人 channel: QR-scan login + getupdates long-polling.
|
||||||
|
|
||||||
|
Port of dsh-im src/channels/weixin (API surface only, no protocol hacks):
|
||||||
|
- login: POST /ilink/bot/get_bot_qrcode?bot_type=... -> {qrcode,...}
|
||||||
|
GET /ilink/bot/get_qrcode_status?qrcode=... (long poll, optional verify_code)
|
||||||
|
-> token on success
|
||||||
|
- receive: POST /ilink/bot/getupdates {get_updates_buf} (long poll; timeout
|
||||||
|
returns empty msgs, NOT an error)
|
||||||
|
- send: POST /ilink/bot/sendmessage (whole-text only, no edit API)
|
||||||
|
- base: https://ilinkai.weixin.qq.com/
|
||||||
|
|
||||||
|
Config (dict):
|
||||||
|
token: str = "" # existing login token (skip QR if set)
|
||||||
|
bot_type: str = "" # passed to get_bot_qrcode
|
||||||
|
base_url: str = default
|
||||||
|
poll_timeout_ms: int = 35000
|
||||||
|
allowed_users: list[str] = []
|
||||||
|
|
||||||
|
Login flow: call start_login() to get a QR for the user to scan with
|
||||||
|
WeChat; poll_login() yields status; on success the token is stored via
|
||||||
|
token_provider (persist it — scanning is manual).
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import json
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
import urllib.error
|
||||||
|
import urllib.parse
|
||||||
|
import urllib.request
|
||||||
|
from typing import Any, Callable
|
||||||
|
|
||||||
|
from .base import IMChannel, InboundMessage, clean_control_chars, split_message_text
|
||||||
|
|
||||||
|
DEFAULT_BASE = "https://ilinkai.weixin.qq.com/"
|
||||||
|
DEFAULT_POLL_TIMEOUT_MS = 35_000
|
||||||
|
|
||||||
|
|
||||||
|
class WeixinApiError(Exception):
|
||||||
|
def __init__(self, code: str, message: str, provider: Any = None):
|
||||||
|
super().__init__(f"{code}: {message}")
|
||||||
|
self.code = code
|
||||||
|
self.provider = provider
|
||||||
|
|
||||||
|
|
||||||
|
class WeixinChannel:
|
||||||
|
name = "weixin"
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
config: dict[str, Any],
|
||||||
|
http_post: Callable[[str, dict, str | None, int], dict] | None = None,
|
||||||
|
http_get: Callable[[str, int], dict] | None = None,
|
||||||
|
token_persist: Callable[[str], None] | None = None,
|
||||||
|
logger: Any = None,
|
||||||
|
):
|
||||||
|
self.base_url = (config.get("base_url") or DEFAULT_BASE).rstrip("/") + "/"
|
||||||
|
self.bot_type = config.get("bot_type", "")
|
||||||
|
self.poll_timeout_ms = int(config.get("poll_timeout_ms", DEFAULT_POLL_TIMEOUT_MS))
|
||||||
|
self.allowed_users = set(config.get("allowed_users") or [])
|
||||||
|
self._token: str = config.get("token", "")
|
||||||
|
self._get_updates_buf = ""
|
||||||
|
self._http_post = http_post or self._default_post
|
||||||
|
self._http_get = http_get or self._default_get
|
||||||
|
self._token_persist = token_persist
|
||||||
|
self._logger = logger or _log()
|
||||||
|
self._msg_cb: Callable[[InboundMessage], None] | None = None
|
||||||
|
self._stop = threading.Event()
|
||||||
|
self._thread: threading.Thread | None = None
|
||||||
|
self._poll_thread: threading.Thread | None = None
|
||||||
|
|
||||||
|
# -- IMChannel ---------------------------------------------------------
|
||||||
|
def start(self) -> None:
|
||||||
|
if not self._token:
|
||||||
|
raise WeixinApiError("no-token", "call start_login()/finish QR scan first, or set config token")
|
||||||
|
self._stop.clear()
|
||||||
|
self._poll_thread = threading.Thread(target=self._poll_loop, name="weixin-poll", daemon=True)
|
||||||
|
self._poll_thread.start()
|
||||||
|
|
||||||
|
def stop(self) -> None:
|
||||||
|
self._stop.set()
|
||||||
|
|
||||||
|
def on_message(self, cb: Callable[[InboundMessage], None]) -> None:
|
||||||
|
self._msg_cb = cb
|
||||||
|
|
||||||
|
def set_event_sink(self, sink: Callable[[str, str, dict], None]) -> None:
|
||||||
|
self._sink = sink
|
||||||
|
|
||||||
|
# -- login -------------------------------------------------------------
|
||||||
|
def start_login(self, local_tokens: list[str] | None = None) -> dict[str, str]:
|
||||||
|
"""Request a login QR; returns {qrcode, qrcode_url}. User must scan."""
|
||||||
|
body: dict[str, Any] = {"local_token_list": local_tokens or []}
|
||||||
|
if self.bot_type:
|
||||||
|
resp = self._http_post(f"ilink/bot/get_bot_qrcode?bot_type={urllib.parse.quote(self.bot_type)}", body, None, 10_000)
|
||||||
|
else:
|
||||||
|
resp = self._http_post("ilink/bot/get_bot_qrcode", body, None, 10_000)
|
||||||
|
qrcode = resp.get("qrcode")
|
||||||
|
if not qrcode:
|
||||||
|
raise WeixinApiError("invalid-qr", "微信服务没有返回二维码令牌", resp)
|
||||||
|
return {"qrcode": qrcode, "qrcode_url": resp.get("qrcode_img_content", "")}
|
||||||
|
|
||||||
|
def poll_login(self, qrcode: str, verify_code: str = "", timeout_s: float = 120) -> str:
|
||||||
|
"""Long-poll QR status until confirmed; returns the bot token."""
|
||||||
|
deadline = time.monotonic() + timeout_s
|
||||||
|
endpoint = f"ilink/bot/get_qrcode_status?qrcode={urllib.parse.quote(qrcode)}"
|
||||||
|
if verify_code:
|
||||||
|
endpoint += f"&verify_code={urllib.parse.quote(verify_code)}"
|
||||||
|
while time.monotonic() < deadline and not self._stop.is_set():
|
||||||
|
resp = self._http_get(endpoint, 40_000)
|
||||||
|
status = resp.get("status")
|
||||||
|
if status == "confirmed" or resp.get("token"):
|
||||||
|
self._token = resp["token"]
|
||||||
|
if self._token_persist:
|
||||||
|
self._token_persist(self._token)
|
||||||
|
self._logger.info("[weixin] login confirmed")
|
||||||
|
return self._token
|
||||||
|
if status in ("expired", "rejected"):
|
||||||
|
raise WeixinApiError(f"login-{status}", f"扫码登录{ '过期' if status=='expired' else '被拒绝' }")
|
||||||
|
time.sleep(1.0)
|
||||||
|
raise WeixinApiError("login-timeout", "扫码登录超时")
|
||||||
|
|
||||||
|
# -- receive -----------------------------------------------------------
|
||||||
|
def _poll_loop(self) -> None:
|
||||||
|
self._logger.info("[weixin] long-poll started")
|
||||||
|
while not self._stop.is_set():
|
||||||
|
try:
|
||||||
|
resp = self._http_post(
|
||||||
|
"ilink/bot/getupdates",
|
||||||
|
{"get_updates_buf": self._get_updates_buf, "base_info": {}},
|
||||||
|
self._token,
|
||||||
|
self.poll_timeout_ms,
|
||||||
|
)
|
||||||
|
msgs = resp.get("msgs") or []
|
||||||
|
self._get_updates_buf = resp.get("get_updates_buf", self._get_updates_buf)
|
||||||
|
for m in msgs:
|
||||||
|
self._handle(m)
|
||||||
|
except Exception as e: # noqa: BLE001 - keep polling on transient errors
|
||||||
|
self._logger.warning(f"[weixin] poll error: {e}; backoff 3s")
|
||||||
|
self._stop.wait(3)
|
||||||
|
|
||||||
|
def _handle(self, msg: dict[str, Any]) -> None:
|
||||||
|
sender = str(msg.get("from_user_id") or msg.get("sender") or "")
|
||||||
|
chat_id = sender # 1:1 DM: peer = sender
|
||||||
|
if self.allowed_users and sender not in self.allowed_users:
|
||||||
|
return
|
||||||
|
text = ""
|
||||||
|
msgtype = msg.get("msg_type", "")
|
||||||
|
if msgtype in ("text", 1, "1"):
|
||||||
|
text = msg.get("text", {}).get("content", "") if isinstance(msg.get("text"), dict) else str(msg.get("content", ""))
|
||||||
|
text = clean_control_chars(text, max_len=100000).strip()
|
||||||
|
if not text:
|
||||||
|
return
|
||||||
|
if self._msg_cb:
|
||||||
|
self._msg_cb(InboundMessage(channel=self.name, chat_id=chat_id, user_id=sender, text=text, raw={"msg": msg}))
|
||||||
|
|
||||||
|
# -- outbound ----------------------------------------------------------
|
||||||
|
def reply(self, chat_id: str, text: str) -> None:
|
||||||
|
for chunk in split_message_text(text, 2000):
|
||||||
|
self._http_post(
|
||||||
|
"ilink/bot/sendmessage",
|
||||||
|
{"to_user_id": chat_id, "msg_type": "text", "text": {"content": chunk}},
|
||||||
|
self._token,
|
||||||
|
15_000,
|
||||||
|
)
|
||||||
|
|
||||||
|
def push_event(self, chat_id: str, kind: str, payload: dict[str, Any]) -> None:
|
||||||
|
# No edit API: deltas coalesce away, only final text is delivered.
|
||||||
|
if kind == "final":
|
||||||
|
self.reply(chat_id, str(payload.get("text", "")))
|
||||||
|
elif kind == "permission":
|
||||||
|
self.reply(chat_id, _permission_text(payload))
|
||||||
|
|
||||||
|
# -- transport defaults ------------------------------------------------
|
||||||
|
def _default_post(self, endpoint: str, body: dict, token: str | None, timeout_ms: int) -> dict:
|
||||||
|
url = self.base_url + endpoint
|
||||||
|
headers = {"Content-Type": "application/json"}
|
||||||
|
if token:
|
||||||
|
headers["Authorization"] = f"Bearer {token}"
|
||||||
|
req = urllib.request.Request(url, data=json.dumps(body).encode(), headers=headers, method="POST")
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(req, timeout=timeout_ms / 1000 + 5) as resp:
|
||||||
|
return json.loads(resp.read())
|
||||||
|
except urllib.error.HTTPError as e:
|
||||||
|
raise WeixinApiError("http-error", f"{e.code} on {endpoint}", e.read()[:200]) from e
|
||||||
|
except urllib.error.URLError as e:
|
||||||
|
if "timed out" in str(e.reason):
|
||||||
|
return {} # long-poll timeout: empty tick
|
||||||
|
raise WeixinApiError("network", str(e)) from e
|
||||||
|
|
||||||
|
def _default_get(self, endpoint: str, timeout_ms: int) -> dict:
|
||||||
|
url = self.base_url + endpoint
|
||||||
|
try:
|
||||||
|
with urllib.request.urlopen(url, timeout=timeout_ms / 1000 + 5) as resp:
|
||||||
|
return json.loads(resp.read())
|
||||||
|
except urllib.error.HTTPError as e:
|
||||||
|
raise WeixinApiError("http-error", f"{e.code} on {endpoint}") from e
|
||||||
|
|
||||||
|
|
||||||
|
def _permission_text(payload: dict[str, Any]) -> str:
|
||||||
|
title = payload.get("title") or payload.get("tool", "operation")
|
||||||
|
return f"⚠️ 权限请求:{title}\n回复「允许」执行;其他回复视为拒绝。"
|
||||||
|
|
||||||
|
|
||||||
|
def _log():
|
||||||
|
import logging
|
||||||
|
|
||||||
|
return logging.getLogger("agenthub.weixin")
|
||||||
@@ -0,0 +1,171 @@
|
|||||||
|
"""Tests for the three IM channels (mock transports, no network)."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import base64
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import urllib.request
|
||||||
|
import xml.etree.ElementTree as ET
|
||||||
|
|
||||||
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
|
||||||
|
|
||||||
|
from agenthub.channels.base import clean_control_chars, split_message_text # noqa: E402
|
||||||
|
from agenthub.channels.wecom import WecomAibotChannel # noqa: E402
|
||||||
|
from agenthub.channels.wecom_app import WxMsgCrypt # noqa: E402
|
||||||
|
from agenthub.channels.weixin import WeixinChannel # noqa: E402
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# base helpers
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
def test_split_prefers_newline():
|
||||||
|
assert split_message_text("ab\ncd", 4) == ["ab", "cd"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_split_hard_cut_utf8_safe():
|
||||||
|
parts = split_message_text("你好世界", 4) # 4 bytes = 1 chinese char + part
|
||||||
|
assert all(p.encode("utf-8") for p in parts)
|
||||||
|
assert "".join(parts) == "你好世界"
|
||||||
|
|
||||||
|
|
||||||
|
def test_clean_control_chars():
|
||||||
|
assert clean_control_chars("a\u200bb\u0000c", 100) == "abc"
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# wecom aibot
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class MockWS:
|
||||||
|
def __init__(self):
|
||||||
|
self.sent = []
|
||||||
|
self.incoming = []
|
||||||
|
|
||||||
|
def connect(self):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def recv(self, timeout=1.0):
|
||||||
|
if self.incoming:
|
||||||
|
return self.incoming.pop(0)
|
||||||
|
return None
|
||||||
|
|
||||||
|
def send(self, raw):
|
||||||
|
self.sent.append(json.loads(raw))
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
def _make_wecom():
|
||||||
|
ws = MockWS()
|
||||||
|
ch = WecomAibotChannel(
|
||||||
|
{"bot_id": "b", "secret": "s", "allowed_users": ["u1"]},
|
||||||
|
ws_factory=lambda cfg: ws,
|
||||||
|
)
|
||||||
|
return ch, ws
|
||||||
|
|
||||||
|
|
||||||
|
def test_wecom_dispatch_text_and_permission():
|
||||||
|
ch, ws = _make_wecom()
|
||||||
|
got = []
|
||||||
|
ch.on_message(got.append)
|
||||||
|
ws.incoming.append(
|
||||||
|
json.dumps({"frame_id": "f1", "body": {"msgtype": "text", "from": {"userid": "u1"}, "chatid": "c1", "text": {"content": "hello\u200b"}}})
|
||||||
|
)
|
||||||
|
ch._dispatch(json.loads(ws.incoming[0]), ws)
|
||||||
|
assert len(got) == 1 and got[0].text == "hello" and got[0].chat_id == "c1"
|
||||||
|
|
||||||
|
|
||||||
|
def test_wecom_allowed_users_drops_others():
|
||||||
|
ch, ws = _make_wecom()
|
||||||
|
got = []
|
||||||
|
ch.on_message(got.append)
|
||||||
|
ch._dispatch({"frame_id": "f2", "body": {"msgtype": "text", "from": {"userid": "u2"}, "chatid": "c", "text": {"content": "x"}}}, ws)
|
||||||
|
assert got == []
|
||||||
|
|
||||||
|
|
||||||
|
def test_wecom_streaming_delta_coalesce_and_final():
|
||||||
|
ch, ws = _make_wecom()
|
||||||
|
ch._ws = ws # pretend connected (stream sends go through the socket)
|
||||||
|
ch.push_event("c1", "delta", {"text": "hello "})
|
||||||
|
ch.push_event("c1", "delta", {"text": "world"})
|
||||||
|
# force-time independent: final flushes buffer
|
||||||
|
ch.push_event("c1", "final", {"text": "hello world"})
|
||||||
|
replies = [m for m in ws.sent if m["type"] == "reply_stream"]
|
||||||
|
assert replies and replies[-1]["finished"] is True
|
||||||
|
assert replies[-1]["content"] == "hello world"
|
||||||
|
assert len({m["req_id"] for m in replies}) == 1 # same bubble
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# wecom-app crypto round-trip
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
def test_wxbiz_crypt_roundtrip():
|
||||||
|
import os
|
||||||
|
|
||||||
|
key = base64.b64encode(os.urandom(32)).decode().rstrip("=")
|
||||||
|
crypt = WxMsgCrypt("tok", key, "corp123")
|
||||||
|
nonce, ts = "n1", "1700000000"
|
||||||
|
enc = crypt.encrypt_msg("<xml>hi</xml>", nonce, ts)
|
||||||
|
payload = json.loads(enc)
|
||||||
|
assert crypt._sign(ts, nonce, payload["encrypt"]) == payload["msgsignature"]
|
||||||
|
plain = crypt._decrypt(payload["encrypt"])
|
||||||
|
assert plain == "<xml>hi</xml>"
|
||||||
|
|
||||||
|
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
# weixin
|
||||||
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
class MockHTTP:
|
||||||
|
def __init__(self, responses):
|
||||||
|
self.responses = responses
|
||||||
|
self.posts = []
|
||||||
|
|
||||||
|
def post(self, endpoint, body, token, timeout_ms):
|
||||||
|
self.posts.append((endpoint, body, token))
|
||||||
|
return self.responses.get(endpoint, {})
|
||||||
|
|
||||||
|
def get(self, endpoint, timeout_ms):
|
||||||
|
return self.responses.get(endpoint, {})
|
||||||
|
|
||||||
|
|
||||||
|
def test_weixin_login_flow():
|
||||||
|
http = MockHTTP(
|
||||||
|
{
|
||||||
|
"ilink/bot/get_bot_qrcode": {"qrcode": "qr1"},
|
||||||
|
"ilink/bot/get_qrcode_status?qrcode=qr1": {"status": "confirmed", "token": "tk"},
|
||||||
|
}
|
||||||
|
)
|
||||||
|
ch = WeixinChannel({}, http_post=http.post, http_get=http.get)
|
||||||
|
qr = ch.start_login()
|
||||||
|
assert qr["qrcode"] == "qr1"
|
||||||
|
token = ch.poll_login("qr1", timeout_s=3)
|
||||||
|
assert token == "tk" and ch._token == "tk"
|
||||||
|
|
||||||
|
|
||||||
|
def test_weixin_receive_and_reply():
|
||||||
|
http = MockHTTP({"ilink/bot/getupdates": {"msgs": [], "get_updates_buf": ""}})
|
||||||
|
ch = WeixinChannel({"token": "tk"}, http_post=http.post, http_get=http.get)
|
||||||
|
got = []
|
||||||
|
ch.on_message(got.append)
|
||||||
|
ch._handle({"from_user_id": "wxid_1", "to_user_id": "bot", "msg_type": "text", "text": {"content": " hi\u200b "}})
|
||||||
|
assert got[0].text == "hi" and got[0].chat_id == "wxid_1"
|
||||||
|
|
||||||
|
ch.reply("wxid_1", "answer")
|
||||||
|
ep, body, token = http.posts[-1]
|
||||||
|
assert ep == "ilink/bot/sendmessage" and token == "tk"
|
||||||
|
assert body["text"]["content"] == "answer"
|
||||||
|
|
||||||
|
|
||||||
|
def test_weixin_no_edit_deltas_dropped_final_sent():
|
||||||
|
http = MockHTTP({})
|
||||||
|
ch = WeixinChannel({"token": "tk"}, http_post=http.post, http_get=http.get)
|
||||||
|
ch.push_event("u", "delta", {"text": "partial"})
|
||||||
|
assert not http.posts
|
||||||
|
ch.push_event("u", "final", {"text": "full text"})
|
||||||
|
assert http.posts[-1][1]["text"]["content"] == "full text"
|
||||||
Reference in new issue
Block a user