508 lines
21 KiB
Python
508 lines
21 KiB
Python
"""
|
|
WeChat Agent v2 - wxhelper DLL + Hermes API (:8642)
|
|
"""
|
|
import os, json, time, threading, requests, re, socketserver, subprocess, urllib.request, urllib.error
|
|
os.environ["no_proxy"] = "*"
|
|
os.environ["NO_PROXY"] = "*"
|
|
from http.server import HTTPServer, BaseHTTPRequestHandler
|
|
from urllib.parse import urlparse, parse_qs
|
|
|
|
BOT_WXID = "wxid_7onnerpx2s2l22"
|
|
BLOCK_WXIDS = {"fmessage", "weixin", "wechat"} # 系统账号/微信团队，不回复
|
|
WX_API = "http://127.0.0.1:19088"
|
|
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
LOG_DIR = os.path.join(PROJECT_ROOT, "logs")
|
|
TEMP_DIR = os.path.join(PROJECT_ROOT, "temp")
|
|
LOG_FILE = os.path.join(LOG_DIR, "wechat_agent.log")
|
|
os.makedirs(LOG_DIR, exist_ok=True)
|
|
os.makedirs(TEMP_DIR, exist_ok=True)
|
|
TCP_PORT = 19099
|
|
last_msg_time = time.time()
|
|
nickname_cache = {}
|
|
db_handle_cache = None # MicroMsg.db handle for history queries
|
|
|
|
HERMES_API = "http://192.168.0.103:8642/v1/chat/completions"
|
|
HERMES_KEY = "hermes123"
|
|
SENSENOVA_KEY = "sk-aRNj3UwKSLPsDfh15QNTPwbHxahblfaO"
|
|
SENSENOVA_URL = "https://token.sensenova.cn/v1"
|
|
|
|
INJECTOR = r"D:\F\NewI\opencode\daily-workspace\projects\wechat-hermes-gateway\tools\ConsoleApplication.exe"
|
|
WXHELPER_DLL = r"D:\F\NewI\opencode\daily-workspace\projects\wechat-hermes-gateway\tools\wxhelper_391019.dll"
|
|
|
|
def log(m):
|
|
with open(LOG_FILE, "a", encoding="utf-8") as f:
|
|
f.write(f"{time.strftime('%H:%M:%S')} {m}\n")
|
|
|
|
def wxpost(path, data=None, timeout=10):
|
|
try:
|
|
body = json.dumps(data or {}).encode()
|
|
r = urllib.request.urlopen(urllib.request.Request(WX_API + path, data=body, headers={"Content-Type": "application/json"}), timeout=timeout)
|
|
return json.loads(r.read().decode())
|
|
except urllib.error.HTTPError as e:
|
|
return json.loads(e.read().decode()) if e.code else {"code": -1}
|
|
except Exception as e:
|
|
log(f"WX ERR: {e}")
|
|
return {"code": -1}
|
|
|
|
# ── History Query (via MSG table in MSG*.db databases) ──
|
|
def get_db_handle():
|
|
"""Get handle for database containing MSG table. Cached after first call."""
|
|
global db_handle_cache
|
|
if db_handle_cache:
|
|
return db_handle_cache
|
|
r = wxpost("/api/getDBInfo", timeout=10)
|
|
dbs = r.get("data") or []
|
|
# WeChat 3.9.5.81+: messages stored in MSG0.db, MSG1.db, etc.
|
|
# Older versions: messages in MicroMsg.db's MSG table
|
|
for db in dbs:
|
|
dbname = db.get("databaseName", "")
|
|
if "MSG" in dbname or "Msg" in dbname:
|
|
db_handle_cache = db.get("handle")
|
|
log(f"History DB: {dbname} handle={db_handle_cache}")
|
|
return db_handle_cache
|
|
log("History DB handle: NOT FOUND")
|
|
return None
|
|
|
|
# Message type labels
|
|
MSG_TYPES = {1: "文字", 3: "图片", 34: "语音", 43: "视频", 47: "表情", 49: "链接", 10000: "系统", 10002: "红包"}
|
|
|
|
def query_history(wxid, limit=10):
|
|
"""Query historical text messages with a contact from MSG table."""
|
|
h = get_db_handle()
|
|
if not h:
|
|
return None
|
|
# Text (type=1) and appmsg/link (type=49), use DisplayContent as fallback for StrContent
|
|
limit_val = min(int(limit), 50)
|
|
sql = f"SELECT CreateTime, IsSender, Type, SubType, StrContent, DisplayContent FROM MSG WHERE StrTalker='{wxid}' AND Type IN (1,49) ORDER BY CreateTime DESC LIMIT {limit_val}"
|
|
r = wxpost("/api/execSql", {"dbHandle": h, "sql": sql}, timeout=15)
|
|
data = r.get("data") or []
|
|
if not data or len(data) < 2:
|
|
return None
|
|
# Skip header row, reverse to chronological order
|
|
rows = data[1:]
|
|
rows.reverse()
|
|
# Normalize content: prefer StrContent, fallback to DisplayContent
|
|
results = []
|
|
for row in rows:
|
|
content = (row[4] or "").strip() if len(row) > 4 else ""
|
|
if not content and len(row) > 5:
|
|
content = (row[5] or "").strip()
|
|
if not content:
|
|
continue
|
|
results.append({"CreateTime": row[0], "IsSender": row[1], "Type": row[2], "content": content})
|
|
return results
|
|
|
|
def format_history(wxid, rows):
|
|
"""Format MSG rows into readable chat history text."""
|
|
sender_name = get_nickname(wxid)
|
|
bot_name = get_nickname(BOT_WXID)
|
|
lines = [f"📜 最近与 {sender_name} 的聊天记录 ({len(rows)}条):"]
|
|
for row in rows:
|
|
ts = int(row.get("CreateTime", 0))
|
|
time_str = time.strftime("%m/%d %H:%M", time.localtime(ts)) if ts else "?"
|
|
is_sender = int(row.get("IsSender", 0))
|
|
msg_type = int(row.get("Type", 1))
|
|
content = row.get("content", "")
|
|
# Determine who sent it
|
|
who = bot_name if is_sender else sender_name
|
|
# Format content
|
|
if msg_type == 49:
|
|
content = f"[链接] {content[:60]}"
|
|
else:
|
|
content = content[:200]
|
|
lines.append(f"[{time_str}] {who}: {content}")
|
|
return "\n".join(lines)
|
|
|
|
def handle_history(wxid, count):
|
|
"""Query and format history for a given wxid. Returns text to send."""
|
|
try:
|
|
rows = query_history(wxid, count)
|
|
if rows:
|
|
return format_history(wxid, rows)
|
|
return f"暂无与 {get_nickname(wxid)} 的聊天记录"
|
|
except Exception as e:
|
|
log(f"History ERR: {e}")
|
|
return "查询历史记录失败"
|
|
|
|
def handle_history_json(wxid, count):
|
|
"""Query history and return JSON-serializable dict for HTTP API."""
|
|
try:
|
|
rows = query_history(wxid, count)
|
|
sender_name = get_nickname(wxid)
|
|
if not rows:
|
|
return {"ok": True, "wxid": wxid, "sender_name": sender_name, "count": 0, "messages": []}
|
|
bot_name = get_nickname(BOT_WXID)
|
|
messages = []
|
|
for row in rows:
|
|
ts = int(row.get("CreateTime", 0))
|
|
time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts)) if ts else ""
|
|
is_sender = int(row.get("IsSender", 0))
|
|
msg_type = int(row.get("Type", 1))
|
|
content = row.get("content", "")
|
|
messages.append({
|
|
"time": time_str,
|
|
"timestamp": ts,
|
|
"sender": bot_name if is_sender else sender_name,
|
|
"is_self": bool(is_sender),
|
|
"type": msg_type,
|
|
"content": content[:500]
|
|
})
|
|
return {
|
|
"ok": True,
|
|
"wxid": wxid,
|
|
"sender_name": sender_name,
|
|
"count": len(messages),
|
|
"requested_count": min(int(count or 10), 50),
|
|
"messages": messages
|
|
}
|
|
except Exception as e:
|
|
log(f"History JSON ERR: {e}")
|
|
return {"ok": False, "error": str(e)[:200]}
|
|
|
|
def send_wx(wxid, msg):
|
|
# Strip weixin:// URLs that WeChat interprets as commands
|
|
import re as _re2
|
|
msg = _re2.sub(r'weixin://[^\s]+', '[链接已过滤]', msg)
|
|
r = wxpost("/api/sendTextMsg", {"wxid": wxid, "msg": msg})
|
|
log(f"SEND {wxid}: {r.get('msg','')}")
|
|
|
|
def get_nickname(wxid):
|
|
if wxid in nickname_cache:
|
|
return nickname_cache[wxid]
|
|
r = wxpost("/api/getContactList", timeout=10)
|
|
for c in (r.get("data") or []):
|
|
if c.get("wxid") == wxid:
|
|
nick = c.get("nickname") or c.get("customAccount") or wxid
|
|
nickname_cache[wxid] = nick
|
|
return nick
|
|
nickname_cache[wxid] = wxid
|
|
return wxid
|
|
|
|
def call_hermes(wxid, content):
|
|
nickname = get_nickname(wxid)
|
|
headers = {"Authorization": f"Bearer {HERMES_KEY}", "X-Hermes-Session-Id": "sisyphus", "Content-Type": "application/json"}
|
|
sys_prompt = "回复简短。"
|
|
body = {"model": "hermes-agent", "messages": [{"role": "system", "content": sys_prompt}, {"role": "user", "content": content}]}
|
|
try:
|
|
r = requests.post(HERMES_API, json=body, headers=headers, timeout=180, proxies={"http": None, "https": None})
|
|
if r.status_code == 200:
|
|
return r.json()["choices"][0]["message"]["content"]
|
|
except Exception as e:
|
|
log(f"API ERR: {e}")
|
|
return None
|
|
|
|
def inject_to_hermes_session(text):
|
|
"""Inject chat history / context directly into Hermes's sisyphus session for memory repair."""
|
|
headers = {"Authorization": f"Bearer {HERMES_KEY}", "X-Hermes-Session-Id": "sisyphus", "Content-Type": "application/json"}
|
|
sys_prompt = "📥 MEMORY INJECTION: Below is past chat history. Absorb this into your context for memory repair. Do NOT reply to this — just acknowledge with 'Memory synced.'"
|
|
body = {"model": "hermes-agent", "messages": [
|
|
{"role": "system", "content": sys_prompt},
|
|
{"role": "user", "content": text}
|
|
]}
|
|
try:
|
|
r = requests.post(HERMES_API, json=body, headers=headers, timeout=180, proxies={"http": None, "https": None})
|
|
if r.status_code == 200:
|
|
reply = r.json()["choices"][0]["message"]["content"]
|
|
log(f"Inject history OK: {reply[:50]}")
|
|
return True
|
|
log(f"Inject history HTTP {r.status_code}")
|
|
except Exception as e:
|
|
log(f"Inject history ERR: {e}")
|
|
return False
|
|
|
|
# ── Inject wxhelper DLL ──
|
|
def inject_wxhelper():
|
|
try:
|
|
r = wxpost("/api/checkLogin", timeout=5)
|
|
if r.get("code") == 1:
|
|
log("wxhelper already injected")
|
|
return True
|
|
except:
|
|
pass
|
|
try:
|
|
result = subprocess.run([INJECTOR, "-i", "WeChat.exe", "-p", WXHELPER_DLL], capture_output=True, text=True, timeout=30)
|
|
log(f"Inject: {result.stdout.strip()[:50]}")
|
|
time.sleep(3)
|
|
r = wxpost("/api/checkLogin", timeout=5)
|
|
if r.get("code") == 1:
|
|
log("wxhelper injected OK")
|
|
return True
|
|
log(f"Inject check: {r}")
|
|
return False
|
|
except Exception as e:
|
|
log(f"Inject FAIL: {e}")
|
|
return False
|
|
|
|
# ── TCP Message Receiver ──
|
|
class MsgHandler(socketserver.BaseRequestHandler):
|
|
def handle(self):
|
|
try:
|
|
data = b""
|
|
while True:
|
|
c = self.request.recv(4096)
|
|
data += c
|
|
if not c or c[-1] == 10:
|
|
break
|
|
if data.strip():
|
|
threading.Thread(target=process_msg, args=(data,), daemon=True).start()
|
|
self.request.sendall(b"200 OK\n")
|
|
except:
|
|
pass
|
|
finally:
|
|
self.request.close()
|
|
|
|
def process_msg(raw_data):
|
|
global last_msg_time
|
|
last_msg_time = time.time()
|
|
try:
|
|
d = json.loads(raw_data)
|
|
log(f"RAW: fromUser={d.get('fromUser','')} type={d.get('type','')} self={d.get('isSelf',d.get('self',0))}")
|
|
fu = d.get("fromUser", "") or d.get("fromuser", "") or d.get("sender", "")
|
|
ct = d.get("content", "") or d.get("msg", "") or d.get("text", "")
|
|
msg_type = d.get("type", 1)
|
|
is_self = d.get("isSelf", 0) or d.get("self", 0)
|
|
if not fu or not ct or fu == BOT_WXID or fu in BLOCK_WXIDS or fu.startswith("gh_") or is_self:
|
|
log(f"SKIP: fu={fu} self={is_self}")
|
|
return
|
|
# Route by message type
|
|
if msg_type == 34: # Voice
|
|
log(f"<- {fu}: [voice]")
|
|
reply = call_hermes(fu, "[voice message]")
|
|
if reply: send_wx(fu, reply)
|
|
return
|
|
if msg_type == 3: # Image - wxhelper sends image as separate event
|
|
return
|
|
# Text - prepend sender wxid+name so Hermes knows who's talking
|
|
sender_name = get_nickname(fu)
|
|
msg_with_sender = f"[{fu}|{sender_name}] {ct}"
|
|
log(f"<- {fu} ({sender_name}): {ct[:50]}")
|
|
reply = call_hermes(fu, msg_with_sender)
|
|
if reply:
|
|
log(f"-> {fu}: {reply[:50]}")
|
|
process_tags(reply, fu)
|
|
else:
|
|
log(f"-> {fu}: no reply")
|
|
except Exception as e:
|
|
log(f"MSG ERR: {e}")
|
|
import traceback
|
|
log(f"TRACE: {traceback.format_exc()[:200]}")
|
|
|
|
def process_tags(reply, fu):
|
|
if not reply:
|
|
return
|
|
clean = reply
|
|
# [FILE]
|
|
for tag, pattern, repl in [
|
|
("FILE", r'\[FILE\](.*?)\[/FILE\]', lambda m: download_and_send_file(m, fu)),
|
|
("IMG", r'\[IMG\](.*?)\[/IMG\]', lambda m: handle_img(m, fu)),
|
|
("EMOJI", r'\[EMOJI\](.*?)\[/EMOJI\]', lambda m: download_emoji(m, fu)),
|
|
]:
|
|
match = re.search(pattern, clean)
|
|
if match:
|
|
clean = re.sub(r'\s*' + pattern.replace('(.*?)', '.*?') + r'\s*', '', clean).strip()
|
|
try:
|
|
match = re.search(pattern, reply) # re-match against original
|
|
if match:
|
|
threading.Thread(target=repl, args=(match,), daemon=True).start()
|
|
except: pass
|
|
# [CONTACT:wxid]
|
|
cm = re.search(r'\[CONTACT:(\w+)\]', clean)
|
|
if cm:
|
|
clean = re.sub(r'\s*\[CONTACT:\w+\]\s*', '', clean).strip()
|
|
r = wxpost("/api/getContactProfile", {"wxid": cm.group(1)})
|
|
cd = r.get("data", {})
|
|
send_wx(fu, f"昵称: {cd.get('nickname','?')} 备注: {cd.get('remark','')}")
|
|
# [ROOM_MEMBERS:roomid]
|
|
rm = re.search(r'\[ROOM_MEMBERS:(\S+)\]', clean)
|
|
if rm:
|
|
clean = re.sub(r'\s*\[ROOM_MEMBERS:\S+\]\s*', '', clean).strip()
|
|
r = wxpost("/api/getMemberFromChatRoom", {"chatRoomId": rm.group(1)})
|
|
members = (r.get("data") or {}).get("members", "")
|
|
mlist = [m for m in members.split("\u0007") if m]
|
|
send_wx(fu, f"群成员 ({len(mlist)}): {','.join(mlist[:20])}")
|
|
# [HISTORY:wxid:count] - query chat history from MSG table
|
|
hm = re.search(r'\[HISTORY:(\S+?):(\d+)\]', clean)
|
|
if hm:
|
|
clean = re.sub(r'\s*\[HISTORY:\S+?:\d+\]\s*', '', clean).strip()
|
|
target_wxid, count = hm.group(1), int(hm.group(2))
|
|
threading.Thread(target=lambda: send_wx(fu, handle_history(target_wxid, count)), daemon=True).start()
|
|
# [PAT:roomid:wxid]
|
|
pm = re.search(r'\[PAT:(\S+):(\S+)\]', clean)
|
|
if pm:
|
|
clean = re.sub(r'\s*\[PAT:\S+:\S+\]\s*', '', clean).strip()
|
|
wxpost("/api/sendPatMsg", {"receiver": pm.group(1), "wxid": pm.group(2)})
|
|
if clean.strip():
|
|
send_wx(fu, clean.strip())
|
|
|
|
def download_and_send_file(m, fu):
|
|
url = m.group(1).strip()
|
|
ir = requests.get(url, timeout=60, proxies={"http": None, "https": None})
|
|
if ir.status_code == 200:
|
|
tmp = os.path.join(TEMP_DIR, f"send_file_{int(time.time())}.dat")
|
|
with open(tmp, "wb") as f: f.write(ir.content)
|
|
wxpost("/api/sendFileMsg", {"wxid": fu, "filePath": tmp})
|
|
os.remove(tmp)
|
|
|
|
def handle_img(m, fu):
|
|
cmd = m.group(1).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
|
|
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")
|
|
log(f"GEN SenseNova: {prompt[:30]} [{ratio}]")
|
|
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:
|
|
img_url = r.json()["data"][0]["url"]
|
|
ir = requests.get(img_url, timeout=60)
|
|
if ir.status_code == 200:
|
|
tmp = os.path.join(TEMP_DIR, f"gen_img_{int(time.time())}.png")
|
|
with open(tmp, "wb") as f: f.write(ir.content)
|
|
wxpost("/api/sendImagesMsg", {"wxid": fu, "imagePath": tmp})
|
|
os.remove(tmp)
|
|
else:
|
|
ir = requests.get(cmd, timeout=30, proxies={"http": None, "https": None})
|
|
if ir.status_code == 200:
|
|
ext = ".jpg"
|
|
if "png" in ir.headers.get("content-type", ""): ext = ".png"
|
|
tmp = os.path.join(TEMP_DIR, f"send_img_{int(time.time())}{ext}")
|
|
with open(tmp, "wb") as f: f.write(ir.content)
|
|
wxpost("/api/sendImagesMsg", {"wxid": fu, "imagePath": tmp})
|
|
os.remove(tmp)
|
|
|
|
def download_emoji(m, fu):
|
|
url = m.group(1).strip()
|
|
ir = requests.get(url, timeout=30, proxies={"http": None, "https": None})
|
|
if ir.status_code == 200:
|
|
tmp = os.path.join(TEMP_DIR, f"emoji_{int(time.time())}.png")
|
|
with open(tmp, "wb") as f: f.write(ir.content)
|
|
wxpost("/api/sendCustomEmotion", {"wxid": fu, "filePath": tmp})
|
|
os.remove(tmp)
|
|
|
|
# ── Watchdog ──
|
|
def watchdog():
|
|
global last_msg_time
|
|
while True:
|
|
idle = time.time() - last_msg_time
|
|
if idle > 120:
|
|
try:
|
|
r = wxpost("/api/checkLogin", timeout=5)
|
|
if r.get("code") == 1:
|
|
wxpost("/api/hookSyncMsg", {"ip": "127.0.0.1", "port": TCP_PORT, "enableHttp": 0})
|
|
log(f"WATCHDOG: refreshed ({int(idle)}s)")
|
|
else:
|
|
log("WATCHDOG: re-injecting...")
|
|
inject_wxhelper()
|
|
except:
|
|
pass
|
|
last_msg_time = time.time()
|
|
time.sleep(30)
|
|
|
|
# ── Start ──
|
|
print("[Agent] starting...", flush=True)
|
|
log("=== Agent v2 (wxhelper) ===")
|
|
|
|
# Inject wxhelper
|
|
inject_wxhelper()
|
|
|
|
# Check login
|
|
r = wxpost("/api/checkLogin")
|
|
if r.get("code") == 1:
|
|
log(f"Logged in: OK")
|
|
else:
|
|
log(f"Login check: {r}")
|
|
log("Will retry via watchdog")
|
|
|
|
# Start watchdog
|
|
threading.Thread(target=watchdog, daemon=True).start()
|
|
|
|
# Start TCP server for message receiving
|
|
tcp_server = socketserver.ThreadingTCPServer(("127.0.0.1", TCP_PORT), MsgHandler)
|
|
threading.Thread(target=tcp_server.serve_forever, daemon=True).start()
|
|
log(f"TCP server on :{TCP_PORT}")
|
|
|
|
# Hook sync messages (tell DLL to send events to our TCP server)
|
|
r = wxpost("/api/hookSyncMsg", {"port": TCP_PORT, "ip": "127.0.0.1", "enableHttp": 0})
|
|
log(f"hookSyncMsg: {r}")
|
|
|
|
# Reply server for hermes-msg
|
|
class RH(BaseHTTPRequestHandler):
|
|
def do_POST(self):
|
|
global last_msg_time
|
|
last_msg_time = time.time()
|
|
body = self.rfile.read(int(self.headers.get("Content-Length", 0)))
|
|
try:
|
|
d = json.loads(body)
|
|
if self.path in ("/history", "/api/chatHistory"):
|
|
wxid = (d.get("wxid", "") or "").strip()
|
|
count = d.get("count", 10) or d.get("limit", 10)
|
|
if not wxid:
|
|
self._send_json({"ok": False, "error": "Missing wxid"})
|
|
return
|
|
self._send_json(handle_history_json(wxid, count))
|
|
return
|
|
if self.path == "/hermes-msg":
|
|
msg = d.get("message", "") or d.get("content", "") or str(d)[:200]
|
|
log("<<< HERMES: " + msg[:100])
|
|
with open(os.path.join(TEMP_DIR, "hermes_inbox.txt"), "a", encoding="utf-8") as f:
|
|
f.write(f"{time.strftime('%H:%M:%S')} {msg}\n")
|
|
# HISTORY_DATA tag: query history and inject back to Hermes session
|
|
hm = re.search(r'\[HISTORY_DATA:(\S+?):(\d+)\]', msg)
|
|
if hm:
|
|
target_wxid, count = hm.group(1), int(hm.group(2))
|
|
history_text = handle_history(target_wxid, count)
|
|
if history_text:
|
|
threading.Thread(target=lambda: inject_to_hermes_session(history_text), daemon=True).start()
|
|
log(f"HISTORY_DATA: injected for {target_wxid} ({count} msgs)")
|
|
else:
|
|
log(f"HISTORY_DATA: no messages for {target_wxid}")
|
|
self.send_response(200); self.end_headers(); return
|
|
to = d.get("to", "") or d.get("wxid", "")
|
|
msg = d.get("message", "") or d.get("content", "")
|
|
if to and msg:
|
|
log(f"REPLY {to}: {msg[:50]}")
|
|
send_wx(to, msg)
|
|
except Exception as e:
|
|
log(f"RH ERR: {e}")
|
|
self.send_response(200); self.end_headers()
|
|
def do_GET(self):
|
|
parsed = urlparse(self.path)
|
|
if parsed.path in ("/history", "/api/chatHistory"):
|
|
params = parse_qs(parsed.query)
|
|
wxid = params.get("wxid", [""])[0]
|
|
count = params.get("count", ["10"])[0]
|
|
result = handle_history_json(wxid, count)
|
|
log(f"HTTP GET {parsed.path} wxid={wxid} count={count}")
|
|
self._send_json(result)
|
|
return
|
|
self.send_response(200); 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
|
|
|
|
threading.Thread(target=lambda: HTTPServer(("0.0.0.0", 5801), RH).serve_forever(), daemon=True).start()
|
|
log("HTTP :5801")
|
|
|
|
# Notify user
|
|
send_wx("filehelper", "[Agent v2] wxhelper online")
|
|
log("Ready")
|
|
print(f"[Agent v2] wxhelper :19088 | Hermes :8642")
|
|
|
|
try:
|
|
while True:
|
|
time.sleep(1)
|
|
except KeyboardInterrupt:
|
|
log("Bye")
|