feat: add wechatpad for personal wechat

* 更新了wechatpad接口，以及适配器

* 更新了wechatpad接口，以及适配器

* 修复一些细节问题，比如at回复，以及启动登录和启动ws长连接的线程同步

* importutil中修复了在wi上启动替换斜杠问题，login中加上了一个login，暂时没啥用。wechatpad中做出了一些细节修改

* 更新了wechatpad接口，以及适配器

* 怎加了处理图片链接转换为image_base64发送

* feat(wechatpad): 调整日志+bugfix

* feat(wechatpad): fix typo

* 修正了发送语音api参数错误，添加了发送链接处理为base64数据（好像只有一部分链接可以）

* 修复了部分手抽的typo错误

* chore: remove manager.py

---------

Co-authored-by: shinelin <shinelinxx@gmail.com>
Co-authored-by: Junyan Qin (Chin) <rockchinq@gmail.com>

libs/wechatpad_api/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

libs/wechatpad_api/README.md

@@ -0,0 +1,38 @@
+# wechatpad-python
+
+
+## 此项目时准备对接wechatpadpro 的pythonsdk
+
+## 未完工接口
+
+* 关于好友的接口
+* 关于群管理的接口
+* 关于下载的接口
+* 关于用户的部分接口
+* 关于消息的部分接口
+* 关于支付的
+* 关于朋友圈的
+* 关于标签的
+* 关于收藏的
+
+* 暂时只写了一部分接口
+
+
+## 已完工接口
+
+1. 获取普通token
+2. 登录二维码（只是返回数据，暂时还未打印二维码）
+3. 获取登录状态
+4. 唤醒登录
+5. 退出登录
+6. 获取用户信息
+7. 获取用户二维码
+8. 上传用户头像
+9. 获取设备信息
+10. 发送文本消息
+11. 发送图片消息
+12. 发送语音消息
+13. 发送app消息
+14. 发送emoji消息
+15. 发送名片消息
+16. 撤回消息

libs/wechatpad_api/__init__.py

@@ -0,0 +1 @@
+from .client import WeChatPadClient

libs/wechatpad_api/api/chatroom.py

@@ -0,0 +1,14 @@
+from libs.wechatpad_api.util.http_util import async_request, post_json
+
+
+class ChatRoomApi:
+    def __init__(self, base_url, token):
+        self.base_url = base_url
+        self.token = token
+
+    def get_chatroom_member_detail(self, chatroom_name):
+        params = {
+            "ChatRoomName": chatroom_name
+        }
+        url = self.base_url + '/group/GetChatroomMemberDetail'
+        return post_json(url, token=self.token, data=params)

libs/wechatpad_api/api/downloadpai.py

@@ -0,0 +1,39 @@
+from libs.wechatpad_api.util.http_util import async_request, post_json
+import httpx
+import base64
+
+class DownloadApi:
+    def __init__(self, base_url, token):
+        self.base_url = base_url
+        self.token = token
+
+    def send_download(self, aeskey, file_type, file_url):
+        json_data = {
+                  "AesKey": aeskey,
+                  "FileType": file_type,
+                  "FileURL": file_url
+                }
+        url = self.base_url + "/message/SendCdnDownload"
+        return post_json(url, token=self.token, data=json_data)
+
+    def get_msg_voice(self,buf_id, length, new_msgid):
+        json_data = {
+            "Bufid": buf_id,
+            "Length": length,
+            "NewMsgId": new_msgid,
+            "ToUserName": ""
+        }
+        url = self.base_url + "/message/GetMsgVoice"
+        return post_json(url, token=self.token, data=json_data)
+
+
+    async def download_url_to_base64(self, download_url):
+        async with httpx.AsyncClient() as client:
+            response = await client.get(download_url)
+
+            if response.status_code == 200:
+                file_bytes = response.content
+                base64_str = base64.b64encode(file_bytes).decode('utf-8')  # 返回字符串格式
+                return base64_str
+            else:
+                raise Exception('获取文件失败')

libs/wechatpad_api/api/friend.py

@@ -0,0 +1,11 @@
+from libs.wechatpad_api.util.http_util import post_json,async_request
+from typing import List, Dict, Any, Optional
+
+
+class FriendApi:
+    """联系人API类，处理所有与联系人相关的操作"""
+
+    def __init__(self, base_url: str, token: str):
+        self.base_url = base_url
+        self.token = token
+

libs/wechatpad_api/api/login.py

@@ -0,0 +1,102 @@
+from libs.wechatpad_api.util.http_util import async_request,post_json,get_json
+
+
+class LoginApi:
+    def __init__(self, base_url: str, token: str = None, admin_key: str = None):
+        '''
+
+        Args:
+            base_url: 原始路径
+            token: token
+            admin_key: 管理员key
+        '''
+        self.base_url = base_url
+        self.token = token
+        # self.admin_key = admin_key
+
+    def get_token(self, admin_key, day: int=365):
+        # 获取普通token
+        url = f"{self.base_url}/admin/GenAuthKey1"
+        json_data = {
+                "Count": 1,
+                "Days": day
+            }
+        return post_json(base_url=url, token=admin_key, data=json_data)
+
+    def get_login_qr(self, Proxy: str = ""):
+        '''
+
+        Args:
+            Proxy:异地使用时代理
+
+        Returns:json数据
+
+        '''
+        """
+        
+        {
+  "Code": 200,
+  "Data": {
+    "Key": "3141312",
+    "QrCodeUrl": "https://1231x/g6bMlv2dX8zwNbqE6-Zs",
+    "Txt": "建议返回data=之后内容自定义生成二维码",
+    "baseResp": {
+      "ret": 0,
+      "errMsg": {}
+    }
+  },
+  "Text": ""
+}
+        
+        """
+        #获取登录二维码
+        url = f"{self.base_url}/login/GetLoginQrCodeNew"
+        check = False
+        if Proxy != "":
+            check = True
+        json_data = {
+              "Check": check,
+              "Proxy": Proxy
+            }
+        return post_json(base_url=url, token=self.token, data=json_data)
+
+
+    def get_login_status(self):
+        # 获取登录状态
+        url = f'{self.base_url}/login/GetLoginStatus'
+        return get_json(base_url=url, token=self.token)
+
+
+
+    def logout(self):
+        # 退出登录
+        url = f'{self.base_url}/login/LogOut'
+        return post_json(base_url=url, token=self.token)
+
+
+
+
+    def wake_up_login(self, Proxy: str = ""):
+        # 唤醒登录
+        url = f'{self.base_url}/login/WakeUpLogin'
+        check = False
+        if Proxy != "":
+            check = True
+        json_data = {
+            "Check": check,
+            "Proxy": ""
+        }
+
+        return post_json(base_url=url, token=self.token, data=json_data)
+
+
+
+    def login(self,admin_key):
+        login_status = self.get_login_status()
+        if login_status["Code"] == 300 and login_status["Text"] == "你已退出微信":
+            print("token已经失效，重新获取")
+            token_data = self.get_token(admin_key)
+            self.token = token_data["Data"][0]
+
+
+

