Skip to content

GOWA - WhatsApp REST API with support for UI, Multi Account, Webhooks, and MCP, and Chatwoot. Built with Golang for efficient memory use.

13.2 KB
Raw Blame
package usecase

import (
	"context"
	"errors"
	"fmt"
	"os"
	"sync"
	"time"

	"github.com/aldinokemal/go-whatsapp-web-multidevice/config"
	domainApp "github.com/aldinokemal/go-whatsapp-web-multidevice/domains/app"
	domainChatStorage "github.com/aldinokemal/go-whatsapp-web-multidevice/domains/chatstorage"
	"github.com/aldinokemal/go-whatsapp-web-multidevice/infrastructure/whatsapp"
	pkgError "github.com/aldinokemal/go-whatsapp-web-multidevice/pkg/error"
	"github.com/aldinokemal/go-whatsapp-web-multidevice/ui/websocket"
	"github.com/aldinokemal/go-whatsapp-web-multidevice/validations"
	fiberUtils "github.com/gofiber/utils/v2"
	"github.com/sirupsen/logrus"
	"github.com/skip2/go-qrcode"
	"go.mau.fi/libsignal/logger"
	"go.mau.fi/whatsmeow"
	"go.mau.fi/whatsmeow/types"
)

type serviceApp struct {
	chatStorageRepo domainChatStorage.IChatStorageRepository
	deviceManager   *whatsapp.DeviceManager
	loginLocks      sync.Map // device id -> chan struct{}, see lockLogin
}

func NewAppService(chatStorageRepo domainChatStorage.IChatStorageRepository, deviceManager *whatsapp.DeviceManager) domainApp.IAppUsecase {
	return &serviceApp{
		chatStorageRepo: chatStorageRepo,
		deviceManager:   deviceManager,
	}
}

func (service *serviceApp) Login(ctx context.Context, deviceID string) (response domainApp.LoginResponse, err error) {
	unlock, err := service.lockLogin(ctx, deviceID)
	if err != nil {
		return response, err
	}
	defer unlock()

	instance, client, err := service.ensureClient(ctx, deviceID)
	if err != nil {
		return response, err
	}

	if client.IsLoggedIn() {
		instance.UpdateStateFromClient()
		return response, pkgError.ErrAlreadyLoggedIn
	}

	// Disconnect first to ensure QR flow starts cleanly.
	client.Disconnect()
	instance.ClearPasskeyState()

	// Start every QR login on a fresh client. Disconnect emits no event, so the QR
	// channel of a previous login stays registered on the client and, once its context
	// expires, disconnects the next session right after its QR code is shown (#851).
	if client.Store.ID == nil {
		instance.SetClient(nil)
		if instance, client, err = service.ensureClient(ctx, deviceID); err != nil {
			return response, err
		}
	}

	// Use a detached context for the QR channel so the pairing session
	// survives after the HTTP response is sent. The HTTP request context
	// has a short timeout (e.g. 45s) which would cancel the QR emitter
	// and disconnect the client before the user can scan the code.
	// Total QR window: ~160s (first code 60s + five codes at 20s each).
	qrCtx, qrCancel := context.WithTimeout(context.Background(), 3*time.Minute)

	chImage := make(chan string, 1) // Buffered to prevent goroutine leak
	ch, err := client.GetQRChannel(qrCtx)
	if err != nil {
		qrCancel()
		logrus.Errorf("[LOGIN][%s] GetQRChannel failed: %v", deviceID, err)
		if errors.Is(err, whatsmeow.ErrQRStoreContainsID) {
			_ = client.Connect()
			instance.UpdateStateFromClient()
			if client.IsLoggedIn() {
				return response, pkgError.ErrAlreadyLoggedIn
			}
			return response, pkgError.ErrSessionSaved
		}
		return response, pkgError.ErrQrChannel
	}

	go func() {
		defer qrCancel()
		defer close(chImage) // Ensure channel is closed when done
		for {
			var evt whatsmeow.QRChannelItem
			select {
			case item, ok := <-ch:
				if !ok {
					return
				}
				evt = item
			case <-qrCtx.Done():
				// A superseded login's channel is never closed; stop with its QR window.
				return
			}
			response.Code = evt.Code
			response.Duration = evt.Timeout / time.Second / 2
			if evt.Event == "code" {
				qrPath := fmt.Sprintf("%s/scan-qr-%s.png", config.PathQrCode, fiberUtils.UUIDv4())
				if err := qrcode.WriteFile(evt.Code, qrcode.Medium, 512, qrPath); err != nil {
					logrus.Errorf("[LOGIN][%s] Error when write qr code to file: %v", deviceID, err)
					continue // Skip sending if QR generation failed
				}
				go func(path string, duration time.Duration) {
					time.Sleep(duration * time.Second)
					if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
						logrus.Errorf("[LOGIN][%s] error when remove qrImage file: %v", deviceID, err)
					}
				}(qrPath, response.Duration)
				select {
				case chImage <- qrPath:
				case <-qrCtx.Done():
					logrus.Warnf("[LOGIN][%s] QR context canceled while sending QR path", deviceID)
					return
				}
			} else if evt.Event == whatsmeow.QRChannelEventPasskeyRequest || evt.Event == whatsmeow.QRChannelEventPasskeyResponse {
				// Passkey events are broadcast by the global event handler and served via /app/passkey endpoints.
				logrus.Infof("[LOGIN][%s] passkey pairing event: %s", deviceID, evt.Event)
			} else {
				logrus.Errorf("[LOGIN][%s] error when get qrCode %s %v", deviceID, evt.Event, evt.Error)
			}
		}
	}()

	if err = client.Connect(); err != nil {
		qrCancel()
		logger.Error("Error when connect to whatsapp", err)
		return response, pkgError.ErrReconnect
	}

	instance.UpdateStateFromClient()

	// Wait for QR image with timeout to prevent hanging
	select {
	case imagePath, ok := <-chImage:
		if !ok {
			return response, fmt.Errorf("QR channel closed without receiving image")
		}
		response.ImagePath = imagePath
	case <-ctx.Done():
		return response, ctx.Err()
	case <-time.After(120 * time.Second):
		return response, fmt.Errorf("timeout waiting for QR code")
	}

	return response, nil
}

