Hua/nanobot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main'

Browse Source 
# Conflicts:
#	nanobot/channels/qq.py
#	nanobot/channels/telegram.py
#	nanobot/channels/whatsapp.py
#	tests/test_qq_channel.py
This commit is contained in:
Hua
2026-03-24 12:00:05 +08:00
parent b5ef69b210 c00e64a817
commit 751e82988c
8 changed files with 374 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
bridge/src/whatsapp.ts
View File

@@ -29,6 +29,7 @@ export interface InboundMessage {
content: string;
timestamp: number;
isGroup: boolean;
wasMentioned?: boolean;
media?: string[];
}
@@ -48,6 +49,31 @@ export class WhatsAppClient {
this.options = options;
}
private normalizeJid(jid: string | undefined | null): string {
return (jid || '').split(':')[0];
}
private wasMentioned(msg: any): boolean {
if (!msg?.key?.remoteJid?.endsWith('@g.us')) return false;
const candidates = [
msg?.message?.extendedTextMessage?.contextInfo?.mentionedJid,
msg?.message?.imageMessage?.contextInfo?.mentionedJid,
msg?.message?.videoMessage?.contextInfo?.mentionedJid,
msg?.message?.documentMessage?.contextInfo?.mentionedJid,
msg?.message?.audioMessage?.contextInfo?.mentionedJid,
];
const mentioned = candidates.flatMap((items) => (Array.isArray(items) ? items : []));
if (mentioned.length === 0) return false;
const selfIds = new Set(
[this.sock?.user?.id, this.sock?.user?.lid, this.sock?.user?.jid]
.map((jid) => this.normalizeJid(jid))
.filter(Boolean),
);
return mentioned.some((jid: string) => selfIds.has(this.normalizeJid(jid)));
}
async connect(): Promise<void> {
const logger = pino({ level: 'silent' });
const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir);
@@ -145,6 +171,7 @@ export class WhatsAppClient {
if (!finalContent && mediaPaths.length === 0) continue;
const isGroup = msg.key.remoteJid?.endsWith('@g.us') || false;
const wasMentioned = this.wasMentioned(msg);
this.options.onMessage({
id: msg.key.id || '',
@@ -153,6 +180,7 @@ export class WhatsAppClient {
content: finalContent,
timestamp: msg.messageTimestamp as number,
isGroup,
...(isGroup ? { wasMentioned } : {}),
...(mediaPaths.length > 0 ? { media: mediaPaths } : {}),
});
}

5
nanobot/channels/feishu.py
View File

@@ -938,6 +938,9 @@ class FeishuChannel(BaseChannel):
reply_message_id: str | None = None
if self.config.reply_to_message and not msg.metadata.get("_progress", False):
reply_message_id = msg.metadata.get("message_id") or None
# For topic group messages, always reply to keep context in thread
elif msg.metadata.get("thread_id"):
reply_message_id = msg.metadata.get("root_id") or msg.metadata.get("message_id") or None
first_send = True
@@ -1095,6 +1098,7 @@ class FeishuChannel(BaseChannel):
parent_id = getattr(message, "parent_id", None) or None
root_id = getattr(message, "root_id", None) or None
thread_id = getattr(message, "thread_id", None) or None
if parent_id and self._client:
loop = asyncio.get_running_loop()
@@ -1120,6 +1124,7 @@ class FeishuChannel(BaseChannel):
"msg_type": msg_type,
"parent_id": parent_id,
"root_id": root_id,
"thread_id": thread_id,
}
)

253
nanobot/channels/qq.py
View File

