Give the WhatsApp group names their own type

[onechat] / whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 20143a9fee0c6727776e4985ed0051ebeb72c595..929ae5dd5785d20be1d6719adb7d63ff852ba7bb 100644 (file)
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -1,7 +1,10 @@
 package main
 
 import (
 package main
 
 import (

+       "cmp"

        "context"
        "context"

+       "crypto/sha256"
+       "encoding/hex"

        "errors"
        "fmt"
        "log"
        "errors"
        "fmt"
        "log"


@@ -12,13 +15,18 @@ import (
        "strings"
        "sync"
        "time"
        "strings"
        "sync"
        "time"

+       "unicode"

 
        "go.mau.fi/whatsmeow"
 
        "go.mau.fi/whatsmeow"

+       "go.mau.fi/whatsmeow/proto/waE2E"

        "go.mau.fi/whatsmeow/store"
        "go.mau.fi/whatsmeow/store/sqlstore"
        "go.mau.fi/whatsmeow/types"
        "go.mau.fi/whatsmeow/types/events"
        waLog "go.mau.fi/whatsmeow/util/log"
        "go.mau.fi/whatsmeow/store"
        "go.mau.fi/whatsmeow/store/sqlstore"
        "go.mau.fi/whatsmeow/types"
        "go.mau.fi/whatsmeow/types/events"
        waLog "go.mau.fi/whatsmeow/util/log"

+       "golang.org/x/text/runes"
+       "golang.org/x/text/transform"
+       "golang.org/x/text/unicode/norm"

 
        // The session store of the library opens SQLite with this pure Go
        // driver.
 
        // The session store of the library opens SQLite with this pure Go
        // driver.


@@ -75,12 +83,33 @@ const (
        // session database or of the groups from WhatsApp.
        whatsappLookupTime = 10 * time.Second
 
        // session database or of the groups from WhatsApp.
        whatsappLookupTime = 10 * time.Second
 

-       // whatsappGroupsRefresh is the shortest time between two reads of the
-       // groups from WhatsApp for a group with no name.
-       whatsappGroupsRefresh = time.Minute
+       // whatsappCatchupLimit is the longest wait for the end of the catch-up
+       // after a connection.
+       whatsappCatchupLimit = time.Minute

 
 

-       // whatsappUnknownGroup is the name of a group whose name is not known.
-       whatsappUnknownGroup = "A group with no known name"
+       // whatsappFindMatches is the most matches of whatsapp_find.
+       whatsappFindMatches = 20
+
+       // whatsappNotLinked is the answer of a WhatsApp tool without a link.
+       whatsappNotLinked = "WhatsApp is not linked. Tell the user to run /whatsapp pair PHONE in the terminal or in Telegram."
+
+       // whatsappSendTime is the longest time of a send.
+       whatsappSendTime = 30 * time.Second
+
+       // whatsappSendBytes is the most bytes of the text of a send.
+       whatsappSendBytes = 65536
+
+       // whatsappSendIDBytes is the most bytes of the ID of a send.
+       whatsappSendIDBytes = 100
+
+       // The states of a send record.
+       whatsappSending = "sending"
+       whatsappSent    = "sent"
+       whatsappFailed  = "failed"
+
+       // whatsappNamesNotReady is the answer of whatsapp_find before the names
+       // arrive from the phone.
+       whatsappNamesNotReady = "The names of the contacts and groups have not arrived from the phone yet. They come some minutes after the link. Try again later."

 )
 
 // WhatsAppClient is the part of the WhatsApp client that the daemon uses. The
 )
 
 // WhatsAppClient is the part of the WhatsApp client that the daemon uses. The


@@ -93,6 +122,8 @@ type WhatsAppClient interface {
        PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error)
        Logout(ctx context.Context) error
        GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error)
        PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error)
        Logout(ctx context.Context) error
        GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error)

+       GenerateMessageID() types.MessageID
+       SendMessage(ctx context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error)

 }
 
 // openWhatsApp opens the WhatsApp session in the data directory dir. Without
 }
 
 // openWhatsApp opens the WhatsApp session in the data directory dir. Without


@@ -102,20 +133,21 @@ type WhatsAppClient interface {
 // the client of a device with its event handler.
 func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *log.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) {
        w := &WhatsApp{
 // the client of a device with its event handler.
 func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *log.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) {
        w := &WhatsApp{

-               dir:         filepath.Join(dir, whatsappDirName),
-               clock:       clock,
-               logger:      logger,
-               newClient:   newClient,
-               noticeDelay: whatsappNoticeDelay,
-               requests:    make(chan WhatsAppRequest, whatsappRequests),
-               logouts:     make(chan struct{}, 1),
-               wake:        make(chan struct{}, 1),
-               failures:    make(chan error, 1),
-               groupNames:  make(map[string]string),
+               dir:          filepath.Join(dir, whatsappDirName),
+               clock:        clock,
+               logger:       logger,
+               newClient:    newClient,
+               noticeDelay:  whatsappNoticeDelay,
+               catchupLimit: whatsappCatchupLimit,
+               requests:     make(chan WhatsAppRequest, whatsappRequests),
+               logouts:      make(chan struct{}, 1),
+               wake:         make(chan struct{}, 1),
+               failures:     make(chan error, 1),
+               groups:       newWhatsAppGroups(logger),

        }
 
        var err error
        }
 
        var err error

-       w.batches, err = openWhatsAppBatches(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)
+       w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)

        if err != nil {
                return nil, err
        }
        if err != nil {
                return nil, err
        }


