add

internal/collector/collector.go

@@ -0,0 +1,255 @@
+package collector
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/sky22333/qqbot/config"
+	"github.com/sky22333/qqbot/internal/qqapi"
+	"github.com/sky22333/qqbot/internal/targets"
+	"github.com/sky22333/qqbot/message"
+)
+
+const (
+	intentPublicGuildMessages = 1 << 30
+	intentDirectMessage       = 1 << 12
+	intentGroupAndC2C         = 1 << 25
+	intentGuildMembers        = 1 << 1
+)
+
+var intentLevels = []int{
+	intentPublicGuildMessages | intentDirectMessage | intentGroupAndC2C,
+	intentPublicGuildMessages | intentGroupAndC2C,
+	intentPublicGuildMessages | intentGuildMembers,
+}
+
+type wsPayload struct {
+	Op int             `json:"op"`
+	D  json.RawMessage `json:"d"`
+	S  *int64          `json:"s,omitempty"`
+	T  string          `json:"t,omitempty"`
+}
+
+type helloData struct {
+	HeartbeatInterval int64 `json:"heartbeat_interval"`
+}
+
+type c2cMessageEvent struct {
+	ID      string `json:"id"`
+	Content string `json:"content"`
+	Author  struct {
+		UserOpenID string `json:"user_openid"`
+	} `json:"author"`
+}
+
+type groupMessageEvent struct {
+	ID          string `json:"id"`
+	Content     string `json:"content"`
+	GroupOpenID string `json:"group_openid"`
+}
+
+type Collector struct {
+	cfg    config.Config
+	logger *slog.Logger
+	client *qqapi.Client
+	store  *targets.Store
+
+	ctx    context.Context
+	cancel context.CancelFunc
+	wg     sync.WaitGroup
+}
+
+func New(cfg config.Config, logger *slog.Logger, store *targets.Store) (*Collector, error) {
+	client, err := qqapi.NewClient(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if logger == nil {
+		logger = slog.Default()
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	return &Collector{
+		cfg:    cfg,
+		logger: logger,
+		client: client,
+		store:  store,
+		ctx:    ctx,
+		cancel: cancel,
+	}, nil
+}
+
+func (c *Collector) Start() {
+	c.wg.Add(1)
+	go func() {
+		defer c.wg.Done()
+		c.runLoop()
+	}()
+}
+
+func (c *Collector) Stop() {
+	c.cancel()
+	c.wg.Wait()
+}
+
+func (c *Collector) runLoop() {
+	reconnectDelay, _ := c.cfg.CollectorReconnectDelay()
+	if reconnectDelay <= 0 {
+		reconnectDelay = 3 * time.Second
+	}
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		default:
+		}
+		if err := c.runOnce(); err != nil {
+			if c.ctx.Err() != nil {
+				return
+			}
+			c.logger.Error("collector 连接中断", "error", err)
+		}
+		timer := time.NewTimer(reconnectDelay)
+		select {
+		case <-c.ctx.Done():
+			timer.Stop()
+			return
+		case <-timer.C:
+		}
+	}
+}
+
+func (c *Collector) runOnce() error {
+	token, err := c.client.AccessToken(c.ctx)
+	if err != nil {
+		return err
+	}
+	gatewayURL, err := c.client.GatewayURL(c.ctx)
+	if err != nil {
+		return err
+	}
+	conn, _, err := websocket.DefaultDialer.DialContext(c.ctx, gatewayURL, nil)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+	stopClose := make(chan struct{})
+	go func() {
+		select {
+		case <-c.ctx.Done():
+			_ = conn.Close()
+		case <-stopClose:
+		}
+	}()
+	defer close(stopClose)
+	c.logger.Info("collector 已连接 gateway")
+
+	var lastSeq atomic.Int64
+	intentIndex := 0
+	heartbeatStop := make(chan struct{})
+	defer close(heartbeatStop)
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return nil
+		default:
+		}
+
+		_, data, err := conn.ReadMessage()
+		if err != nil {
+			return err
+		}
+		payload := wsPayload{}
+		if err := json.Unmarshal(data, &payload); err != nil {
+			continue
+		}
+		if payload.S != nil {
+			lastSeq.Store(*payload.S)
+		}
+
+		switch payload.Op {
+		case 10:
+			hello := helloData{}
+			if err := json.Unmarshal(payload.D, &hello); err == nil && hello.HeartbeatInterval > 0 {
+				go startHeartbeat(c.ctx, conn, hello.HeartbeatInterval, &lastSeq, heartbeatStop)
+			}
+			if err := sendIdentify(conn, token, intentLevels[intentIndex]); err != nil {
+				return err
+			}
+		case 9:
+			if intentIndex < len(intentLevels)-1 {
+				intentIndex++
+			}
+			if err := sendIdentify(conn, token, intentLevels[intentIndex]); err != nil {
+				return err
+			}
+		case 0:
+			c.handleDispatch(payload.T, payload.D)
+		case 7:
+			return errors.New("gateway 要求重连")
+		}
+	}
+}
+
+func (c *Collector) handleDispatch(eventType string, raw json.RawMessage) {
+	switch strings.TrimSpace(eventType) {
+	case "C2C_MESSAGE_CREATE":
+		event := c2cMessageEvent{}
+		if err := json.Unmarshal(raw, &event); err != nil {
+			return
+		}
+		if event.Author.UserOpenID == "" {
+			return
+		}
+		_ = c.store.Upsert(message.TargetC2C, event.Author.UserOpenID, event.ID, event.Content)
+		c.logger.Info("采集到 c2c 目标", "target_id", event.Author.UserOpenID, "message_id", event.ID)
+	case "GROUP_AT_MESSAGE_CREATE":
+		event := groupMessageEvent{}
+		if err := json.Unmarshal(raw, &event); err != nil {
+			return
+		}
+		if event.GroupOpenID == "" {
+			return
+		}
+		_ = c.store.Upsert(message.TargetGroup, event.GroupOpenID, event.ID, event.Content)
+		c.logger.Info("采集到 group 目标", "target_id", event.GroupOpenID, "message_id", event.ID)
+	}
+}
+
+func startHeartbeat(ctx context.Context, conn *websocket.Conn, intervalMS int64, seq *atomic.Int64, stop <-chan struct{}) {
+	ticker := time.NewTicker(time.Duration(intervalMS) * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-stop:
+			return
+		case <-ticker.C:
+			payload := map[string]any{
+				"op": 1,
+				"d":  seq.Load(),
+			}
+			_ = conn.WriteJSON(payload)
+		}
+	}
+}
+
+func sendIdentify(conn *websocket.Conn, token string, intents int) error {
+	payload := map[string]any{
+		"op": 2,
+		"d": map[string]any{
+			"token":   "QQBot " + token,
+			"intents": intents,
+			"shard":   []int{0, 1},
+		},
+	}
+	return conn.WriteJSON(payload)
+}