libs/wechatpad_api/api/message.py

@@ -0,0 +1,123 @@
+
+from libs.wechatpad_api.util.http_util import async_request, post_json
+
+
+class MessageApi:
+    def __init__(self, base_url, token):
+        self.base_url = base_url
+        self.token = token
+
+    def post_text(self, to_wxid, content, ats: list= []):
+        '''
+
+        Args:
+            app_id: 微信id
+            to_wxid: 发送方的微信id
+            content: 内容
+            ats: at
+
+        Returns:
+
+        '''
+        url = self.base_url + "/message/SendTextMessage"
+        """发送文字消息"""
+        json_data = {
+                      "MsgItem": [
+                        {
+                          "AtWxIDList": ats,
+                          "ImageContent": "",
+                          "MsgType": 0,
+                          "TextContent": content,
+                          "ToUserName": to_wxid
+                        }
+                      ]
+                    }
+        return  post_json(base_url=url, token=self.token, data=json_data)
+
+
+
+
+    def post_image(self, to_wxid, img_url, ats: list= []):
+        """发送图片消息"""
+        # 这里好像可以尝试发送多个暂时未测试
+        json_data = {
+            "MsgItem": [
+                {
+                    "AtWxIDList": ats,
+                    "ImageContent": img_url,
+                    "MsgType": 0,
+                    "TextContent": '',
+                    "ToUserName": to_wxid
+                }
+            ]
+        }
+        url = self.base_url + "/message/SendImageMessage"
+        return post_json(base_url=url, token=self.token, data=json_data)
+
+    def post_voice(self, to_wxid, voice_data, voice_forma, voice_duration):
+        """发送语音消息"""
+        json_data = {
+            "ToUserName": to_wxid,
+            "VoiceData": voice_data,
+            "VoiceFormat": voice_forma,
+            "VoiceSecond": voice_duration
+        }
+        url = self.base_url + "/message/SendVoice"
+        return post_json(base_url=url, token=self.token, data=json_data)
+
+
+
+
+
+    def post_name_card(self, alias, to_wxid, nick_name, name_card_wxid, flag):
+        """发送名片消息"""
+        param = {
+                "CardAlias": alias,
+                "CardFlag": flag,
+                "CardNickName": nick_name,
+                "CardWxId": name_card_wxid,
+                "ToUserName": to_wxid
+        }
+        url = f"{self.base_url}/message/ShareCardMessage"
+        return post_json(base_url=url, token=self.token, data=param)
+
+    def post_emoji(self, to_wxid, emoji_md5, emoji_size:int=0):
+        """发送emoji消息"""
+        json_data = {
+            "EmojiList": [
+                {
+                    "EmojiMd5": emoji_md5,
+                    "EmojiSize": emoji_size,
+                    "ToUserName": to_wxid
+                }
+            ]
+        }
+        url = f"{self.base_url}/message/SendEmojiMessage"
+        return post_json(base_url=url, token=self.token, data=json_data)
+
+    def post_app_msg(self, to_wxid,xml_data, contenttype:int=0):
+        """发送appmsg消息"""
+        json_data = {
+            "AppList": [
+                {
+                    "ContentType": contenttype,
+                    "ContentXML": xml_data,
+                    "ToUserName": to_wxid
+                }
+            ]
+        }
+        url = f"{self.base_url}/message/SendAppMessage"
+        return post_json(base_url=url, token=self.token, data=json_data)
+
+
+
+    def revoke_msg(self, to_wxid, msg_id, new_msg_id, create_time):
+        """撤回消息"""
+        param = {
+              "ClientMsgId": msg_id,
+              "CreateTime": create_time,
+              "NewMsgId": new_msg_id,
+              "ToUserName": to_wxid
+            }
+        url = f"{self.base_url}/message/RevokeMsg"
+        return post_json(base_url=url, token=self.token, data=param)

libs/wechatpad_api/api/user.py

@@ -0,0 +1,37 @@
+from libs.wechatpad_api.util.http_util import post_json, async_request, get_json
+
+
+class UserApi:
+    def __init__(self, base_url, token):
+        self.base_url = base_url
+        self.token = token
+
+    def get_profile(self):
+        """获取个人资料"""
+        url = f'{self.base_url}/user/GetProfile'
+
+        return get_json(base_url=url, token=self.token)
+
+    def get_qr_code(self, recover:bool=True, style:int=8):
+        """获取自己的二维码"""
+        param = {
+              "Recover": recover,
+              "Style": style
+            }
+        url = f'{self.base_url}/user/GetMyQRCode'
+        return post_json(base_url=url, token=self.token, data=param)
+
+    def get_safety_info(self):
+        """获取设备记录"""
+        url = f'{self.base_url}/equipment/GetSafetyInfo'
+        return post_json(base_url=url, token=self.token)
+
+
+
+    async def update_head_img(self,  head_img_base64):
+        """修改头像"""
+        param = {
+              "Base64": head_img_base64
+            }
+        url = f'{self.base_url}/user/UploadHeadImage'
+        return await async_request(base_url=url, token_key=self.token, json=param)

