GOWA - WhatsApp REST API with support for UI, Multi Account, Webhooks, and MCP, and Chatwoot. Built with Golang for efficient memory use.
Go botgogolanggolang-whatsappgolang-whatsapp-apirestrest-apiwhatsappwhatsapp-apiwhatsapp-api-gowhatsapp-multi-devicewhatsapp-web-multi-device
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
}