"""
WeChat Agent v2 - wxhelper DLL + Hermes API (:8642)
"""
import os, json, time, threading, requests, re, socketserver, subprocess, urllib.request, urllib.error, base64
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\Injector_x64.exe"
WXHELPER_DLL = r"D:\F\NewI\opencode\daily-workspace\projects\wechat-hermes-gateway\tools\wxhelper_official_39581.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.
    # Also check ChatMsg.db (has ChatMsg table with different schema).
    # Prefer MSG*.db over MicroMsg.db (MicroMsg.db has "Msg" in name but no MSG table in new versions).
    candidate = None
    for db in dbs:
        dbname = db.get("databaseName", "")
        # Prefer MSG0.db/MSG1.db over MicroMsg.db
        if dbname.upper().startswith("MSG") and dbname.upper().endswith(".DB"):
            candidate = db.get("handle")
            log(f"History DB: {dbname} handle={candidate}")
            break
        # Fallback: check if any table is named MSG
        for t in (db.get("tables") or []):
            if t.get("tableName") == "MSG":
                candidate = db.get("handle")
                log(f"History DB: {dbname} handle={candidate}")
                break
        if candidate:
            break
    if candidate:
        db_handle_cache = candidate
        return candidate
    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
    # Also check if port 19088 is just listening (wxhelper HTTP server alive)
    try:
        import socket as _sock
        s = _sock.create_connection(("127.0.0.1", 19088), timeout=2)
        s.close()
        r = wxpost("/api/checkLogin", timeout=5)
        if r.get("code") == 1:
            log("wxhelper HTTP server alive, login OK")
            return True
    except:
        pass
    # Wait a moment in case server is still starting
    time.sleep(3)
    try:
        r = wxpost("/api/checkLogin", timeout=5)
        if r.get("code") == 1:
            log("wxhelper responding after wait")
            return True
    except:
        pass
    try:
        # Injector_x64.exe: -n process_name -i dll_path
        result = subprocess.run([INJECTOR, "-n", "WeChat.exe", "-i", WXHELPER_DLL], capture_output=True, text=True, timeout=30)
        output = (result.stdout + result.stderr).strip()
        log(f"Inject: {output[:100]}")
        # Check if injection succeeded by looking for "success" in output
        if "success" not in output.lower():
            log(f"Inject MAY HAVE FAILED (no 'success' in output), retrying...")
            time.sleep(2)
            result2 = subprocess.run([INJECTOR, "-n", "WeChat.exe", "-i", WXHELPER_DLL], capture_output=True, text=True, timeout=30)
            log(f"Inject retry: {(result2.stdout+result2.stderr).strip()[:100]}")
        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()

# ���� Image OCR ����
WX_FILES_BASE = os.path.join(os.path.expanduser("~"), "Documents", "WeChat Files")
BOT_WX_DIR = os.path.join(WX_FILES_BASE, BOT_WXID, "wxhelper")

def ocr_image(base64_data):
    """OCR from in-memory base64 image data. Returns text or None."""
    try:
        headers = {"Authorization": "Bearer b0359bed-09f2-49e2-a53c-32ba057412e3", "Content-Type": "application/json"}
        payload = {
            "model": "doubao-seed-code",
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "text", "text": "请识别这张图片中的所有中文和英文字符，保持原文输出，包括数字、表格、百分比的完整结构。严格逐行逐列输出所有数据，不要省略、不要总结。"},
                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_data}"}}
                ]
            }]
        }
        r = requests.post(
            "https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions",
            json=payload, headers=headers, timeout=60,
            proxies={"http": None, "https": None}
        )
        if r.status_code == 200:
            text = r.json()["choices"][0]["message"]["content"].strip()
            log(f"OCR OK ({len(text)} chars)")
            return text
        log(f"OCR HTTP {r.status_code}: {r.text[:200]}")
    except Exception as e:
        log(f"OCR ERR: {e}")
    return None

def ocr_image_file(image_path):
    """OCR an image file on disk. Returns text or None."""
    try:
        with open(image_path, "rb") as f:
            b64 = base64.b64encode(f.read()).decode()
        return ocr_image(b64)
    except Exception as e:
        log(f"ocr_image_file ERR: {e}")
    return None