@@ -140,6 +172,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 
        if w.device.ID != nil {
                w.linked = true
 
        if w.device.ID != nil {
                w.linked = true

+               w.catchingUp = true

                w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User)
        }
 
                w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User)
        }
 


@@ -159,13 +192,20 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 // client, and the state of the connection, which the event handler of the
 // library changes from its own goroutines.
 //
 // client, and the state of the connection, which the event handler of the
 // library changes from its own goroutines.
 //

-// The text messages go into batches, one chat at a time, as WhatsAppBatches
-// says. Run logs each closed batch as a work message that starts with
-// [WhatsApp], and a batch that needs the user wakes the turn loop. The event
-// handler acknowledges a message only after the state file holds it, so the
-// servers send again a message that a crash lost. A batch leaves the state file
-// only after its work message is durable in the log. A crash between the two
-// makes the batch repeat once.
+// The text messages go into batches, one chat at a time, as WhatsAppState says.
+// Run logs each closed batch as a work message that starts with [WhatsApp], and
+// a batch that needs the user wakes the turn loop.
+//
+// After each connection, the servers send the messages that came while the
+// daemon was away, and then OfflineSyncCompleted. Until then, or until
+// catchupLimit passes, the closed batches wait in the state file. At the end of
+// the catch-up, Run closes all batches, logs them, and wakes the turn loop
+// once, so the whole catch-up gives one turn and not one turn for each chat.
+// The batches of the state file at the start wait for the first catch-up in the
+// same way. The event handler acknowledges a message only after the state file
+// holds it, so the servers send again a message that a crash lost. A batch
+// leaves the state file only after its work message is durable in the log. A
+// crash between the two makes the batch repeat once.

 //
 // The library logs nothing, because its log lines hold the ID of the own
 // account, which is the phone number of the user. The own number and the own
 //
 // The library logs nothing, because its log lines hold the ID of the own
 // account, which is the phone number of the user. The own number and the own


@@ -175,16 +215,18 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 // log, and those of private chats hold phone numbers, because the agent needs
 // them to send.
 type WhatsApp struct {
 // log, and those of private chats hold phone numbers, because the agent needs
 // them to send.
 type WhatsApp struct {

-       dir         string
-       clock       func() time.Time
-       logger      *log.Logger
-       newClient   func(device *store.Device, handle func(event any) bool) WhatsAppClient
-       noticeDelay time.Duration
-       requests    chan WhatsAppRequest
-       logouts     chan struct{}
-       wake        chan struct{}
-       failures    chan error
-       batches     *WhatsAppBatches
+       dir          string
+       clock        func() time.Time
+       logger       *log.Logger
+       newClient    func(device *store.Device, handle func(event any) bool) WhatsAppClient
+       noticeDelay  time.Duration
+       catchupLimit time.Duration
+       requests     chan WhatsAppRequest
+       logouts      chan struct{}
+       wake         chan struct{}
+       failures     chan error
+       state        *WhatsAppState
+       groups       *WhatsAppGroups

 
        mutex          sync.Mutex
        container      *sqlstore.Container
 
        mutex          sync.Mutex
        container      *sqlstore.Container


@@ -200,8 +242,10 @@ type WhatsApp struct {
        noticed        bool
        timer          *time.Timer
        closed         bool
        noticed        bool
        timer          *time.Timer
        closed         bool

-       groupNames     map[string]string
-       groupsAt       time.Time
+       catchingUp     bool
+       caughtUp       bool
+       catchups       int
+       catchupTimer   *time.Timer

 }
 
 // Run connects a linked device, logs the closed batches in l, runs the pair and
 }
 
 // Run connects a linked device, logs the closed batches in l, runs the pair and


@@ -230,13 +274,13 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err
        }()
 
        for {
        }()
 
        for {

-               err := w.deliver(ctx, l)
+               err := w.deliver(ctx, l, false)

                if err != nil {
                        return err
                }
 
                var due <-chan time.Time
                if err != nil {
                        return err
                }
 
                var due <-chan time.Time

-               wait, open := w.batches.Wait(time.Now())
+               wait, open := w.state.Wait(time.Now())

                if open {
                        due = time.After(wait)
                }
                if open {
                        due = time.After(wait)
                }


@@ -272,7 +316,7 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err
                                pairing.Go(func() {
                                        defer cancelPair()
 
                                pairing.Go(func() {
                                        defer cancelPair()
 

-                                       w.pair(pairCtx, l, request.phone, request.answer)
+                                       w.pair(pairCtx, ctx, l, request.phone, request.answer)

                                })
                        }
                }
                                })
                        }
                }