func (service *serviceApp) LoginWithCode(ctx context.Context, deviceID string, phoneNumber string) (loginCode string, err error) {
	if err = validations.ValidateLoginWithCode(ctx, phoneNumber); err != nil {
		logrus.Errorf("Error when validate login with code: %s", err.Error())
		return loginCode, err
	}

	unlock, err := service.lockLogin(ctx, deviceID)
	if err != nil {
		return loginCode, err
	}
	defer unlock()

	instance, client, err := service.ensureClient(ctx, deviceID)
	if err != nil {
		return loginCode, err
	}

	if client.IsLoggedIn() {
		instance.UpdateStateFromClient()
		return loginCode, pkgError.ErrAlreadyLoggedIn
	}

	// Connect before requesting pairing code.
	if !client.IsConnected() {
		if err = client.Connect(); err != nil {
			return loginCode, err
		}
	}

	logrus.Infof("[LOGIN_CODE][%s] Starting phone pairing for number: %s", deviceID, phoneNumber)
	loginCode, err = client.PairPhone(ctx, phoneNumber, true, whatsmeow.PairClientChrome, "Chrome (Linux)")
	if err != nil {
		logrus.Errorf("Error when pairing phone: %s", err.Error())
		return loginCode, err
	}

	instance.UpdateStateFromClient()
	logrus.Infof("Successfully paired phone with code: %s", loginCode)
	return loginCode, nil
}

func (service *serviceApp) PasskeyChallenge(_ context.Context, deviceID string) (response domainApp.PasskeyChallengeResponse, err error) {
	if service.deviceManager == nil {
		return response, fmt.Errorf("device manager not initialized")
	}

	instance, ok := service.deviceManager.GetDevice(deviceID)
	if !ok || instance == nil {
		return response, fmt.Errorf("device %s not found", deviceID)
	}

	challenge, code, skipHandoffUX := instance.PasskeyState()
	response.Status = "none"
	if challenge != nil {
		response.Status = "awaiting_response"
	} else if code != "" {
		response.Status = "awaiting_confirmation"
	}
	response.Challenge = challenge
	response.Code = code
	response.SkipHandoffUX = skipHandoffUX
	return response, nil
}

func (service *serviceApp) PasskeyResponse(ctx context.Context, deviceID string, assertion *types.WebAuthnResponse) error {
	if err := validations.ValidatePasskeyResponse(ctx, assertion); err != nil {
		return err
	}

	if service.deviceManager == nil {
		return fmt.Errorf("device manager not initialized")
	}

	instance, ok := service.deviceManager.GetDevice(deviceID)
	if !ok || instance == nil {
		return fmt.Errorf("device %s not found", deviceID)
	}

	client := instance.GetClient()
	if client == nil {
		return pkgError.ErrWaCLI
	}

	challenge, _, _ := instance.PasskeyState()
	if challenge == nil {
		return fmt.Errorf("no pending passkey pairing request for device %s", deviceID)
	}

	if !client.IsConnected() {
		return fmt.Errorf("device %s is not connected, restart login and retry the passkey flow", deviceID)
	}

	if err := client.SendPasskeyResponse(ctx, assertion); err != nil {
		logrus.Errorf("[PASSKEY][%s] failed to send passkey response: %v", deviceID, err)
		return err
	}

	// The PairPasskeyConfirmation event repopulates the confirmation code shortly after.
	instance.ClearPasskeyState()
	return nil
}

func (service *serviceApp) PasskeyConfirm(ctx context.Context, deviceID string) error {
	if service.deviceManager == nil {
		return fmt.Errorf("device manager not initialized")
	}

	instance, ok := service.deviceManager.GetDevice(deviceID)
	if !ok || instance == nil {
		return fmt.Errorf("device %s not found", deviceID)
	}

	client := instance.GetClient()
	if client == nil {
		return pkgError.ErrWaCLI
	}

	_, code, _ := instance.PasskeyState()
	if code == "" {
		return fmt.Errorf("no pending passkey confirmation for device %s", deviceID)
	}

	if !client.IsConnected() {
		return fmt.Errorf("device %s is not connected, restart login and retry the passkey flow", deviceID)
	}

	if err := client.SendPasskeyConfirmation(ctx); err != nil {
		logrus.Errorf("[PASSKEY][%s] failed to send passkey confirmation: %v", deviceID, err)
		return err
	}

	instance.ClearPasskeyState()
	return nil
}