libs/wechatpad_api/client.py

@@ -0,0 +1,97 @@
+
+from libs.wechatpad_api.api.login import LoginApi
+from libs.wechatpad_api.api.friend import FriendApi
+from libs.wechatpad_api.api.message import MessageApi
+from libs.wechatpad_api.api.user import UserApi
+from libs.wechatpad_api.api.downloadpai import DownloadApi
+from libs.wechatpad_api.api.chatroom import ChatRoomApi
+
+
+
+
+
+class WeChatPadClient:
+    def __init__(self,base_url, token):
+        self._login_api = LoginApi(base_url, token)
+        self._friend_api = FriendApi(base_url, token)
+        self._message_api = MessageApi(base_url, token)
+        self._user_api = UserApi(base_url, token)
+        self._download_api = DownloadApi(base_url, token)
+        self._chatroom_api = ChatRoomApi(base_url, token)
+
+    def get_token(self,admin_key, day: int):
+        '''获取token'''
+        return self._login_api.get_token(admin_key, day)
+
+    def get_login_qr(self, Proxy:str=""):
+        """登录二维码"""
+        return self._login_api.get_login_qr(Proxy=Proxy)
+
+    def awaken_login(self, Proxy:str=""):
+        '''唤醒登录'''
+        return self._login_api.wake_up_login(Proxy=Proxy)
+
+    def log_out(self):
+        """退出登录"""
+        return self._login_api.logout()
+
+    def get_login_status(self):
+        """获取登录状态"""
+        return self._login_api.get_login_status()
+
+    def send_text_message(self, to_wxid, message, ats: list=[]):
+        """发送文本消息"""
+        return  self._message_api.post_text(to_wxid, message, ats)
+
+    def send_image_message(self, to_wxid, img_url, ats: list=[]):
+        """发送图片消息"""
+        return  self._message_api.post_image(to_wxid, img_url, ats)
+
+    def send_voice_message(self, to_wxid, voice_data, voice_forma, voice_duration):
+        """发送音频消息"""
+        return  self._message_api.post_voice(to_wxid, voice_data, voice_forma, voice_duration)
+
+    def send_app_message(self, to_wxid, app_message, type):
+        """发送app消息"""
+        return  self._message_api.post_app_msg(to_wxid, app_message, type)
+
+    def send_emoji_message(self, to_wxid, emoji_md5, emoji_size):
+        """发送emoji消息"""
+        return  self._message_api.post_emoji(to_wxid,emoji_md5,emoji_size)
+
+    def revoke_msg(self, to_wxid, msg_id, new_msg_id, create_time):
+        """撤回消息"""
+        return  self._message_api.revoke_msg(to_wxid, msg_id, new_msg_id, create_time)
+
+    def get_profile(self):
+        """获取用户信息"""
+        return self._user_api.get_profile()
+
+    def get_qr_code(self, recover:bool=True, style:int=8):
+        """获取用户二维码"""
+        return  self._user_api.get_qr_code(recover=recover, style=style)
+
+    def get_safety_info(self):
+        """获取设备信息"""
+        return  self._user_api.get_safety_info()
+
+    def update_head_img(self,  head_img_base64):
+        """上传用户头像"""
+        return  self._user_api.update_head_img(head_img_base64)
+
+    def cdn_download(self, aeskey, file_type, file_url):
+        """cdn下载"""
+        return self._download_api.send_download( aeskey, file_type, file_url)
+
+    def get_msg_voice(self,buf_id, length, msgid):
+        """下载语音"""
+        return self._download_api.get_msg_voice(buf_id, length, msgid)
+
+    async def download_base64(self,url):
+        return await self._download_api.download_url_to_base64(download_url=url)
+
+    def get_chatroom_member_detail(self, chatroom_name):
+        """查看群成员详情"""
+        return self._chatroom_api.get_chatroom_member_detail(chatroom_name)
+
+

libs/wechatpad_api/util/http_util.py