@@ -2,11 +2,15 @@
import asyncio
import base64
import os
import re
import time
from collections import deque
from pathlib import Path
from typing import TYPE_CHECKING
from typing import TYPE_CHECKING, Any
from urllib.parse import urlparse
import aiohttp
from loguru import logger
from nanobot.bus.events import OutboundMessage
@@ -16,6 +20,11 @@ from nanobot.config.schema import QQConfig, QQInstanceConfig
from nanobot.security.network import validate_url_target
from nanobot.utils.delivery import delivery_artifacts_root, is_image_file
try:
from nanobot.config.paths import get_media_dir
except Exception: # pragma: no cover
get_media_dir = None # type: ignore
try:
import botpy
from botpy.http import Route
@@ -34,6 +43,33 @@ if TYPE_CHECKING:
from botpy.message import C2CMessage, GroupMessage
_IMAGE_EXTS = {
".png",
".jpg",
".jpeg",
".gif",
".bmp",
".webp",
".tif",
".tiff",
".ico",
".svg",
}
_SAFE_NAME_RE = re.compile(r"[^\w.\-()\[\]（）【】\u4e00-\u9fff]+", re.UNICODE)
def _sanitize_filename(name: str) -> str:
"""Sanitize filename to avoid traversal and problematic characters."""
name = Path(name or "").name.strip()
name = _SAFE_NAME_RE.sub("_", name).strip("._ ")
return name
def _is_image_name(name: str) -> bool:
"""Return whether the file name looks like an image."""
return Path(name).suffix.lower() in _IMAGE_EXTS
def _make_bot_class(channel: "QQChannel") -> "type[botpy.Client]":
"""Create a botpy Client subclass bound to the given channel."""
intents = botpy.Intents(public_messages=True, direct_message=True)
@@ -71,17 +107,21 @@ class QQChannel(BaseChannel):
def __init__(
self,
config: QQConfig | QQInstanceConfig,
config: QQConfig | QQInstanceConfig | dict,
bus: MessageBus,
workspace: str | Path | None = None,
):
if isinstance(config, dict):
config = QQConfig.model_validate(config)
super().__init__(config, bus)
self.config: QQConfig | QQInstanceConfig = config
self._client: "botpy.Client | None" = None
self._processed_ids: deque = deque(maxlen=1000)
self._http: aiohttp.ClientSession | None = None
self._processed_ids: deque[str] = deque(maxlen=1000)
self._msg_seq: int = 1 # 消息序列号，避免被 QQ API 去重
self._chat_type_cache: dict[str, str] = {}
self._workspace = Path(workspace).expanduser() if workspace is not None else None
self._media_root = self._init_media_root()
@staticmethod
def _is_remote_media(path: str) -> bool:
@@ -153,14 +193,24 @@ class QQChannel(BaseChannel):
"""Encode a local media file as base64 for QQ rich-media upload."""
return base64.b64encode(path.read_bytes()).decode("ascii")
async def _post_text_message(self, chat_id: str, msg_type: str, content: str, msg_id: str | None) -> None:
"""Send a plain-text QQ message."""
payload = {
"msg_type": 0,
"content": content,
async def _post_text_message(
self,
chat_id: str,
msg_type: str,
content: str,
msg_id: str | None,
) -> None:
"""Send a plain-text or markdown QQ message."""
use_markdown = self.config.msg_format == "markdown"
payload: dict[str, Any] = {
"msg_type": 2 if use_markdown else 0,
"msg_id": msg_id,
"msg_seq": self._next_msg_seq(),
}
if use_markdown:
payload["markdown"] = {"content": content}
else:
payload["content"] = content
if msg_type == "group":
await self._client.api.post_group_message(group_openid=chat_id, **payload)
else:
@@ -248,8 +298,24 @@ class QQChannel(BaseChannel):
msg_seq=self._next_msg_seq(),
)
def _init_media_root(self) -> Path:
"""Choose a directory for saving inbound attachments."""
if self.config.media_dir:
root = Path(self.config.media_dir).expanduser()
elif get_media_dir:
try:
root = Path(get_media_dir("qq"))
except Exception:
root = Path.home() / ".nanobot" / "media" / "qq"
else:
root = Path.home() / ".nanobot" / "media" / "qq"
root.mkdir(parents=True, exist_ok=True)
logger.info("QQ media directory: {}", str(root))
return root
async def start(self) -> None:
"""Start the QQ bot."""
"""Start the QQ bot with auto-reconnect."""
if not QQ_AVAILABLE:
logger.error("QQ SDK not installed. Run: pip install qq-botpy")
return
@@ -259,8 +325,8 @@ class QQChannel(BaseChannel):
return
self._running = True
bot_class = _make_bot_class(self)
self._client = bot_class()
self._http = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=120))
self._client = _make_bot_class(self)()
logger.info("QQ bot started (C2C & Group supported)")
await self._run_bot()
@@ -276,13 +342,20 @@ class QQChannel(BaseChannel):
await asyncio.sleep(5)
async def stop(self) -> None:
"""Stop the QQ bot."""
"""Stop bot and cleanup resources."""
self._running = False
if self._client:
try:
await self._client.close()
except Exception:
pass
self._client = None
if self._http:
try:
await self._http.close()
except Exception:
pass
self._http = None
logger.info("QQ bot stopped")
async def send(self, msg: OutboundMessage) -> None:
@@ -297,11 +370,13 @@ class QQChannel(BaseChannel):
content_sent = False
fallback_lines: list[str] = []
for media_path in msg.media:
for media_path in msg.media or []:
local_media_path: Path | None = None
local_file_type: int | None = None
if not self._is_remote_media(media_path):
local_media_path, local_file_type, publish_error = self._resolve_local_media(media_path)
local_media_path, local_file_type, publish_error = self._resolve_local_media(
media_path
)
if local_media_path is None:
logger.warning(
"QQ outbound local media could not be uploaded directly: {} ({})",
@@ -353,7 +428,9 @@ class QQChannel(BaseChannel):
logger.error("Error sending QQ media {}: {}", media_path, media_error)
if local_media_path is not None:
fallback_lines.append(
self._failed_media_notice(media_path, "QQ local file_data upload failed")
self._failed_media_notice(
media_path, "QQ local file_data upload failed"
)
)
else:
fallback_lines.append(self._failed_media_notice(media_path))
@@ -372,29 +449,161 @@ class QQChannel(BaseChannel):
async def _on_message(self, data: "C2CMessage | GroupMessage", is_group: bool = False) -> None:
"""Handle incoming message from QQ."""
try:
# Dedup by message ID
if data.id in self._processed_ids:
return
self._processed_ids.append(data.id)
content = (data.content or "").strip()
if not content:
return
if is_group:
chat_id = data.group_openid
user_id = data.author.member_openid
self._chat_type_cache[chat_id] = "group"
else:
chat_id = str(getattr(data.author, 'id', None) or getattr(data.author, 'user_openid', 'unknown'))
chat_id = str(
getattr(data.author, "id", None)
or getattr(data.author, "user_openid", "unknown")
)
user_id = chat_id
self._chat_type_cache[chat_id] = "c2c"
content = (data.content or "").strip()
attachments = getattr(data, "attachments", None) or []
media_paths, recv_lines, att_meta = await self._handle_attachments(attachments)
if recv_lines:
tag = "[Image]" if any(_is_image_name(Path(p).name) for p in media_paths) else "[File]"
file_block = "Received files:\n" + "\n".join(recv_lines)
content = f"{content}\n\n{file_block}".strip() if content else f"{tag}\n{file_block}"
if not content and not media_paths:
return
await self._handle_message(
sender_id=user_id,
chat_id=chat_id,
content=content,
metadata={"message_id": data.id},
media=media_paths or None,
metadata={
"message_id": data.id,
"attachments": att_meta,
},
)
except Exception:
logger.exception("Error handling QQ message")
async def _handle_attachments(self, attachments: list[Any]) -> tuple[list[str], list[str], list[dict[str, Any]]]:
"""Extract, download, and format QQ attachments for downstream tools."""
media_paths: list[str] = []
recv_lines: list[str] = []
att_meta: list[dict[str, Any]] = []
if not attachments:
return media_paths, recv_lines, att_meta
for att in attachments:
url = getattr(att, "url", None)
filename = getattr(att, "filename", None)
content_type = getattr(att, "content_type", None)
local_path = (
await self._download_to_media_dir_chunked(url, filename_hint=filename or "")
if url
else None
)
att_meta.append(
{
"url": url,
"filename": filename,
"content_type": content_type,
"saved_path": local_path,
}
)
shown_name = filename or url or "file"
if local_path:
media_paths.append(local_path)
recv_lines.append(f"- {shown_name}\n saved: {local_path}")
else:
recv_lines.append(f"- {shown_name}\n saved: [download failed]")
return media_paths, recv_lines, att_meta
async def _download_to_media_dir_chunked(self, url: str, filename_hint: str = "") -> str | None:
"""Download an inbound attachment using chunked streaming writes."""
if not self._http:
self._http = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=120))
safe = _sanitize_filename(filename_hint)
timestamp_ms = int(time.time() * 1000)
tmp_path: Path | None = None
try:
async with self._http.get(
url,
timeout=aiohttp.ClientTimeout(total=120),
allow_redirects=True,
) as resp:
if resp.status != 200:
logger.warning("QQ download failed: status={} url={}", resp.status, url)
return None
content_type = (resp.headers.get("Content-Type") or "").lower()
ext = Path(urlparse(url).path).suffix or Path(filename_hint).suffix
if not ext:
if "png" in content_type:
ext = ".png"
elif "jpeg" in content_type or "jpg" in content_type:
ext = ".jpg"
elif "gif" in content_type:
ext = ".gif"
elif "webp" in content_type:
ext = ".webp"
elif "pdf" in content_type:
ext = ".pdf"
else:
ext = ".bin"
if safe and not Path(safe).suffix:
safe = safe + ext
filename = safe or f"qq_file_{timestamp_ms}{ext}"
target = self._media_root / filename
if target.exists():
target = self._media_root / f"{target.stem}_{timestamp_ms}{target.suffix}"
tmp_path = target.with_suffix(target.suffix + ".part")
chunk_size = max(1024, int(self.config.download_chunk_size or 262144))
max_bytes = max(
1024 * 1024,
int(self.config.download_max_bytes or (200 * 1024 * 1024)),
)
downloaded = 0
def _open_tmp() -> Any:
tmp_path.parent.mkdir(parents=True, exist_ok=True)
return open(tmp_path, "wb") # noqa: SIM115
f = await asyncio.to_thread(_open_tmp)
try:
async for chunk in resp.content.iter_chunked(chunk_size):
if not chunk:
continue
downloaded += len(chunk)
if downloaded > max_bytes:
logger.warning(
"QQ download exceeded max_bytes={} url={} -> abort",
max_bytes,
url,
)
return None
await asyncio.to_thread(f.write, chunk)
finally:
await asyncio.to_thread(f.close)
await asyncio.to_thread(os.replace, tmp_path, target)
tmp_path = None
logger.info("QQ file saved: {}", str(target))
return str(target)
except Exception as e:
logger.error("QQ download error: {}", e)
return None
finally:
if tmp_path is not None:
try:
tmp_path.unlink(missing_ok=True)
except Exception:
pass

