hermes_channels.py 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684
  1. """Per-Bot messaging channels on Hermes platform adapters (Telegram, Feishu/Lark, DingTalk, WeCom).
  2. Two roles:
  3. * Service ops (``op_*``), dispatched by ``hermes_service.py`` inside one Bot's Hermes home:
  4. platform CRUD (secrets in that Bot's ``.env``, ``${VAR}`` references in ``config.yaml``
  5. under ``yaovi_channels``), connection test, pairing list/approve/revoke (Hermes PairingStore).
  6. * Bridge (``python hermes_channels.py``), one process per Bot with enabled channels, supervised
  7. by Yaovi. It only sends and receives: inbound messages from authorized senders are written
  8. to stdout as NDJSON for Yaovi to run; Yaovi sends replies back with ``send`` on stdin.
  9. Authorization is owner-only pairing (no ALLOW_ALL); unknown DM senders receive a pairing
  10. code to approve in that Bot's settings; group messages require an @mention.
  11. """
  12. from __future__ import annotations
  13. import asyncio
  14. import importlib.util
  15. import shutil
  16. import hashlib
  17. import ssl
  18. import copy
  19. import json
  20. import os
  21. import re
  22. import sys
  23. import threading
  24. import time
  25. from pathlib import Path
  26. from typing import Any
  27. ROOT = Path(__file__).resolve().parent
  28. for _p in (str(ROOT / "hermes"), str(ROOT)):
  29. if _p not in sys.path:
  30. sys.path.insert(0, _p)
  31. # Platform -> credential fields (env names Hermes adapters read natively) and options.
  32. PLATFORMS: dict[str, dict[str, Any]] = {
  33. "telegram": {"label": "Telegram", "fields": [
  34. {"key": "TELEGRAM_BOT_TOKEN", "label": "Bot Token", "secret": True, "required": True}]},
  35. "feishu": {"label": "飞书 / Lark", "fields": [
  36. {"key": "FEISHU_APP_ID", "label": "App ID", "secret": False, "required": True},
  37. {"key": "FEISHU_APP_SECRET", "label": "App Secret", "secret": True, "required": True},
  38. {"key": "FEISHU_DOMAIN", "label": "域名(feishu / lark)", "secret": False, "required": False}]},
  39. "dingtalk": {"label": "钉钉", "fields": [
  40. {"key": "DINGTALK_CLIENT_ID", "label": "Client ID (AppKey)", "secret": False, "required": True},
  41. {"key": "DINGTALK_CLIENT_SECRET", "label": "Client Secret", "secret": True, "required": True}]},
  42. "wecom": {"label": "企业微信", "fields": [
  43. {"key": "WECOM_BOT_ID", "label": "机器人 Bot ID", "secret": False, "required": True},
  44. {"key": "WECOM_SECRET", "label": "Secret", "secret": True, "required": True}]},
  45. }
  46. PLATFORMS.update({
  47. 'slack': {'label':'Slack','fields':[
  48. {'key':'SLACK_BOT_TOKEN','label':'Bot Token (xoxb-)','secret':True,'required':True},
  49. {'key':'SLACK_APP_TOKEN','label':'Socket Mode App Token (xapp-)','secret':True,'required':True}]},
  50. 'discord': {'label':'Discord','fields':[{'key':'DISCORD_BOT_TOKEN','label':'Bot Token','secret':True,'required':True}]},
  51. 'email': {'label':'Email','fields':[
  52. {'key':'EMAIL_ADDRESS','label':'邮箱地址','secret':False,'required':True},
  53. {'key':'EMAIL_PASSWORD','label':'应用密码','secret':True,'required':True},
  54. {'key':'EMAIL_IMAP_HOST','label':'IMAP TLS 主机(993)','secret':False,'required':True},
  55. {'key':'EMAIL_SMTP_HOST','label':'SMTP STARTTLS 主机(587)','secret':False,'required':True},
  56. {'key':'EMAIL_AUTHSERV_ID','label':'收信服务器 Authentication-Results authserv-id','secret':False,'required':True}]},
  57. 'signal': {'label':'Signal','fields':[
  58. {'key':'SIGNAL_HTTP_URL','label':'signal-cli HTTP 地址','secret':False,'required':True},
  59. {'key':'SIGNAL_ACCOUNT','label':'已关联 Signal 账号','secret':False,'required':True}]},
  60. 'whatsapp': {'label':'WhatsApp','fields':[]},
  61. })
  62. def preparation(name):
  63. missing=[]
  64. for module in {'slack':['slack_bolt','slack_sdk'],'discord':['discord'],'signal':['httpx'],'whatsapp':['aiohttp']}.get(name,[]):
  65. if importlib.util.find_spec(module) is None:missing.append('Python: '+module)
  66. if name=='whatsapp':
  67. from hermes_constants import get_hermes_dir
  68. if not shutil.which('node'):missing.append('Node.js')
  69. bridge=_whatsapp_bridge_directory()
  70. stamp=bridge/'node_modules/.hermes-pkg-hash'
  71. expected=hashlib.sha256((bridge/'package.json').read_bytes()).hexdigest()[:16] if (bridge/'package.json').exists() else ''
  72. manifest=bridge/'.yaovi-source-hash'
  73. source=ROOT/'hermes/scripts/whatsapp-bridge'
  74. current=_bridge_digest(bridge);wanted=_bridge_digest(source)
  75. if not stamp.exists() or stamp.read_text().strip()!=expected or not manifest.exists() or manifest.read_text().strip()!=wanted or current!=wanted:missing.append('WhatsApp bridge 固定版本依赖(通过主机打包或显式准备安装)')
  76. if not (get_hermes_dir('platforms/whatsapp/session','whatsapp/session')/'creds.json').exists():missing.append('WhatsApp 扫码关联')
  77. return {'ready':not missing,'missing':missing}
  78. HOME_ENV = {p: f"{p.upper()}_HOME_CHANNEL" for p in PLATFORMS}
  79. HOME_ENV["email"] = "EMAIL_HOME_ADDRESS"
  80. # Hardened env forced in every bridge: Yaovi is the only authorizer; groups need an @mention.
  81. FORCED_ENV = {
  82. "GATEWAY_ALLOW_ALL_USERS": "false", "GATEWAY_ALLOWED_USERS": "",
  83. **{f"{p.upper()}_ALLOW_ALL_USERS": "false" for p in PLATFORMS},
  84. **{f"{p.upper()}_ALLOWED_USERS": "" for p in PLATFORMS}, # adapter-level filter off; bridge decides
  85. "SLACK_REQUIRE_MENTION":"true", "DISCORD_REQUIRE_MENTION":"true", "SIGNAL_REQUIRE_MENTION":"true", "WHATSAPP_REQUIRE_MENTION":"true",
  86. "WHATSAPP_MODE":"bot", "WHATSAPP_GROUP_POLICY":"open", "WHATSAPP_DM_POLICY":"pairing", "EMAIL_TRUST_FROM_HEADER":"false",
  87. "TELEGRAM_REQUIRE_MENTION": "true", "DINGTALK_REQUIRE_MENTION": "true", "FEISHU_REQUIRE_MENTION": "true",
  88. "FEISHU_GROUP_POLICY": "open", "WECOM_DM_POLICY": "open", "WECOM_GROUP_POLICY": "open",
  89. }
  90. REF_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
  91. class ChannelError(Exception):
  92. def __init__(self, status: int, message: str):
  93. super().__init__(message)
  94. self.status = status
  95. def _platform(args: dict) -> str:
  96. name = str(args.get("platform") or "")
  97. if name not in PLATFORMS:
  98. raise ChannelError(400, f"不支持的渠道:{name or '(空)'}")
  99. return name
  100. def _channels() -> dict[str, dict]:
  101. from hermes_cli.config import read_raw_config
  102. data = (read_raw_config() or {}).get("yaovi_channels") or {}
  103. return {k: v for k, v in data.items() if k in PLATFORMS and isinstance(v, dict)} if isinstance(data, dict) else {}
  104. def _save_channels(channels: dict[str, dict]) -> None:
  105. from hermes_cli.config import read_raw_config, save_config
  106. cfg = read_raw_config() or {}
  107. if channels:
  108. cfg["yaovi_channels"] = channels
  109. else:
  110. cfg.pop("yaovi_channels", None)
  111. save_config(cfg)
  112. def _env() -> dict[str, str]:
  113. from hermes_cli.config import load_env
  114. try:
  115. return load_env() or {}
  116. except Exception:
  117. return {}
  118. def _store():
  119. from gateway.pairing import PairingStore
  120. return PairingStore()
  121. def _approved_sorted(name: str) -> list[dict]:
  122. """Approved users for *name*, earliest grant first (missing approved_at last)."""
  123. return sorted(
  124. _store().list_approved(name),
  125. key=lambda a: (a.get("approved_at") is None, float(a["approved_at"]) if isinstance(a.get("approved_at"), (int, float)) else 0),
  126. )
  127. def _trim_approved(name: str) -> list[dict]:
  128. """Keep at most one approved identity per platform (the earliest); revoke extras."""
  129. approved = _approved_sorted(name)
  130. if len(approved) <= 1:
  131. return approved
  132. keep, store = approved[0], _store()
  133. for extra in approved[1:]:
  134. store.revoke(name, str(extra.get("user_id")))
  135. return [keep]
  136. def _summary(name: str, cfg: dict | None, env: dict[str, str]) -> dict:
  137. cfg = cfg or {}
  138. creds = cfg.get("credentials") if isinstance(cfg.get("credentials"), dict) else {}
  139. fields = []
  140. for f in PLATFORMS[name]["fields"]:
  141. ref = creds.get(f["key"]) if isinstance(creds.get(f["key"]), str) else ""
  142. m = REF_RE.match(ref or "")
  143. value = env.get(m.group(1)) if m else None
  144. fields.append({**f, "configured": bool(value), "value": None if f["secret"] or not value else value})
  145. store = _store()
  146. return {
  147. "platform": name, "label": PLATFORMS[name]["label"], "configured": bool(cfg),
  148. "enabled": bool(cfg.get("enabled")), "fields": fields,
  149. "ready": bool(cfg) and all(x["configured"] for x in fields if x["required"]) and preparation(name)["ready"],
  150. "preparation": preparation(name),
  151. "home_channel": cfg.get("home_channel") or "", "home_channel_name": cfg.get("home_channel_name") or "",
  152. "pending": [{"code": p.get("code"), "user_id": p.get("user_id"), "user_name": p.get("user_name") or "",
  153. "age_minutes": p.get("age_minutes")} for p in store.list_pending(name)] if cfg else [],
  154. "approved": [{"user_id": a.get("user_id"), "user_name": a.get("user_name") or ""}
  155. for a in (_trim_approved(name) if cfg else [])],
  156. }
  157. def op_list(args: dict) -> dict:
  158. channels, env = _channels(), _env()
  159. return {"platforms": [_summary(n, channels.get(n), env) for n in PLATFORMS]}
  160. def op_enabled(args: dict) -> dict:
  161. """Platforms the bridge should start (enabled and fully configured)."""
  162. return {"platforms": [s["platform"] for s in op_list({})["platforms"] if s["enabled"] and s["ready"]]}
  163. def op_upsert(args: dict) -> dict:
  164. from hermes_cli.config import save_env_value, remove_env_value
  165. name = _platform(args)
  166. if name=='whatsapp' and args.get('enabled') is False:
  167. from hermes_pairing import manager
  168. from hermes_constants import get_hermes_home
  169. manager.invalidate_home(get_hermes_home())
  170. channels = _channels()
  171. previous = channels.get(name) or {}
  172. prev_creds = previous.get("credentials") if isinstance(previous.get("credentials"), dict) else {}
  173. incoming = args.get("credentials") or {}
  174. if not isinstance(incoming, dict):
  175. raise ChannelError(400, "credentials 必须是对象")
  176. creds: dict[str, str] = {}
  177. for f in PLATFORMS[name]["fields"]:
  178. key, value = f["key"], incoming.get(f["key"], True if f["key"] in prev_creds else None)
  179. if value is True and key in prev_creds: # keep stored value
  180. creds[key] = prev_creds[key]
  181. elif isinstance(value, str) and value.strip():
  182. if len(value) > 4000 or "\n" in value:
  183. raise ChannelError(400, f"{f['label']} 的值无效")
  184. save_env_value(key, value.strip())
  185. creds[key] = "${" + key + "}"
  186. elif value in (None, "", False):
  187. if f["required"]:
  188. raise ChannelError(400, f"缺少 {f['label']}")
  189. if key in prev_creds:
  190. remove_env_value(key)
  191. else:
  192. raise ChannelError(400, f"{f['label']} 的值无效")
  193. entry: dict[str, Any] = {"enabled": bool(args.get("enabled", previous.get("enabled", True))), "credentials": creds}
  194. home = str(args.get("home_channel", previous.get("home_channel") or "") or "").strip()
  195. if len(home) > 256 or "\n" in home:
  196. raise ChannelError(400, "主频道 ID 无效")
  197. if home:
  198. entry["home_channel"] = home
  199. entry["home_channel_name"] = str(args.get("home_channel_name", previous.get("home_channel_name") or "") or "")[:128]
  200. save_env_value(HOME_ENV[name], home)
  201. elif previous.get("home_channel"):
  202. remove_env_value(HOME_ENV[name])
  203. channels[name] = entry
  204. _save_channels(channels)
  205. return _summary(name, entry, _env())
  206. def op_set_enabled(args: dict) -> dict:
  207. name = _platform(args)
  208. channels = _channels()
  209. if name not in channels:
  210. raise ChannelError(404, "该渠道尚未配置")
  211. if name=='whatsapp' and not args.get('enabled'):
  212. from hermes_pairing import manager
  213. from hermes_constants import get_hermes_home
  214. manager.invalidate_home(get_hermes_home())
  215. channels[name]["enabled"] = bool(args.get("enabled"))
  216. _save_channels(channels)
  217. return _summary(name, channels[name], _env())
  218. def op_remove(args: dict) -> dict:
  219. from hermes_cli.config import remove_env_value
  220. name = _platform(args)
  221. channels = _channels()
  222. if name=='whatsapp':
  223. from hermes_pairing import manager
  224. from hermes_constants import get_hermes_home
  225. manager.invalidate_home(get_hermes_home())
  226. entry = channels.pop(name, None)
  227. if entry is None:
  228. raise ChannelError(404, "该渠道尚未配置")
  229. for key in list((entry.get("credentials") or {}).keys()) + [HOME_ENV[name]]:
  230. remove_env_value(key)
  231. store = _store()
  232. for a in store.list_approved(name):
  233. store.revoke(name, str(a.get("user_id")))
  234. store.clear_pending(name)
  235. if name=='whatsapp':
  236. from hermes_constants import get_hermes_dir
  237. session=get_hermes_dir('platforms/whatsapp/session','whatsapp/session')
  238. if session.exists():
  239. backup=session.parent/'session-backups'/str(time.time_ns());backup.parent.mkdir(parents=True,exist_ok=True,mode=0o700);os.replace(session,backup)
  240. _save_channels(channels)
  241. return {"ok": True}
  242. def op_pairing_approve(args: dict) -> dict:
  243. name = _platform(args)
  244. if name not in _channels():
  245. raise ChannelError(404, "该渠道尚未配置")
  246. code = str(args.get("code") or "").strip().upper()
  247. if not code:
  248. raise ChannelError(400, "请输入配对码")
  249. existing = _trim_approved(name)
  250. if existing:
  251. who = existing[0].get("user_name") or existing[0].get("user_id") or ""
  252. raise ChannelError(
  253. 409,
  254. f"每个渠道只能授权一位用户(当前为 {who})。请先取消其授权,再批准新的配对码。",
  255. )
  256. result = _store().approve_code(name, code)
  257. if not result:
  258. raise ChannelError(404, "配对码无效或已过期")
  259. _trim_approved(name) # defend against concurrent grants
  260. return {"user_id": result.get("user_id"), "user_name": result.get("user_name") or ""}
  261. def op_pairing_revoke(args: dict) -> dict:
  262. name = _platform(args)
  263. user = str(args.get("user_id") or "")
  264. if not _store().revoke(name, user):
  265. raise ChannelError(404, "未找到该授权用户")
  266. return {"ok": True}
  267. def op_test(args: dict) -> dict:
  268. """Connect the configured adapter once and disconnect (verifies credentials)."""
  269. name = _platform(args)
  270. if name not in _channels():
  271. raise ChannelError(404, "该渠道尚未配置")
  272. _apply_env()
  273. try:
  274. adapter = _create_adapter(name)
  275. except ChannelError:
  276. raise
  277. except Exception as e:
  278. raise ChannelError(400, f"渠道初始化失败:{e}")
  279. if name=='email' and not os.environ.get('YAOVI_HERMES_TEST_CHANNEL_ADAPTER'):
  280. import imaplib,smtplib
  281. imap=None;smtp=None
  282. try:
  283. imap=imaplib.IMAP4_SSL(adapter._imap_host,adapter._imap_port,ssl_context=ssl.create_default_context(),timeout=15)
  284. imap.login(adapter._address,adapter._password);imap.noop()
  285. smtp=smtplib.SMTP(adapter._smtp_host,adapter._smtp_port,timeout=15);smtp.starttls(context=ssl.create_default_context());smtp.login(adapter._address,adapter._password);smtp.noop()
  286. return {'ok':True}
  287. except Exception: return {'ok':False,'error':'邮件服务器认证失败,请检查TLS地址和应用密码。'}
  288. finally:
  289. if imap:
  290. try:imap.logout()
  291. except Exception:pass
  292. if smtp:
  293. try:smtp.quit()
  294. except Exception:pass
  295. async def probe():
  296. try:
  297. ok = await asyncio.wait_for(adapter.connect(), timeout=float(args.get("timeout") or 20))
  298. finally:
  299. try:
  300. await asyncio.wait_for(adapter.disconnect(), timeout=10)
  301. except Exception:
  302. pass
  303. return ok
  304. try:
  305. ok = asyncio.run(probe())
  306. except asyncio.TimeoutError:
  307. return {"ok": False, "error": "连接超时"}
  308. except Exception as e:
  309. return {"ok": False, "error": str(e)[:500] or type(e).__name__}
  310. return {"ok": ok is not False, "error": None if ok is not False else "连接失败,请检查凭据"}
  311. # ---------------------------------------------------------------- adapters
  312. def _apply_env() -> None:
  313. """Load this Bot's .env only (no system-layer channel credentials) and force hardening."""
  314. from hermes_cli.config import get_hermes_home
  315. for p in PLATFORMS:
  316. for f in PLATFORMS[p]["fields"]:
  317. os.environ.pop(f["key"], None)
  318. env_file = Path(get_hermes_home()) / ".env"
  319. if env_file.exists():
  320. from dotenv import dotenv_values
  321. for k, v in dotenv_values(env_file).items():
  322. if v is not None:
  323. os.environ[k] = v
  324. os.environ.update(FORCED_ENV)
  325. def _create_adapter(name: str):
  326. if os.environ.get("YAOVI_HERMES_TEST_OFFLINE") and os.environ.get("YAOVI_HERMES_TEST_CHANNEL_ADAPTER"):
  327. import importlib
  328. mod, _, attr = os.environ["YAOVI_HERMES_TEST_CHANNEL_ADAPTER"].partition(":")
  329. sys.path.insert(0, str(Path(mod).parent)) if "/" in mod else None
  330. factory = getattr(importlib.import_module(Path(mod).stem if "/" in mod else mod), attr)
  331. return factory(name)
  332. from hermes_cli.plugins import discover_plugins
  333. from gateway.config import Platform, PlatformConfig, load_gateway_config
  334. from gateway.platform_registry import platform_registry
  335. discover_plugins()
  336. cfg = load_gateway_config()
  337. pconfig = cfg.platforms.get(Platform(name)) or PlatformConfig(enabled=True)
  338. pconfig.enabled = True
  339. pconfig.extra = {**(pconfig.extra or {}), "require_mention": True}
  340. if name=='email':pconfig.extra.update({'unauthorized_dm_behavior':'pair','require_authenticated_sender':True})
  341. if name=='signal':
  342. pconfig.extra.update({'group_allowed_users':['*'],'require_mention':True})
  343. os.environ['SIGNAL_GROUP_ALLOWED_USERS']='*'
  344. if name=='whatsapp':
  345. pconfig.extra['bridge_script']=str(_whatsapp_bridge_directory()/'bridge.js')
  346. prep=preparation(name)
  347. if not prep['ready']:raise ChannelError(409,'、'.join(prep['missing']))
  348. if name=='signal':
  349. from plugins.platforms.signal.adapter import SignalAdapter,validate_signal_config
  350. adapter=SignalAdapter(pconfig) if validate_signal_config(pconfig) else None
  351. else:adapter = platform_registry.create_adapter(name, pconfig)
  352. if adapter is None:
  353. raise ChannelError(400, f"{PLATFORMS[name]['label']} 适配器无法创建(凭据缺失或依赖不可用)")
  354. if name=='signal':
  355. def mention(text,data):
  356. account=adapter._account_normalized;identities={v for v in [account,adapter._recipient_uuid_by_number.get(account)] if v}
  357. matched=any(str(m.get(k,'')) in identities for m in data.get('mentions',[]) for k in ('number','uuid')) or any(re.search(r'(?<![\w+])@'+re.escape(v)+r'(?![\w+])',text or '') for v in identities)
  358. if not matched:return False,text
  359. for v in identities:text=re.sub(r'(?<![\w+])@'+re.escape(v)+r'(?![\w+])','',text or '')
  360. return True,text.strip()
  361. adapter._apply_group_mention_rules=mention
  362. if name=='whatsapp':
  363. adapter._runtime_status_platform_key='yaovi:'+str(Path(os.environ['HERMES_HOME']).resolve())
  364. def checked_deps(_directory):
  365. prep=preparation(name)
  366. if not prep['ready']:raise ChannelError(409,'、'.join(prep['missing']))
  367. return True
  368. adapter._ensure_bridge_deps=checked_deps
  369. return adapter
  370. # ---------------------------------------------------------------- bridge
  371. PAIRING_TEXT = ("你好!我还不认识你。配对码:{code}\n"
  372. "请让 Bot 所有者在 Yaovi 中打开该 Bot 的设置 → 渠道,输入此配对码完成授权(1 小时内有效)。")
  373. class Bridge:
  374. def __init__(self, wire):
  375. self.wire = wire
  376. self.lock = threading.Lock()
  377. self.adapters: dict[str, Any] = {}
  378. self.loop: asyncio.AbstractEventLoop | None = None
  379. self.stopping = asyncio.Event()
  380. self.send_locks = {}
  381. def emit(self, frame: dict) -> None:
  382. with self.lock:
  383. self.wire.write(json.dumps(frame, ensure_ascii=False) + "\n")
  384. self.wire.flush()
  385. def authorized(self, platform: str, user_id: str | None) -> bool:
  386. return bool(user_id) and _store().is_approved(platform, str(user_id))
  387. async def on_event(self, platform: str, event: Any) -> None:
  388. src = getattr(event, "source", None)
  389. if src is None or getattr(src, "is_bot", False):
  390. return
  391. user_id = str(getattr(src, "user_id", "") or getattr(event, "user_id", "") or "")
  392. chat_type = str(getattr(src, "chat_type", "dm") or "dm")
  393. if platform=='slack' and isinstance(getattr(event,'raw_message',None),dict) and event.raw_message.get('channel_type')=='mpim':chat_type='group'
  394. chat_id = str(getattr(src, "chat_id", "") or "")
  395. user_name = str(getattr(src, "user_name", "") or getattr(event, "user_name", "") or "")
  396. adapter=self.adapters.get(platform)
  397. if chat_type!='dm' and adapter:
  398. raw=getattr(event,'raw_message',None)
  399. if platform=='slack':
  400. from plugins.platforms.slack.adapter import _slack_mention_detection_text
  401. ids={u for u in [getattr(adapter,'_bot_user_id',None),*getattr(adapter,'_team_bot_user_ids',{}).values()] if u}
  402. if not isinstance(raw,dict) or not adapter._slack_message_mentions_self(_slack_mention_detection_text(raw),ids):return
  403. elif platform=='discord':
  404. if raw is None or not adapter._self_is_explicitly_mentioned(raw):return
  405. elif platform=='whatsapp':
  406. if not isinstance(raw,dict) or not ({adapter._normalize_whatsapp_id(v) for v in raw.get('mentionedIds',[])} & adapter._bot_ids_from_message(raw)):return
  407. if not self.authorized(platform, user_id):
  408. if chat_type == "dm" and user_id:
  409. code = _store().generate_code(platform, user_id, user_name)
  410. if code:
  411. self.emit({"type": "pairing", "platform": platform, "userId": user_id, "userName": user_name})
  412. if platform=='email':
  413. await self.send({'platform':platform,'chatId':chat_id,'text':PAIRING_TEXT.format(code=code),'emailContext':copy.deepcopy(getattr(adapter,'_thread_context',{}).get(chat_id,{}))})
  414. else:await self.adapters[platform].send(chat_id, PAIRING_TEXT.format(code=code))
  415. return # groups: unknown senders are ignored
  416. thread = str(getattr(src, "thread_id", "") or "")
  417. key = ":".join([platform, chat_type, chat_id] + ([thread] if thread else []))
  418. media=[]
  419. from hermes_constants import get_hermes_home
  420. home=Path(get_hermes_home()).resolve()
  421. for i,value in enumerate(getattr(event,'media_urls',[]) or []):
  422. raw=str(value);raw=raw[7:] if raw.startswith('file://') else raw
  423. path=Path(raw)
  424. if not path.is_absolute() or not path.exists() or path.is_symlink():continue
  425. resolved=path.resolve()
  426. if not any(resolved.is_relative_to(home/p) for p in ['cache','image_cache','audio_cache','video_cache','document_cache']):continue
  427. if not resolved.is_file() or resolved.stat().st_size>25*1024*1024:continue
  428. types=getattr(event,'media_types',[]) or []
  429. media.append({'relativePath':resolved.relative_to(home).as_posix(),'name':resolved.name,'mimeType':types[i] if i<len(types) else 'application/octet-stream'})
  430. email_context=copy.deepcopy(getattr(self.adapters.get(platform),'_thread_context',{}).get(chat_id)) if platform=='email' else None
  431. self.emit({"type": "inbound", "platform": platform, "sessionKey": key, "chatId": chat_id, "chatType": chat_type,
  432. "chatName": str(getattr(src, "chat_name", "") or ""), "threadId": thread or None,
  433. "userId": user_id, "userName": user_name, "text": str(getattr(event, "text", "") or ""),
  434. "messageId": str(getattr(event, "message_id", "") or "") or None, "media":media, "emailContext":email_context})
  435. def install(self, platform: str, adapter: Any) -> None:
  436. async def handle_message(event): # replaces the runner path: no agent runs here
  437. try:
  438. await self.on_event(platform, event)
  439. except Exception as e:
  440. self.emit({"type": "status", "platform": platform, "state": "warning", "error": str(e)[:300]})
  441. async def noop_handler(event):
  442. return None
  443. adapter.set_message_handler(noop_handler)
  444. adapter.handle_message = handle_message
  445. adapter.set_authorization_check(lambda uid, ct=None, cid=None, **k: self.authorized(platform, uid))
  446. # Native early gates otherwise drop the first DM before Yaovi can issue a pairing code.
  447. # Only the final on_event boundary may dispatch to the Agent.
  448. if platform=='slack':
  449. adapter._early_reject_unauthorized=lambda uid,cid,is_dm: not (is_dm or self.authorized(platform,uid))
  450. if platform=='discord':
  451. adapter._is_allowed_user=lambda uid,author=None,*,guild=None,is_dm=False,channel_ids=None: bool(is_dm or self.authorized(platform,uid))
  452. async def send(self, args: dict) -> dict:
  453. platform = str(args.get("platform") or "")
  454. adapter = self.adapters.get(platform)
  455. if adapter is None:
  456. raise ChannelError(404, f"渠道 {platform} 未连接")
  457. text = str(args.get("text") or "")
  458. if not text.strip():
  459. return {"ok": True, "skipped": True}
  460. metadata = {"thread_id": args["threadId"]} if args.get("threadId") else None
  461. kw: dict[str, Any] = {"reply_to": args.get("replyTo") or None}
  462. if metadata:
  463. kw["metadata"] = metadata
  464. async with self.send_locks.setdefault(platform,asyncio.Lock()):
  465. if platform=='email' and isinstance(args.get('emailContext'),dict):
  466. adapter._thread_context[str(args.get('chatId') or '')]={k:str(v)[:1000] for k,v in args['emailContext'].items() if k in ('subject','message_id')}
  467. if platform=='email':
  468. # Build MIME before yielding: inbound mail may replace thread context meanwhile.
  469. msg,msg_id,_subject=adapter._new_reply(str(args.get('chatId') or ''),text,args.get('replyTo'))
  470. await asyncio.to_thread(adapter._smtp_send,msg)
  471. return {'ok':True,'messageId':msg_id}
  472. result = await adapter.send(str(args.get("chatId") or ""), text, **kw)
  473. ok = getattr(result, "success", True)
  474. if ok is False:
  475. raise ChannelError(502, str(getattr(result, "error", "") or "发送失败"))
  476. return {"ok": True, "messageId": getattr(result, "message_id", None)}
  477. async def command(self, msg: dict) -> None:
  478. rid, op = msg.get("id"), msg.get("op")
  479. try:
  480. if op == "send":
  481. result = await self.send(msg.get("args") or {})
  482. elif op == "status":
  483. result = {"platforms": list(self.adapters)}
  484. elif op == "stop":
  485. self.stopping.set()
  486. result = {"ok": True}
  487. else:
  488. raise ChannelError(400, f"unknown op {op}")
  489. self.emit({"id": rid, "ok": True, "result": result})
  490. except Exception as e:
  491. self.emit({"id": rid, "ok": False, "status": getattr(e, "status", 500), "error": str(e)[:500] or type(e).__name__})
  492. def read_stdin(self) -> None:
  493. for line in sys.stdin:
  494. line = line.strip()
  495. if not line:
  496. continue
  497. try:
  498. msg = json.loads(line)
  499. except ValueError:
  500. continue
  501. asyncio.run_coroutine_threadsafe(self.command(msg), self.loop)
  502. self.loop.call_soon_threadsafe(self.stopping.set)
  503. async def connect(self, platform: str) -> None:
  504. delay=5
  505. while not self.stopping.is_set():
  506. adapter=None;fatal=asyncio.Event()
  507. try:
  508. adapter=_create_adapter(platform);self.install(platform,adapter)
  509. if hasattr(adapter,'set_fatal_error_handler'):
  510. adapter.set_fatal_error_handler(lambda _adapter,event=fatal: self.loop.call_soon_threadsafe(event.set))
  511. ok=await asyncio.wait_for(adapter.connect(),timeout=60)
  512. if ok is False:raise ChannelError(502,'连接失败,请检查凭据')
  513. self.adapters[platform]=adapter
  514. self.emit({'type':'status','platform':platform,'state':'connected'});delay=5
  515. stopped=asyncio.create_task(self.stopping.wait());failed=asyncio.create_task(fatal.wait())
  516. try:await asyncio.wait([stopped,failed],return_when=asyncio.FIRST_COMPLETED)
  517. finally:
  518. stopped.cancel();failed.cancel()
  519. if self.stopping.is_set():return
  520. raise ChannelError(502,str(getattr(adapter,'fatal_error_message',None) or '渠道连接中断'))
  521. except asyncio.CancelledError:raise
  522. except Exception as e:
  523. self.emit({'type':'status','platform':platform,'state':'error','error':str(e)[:300]})
  524. if adapter is not None and getattr(adapter,'fatal_error_retryable',True) is False:return
  525. finally:
  526. if self.adapters.get(platform) is adapter:self.adapters.pop(platform,None)
  527. if adapter is not None:
  528. try:await asyncio.wait_for(adapter.disconnect(),timeout=10)
  529. except Exception:pass
  530. try:await asyncio.wait_for(self.stopping.wait(),timeout=delay)
  531. except asyncio.TimeoutError:pass
  532. delay=min(delay*2,300)
  533. async def run(self) -> None:
  534. self.loop = asyncio.get_running_loop()
  535. _apply_env()
  536. platforms = op_enabled({})["platforms"]
  537. self.emit({"type": "ready", "platforms": platforms})
  538. threading.Thread(target=self.read_stdin, daemon=True).start()
  539. tasks = [asyncio.create_task(self.connect(p)) for p in platforms]
  540. await self.stopping.wait()
  541. for t in tasks:
  542. t.cancel()
  543. await asyncio.gather(*tasks,return_exceptions=True)
  544. for adapter in list(self.adapters.values()):
  545. try:
  546. await asyncio.wait_for(adapter.disconnect(), timeout=10)
  547. except Exception:
  548. pass
  549. def main() -> None:
  550. os.environ.setdefault("HERMES_SKIP_UPDATE_CHECK", "1")
  551. os.environ["HERMES_PYTHON_SRC_ROOT"] = str(ROOT / "hermes")
  552. wire = os.fdopen(os.dup(1), "w", buffering=1, encoding="utf-8") # Hermes may rebind stdout
  553. sys.stdout = sys.stderr
  554. import hermes_service
  555. hermes_service._bootstrap() # same offline test guard as the service bridge
  556. asyncio.run(Bridge(wire).run())
  557. # Setup operations are imported by the service, never by the bridge's stdin runner.
  558. def _whatsapp_bridge_directory():
  559. from hermes_constants import get_hermes_home
  560. return Path(get_hermes_home())/'channel-tools/whatsapp-bridge'
  561. def _bridge_digest(directory):
  562. files=sorted([*directory.glob('*.js'),directory/'package.json',directory/'package-lock.json'])
  563. return hashlib.sha256(b''.join(p.name.encode()+b'\0'+p.read_bytes() for p in files if p.is_file())).hexdigest()
  564. def op_prepare(args):
  565. name=_platform(args)
  566. if name!='whatsapp':return preparation(name)
  567. import subprocess
  568. from hermes_files import _file_lock
  569. npm=shutil.which('npm');node=shutil.which('node')
  570. if not npm or not node:raise ChannelError(409,'请先在Host准备Node.js和npm;不会自动安装运行时')
  571. source=ROOT/'hermes/scripts/whatsapp-bridge';target=_whatsapp_bridge_directory()
  572. with _file_lock(target.parent/'whatsapp-prepare.lock'):
  573. target.mkdir(parents=True,exist_ok=True)
  574. for filename in [p.name for p in source.glob('*.js')]+['package.json','package-lock.json']:
  575. shutil.copyfile(source/filename,target/filename)
  576. subprocess.run([npm,'ci','--omit=dev','--ignore-scripts','--no-audit','--no-fund'],cwd=target,check=True,capture_output=True,timeout=240)
  577. (target/'node_modules/.hermes-pkg-hash').write_text(hashlib.sha256((target/'package.json').read_bytes()).hexdigest()[:16])
  578. (target/'.yaovi-source-hash').write_text(_bridge_digest(source))
  579. return preparation(name)
  580. def op_whatsapp_start(args):
  581. from hermes_pairing import manager
  582. from hermes_constants import get_hermes_home,get_hermes_dir
  583. if _channels().get('whatsapp',{}).get('enabled'):raise ChannelError(409,'请先停用WhatsApp渠道再关联,避免会话冲突。')
  584. prep=preparation('whatsapp');missing=[v for v in prep['missing'] if v!='WhatsApp 扫码关联']
  585. if missing:raise ChannelError(409,'、'.join(missing))
  586. return manager.start(get_hermes_home(),_whatsapp_bridge_directory(),get_hermes_dir('platforms/whatsapp/session','whatsapp/session'),args.get('reset',False))
  587. def op_whatsapp_apply(args):
  588. from hermes_pairing import manager
  589. from hermes_constants import get_hermes_home
  590. try:return manager.apply(args['id'],get_hermes_home(),lambda:op_upsert({'platform':'whatsapp','enabled':True,'credentials':{}}))
  591. except ValueError as e:raise ChannelError(409,str(e)) from None
  592. def op_whatsapp_status(args):
  593. from hermes_pairing import manager
  594. from hermes_constants import get_hermes_home
  595. return manager.get(args['id'],get_hermes_home())
  596. def op_whatsapp_cancel(args):
  597. from hermes_pairing import manager
  598. from hermes_constants import get_hermes_home
  599. return manager.cancel(args['id'],get_hermes_home())
  600. if __name__ == "__main__":
  601. main()