feat: add skills and upgrade feishu/dingtalk channel

channel/dingtalk/dingtalk_channel.py

@@ -9,6 +9,7 @@ import json
 # -*- coding=utf-8 -*-
 import logging
 import time
+import requests
 
 import dingtalk_stream
 from dingtalk_stream import AckMessage
@@ -107,16 +108,156 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
         conf()["group_name_white_list"] = ["ALL_GROUP"]
         # 单聊无需前缀
         conf()["single_chat_prefix"] = [""]
+        # Access token cache
+        self._access_token = None
+        self._access_token_expires_at = 0
+        # Robot code cache (extracted from incoming messages)
+        self._robot_code = None
 
     def startup(self):
         credential = dingtalk_stream.Credential(self.dingtalk_client_id, self.dingtalk_client_secret)
         client = dingtalk_stream.DingTalkStreamClient(credential)
         client.register_callback_handler(dingtalk_stream.chatbot.ChatbotMessage.TOPIC, self)
         client.start_forever()
+    
+    def get_access_token(self):
+        """
+        获取企业内部应用的 access_token
+        文档: https://open.dingtalk.com/document/orgapp/obtain-orgapp-token
+        """
+        current_time = time.time()
+        
+        # 如果 token 还没过期，直接返回缓存的 token
+        if self._access_token and current_time < self._access_token_expires_at:
+            return self._access_token
+        
+        # 获取新的 access_token
+        url = "https://api.dingtalk.com/v1.0/oauth2/accessToken"
+        headers = {"Content-Type": "application/json"}
+        data = {
+            "appKey": self.dingtalk_client_id,
+            "appSecret": self.dingtalk_client_secret
+        }
+        
+        try:
+            response = requests.post(url, headers=headers, json=data, timeout=10)
+            result = response.json()
+            
+            if response.status_code == 200 and "accessToken" in result:
+                self._access_token = result["accessToken"]
+                # Token 有效期为 2 小时，提前 5 分钟刷新
+                self._access_token_expires_at = current_time + result.get("expireIn", 7200) - 300
+                logger.info("[DingTalk] Access token refreshed successfully")
+                return self._access_token
+            else:
+                logger.error(f"[DingTalk] Failed to get access token: {result}")
+                return None
+        except Exception as e:
+            logger.error(f"[DingTalk] Error getting access token: {e}")
+            return None
+    
+    def send_single_message(self, user_id: str, content: str, robot_code: str) -> bool:
+        """
+        Send message to single user (private chat)
+        API: https://open.dingtalk.com/document/orgapp/chatbots-send-one-on-one-chat-messages-in-batches
+        """
+        access_token = self.get_access_token()
+        if not access_token:
+            logger.error("[DingTalk] Failed to send single message: Access token not available.")
+            return False
+
+        if not robot_code:
+            logger.error("[DingTalk] Cannot send single message: robot_code is required")
+            return False
+
+        url = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend"
+        headers = {
+            "x-acs-dingtalk-access-token": access_token,
+            "Content-Type": "application/json"
+        }
+        data = {
+            "msgParam": json.dumps({"content": content}),
+            "msgKey": "sampleText",
+            "userIds": [user_id],
+            "robotCode": robot_code
+        }
+
+        logger.info(f"[DingTalk] Sending single message to user {user_id} with robot_code {robot_code}")
+        try:
+            response = requests.post(url, headers=headers, json=data, timeout=10)
+            result = response.json()
+            
+            if response.status_code == 200 and result.get("processQueryKey"):
+                logger.info(f"[DingTalk] Single message sent successfully to {user_id}")
+                return True
+            else:
+                logger.error(f"[DingTalk] Failed to send single message: {result}")
+                return False
+        except Exception as e:
+            logger.error(f"[DingTalk] Error sending single message: {e}")
+            return False
+    
+    def send_group_message(self, conversation_id: str, content: str, robot_code: str = None):
+        """
+        主动发送群消息
+        文档: https://open.dingtalk.com/document/orgapp/the-robot-sends-a-group-message
+        
+        Args:
+            conversation_id: 会话ID (openConversationId)
+            content: 消息内容
+            robot_code: 机器人编码，默认使用 dingtalk_client_id
+        """
+        access_token = self.get_access_token()
+        if not access_token:
+            logger.error("[DingTalk] Cannot send group message: no access token")
+            return False
+        
+        # Validate robot_code
+        if not robot_code:
+            logger.error("[DingTalk] Cannot send group message: robot_code is required")
+            return False
+        
+        url = "https://api.dingtalk.com/v1.0/robot/groupMessages/send"
+        headers = {
+            "x-acs-dingtalk-access-token": access_token,
+            "Content-Type": "application/json"
+        }
+        data = {
+            "msgParam": json.dumps({"content": content}),
+            "msgKey": "sampleText",
+            "openConversationId": conversation_id,
+            "robotCode": robot_code
+        }
+        
+        try:
+            response = requests.post(url, headers=headers, json=data, timeout=10)
+            result = response.json()
+            
+            if response.status_code == 200:
+                logger.info(f"[DingTalk] Group message sent successfully to {conversation_id}")
+                return True
+            else:
+                logger.error(f"[DingTalk] Failed to send group message: {result}")
+                return False
+        except Exception as e:
+            logger.error(f"[DingTalk] Error sending group message: {e}")
+            return False
 
     async def process(self, callback: dingtalk_stream.CallbackMessage):
         try:
             incoming_message = dingtalk_stream.ChatbotMessage.from_dict(callback.data)
