feat(whatsapp): implement recipient JID parsing and enhance message sending logging

MinecraftFuns · MinecraftFuns · commit c97bb25e1601 · 2026-02-02T18:48:16.000-05:00
diff --git a/internal/messaging/whatsapp_service.go b/internal/messaging/whatsapp_service.go
@@ -42,6 +42,8 @@ type WhatsAppService struct {
 	done      chan struct{}
 	mu        sync.RWMutex
 	stopped   bool
+	lidMu     sync.RWMutex
+	lidByPhone map[string]string // canonical phone -> JID string for LID addressing
 }
 
 // NewWhatsAppService creates a new WhatsAppService wrapping the given WhatsAppSender.
@@ -51,6 +53,7 @@ func NewWhatsAppService(client whatsapp.WhatsAppSender) *WhatsAppService {
 		receipts:  make(chan models.Receipt, DefaultChannelBufferSize),
 		responses: make(chan models.Response, DefaultChannelBufferSize),
 		done:      make(chan struct{}),
+		lidByPhone: make(map[string]string),
 	}
 
 	// If the client is a full Client (not just an interface), store it for event handling
@@ -64,6 +67,33 @@ func NewWhatsAppService(client whatsapp.WhatsAppSender) *WhatsAppService {
 	return service
 }
 
+func (s *WhatsAppService) storeRecipientLID(canonicalPhone string, lidJID string) {
+	if canonicalPhone == "" || lidJID == "" {
+		return
+	}
+
+	s.lidMu.Lock()
+	defer s.lidMu.Unlock()
+
+	if existing, ok := s.lidByPhone[canonicalPhone]; ok && existing == lidJID {
+		return
+	}
+
+	s.lidByPhone[canonicalPhone] = lidJID
+	slog.Debug("WhatsAppService stored LID mapping", "phone", canonicalPhone, "lid", lidJID)
+}
+
+func (s *WhatsAppService) resolveRecipientAddress(canonicalPhone string) string {
+	s.lidMu.RLock()
+	defer s.lidMu.RUnlock()
+
+	if lidJID, ok := s.lidByPhone[canonicalPhone]; ok && lidJID != "" {
+		return lidJID
+	}
+
+	return canonicalPhone
+}
+
 // ValidateAndCanonicalizeRecipient validates and canonicalizes a WhatsApp phone number.
 // It removes all non-numeric characters and validates the result has at least 6 digits.
 func (s *WhatsAppService) ValidateAndCanonicalizeRecipient(recipient string) (string, error) {
@@ -148,10 +178,15 @@ func (s *WhatsAppService) SendMessage(ctx context.Context, to string, body strin
 		return err
 	}
 
-	slog.Debug("WhatsAppService SendMessage invoked", "to", canonicalTo, "body_length", len(body))
-	err = s.client.SendMessage(ctx, canonicalTo, body)
+	sendTo := s.resolveRecipientAddress(canonicalTo)
+	if sendTo != canonicalTo {
+		slog.Debug("WhatsAppService SendMessage using LID recipient", "to", sendTo, "phone", canonicalTo)
+	} else {
+		slog.Debug("WhatsAppService SendMessage invoked", "to", canonicalTo, "body_length", len(body))
+	}
+	err = s.client.SendMessage(ctx, sendTo, body)
 	if err != nil {
-		slog.Error("WhatsAppService SendMessage error", "error", err, "to", canonicalTo)
+		slog.Error("WhatsAppService SendMessage error", "error", err, "to", sendTo, "phone", canonicalTo)
 		return err
 	}
 
@@ -183,21 +218,23 @@ func (s *WhatsAppService) SendPromptWithButtons(ctx context.Context, to string,
 		return err
 	}
 
+	sendTo := s.resolveRecipientAddress(canonicalTo)
+
 	var sendErr error
 	if sender, ok := s.client.(promptButtonsClient); ok {
-		slog.Debug("WhatsAppService SendPromptWithButtons using poll message", "to", canonicalTo)
-		sendErr = sender.SendPromptButtons(ctx, canonicalTo, body)
+		slog.Debug("WhatsAppService SendPromptWithButtons using poll message", "to", sendTo, "phone", canonicalTo)
+		sendErr = sender.SendPromptButtons(ctx, sendTo, body)
 	} else {
-		slog.Debug("WhatsAppService SendPromptWithButtons falling back to text message", "to", canonicalTo)
-		sendErr = s.client.SendMessage(ctx, canonicalTo, body)
+		slog.Debug("WhatsAppService SendPromptWithButtons falling back to text message", "to", sendTo, "phone", canonicalTo)
+		sendErr = s.client.SendMessage(ctx, sendTo, body)
 	}
 
 	if sendErr != nil {
-		slog.Error("WhatsAppService SendPromptWithButtons error", "error", sendErr, "to", canonicalTo)
+		slog.Error("WhatsAppService SendPromptWithButtons error", "error", sendErr, "to", sendTo, "phone", canonicalTo)
 		return sendErr
 	}
 	s.safeEmitReceipt(models.Receipt{To: canonicalTo, Status: models.MessageStatusSent, Time: time.Now().Unix()})
-	slog.Info("WhatsAppService prompt with poll sent and receipt emitted", "to", canonicalTo)
+	slog.Info("WhatsAppService prompt with poll sent and receipt emitted", "to", sendTo, "phone", canonicalTo)
 	return nil
 }
 