# ���� Full Image Download & Decode (wxhelper 3.9.5.81+) ����
def download_full_image(msg_id):
    """Download full image from CDN via downloadAttach. Returns encrypted .dat path or None.
    
    Retries both the API call (wxhelper may return -2 transiently) 
    and file existence (async CDN download takes time).
    """
    try:
        dat_path = os.path.join(BOT_WX_DIR, "image", f"{msg_id}.dat")
        
        # Phase 1: Retry API call (wxhelper may return -2 if msg not ready)
        for api_attempt in range(10):
            r = wxpost("/api/downloadAttach", {"msgId": int(msg_id)}, timeout=30)
            code = r.get("code", -1)
            if code >= 0:
                break
            log(f"downloadAttach attempt {api_attempt+1}: code={code} {r.get('msg','')}")
            time.sleep(1)
        else:
            log(f"downloadAttach FAILED after 10 attempts, last code={code}")
            return None
        
        # Phase 2: Wait for async CDN download
        log(f"downloadAttach queued, waiting for file...")
        for wait_attempt in range(20):
            if os.path.exists(dat_path):
                log(f"Download OK: {dat_path} ({os.path.getsize(dat_path)} bytes)")
                return dat_path
            time.sleep(1)
        log(f"downloadAttach: .dat not found after 20s for msgId={msg_id}")
    except Exception as e:
        log(f"downloadAttach ERR: {e}")
    return None

def decode_image_file(dat_path):
    """Decrypt encrypted .dat to viewable image. Returns decoded path or None.
    
    Some .dat files are already valid PNG/JPEG images (not encrypted).
    Falls back to checking if .dat itself is a valid image.
    """
    try:
        before_files = set(os.listdir(TEMP_DIR))
        r = wxpost("/api/decodeImage", {"filePath": dat_path, "storeDir": TEMP_DIR}, timeout=30)
        if r.get("code", -1) > 0:
            base = os.path.splitext(os.path.basename(dat_path))[0]
            for ext in ['.jpg', '.jpeg', '.png', '.bmp']:
                cand = os.path.join(TEMP_DIR, base + ext)
                if os.path.exists(cand):
                    log(f"Decoded: {cand}")
                    return cand
            for f in os.listdir(TEMP_DIR):
                if f in before_files: continue
                if f.lower().endswith(('.jpg', '.jpeg', '.png')):
                    cand = os.path.join(TEMP_DIR, f)
                    log(f"Decoded (new): {cand}")
                    return cand
            log("decodeImage OK but no new image file found")
        # Fallback: .dat file may already be a valid image (not encrypted)
        with open(dat_path, "rb") as f:
            header = f.read(4)
        ext = None
        if header[:2] == b'\xff\xd8':       # JPEG
            ext = '.jpg'
        elif header[:4] == b'\x89PNG':       # PNG
            ext = '.png'
        elif header[:4] == b'GIF8':          # GIF
            ext = '.gif'
        elif header[:2] == b'BM':            # BMP
            ext = '.bmp'
        if ext:
            out_path = os.path.join(TEMP_DIR, os.path.splitext(os.path.basename(dat_path))[0] + ext)
            import shutil
            shutil.copy(dat_path, out_path)
            log(f".dat is already {ext}, copied to {out_path}")
            return out_path
        log(f"decodeImage FAIL: code={r.get('code')} {r.get('msg','')}")
    except Exception as e:
        log(f"decodeImage ERR: {e}")
    return None

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 and reply.strip():
                send_wx(fu, reply.strip())
            return
        if msg_type == 3:  # Image
            msg_id = d.get("msgId", 0) or d.get("svrid", 0)
            log(f"IMAGE: msgId={msg_id} b64_len={len(d.get('base64Img',''))}")
            ocr_text = None
            # Full-image OCR via wxhelper 3.9.5.81 APIs
            if msg_id:
                dat_path = download_full_image(msg_id)
                if dat_path:
                    decoded = decode_image_file(dat_path)
                    if decoded:
                        log(f"Full image OCR on {decoded}")
                        ocr_text = ocr_image_file(decoded)
            if ocr_text:
                log(f"OCR result ({len(ocr_text)} chars): {ocr_text[:200]}")
                reply = call_hermes(fu, f"[老莫发送了一张图片，OCR识别结果如下]\n{ocr_text}")
            elif msg_id:
                # Had msgId but full-image OCR failed - report error, don't use thumbnail
                log("Full-image OCR failed, skipping thumbnail (useless at 84x210)")
                reply = call_hermes(fu, "[老莫发送了一张图片，但全尺寸图片下载或OCR识别失败，无法读取内容]")
            else:
                # No msgId at all - rare, just report failure
                log("No msgId available, cannot download full image")
                reply = call_hermes(fu, "[老莫发送了一张图片，但无法获取图片ID，无法识别]")
            if reply and reply.strip():
                log(f"-> {fu}: {reply[:50]}")
                process_tags(reply, fu)
            else:
                log(f"-> {fu}: skip (blank image response)")
            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 and reply.strip():
            log(f"-> {fu}: {reply[:50]}")
            process_tags(reply, fu)
        else:
            log(f"-> {fu}: no reply (blank/empty)")
    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"�dz�: {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")