http_server.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ComWeChatBot HTTP API Server
为 OpenClaw 提供 HTTP 接口
"""

import json
import logging
import psutil
import socketserver
import threading
import time
from datetime import datetime
from http.server import HTTPServer, BaseHTTPRequestHandler
from typing import Dict, Any, List

import comtypes.client

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger('ComWeChatHTTP')

class WeChatBot:
    """微信机器人核心类"""
    
    def __init__(self):
        self.robot = None
        self.pid = None
        self.self_info = {}
        self.msg_handlers = []
        self.socket_thread = None
        self.running = False
        
    def init(self) -> bool:
        """初始化"""
        try:
            self.robot = comtypes.client.CreateObject("WeChatRobot.CWeChatRobot")
            logger.info("COM object created")
            
            # 获取微信 PID
            self.pid = self._get_wechat_pid()
            if not self.pid:
                logger.error("WeChat not running")
                return False
            logger.info(f"WeChat PID: {self.pid}")
            
            # 启动服务
            result = self.robot.CStartRobotService(self.pid)
            if result != 0:
                logger.error(f"Start service failed: {result}")
                return False
            logger.info("Robot service started")
            
            # 检查登录
            if not self.robot.CIsWxLogin(self.pid):
                logger.error("WeChat not logged in")
                return False
            logger.info("WeChat logged in")
            
            # 获取个人信息
            self.self_info = json.loads(self.robot.CGetSelfInfo(self.pid))
            logger.info(f"User: {self.self_info.get('wxNickName')}")
            
            # 启动消息接收
            self._start_message_listener()
            
            self.running = True
            return True
            
        except Exception as e:
            logger.error(f"Init error: {e}")
            return False
    
    def _get_wechat_pid(self) -> int:
        for pid in psutil.pids():
            try:
                if psutil.Process(pid).name() == 'WeChat.exe':
                    return pid
            except:
                pass
        return None
    
    def _start_message_listener(self):
        """启动消息监听"""
        port = 10808
        self.robot.CStartReceiveMessage(self.pid, port)
        logger.info(f"Message listener on port {port}")
        
        class MsgHandler(socketserver.BaseRequestHandler):
            def handle(handler_self):
                conn = handler_self.request
                while True:
                    try:
                        data = b""
                        while True:
                            chunk = conn.recv(1024)
                            if not chunk:
                                break
                            data += chunk
                            if chunk[-1] == 0xA:
                                break
                        
                        if not data:
                            break
                        
                        msg = json.loads(data.decode('utf-8'))
                        self._process_message(msg)
                        conn.sendall(b"200 OK")
                    except:
                        break
                conn.close()
        
        server = socketserver.ThreadingTCPServer(("127.0.0.1", port), MsgHandler)
        self.socket_thread = threading.Thread(target=server.serve_forever)
        self.socket_thread.daemon = True
        self.socket_thread.start()
    
    def _process_message(self, msg: dict):
        """处理消息"""
        # 忽略自己发送的消息
        if msg.get('isSendMsg') == 1:
            return
        
        logger.info(f"Message received: {msg}")
        
        # 调用所有处理器
        for handler in self.msg_handlers:
            try:
                handler(msg)
            except Exception as e:
                logger.error(f"Handler error: {e}")
    
    def on_message(self, handler):
        """注册消息处理器"""
        self.msg_handlers.append(handler)
    
    def send_text(self, wxid: str, content: str) -> bool:
        """发送文本消息"""
        try:
            result = self.robot.CSendText(self.pid, wxid, content)
            return result == 0
        except Exception as e:
            logger.error(f"Send text error: {e}")
            return False
    
    def send_image(self, wxid: str, img_path: str) -> bool:
        """发送图片"""
        try:
            result = self.robot.CSendImage(self.pid, wxid, img_path)
            return result == 0
        except Exception as e:
            logger.error(f"Send image error: {e}")
            return False
    
    def get_friend_list(self) -> List[dict]:
        """获取好友列表"""
        try:
            result = self.robot.CGetFriendList(self.pid)
            return json.loads(result)
        except Exception as e:
            logger.error(f"Get friend list error: {e}")
            return []
    
    def get_user_info(self, wxid: str) -> dict:
        """获取用户信息"""
        try:
            result = self.robot.CGetWxUserInfo(self.pid, wxid)
            return json.loads(result)
        except Exception as e:
            logger.error(f"Get user info error: {e}")
            return {}
    
    def stop(self):
        """停止"""
        if self.robot and self.pid:
            self.robot.CStopReceiveMessage(self.pid)
            self.robot.CStopRobotService(self.pid)
        self.running = False
        logger.info("Bot stopped")


# 全局机器人实例
bot = WeChatBot()

class APIHandler(BaseHTTPRequestHandler):
    """HTTP API 处理器"""
    
    def log_message(self, format, *args):
        # 禁用默认日志
        pass
    
    def _send_json(self, data: dict, status=200):
        """发送 JSON 响应"""
        self.send_response(status)
        self.send_header('Content-Type', 'application/json; charset=utf-8')
        self.send_header('Access-Control-Allow-Origin', '*')
        self.end_headers()
        self.wfile.write(json.dumps(data, ensure_ascii=False).encode('utf-8'))
    
    def do_GET(self):
        """处理 GET 请求"""
        path = self.path
        
        if path == '/api/status':
            self._handle_status()
        elif path == '/api/self':
            self._handle_get_self()
        elif path == '/api/friends':
            self._handle_get_friends()
        else:
            self._send_json({'error': 'Not found'}, 404)
    
    def do_POST(self):
        """处理 POST 请求"""
        path = self.path
        
        # 读取请求体
        content_length = int(self.headers.get('Content-Length', 0))
        body = self.rfile.read(content_length).decode('utf-8')
        
        try:
            data = json.loads(body) if body else {}
        except:
            data = {}
        
        if path == '/api/send/text':
            self._handle_send_text(data)
        elif path == '/api/send/image':
            self._handle_send_image(data)
        else:
            self._send_json({'error': 'Not found'}, 404)
    
    def _handle_status(self):
        """获取状态"""
        self._send_json({
            'running': bot.running,
            'pid': bot.pid,
            'self': bot.self_info
        })
    
    def _handle_get_self(self):
        """获取个人信息"""
        self._send_json(bot.self_info)
    
    def _handle_get_friends(self):
        """获取好友列表"""
        friends = bot.get_friend_list()
        self._send_json({'friends': friends})
    
    def _handle_send_text(self, data: dict):
        """发送文本消息"""
        wxid = data.get('wxid', '')
        content = data.get('content', '')
        
        if not wxid or not content:
            self._send_json({'error': 'Missing wxid or content'}, 400)
            return
        
        success = bot.send_text(wxid, content)
        self._send_json({
            'success': success,
            'wxid': wxid,
            'content': content
        })
    
    def _handle_send_image(self, data: dict):
        """发送图片"""
        wxid = data.get('wxid', '')
        path = data.get('path', '')
        
        if not wxid or not path:
            self._send_json({'error': 'Missing wxid or path'}, 400)
            return
        
        success = bot.send_image(wxid, path)
        self._send_json({
            'success': success,
            'wxid': wxid,
            'path': path
        })


def main():
    """主函数"""
    print("=" * 50)
    print("ComWeChatBot HTTP Server")
    print("=" * 50)
    
    # 初始化机器人
    if not bot.init():
        print("[ERROR] Failed to initialize bot")
        return 1
    
    # 注册消息处理器
    def on_msg(msg):
        # 这里可以添加消息转发到 OpenClaw 的逻辑
        pass
    
    bot.on_message(on_msg)
    
    # 启动 HTTP 服务器
    port = 8001
    server = HTTPServer(('127.0.0.1', port), APIHandler)
    logger.info(f"HTTP server started on http://127.0.0.1:{port}")
    print(f"\n[OK] HTTP API: http://127.0.0.1:{port}")
    print("[OK] Endpoints:")
    print(f"  GET  /api/status      - Get bot status")
    print(f"  GET  /api/self        - Get self info")
    print(f"  GET  /api/friends     - Get friend list")
    print(f"  POST /api/send/text   - Send text message")
    print(f"  POST /api/send/image  - Send image")
    print("\nPress Ctrl+C to stop\n")
    
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\n[INFO] Stopping...")
        bot.stop()
        server.shutdown()
        print("[OK] Stopped")
    
    return 0


if __name__ == '__main__':
    exit(main())