@@ -217,23 +254,25 @@ func (s *WhatsAppService) SendIntensityAdjustmentPoll(ctx context.Context, to st
 		return err
 	}
 
+	sendTo := s.resolveRecipientAddress(canonicalTo)
+
 	var sendErr error
 	if sender, ok := s.client.(promptButtonsClient); ok {
-		slog.Debug("WhatsAppService SendIntensityAdjustmentPoll using poll message", "to", canonicalTo, "currentIntensity", currentIntensity)
-		sendErr = sender.SendIntensityAdjustmentPoll(ctx, canonicalTo, currentIntensity)
+		slog.Debug("WhatsAppService SendIntensityAdjustmentPoll using poll message", "to", sendTo, "phone", canonicalTo, "currentIntensity", currentIntensity)
+		sendErr = sender.SendIntensityAdjustmentPoll(ctx, sendTo, currentIntensity)
 	} else {
 		// Fallback: send text message asking about intensity
-		slog.Debug("WhatsAppService SendIntensityAdjustmentPoll falling back to text message", "to", canonicalTo)
-		sendErr = s.client.SendMessage(ctx, canonicalTo, "How's the intensity? Reply with 'low', 'normal', or 'high'.")
+		slog.Debug("WhatsAppService SendIntensityAdjustmentPoll falling back to text message", "to", sendTo, "phone", canonicalTo)
+		sendErr = s.client.SendMessage(ctx, sendTo, "How's the intensity? Reply with 'low', 'normal', or 'high'.")
 	}
 
 	if sendErr != nil {
-		slog.Error("WhatsAppService SendIntensityAdjustmentPoll error", "error", sendErr, "to", canonicalTo)
+		slog.Error("WhatsAppService SendIntensityAdjustmentPoll error", "error", sendErr, "to", sendTo, "phone", canonicalTo)
 		return sendErr
 	}
 
 	s.safeEmitReceipt(models.Receipt{To: canonicalTo, Status: models.MessageStatusSent, Time: time.Now().Unix()})
-	slog.Info("WhatsAppService intensity adjustment poll sent and receipt emitted", "to", canonicalTo, "currentIntensity", currentIntensity)
+	slog.Info("WhatsAppService intensity adjustment poll sent and receipt emitted", "to", sendTo, "phone", canonicalTo, "currentIntensity", currentIntensity)
 	return nil
 }
 
@@ -253,9 +292,11 @@ func (s *WhatsAppService) SendTypingIndicator(ctx context.Context, to string, ty
 		return err
 	}
 