17
nanobot/channels/telegram.py
View File

@@ -10,7 +10,7 @@ from dataclasses import dataclass
from typing import Any
from loguru import logger
from telegram import BotCommand, ReplyParameters, Update
from telegram import BotCommand, ReactionTypeEmoji, ReplyParameters, Update
from telegram.error import TimedOut
from telegram.ext import Application, CommandHandler, ContextTypes, MessageHandler, filters
from telegram.request import HTTPXRequest
@@ -800,6 +800,7 @@ class TelegramChannel(BaseChannel):
"session_key": session_key,
}
self._start_typing(str_chat_id)
await self._add_reaction(str_chat_id, message.message_id, self.config.react_emoji)
buf = self._media_group_buffers[key]
if content and content != "[empty message]":
buf["contents"].append(content)
@@ -810,6 +811,7 @@ class TelegramChannel(BaseChannel):
# Start typing indicator before processing
self._start_typing(str_chat_id)
await self._add_reaction(str_chat_id, message.message_id, self.config.react_emoji)
# Forward to the message bus
await self._handle_message(
@@ -849,6 +851,19 @@ class TelegramChannel(BaseChannel):
if task and not task.done():
task.cancel()
async def _add_reaction(self, chat_id: str, message_id: int, emoji: str) -> None:
"""Add an emoji reaction best-effort without interrupting message handling."""
if not self._app or not emoji:
return
try:
await self._app.bot.set_message_reaction(
chat_id=int(chat_id),
message_id=message_id,
reaction=[ReactionTypeEmoji(emoji=emoji)],
)
except Exception as e:
logger.debug("Telegram reaction failed: {}", e)
async def _typing_loop(self, chat_id: str) -> None:
"""Repeatedly send 'typing' action until cancelled."""
try:

10
nanobot/channels/whatsapp.py
View File

@@ -32,7 +32,9 @@ class WhatsAppChannel(BaseChannel):
def default_config(cls) -> dict[str, object]:
return WhatsAppConfig().model_dump(by_alias=True)
def __init__(self, config: WhatsAppConfig | WhatsAppInstanceConfig, bus: MessageBus):
def __init__(self, config: WhatsAppConfig | WhatsAppInstanceConfig | dict, bus: MessageBus):
if isinstance(config, dict):
config = WhatsAppConfig.model_validate(config)
super().__init__(config, bus)
self.config: WhatsAppConfig | WhatsAppInstanceConfig = config
self._ws = None
@@ -175,6 +177,12 @@ class WhatsAppChannel(BaseChannel):
self._processed_message_ids.popitem(last=False)
# Extract just the phone number or lid as chat_id
is_group = data.get("isGroup", False)
was_mentioned = data.get("wasMentioned", False)
if is_group and self.config.group_policy == "mention" and not was_mentioned:
return
user_id = pn if pn else sender
sender_id = user_id.split("@")[0] if "@" in user_id else user_id
logger.info("Sender {}", sender)

6
nanobot/config/schema.py
View File

@@ -21,6 +21,7 @@ class WhatsAppConfig(Base):
bridge_url: str = "ws://localhost:3001"
bridge_token: str = "" # Shared token for bridge auth (optional, recommended)
allow_from: list[str] = Field(default_factory=list) # Allowed phone numbers
group_policy: Literal["open", "mention"] = "open"
class WhatsAppInstanceConfig(WhatsAppConfig):
@@ -46,6 +47,7 @@ class TelegramConfig(Base):
None # HTTP/SOCKS5 proxy URL, e.g. "http://127.0.0.1:7890" or "socks5://127.0.0.1:1080"
)
reply_to_message: bool = False # If true, bot replies quote the original message
react_emoji: str = "👀"
group_policy: Literal["open", "mention"] = "mention" # "mention" responds when @mentioned or replied to, "open" responds to all
connection_pool_size: int = 32 # Outbound Telegram API HTTP pool size
pool_timeout: float = 5.0 # Shared HTTP pool timeout for bot sends and getUpdates
@@ -319,6 +321,10 @@ class QQConfig(Base):
app_id: str = "" # 机器人 ID (AppID) from q.qq.com
secret: str = "" # 机器人密钥 (AppSecret) from q.qq.com
allow_from: list[str] = Field(default_factory=list) # Allowed user openids
msg_format: Literal["plain", "markdown"] = "plain"
media_dir: str = ""
download_chunk_size: int = 1024 * 256
download_max_bytes: int = 1024 * 1024 * 200
media_base_url: str = "" # Public base URL used to expose workspace/out QQ media files

