cleanup: archive unused scripts, finalize docs
- Moved old GDB hook and memory monitor scripts to archive/ - Updated README with final Docker solution - Updated .env.example, .gitignore - Added final-note.md documenting deployment decision - All research scripts preserved in archive/ for reference
This commit is contained in:
@@ -0,0 +1,703 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
MoWeChat — 莫荷微信 Bot (Linux iLink 版)
|
||||
|
||||
替换方案：将 Windows wxhelper DLL 注入方案替换为腾讯官方 iLink Bot API。
|
||||
架构：微信 → iLink Bot API (ilinkai.weixin.qq.com) → Hermes Gateway (:8642)
|
||||
|
||||
依赖:
|
||||
pip install weixin-bot-sdk aiohttp requests
|
||||
|
||||
首次运行：
|
||||
python3 wechat_agent.py
|
||||
终端显示二维码 → 用莫荷的手机微信扫码 → 凭证保存后自动运行
|
||||
|
||||
版本: 1.0
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from http.server import HTTPServer, BaseHTTPRequestHandler
|
||||
from urllib.parse import urlparse
|
||||
|
||||
from weixin_bot import WeixinBot, IncomingMessage
|
||||
|
||||
# ── Configuration ──────────────────────────────────────────────
|
||||
|
||||
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
||||
PROJECT_ROOT = os.path.dirname(SCRIPT_DIR) # gateway/
|
||||
AGENTS_ROOT = os.path.dirname(PROJECT_ROOT) # AgentsMeeting/
|
||||
LOG_DIR = os.path.join(AGENTS_ROOT, "logs")
|
||||
TEMP_DIR = os.path.join(AGENTS_ROOT, "temp")
|
||||
|
||||
# Hermes Gateway — same endpoint as Windows wechat_agent.py uses
|
||||
HERMES_API = "http://192.168.1.246:8642/v1/chat/completions"
|
||||
HERMES_KEY = "hermes123"
|
||||
|
||||
# Mohe's iLink Bot user_id (set after login)
|
||||
MOHE_USER_ID = None
|
||||
|
||||
# ── Setup ──────────────────────────────────────────────────────
|
||||
|
||||
os.makedirs(LOG_DIR, exist_ok=True)
|
||||
os.makedirs(TEMP_DIR, exist_ok=True)
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s [%(levelname)s] %(message)s",
|
||||
datefmt="%H:%M:%S",
|
||||
handlers=[
|
||||
logging.FileHandler(os.path.join(LOG_DIR, "wechat_agent_linux.log"), encoding="utf-8"),
|
||||
logging.StreamHandler(),
|
||||
],
|
||||
)
|
||||
log = logging.getLogger("mohe")
|
||||
|
||||
# ── PID lock ───────────────────────────────────────────────────
|
||||
|
||||
PID_FILE = os.path.join(TEMP_DIR, "wechat_agent_linux.pid")
|
||||
|
||||
|
||||
def acquire_pid_lock():
|
||||
"""Write PID file, exit if another instance is running."""
|
||||
if os.path.exists(PID_FILE):
|
||||
try:
|
||||
with open(PID_FILE) as f:
|
||||
old_pid = int(f.read().strip())
|
||||
# Check if process still exists
|
||||
os.kill(old_pid, 0)
|
||||
log.error(f"Another instance running (PID {old_pid}). Exiting.")
|
||||
sys.exit(1)
|
||||
except (ProcessLookupError, ValueError):
|
||||
pass # Stale PID file
|
||||
with open(PID_FILE, "w") as f:
|
||||
f.write(str(os.getpid()))
|
||||
|
||||
|
||||
def release_pid_lock():
|
||||
try:
|
||||
os.remove(PID_FILE)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
# ── Hermes Gateway API ─────────────────────────────────────────
|
||||
|
||||
import requests as _requests
|
||||
|
||||
|
||||
def call_hermes(wxid_or_user: str, content: str) -> str | None:
|
||||
"""
|
||||
Send message to Hermes Gateway, get reply.
|
||||
Returns the reply text, or None if silent/no reply.
|
||||
"""
|
||||
headers = {
|
||||
"Authorization": f"Bearer {HERMES_KEY}",
|
||||
"X-Hermes-Session-Id": "sisyphus",
|
||||
"Content-Type": "application/json",
|
||||
}
|
||||
|
||||
is_group = "@chatroom" in wxid_or_user
|
||||
system_prompt = (
|
||||
"你是莫荷，女生。群聊中回复要短。"
|
||||
if is_group
|
||||
else "你是莫荷，女生。回复简短自然，像朋友聊天。"
|
||||
)
|
||||
|
||||
# Prefix with sender info like the Windows version does
|
||||
chat_type = "Group" if is_group else "Private"
|
||||
prefixed = f"[{chat_type}][{wxid_or_user}] {content}"
|
||||
|
||||
body = {
|
||||
"model": "hermes-agent",
|
||||
"messages": [
|
||||
{"role": "system", "content": system_prompt},
|
||||
{"role": "user", "content": prefixed},
|
||||
],
|
||||
}
|
||||
|
||||
try:
|
||||
r = _requests.post(
|
||||
HERMES_API,
|
||||
json=body,
|
||||
headers=headers,
|
||||
timeout=60,
|
||||
)
|
||||
if r.status_code == 200:
|
||||
data = r.json()
|
||||
choice = data["choices"][0]
|
||||
finish_reason = choice.get("finish_reason", "")
|
||||
if finish_reason == "silent":
|
||||
log.info("Hermes: __SILENT__ (group skip)")
|
||||
return None
|
||||
return choice["message"]["content"]
|
||||
log.warning(f"Hermes HTTP {r.status_code}: {r.text[:200]}")
|
||||
except Exception as e:
|
||||
log.error(f"Hermes API error: {e}")
|
||||
return None
|
||||
|
||||
|
||||
# ── Image Generation (SenseNova) ───────────────────────────────
|
||||
|
||||
SENSENOVA_KEY = "sk-aRNj3UwKSLPsDfh15QNTPwbHxahblfaO"
|
||||
SENSENOVA_URL = "https://token.sensenova.cn/v1"
|
||||
|
||||
|
||||
def generate_image(prompt: str, ratio: str = "1:1") -> str | None:
|
||||
"""Generate image via SenseNova API. Returns URL or None."""
|
||||
size_map = {
|
||||
"1:1": "2048x2048", "16:9": "2752x1536", "9:16": "1536x2752",
|
||||
"3:2": "2496x1664", "2:3": "1664x2496", "3:4": "1760x2368", "4:3": "2368x1760",
|
||||
}
|
||||
size = size_map.get(ratio, "2048x2048")
|
||||
try:
|
||||
r = _requests.post(
|
||||
SENSENOVA_URL + "/images/generations",
|
||||
json={
|
||||
"model": "sensenova-u1-fast",
|
||||
"prompt": prompt,
|
||||
"size": size,
|
||||
"response_format": "url",
|
||||
},
|
||||
headers={
|
||||
"Authorization": f"Bearer {SENSENOVA_KEY}",
|
||||
"Content-Type": "application/json",
|
||||
},
|
||||
timeout=180,
|
||||
)
|
||||
if r.status_code == 200:
|
||||
return r.json()["data"][0]["url"]
|
||||
log.warning(f"Image gen HTTP {r.status_code}: {r.text[:200]}")
|
||||
except Exception as e:
|
||||
log.error(f"Image gen error: {e}")
|
||||
return None
|
||||
|
||||
|
||||
# ── OCR via Doubao Vision API ──────────────────────────────────
|
||||
|
||||
DOUBAO_KEY = "b0359bed-09f2-49e2-a53c-32ba057412e3"
|
||||
|
||||
|
||||
def ocr_image_from_url(img_url: str) -> str | None:
|
||||
"""Download image from URL and OCR it. Returns text or None."""
|
||||
try:
|
||||
r = _requests.get(img_url, timeout=30)
|
||||
if r.status_code != 200:
|
||||
log.warning(f"Image download HTTP {r.status_code}")
|
||||
return None
|
||||
import base64
|
||||
b64 = base64.b64encode(r.content).decode()
|
||||
return _ocr_base64(b64)
|
||||
except Exception as e:
|
||||
log.error(f"Image download/OCR error: {e}")
|
||||
return None
|
||||
|
||||
|
||||
def _ocr_base64(b64_data: str) -> str | None:
|
||||
"""OCR from base64-encoded image data."""
|
||||
try:
|
||||
r = _requests.post(
|
||||
"https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions",
|
||||
json={
|
||||
"model": "doubao-seed-code",
|
||||
"messages": [{
|
||||
"role": "user",
|
||||
"content": [
|
||||
{"type": "text", "text": "请识别这张图片中的所有中文和英文字符，保持原文输出，包括数字、表格、百分比的完整结构。严格逐行逐列输出所有数据，不要省略、不要总结。"},
|
||||
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64_data}"}},
|
||||
],
|
||||
}],
|
||||
},
|
||||
headers={"Authorization": f"Bearer {DOUBAO_KEY}", "Content-Type": "application/json"},
|
||||
timeout=60,
|
||||
)
|
||||
if r.status_code == 200:
|
||||
text = r.json()["choices"][0]["message"]["content"].strip()
|
||||
log.info(f"OCR OK ({len(text)} chars)")
|
||||
return text
|
||||
log.warning(f"OCR HTTP {r.status_code}: {r.text[:200]}")
|
||||
except Exception as e:
|
||||
log.error(f"OCR error: {e}")
|
||||
return None
|
||||
|
||||
|
||||
# ── Article Processor ──────────────────────────────────────────
|
||||
|
||||
def fetch_article(url: str) -> dict | None:
|
||||
"""Fetch article content via local article_processor (:5810)."""
|
||||
try:
|
||||
import urllib.request as ur
|
||||
req = ur.Request(
|
||||
"http://127.0.0.1:5810/process",
|
||||
data=json.dumps({"url": url}).encode("utf-8"),
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
with ur.urlopen(req, timeout=180) as resp:
|
||||
result = json.loads(resp.read().decode("utf-8"))
|
||||
if result.get("status") == "ok":
|
||||
return {
|
||||
"title": result.get("title", ""),
|
||||
"content": result.get("content", "")[:3000],
|
||||
"images": result.get("images_ocr", 0),
|
||||
}
|
||||
log.warning(f"Article processor error: {result.get('error','')[:100]}")
|
||||
except Exception as e:
|
||||
log.error(f"Article fetch error: {e}")
|
||||
return None
|
||||
|
||||
|
||||
# ── Main Message Handler ──────────────────────────────────────
|
||||
|
||||
def detect_group(msg: IncomingMessage) -> str:
|
||||
"""
|
||||
Detect if a message is from a group chat.
|
||||
Returns the group_id if it's a group, or empty string if private chat.
|
||||
"""
|
||||
raw = msg.raw
|
||||
# Check group_id field directly from protocol
|
||||
gid = raw.get("group_id", "") or ""
|
||||
if gid:
|
||||
return gid
|
||||
# Also check session_id for group patterns (contains 'chatroom' or multiple '@')
|
||||
session_id = raw.get("session_id", "") or ""
|
||||
if "@chatroom" in session_id:
|
||||
return session_id.split("#")[0] if "#" in session_id else session_id
|
||||
return ""
|
||||
|
||||
|
||||
def extract_article_url(text: str) -> str | None:
|
||||
"""Extract article URL from text. Supports WeChat public accounts, Xiaohongshu, and common share links."""
|
||||
patterns = [
|
||||
r"https?://mp\.weixin\.qq\.com[^\"'\s<)<>\[\]]+",
|
||||
r"https?://(?:www\.)?xiaohongshu\.com[^\"'\s<)<>\[\]]+",
|
||||
r"https?://xhslink\.com[^\"'\s<)<>\[\]]+",
|
||||
r"https?://(?:www\.)?zhihu\.com[^\"'\s<)<>\[\]]+",
|
||||
]
|
||||
for p in patterns:
|
||||
m = re.search(p, text)
|
||||
if m:
|
||||
return m.group(0)
|
||||
return None
|
||||
|
||||
|
||||
async def handle_incoming(msg: IncomingMessage, bot: WeixinBot):
|
||||
"""Process an incoming message from WeChat via iLink SDK."""
|
||||
log.info(f"[{msg.type}] {msg.user_id}: {(msg.text or '')[:80]}")
|
||||
|
||||
fu = msg.user_id
|
||||
content = msg.text or ""
|
||||
msg_type = msg.type
|
||||
|
||||
# ── Group chat detection ──
|
||||
group_id = detect_group(msg)
|
||||
if group_id:
|
||||
log.info(f"GROUP message from {group_id}, sender={fu}")
|
||||
# Use the group_id as the conversation identifier (like Windows version uses roomid)
|
||||
conv_id = group_id
|
||||
prefix = "[Group]"
|
||||
else:
|
||||
conv_id = fu
|
||||
prefix = "[Private]"
|
||||
|
||||
# ── TEXT message ──
|
||||
if msg_type == "text":
|
||||
handler_input = content
|
||||
|
||||
# Check for ref_msg (forwarded/quoted content like articles)
|
||||
ref_text = ""
|
||||
for item in msg.raw.get("item_list", []):
|
||||
ref_msg = item.get("ref_msg")
|
||||
if ref_msg:
|
||||
ref_title = ref_msg.get("title", "")
|
||||
ref_item = ref_msg.get("message_item", {})
|
||||
if isinstance(ref_item, dict) and ref_item.get("type") == 1:
|
||||
ref_text_data = ref_item.get("text_item", {}).get("text", "")
|
||||
if ref_text_data:
|
||||
ref_text = f"\n[引用消息] {ref_text_data[:500]}"
|
||||
if ref_title:
|
||||
handler_input = f"[老莫转发了一篇文章] 标题: {ref_title}\n\n{content}{ref_text}"
|
||||
|
||||
# Detect article URLs (WeChat public account, Xiaohongshu, etc.)
|
||||
article_url = extract_article_url(handler_input)
|
||||
if article_url:
|
||||
log.info(f"Article URL detected: {article_url[:80]}")
|
||||
article = fetch_article(article_url)
|
||||
if article:
|
||||
title = article.get("title", "")
|
||||
article_text = article.get("content", "")[:2000]
|
||||
images = article.get("images", 0)
|
||||
handler_input = (
|
||||
f"[老莫转发了一篇文章]\n标题: {title}\n"
|
||||
+ (f"（{images}张图片已OCR）\n" if images else "")
|
||||
+ f"\n{article_text}"
|
||||
)
|
||||
else:
|
||||
# Article processor failed, send original content
|
||||
log.warning("Article processor returned no content, sending raw text")
|
||||
|
||||
reply = call_hermes(conv_id, handler_input)
|
||||
if reply and reply.strip():
|
||||
await process_reply(reply, conv_id, bot)
|
||||
|
||||
# ── IMAGE message ──
|
||||
elif msg_type == "image":
|
||||
log.info(f"Image from {conv_id}, attempting OCR...")
|
||||
|
||||
# Get image URL from the raw message
|
||||
img_url = None
|
||||
for item in msg.raw.get("item_list", []):
|
||||
if item.get("type") in (2,): # IMAGE
|
||||
img_item = item.get("image_item", {})
|
||||
img_url = img_item.get("url", "")
|
||||
if not img_url:
|
||||
# CDN media - download via CDN API
|
||||
media = img_item.get("media", {})
|
||||
if media:
|
||||
log.info("Image has CDN media, attempting CDN download...")
|
||||
img_url = download_cdn_image(media)
|
||||
break
|
||||
|
||||
ocr_text = None
|
||||
if img_url:
|
||||
ocr_text = ocr_image_from_url(img_url)
|
||||
if not ocr_text:
|
||||
log.warning("OCR returned no text from image URL")
|
||||
else:
|
||||
log.info("No image URL available, cannot OCR")
|
||||
|
||||
if ocr_text:
|
||||
handler_input = f"[老莫发送了一张图片，OCR识别结果如下]\n{ocr_text}"
|
||||
else:
|
||||
handler_input = "[老莫发送了一张图片，但无法识别图片内容]"
|
||||
|
||||
reply = call_hermes(conv_id, handler_input)
|
||||
if reply and reply.strip():
|
||||
await bot.reply(msg, reply.strip())
|
||||
|
||||
# ── VOICE message ──
|
||||
elif msg_type == "voice":
|
||||
reply = call_hermes(conv_id, "[voice message]")
|
||||
if reply and reply.strip():
|
||||
await bot.reply(msg, reply.strip())
|
||||
|
||||
# ── Unknown type ──
|
||||
else:
|
||||
log.info(f"Unhandled message type: {msg_type}")
|
||||
|
||||
|
||||
def download_cdn_image(media: dict) -> str | None:
|
||||
"""
|
||||
Download an image from WeChat CDN using the iLink media protocol.
|
||||
The media dict contains aes_key and encrypt_query_param for AES-128-ECB decryption.
|
||||
For now, this is a placeholder - CDN download requires AES decryption.
|
||||
"""
|
||||
logger = log
|
||||
logger.info(f"CDN media available but direct download not yet implemented")
|
||||
logger.debug(f"CDN media keys: {list(media.keys())}")
|
||||
return None
|
||||
|
||||
|
||||
async def process_reply(reply: str, fu: str, bot: WeixinBot):
|
||||
"""
|
||||
Process Hermes reply text, handling tags like [FILE], [IMG], [EMOJI].
|
||||
Uses bot.reply(msg) or bot.send(user_id, text) based on context.
|
||||
"""
|
||||
if not reply or not reply.strip():
|
||||
return
|
||||
|
||||
clean = reply
|
||||
|
||||
# ── [FILE] tag ──
|
||||
fm = re.search(r'\[FILE\](.*?)\[/FILE\]', clean)
|
||||
if fm:
|
||||
url = fm.group(1).strip()
|
||||
log.info(f"[FILE] URL: {url}")
|
||||
# iLink doesn't natively support file sending via simple URL.
|
||||
# Send as text with download link for now.
|
||||
clean = re.sub(r'\s*\[FILE\].*?\[/FILE\]\s*', '', clean).strip()
|
||||
extra = f"\n文件链接: {url}"
|
||||
if clean.strip():
|
||||
clean += extra
|
||||
else:
|
||||
clean = f"文件: {url}"
|
||||
|
||||
# ── [IMG] tag ──
|
||||
im = re.search(r'\[IMG\](.*?)\[/IMG\]', clean)
|
||||
if im:
|
||||
cmd = im.group(1).strip()
|
||||
clean = re.sub(r'\s*\[IMG\].*?\[/IMG\]\s*', '', clean).strip()
|
||||
|
||||
if cmd.startswith("generate:") or cmd.startswith("draw:"):
|
||||
parts = cmd.split(":", 1)[1].strip()
|
||||
ratio = "1:1"
|
||||
if "|" in parts:
|
||||
ratio = parts.split("|")[1].strip()
|
||||
prompt = parts.split("|")[0].strip()
|
||||
else:
|
||||
prompt = parts
|
||||
log.info(f"[IMG] generate: {prompt[:40]} [{ratio}]")
|
||||
img_url = generate_image(prompt, ratio)
|
||||
if img_url:
|
||||
# For images, we can't send via iLink natively yet.
|
||||
# Send the URL as a text message.
|
||||
extra = f"\n图片已生成: {img_url}"
|
||||
if clean.strip():
|
||||
clean += extra
|
||||
else:
|
||||
clean = f"图片已生成: {img_url}"
|
||||
else:
|
||||
extra = "\n[图片生成失败]"
|
||||
clean += extra if clean.strip() else extra.strip()
|
||||
else:
|
||||
# Regular image URL
|
||||
extra = f"\n图片: {cmd}"
|
||||
if clean.strip():
|
||||
clean += extra
|
||||
else:
|
||||
clean = f"图片: {cmd}"
|
||||
|
||||
# ── [EMOJI] tag ──
|
||||
em = re.search(r'\[EMOJI\](.*?)\[/EMOJI\]', clean)
|
||||
if em:
|
||||
url = em.group(1).strip()
|
||||
log.info(f"[EMOJI] URL: {url}")
|
||||
clean = re.sub(r'\s*\[EMOJI\].*?\[/EMOJI\]\s*', '', clean).strip()
|
||||
|
||||
# ── [CONTACT] tag — not supported via iLink ──
|
||||
clean = re.sub(r'\s*\[CONTACT:\w+\]\s*', '', clean)
|
||||
|
||||
# ── [ROOM_MEMBERS] tag — not supported via iLink ──
|
||||
clean = re.sub(r'\s*\[ROOM_MEMBERS:\S+\]\s*', '', clean)
|
||||
|
||||
# ── [HISTORY] tag — not supported via iLink ──
|
||||
clean = re.sub(r'\s*\[HISTORY:\S+?:\d+\]\s*', '', clean)
|
||||
|
||||
# ── [PAT] tag — not supported via iLink ──
|
||||
clean = re.sub(r'\s*\[PAT:\S+:\S+\]\s*', '', clean)
|
||||
|
||||
# ── Send remaining text ──
|
||||
clean = clean.strip()
|
||||
if clean:
|
||||
await bot.send(fu, clean)
|
||||
|
||||
|
||||
# ── 5801 HTTP Server ──────────────────────────────────────────
|
||||
# Receives messages from Hermes/xxm to forward to WeChat.
|
||||
# Uses asyncio queue to bridge sync HTTP → async iLink SDK.
|
||||
|
||||
_message_queue: asyncio.Queue[dict] = asyncio.Queue()
|
||||
_http_server_ready = threading.Event()
|
||||
|
||||
|
||||
class HermesMsgHandler(BaseHTTPRequestHandler):
|
||||
"""HTTP server that receives Hermes messages and queues them for iLink sending."""
|
||||
|
||||
def do_POST(self):
|
||||
body = self.rfile.read(int(self.headers.get("Content-Length", 0)))
|
||||
try:
|
||||
d = json.loads(body)
|
||||
log.info(f"5801 POST: {json.dumps(d, ensure_ascii=False)[:200]}")
|
||||
|
||||
to = d.get("to", "") or d.get("wxid", "")
|
||||
msg = d.get("message", "") or d.get("content", "")
|
||||
path = self.path
|
||||
|
||||
# History query endpoint
|
||||
if path in ("/history", "/api/chatHistory"):
|
||||
wxid = d.get("wxid", "") or d.get("to", "")
|
||||
count = d.get("count", 10) or d.get("limit", 10)
|
||||
self._send_json({
|
||||
"ok": True,
|
||||
"note": "iLink SDK does not support history query. Use Hermes session_search instead.",
|
||||
"messages": [],
|
||||
})
|
||||
return
|
||||
|
||||
# Stop endpoint
|
||||
if path == "/stop":
|
||||
_message_queue.put_nowait({"type": "stop"})
|
||||
self._send_json({"ok": True, "status": "stopped"})
|
||||
return
|
||||
|
||||
# Queue the message for async processing (queue consumed by the iLink message loop)
|
||||
_message_queue.put_nowait({
|
||||
"type": "outgoing",
|
||||
"to": to,
|
||||
"message": msg,
|
||||
})
|
||||
|
||||
except Exception as e:
|
||||
log.error(f"5801 handler error: {e}")
|
||||
self.send_response(200)
|
||||
self.end_headers()
|
||||
|
||||
def do_GET(self):
|
||||
parsed = urlparse(self.path)
|
||||
if parsed.path == "/health":
|
||||
self._send_json({
|
||||
"ok": True,
|
||||
"platform": "linux-ilink",
|
||||
"mohe_user_id": MOHE_USER_ID or "not_logged_in",
|
||||
})
|
||||
return
|
||||
if parsed.path in ("/history", "/api/chatHistory"):
|
||||
import urllib.parse as up
|
||||
params = up.parse_qs(parsed.query)
|
||||
wxid = params.get("wxid", [""])[0]
|
||||
count = params.get("count", ["10"])[0]
|
||||
self._send_json({
|
||||
"ok": True,
|
||||
"note": "iLink SDK does not support history query.",
|
||||
"messages": [],
|
||||
})
|
||||
return
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.end_headers()
|
||||
self.wfile.write(b'{"ok":true}')
|
||||
|
||||
def _send_json(self, data):
|
||||
body = json.dumps(data, ensure_ascii=False).encode("utf-8")
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def log_message(self, *a):
|
||||
pass
|
||||
|
||||
|
||||
def start_http_server():
|
||||
"""Start the sync HTTP server in a daemon thread."""
|
||||
server = HTTPServer(("0.0.0.0", 5801), HermesMsgHandler)
|
||||
t = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
t.start()
|
||||
log.info("HTTP :5801 ready (Hermes message receiver)")
|
||||
_http_server_ready.set()
|
||||
return server
|
||||
|
||||
|
||||
# ── Queue Consumer ────────────────────────────────────────────
|
||||
# Consumes the 5801 message queue inside the iLink event loop.
|
||||
|
||||
async def consume_outgoing_queue(bot: WeixinBot):
|
||||
"""
|
||||
Async task: consumes messages from 5801 queue and sends via iLink.
|
||||
Runs inside the same event loop as the iLink bot.
|
||||
"""
|
||||
while True:
|
||||
try:
|
||||
item = await _message_queue.get()
|
||||
msg_type = item.get("type")
|
||||
|
||||
if msg_type == "stop":
|
||||
log.info("Queue consumer: stop signal received")
|
||||
bot.stop()
|
||||
break
|
||||
|
||||
if msg_type == "outgoing":
|
||||
to = item.get("to", "")
|
||||
msg = item.get("message", "")
|
||||
if to and msg:
|
||||
try:
|
||||
await bot.send(to, msg)
|
||||
log.info(f"5801 -> {to}: {msg[:80]}")
|
||||
except RuntimeError as e:
|
||||
log.warning(f"5801 send failed (no context token for {to}): {e}")
|
||||
except Exception as e:
|
||||
log.error(f"5801 send error: {e}")
|
||||
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
except Exception as e:
|
||||
log.error(f"Queue consumer error: {e}")
|
||||
|
||||
|
||||
# ── Outbound Message Router (replacement for session_router) ──
|
||||
# Handles messages from xxm/Hermes that need to be sent to WeChat.
|
||||
# In the iLink world, all outgoing messages go through bot.send().
|
||||
|
||||
async def route_hermes_message(msg_text: str, bot: WeixinBot):
|
||||
"""Route a message from Hermes to WeChat via iLink."""
|
||||
# For now, route to Dad's user_id if known.
|
||||
# In practice, the 5801 server with 'to' field is the primary path.
|
||||
log.info(f"Hermes message: {msg_text[:100]}")
|
||||
# The 5801 server handles the actual sending with explicit 'to' field.
|
||||
# This function is for messages without an explicit target.
|
||||
|
||||
|
||||
# ── Main ──────────────────────────────────────────────────────
|
||||
|
||||
def main():
|
||||
acquire_pid_lock()
|
||||
log.info("=== MoWeChat Agent (Linux/iLink v1.0) ===")
|
||||
|
||||
# Start 5801 HTTP server (in a thread)
|
||||
http_server = start_http_server()
|
||||
_http_server_ready.wait(timeout=5)
|
||||
|
||||
# Create and run the iLink bot
|
||||
bot = WeixinBot()
|
||||
|
||||
try:
|
||||
# Login (QR scan first time, then auto)
|
||||
log.info("Logging in to iLink Bot API...")
|
||||
creds = bot.login()
|
||||
global MOHE_USER_ID
|
||||
MOHE_USER_ID = creds.user_id
|
||||
log.info(f"Logged in as {MOHE_USER_ID}")
|
||||
except Exception as e:
|
||||
log.error(f"Login failed: {e}")
|
||||
release_pid_lock()
|
||||
sys.exit(1)
|
||||
|
||||
# Register message handler
|
||||
@bot.on_message
|
||||
async def handle(msg: IncomingMessage):
|
||||
await handle_incoming(msg, bot)
|
||||
|
||||
# Register queue consumer (runs inside bot's event loop)
|
||||
# We schedule this before bot.run() by patching into the _run_loop flow.
|
||||
# Since _run_loop is private, we use a different approach:
|
||||
# Override the start of _run_loop by wrapping it.
|
||||
|
||||
# Actually, bot.run() creates its own event loop with asyncio.run().
|
||||
# We need to hook into that loop. Let's save the original _run_loop
|
||||
# and wrap it to also start the queue consumer.
|
||||
|
||||
original_run_loop = bot._run_loop
|
||||
|
||||
async def wrapped_run_loop():
|
||||
# Start queue consumer as a background task
|
||||
asyncio.create_task(consume_outgoing_queue(bot))
|
||||
# Run the original loop
|
||||
await original_run_loop()
|
||||
|
||||
bot._run_loop = wrapped_run_loop
|
||||
|
||||
try:
|
||||
log.info("Bot starting. Press Ctrl+C to stop.")
|
||||
bot.run()
|
||||
except KeyboardInterrupt:
|
||||
log.info("Shutting down...")
|
||||
except Exception as e:
|
||||
log.error(f"Bot error: {e}")
|
||||
finally:
|
||||
bot.stop()
|
||||
http_server.shutdown()
|
||||
release_pid_lock()
|
||||
log.info("Stopped.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user