feat: 实现 Go 与 JS/TS SDK 连接收发与其余接口

2026-09-30 07:03:33 +08:00
parent 1cff321f2a
commit 9650cbff76
32 changed files with 7145 additions and 1 deletions
@@ -0,0 +1,326 @@
+package nixmsg
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"time"
+)
+
+func (c *Client) handleDown(payload []byte) {
+	var head struct {
+		Type string `json:"type"`
+		RID  string `json:"rid"`
+	}
+	if err := unmarshalJSON(payload, &head); err != nil {
+		return
+	}
+	switch head.Type {
+	case "resp":
+		var rf respFrame
+		if err := unmarshalJSON(payload, &rf); err != nil {
+			return
+		}
+		c.mu.Lock()
+		p := c.pending[head.RID]
+		if p != nil {
+			delete(c.pending, head.RID)
+		}
+		c.mu.Unlock()
+		if p != nil {
+			select {
+			case p.ch <- rf:
+			default:
+			}
+		}
+	case "msg":
+		c.handleMsg(payload)
+	case "receipt":
+		c.handleReceipt(payload)
+	case "revoked":
+		c.handleRevoked(payload)
+	case "presence":
+		c.handlePresence(payload)
+	case "group_event":
+		c.handleGroupEvent(payload)
+	case "fatal":
+		var f struct {
+			Reason string `json:"reason"`
+		}
+		_ = unmarshalJSON(payload, &f)
+		c.mu.Lock()
+		c.stopReconnect = true
+		c.setStateLocked(StateAuthFailed, f.Reason)
+		c.failQueuedLocked(apiErr("fatal", f.Reason))
+		cancel := c.cancel
+		c.mu.Unlock()
+		if cancel != nil {
+			cancel()
+		}
+	}
+}
+
+func (c *Client) handleMsg(payload []byte) {
+	var m struct {
+		ID       string         `json:"id"`
+		From     string         `json:"from"`
+		To       Target         `json:"to"`
+		Body     Body           `json:"body"`
+		Meta     map[string]any `json:"meta"`
+		SendAtMs int64          `json:"send_at_ms"`
+	}
+	if err := unmarshalJSON(payload, &m); err != nil {
+		return
+	}
+	key := m.From + "\x00" + m.ID
+	c.mu.Lock()
+	ent := c.dedup[key]
+	manual := c.opts.ManualAck
+	if ent != nil && ent.state == dedupAcked {
+		c.mu.Unlock()
+		_ = c.sendAckFrame(m.From, m.ID)
+		return
+	}
+	if ent != nil && ent.state == dedupDelivered {
+		c.mu.Unlock()
+		return
+	}
+	c.rememberDedupLocked(key, m.From, m.ID, dedupDelivered)
+	c.mu.Unlock()
+
+	msg := Message{ID: m.ID, From: m.From, To: m.To, Body: m.Body, Meta: m.Meta, SendAtMs: m.SendAtMs}
+	var cbErr error
+	c.cbMu.Lock()
+	if c.onMessage != nil {
+		cbErr = c.onMessage(msg)
+	}
+	c.cbMu.Unlock()
+
+	if manual {
+		return
+	}
+	if cbErr != nil {
+		c.mu.Lock()
+		delete(c.dedup, key)
+		c.mu.Unlock()
+		return
+	}
+	_ = c.sendAckFrame(m.From, m.ID)
+	c.mu.Lock()
+	if e := c.dedup[key]; e != nil {
+		e.state = dedupAcked
+	}
+	c.mu.Unlock()
+}
+
+func (c *Client) rememberDedupLocked(key, from, id string, st dedupState) {
+	if _, ok := c.dedup[key]; !ok {
+		c.dedupOrd = append(c.dedupOrd, key)
+		for len(c.dedupOrd) > c.opts.DedupCapacity {
+			old := c.dedupOrd[0]
+			c.dedupOrd = c.dedupOrd[1:]
+			delete(c.dedup, old)
+		}
+	}
+	c.dedup[key] = &dedupEntry{state: st, from: from, id: id}
+}
+
+// Ack 手动确认。
+func (c *Client) Ack(msg Message) error {
+	if err := c.sendAckFrame(msg.From, msg.ID); err != nil {
+		return err
+	}
+	key := msg.From + "\x00" + msg.ID
+	c.mu.Lock()
+	c.rememberDedupLocked(key, msg.From, msg.ID, dedupAcked)
+	c.mu.Unlock()
+	return nil
+}
+
+func (c *Client) sendAckFrame(from, id string) error {
+	req := map[string]any{
+		"v": 1, "type": "ack", "rid": c.nextRID(), "from": from, "id": id,
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	data, err := c.request(ctx, req, true)
+	if err != nil {
+		return err
+	}
+	if len(data) > 0 {
+		var d struct {
+			Result string `json:"result"`
+		}
+		if json.Unmarshal(data, &d) == nil && d.Result != "" && d.Result != "accepted" {
+			c.emitRevoked(RevokedEvent{ID: id, From: from, Reason: d.Result})
+		}
+	}
+	return nil
+}
+
+func (c *Client) handleReceipt(payload []byte) {
+	var r struct {
+		ReceiptID  string `json:"receipt_id"`
+		ID         string `json:"id"`
+		EndpointID string `json:"endpoint_id"`
+		State      string `json:"state"`
+		Reason     string `json:"reason"`
+		AtMs       int64  `json:"at_ms"`
+	}
+	if err := unmarshalJSON(payload, &r); err != nil {
+		return
+	}
+	c.mu.Lock()
+	if _, ok := c.receiptSeen[r.ReceiptID]; ok {
+		c.mu.Unlock()
+		_ = c.sendReceiptAck(r.ReceiptID)
+		return
+	}
+	c.receiptSeen[r.ReceiptID] = struct{}{}
+	c.mu.Unlock()
+	ev := Receipt{ReceiptID: r.ReceiptID, ID: r.ID, EndpointID: r.EndpointID, State: r.State, Reason: r.Reason, AtMs: r.AtMs}
+	c.cbMu.Lock()
+	if c.onReceipt != nil {
+		c.onReceipt(ev)
+	}
+	c.cbMu.Unlock()
+	_ = c.sendReceiptAck(r.ReceiptID)
+}
+
+func (c *Client) sendReceiptAck(receiptID string) error {
+	req := map[string]any{"v": 1, "type": "receipt_ack", "rid": c.nextRID(), "receipt_id": receiptID}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	_, err := c.request(ctx, req, true)
+	return err
+}
+
+func (c *Client) handleRevoked(payload []byte) {
+	var r struct {
+		ID     string `json:"id"`
+		From   string `json:"from"`
+		Reason string `json:"reason"`
+	}
+	if err := unmarshalJSON(payload, &r); err != nil {
+		return
+	}
+	key := r.From + "\x00" + r.ID
+	c.mu.Lock()
+	ent := c.dedup[key]
+	if ent == nil || ent.state == dedupAcked {
+		c.mu.Unlock()
+		return
+	}
+	delete(c.dedup, key)
+	c.mu.Unlock()
+	c.emitRevoked(RevokedEvent{ID: r.ID, From: r.From, Reason: r.Reason})
+}
+
+func (c *Client) emitRevoked(e RevokedEvent) {
+	c.cbMu.Lock()
+	defer c.cbMu.Unlock()
+	if c.onRevoked != nil {
+		c.onRevoked(e)
+	}
+}
+
+func (c *Client) handlePresence(payload []byte) {
+	var p struct {
+		ID     string `json:"id"`
+		Online bool   `json:"online"`
+		AtMs   int64  `json:"at_ms"`
+	}
+	if err := unmarshalJSON(payload, &p); err != nil {
+		return
+	}
+	c.cbMu.Lock()
+	defer c.cbMu.Unlock()
+	if c.onPresence != nil {
+		c.onPresence(PresenceEvent{ID: p.ID, Online: p.Online, AtMs: p.AtMs})
+	}
+}
+
+func (c *Client) handleGroupEvent(payload []byte) {
+	var g struct {
+		GroupID    string `json:"group_id"`
+		Event      string `json:"event"`
+		EndpointID string `json:"endpoint_id"`
+		AtMs       int64  `json:"at_ms"`
+	}
+	if err := unmarshalJSON(payload, &g); err != nil {
+		return
+	}
+	c.cbMu.Lock()
+	defer c.cbMu.Unlock()
+	if c.onGroupEvent != nil {
+		c.onGroupEvent(GroupEvent{GroupID: g.GroupID, Event: g.Event, EndpointID: g.EndpointID, AtMs: g.AtMs})
+	}
+}
+
+func (c *Client) request(ctx context.Context, frame map[string]any, allowUnready bool) (json.RawMessage, error) {
+	c.mu.Lock()
+	if c.closed {
+		c.mu.Unlock()
+		return nil, apiErr(CodeClosed, "已关闭")
+	}
+	if !allowUnready && !c.handshook {
+		c.mu.Unlock()
+		return nil, apiErr(CodeNotConnected, "未握手")
+	}
+	tr := c.transport
+	c.mu.Unlock()
+	if tr == nil {
+		return nil, apiErr(CodeNotConnected, "未连接")
+	}
+	rid, _ := frame["rid"].(string)
+	if rid == "" {
+		rid = c.nextRID()
+		frame["rid"] = rid
+	}
+	payload, err := marshalJSON(frame)
+	if err != nil {
+		return nil, err
+	}
+	ch := make(chan respFrame, 1)
+	c.mu.Lock()
+	c.pending[rid] = &pendingReq{rid: rid, ch: ch}
+	c.mu.Unlock()
+	if err := tr.PublishUp(payload); err != nil {
+		c.mu.Lock()
+		delete(c.pending, rid)
+		c.mu.Unlock()
+		return nil, err
+	}
+	select {
+	case <-ctx.Done():
+		c.mu.Lock()
+		delete(c.pending, rid)
+		c.mu.Unlock()
+		return nil, ctx.Err()
+	case rf := <-ch:
+		if !rf.OK {
+			code, msg := CodeBadRequest, "请求失败"
+			if rf.Error != nil {
+				code, msg = rf.Error.Code, rf.Error.Message
+			}
+			return nil, apiErr(code, msg)
+		}
+		return rf.Data, nil
+	}
+}
+
+// bodyDecodedLen 按解码后字节计正文大小。
+func bodyDecodedLen(b Body) (int, error) {
+	switch b.Enc {
+	case "utf8", "":
+		return len([]byte(b.Data)), nil
+	case "base64":
+		raw, err := base64.StdEncoding.DecodeString(b.Data)
+		if err != nil {
+			return 0, apiErr(CodeBadRequest, "base64 正文无效")
+		}
+		return len(raw), nil
+	default:
+		return 0, apiErr(CodeBadRequest, "未知 enc")
+	}
+}