30
tests/test_qq_channel.py
View File

@@ -80,6 +80,7 @@ async def test_on_group_message_routes_to_group_chat_id() -> None:
content="hello",
group_openid="group123",
author=SimpleNamespace(member_openid="user1"),
attachments=[],
)
await channel._on_message(data, is_group=True)
@@ -142,6 +143,35 @@ async def test_send_c2c_message_uses_plain_text_c2c_api_with_msg_seq() -> None:
assert not channel._client.api.group_calls
@pytest.mark.asyncio
async def test_send_group_message_uses_markdown_when_configured() -> None:
channel = QQChannel(
QQConfig(app_id="app", secret="secret", allow_from=["*"], msg_format="markdown"),
MessageBus(),
)
channel._client = _FakeClient()
channel._chat_type_cache["group123"] = "group"
await channel.send(
OutboundMessage(
channel="qq",
chat_id="group123",
content="**hello**",
metadata={"message_id": "msg1"},
)
)
assert len(channel._client.api.group_calls) == 1
call = channel._client.api.group_calls[0]
assert call == {
"group_openid": "group123",
"msg_type": 2,
"markdown": {"content": "**hello**"},
"msg_id": "msg1",
"msg_seq": 2,
}
@pytest.mark.asyncio
async def test_send_group_remote_media_url_uses_file_api_then_media_message(monkeypatch) -> None:
channel = QQChannel(QQConfig(app_id="app", secret="secret", allow_from=["*"]), MessageBus())