-	slog.Debug("WhatsAppService SendTypingIndicator invoked", "to", canonicalTo, "typing", typing)
-	if err := s.client.SendTypingIndicator(ctx, canonicalTo, typing); err != nil {
-		slog.Warn("WhatsAppService SendTypingIndicator error", "error", err, "to", canonicalTo, "typing", typing)
+	sendTo := s.resolveRecipientAddress(canonicalTo)
+
+	slog.Debug("WhatsAppService SendTypingIndicator invoked", "to", sendTo, "phone", canonicalTo, "typing", typing)
+	if err := s.client.SendTypingIndicator(ctx, sendTo, typing); err != nil {
+		slog.Warn("WhatsAppService SendTypingIndicator error", "error", err, "to", sendTo, "phone", canonicalTo, "typing", typing)
 		return err
 	}
 
@@ -364,10 +405,47 @@ func (s *WhatsAppService) handleIncomingMessage(evt *events.Message) {
 		return
 	}
 
-	// Convert JID to E.164 format (remove @s.whatsapp.net suffix)
-	fromNumber := strings.TrimSuffix(evt.Info.Sender.User, "")
-	if !strings.HasPrefix(fromNumber, "+") {
-		fromNumber = "+" + fromNumber
+	// Convert JID to E.164 format and store LID mapping if available
+	fromNumber := ""
+	canonicalPhone := ""
+
+	sender := evt.Info.Sender.ToNonAD()
+	senderAlt := evt.Info.SenderAlt.ToNonAD()
+
+	var phoneJID types.JID
+	var lidJID types.JID
+
+	if evt.Info.AddressingMode == types.AddressingModeLID {
+		lidJID = sender
+		phoneJID = senderAlt
+	} else {
+		phoneJID = sender
+		lidJID = senderAlt
+	}
+
+	if phoneJID.User == "" || phoneJID.Server != types.DefaultUserServer {
+		phoneJID = sender
+	}
+
+	if phoneJID.User != "" {
+		fromNumber = phoneJID.User
+		if !strings.HasPrefix(fromNumber, "+") {
+			fromNumber = "+" + fromNumber
+		}
+	}
+
+	if fromNumber == "" {
+		fromNumber = sender.User
+		if !strings.HasPrefix(fromNumber, "+") {
+			fromNumber = "+" + fromNumber
+		}
+	}
+
+	if canonical, err := s.ValidateAndCanonicalizeRecipient(fromNumber); err == nil {
+		canonicalPhone = canonical
+		if lidJID.User != "" && lidJID.Server == types.HiddenUserServer {
+			s.storeRecipientLID(canonicalPhone, lidJID.String())
+		}
 	}
 
 	response := models.Response{
@@ -376,7 +454,7 @@ func (s *WhatsAppService) handleIncomingMessage(evt *events.Message) {
 		Time: evt.Info.Timestamp.Unix(),
 	}
 
-	slog.Debug("WhatsAppService processing incoming message", "from", response.From, "body_length", len(response.Body))
+	slog.Debug("WhatsAppService processing incoming message", "from", response.From, "body_length", len(response.Body), "addressingMode", evt.Info.AddressingMode, "canonicalPhone", canonicalPhone)
 
 	// Send to responses channel (non-blocking)
 	s.safeEmitResponse(response)
diff --git a/internal/whatsapp/whatsapp.go b/internal/whatsapp/whatsapp.go
@@ -262,11 +262,15 @@ func (c *Client) SendMessage(ctx context.Context, to string, body string) error
 	// Note: Phone number validation and canonicalization should be handled by the service layer.
 	// The recipient should already be validated and canonicalized when this method is called.
 
-	slog.Debug("Sending WhatsApp message", "to", to, "body_length", len(body))
-	jid := types.NewJID(to, JIDSuffix)
+	jid, err := parseRecipientJID(to)
+	if err != nil {
+		return err
+	}
+
+	slog.Debug("Sending WhatsApp message", "to", jid.String(), "body_length", len(body))
 	msg := &waE2E.Message{Conversation: &body}
 
-	_, err := c.waClient.SendMessage(ctx, jid, msg)
+	_, err = c.waClient.SendMessage(ctx, jid, msg)
 	if err != nil {
 		slog.Error("Failed to send WhatsApp message", "error", err, "to", to)
 		return fmt.Errorf("failed to send message to %s: %w", to, err)
@@ -292,12 +296,16 @@ func (c *Client) SendPromptButtons(ctx context.Context, to string, body string)
 		return fmt.Errorf("message body cannot be empty")
 	}
 
-	slog.Debug("Sending WhatsApp prompt with poll", "to", to, "body_length", len(body))
-	jid := types.NewJID(to, JIDSuffix)
+	jid, err := parseRecipientJID(to)
+	if err != nil {
+		return err
+	}
+
+	slog.Debug("Sending WhatsApp prompt with poll", "to", jid.String(), "body_length", len(body))
 
 	// First send the main prompt message
 	mainMsg := &waE2E.Message{Conversation: &body}
-	_, err := c.waClient.SendMessage(ctx, jid, mainMsg)
+	_, err = c.waClient.SendMessage(ctx, jid, mainMsg)
 	if err != nil {
 		slog.Error("Failed to send WhatsApp prompt message", "error", err, "to", to)
 		return fmt.Errorf("failed to send prompt message to %s: %w", to, err)
@@ -340,8 +348,12 @@ func (c *Client) SendIntensityAdjustmentPoll(ctx context.Context, to string, cur
 		return fmt.Errorf("invalid intensity level: %s", currentIntensity)
 	}
 
-	slog.Debug("Sending intensity adjustment poll", "to", to, "currentIntensity", currentIntensity, "options", options)
-	jid := types.NewJID(to, JIDSuffix)
+	jid, err := parseRecipientJID(to)
+	if err != nil {
+		return err
+	}
+
+	slog.Debug("Sending intensity adjustment poll", "to", jid.String(), "currentIntensity", currentIntensity, "options", options)
 
 	// Send poll using Whatsmeow's built-in helper
 	pollMsg := c.waClient.BuildPollCreation(
@@ -350,7 +362,7 @@ func (c *Client) SendIntensityAdjustmentPoll(ctx context.Context, to string, cur
 		1, // single-select
 	)
 
-	_, err := c.waClient.SendMessage(ctx, jid, pollMsg)
+	_, err = c.waClient.SendMessage(ctx, jid, pollMsg)
 	if err != nil {
 		slog.Error("Failed to send intensity adjustment poll", "error", err, "to", to)
 		return fmt.Errorf("failed to send intensity poll to %s: %w", to, err)
@@ -375,7 +387,10 @@ func (c *Client) SendTypingIndicator(ctx context.Context, to string, typing bool
 	default:
 	}
 
-	jid := types.NewJID(to, JIDSuffix)
+	jid, err := parseRecipientJID(to)
+	if err != nil {
+		return err
+	}
 	presence := types.ChatPresencePaused
 	if typing {
 		presence = types.ChatPresenceComposing
@@ -390,6 +405,18 @@ func (c *Client) SendTypingIndicator(ctx context.Context, to string, typing bool
 	return nil
 }
 
+func parseRecipientJID(to string) (types.JID, error) {
+	if strings.Contains(to, "@") {
+		jid, err := types.ParseJID(to)
+		if err != nil {
+			return types.JID{}, fmt.Errorf("invalid recipient JID %q: %w", to, err)
+		}
+		return jid.ToNonAD(), nil
+	}
+
+	return types.NewJID(to, JIDSuffix), nil
+}
+
 // GetClient returns the underlying whatsmeow client for event handling
 func (c *Client) GetClient() *whatsmeow.Client {
 	return c.waClient