@@ -385,6 +429,21 @@ func (w *WhatsApp) isLinked() bool {
        return w.linked
 }
 
        return w.linked
 }
 

+// link returns a copy of the link of the device: whether it is linked, the
+// device, the client, whether it is connected, and the own IDs.
+func (w *WhatsApp) link() WhatsAppLink {
+       w.mutex.Lock()
+       defer w.mutex.Unlock()
+
+       return WhatsAppLink{
+               linked:    w.linked,
+               device:    w.device,
+               client:    w.client,
+               connected: w.connected,
+               own:       slices.Clone(w.own),
+       }
+}
+

 // connect makes the client of the linked device and connects it.
 func (w *WhatsApp) connect(ctx context.Context) {
        w.mutex.Lock()
 // connect makes the client of the linked device and connects it.
 func (w *WhatsApp) connect(ctx context.Context) {
        w.mutex.Lock()


@@ -406,6 +465,10 @@ func (w *WhatsApp) close() {
                w.timer.Stop()
        }
 
                w.timer.Stop()
        }
 

+       if w.catchupTimer != nil {
+               w.catchupTimer.Stop()
+       }
+

        client := w.client
        w.client = nil
        w.mutex.Unlock()
        client := w.client
        w.client = nil
        w.mutex.Unlock()


@@ -422,7 +485,7 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
                return nil
        }
 
                return nil
        }
 

-       err := w.deliverAll(ctx, l)
+       err := w.deliver(ctx, l, true)

        if err != nil {
                return err
        }
        if err != nil {
                return err
        }


@@ -458,7 +521,7 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
                return nil
        }
 
                return nil
        }
 

-       err := w.deliverAll(ctx, l)
+       err := w.deliver(ctx, l, true)

        if err != nil {
                return err
        }
        if err != nil {
                return err
        }


@@ -493,21 +556,39 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 }
 
 // deliver logs the closed batches in l in order, each as a work message of
 }
 
 // deliver logs the closed batches in l in order, each as a work message of

-// whatsappSource that wakes the loop when the batch starts a turn. A batch
-// leaves the state file after its message is durable in the log. A group with
-// no name gets its name from WhatsApp first.
-func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop) error {
-       _, err := w.batches.CloseDue(time.Now())
+// whatsappSource, and wakes the loop once with the batches that start a turn. A
+// batch leaves the state file after its message is durable in the log. A group
+// with no name gets its name from WhatsApp first. During a catch-up it logs
+// nothing, and at its end it closes all batches first. With all, it closes and
+// logs all batches also during a catch-up.
+func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop, all bool) error {
+       w.mutex.Lock()
+       catchingUp := w.catchingUp
+       caughtUp := w.caughtUp
+       w.caughtUp = false
+       w.mutex.Unlock()
+
+       var err error
+       switch {
+       case all || caughtUp:
+               err = w.state.CloseAll()
+       case catchingUp:
+               return nil
+       default:
+               _, err = w.state.CloseDue(time.Now())
+       }
+

        if err != nil {
                return err
        }
 
        if err != nil {
                return err
        }
 

-       for _, batch := range w.batches.Closed() {
+       var turns []Message
+       for _, batch := range w.state.Closed() {

                if batch.Chat.Group && batch.Chat.Name == "" {
                if batch.Chat.Group && batch.Chat.Name == "" {

-                       batch.Chat.Name = w.groupName(ctx, batch.Chat.ID)
+                       batch.Chat.Name = w.groups.name(ctx, w.link(), batch.Chat.ID)

                }
 
                }
 

-               _, err = l.Work(whatsappSource, batch.Text(w.clock().Location()), "", batch.Turn())
+               message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "")

                if err != nil {
                        return fmt.Errorf("log a WhatsApp batch: %w", err)
                }
                if err != nil {
                        return fmt.Errorf("log a WhatsApp batch: %w", err)
                }


@@ -524,65 +605,93 @@ func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop) error {
                        return fmt.Errorf("log a WhatsApp batch: %w", err)
                }
 
                        return fmt.Errorf("log a WhatsApp batch: %w", err)
                }
 

-               err = w.batches.Remove(batch.Number)
+               err = w.state.Remove(batch.Number)

                if err != nil {
                        return err
                }
                if err != nil {
                        return err
                }

-       }
-
-       return nil
-}

 
 

-// deliverAll closes every open batch and logs all of them.
-func (w *WhatsApp) deliverAll(ctx context.Context, l *TurnLoop) error {
-       err := w.batches.CloseAll()
-       if err != nil {
-               return err
+               if batch.Turn() {
+                       turns = append(turns, message)
+               }

        }
 
        }
 

-       return w.deliver(ctx, l)
+       l.Wake(turns...)
+
+       return nil

 }
 
 }
 