49
tests/test_whatsapp_channel.py
View File

@@ -106,3 +106,52 @@ async def test_send_when_disconnected_is_noop():
await ch.send(msg)
ch._ws.send.assert_not_called()
@pytest.mark.asyncio
async def test_group_policy_mention_skips_unmentioned_group_message():
ch = WhatsAppChannel({"enabled": True, "groupPolicy": "mention"}, MagicMock())
ch._handle_message = AsyncMock()
await ch._handle_bridge_message(
json.dumps(
{
"type": "message",
"id": "m1",
"sender": "12345@g.us",
"pn": "user@s.whatsapp.net",
"content": "hello group",
"timestamp": 1,
"isGroup": True,
"wasMentioned": False,
}
)
)
ch._handle_message.assert_not_called()
@pytest.mark.asyncio
async def test_group_policy_mention_accepts_mentioned_group_message():
ch = WhatsAppChannel({"enabled": True, "groupPolicy": "mention"}, MagicMock())
ch._handle_message = AsyncMock()
await ch._handle_bridge_message(
json.dumps(
{
"type": "message",
"id": "m1",
"sender": "12345@g.us",
"pn": "user@s.whatsapp.net",
"content": "hello @bot",
"timestamp": 1,
"isGroup": True,
"wasMentioned": True,
}
)
)
ch._handle_message.assert_awaited_once()
kwargs = ch._handle_message.await_args.kwargs
assert kwargs["chat_id"] == "12345@g.us"
assert kwargs["sender_id"] == "user"