Files
Enterprise-Knowledge-Base/internal/im/dingtalk/adapter.go
T
wizardchen 01819b5bc2 fix(im): prevent DingTalk stream connection from going stale
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.
2026-06-22 15:04:23 +08:00

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)
}