-// groupName returns the name of the group id, or whatsappUnknownGroup. A group
-// that is not in the names of the groups reads the groups from WhatsApp again,
-// at most once in whatsappGroupsRefresh.
-func (w *WhatsApp) groupName(ctx context.Context, id string) string {
+// Find returns the contacts and the groups whose name contains name, with no
+// regard to case and accents, as lines "ID | name | contact" or "ID | name |
+// group", sorted by name. It gives at most whatsappFindMatches lines and the
+// number of the others. The contacts come from the session database, and the
+// groups from WhatsApp, read again after whatsappGroupsAge. When the groups
+// cannot be read and none are known, the answer says so. Before the names
+// arrive from the phone, it says that they are not ready.
+func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {

        w.mutex.Lock()
        w.mutex.Lock()

-       name, found := w.groupNames[id]
-       client := w.client
-       fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
+       linked := w.linked
+       device := w.device
+       own := slices.Clone(w.own)

        w.mutex.Unlock()
 
        w.mutex.Unlock()
 

-       if found {
-               return name
-       }
+       stale := w.groups.stale()

 
 

-       if client == nil || fresh {
-               return whatsappUnknownGroup
+       if !linked {
+               return whatsappNotLinked, nil

        }
 
        }
 

-       ctx, cancel := context.WithTimeout(ctx, whatsappLookupTime)
-       defer cancel()
+       query := whatsappFold(name)
+       if query == "" {
+               return "", errors.New("name is empty: give a part of the name of the contact or the group")
+       }

 
 

-       groups, err := client.GetJoinedGroups(ctx)
+       contacts, err := device.Contacts.GetAllContacts(ctx)

        if err != nil {
        if err != nil {

-               w.logger.Printf("read the groups: %s", w.redact(err.Error()))
+               return "", fmt.Errorf("read the contacts: %s", w.redact(err.Error()))

        }
 
        }
 

-       w.mutex.Lock()
-       defer w.mutex.Unlock()
+       read := !stale || w.groups.read(ctx, w.link())
+       groups := w.groups.all()
+
+       if len(contacts) == 0 && len(groups) == 0 {
+               if !read {
+                       return "The names are not known yet, and WhatsApp is disconnected, so the groups cannot be read. Try again later.", nil
+               }
+
+               return whatsappNamesNotReady, nil
+       }
+
+       var matches []WhatsAppMatch
+       for jid, contact := range contacts {
+               names := []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName}
+               shown := slices.IndexFunc(names, func(name string) bool {
+                       return name != ""
+               })

 
 

-       w.groupsAt = time.Now()
-       for _, group := range groups {
-               w.groupNames[group.JID.String()] = group.Name
+               if slices.Contains(own, jid.User) || shown < 0 || !slices.ContainsFunc(names, func(name string) bool {
+                       return strings.Contains(whatsappFold(name), query)
+               }) {
+                       continue
+               }
+
+               matches = append(matches, WhatsAppMatch{
+                       id:   jid.ToNonAD().String(),
+                       name: names[shown],
+                       kind: "contact",
+               })

        }
 
        }
 

-       name, found = w.groupNames[id]
-       if !found || name == "" {
-               return whatsappUnknownGroup
+       for id, group := range groups {
+               if strings.Contains(whatsappFold(group), query) {
+                       matches = append(matches, WhatsAppMatch{
+                               id:   id,
+                               name: group,
+                               kind: "group",
+                       })
+               }

        }
 
        }
 

-       return name
+       return whatsappFindAnswer(name, matches, read || len(groups) > 0), nil

 }
 
 // removeSession ends the connection, closes the session database, and deletes
 }
 
 // removeSession ends the connection, closes the session database, and deletes