internal/httpserver/server.go

@@ -0,0 +1,215 @@
+package httpserver
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/sky22333/qqbot/config"
+	"github.com/sky22333/qqbot/internal/notifier"
+	"github.com/sky22333/qqbot/internal/targets"
+	"github.com/sky22333/qqbot/message"
+)
+
+type Server struct {
+	cfg      config.Config
+	logger   *slog.Logger
+	notifier *notifier.Notifier
+	targets  *targets.Store
+	srv      *http.Server
+}
+
+func New(cfg config.Config, logger *slog.Logger, n *notifier.Notifier, t *targets.Store) (*Server, error) {
+	if logger == nil {
+		logger = slog.Default()
+	}
+	readTimeout, err := cfg.ReadTimeout()
+	if err != nil {
+		return nil, err
+	}
+	writeTimeout, err := cfg.WriteTimeout()
+	if err != nil {
+		return nil, err
+	}
+	handler := &Server{
+		cfg:      cfg,
+		logger:   logger,
+		notifier: n,
+		targets:  t,
+	}
+	mux := http.NewServeMux()
+	mux.HandleFunc("/healthz", handler.healthz)
+	mux.HandleFunc("/readyz", handler.readyz)
+	mux.HandleFunc("/api/v1/messages/send", handler.sendSync)
+	mux.HandleFunc("/api/v1/messages", handler.enqueue)
+	mux.HandleFunc("/api/v1/messages/", handler.queryStatus)
+	mux.HandleFunc("/api/v1/targets", handler.listTargets)
+
+	handler.srv = &http.Server{
+		Addr:         cfg.Server.ListenAddr,
+		Handler:      mux,
+		ReadTimeout:  readTimeout,
+		WriteTimeout: writeTimeout,
+	}
+	return handler, nil
+}
+
+func (s *Server) Start() error {
+	s.logger.Info("HTTP 服务启动", "addr", s.cfg.Server.ListenAddr)
+	err := s.srv.ListenAndServe()
+	if errors.Is(err, http.ErrServerClosed) {
+		return nil
+	}
+	return err
+}
+
+func (s *Server) Shutdown(ctx context.Context) error {
+	return s.srv.Shutdown(ctx)
+}
+
+func (s *Server) healthz(w http.ResponseWriter, _ *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true, "time": time.Now()})
+}
+
+func (s *Server) readyz(w http.ResponseWriter, _ *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]any{"ready": true, "time": time.Now()})
+}
+
+func (s *Server) sendSync(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	if !s.authorized(r) {
+		writeError(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	req, err := s.decodePushRequest(w, r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	result, err := s.notifier.Send(r.Context(), req)
+	if err != nil {
+		writeError(w, http.StatusBadGateway, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"code":    0,
+		"message": "ok",
+		"data":    result,
+	})
+}
+
+func (s *Server) enqueue(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	if !s.authorized(r) {
+		writeError(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	req, err := s.decodePushRequest(w, r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	requestID, err := s.notifier.Enqueue(r.Context(), req)
+	if err != nil {
+		writeError(w, http.StatusServiceUnavailable, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusAccepted, map[string]any{
+		"code":    0,
+		"message": "accepted",
+		"data": map[string]any{
+			"request_id": requestID,
+		},
+	})
+}
+
+func (s *Server) queryStatus(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	if !s.authorized(r) {
+		writeError(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	requestID := strings.TrimPrefix(r.URL.Path, "/api/v1/messages/")
+	if requestID == "" {
+		writeError(w, http.StatusBadRequest, "request id 不能为空")
+		return
+	}
+	status, ok := s.notifier.GetStatus(requestID)
+	if !ok {
+		writeError(w, http.StatusNotFound, "not found")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"code":    0,
+		"message": "ok",
+		"data":    status,
+	})
+}
+
+func (s *Server) listTargets(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	if !s.authorized(r) {
+		writeError(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	targetType := strings.TrimSpace(r.URL.Query().Get("target_type"))
+	items := s.targets.List(200, targetType)
+	writeJSON(w, http.StatusOK, map[string]any{
+		"code":    0,
+		"message": "ok",
+		"data":    items,
+	})
+}
+
+func (s *Server) decodePushRequest(w http.ResponseWriter, r *http.Request) (message.PushRequest, error) {
+	defer r.Body.Close()
+	r.Body = http.MaxBytesReader(w, r.Body, s.cfg.Server.MaxBodyBytes)
+	decoder := json.NewDecoder(r.Body)
+	decoder.DisallowUnknownFields()
+	req := message.PushRequest{}
+	if err := decoder.Decode(&req); err != nil {
+		return message.PushRequest{}, err
+	}
+	return req, nil
+}
+
+func (s *Server) authorized(r *http.Request) bool {
+	if strings.TrimSpace(s.cfg.Server.APIToken) == "" {
+		return true
+	}
+	auth := r.Header.Get("Authorization")
+	if !strings.HasPrefix(auth, "Bearer ") {
+		return false
+	}
+	token := strings.TrimPrefix(auth, "Bearer ")
+	return token == s.cfg.Server.APIToken
+}
+
+func writeError(w http.ResponseWriter, status int, msg string) {
+	writeJSON(w, status, map[string]any{
+		"code":    status,
+		"message": msg,
+	})
+}
+
+func writeJSON(w http.ResponseWriter, status int, payload any) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(payload)
+}

internal/notifier/notifier.go

@@ -0,0 +1,326 @@
+package notifier
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"log/slog"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sky22333/qqbot/config"
+	"github.com/sky22333/qqbot/internal/qqapi"
+	"github.com/sky22333/qqbot/internal/targets"
+	"github.com/sky22333/qqbot/message"
+)
+
+type idempotentRecord struct {
+	result    message.PushResult
+	expiresAt time.Time
+}
+
+type statusRecord struct {
+	status    message.DeliveryStatus
+	expiresAt time.Time
+}
+
+type job struct {
+	req message.PushRequest
+}
+
+type Notifier struct {
+	cfg    config.Config
+	logger *slog.Logger
+	client *qqapi.Client
+
+	ctx    context.Context
+	cancel context.CancelFunc
+	wg     sync.WaitGroup
+
+	queue chan job
+
+	mu         sync.RWMutex
+	idempotent map[string]idempotentRecord
+	statuses   map[string]statusRecord
+	targets    *targets.Store
+}
+
+func New(cfg config.Config, logger *slog.Logger) (*Notifier, error) {
+	client, err := qqapi.NewClient(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if logger == nil {
+		logger = slog.Default()
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	n := &Notifier{
+		cfg:        cfg,
+		logger:     logger,
+		client:     client,
+		ctx:        ctx,
+		cancel:     cancel,
+		queue:      make(chan job, cfg.Dispatch.QueueSize),
+		idempotent: make(map[string]idempotentRecord),
+		statuses:   make(map[string]statusRecord),
+	}
+	n.startWorkers()
+	n.startCleanup()
+	return n, nil
+}
+
+func (n *Notifier) SetTargetStore(store *targets.Store) {
+	n.targets = store
+}
+
+func (n *Notifier) Close() {
+	n.cancel()
+	n.wg.Wait()
+}
+
+func (n *Notifier) Enqueue(ctx context.Context, req message.PushRequest) (string, error) {
+	req = n.fillTargetIfMissing(req)
+	if err := validateRequest(req); err != nil {
+		return "", err
+	}
+	if req.RequestID == "" {
+		req.RequestID = newRequestID()
+	}
+	n.setStatus(message.DeliveryStatus{
+		RequestID: req.RequestID,
+		State:     message.StateQueued,
+		UpdatedAt: time.Now(),
+	})
+
+	timeout, _ := n.cfg.EnqueueTimeout()
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	select {
+	case <-ctx.Done():
+		return "", ctx.Err()
+	case <-n.ctx.Done():
+		return "", errors.New("notifier 已关闭")
+	case <-timer.C:
+		n.setStatus(message.DeliveryStatus{
+			RequestID: req.RequestID,
+			State:     message.StateFailed,
+			Error:     "入队超时",
+			UpdatedAt: time.Now(),
+		})
+		return "", errors.New("入队超时")
+	case n.queue <- job{req: req}:
+		return req.RequestID, nil
+	}
+}
+
+func (n *Notifier) Send(ctx context.Context, req message.PushRequest) (message.PushResult, error) {
+	req = n.fillTargetIfMissing(req)
+	if err := validateRequest(req); err != nil {
+		return message.PushResult{}, err
+	}
+	if req.RequestID == "" {
+		req.RequestID = newRequestID()
+	}
+	if req.IdempotencyKey != "" {
+		if result, ok := n.getIdempotent(req.IdempotencyKey); ok {
+			n.setStatus(message.DeliveryStatus{
+				RequestID: req.RequestID,
+				State:     message.StateSuccess,
+				Result:    &result,
+				UpdatedAt: time.Now(),
+			})
+			return result, nil
+		}
+	}
+	n.setStatus(message.DeliveryStatus{
+		RequestID: req.RequestID,
+		State:     message.StateSending,
+		UpdatedAt: time.Now(),
+	})
+	result, err := n.sendWithRetry(ctx, req)
+	if err != nil {
+		n.setStatus(message.DeliveryStatus{
+			RequestID: req.RequestID,
+			State:     message.StateFailed,
+			Error:     err.Error(),
+			UpdatedAt: time.Now(),
+		})
+		return message.PushResult{}, err
+	}
+	if req.IdempotencyKey != "" {
+		n.setIdempotent(req.IdempotencyKey, result)
+	}
+	n.setStatus(message.DeliveryStatus{
+		RequestID: req.RequestID,
+		State:     message.StateSuccess,
+		Result:    &result,
+		UpdatedAt: time.Now(),
+	})
+	return result, nil
+}
+
+func (n *Notifier) fillTargetIfMissing(req message.PushRequest) message.PushRequest {
+	if strings.TrimSpace(req.TargetID) != "" || n.targets == nil {
+		return req
+	}
+	req.TargetType = message.TargetType(strings.TrimSpace(string(req.TargetType)))
+	if req.TargetType == "" {
+		item, ok := n.targets.LatestAny()
+		if !ok {
+			return req
+		}
+		req.TargetType = item.TargetType
+		req.TargetID = item.TargetID
+		return req
+	}
+	item, ok := n.targets.Latest(req.TargetType)
+	if !ok {
+		return req
+	}
+	req.TargetID = item.TargetID
+	return req
+}
+
+func (n *Notifier) GetStatus(requestID string) (message.DeliveryStatus, bool) {
+	n.mu.RLock()
+	defer n.mu.RUnlock()
+	record, ok := n.statuses[requestID]
+	if !ok || time.Now().After(record.expiresAt) {
+		return message.DeliveryStatus{}, false
+	}
+	return record.status, true
+}
+
+func (n *Notifier) startWorkers() {
+	for i := 0; i < n.cfg.Dispatch.Workers; i++ {
+		n.wg.Add(1)
+		go func(workerID int) {
+			defer n.wg.Done()
+			for {
+				select {
+				case <-n.ctx.Done():
+					return
+				case task := <-n.queue:
+					_, err := n.Send(n.ctx, task.req)
+					if err != nil {
+						n.logger.Error("消息发送失败", "worker", workerID, "request_id", task.req.RequestID, "error", err)
+					}
+				}
+			}
+		}(i + 1)
+	}
+}
+
+func (n *Notifier) startCleanup() {
+	interval := time.Duration(n.cfg.Runtime.CleanupIntervalSec) * time.Second
+	n.wg.Add(1)
+	go func() {
+		defer n.wg.Done()
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-n.ctx.Done():
+				return
+			case <-ticker.C:
+				now := time.Now()
+				n.mu.Lock()
+				for key, val := range n.idempotent {
+					if now.After(val.expiresAt) {
+						delete(n.idempotent, key)
+					}
+				}
+				for key, val := range n.statuses {
+					if now.After(val.expiresAt) {
+						delete(n.statuses, key)
+					}
+				}
+				n.mu.Unlock()
+			}
+		}
+	}()
+}
+
+func (n *Notifier) sendWithRetry(ctx context.Context, req message.PushRequest) (message.PushResult, error) {
+	backoff := time.Duration(n.cfg.Dispatch.RetryBackoffMS) * time.Millisecond
+	max := n.cfg.Dispatch.RetryMax
+	var lastErr error
+	for attempt := 0; attempt <= max; attempt++ {
+		result, err := n.client.Send(ctx, req)
+		if err == nil {
+			return result, nil
+		}
+		lastErr = err
+		var apiErr *qqapi.APIError
+		if errors.As(err, &apiErr) {
+			if !apiErr.Temporary() {
+				return message.PushResult{}, err
+			}
+		}
+		if attempt == max {
+			break
+		}
+		sleep := backoff * time.Duration(1<<attempt)
+		timer := time.NewTimer(sleep)
+		select {
+		case <-ctx.Done():
+			timer.Stop()
+			return message.PushResult{}, ctx.Err()
+		case <-timer.C:
+		}
+	}
+	return message.PushResult{}, fmt.Errorf("重试后仍失败: %w", lastErr)
+}
+
+func (n *Notifier) setIdempotent(key string, result message.PushResult) {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	n.idempotent[key] = idempotentRecord{
+		result:    result,
+		expiresAt: time.Now().Add(time.Duration(n.cfg.Runtime.IdempotencyTTLSeconds) * time.Second),
+	}
+}
+
+func (n *Notifier) getIdempotent(key string) (message.PushResult, bool) {
+	n.mu.RLock()
+	defer n.mu.RUnlock()
+	record, ok := n.idempotent[key]
+	if !ok || time.Now().After(record.expiresAt) {
+		return message.PushResult{}, false
+	}
+	return record.result, true
+}
+
+func (n *Notifier) setStatus(status message.DeliveryStatus) {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	n.statuses[status.RequestID] = statusRecord{
+		status:    status,
+		expiresAt: time.Now().Add(time.Duration(n.cfg.Runtime.StatusTTLSeconds) * time.Second),
+	}
+}
+
+func newRequestID() string {
+	buf := make([]byte, 16)
+	_, _ = rand.Read(buf)
+	return hex.EncodeToString(buf)
+}
+
+func validateRequest(req message.PushRequest) error {
+	if strings.TrimSpace(req.TargetID) == "" {
+		return errors.New("target_id 不能为空")
+	}
+	if strings.TrimSpace(req.Content) == "" {
+		return errors.New("content 不能为空")
+	}
+	if req.TargetType != message.TargetC2C &&
+		req.TargetType != message.TargetGroup &&
+		req.TargetType != message.TargetChannel {
+		return errors.New("target_type 只支持 c2c/group/channel")
+	}
+	return nil
+}

internal/qqapi/client.go

@@ -0,0 +1,321 @@
+package qqapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sky22333/qqbot/config"
+	"github.com/sky22333/qqbot/message"
+)
+
+type APIError struct {
+	StatusCode int    `json:"status_code"`
+	Code       int    `json:"code"`
+	Message    string `json:"message"`
+	TraceID    string `json:"trace_id"`
+}
+
+func (e *APIError) Error() string {
+	return fmt.Sprintf("qq api error status=%d code=%d message=%s trace=%s", e.StatusCode, e.Code, e.Message, e.TraceID)
+}
+
+func (e *APIError) Temporary() bool {
+	if e.StatusCode == http.StatusTooManyRequests {
+		return true
+	}
+	return e.StatusCode >= 500
+}
+
+type tokenResponse struct {
+	AccessToken string `json:"access_token"`
+	ExpiresIn   any    `json:"expires_in"`
+}
+
+type messageResp struct {
+	ID        string `json:"id"`
+	Timestamp string `json:"timestamp"`
+}
+
+type gatewayResp struct {
+	URL string `json:"url"`
+}
+
+type apiErrPayload struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+type Client struct {
+	cfg        config.Config
+	httpClient *http.Client
+
+	mu       sync.RWMutex
+	token    string
+	expires  time.Time
+	appID    string
+	secret   string
+	tokenURL string
+	baseURL  string
+}
+
+func NewClient(cfg config.Config) (*Client, error) {
+	timeout, err := cfg.RequestTimeout()
+	if err != nil {
+		return nil, err
+	}
+	transport := &http.Transport{
+		MaxIdleConns:        128,
+		MaxIdleConnsPerHost: 64,
+		IdleConnTimeout:     90 * time.Second,
+	}
+	return &Client{
+		cfg: cfg,
+		httpClient: &http.Client{
+			Timeout:   timeout,
+			Transport: transport,
+		},
+		appID:    cfg.QQBot.AppID,
+		secret:   cfg.QQBot.ClientSecret,
+		tokenURL: strings.TrimRight(cfg.QQBot.TokenURL, "/"),
+		baseURL:  strings.TrimRight(cfg.QQBot.APIBase, "/"),
+	}, nil
+}
+
+func (c *Client) Send(ctx context.Context, req message.PushRequest) (message.PushResult, error) {
+	token, err := c.getToken(ctx)
+	if err != nil {
+		return message.PushResult{}, err
+	}
+	res, err := c.sendWithToken(ctx, token, req)
+	if err != nil {
+		var apiErr *APIError
+		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusUnauthorized {
+			c.invalidateToken()
+			token, tokenErr := c.getToken(ctx)
+			if tokenErr != nil {
+				return message.PushResult{}, tokenErr
+			}
+			return c.sendWithToken(ctx, token, req)
+		}
+		return message.PushResult{}, err
+	}
+	return res, nil
+}
+
+func (c *Client) AccessToken(ctx context.Context) (string, error) {
+	return c.getToken(ctx)
+}
+
+func (c *Client) GatewayURL(ctx context.Context) (string, error) {
+	token, err := c.getToken(ctx)
+	if err != nil {
+		return "", err
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/gateway", nil)
+	if err != nil {
+		return "", err
+	}
+	httpReq.Header.Set("Authorization", "QQBot "+token)
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return "", fmt.Errorf("获取 gateway 失败: status=%d body=%s", resp.StatusCode, string(raw))
+	}
+	data := gatewayResp{}
+	if err := json.Unmarshal(raw, &data); err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(data.URL) == "" {
+		return "", errors.New("gateway url 为空")
+	}
+	return data.URL, nil
+}
+
+func (c *Client) sendWithToken(ctx context.Context, token string, req message.PushRequest) (message.PushResult, error) {
+	url, body, err := c.buildRequest(req)
+	if err != nil {
+		return message.PushResult{}, err
+	}
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return message.PushResult{}, err
+	}
+	httpReq.Header.Set("Authorization", "QQBot "+token)
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return message.PushResult{}, err
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return message.PushResult{}, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		apiErr := apiErrPayload{}
+		_ = json.Unmarshal(raw, &apiErr)
+		return message.PushResult{}, &APIError{
+			StatusCode: resp.StatusCode,
+			Code:       apiErr.Code,
+			Message:    apiErr.Message,
+			TraceID:    resp.Header.Get("x-tps-trace-id"),
+		}
+	}
+	out := messageResp{}
+	if err := json.Unmarshal(raw, &out); err != nil {
+		return message.PushResult{}, err
+	}
+	return message.PushResult{
+		RequestID: req.RequestID,
+		MessageID: out.ID,
+		Timestamp: parseTime(out.Timestamp),
+	}, nil
+}
+
+func (c *Client) buildRequest(req message.PushRequest) (string, []byte, error) {
+	if strings.TrimSpace(req.TargetID) == "" {
+		return "", nil, errors.New("target_id 不能为空")
+	}
+	if strings.TrimSpace(req.Content) == "" {
+		return "", nil, errors.New("content 不能为空")
+	}
+	payload := map[string]any{
+		"content":  req.Content,
+		"msg_type": 0,
+	}
+	if c.cfg.QQBot.Markdown {
+		payload = map[string]any{
+			"markdown": map[string]any{"content": req.Content},
+			"msg_type": 2,
+		}
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return "", nil, err
+	}
+	switch req.TargetType {
+	case message.TargetC2C:
+		return fmt.Sprintf("%s/v2/users/%s/messages", c.baseURL, req.TargetID), body, nil
+	case message.TargetGroup:
+		return fmt.Sprintf("%s/v2/groups/%s/messages", c.baseURL, req.TargetID), body, nil
+	case message.TargetChannel:
+		return fmt.Sprintf("%s/channels/%s/messages", c.baseURL, req.TargetID), body, nil
+	default:
+		return "", nil, fmt.Errorf("不支持的 target_type: %s", req.TargetType)
+	}
+}
+
+func (c *Client) getToken(ctx context.Context) (string, error) {
+	c.mu.RLock()
+	if c.token != "" && time.Until(c.expires) > 5*time.Minute {
+		token := c.token
+		c.mu.RUnlock()
+		return token, nil
+	}
+	c.mu.RUnlock()
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.token != "" && time.Until(c.expires) > 5*time.Minute {
+		return c.token, nil
+	}
+
+	reqBody, _ := json.Marshal(map[string]string{
+		"appId":        c.appID,
+		"clientSecret": c.secret,
+	})
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, c.tokenURL, bytes.NewReader(reqBody))
+	if err != nil {
+		return "", err
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return "", fmt.Errorf("获取 token 失败: status=%d body=%s", resp.StatusCode, string(raw))
+	}
+	tokenData := tokenResponse{}
+	if err := json.Unmarshal(raw, &tokenData); err != nil {
+		return "", err
+	}
+	if tokenData.AccessToken == "" {
+		return "", errors.New("token 为空")
+	}
+	expSec := parseExpiresIn(tokenData.ExpiresIn)
+	if expSec <= 0 {
+		expSec = 7200
+	}
+	c.token = tokenData.AccessToken
+	c.expires = time.Now().Add(time.Duration(expSec) * time.Second)
+	return c.token, nil
+}
+
+func parseExpiresIn(raw any) int64 {
+	switch v := raw.(type) {
+	case float64:
+		return int64(v)
+	case int64:
+		return v
+	case int:
+		return int64(v)
+	case json.Number:
+		n, err := v.Int64()
+		if err == nil {
+			return n
+		}
+	case string:
+		s := strings.TrimSpace(v)
+		if s == "" {
+			return 0
+		}
+		n, err := strconv.ParseInt(s, 10, 64)
+		if err == nil {
+			return n
+		}
+	}
+	return 0
+}
+
+func (c *Client) invalidateToken() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.token = ""
+	c.expires = time.Time{}
+}
+
+func parseTime(raw string) time.Time {
+	if raw == "" {
+		return time.Now()
+	}
+	if t, err := time.Parse(time.RFC3339, raw); err == nil {
+		return t
+	}
+	if t, err := time.Parse("2006-01-02T15:04:05Z07:00", raw); err == nil {
+		return t
+	}
+	return time.Now()
+}

internal/targets/store.go

@@ -0,0 +1,280 @@
+package targets
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sky22333/qqbot/message"
+)
+
+type KnownTarget struct {
+	TargetType    message.TargetType `json:"target_type"`
+	TargetID      string             `json:"target_id"`
+	FirstSeenAt   time.Time          `json:"first_seen_at"`
+	LastSeenAt    time.Time          `json:"last_seen_at"`
+	LastMessageID string             `json:"last_message_id,omitempty"`
+	LastContent   string             `json:"last_content,omitempty"`
+	SeenCount     int64              `json:"seen_count"`
+}
+
+type Store struct {
+	filePath      string
+	maxRecords    int
+	flushInterval time.Duration
+
+	mu      sync.RWMutex
+	records map[string]KnownTarget
+	latest  map[message.TargetType]KnownTarget
+	latestX KnownTarget
+	hasLast bool
+	dirty   bool
+	version uint64
+
+	ctx      context.Context
+	cancel   context.CancelFunc
+	wg       sync.WaitGroup
+	flushSig chan struct{}
+}
+
+func NewStore(filePath string, maxRecords int, flushInterval time.Duration) (*Store, error) {
+	if strings.TrimSpace(filePath) == "" {
+		return nil, errors.New("targets file path 不能为空")
+	}
+	if maxRecords <= 0 {
+		maxRecords = 10000
+	}
+	if flushInterval <= 0 {
+		flushInterval = 2 * time.Second
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	s := &Store{
+		filePath:      filePath,
+		maxRecords:    maxRecords,
+		flushInterval: flushInterval,
+		records:       make(map[string]KnownTarget),
+		latest:        make(map[message.TargetType]KnownTarget),
+		ctx:           ctx,
+		cancel:        cancel,
+		flushSig:      make(chan struct{}, 1),
+	}
+	if err := s.load(); err != nil {
+		cancel()
+		return nil, err
+	}
+	s.startFlusher()
+	return s, nil
+}
+
+func (s *Store) Upsert(targetType message.TargetType, targetID, msgID, content string) error {
+	targetID = strings.TrimSpace(targetID)
+	if targetID == "" {
+		return nil
+	}
+	key := string(targetType) + ":" + targetID
+	now := time.Now()
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	record, ok := s.records[key]
+	if !ok {
+		record = KnownTarget{
+			TargetType:  targetType,
+			TargetID:    targetID,
+			FirstSeenAt: now,
+		}
+	}
+	record.LastSeenAt = now
+	record.LastMessageID = strings.TrimSpace(msgID)
+	record.LastContent = strings.TrimSpace(content)
+	record.SeenCount++
+	s.records[key] = record
+	s.latest[record.TargetType] = record
+	s.latestX = record
+	s.hasLast = true
+	s.compactIfNeededLocked()
+	s.dirty = true
+	s.version++
+	s.signalFlushLocked()
+	return nil
+}
+
+func (s *Store) List(limit int, targetType string) []KnownTarget {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	targetType = strings.TrimSpace(strings.ToLower(targetType))
+	items := make([]KnownTarget, 0, len(s.records))
+	for _, r := range s.records {
+		if targetType != "" && string(r.TargetType) != targetType {
+			continue
+		}
+		items = append(items, r)
+	}
+	sort.Slice(items, func(i, j int) bool {
+		return items[i].LastSeenAt.After(items[j].LastSeenAt)
+	})
+	if limit > 0 && len(items) > limit {
+		items = items[:limit]
+	}
+	return items
+}
+
+func (s *Store) Latest(targetType message.TargetType) (KnownTarget, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	item, ok := s.latest[targetType]
+	if !ok {
+		return KnownTarget{}, false
+	}
+	return item, true
+}
+
+func (s *Store) LatestAny() (KnownTarget, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if !s.hasLast {
+		return KnownTarget{}, false
+	}
+	return s.latestX, true
+}
+
+func (s *Store) load() error {
+	if _, err := os.Stat(s.filePath); err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+	raw, err := os.ReadFile(s.filePath)
+	if err != nil {
+		return err
+	}
+	var list []KnownTarget
+	if err := json.Unmarshal(raw, &list); err != nil {
+		return err
+	}
+	for _, item := range list {
+		key := string(item.TargetType) + ":" + item.TargetID
+		s.records[key] = item
+	}
+	s.rebuildLatestLocked()
+	return nil
+}
+
+func (s *Store) Close() error {
+	s.cancel()
+	s.wg.Wait()
+	return s.flushNow()
+}
+
+func (s *Store) startFlusher() {
+	s.wg.Add(1)
+	go func() {
+		defer s.wg.Done()
+		ticker := time.NewTicker(s.flushInterval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-s.ctx.Done():
+				return
+			case <-ticker.C:
+				_ = s.flushNow()
+			case <-s.flushSig:
+				_ = s.flushNow()
+			}
+		}
+	}()
+}
+
+func (s *Store) flushNow() error {
+	records, version, ok := s.snapshotForFlush()
+	if !ok {
+		return nil
+	}
+	if err := s.writeRecords(records); err != nil {
+		return err
+	}
+	s.mu.Lock()
+	if s.version == version {
+		s.dirty = false
+	}
+	s.mu.Unlock()
+	return nil
+}
+
+func (s *Store) snapshotForFlush() ([]KnownTarget, uint64, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if !s.dirty {
+		return nil, 0, false
+	}
+	list := make([]KnownTarget, 0, len(s.records))
+	for _, item := range s.records {
+		list = append(list, item)
+	}
+	sort.Slice(list, func(i, j int) bool {
+		return list[i].LastSeenAt.After(list[j].LastSeenAt)
+	})
+	return list, s.version, true
+}
+
+func (s *Store) writeRecords(list []KnownTarget) error {
+	if err := os.MkdirAll(filepath.Dir(s.filePath), 0o755); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(list, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(s.filePath, data, 0o644)
+}
+
+func (s *Store) signalFlushLocked() {
+	select {
+	case s.flushSig <- struct{}{}:
+	default:
+	}
+}
+
+func (s *Store) compactIfNeededLocked() {
+	if len(s.records) <= s.maxRecords {
+		return
+	}
+	list := make([]KnownTarget, 0, len(s.records))
+	for _, item := range s.records {
+		list = append(list, item)
+	}
+	sort.Slice(list, func(i, j int) bool {
+		return list[i].LastSeenAt.After(list[j].LastSeenAt)
+	})
+	cut := list[s.maxRecords:]
+	for _, item := range cut {
+		key := string(item.TargetType) + ":" + item.TargetID
+		delete(s.records, key)
+	}
+	s.rebuildLatestLocked()
+}
+
+func (s *Store) rebuildLatestLocked() {
+	clear(s.latest)
+	s.latestX = KnownTarget{}
+	s.hasLast = false
+	for _, item := range s.records {
+		prev, ok := s.latest[item.TargetType]
+		if !ok || item.LastSeenAt.After(prev.LastSeenAt) {
+			s.latest[item.TargetType] = item
+		}
+		if !s.hasLast || item.LastSeenAt.After(s.latestX.LastSeenAt) {
+			s.latestX = item
+			s.hasLast = true
+		}
+	}
+}