@@ -0,0 +1,92 @@
+import requests
+
+def post_json(base_url, token, data=None):
+    headers = {
+        'Content-Type': 'application/json'
+    }
+
+
+    url = base_url + f'?key={token}'
+
+    try:
+        response = requests.post(url, json=data, headers=headers, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+
+        if result:
+            return result
+        else:
+            raise RuntimeError(response.text)
+    except Exception as e:
+        print(f"http请求失败, url={url}, exception={e}")
+        raise RuntimeError(str(e))
+
+def get_json(base_url, token):
+    headers = {
+        'Content-Type': 'application/json'
+    }
+
+
+    url = base_url + f'?key={token}'
+
+    try:
+        response = requests.get(url, headers=headers, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+
+        if result:
+            return result
+        else:
+            raise RuntimeError(response.text)
+    except Exception as e:
+        print(f"http请求失败, url={url}, exception={e}")
+        raise RuntimeError(str(e))
+
+import aiohttp
+import asyncio
+
+
+async def async_request(
+        base_url: str,
+        token_key: str,
+        method: str = 'POST',
+        params: dict = None,
+        # headers: dict = None,
+        data: dict = None,
+        json: dict = None
+):
+    """
+    通用异步请求函数
+
+    :param base_url: 请求URL
+    :param token_key: 请求token
+    :param method: HTTP方法 (GET, POST, PUT, DELETE等)
+    :param params: URL查询参数
+    # :param headers: 请求头
+    :param data: 表单数据
+    :param json: JSON数据
+    :return: 响应文本
+    """
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    url = f"{base_url}?key={token_key}"
+    async with aiohttp.ClientSession() as session:
+        async with session.request(
+                method=method,
+                url=url,
+                params=params,
+                headers=headers,
+                data=data,
+                json=json
+        ) as response:
+            response.raise_for_status()  # 如果状态码不是200，抛出异常
+            result = await response.json()
+            # print(result)
+            return result
+            # if result.get('Code') == 200:
+            #
+            #     return await result
+            # else:
+            #     raise RuntimeError("请求失败",response.text)
+

libs/wechatpad_api/util/terminal_printer.py

@@ -0,0 +1,31 @@
+import qrcode
+
+def print_green(text):
+    print(f"\033[32m{text}\033[0m")
+
+def print_yellow(text):
+    print(f"\033[33m{text}\033[0m")
+
+def print_red(text):
+    print(f"\033[31m{text}\033[0m")
+
+def make_and_print_qr(url):
+    """生成并打印二维码
+    
+    Args:
+        url: 需要生成二维码的URL字符串
+        
+    Returns:
+        None
+        
+    功能:
+        1. 在终端打印二维码的ASCII图形
+        2. 同时提供在线二维码生成链接作为备选
+    """
+    print_green("请扫描下方二维码登录")
+    qr = qrcode.QRCode()
+    qr.add_data(url)
+    qr.make()
+    qr.print_ascii(invert=True)
+    print_green(f"也可以访问下方链接获取二维码:\nhttps://api.qrserver.com/v1/create-qr-code/?data={url}")
+

pkg/platform/sources/wechatpad.py

@@ -0,0 +1,773 @@
+import requests
+import websockets
+import websocket
+import json
+import time
+import httpx
+
+from libs.wechatpad_api.client import WeChatPadClient
+
+import typing
+import asyncio
+import traceback
+import time
+import re
+import base64
+import uuid
+import json
+import os
+import copy
+import datetime
+import threading
+
+import quart
+import aiohttp
+
+from .. import adapter
+from ...pipeline.longtext.strategies import forward
+from ...core import app
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...utils import image
+import xml.etree.ElementTree as ET
+from typing import Optional, List, Tuple
+from functools import partial
+import logging
+
+class WeChatPadMessageConverter(adapter.MessageConverter):
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.bot = WeChatPadClient(self.config["wechatpad_url"],self.config["token"])
+        self.logger = logging.getLogger("WeChatPadMessageConverter")
+
+    @staticmethod
+    async def yiri2target(
+            message_chain: platform_message.MessageChain
+    ) -> list[dict]:
+        content_list = []
+        current_file_path = os.path.abspath(__file__)
+
+
+
+        for component in message_chain:
+            if isinstance(component, platform_message.At):
+                content_list.append({"type": "at", "target": component.target})
+            elif isinstance(component, platform_message.Plain):
+                content_list.append({"type": "text", "content": component.text})
+            elif isinstance(component, platform_message.Image):
+                if component.url:
+                    async with httpx.AsyncClient() as client:
+                        response = await client.get(component.url)
+
+                        if response.status_code == 200:
+                            file_bytes = response.content
+                            base64_str = base64.b64encode(file_bytes).decode('utf-8')  # 返回字符串格式
+                        else:
+                            raise Exception('获取文件失败')
+                    # pass
+                    content_list.append({"type": "image", "image": base64_str})
+                elif component.base64:
+                    content_list.append({"type": "image", "image": component.base64})
+
+            elif isinstance(component, platform_message.WeChatEmoji):
+                content_list.append(
+                    {'type': 'WeChatEmoji', 'emoji_md5': component.emoji_md5, 'emoji_size': component.emoji_size})
+            elif isinstance(component, platform_message.Voice):
+                content_list.append({"type": "voice", "data": component.url, "duration": component.length, "forma": 0})
+            elif isinstance(component, platform_message.WeChatAppMsg):
+                content_list.append({'type': 'WeChatAppMsg', 'app_msg': component.app_msg})
+            elif isinstance(component, platform_message.Forward):
+                for node in component.node_list:
+                    if node.message_chain:
+                        content_list.extend(await WeChatPadMessageConverter.yiri2target(node.message_chain))
+
+        return content_list
+
+
+    async def target2yiri(
+            self,
+            message: dict,
+            bot_account_id: str
+    ) -> platform_message.MessageChain:
+        """外部消息转平台消息"""
+        # 数据预处理
+        message_list = []
+        ats_bot = False  # 是否被@
+        content = message["content"]["str"]
+        content_no_preifx = content  # 群消息则去掉前缀
+        is_group_message = self._is_group_message(message)
+        if is_group_message:
+            ats_bot = self._ats_bot(message, bot_account_id)
+            if "@所有人" in content:
+                message_list.append(platform_message.AtAll())
+            elif ats_bot:
+                message_list.append(platform_message.At(target=bot_account_id))
+            content_no_preifx, _ = self._extract_content_and_sender(content)
+
+        msg_type = message["msg_type"]
+
+        # 映射消息类型到处理器方法
+        handler_map = {
+            1: self._handler_text,
+            3: self._handler_image,
+            34: self._handler_voice,
+            49: self._handler_compound,  # 复合类型
+        }
+
+        # 分派处理
+        handler = handler_map.get(msg_type, self._handler_default)
+        handler_result = await handler(
+            message=message,  # 原始的message
+            content_no_preifx=content_no_preifx,  # 处理后的content
+        )
+
+        if handler_result and len(handler_result) > 0:
+            message_list.extend(handler_result)
+
+        return platform_message.MessageChain(message_list)
+
+    async def _handler_text(
+            self,
+            message: Optional[dict],
+            content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理文本消息 (msg_type=1)"""
+        if message and self._is_group_message(message):
+            pattern = r'@\S{1,20}'
+            content_no_preifx = re.sub(pattern, '', content_no_preifx)
+
+        return platform_message.MessageChain([platform_message.Plain(content_no_preifx)])
+
+    async def _handler_image(
+            self,
+            message: Optional[dict],
+            content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理图像消息 (msg_type=3)"""
+        try:
+            image_xml = content_no_preifx
+            if not image_xml:
+                return platform_message.MessageChain([platform_message.Unknown("[图片内容为空]")])
+            root = ET.fromstring(image_xml)
+
+            # 提取img标签的属性
+            img_tag = root.find('img')
+            if img_tag is not None:
+                aeskey = img_tag.get('aeskey')
+                cdnthumburl = img_tag.get('cdnthumburl')
+                # cdnmidimgurl = img_tag.get('cdnmidimgurl')
+
+
+            image_data = self.bot.cdn_download(aeskey=aeskey, file_type=1, file_url=cdnthumburl)
+            if image_data["Data"]['FileData'] == '':
+                image_data = self.bot.cdn_download(aeskey=aeskey, file_type=2, file_url=cdnthumburl)
+            base64_str = image_data["Data"]['FileData']
+            # self.logger.info(f"data:image/png;base64,{base64_str}")
+
+
+            elements = [
+                platform_message.Image(base64=f"data:image/png;base64,{base64_str}"),
+                # platform_message.WeChatForwardImage(xml_data=image_xml)  # 微信消息转发
+            ]
+            return platform_message.MessageChain(elements)
+        except Exception as e:
+            self.logger.error(f"处理图片失败: {str(e)}")
+            return platform_message.MessageChain([platform_message.Unknown("[图片处理失败]")])
+
+    async def _handler_voice(
+            self,
+            message: Optional[dict],
+            content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理语音消息 (msg_type=34)"""
+        message_List = []
+        try:
+            # 从消息中提取语音数据（需根据实际数据结构调整字段名）
+            # audio_base64 = message["img_buf"]["buffer"]
+            voice_xml = content_no_preifx
+            new_msg_id = message['new_msg_id']
+            root = ET.fromstring(voice_xml)
+
+            # 提取voicemsg标签的属性
+            voicemsg = root.find('voicemsg')
+            if voicemsg is not None:
+                bufid = voicemsg.get('bufid')
+                length = voicemsg.get('voicelength')
+            voice_data = self.bot.get_msg_voice(buf_id=str(bufid), length=int(length), msgid=str(new_msg_id))
+            audio_base64 = voice_data["Data"]['Base64']
+
+            # 验证语音数据有效性
+            if not audio_base64:
+                message_List.append(platform_message.Unknown(text="[语音内容为空]"))
+                return platform_message.MessageChain(message_List)
+
+            # 转换为平台支持的语音格式（如 Silk 格式）
+            voice_element = platform_message.Voice(
+                base64=f"data:audio/silk;base64,{audio_base64}"
+            )
+            message_List.append(voice_element)
+
+        except KeyError as e:
+            self.logger.error(f"语音数据字段缺失: {str(e)}")
+            message_List.append(platform_message.Unknown(text="[语音数据解析失败]"))
+        except Exception as e:
+            self.logger.error(f"处理语音消息异常: {str(e)}")
+            message_List.append(platform_message.Unknown(text="[语音处理失败]"))
+
+        return platform_message.MessageChain(message_List)
+
+    async def _handler_compound(
+            self,
+            message: Optional[dict],
+            content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理复合消息 (msg_type=49)，根据子类型分派"""
+        try:
+            xml_data = ET.fromstring(content_no_preifx)
+            appmsg_data = xml_data.find('.//appmsg')
+            if appmsg_data:
+                data_type = appmsg_data.findtext('.//type', "")
+                # 二次分派处理器
+                sub_handler_map = {
+                    '57': self._handler_compound_quote,
+                    '5': self._handler_compound_link,
+                    '6': self._handler_compound_file,
+                    '33': self._handler_compound_mini_program,
+                    '36': self._handler_compound_mini_program,
+                    '2000': partial(self._handler_compound_unsupported, text="[转账消息]"),
+                    '2001': partial(self._handler_compound_unsupported, text="[红包消息]"),
+                    '51': partial(self._handler_compound_unsupported, text="[视频号消息]"),
+                }
+
+                handler = sub_handler_map.get(data_type, self._handler_compound_unsupported)
+                return await handler(
+                    message=message,  # 原始msg
+                    xml_data=xml_data,  # xml数据
+                )
+            else:
+                return platform_message.MessageChain([platform_message.Unknown(text=content_no_preifx)])
+        except Exception as e:
+            self.logger.error(f"解析复合消息失败: {str(e)}")
+            return platform_message.MessageChain([platform_message.Unknown(text=content_no_preifx)])
+
+    async def _handler_compound_quote(
+            self,
+            message: Optional[dict],
+            xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理引用消息 (data_type=57)"""
+        message_list = []
+#         self.logger.info("_handler_compound_quote", ET.tostring(xml_data, encoding='unicode'))
+        appmsg_data = xml_data.find('.//appmsg')
+        quote_data = ""  # 引用原文
+        quote_id = None  # 引用消息的原发送者
+        tousername = None  # 接收方: 所属微信的wxid
+        user_data = ""  # 用户消息
+        sender_id = xml_data.findtext('.//fromusername')  # 发送方：单聊用户/群member
+
+        # 引用消息转发
+        if appmsg_data:
+            user_data = appmsg_data.findtext('.//title') or ""
+            quote_data = appmsg_data.find('.//refermsg').findtext('.//content')
+            quote_id = appmsg_data.find('.//refermsg').findtext('.//chatusr')
+            message_list.append(
+                platform_message.WeChatAppMsg(
+                    app_msg=ET.tostring(appmsg_data, encoding='unicode'))
+            )
+        if message:
+            tousername = message['to_user_name']["str"]
+        
+        if quote_data:
+            quote_data_message_list = platform_message.MessageChain()
+            # 文本消息
+            try:
+                if "<msg>" not in quote_data:
+                    quote_data_message_list.append(platform_message.Plain(quote_data))
+                else:
+                    # 引用消息展开
+                    quote_data_xml = ET.fromstring(quote_data)
+                    if quote_data_xml.find("img"):
+                        quote_data_message_list.extend(await self._handler_image(None, quote_data))
+                    elif quote_data_xml.find("voicemsg"):
+                        quote_data_message_list.extend(await self._handler_voice(None, quote_data))
+                    elif quote_data_xml.find("videomsg"):
+                        quote_data_message_list.extend(await self._handler_default(None, quote_data))  # 先不处理
+                    else:
+                        # appmsg
+                        quote_data_message_list.extend(await self._handler_compound(None, quote_data))
+            except Exception as e:
+                self.logger.error(f"处理引用消息异常 expcetion:{e}")
+                quote_data_message_list.append(platform_message.Plain(quote_data))
+            message_list.append(
+                platform_message.Quote(
+                    sender_id=sender_id,
+                    origin=quote_data_message_list,
+                )
+            )
+            if len(user_data) > 0:
+                pattern = r'@\S{1,20}'
+                user_data = re.sub(pattern, '', user_data)
+                message_list.append(platform_message.Plain(user_data))
+
+        return platform_message.MessageChain(message_list)
+
+    async def _handler_compound_file(
+            self,
+            message: dict,
+            xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理文件消息 (data_type=6)"""
+        xml_data_str = ET.tostring(xml_data, encoding='unicode')
+        return platform_message.MessageChain([
+            platform_message.WeChatForwardFile(xml_data=xml_data_str)
+        ])
+
+    async def _handler_compound_link(
+            self,
+            message: dict,
+            xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理链接消息（如公众号文章、外部网页）"""
+        message_list = []
+        try:
+            # 解析 XML 中的链接参数
+            appmsg = xml_data.find('.//appmsg')
+            if appmsg is None:
+                return platform_message.MessageChain()
+            message_list.append(
+                platform_message.WeChatLink(
+                    link_title=appmsg.findtext('title', ''),
+                    link_desc=appmsg.findtext('des', ''),
+                    link_url=appmsg.findtext('url', ''),
+                    link_thumb_url=appmsg.findtext("thumburl", '')  # 这个字段拿不到
+                )
+            )
+            # 还没有发链接的接口, 暂时还需要自己构造appmsg, 先用WeChatAppMsg。
+            message_list.append(
+                platform_message.WeChatAppMsg(
+                    app_msg=ET.tostring(appmsg, encoding='unicode')
+                )
+            )
+        except Exception as e:
+            self.logger.error(f"解析链接消息失败: {str(e)}")
+        return platform_message.MessageChain(message_list)
+
+    async def _handler_compound_mini_program(
+            self,
+            message: dict,
+            xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理小程序消息（如小程序卡片、服务通知）"""
+        xml_data_str = ET.tostring(xml_data, encoding='unicode')
+        return platform_message.MessageChain([
+            platform_message.WeChatForwardMiniPrograms(xml_data=xml_data_str)
+        ])
+
+    async def _handler_default(
+            self,
+            message: Optional[dict],
+            content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理未知消息类型"""
+        if message:
+            msg_type = message["msg_type"]
+        else:
+            msg_type = ""
+        return platform_message.MessageChain([
+            platform_message.Unknown(text=f"[未知消息类型 msg_type:{msg_type}]")
+        ])
+
+    def _handler_compound_unsupported(
+            self,
+            message: dict,
+            xml_data: str,
+            text: Optional[str] = None
+    ) -> platform_message.MessageChain:
+        """处理未支持复合消息类型(msg_type=49)子类型"""
+        if not text:
+            text = f"[xml_data={xml_data}]"
+        content_list = []
+        content_list.append(
+            platform_message.Unknown(text=f"[处理未支持复合消息类型[msg_type=49]|{text}"))
+
+        return platform_message.MessageChain(content_list)
+
+    # 返回是否被艾特
+    def _ats_bot(self, message: dict, bot_account_id: str) -> bool:
+        ats_bot = False
+        try:
+            to_user_name = message['to_user_name']['str']  # 接收方: 所属微信的wxid
+            raw_content = message["content"]["str"]  # 原始消息内容
+            content_no_prefix, _ = self._extract_content_and_sender(raw_content)
+            # 直接艾特机器人（这个有bug，当被引用的消息里面有@bot,会套娃
+            # ats_bot =  ats_bot or (f"@{bot_account_id}" in content_no_prefix)
+            # 文本类@bot
+            push_content = message.get('push_content', '')
+            ats_bot = ats_bot or ('在群聊中@了你' in push_content)
+            # 引用别人时@bot
+            msg_source = message.get('msg_source', '') or ''
+            if len(msg_source) > 0:
+                msg_source_data = ET.fromstring(msg_source)
+                at_user_list = msg_source_data.findtext("atuserlist") or ""
+                ats_bot = ats_bot or (to_user_name in at_user_list)
+            # 引用bot
+            if message.get('msg_type', 0) == 49:
+                xml_data = ET.fromstring(content_no_prefix)
+                appmsg_data = xml_data.find('.//appmsg')
+                tousername = message['to_user_name']['str']
+                if appmsg_data:  # 接收方: 所属微信的wxid
+                    quote_id = appmsg_data.find('.//refermsg').findtext('.//chatusr')  # 引用消息的原发送者
+                    ats_bot = ats_bot or (quote_id == tousername)
+        except Exception as e:
+            self.logger.error(f"_ats_bot got except: {e}")
+        finally:
+            return ats_bot
+
+    # 提取一下content前面的sender_id, 和去掉前缀的内容
+    def _extract_content_and_sender(self, raw_content: str) -> Tuple[str, Optional[str]]:
+        try:
+            # 检查消息开头，如果有 wxid_sbitaz0mt65n22:\n 则删掉
+            # add: 有些用户的wxid不是上述格式。换成user_name:
+            regex = re.compile(r"^[a-zA-Z0-9_\-]{5,20}:")
+            line_split = raw_content.split("\n")
+            if len(line_split) > 0 and regex.match(line_split[0]):
+                raw_content = "\n".join(line_split[1:])
+                sender_id = line_split[0].strip(":")
+                return raw_content, sender_id
+        except Exception as e:
+            self.logger.error(f"_extract_content_and_sender got except: {e}")
+        finally:
+            return raw_content, None
+
+    # 是否是群消息
+    def _is_group_message(self, message: dict) -> bool:
+        from_user_name = message['from_user_name']['str']
+        return from_user_name.endswith("@chatroom")
+
+
+class WeChatPadEventConverter(adapter.EventConverter):
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.message_converter = WeChatPadMessageConverter(config)
+        self.logger = logging.getLogger("WeChatPadEventConverter")
+        
+    @staticmethod
+    async def yiri2target(
+            event: platform_events.MessageEvent
+    ) -> dict:
+        pass
+
+    async def target2yiri(
+            self,
+            event: dict,
+            bot_account_id: str
+    ) -> platform_events.MessageEvent:
+
+        # 排除公众号以及微信团队消息
+        if event['from_user_name']['str'].startswith('gh_') \
+                or event['from_user_name']['str']=='weixin'\
+                or event['from_user_name']['str'] == "newsapp"\
+                or event['from_user_name']['str'] == self.config["wxid"]:
+            return None
+        message_chain = await self.message_converter.target2yiri(copy.deepcopy(event), bot_account_id)
+
+        if not message_chain:
+            return None
+
+        if '@chatroom' in event['from_user_name']['str']:
+            # 找出开头的 wxid_ 字符串，以:结尾
+            sender_wxid = event['content']['str'].split(":")[0]
+
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=sender_wxid,
+                    member_name=event['from_user_name']['str'],
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=event['from_user_name']['str'],
+                        name=event['from_user_name']['str'],
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title="",
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=message_chain,
+                time=event["create_time"],
+                source_platform_object=event,
+            )
+        else:
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event['from_user_name']['str'],
+                    nickname=event['from_user_name']['str'],
+                    remark='',
+                ),
+                message_chain=message_chain,
+                time=event["create_time"],
+                source_platform_object=event,
+            )
+
+
+class WeChatPadAdapter(adapter.MessagePlatformAdapter):
+    name: str = "WeChatPad"  # 定义适配器名称
+
+    bot: WeChatPadClient
+    quart_app: quart.Quart
+
+    bot_account_id: str
+
+    config: dict
+
+    ap: app.Application
+
+    message_converter: WeChatPadMessageConverter
+    event_converter: WeChatPadEventConverter
+
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
+    ] = {}
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+        self.ap = ap
+        self.quart_app = quart.Quart(__name__)
+
+        self.message_converter = WeChatPadMessageConverter(config)
+        self.event_converter = WeChatPadEventConverter(config)
+
+    async def ws_message(self, data):
+        """处理接收到的消息"""
+        # self.ap.logger.debug(f"Gewechat callback event: {data}")
+        # print(data)
+
+
+        try:
+            event = await self.event_converter.target2yiri(data.copy(), self.bot_account_id)
+        except Exception as e:
+            traceback.print_exc()
+
+        if event.__class__ in self.listeners:
+            await self.listeners[event.__class__](event, self)
+
+        return 'ok'
+
+
+    async def _handle_message(
+            self,
+            message: platform_message.MessageChain,
+            target_id: str
+    ):
+        """统一消息处理核心逻辑"""
+        content_list = await self.message_converter.yiri2target(message)
+        # print(content_list)
+        at_targets = [item["target"] for item in content_list if item["type"] == "at"]
+        # print(at_targets)
+        # 处理@逻辑
+        at_targets = at_targets or []
+        member_info = []
+        if at_targets:
+            member_info = self.bot.get_chatroom_member_detail(
+                target_id,
+            )["Data"]["member_data"]["chatroom_member_list"]
+
+        # 处理消息组件
+        for msg in content_list:
+            # 文本消息处理@
+            if msg['type'] == 'text' and at_targets:
+                at_nick_name_list = []
+                for member in member_info:
+                    if member["user_name"] in at_targets:
+                        at_nick_name_list.append(f'@{member["nick_name"]}')
+                msg['content'] = f'{" ".join(at_nick_name_list)} {msg["content"]}'
+
+            # 统一消息派发
+            handler_map = {
+                'text': lambda msg: self.bot.send_text_message(
+                    to_wxid=target_id,
+                    message=msg['content'],
+                    ats=at_targets
+                ),
+                'image': lambda msg: self.bot.send_image_message(
+                    to_wxid=target_id,
+                    img_url=msg["image"],
+                    ats = at_targets
+                ),
+                'WeChatEmoji': lambda msg: self.bot.send_emoji_message(
+                    to_wxid=target_id,
+                    emoji_md5=msg['emoji_md5'],
+                    emoji_size=msg['emoji_size']
+                ),
+
+                'voice': lambda msg: self.bot.send_voice_message(
+                    to_wxid=target_id,
+                    voice_data=msg['data'],
+                    voice_duration=msg["duration"],
+                    voice_forma=msg["forma"],
+                ),
+                'WeChatAppMsg': lambda msg: self.bot.send_app_message(
+                    to_wxid=target_id,
+                    app_message=msg['app_msg'],
+                    type=0,
+                ),
+                'at': lambda msg: None
+            }
+
+            if handler := handler_map.get(msg['type']):
+                handler(msg)
+                # self.ap.logger.warning(f"未处理的消息类型: {ret}")
+            else:
+                self.ap.logger.warning(f"未处理的消息类型: {msg['type']}")
+                continue
+
+    async def send_message(
+            self,
+            target_type: str,
+            target_id: str,
+            message: platform_message.MessageChain
+    ):
+        """主动发送消息"""
+        return await self._handle_message(message, target_id)
+
+    async def reply_message(
+            self,
+            message_source: platform_events.MessageEvent,
+            message: platform_message.MessageChain,
+            quote_origin: bool = False
+    ):
+        """回复消息"""
+        if message_source.source_platform_object:
+            target_id = message_source.source_platform_object['from_user_name']['str']
+            return await self._handle_message(message, target_id)
+
+    async def is_muted(self, group_id: int) -> bool:
+        pass
+
+    def register_listener(
+            self,
+            event_type: typing.Type[platform_events.Event],
+            callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None]
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+            self,
+            event_type: typing.Type[platform_events.Event],
+            callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None]
+    ):
+        pass
+
+    async def run_async(self):
+
+        if not self.config["admin_key"] and not self.config["token"]:
+            raise RuntimeError("无wechatpad管理密匙，请填入配置文件后重启")
+        else:
+            if self.config["token"]:
+                self.bot = WeChatPadClient(
+                    self.config['wechatpad_url'],
+                    self.config["token"]
+                )
+                data = self.bot.get_login_status()
+                self.ap.logger.info(data)
+                if data["Code"] == 300 and data["Text"] == "你已退出微信":
+                    response = requests.post(
+                        f"{self.config['wechatpad_url']}/admin/GenAuthKey1?key={self.config['admin_key']}",
+                        json={"Count": 1, "Days": 365}
+                    )
+                    if response.status_code != 200:
+                        raise Exception(f"获取token失败: {response.text}")
+                    self.config["token"] = response.json()["Data"][0]
+
+            elif not self.config["token"]:
+                response = requests.post(
+                    f"{self.config['wechatpad_url']}/admin/GenAuthKey1?key={self.config['admin_key']}",
+                    json={"Count": 1, "Days": 365}
+                )
+                if response.status_code != 200:
+                    raise Exception(f"获取token失败: {response.text}")
+                self.config["token"] = response.json()["Data"][0]
+
+        self.bot = WeChatPadClient(
+            self.config['wechatpad_url'],
+            self.config["token"]
+        )
+        self.ap.logger.info(self.config["token"])
+        thread_1 = threading.Event()
+
+
+        def wechat_login_process():
+            # 不登录，这些先注释掉，避免登陆态尝试拉qrcode。
+            # login_data =self.bot.get_login_qr()
+
+            # url = login_data['Data']["QrCodeUrl"]
+            # self.ap.logger.info(login_data)
+
+
+            profile =self.bot.get_profile()
+            self.ap.logger.info(profile)
+
+            self.bot_account_id = profile["Data"]["userInfo"]["nickName"]["str"]
+            self.config["wxid"] = profile["Data"]["userInfo"]["userName"]["str"]
+            thread_1.set()
+
+
+        # asyncio.create_task(wechat_login_process)
+        threading.Thread(target=wechat_login_process).start()
+
+        def connect_websocket_sync() -> None:
+
+            thread_1.wait()
+            uri = f"{self.config['wechatpad_ws']}/GetSyncMsg?key={self.config['token']}"
+            self.ap.logger.info(f"Connecting to WebSocket: {uri}")
+            def on_message(ws, message):
+                try:
+                    data = json.loads(message)
+                    self.ap.logger.debug(f"Received message: {data}")
+                    # 这里需要确保ws_message是同步的，或者使用asyncio.run调用异步方法
+                    asyncio.run(self.ws_message(data))
+                except json.JSONDecodeError:
+                    self.ap.logger.error(f"Non-JSON message: {message[:100]}...")
+
+            def on_error(ws, error):
+                self.ap.logger.error(f"WebSocket error: {str(error)[:200]}")
+
+            def on_close(ws, close_status_code, close_msg):
+                self.ap.logger.info("WebSocket closed, reconnecting...")
+                time.sleep(5)
+                connect_websocket_sync()  # 自动重连
+
+            def on_open(ws):
+                self.ap.logger.info("WebSocket connected successfully!")
+
+            ws = websocket.WebSocketApp(
+                uri,
+                on_message=on_message,
+                on_error=on_error,
+                on_close=on_close,
+                on_open=on_open
+            )
+            ws.run_forever(
+                ping_interval=60,
+                ping_timeout=20
+            )
+
+        # 直接调用同步版本（会阻塞）
+        # connect_websocket_sync()
+
+        # 这行代码会在WebSocket连接断开后才会执行
+        # self.ap.logger.info("WebSocket client thread started")
+        thread = threading.Thread(
+            target=connect_websocket_sync,
+            name="WebSocketClientThread",
+            daemon=True
+        )
+        thread.start()
+        self.ap.logger.info("WebSocket client thread started")
+
+    async def kill(self) -> bool:
+        pass

pkg/platform/sources/wechatpad.yaml

@@ -0,0 +1,51 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: wechatpad
+  label:
+    en_US: WeChatPad
+    zh_CN: WeChatPad（个人微信ipad）
+  description:
+    en_US: WeChatPad Adapter
+    zh_CN: WeChatPad 适配器
+spec:
+  config:
+    - name: wechatpad_url
+      label:
+        en_US: WeChatPad ERL
+        zh_CN: WeChatPad URL
+      type: string
+      required: true
+      default: ""
+    - name: wechatpad_ws
+      label:
+        en_US: WeChatPad_Ws
+        zh_CN: WeChatPad_Ws
+      type: string
+      required: true
+      default: ""
+    - name: admin_key
+      label:
+        en_US: Admin_Key
+        zh_CN: 管理员密匙
+      type: string
+      required: true
+      default: ""
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+    - name: wxid
+      label:
+        en_US: wxid
+        zh_CN: wxid
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./wechatpad.py
+    attr: WeChatPadAdapter

pkg/utils/importutil.py

@@ -32,7 +32,7 @@ def import_dir(path: str):
             rel_path = full_path.replace(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), '')
             rel_path = rel_path[1:]
             rel_path = rel_path.replace('/', '.')[:-3]
-            rel_path = rel_path.replace('\\', '.')
+            rel_path = rel_path.replace("\\",".")
             importlib.import_module(rel_path)