func (service *serviceApp) Logout(ctx context.Context, deviceID string) error {
	if err := validations.ValidateDeviceID(ctx, deviceID); err != nil {
		return err
	}
	if service.deviceManager == nil {
		return fmt.Errorf("device manager not initialized")
	}

	if err := service.deviceManager.LogoutDeviceKeepSlot(ctx, deviceID); err != nil {
		logrus.WithError(err).Warnf("[LOGOUT][%s] logout completed with warnings", deviceID)
		return err
	}

	// Broadcast the logout so the UI can refresh without manual polling. The slot is
	// kept, so the device stays listed (disconnected) and can be re-paired by id.
	var devices []domainApp.DevicesResponse
	if list, err := service.FetchDevices(ctx); err == nil {
		devices = list
	} else {
		logrus.WithError(err).Warn("[LOGOUT] failed to fetch devices after logout")
	}

	websocket.Broadcast <- websocket.BroadcastMessage{
		Code:    "DEVICE_LOGGED_OUT",
		Message: fmt.Sprintf("Device %s logged out (slot kept)", deviceID),
		Result: map[string]any{
			"device_id": deviceID,
			"devices":   devices,
		},
	}

	return nil
}

func (service *serviceApp) Reconnect(_ context.Context, deviceID string) (err error) {
	instance, client, err := service.ensureClient(context.Background(), deviceID)
	if err != nil {
		return err
	}

	if client.Store == nil || client.Store.ID == nil {
		return fmt.Errorf("device %s is not logged in (session deleted)", deviceID)
	}

	client.Disconnect()
	err = client.Connect()
	instance.UpdateStateFromClient()
	if err != nil {
		logrus.Errorf("[RECONNECT][%s] Reconnect failed: %v", deviceID, err)
	}
	return err
}

func (service *serviceApp) Status(_ context.Context, deviceID string) (bool, bool, error) {
	if service.deviceManager == nil {
		return false, false, fmt.Errorf("device manager not initialized")
	}

	instance, ok := service.deviceManager.GetDevice(deviceID)
	if !ok || instance == nil {
		return false, false, fmt.Errorf("device %s not found", deviceID)
	}

	instance.UpdateStateFromClient()
	client := instance.GetClient()
	if client == nil {
		return false, false, nil
	}

	if client.Store == nil || client.Store.ID == nil {
		return false, false, nil
	}

	return client.IsConnected(), client.IsLoggedIn(), nil
}

func (service *serviceApp) FirstDevice(ctx context.Context) (response domainApp.DevicesResponse, err error) {
	devices, err := service.FetchDevices(ctx)
	if err != nil {
		return response, err
	}
	if len(devices) == 0 {
		return response, fmt.Errorf("no devices available")
	}
	return devices[0], nil
}

func (service *serviceApp) FetchDevices(_ context.Context) (response []domainApp.DevicesResponse, err error) {
	if service.deviceManager == nil {
		return response, fmt.Errorf("device manager not initialized")
	}

	for _, inst := range service.deviceManager.ListDevices() {
		inst.UpdateStateFromClient()
		name := inst.DisplayName()
		if name == "" {
			name = inst.PhoneNumber()
		}

		response = append(response, domainApp.DevicesResponse{
			Name:   name,
			Device: inst.ID(),
			JID:    inst.JID(),
		})
	}

	return response, nil
}

func (service *serviceApp) ensureClient(ctx context.Context, deviceID string) (*whatsapp.DeviceInstance, *whatsmeow.Client, error) {
	if deviceID == "" {
		return nil, nil, fmt.Errorf("device id is required")
	}

	if service.deviceManager == nil {
		return nil, nil, fmt.Errorf("device manager not initialized")
	}

	instance, err := service.deviceManager.EnsureClient(ctx, deviceID)
	if err != nil {
		return nil, nil, err
	}

	client := instance.GetClient()
	if client == nil {
		return instance, nil, pkgError.ErrWaCLI
	}

	return instance, client, nil
}

// lockLogin serializes login flows per device. Login swaps an unpaired device's
// client, which must not happen while an overlapping login is still using it.
func (service *serviceApp) lockLogin(ctx context.Context, deviceID string) (unlock func(), err error) {
	value, _ := service.loginLocks.LoadOrStore(deviceID, make(chan struct{}, 1))
	lock := value.(chan struct{})
	select {
	case lock <- struct{}{}:
	case <-ctx.Done():
		return nil, ctx.Err()
	}
	// select picks randomly when both cases are ready; don't run a cancelled request.
	if err := ctx.Err(); err != nil {
		<-lock
		return nil, err
	}
	return func() { <-lock }, nil
}