+            
+            # Debug: 打印完整的 event 数据
+            logger.info(f"[DingTalk] ===== Incoming Message Debug =====")
+            logger.info(f"[DingTalk] callback.data keys: {callback.data.keys() if hasattr(callback.data, 'keys') else 'N/A'}")
+            logger.info(f"[DingTalk] incoming_message attributes: {dir(incoming_message)}")
+            logger.info(f"[DingTalk] robot_code: {getattr(incoming_message, 'robot_code', 'N/A')}")
+            logger.info(f"[DingTalk] chatbot_corp_id: {getattr(incoming_message, 'chatbot_corp_id', 'N/A')}")
+            logger.info(f"[DingTalk] chatbot_user_id: {getattr(incoming_message, 'chatbot_user_id', 'N/A')}")
+            logger.info(f"[DingTalk] conversation_id: {getattr(incoming_message, 'conversation_id', 'N/A')}")
+            logger.info(f"[DingTalk] Raw callback.data: {callback.data}")
+            logger.info(f"[DingTalk] =====================================")
+            
             image_download_handler = self  # 传入方法所在的类实例
             dingtalk_msg = DingTalkMessage(incoming_message, image_download_handler)
 
@@ -174,8 +315,48 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
 
     def send(self, reply: Reply, context: Context):
         receiver = context["receiver"]
-        isgroup = context.kwargs['msg'].is_group
-        incoming_message = context.kwargs['msg'].incoming_message
+        
+        # Check if msg exists (for scheduled tasks, msg might be None)
+        msg = context.kwargs.get('msg')
+        if msg is None:
+            # 定时任务场景：使用主动发送 API
+            is_group = context.get("isgroup", False)
+            logger.info(f"[DingTalk] Sending scheduled task message to {receiver} (is_group={is_group})")
+            
+            # 使用缓存的 robot_code 或配置的值
+            robot_code = self._robot_code or conf().get("dingtalk_robot_code")
+            logger.info(f"[DingTalk] Using robot_code: {robot_code}, cached: {self._robot_code}, config: {conf().get('dingtalk_robot_code')}")
+            
+            if not robot_code:
+                logger.error(f"[DingTalk] Cannot send scheduled task: robot_code not available. Please send at least one message to the bot first, or configure dingtalk_robot_code in config.json")
+                return
+            
+            # 根据是否群聊选择不同的 API
+            if is_group:
+                success = self.send_group_message(receiver, reply.content, robot_code)
+            else:
+                # 单聊场景：尝试从 context 中获取 dingtalk_sender_staff_id
+                sender_staff_id = context.get("dingtalk_sender_staff_id")
+                if not sender_staff_id:
+                    logger.error(f"[DingTalk] Cannot send single chat scheduled message: sender_staff_id not available in context")
+                    return
+                
+                logger.info(f"[DingTalk] Sending single message to staff_id: {sender_staff_id}")
+                success = self.send_single_message(sender_staff_id, reply.content, robot_code)
+            
+            if not success:
+                logger.error(f"[DingTalk] Failed to send scheduled task message")
+            return
+        
+        # 从正常消息中提取并缓存 robot_code
+        if hasattr(msg, 'robot_code'):
+            robot_code = msg.robot_code
+            if robot_code and robot_code != self._robot_code:
+                self._robot_code = robot_code
+                logger.info(f"[DingTalk] Cached robot_code: {robot_code}")
+        
+        isgroup = msg.is_group
+        incoming_message = msg.incoming_message
 
         if conf().get("dingtalk_card_enabled"):
             logger.info("[Dingtalk] sendMsg={}, receiver={}".format(reply, receiver))

channel/dingtalk/dingtalk_message.py

@@ -22,6 +22,7 @@ class DingTalkMessage(ChatMessage):
         self.create_time = event.create_at
         self.image_content = event.image_content
         self.rich_text_content = event.rich_text_content
+        self.robot_code = event.robot_code  # 机器人编码
         if event.conversation_type == "1":
             self.is_group = False
         else: