Retry the first WhatsApp connection

[onechat] / whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 3c519e8b127c04b2bb64ddb14b89edb4d63c6bcc..e02e8c66242c1953091e1a85eeb78b691f9496a0 100644 (file)
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -8,16 +8,19 @@ import (
        "net/url"
        "os"
        "path/filepath"
        "net/url"
        "os"
        "path/filepath"

+       "slices"

        "strings"
        "sync"
        "time"
 
        "go.mau.fi/whatsmeow"
        "strings"
        "sync"
        "time"
 
        "go.mau.fi/whatsmeow"

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

        "go.mau.fi/whatsmeow/store"
        "go.mau.fi/whatsmeow/store/sqlstore"
        "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/types/events"
        waLog "go.mau.fi/whatsmeow/util/log"

-

        // The session store of the library opens SQLite with this pure Go
        // driver.
        _ "modernc.org/sqlite"
        // The session store of the library opens SQLite with this pure Go
        // driver.
        _ "modernc.org/sqlite"


@@ -36,7 +39,8 @@ const (
        // as "/whatsapp status".
        whatsappCommand = "/whatsapp"
 
        // as "/whatsapp status".
        whatsappCommand = "/whatsapp"
 

-       // whatsappUsage is the answer to a WhatsApp command that does not exist.
+       // whatsappUsage is the answer to a WhatsApp command that does not
+       // exist.

        whatsappUsage = "Use /whatsapp pair PHONE, /whatsapp status, or /whatsapp unlink. PHONE is the number of your WhatsApp account with its country code, such as +15550001111."
 
        // whatsappPairSteps tells the user what to do with the pairing code,
        whatsappUsage = "Use /whatsapp pair PHONE, /whatsapp status, or /whatsapp unlink. PHONE is the number of your WhatsApp account with its country code, such as +15550001111."
 
        // whatsappPairSteps tells the user what to do with the pairing code,


@@ -61,9 +65,23 @@ const (
        // gets a notice.
        whatsappNoticeDelay = 10 * time.Minute
 
        // gets a notice.
        whatsappNoticeDelay = 10 * time.Minute
 

+       // whatsappRetryDelay is the first wait after a failed starting
+       // connection.
+       whatsappRetryDelay = 2 * time.Second
+
+       // whatsappRetryLimit is the longest wait between starting connections.
+       whatsappRetryLimit = 5 * time.Minute
+

        // whatsappRequests is the number of pair and unlink commands that can
        // wait for Run.
        whatsappRequests = 8
        // whatsappRequests is the number of pair and unlink commands that can
        // wait for Run.
        whatsappRequests = 8

+
+       // whatsappLookupTime is the longest time of a read of the names in the
+       // session database or of the groups from WhatsApp.
+       whatsappLookupTime = 10 * time.Second
+
+       // 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."

 )
 
 // 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


@@ -75,6 +93,9 @@ type WhatsAppClient interface {
        GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error)
        PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error)
        Logout(ctx context.Context) error
        GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, 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


@@ -91,8 +112,17 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
                noticeDelay: whatsappNoticeDelay,
                requests:    make(chan WhatsAppRequest, whatsappRequests),
                logouts:     make(chan struct{}, 1),
                noticeDelay: whatsappNoticeDelay,
                requests:    make(chan WhatsAppRequest, whatsappRequests),
                logouts:     make(chan struct{}, 1),

+               groups:      newWhatsAppGroups(logger),
+       }
+
+       var err error
+       w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)
+       if err != nil {
+               return nil, err

        }
 
        }
 

+       w.inbox = newWhatsAppInbox(w.state, clock, w.groups)
+

        info, err := os.Stat(w.sessionPath())
        if errors.Is(err, os.ErrNotExist) {
                return w, nil
        info, err := os.Stat(w.sessionPath())
        if errors.Is(err, os.ErrNotExist) {
                return w, nil


@@ -113,15 +143,16 @@ 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.inbox.waitForCatchup()

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

-// WhatsApp is the link of the daemon to the WhatsApp account of the user, as
-// a linked device. The session database of the library in dir holds the keys
-// of the device. Run keeps a linked device connected, and the library connects
+// WhatsApp is the link of the daemon to the WhatsApp account of the user, as a
+// linked device. The session database of the library in dir holds the keys of
+// the device. Run keeps a linked device connected, and the library connects

 // again by itself after a network failure.
 //
 // The commands pair and unlink go to Run as requests, and Run runs one at a
 // again by itself after a network failure.
 //
 // The commands pair and unlink go to Run as requests, and Run runs one at a


@@ -132,10 +163,17 @@ 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 inbox puts the text messages into batches and logs them, and groups
+// holds the names of the groups. Both get a WhatsAppLink from link for each
+// call, so they use the current device and client.
+//

 // 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
 // LID never go to the log of the agent or to the log of the daemon: redact
 // 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
 // LID never go to the log of the agent or to the log of the daemon: redact

-// removes them from the errors.
+// removes them from the errors, and a batch shows the messages of the user as
+// You and a mention of the user as @you. The IDs of the other chats go to the
+// 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
 type WhatsApp struct {
        dir         string
        clock       func() time.Time


@@ -144,6 +182,9 @@ type WhatsApp struct {
        noticeDelay time.Duration
        requests    chan WhatsAppRequest
        logouts     chan struct{}
        noticeDelay time.Duration
        requests    chan WhatsAppRequest
        logouts     chan struct{}

+       state       *WhatsAppState
+       groups      *WhatsAppGroups
+       inbox       *WhatsAppInbox

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


@@ -153,6 +194,7 @@ type WhatsApp struct {
        own            []string
        notify         func(Event)
        connected      bool
        own            []string
        notify         func(Event)
        connected      bool

+       retrying       bool

        connectedAt    time.Time
        disconnectedAt time.Time
        disconnections int
        connectedAt    time.Time
        disconnectedAt time.Time
        disconnections int


@@ -161,18 +203,44 @@ type WhatsApp struct {
        closed         bool
 }
 
        closed         bool
 }
 

-// Run connects a linked device, runs the pair and unlink commands, and handles
-// a logout from the phone, until ctx ends. Its notes go to the log of l, and
-// notify gets the notices for all clients. A failed first connection is
-// logged, and the library tries again when the failure is one of the network.
-func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
+// Run connects a linked device, logs the closed batches in l, runs the pair and
+// unlink commands, and handles a logout from the phone, until ctx ends. Its
+// notes go to the log of l, and notify gets the notices for all clients. A
+// failed first connection starts the same outage notice as a lost connection. A
+// timer in the select retries it with a doubled wait from 2 seconds to 5
+// minutes, without a retry goroutine or a wait that blocks commands or the
+// inbox. A connection, unlink, logout, pair command, or ctx end stops retries.
+// The library owns retries after a connection opens. Run returns the error of a
+// write of the log or of the state file, which stops the daemon, because then
+// messages would be lost.
+func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error {

        w.mutex.Lock()
        w.notify = notify
        linked := w.linked
        w.mutex.Lock()
        w.notify = notify
        linked := w.linked

+       w.retrying = linked

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

-       if linked {
-               w.connect(ctx)
+       timer := time.NewTimer(whatsappRetryDelay)
+       timer.Stop()
+       defer timer.Stop()
+
+       var retry <-chan time.Time
+       delay := whatsappRetryDelay
+       connect := func() {
+               retry = nil
+               if w.connect(ctx) {
+                       timer.Reset(delay)
+                       retry = timer.C
+                       delay = min(2*delay, whatsappRetryLimit)
+               }
+       }
+
+       stopRetry := func() {
+               timer.Stop()
+               retry = nil
+               w.mutex.Lock()
+               w.retrying = false
+               w.mutex.Unlock()

        }
 
        var pairing sync.WaitGroup
        }
 
        var pairing sync.WaitGroup


@@ -183,20 +251,43 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
                w.close()
        }()
 
                w.close()
        }()
 

+       if linked {
+               connect()
+       }
+

        for {
        for {

+               err := w.inbox.deliver(ctx, l, w.link(), false)
+               if err != nil {
+                       return err
+               }
+

                select {
                case <-ctx.Done():
                select {
                case <-ctx.Done():

-                       return
+                       return nil
+               case err = <-w.inbox.failures:
+                       return err
+               case <-w.inbox.wake:
+               case <-w.inbox.due():
+               case <-retry:
+                       connect()

                case <-w.logouts:
                case <-w.logouts:

-                       w.loggedOut(l)
+                       stopRetry()
+                       err = w.loggedOut(ctx, l)
+                       if err != nil {
+                               return err
+                       }

                case request := <-w.requests:
                case request := <-w.requests:

+                       stopRetry()

                        cancel()
                        pairing.Wait()
                        cancel = func() {}
 
                        switch {
                        case request.unlink:
                        cancel()
                        pairing.Wait()
                        cancel = func() {}
 
                        switch {
                        case request.unlink:

-                               w.unlink(ctx, l, request.answer)
+                               err = w.unlink(ctx, l, request.answer)
+                               if err != nil {
+                                       return err
+                               }

                        case w.isLinked():
                                request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
                        default:
                        case w.isLinked():
                                request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
                        default:


@@ -205,7 +296,7 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
                                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)

                                })
                        }
                }
                                })
                        }
                }


@@ -248,8 +339,8 @@ func (w *WhatsApp) Command(args string, answer func(text string)) {
 }
 
 // Status returns the state of the link: not linked, linked and connected, or
 }
 
 // Status returns the state of the link: not linked, linked and connected, or

-// linked and disconnected, with the times of the connection. It never holds
-// the phone number.
+// linked and disconnected, with the times of the connection. It never holds the
+// phone number.

 func (w *WhatsApp) Status() string {
        w.mutex.Lock()
        defer w.mutex.Unlock()
 func (w *WhatsApp) Status() string {
        w.mutex.Lock()
        defer w.mutex.Unlock()


@@ -283,12 +374,23 @@ func (w *WhatsApp) Close() error {
        return err
 }
 
        return err
 }
 

+// Find returns the answer of whatsapp_find for name, as whatsappFind says.
+func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {
+       return whatsappFind(ctx, w.link(), w.groups, name)
+}
+
+// Send returns the answer of whatsapp_send for the send id of text to chat, as
+// whatsappSend says.
+func (w *WhatsApp) Send(ctx context.Context, id, chat, text string) (string, error) {
+       return whatsappSend(ctx, w.link(), w.groups, w.state, w.clock, id, chat, text)
+}
+

 func (w *WhatsApp) sessionPath() string {
        return filepath.Join(w.dir, whatsappSessionFileName)
 }
 
 func (w *WhatsApp) sessionPath() string {
        return filepath.Join(w.dir, whatsappSessionFileName)
 }
 

-// openSession opens the session database and its first device. The caller
-// holds the mutex, or no other goroutine uses w yet.
+// openSession opens the session database and its first device. The caller holds
+// the mutex, or no other goroutine uses w yet.

 func (w *WhatsApp) openSession(ctx context.Context) error {
        address, err := whatsappSessionAddress(w.sessionPath())
        if err != nil {
 func (w *WhatsApp) openSession(ctx context.Context) error {
        address, err := whatsappSessionAddress(w.sessionPath())
        if err != nil {


@@ -318,21 +420,77 @@ func (w *WhatsApp) isLinked() bool {
        return w.linked
 }
 
        return w.linked
 }
 

-// connect makes the client of the linked device and connects it.
-func (w *WhatsApp) connect(ctx context.Context) {
+// 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 tries the starting connection of the linked device with one client.
+// It returns whether Run must retry. A failed call starts the shared outage
+// state and logs its redacted cause once, because a returned ConnectContext
+// error does not emit Disconnected. Connected logs recovery after
+// authentication.
+func (w *WhatsApp) connect(ctx context.Context) bool {

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

-       w.client = w.newClient(w.device, w.handle)
+       if ctx.Err() != nil || !w.linked || !w.retrying || w.closed {
+               w.mutex.Unlock()
+               return false
+       }
+
+       if w.client == nil {
+               w.client = w.newClient(w.device, w.handle)
+       }
+

        client := w.client
        w.mutex.Unlock()
 
        err := client.ConnectContext(ctx)
        client := w.client
        w.mutex.Unlock()
 
        err := client.ConnectContext(ctx)

-       if err != nil {
-               w.logger.Printf("connect: %s", w.redact(err.Error()))
+       w.mutex.Lock()
+       if err == nil || ctx.Err() != nil || !w.retrying || !w.linked {
+               w.retrying = false
+               w.mutex.Unlock()
+               return false
+       }
+
+       first := w.startOutage()
+       cause := whatsappRedact(w.own, err.Error())
+       w.mutex.Unlock()
+       if first {
+               w.logger.Printf("first connect failed, retrying: %s", cause)

        }
        }

+
+       return true

 }
 
 }
 

-// close ends the connection and the timer of the notice, and stops all
-// notices.
+// startOutage starts the shared outage time and notice timer once. The caller
+// holds the mutex. Its result tells whether this is the first failure.
+func (w *WhatsApp) startOutage() bool {
+       first := w.linked && (w.connected || w.disconnectedAt.IsZero())
+       if first {
+               w.disconnectedAt = w.clock()
+               w.disconnections++
+               disconnections := w.disconnections
+               w.timer = time.AfterFunc(w.noticeDelay, func() {
+                       w.disconnectedLong(disconnections)
+               })
+       }
+
+       w.connected = false
+
+       return first
+}
+
+// close ends the connection and the timer of the notice, and stops all notices.

 func (w *WhatsApp) close() {
        w.mutex.Lock()
        w.closed = true
 func (w *WhatsApp) close() {
        w.mutex.Lock()
        w.closed = true


@@ -344,36 +502,47 @@ func (w *WhatsApp) close() {
        w.client = nil
        w.mutex.Unlock()
 
        w.client = nil
        w.mutex.Unlock()
 

+       w.inbox.close()
+

        if client != nil {
                client.Disconnect()
        }
 }
 
        if client != nil {
                client.Disconnect()
        }
 }
 

-// loggedOut deletes the session after a logout from the phone, notes it in the
-// log of l, and tells all clients one time.
-func (w *WhatsApp) loggedOut(l *TurnLoop) {
+// loggedOut logs the open batches, deletes the session after a logout from the
+// phone, notes it in the log of l, and tells all clients one time.
+func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {

        if !w.isLinked() {
        if !w.isLinked() {

-               return
+               return nil

        }
 
        }
 

-       err := w.removeSession()
+       w.logger.Print("logged out by the phone, run /whatsapp pair PHONE")
+       err := w.inbox.deliver(ctx, l, w.link(), true)

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

-               w.logger.Printf("delete the session after the logout: %v", err)
+               return err
+       }
+
+       err = w.removeSession()
+       if err != nil {
+               w.logger.Printf("session delete failed: %v", err)

        }
 
        err = l.note("WhatsApp was unlinked from the phone.")
        if err != nil {
        }
 
        err = l.note("WhatsApp was unlinked from the phone.")
        if err != nil {

-               w.logger.Printf("note the logout: %v", err)
+               w.logger.Printf("chat note failed: %v", err)

        }
 
        w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.")
        }
 
        w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.")

+
+       return nil

 }
 
 }
 

-// unlink logs out the linked device and deletes the session. When the logout
-// call fails, as it does while WhatsApp is disconnected, the session is
-// deleted all the same, and answer tells the user to remove the device in the
-// phone.
-func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) {
+// unlink logs the open batches, logs out the linked device, and deletes the
+// session. When the logout call fails, as it does while WhatsApp is
+// disconnected, the session is deleted all the same, and answer tells the user
+// to remove the device in the phone. Its error is one of the log or the state
+// file.
+func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) error {

        w.mutex.Lock()
        linked := w.linked
        client := w.client
        w.mutex.Lock()
        linked := w.linked
        client := w.client


@@ -381,7 +550,12 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 
        if !linked {
                answer("WhatsApp is not linked.")
 
        if !linked {
                answer("WhatsApp is not linked.")

-               return
+               return nil
+       }
+
+       err := w.inbox.deliver(ctx, l, w.link(), true)
+       if err != nil {
+               return err

        }
 
        var logoutErr error
        }
 
        var logoutErr error


@@ -392,23 +566,26 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
                logoutErr = client.Logout(ctx)
        }
 
                logoutErr = client.Logout(ctx)
        }
 

-       err := w.removeSession()
+       err = w.removeSession()

        if err != nil {
                answer("The unlink failed: " + w.redact(err.Error()))
        if err != nil {
                answer("The unlink failed: " + w.redact(err.Error()))

-               return
+               return nil

        }
 
        }
 

+       w.logger.Print("unlinked")

        err = l.note("WhatsApp is unlinked.")
        if err != nil {
        err = l.note("WhatsApp is unlinked.")
        if err != nil {

-               w.logger.Printf("note the unlink: %v", err)
+               w.logger.Printf("chat note failed: %v", err)

        }
 
        if client == nil || logoutErr != nil {
                answer("WhatsApp is unlinked here, but the phone did not get the logout. In WhatsApp on your phone, open Linked devices and remove the device.")
        }
 
        if client == nil || logoutErr != nil {
                answer("WhatsApp is unlinked here, but the phone did not get the logout. In WhatsApp on your phone, open Linked devices and remove the device.")

-               return
+               return nil

        }
 
        answer("WhatsApp is unlinked.")
        }
 
        answer("WhatsApp is unlinked.")

+
+       return nil

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


@@ -418,8 +595,10 @@ func (w *WhatsApp) removeSession() error {
        client := w.client
        w.client = nil
        w.linked = false
        client := w.client
        w.client = nil
        w.linked = false

+       w.retrying = false

        w.own = nil
        w.connected = false
        w.own = nil
        w.connected = false

+       w.disconnectedAt = time.Time{}

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


@@ -430,6 +609,8 @@ func (w *WhatsApp) removeSession() error {
        w.device = nil
        w.mutex.Unlock()
 
        w.device = nil
        w.mutex.Unlock()
 

+       w.inbox.stopCatchup()
+

        if client != nil {
                client.Disconnect()
        }
        if client != nil {
                client.Disconnect()
        }


@@ -449,12 +630,18 @@ func (w *WhatsApp) removeSession() error {
        return err
 }
 
        return err
 }
 

-// pair links a new device to the account of phone with a pairing code. It
-// gives the steps and the code to answer, and then the end of the pairing:
-// the linked 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)) {
+// pair links a new device to the account of phone with a pairing code. It gives
+// the steps and the code to answer, and then the end of the pairing: the linked
+// 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.
+//
+// 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())


@@ -471,7 +658,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 {


@@ -493,6 +680,8 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
                return
        }
 
                return
        }
 

+       // The server accepts only a display name of the form "Browser (OS)"
+       // with a common browser and OS, and refuses the pairing otherwise.

        code, err := client.PairPhone(ctx, phone, true, whatsmeow.PairClientChrome, "Chrome (Linux)")
        if err != nil {
                answer("WhatsApp refused the pairing: " + err.Error() + ". Check the phone number and run /whatsapp pair PHONE again.")
        code, err := client.PairPhone(ctx, phone, true, whatsmeow.PairClientChrome, "Chrome (Linux)")
        if err != nil {
                answer("WhatsApp refused the pairing: " + err.Error() + ". Check the phone number and run /whatsapp pair PHONE again.")


@@ -524,10 +713,11 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
                case item.Event == whatsmeow.QRChannelSuccess.Event:
                        linked = true
                        w.linkedBy(client)
                case item.Event == whatsmeow.QRChannelSuccess.Event:
                        linked = true
                        w.linkedBy(client)

+                       w.logger.Print("linked")

 
                        err = l.note("WhatsApp is linked.")
                        if err != nil {
 
                        err = l.note("WhatsApp is linked.")
                        if err != nil {

-                               w.logger.Printf("note the link: %v", err)
+                               w.logger.Printf("chat note failed: %v", err)

                        }
 
                        answer("WhatsApp is linked to +" + phone + ".")
                        }
 
                        answer("WhatsApp is linked to +" + phone + ".")


@@ -583,19 +773,54 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
        w.linked = true
 }
 
        w.linked = true
 }
 

-// handle takes one event of the library and tells if it was handled. 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.
+// handle takes one event of the library and tells if it was handled. A message
+// goes to the inbox. The names of the groups follow the events of the groups. A
+// connection starts a catch-up of the inbox, which ends at OfflineSyncCompleted
+// or after its catchupLimit. A disconnection keeps the time of its start while
+// Run or 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.
+//
+// The log of the daemon gets one line for each change of the connection of the
+// linked device: connected, a failed first connection, a lost connection, and
+// connected again with the length of the outage. The retries of the library and
+// Run between them log nothing.

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

-       var notice string
+       switch event := event.(type) {
+       case *events.Message:
+               return w.inbox.receive(w.link(), event)
+       case *events.GroupInfo:
+               if event.Name != nil {
+                       w.groups.set(event.JID.String(), event.Name.Name)
+               }
+
+               return true
+       case *events.JoinedGroup:
+               w.groups.set(event.JID.String(), event.Name)
+               return true
+       case *events.OfflineSyncCompleted:
+               w.inbox.endCatchup()
+               return true
+       case *events.Connected:
+               w.inbox.startCatchup()
+       }
+
+       var notice, line string

        w.mutex.Lock()
        switch event := event.(type) {
        case *events.PairSuccess:
                w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
        case *events.Connected:
        w.mutex.Lock()
        switch event := event.(type) {
        case *events.PairSuccess:
                w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
        case *events.Connected:

+               switch {
+               case !w.linked || w.connected:
+               case w.disconnectedAt.IsZero():
+                       line = "connected"
+               default:
+                       line = "connected again after " + durationText(w.clock().Sub(w.disconnectedAt))
+               }
+

                w.connected = true
                w.connected = true

+               w.retrying = false

                w.connectedAt = w.clock()
                if w.timer != nil {
                        w.timer.Stop()
                w.connectedAt = w.clock()
                if w.timer != nil {
                        w.timer.Stop()


@@ -606,30 +831,39 @@ func (w *WhatsApp) handle(event any) bool {
                        notice = "WhatsApp is connected again."
                }
        case *events.Disconnected:
                        notice = "WhatsApp is connected again."
                }
        case *events.Disconnected:

-               if w.linked && (w.connected || w.disconnectedAt.IsZero()) {
-                       w.disconnectedAt = w.clock()
-                       w.disconnections++
-                       disconnections := w.disconnections
-                       w.timer = time.AfterFunc(w.noticeDelay, func() {
-                               w.disconnectedLong(disconnections)
-                       })
+               connected := w.connected
+               if w.startOutage() {
+                       line = "disconnected, retrying"
+                       if !connected {
+                               line = "first connect failed, retrying"
+                       }

                }
                }

-
-               w.connected = false

        case *events.LoggedOut:
        case *events.LoggedOut:

+               w.retrying = false

                select {
                case w.logouts <- struct{}{}:
                default:
                }
        case events.PermanentDisconnect:
                select {
                case w.logouts <- struct{}{}:
                default:
                }
        case events.PermanentDisconnect:

+               w.retrying = false

                if w.linked {
                        w.connected = false
                        w.noticed = true
                        notice = "WhatsApp is disconnected and does not connect again by itself: " + event.PermanentDisconnectDescription() + ". Restart the daemon to try again."
                if w.linked {
                        w.connected = false
                        w.noticed = true
                        notice = "WhatsApp is disconnected and does not connect again by itself: " + event.PermanentDisconnectDescription() + ". Restart the daemon to try again."

+                       line = "disconnected for good, restart to retry: " + whatsappRedact(w.own, event.PermanentDisconnectDescription())

                }
        }
                }
        }

+
+       if w.closed {
+               line = ""
+       }
+

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

+       if line != "" {
+               w.logger.Print(line)
+       }
+

        if notice != "" {
                w.broadcast(notice)
        }
        if notice != "" {
                w.broadcast(notice)
        }


@@ -674,11 +908,17 @@ 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)
+}

 
 

-       return text
+// 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


@@ -689,14 +929,23 @@ type WhatsAppRequest struct {
        answer func(text string)
 }
 
        answer func(text string)
 }
 

+// whatsappSetDeviceProps sets the device properties that the library sends at
+// the pairing. They are global values of the library, so the daemon sets them
+// once before any client exists. The phone shows the linked device with the
+// name OneChat and a desktop icon only when the platform type is known.
+func whatsappSetDeviceProps() {
+       store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})
+       store.DeviceProps.PlatformType = waCompanionReg.DeviceProps_DESKTOP.Enum()
+}
+

 // whatsappNewClient returns the client of the library for device, with handle
 // whatsappNewClient returns the client of the library for device, with handle

-// as its event handler. The client tries again after a failed first
-// connection, acknowledges a message only after handle returns true, and
-// downloads no old history. The phone shows the device with the name OneChat.
+// as its event handler. Run owns failed starting connections of linked devices,
+// so only an unlinked device enables the initial retry of the library for
+// pairing. The library still retries a lost connection. The client acknowledges
+// a message only after handle returns true, and downloads no old history.

 func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
 func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsAppClient {

-       store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})

        client := whatsmeow.NewClient(device, waLog.Noop)
        client := whatsmeow.NewClient(device, waLog.Noop)

-       client.InitialAutoReconnect = true
+       client.InitialAutoReconnect = device.ID == nil

        client.SynchronousAck = true
        client.ManualHistorySyncDownload = true
        client.AddEventHandlerWithSuccessStatus(handle)
        client.SynchronousAck = true
        client.ManualHistorySyncDownload = true
        client.AddEventHandlerWithSuccessStatus(handle)


@@ -704,6 +953,48 @@ func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsA
        return client
 }
 
        return client
 }
 

+// 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
+// LID gets its phone number from the LID map of the session.
+func whatsappContactName(ctx context.Context, device *store.Device, jid types.JID, push string) string {
+       jid = jid.ToNonAD()
+       candidates := []types.JID{jid}
+       phone := types.EmptyJID
+       switch jid.Server {
+       case types.DefaultUserServer:
+               phone = jid
+       case types.HiddenUserServer:
+               mapped, err := device.LIDs.GetPNForLID(ctx, jid)
+               if err == nil && !mapped.IsEmpty() {
+                       phone = mapped
+                       candidates = append(candidates, mapped)
+               }
+       }
+
+       for _, candidate := range candidates {
+               contact, err := device.Contacts.GetContact(ctx, candidate)
+               if err != nil || !contact.Found {
+                       continue
+               }
+
+               for _, name := range []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName} {
+                       if name != "" {
+                               return name
+                       }
+               }
+       }
+
+       switch {
+       case push != "":
+               return push
+       case !phone.IsEmpty():
+               return "+" + phone.User
+       default:
+               return jid.User
+       }
+}
+

 // 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


@@ -716,6 +1007,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.


@@ -750,9 +1050,9 @@ func whatsappCommandArgs(line string) (string, bool) {
        return strings.TrimSpace(args), true
 }
 
        return strings.TrimSpace(args), true
 }
 

-// whatsappPhone returns the digits of phone, a number with its country code
-// and an optional + and dashes, and tells if it has the form of a number: 7 to
-// 15 digits, with no 0 first.
+// whatsappPhone returns the digits of phone, a number with its country code and
+// an optional + and dashes, and tells if it has the form of a number: 7 to 15
+// digits, with no 0 first.

 func whatsappPhone(phone string) (string, bool) {
        phone = strings.ReplaceAll(strings.TrimPrefix(phone, "+"), "-", "")
        valid := len(phone) >= 7 && len(phone) <= 15 && phone[0] != '0' && strings.Trim(phone, "0123456789") == ""
 func whatsappPhone(phone string) (string, bool) {
        phone = strings.ReplaceAll(strings.TrimPrefix(phone, "+"), "-", "")
        valid := len(phone) >= 7 && len(phone) <= 15 && phone[0] != '0' && strings.Trim(phone, "0123456789") == ""