@@ -594,6 +703,7 @@ func (w *WhatsApp) removeSession() error {
        w.linked = false
        w.own = nil
        w.connected = false
        w.linked = false
        w.own = nil
        w.connected = false

+       w.catchingUp = false

        if w.timer != nil {
                w.timer.Stop()
        }
        if w.timer != nil {
                w.timer.Stop()
        }


@@ -628,7 +738,13 @@ func (w *WhatsApp) removeSession() error {
 // number, an expired code, or a failure. A pairing that a new one ends gives no
 // answer. A link notes "WhatsApp is linked." in the log of l, with no number.
 // The client of a pairing that does not link is disconnected.
 // number, an expired code, or a failure. A pairing that a new one ends gives no
 // answer. A link notes "WhatsApp is linked." in the log of l, with no number.
 // The client of a pairing that does not link is disconnected.

-func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer func(text string)) {
+//
+// ctx limits the pairing, but the connection uses runCtx, the context of Run.
+// The library keeps the context of the connection for its keep-alive, its event
+// handler, and its reconnections, and after the link the server ends the stream
+// and the library connects again. With ctx, the end of the pairing would stop
+// that reconnection, and the linked device would never connect.
+func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, answer func(text string)) {

        device, err := w.newDevice(ctx)
        if err != nil {
                answer("The pairing failed: " + err.Error())
        device, err := w.newDevice(ctx)
        if err != nil {
                answer("The pairing failed: " + err.Error())


@@ -645,7 +761,7 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
 
        qr, err := client.GetQRChannel(ctx)
        if err == nil {
 
        qr, err := client.GetQRChannel(ctx)
        if err == nil {

-               err = client.ConnectContext(ctx)
+               err = client.ConnectContext(runCtx)

        }
 
        if err != nil {
        }
 
        if err != nil {


@@ -759,30 +875,44 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 
 // handle takes one event of the library and tells if it was handled. A message
 // goes to receive. The names of the groups follow the events of the groups. A
 
 // handle takes one event of the library and tells if it was handled. A message
 // goes to receive. The names of the groups follow the events of the groups. A

-// disconnection keeps the time of its start while the library tries again.
-// After noticeDelay of a disconnection, all clients get one notice, and they
-// get one more when the connection comes back. A disconnection that the library
-// does not try again gives a notice at once.
+// connection starts a catch-up, which ends at OfflineSyncCompleted or after
+// catchupLimit. A disconnection keeps the time of its start while the library
+// tries again. After noticeDelay of a disconnection, all clients get one
+// notice, and they get one more when the connection comes back. A disconnection
+// that the library does not try again gives a notice at once.

 func (w *WhatsApp) handle(event any) bool {
 func (w *WhatsApp) handle(event any) bool {

-       message, isMessage := event.(*events.Message)
-       if isMessage {
-               return w.receive(message)
-       }
-
-       var notice string
-       w.mutex.Lock()

        switch event := event.(type) {
        switch event := event.(type) {

+       case *events.Message:
+               return w.receive(event)

        case *events.GroupInfo:
                if event.Name != nil {
        case *events.GroupInfo:
                if event.Name != nil {

-                       w.groupNames[event.JID.String()] = event.Name.Name
+                       w.groups.set(event.JID.String(), event.Name.Name)

                }
                }

+
+               return true

        case *events.JoinedGroup:
        case *events.JoinedGroup:

-               w.groupNames[event.JID.String()] = event.Name
+               w.groups.set(event.JID.String(), event.Name)
+               return true
+       }
+
+       var notice string
+       w.mutex.Lock()
+       switch event := event.(type) {

        case *events.PairSuccess:
                w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
        case *events.Connected:
                w.connected = true
                w.connectedAt = w.clock()
        case *events.PairSuccess:
                w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
        case *events.Connected:
                w.connected = true
                w.connectedAt = w.clock()

+               w.catchingUp = true
+               w.catchups++
+               catchups := w.catchups
+               if w.catchupTimer != nil {
+                       w.catchupTimer.Stop()
+               }
+
+               w.catchupTimer = time.AfterFunc(w.catchupLimit, func() {
+                       w.caughtUpBy(catchups)
+               })

                if w.timer != nil {
                        w.timer.Stop()
                }
                if w.timer != nil {
                        w.timer.Stop()
                }


@@ -802,6 +932,8 @@ func (w *WhatsApp) handle(event any) bool {
                }
 
                w.connected = false
                }
 
                w.connected = false

+       case *events.OfflineSyncCompleted:
+               w.endCatchup()

        case *events.LoggedOut:
                select {
                case w.logouts <- struct{}{}:
        case *events.LoggedOut:
                select {
                case w.logouts <- struct{}{}:


@@ -831,12 +963,17 @@ func (w *WhatsApp) receive(event *events.Message) bool {
        ctx, cancel := context.WithTimeout(context.Background(), whatsappLookupTime)
        defer cancel()
 
        ctx, cancel := context.WithTimeout(context.Background(), whatsappLookupTime)
        defer cancel()
 

-       chat, message, found := w.message(ctx, event)
+       w.mutex.Lock()
+       device := w.device
+       own := slices.Clone(w.own)
+       w.mutex.Unlock()
+
+       chat, message, found := whatsappMessage(ctx, device, own, event)

        if !found {
                return true
        }
 
        if !found {
                return true
        }
 

-       _, err := w.batches.Add(chat, message, time.Now())
+       _, err := w.state.Add(chat, message, time.Now())

        if err != nil {
                select {
                case w.failures <- err:
        if err != nil {
                select {
                case w.failures <- err:


@@ -854,96 +991,34 @@ func (w *WhatsApp) receive(event *events.Message) bool {
        return true
 }
 
        return true
 }
 

-// message returns the chat and the batch message of event, or false when the
-// batches do not take it. They take the text of a private chat or a group, from
-// another person or from the user. They do not take media, reactions, edits,
-// deletions, view-once and disappearing messages, old history, status
-// broadcasts, channels, and the chat of the user with itself.
-//
-// A mention of the user becomes @you, another mention @NAME when the name is
-// known, and the own number and LID become OWN, so that they never go to the
-// log.
-func (w *WhatsApp) message(ctx context.Context, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
+// caughtUpBy ends the catch-up of the connection with the number catchups, when
+// no later connection started a new one.
+func (w *WhatsApp) caughtUpBy(catchups int) {

        w.mutex.Lock()
        w.mutex.Lock()

-       device := w.device
-       own := slices.Clone(w.own)
-       w.mutex.Unlock()
+       defer w.mutex.Unlock()

 
 

-       info := event.Info
-       chatJID := info.Chat.ToNonAD()
-       switch {
-       case device == nil:
-       case event.IsEdit, info.Edit != "", event.IsEphemeral, event.IsViewOnce, event.SourceWebMsg != nil:
-       case chatJID.Server != types.DefaultUserServer && chatJID.Server != types.HiddenUserServer && chatJID.Server != types.GroupServer:
-       case slices.Contains(own, chatJID.User):
-       default:
-               return w.text(ctx, device, own, event)
+       if w.catchups == catchups {
+               w.endCatchup()

        }
        }

-
-       return WhatsAppChat{}, WhatsAppMessage{}, false

 }
 
 }
 

-// text returns the chat and the batch message of event, a message that the
-// batches take when it has text.
-func (w *WhatsApp) text(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
-       info := event.Info
-       text := event.Message.GetConversation()
-       extended := event.Message.GetExtendedTextMessage()
-       if text == "" {
-               text = extended.GetText()
-       }
-
-       if strings.TrimSpace(text) == "" {
-               return WhatsAppChat{}, WhatsAppMessage{}, false
-       }
-
-       contextInfo := extended.GetContextInfo()
-       message := WhatsAppMessage{
-               ID:   info.ID,
-               Time: info.Timestamp,
-               Mine: info.IsFromMe,
-       }
-
-       if !message.Mine {
-               message.Sender = whatsappContactName(ctx, device, info.Sender, info.PushName)
-       }
-
-       for _, mentioned := range contextInfo.GetMentionedJID() {
-               jid, err := types.ParseJID(mentioned)
-               switch {
-               case err != nil:
-               case slices.Contains(own, jid.User):
-                       message.Mention = true
-                       text = strings.ReplaceAll(text, "@"+jid.User, "@you")
-               default:
-                       text = strings.ReplaceAll(text, "@"+jid.User, "@"+whatsappContactName(ctx, device, jid, ""))
-               }
-       }
-
-       participant, err := types.ParseJID(contextInfo.GetParticipant())
-       message.Reply = err == nil && slices.Contains(own, participant.User)
-
-       for _, id := range own {
-               text = strings.ReplaceAll(text, id, "OWN")
+// endCatchup ends a running catch-up and wakes Run, which logs all batches. The
+// caller holds the mutex.
+func (w *WhatsApp) endCatchup() {
+       if !w.catchingUp {
+               return

        }
 
        }
 

-       message.Text = text
-       chatJID := info.Chat.ToNonAD()
-       chat := WhatsAppChat{
-               ID:    chatJID.String(),
-               Group: chatJID.Server == types.GroupServer,
+       w.catchingUp = false
+       w.caughtUp = true
+       if w.catchupTimer != nil {
+               w.catchupTimer.Stop()

        }
 
        }
 

-       if !chat.Group {
-               push := info.PushName
-               if message.Mine {
-                       push = ""
-               }
-
-               chat.Name = whatsappContactName(ctx, device, chatJID, push)
+       select {
+       case w.wake <- struct{}{}:
+       default:

        }
        }

-
-       return chat, message, true

 }
 
 // disconnectedLong gives the notice of a long disconnection, unless the
 }
 
 // disconnectedLong gives the notice of a long disconnection, unless the


@@ -983,11 +1058,106 @@ func (w *WhatsApp) redact(text string) string {
        w.mutex.Lock()
        defer w.mutex.Unlock()
 
        w.mutex.Lock()
        defer w.mutex.Unlock()
 

-       for _, id := range w.own {
-               text = strings.ReplaceAll(text, id, "OWN")
+       return whatsappRedact(w.own, text)
+}
+
+// Send sends text to chat, the ID of a private chat or a group, and returns the
+// answer of the tool. id names the send: a call with an id that has a record
+// gives the answer of the record and sends nothing, and the same id with
+// another chat or text is an error. The record "sending" is durable before the
+// send, so a stop of the daemon during the send gives an answer that the result
+// is unknown, and not a second send. A disconnected WhatsApp sends nothing and
+// makes no record.
+func (w *WhatsApp) Send(ctx context.Context, id, chat, text string) (string, error) {
+       w.mutex.Lock()
+       linked := w.linked
+       device := w.device
+       client := w.client
+       connected := w.connected
+       own := slices.Clone(w.own)
+       w.mutex.Unlock()
+
+       if !linked {
+               return whatsappNotLinked, nil

        }
 
        }
 

-       return text
+       jid, err := whatsappSendCheck(id, chat, text, own)
+       if err != nil {
+               return "", err
+       }
+
+       digest := sha256.Sum256([]byte(text))
+       record := WhatsAppSend{
+               ID:     id,
+               Chat:   chat,
+               Digest: hex.EncodeToString(digest[:]),
+               State:  whatsappSending,
+               Time:   w.clock(),
+       }
+
+       held, found := w.state.Send(id)
+       switch {
+       case found && (held.Chat != record.Chat || held.Digest != record.Digest):
+               return "", fmt.Errorf("the id %s belongs to another message: give a new id for each message", id)
+       case found && held.State == whatsappSending:
+               return "The send with this id started, but its result is unknown, because the daemon stopped during it. Ask the user to look at the chat in WhatsApp before you send the message again with a new id.", nil
+       case found:
+               return held.Answer + " This is the answer of the first call with this id: nothing was sent again.", nil
+       case client == nil || !connected:
+               return "", errors.New("WhatsApp is disconnected, so nothing was sent: try again later")
+       }
+
+       record.MessageID = client.GenerateMessageID()
+       err = w.state.PutSend(record)
+       if err != nil {
+               return "", err
+       }
+
+       sendCtx, cancel := context.WithTimeout(ctx, whatsappSendTime)
+       defer cancel()
+
+       response, err := client.SendMessage(sendCtx, jid, &waE2E.Message{
+               Conversation: new(text),
+       }, whatsmeow.SendRequestExtra{
+               ID: record.MessageID,
+       })
+
+       record.State = whatsappSent
+       if err != nil {
+               record.State = whatsappFailed
+               record.Answer = "The send failed: " + w.redact(err.Error()) + "."
+       } else {
+               name := w.groups.name(ctx, w.link(), jid.String())
+               if jid.Server != types.GroupServer {
+                       name = whatsappContactName(ctx, device, jid, "")
+               }
+
+               record.Answer = "Sent to " + name + " at " + response.Timestamp.In(w.clock().Location()).Format("15:04") + "."
+       }
+
+       err = w.state.PutSend(record)
+       if err != nil {
+               return "", err
+       }
+
+       return record.Answer, nil
+}
+
+// WhatsAppMatch is one contact or group of Find.
+type WhatsAppMatch struct {
+       id   string
+       name string
+       kind string
+}
+
+// WhatsAppLink is a copy of the link of the device at one time, for the parts
+// of WhatsApp that do not own it: the groups, the batches, find, and send.
+type WhatsAppLink struct {
+       linked    bool
+       device    *store.Device
+       client    WhatsAppClient
+       connected bool
+       own       []string

 }
 
 // WhatsAppRequest is a pair or unlink command for Run, with the function that
 }
 
 // WhatsAppRequest is a pair or unlink command for Run, with the function that


@@ -1013,6 +1183,90 @@ func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsA
        return client
 }
 
        return client
 }
 

+// whatsappMessage returns the chat and the batch message of event, or false
+// when the batches do not take it. device is the linked device, and own holds
+// the own IDs. The batches take the text of a private chat or a group, from
+// another person or from the user. They do not take media, reactions, edits,
+// deletions, view-once and disappearing messages, old history, status
+// broadcasts, channels, and the chat of the user with itself.
+//
+// A mention of the user becomes @you, another mention @NAME when the name is
+// known, and the own number and LID become OWN, so that they never go to the
+// log.
+func whatsappMessage(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
+       info := event.Info
+       chatJID := info.Chat.ToNonAD()
+       switch {
+       case device == nil:
+       case event.IsEdit, info.Edit != "", event.IsEphemeral, event.IsViewOnce, event.SourceWebMsg != nil:
+       case chatJID.Server != types.DefaultUserServer && chatJID.Server != types.HiddenUserServer && chatJID.Server != types.GroupServer:
+       case slices.Contains(own, chatJID.User):
+       default:
+               return whatsappText(ctx, device, own, event)
+       }
+
+       return WhatsAppChat{}, WhatsAppMessage{}, false
+}
+
+// whatsappText returns the chat and the batch message of event, a message that
+// the batches take when it has text.
+func whatsappText(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
+       info := event.Info
+       text := event.Message.GetConversation()
+       extended := event.Message.GetExtendedTextMessage()
+       if text == "" {
+               text = extended.GetText()
+       }
+
+       if strings.TrimSpace(text) == "" {
+               return WhatsAppChat{}, WhatsAppMessage{}, false
+       }
+
+       contextInfo := extended.GetContextInfo()
+       message := WhatsAppMessage{
+               ID:   info.ID,
+               Time: info.Timestamp,
+               Mine: info.IsFromMe,
+       }
+
+       if !message.Mine {
+               message.Sender = whatsappContactName(ctx, device, info.Sender, info.PushName)
+       }
+
+       for _, mentioned := range contextInfo.GetMentionedJID() {
+               jid, err := types.ParseJID(mentioned)
+               switch {
+               case err != nil:
+               case slices.Contains(own, jid.User):
+                       message.Mention = true
+                       text = strings.ReplaceAll(text, "@"+jid.User, "@you")
+               default:
+                       text = strings.ReplaceAll(text, "@"+jid.User, "@"+whatsappContactName(ctx, device, jid, ""))
+               }
+       }
+
+       participant, err := types.ParseJID(contextInfo.GetParticipant())
+       message.Reply = err == nil && slices.Contains(own, participant.User)
+
+       message.Text = whatsappRedact(own, text)
+       chatJID := info.Chat.ToNonAD()
+       chat := WhatsAppChat{
+               ID:    chatJID.String(),
+               Group: chatJID.Server == types.GroupServer,
+       }
+
+       if !chat.Group {
+               push := info.PushName
+               if message.Mine {
+                       push = ""
+               }
+
+               chat.Name = whatsappContactName(ctx, device, chatJID, push)
+       }
+
+       return chat, message, true
+}
+

 // whatsappContactName returns the name of the person jid: the full name, the
 // first name, the business name, or the push name of the contact in the session
 // of device, then push, the push name of a message, then the phone number. A
 // whatsappContactName returns the name of the person jid: the full name, the
 // first name, the business name, or the push name of the contact in the session
 // of device, then push, the push name of a message, then the phone number. A


@@ -1055,6 +1309,65 @@ func whatsappContactName(ctx context.Context, device *store.Device, jid types.JI
        }
 }
 
        }
 }
 

+// whatsappFold returns text in lower case with no accents and no space at its
+// ends, so that names match with no regard to case and accents.
+func whatsappFold(text string) string {
+       folded, _, err := transform.String(transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC), text)
+       if err != nil {
+               folded = text
+       }
+
+       return strings.ToLower(strings.TrimSpace(folded))
+}
+
+// whatsappFindAnswer returns the answer of Find for name with matches. Without
+// groups, the answer says that it has no groups.
+func whatsappFindAnswer(name string, matches []WhatsAppMatch, groups bool) string {
+       slices.SortFunc(matches, func(a, b WhatsAppMatch) int {
+               return cmp.Or(strings.Compare(whatsappFold(a.name), whatsappFold(b.name)), strings.Compare(a.id, b.id))
+       })
+
+       var lines []string
+       for _, match := range matches[:min(len(matches), whatsappFindMatches)] {
+               lines = append(lines, match.id+" | "+match.name+" | "+match.kind)
+       }
+
+       if len(matches) == 0 {
+               lines = append(lines, "No contact or group has a name with \""+name+"\".")
+       }
+
+       if len(matches) > whatsappFindMatches {
+               lines = append(lines, fmt.Sprintf("%d more: give a longer part of the name.", len(matches)-whatsappFindMatches))
+       }
+
+       if !groups {
+               lines = append(lines, "The groups are not in this answer, because WhatsApp is disconnected.")
+       }
+
+       return strings.Join(lines, "\n")
+}
+
+// whatsappSendCheck returns the JID of chat, and an error when id, chat, or
+// text cannot go to a send. The chat is a private chat or a group, and not the
+// chat of the user with itself.
+func whatsappSendCheck(id, chat, text string, own []string) (types.JID, error) {
+       jid, err := types.ParseJID(chat)
+       switch {
+       case strings.TrimSpace(id) == "" || len(id) > whatsappSendIDBytes:
+               return types.EmptyJID, fmt.Errorf("the id must have 1 to %d bytes", whatsappSendIDBytes)
+       case strings.TrimSpace(text) == "" || len(text) > whatsappSendBytes:
+               return types.EmptyJID, fmt.Errorf("the text must have 1 to %d bytes", whatsappSendBytes)
+       case err != nil || jid.User == "" || jid != jid.ToNonAD() || jid.String() != chat:
+               return types.EmptyJID, fmt.Errorf("%q is not the ID of a WhatsApp chat: find the ID with whatsapp_find", chat)
+       case jid.Server != types.DefaultUserServer && jid.Server != types.HiddenUserServer && jid.Server != types.GroupServer:
+               return types.EmptyJID, fmt.Errorf("%q is not a private chat or a group", chat)
+       case slices.Contains(own, jid.User):
+               return types.EmptyJID, errors.New("this is the chat of the user with itself: send to another chat")
+       }
+
+       return jid, nil
+}
+

 // whatsappOwnIDs returns the own number and the own LID that are not empty.
 func whatsappOwnIDs(ids ...string) []string {
        var own []string
 // whatsappOwnIDs returns the own number and the own LID that are not empty.
 func whatsappOwnIDs(ids ...string) []string {
        var own []string


@@ -1067,6 +1380,15 @@ func whatsappOwnIDs(ids ...string) []string {
        return own
 }
 
        return own
 }
 

+// whatsappRedact replaces each of the own IDs own in text with OWN.
+func whatsappRedact(own []string, text string) string {
+       for _, id := range own {
+               text = strings.ReplaceAll(text, id, "OWN")
+       }
+
+       return text
+}
+

 // whatsappSessionAddress returns the SQLite address of the session database at
 // path, with foreign keys on, as the library needs, and a wait for a busy
 // database.
 // whatsappSessionAddress returns the SQLite address of the session database at
 // path, with foreign keys on, as the library needs, and a wait for a busy
 // database.