01819b5bc2
DingTalk websocket (Stream) channels stopped delivering @-mentions after a day or two and only recovered when the IM channel was toggled off/on. The factory fired the SDK's Start once and relied entirely on the SDK's internal auto-reconnect, with no liveness supervision on WeKnora's side. On long-running connections the SDK can enter a zombie state where the connection object stays alive but no longer receives messages, leaving no way to recover automatically. The cancel func was also ineffective because the SDK ignores the context after the initial dial, so stopping a channel leaked the old connection. Add a reusable RunSupervised helper that keeps a long connection alive and proactively recycles it every 6h on top of the SDK's own reconnect, which bounds the worst-case outage and clears stuck connections. Wire DingTalk to it, add LongConnClient.Close (disables AutoReconnect before closing so the SDK does not resurrect the connection), and make the cancel func actually tear the connection down. Drop the now-unused stream client reference from the adapter, which only sends replies via sessionWebhook or OpenAPI.
599 lines
16 KiB
Go
599 lines
16 KiB
Go
package dingtalk
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/hmac"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/Tencent/WeKnora/internal/im"
|
|
"github.com/Tencent/WeKnora/internal/logger"
|
|
)
|
|
|
|
// httpClient is a shared HTTP client with a reasonable timeout for DingTalk API calls.
|
|
var httpClient = &http.Client{Timeout: 15 * time.Second}
|
|
|
|
// minCardUpdateInterval is the minimum time between consecutive card streaming updates.
|
|
const minCardUpdateInterval = 500 * time.Millisecond
|
|
|
|
// dingtalkConvTypeGroup is the DingTalk conversation type value for group chats.
|
|
const dingtalkConvTypeGroup = "2"
|
|
|
|
// Compile-time checks.
|
|
var (
|
|
_ im.Adapter = (*Adapter)(nil)
|
|
_ im.StreamSender = (*Adapter)(nil)
|
|
)
|
|
|
|
// Adapter implements im.Adapter for DingTalk.
|
|
type Adapter struct {
|
|
clientID string
|
|
clientSecret string
|
|
cardTemplateID string // optional: enables AI card streaming when set
|
|
|
|
// accessToken cache
|
|
tokenMu sync.RWMutex
|
|
token string
|
|
tokenExpAt time.Time
|
|
}
|
|
|
|
// NewWebhookAdapter creates a DingTalk adapter for HTTP callback mode.
|
|
func NewWebhookAdapter(clientID, clientSecret, cardTemplateID string) *Adapter {
|
|
startStreamReaper()
|
|
return &Adapter{
|
|
clientID: clientID,
|
|
clientSecret: clientSecret,
|
|
cardTemplateID: cardTemplateID,
|
|
}
|
|
}
|
|
|
|
// NewAdapter creates a DingTalk adapter for stream (websocket) mode.
|
|
// The stream connection itself is managed separately by the supervisor; the
|
|
// adapter only sends replies (via sessionWebhook or OpenAPI).
|
|
func NewAdapter(clientID, clientSecret, cardTemplateID string) *Adapter {
|
|
startStreamReaper()
|
|
return &Adapter{
|
|
clientID: clientID,
|
|
clientSecret: clientSecret,
|
|
cardTemplateID: cardTemplateID,
|
|
}
|
|
}
|
|
|
|
func (a *Adapter) Platform() im.Platform {
|
|
return im.PlatformDingtalk
|
|
}
|
|
|
|
func (a *Adapter) HandleURLVerification(c *gin.Context) bool {
|
|
return false
|
|
}
|
|
|
|
// VerifyCallback verifies the DingTalk webhook signature (HmacSHA256).
|
|
func (a *Adapter) VerifyCallback(c *gin.Context) error {
|
|
if a.clientSecret == "" {
|
|
return nil
|
|
}
|
|
|
|
timestamp := c.GetHeader("Timestamp")
|
|
sign := c.GetHeader("Sign")
|
|
if timestamp == "" || sign == "" {
|
|
return fmt.Errorf("missing timestamp or sign header")
|
|
}
|
|
|
|
ts, err := strconv.ParseInt(timestamp, 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid timestamp: %w", err)
|
|
}
|
|
diff := time.Now().UnixMilli() - ts
|
|
if diff > 3600*1000 || diff < -3600*1000 {
|
|
return fmt.Errorf("timestamp expired")
|
|
}
|
|
|
|
stringToSign := timestamp + "\n" + a.clientSecret
|
|
h := hmac.New(sha256.New, []byte(a.clientSecret))
|
|
h.Write([]byte(stringToSign))
|
|
expectedSign := base64.StdEncoding.EncodeToString(h.Sum(nil))
|
|
|
|
if !hmac.Equal([]byte(sign), []byte(expectedSign)) {
|
|
return fmt.Errorf("invalid signature")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DingTalk callback message structure.
|
|
type callbackMessage struct {
|
|
ConversationID string `json:"conversationId"`
|
|
ConversationType string `json:"conversationType"`
|
|
MsgID string `json:"msgId"`
|
|
Msgtype string `json:"msgtype"`
|
|
Text *textContent `json:"text"`
|
|
SenderNick string `json:"senderNick"`
|
|
SenderStaffId string `json:"senderStaffId"`
|
|
SenderID string `json:"senderId"`
|
|
SessionWebhook string `json:"sessionWebhook"`
|
|
RobotCode string `json:"robotCode"`
|
|
AtUsers []atUser `json:"atUsers"`
|
|
IsInAtList bool `json:"isInAtList"`
|
|
ChatbotCorpId string `json:"chatbotCorpId"`
|
|
}
|
|
|
|
type textContent struct {
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
type atUser struct {
|
|
DingtalkID string `json:"dingtalkId"`
|
|
StaffID string `json:"staffId"`
|
|
}
|
|
|
|
func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
|
|
bodyBytes, err := io.ReadAll(c.Request.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read body: %w", err)
|
|
}
|
|
c.Request.Body = io.NopCloser(bytes.NewReader(bodyBytes))
|
|
|
|
var msg callbackMessage
|
|
if err := json.Unmarshal(bodyBytes, &msg); err != nil {
|
|
return nil, fmt.Errorf("parse callback: %w", err)
|
|
}
|
|
|
|
return parseCallbackMessage(&msg), nil
|
|
}
|
|
|
|
func parseCallbackMessage(msg *callbackMessage) *im.IncomingMessage {
|
|
chatType := im.ChatTypeDirect
|
|
chatID := ""
|
|
if msg.ConversationType == dingtalkConvTypeGroup {
|
|
chatType = im.ChatTypeGroup
|
|
chatID = msg.ConversationID
|
|
}
|
|
|
|
userID := msg.SenderStaffId
|
|
if userID == "" {
|
|
userID = msg.SenderID
|
|
}
|
|
|
|
content := ""
|
|
if msg.Text != nil {
|
|
content = strings.TrimSpace(msg.Text.Content)
|
|
}
|
|
|
|
return &im.IncomingMessage{
|
|
Platform: im.PlatformDingtalk,
|
|
UserID: userID,
|
|
UserName: msg.SenderNick,
|
|
ChatID: chatID,
|
|
ChatType: chatType,
|
|
MessageID: msg.MsgID,
|
|
MessageType: im.MessageTypeText,
|
|
Content: content,
|
|
Extra: map[string]string{
|
|
"session_webhook": msg.SessionWebhook,
|
|
},
|
|
}
|
|
}
|
|
|
|
// ── Send reply ──
|
|
|
|
func (a *Adapter) SendReply(ctx context.Context, incoming *im.IncomingMessage, reply *im.ReplyMessage) error {
|
|
content := transformThinkBlocks(reply.Content)
|
|
|
|
sessionWebhook := ""
|
|
if incoming.Extra != nil {
|
|
sessionWebhook = incoming.Extra["session_webhook"]
|
|
}
|
|
|
|
if sessionWebhook != "" {
|
|
return a.replyViaSessionWebhook(ctx, sessionWebhook, content)
|
|
}
|
|
return a.replyViaOpenAPI(ctx, incoming, content)
|
|
}
|
|
|
|
func (a *Adapter) replyViaSessionWebhook(ctx context.Context, webhookURL, content string) error {
|
|
body := map[string]interface{}{
|
|
"msgtype": "markdown",
|
|
"markdown": map[string]string{
|
|
"title": "Reply",
|
|
"text": content,
|
|
},
|
|
}
|
|
|
|
jsonBody, err := json.Marshal(body)
|
|
if err != nil {
|
|
return fmt.Errorf("marshal reply: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, webhookURL, bytes.NewReader(jsonBody))
|
|
if err != nil {
|
|
return fmt.Errorf("create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("send reply: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
respBody, _ := io.ReadAll(resp.Body)
|
|
return fmt.Errorf("dingtalk sessionWebhook returned %d: %s", resp.StatusCode, string(respBody))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (a *Adapter) replyViaOpenAPI(ctx context.Context, incoming *im.IncomingMessage, content string) error {
|
|
token, err := a.getAccessToken(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("get access token: %w", err)
|
|
}
|
|
|
|
msgParam, err := json.Marshal(map[string]string{"title": "Reply", "text": content})
|
|
if err != nil {
|
|
return fmt.Errorf("marshal msgParam: %w", err)
|
|
}
|
|
|
|
var apiURL string
|
|
body := map[string]interface{}{
|
|
"robotCode": a.clientID,
|
|
"msgKey": "sampleMarkdown",
|
|
"msgParam": string(msgParam),
|
|
}
|
|
|
|
if incoming.ChatType == im.ChatTypeGroup {
|
|
apiURL = "https://api.dingtalk.com/v1.0/robot/groupMessages/send"
|
|
body["openConversationId"] = incoming.ChatID
|
|
} else {
|
|
apiURL = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend"
|
|
body["userIds"] = []string{incoming.UserID}
|
|
}
|
|
|
|
jsonBody, err := json.Marshal(body)
|
|
if err != nil {
|
|
return fmt.Errorf("marshal body: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(jsonBody))
|
|
if err != nil {
|
|
return fmt.Errorf("create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("x-acs-dingtalk-access-token", token)
|
|
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("send reply: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
respBody, _ := io.ReadAll(resp.Body)
|
|
return fmt.Errorf("dingtalk OpenAPI returned %d: %s", resp.StatusCode, string(respBody))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// getAccessToken returns a cached or fresh DingTalk access token.
|
|
func (a *Adapter) getAccessToken(ctx context.Context) (string, error) {
|
|
a.tokenMu.RLock()
|
|
if a.token != "" && time.Now().Before(a.tokenExpAt) {
|
|
token := a.token
|
|
a.tokenMu.RUnlock()
|
|
return token, nil
|
|
}
|
|
a.tokenMu.RUnlock()
|
|
|
|
a.tokenMu.Lock()
|
|
defer a.tokenMu.Unlock()
|
|
|
|
if a.token != "" && time.Now().Before(a.tokenExpAt) {
|
|
return a.token, nil
|
|
}
|
|
|
|
body := map[string]string{
|
|
"appKey": a.clientID,
|
|
"appSecret": a.clientSecret,
|
|
}
|
|
jsonBody, _ := json.Marshal(body)
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
|
|
"https://api.dingtalk.com/v1.0/oauth2/accessToken",
|
|
bytes.NewReader(jsonBody))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
respBody, _ := io.ReadAll(resp.Body)
|
|
return "", fmt.Errorf("dingtalk accessToken returned %d: %s", resp.StatusCode, string(respBody))
|
|
}
|
|
|
|
var result struct {
|
|
AccessToken string `json:"accessToken"`
|
|
ExpireIn int64 `json:"expireIn"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return "", fmt.Errorf("decode token response: %w", err)
|
|
}
|
|
if result.AccessToken == "" {
|
|
return "", fmt.Errorf("empty access token from dingtalk")
|
|
}
|
|
|
|
a.token = result.AccessToken
|
|
a.tokenExpAt = time.Now().Add(time.Duration(result.ExpireIn)*time.Second - 5*time.Minute)
|
|
|
|
return a.token, nil
|
|
}
|
|
|
|
// ── DingTalk OpenAPI helpers for AI Card ──
|
|
|
|
func (a *Adapter) dingtalkAPI(ctx context.Context, method, path string, body interface{}) (json.RawMessage, error) {
|
|
token, err := a.getAccessToken(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("get access token: %w", err)
|
|
}
|
|
|
|
jsonBody, err := json.Marshal(body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshal body: %w", err)
|
|
}
|
|
|
|
url := "https://api.dingtalk.com" + path
|
|
req, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(jsonBody))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("x-acs-dingtalk-access-token", token)
|
|
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("do request: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
respBody, _ := io.ReadAll(resp.Body)
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("dingtalk API %s returned %d: %s", path, resp.StatusCode, string(respBody))
|
|
}
|
|
return respBody, nil
|
|
}
|
|
|
|
// createAndDeliverCard creates an AI card and delivers it to the conversation.
|
|
func (a *Adapter) createAndDeliverCard(ctx context.Context, incoming *im.IncomingMessage) (string, error) {
|
|
outTrackID := uuid.New().String()
|
|
|
|
body := map[string]interface{}{
|
|
"cardTemplateId": a.cardTemplateID,
|
|
"outTrackId": outTrackID,
|
|
"callbackType": "STREAM",
|
|
"cardData": map[string]interface{}{
|
|
"cardParamMap": map[string]string{
|
|
"content": "",
|
|
},
|
|
},
|
|
"userIdType": 1,
|
|
}
|
|
|
|
if incoming.ChatType == im.ChatTypeGroup {
|
|
// Group chat
|
|
convID := incoming.ChatID
|
|
body["openSpaceId"] = "dtv1.card//IM_GROUP." + convID
|
|
body["imGroupOpenSpaceModel"] = map[string]interface{}{"supportForward": true}
|
|
body["imGroupOpenDeliverModel"] = map[string]interface{}{
|
|
"robotCode": a.clientID,
|
|
"extension": map[string]string{},
|
|
}
|
|
} else {
|
|
// Single chat (1:1 DM)
|
|
body["openSpaceId"] = "dtv1.card//IM_ROBOT." + incoming.UserID
|
|
body["imRobotOpenSpaceModel"] = map[string]interface{}{"supportForward": true}
|
|
body["imRobotOpenDeliverModel"] = map[string]interface{}{
|
|
"robotCode": a.clientID,
|
|
"spaceType": "IM_ROBOT",
|
|
"extension": map[string]string{},
|
|
}
|
|
}
|
|
|
|
_, err := a.dingtalkAPI(ctx, http.MethodPost, "/v1.0/card/instances/createAndDeliver", body)
|
|
if err != nil {
|
|
return "", fmt.Errorf("create card: %w", err)
|
|
}
|
|
|
|
return outTrackID, nil
|
|
}
|
|
|
|
// streamingUpdateCard pushes content to an existing AI card.
|
|
func (a *Adapter) streamingUpdateCard(ctx context.Context, outTrackID, content string, isFinalize bool) error {
|
|
body := map[string]interface{}{
|
|
"outTrackId": outTrackID,
|
|
"guid": uuid.New().String(),
|
|
"key": "content",
|
|
"content": content,
|
|
"isFull": true,
|
|
"isFinalize": isFinalize,
|
|
"isError": false,
|
|
}
|
|
|
|
_, err := a.dingtalkAPI(ctx, http.MethodPut, "/v1.0/card/streaming", body)
|
|
return err
|
|
}
|
|
|
|
// ── StreamSender implementation ──
|
|
|
|
type streamState struct {
|
|
mu sync.Mutex
|
|
content strings.Builder
|
|
sessionWebhook string
|
|
outTrackID string // non-empty when using AI card streaming
|
|
lastUpdate time.Time // for card update throttling
|
|
createdAt time.Time // for orphan stream detection
|
|
}
|
|
|
|
const (
|
|
streamOrphanTTL = 5 * time.Minute
|
|
streamReaperInterval = 1 * time.Minute
|
|
)
|
|
|
|
var (
|
|
streamsMu sync.Mutex
|
|
dStreams = map[string]*streamState{}
|
|
startReaperOnce sync.Once
|
|
reaperStopCh = make(chan struct{})
|
|
)
|
|
|
|
// startStreamReaper starts a background goroutine (once) that periodically
|
|
// removes orphaned stream entries. This prevents memory leaks when EndStream
|
|
// is never called due to panics or pipeline errors.
|
|
func startStreamReaper() {
|
|
startReaperOnce.Do(func() {
|
|
go func() {
|
|
ticker := time.NewTicker(streamReaperInterval)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ticker.C:
|
|
cutoff := time.Now().Add(-streamOrphanTTL)
|
|
streamsMu.Lock()
|
|
for id, state := range dStreams {
|
|
if state.createdAt.Before(cutoff) {
|
|
delete(dStreams, id)
|
|
}
|
|
}
|
|
streamsMu.Unlock()
|
|
case <-reaperStopCh:
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
})
|
|
}
|
|
|
|
func (a *Adapter) StartStream(ctx context.Context, incoming *im.IncomingMessage) (string, error) {
|
|
sessionWebhook := ""
|
|
if incoming.Extra != nil {
|
|
sessionWebhook = incoming.Extra["session_webhook"]
|
|
}
|
|
|
|
streamID := fmt.Sprintf("dt:%s:%s", incoming.UserID, incoming.MessageID)
|
|
|
|
state := &streamState{
|
|
sessionWebhook: sessionWebhook,
|
|
createdAt: time.Now(),
|
|
}
|
|
|
|
// If card template is configured, create an AI card for streaming
|
|
if a.cardTemplateID != "" {
|
|
outTrackID, err := a.createAndDeliverCard(ctx, incoming)
|
|
if err != nil {
|
|
logger.Warnf(ctx, "[DingTalk] Failed to create AI card, falling back to sessionWebhook: %v", err)
|
|
} else {
|
|
state.outTrackID = outTrackID
|
|
}
|
|
}
|
|
|
|
streamsMu.Lock()
|
|
dStreams[streamID] = state
|
|
streamsMu.Unlock()
|
|
|
|
logger.Infof(ctx, "[DingTalk] Streaming started: stream_id=%s, card=%v", streamID, state.outTrackID != "")
|
|
return streamID, nil
|
|
}
|
|
|
|
func (a *Adapter) SendStreamChunk(ctx context.Context, incoming *im.IncomingMessage, streamID string, content string) error {
|
|
if content == "" {
|
|
return nil
|
|
}
|
|
|
|
streamsMu.Lock()
|
|
state, ok := dStreams[streamID]
|
|
streamsMu.Unlock()
|
|
if !ok {
|
|
return fmt.Errorf("unknown stream ID: %s", streamID)
|
|
}
|
|
|
|
state.mu.Lock()
|
|
state.content.WriteString(content)
|
|
|
|
// No card template → just accumulate, send at EndStream
|
|
if state.outTrackID == "" {
|
|
state.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
// Throttle card updates
|
|
if time.Since(state.lastUpdate) < minCardUpdateInterval {
|
|
state.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
fullContent := transformThinkBlocks(state.content.String())
|
|
state.lastUpdate = time.Now()
|
|
outTrackID := state.outTrackID
|
|
state.mu.Unlock()
|
|
|
|
if err := a.streamingUpdateCard(ctx, outTrackID, fullContent, false); err != nil {
|
|
logger.Warnf(ctx, "[DingTalk] Failed to update card stream: %v", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *Adapter) EndStream(ctx context.Context, incoming *im.IncomingMessage, streamID string) error {
|
|
streamsMu.Lock()
|
|
state, ok := dStreams[streamID]
|
|
delete(dStreams, streamID)
|
|
streamsMu.Unlock()
|
|
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
state.mu.Lock()
|
|
fullContent := transformThinkBlocks(state.content.String())
|
|
outTrackID := state.outTrackID
|
|
state.mu.Unlock()
|
|
|
|
if outTrackID != "" {
|
|
// Finalize AI card
|
|
if err := a.streamingUpdateCard(ctx, outTrackID, fullContent, true); err != nil {
|
|
logger.Warnf(ctx, "[DingTalk] Failed to finalize card stream: %v", err)
|
|
}
|
|
} else if state.sessionWebhook != "" {
|
|
if err := a.replyViaSessionWebhook(ctx, state.sessionWebhook, fullContent); err != nil {
|
|
logger.Warnf(ctx, "[DingTalk] Failed to end stream: %v", err)
|
|
}
|
|
} else {
|
|
if err := a.replyViaOpenAPI(ctx, incoming, fullContent); err != nil {
|
|
logger.Warnf(ctx, "[DingTalk] Failed to end stream via OpenAPI: %v", err)
|
|
}
|
|
}
|
|
|
|
logger.Infof(ctx, "[DingTalk] Streaming ended: stream_id=%s", streamID)
|
|
return nil
|
|
}
|
|
|
|
func transformThinkBlocks(content string) string {
|
|
return im.TransformThinkBlocks(content, im.MarkdownThinkStyle)
|
|
}
|