Resume queued appends at their saved log ID

[onechat] / whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 830673478ade69fd154b734a54f6929d300e595b..0c68a44ace8a0184b89789e473537d75ec876199 100644 (file)
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -2,9 +2,10 @@ package main
 
 import (
        "context"
 
 import (
        "context"

+       "database/sql"

        "errors"
        "fmt"
        "errors"
        "fmt"

-       "log"
+       "log/slog"

        "net/url"
        "os"
        "path/filepath"
        "net/url"
        "os"
        "path/filepath"


@@ -14,12 +15,13 @@ import (
        "time"
 
        "go.mau.fi/whatsmeow"
        "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/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"

-

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


@@ -64,27 +66,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
 

-       // whatsappSource is the source of the work events of the batches.
-       whatsappSource = "whatsapp"
-

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

-       // whatsappGroupsRefresh is the shortest time between two reads of the
-       // groups from WhatsApp for a group with no name.
-       whatsappGroupsRefresh = time.Minute
-
-       // whatsappUnknownGroup is the name of a group whose name is not known.
-       whatsappUnknownGroup = "A group with no known name"
-
-       // whatsappCatchupLimit is the longest wait for the end of the catch-up
-       // after a connection.
-       whatsappCatchupLimit = time.Minute
+       // 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


@@ -97,6 +95,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


@@ -104,27 +104,27 @@ type WhatsAppClient interface {
 // the account, so a file that another user can read is an error. The clock
 // gives the times of the status, logger gets the failures, and newClient makes
 // the client of a device with its event handler.
 // the account, so a file that another user can read is an error. The clock
 // gives the times of the status, logger gets the failures, and newClient makes
 // 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) {
+func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *slog.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) {

        w := &WhatsApp{
        w := &WhatsApp{

-               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),
-               groupNames:   make(map[string]string),
+               dir:         filepath.Join(dir, whatsappDirName),
+               clock:       clock,
+               logger:      logger,
+               newClient:   newClient,
+               noticeDelay: whatsappNoticeDelay,
+               requests:    make(chan WhatsAppRequest, whatsappRequests),
+               logouts:     make(chan struct{}, 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
        }
 

+       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


@@ -145,7 +145,8 @@ 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.inbox.waitForCatchup()
+

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


@@ -163,22 +164,13 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 // of the client that asked. A logout from the phone comes as an event of the
 // library, and Run deletes the session. The mutex protects the session, the
 // client, and the state of the connection, which the event handler of the
 // of the client that asked. A logout from the phone comes as an event of the
 // library, and Run deletes the session. The mutex protects the session, the
 // 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.
+// library changes from its own goroutines. The sessionMutex serializes session
+// creation, close, removal, and snapshots. It is held before mutex, and stays
+// held when removal releases mutex for client callbacks.

 //
 //

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


@@ -188,18 +180,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
-       catchupLimit time.Duration
-       requests     chan WhatsAppRequest
-       logouts      chan struct{}
-       wake         chan struct{}
-       failures     chan error
-       batches      *WhatsAppBatches
-
+       dir         string
+       clock       func() time.Time
+       logger      *slog.Logger
+       newClient   func(device *store.Device, handle func(event any) bool) WhatsAppClient
+       noticeDelay time.Duration
+       requests    chan WhatsAppRequest
+       logouts     chan struct{}
+       state       *WhatsAppState
+       groups      *WhatsAppGroups
+       inbox       *WhatsAppInbox
+
+       sessionMutex   sync.Mutex

        mutex          sync.Mutex
        container      *sqlstore.Container
        device         *store.Device
        mutex          sync.Mutex
        container      *sqlstore.Container
        device         *store.Device


@@ -208,38 +200,63 @@ 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
        noticed        bool
        timer          *time.Timer
        closed         bool
        connectedAt    time.Time
        disconnectedAt time.Time
        disconnections int
        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
 // 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
 }
 
 // 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 is logged, and the library tries again when the
-// failure is one of the network. 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.
+// 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, 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()
 func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error {
        w.mutex.Lock()

+

        w.notify = notify
        linked := w.linked
        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

+

        cancel := func() {}
        defer func() {
                cancel()
        cancel := func() {}
        defer func() {
                cancel()


@@ -247,26 +264,28 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err
                w.close()
        }()
 
                w.close()
        }()
 

+       if linked {
+               connect()
+       }
+

        for {
        for {

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

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

-               var due <-chan time.Time
-               wait, open := w.batches.Wait(time.Now())
-               if open {
-                       due = time.After(wait)
-               }
-

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

-               case err = <-w.failures:
+               case err = <-w.inbox.failures:

                        return err
                        return err

-               case <-w.wake:
-               case <-due:
+               case <-w.inbox.wake:
+               case <-w.inbox.due():
+               case <-retry:
+                       connect()

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

+                       stopRetry()
+

                        err = w.loggedOut(ctx, l)
                        if err != nil {
                                return err
                        err = w.loggedOut(ctx, l)
                        if err != nil {
                                return err


@@ -274,10 +293,13 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err
                case request := <-w.requests:
                        cancel()
                        pairing.Wait()
                case request := <-w.requests:
                        cancel()
                        pairing.Wait()

+

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

+                               stopRetry()
+

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


@@ -290,7 +312,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)

                                })
                        }
                }
                                })
                        }
                }


@@ -309,6 +331,7 @@ func (w *WhatsApp) Command(args string, answer func(text string)) {
        switch {
        case len(fields) == 1 && fields[0] == "status":
                answer(w.Status())
        switch {
        case len(fields) == 1 && fields[0] == "status":
                answer(w.Status())

+

                return
        case len(fields) == 1 && fields[0] == "unlink":
                request.unlink = true
                return
        case len(fields) == 1 && fields[0] == "unlink":
                request.unlink = true


@@ -316,12 +339,14 @@ func (w *WhatsApp) Command(args string, answer func(text string)) {
                phone, valid := whatsappPhone(strings.Join(fields[1:], ""))
                if !valid {
                        answer("PHONE must be the number of your WhatsApp account with its country code: 7 to 15 digits, such as +15550001111.")
                phone, valid := whatsappPhone(strings.Join(fields[1:], ""))
                if !valid {
                        answer("PHONE must be the number of your WhatsApp account with its country code: 7 to 15 digits, such as +15550001111.")

+

                        return
                }
 
                request.phone = phone
        default:
                answer(whatsappUsage)
                        return
                }
 
                request.phone = phone
        default:
                answer(whatsappUsage)

+

                return
        }
 
                return
        }
 


@@ -353,8 +378,62 @@ func (w *WhatsApp) Status() string {
        }
 }
 
        }
 }
 

+// BackupSession writes a consistent SQLite snapshot to path while the session
+// cannot be created, closed, or removed. The source opens without creation
+// permission. No session file means no linked state to copy.
+func (w *WhatsApp) BackupSession(ctx context.Context, path string) (err error) {
+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+
+       w.mutex.Lock()
+       defer w.mutex.Unlock()
+
+       _, err = os.Stat(w.sessionPath())
+       if errors.Is(err, os.ErrNotExist) {
+               return nil
+       }
+
+       if err != nil {
+               return fmt.Errorf("read session file: %w", err)
+       }
+
+       err = os.MkdirAll(filepath.Dir(path), 0o700)
+       if err != nil {
+               return fmt.Errorf("create session snapshot directory: %w", err)
+       }
+
+       address, err := whatsappSessionAddress(w.sessionPath())
+       if err != nil {
+               return fmt.Errorf("find session database: %w", err)
+       }
+
+       database, err := sql.Open("sqlite", address+"&mode=rw")
+       if err != nil {
+               return fmt.Errorf("open session snapshot source: %w", err)
+       }
+
+       defer func() {
+               err = errors.Join(err, database.Close())
+       }()
+
+       _, err = database.ExecContext(ctx, "VACUUM INTO ?", path)
+       if err != nil {
+               return fmt.Errorf("snapshot session database: %w", err)
+       }
+
+       err = os.Chmod(path, 0o600)
+       if err != nil {
+               return fmt.Errorf("set session snapshot mode: %w", err)
+       }
+
+       return nil
+}
+

 // Close closes the session database.
 func (w *WhatsApp) Close() error {
 // Close closes the session database.
 func (w *WhatsApp) Close() error {

+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+

        w.mutex.Lock()
        defer w.mutex.Unlock()
 
        w.mutex.Lock()
        defer w.mutex.Unlock()
 


@@ -368,6 +447,17 @@ 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)
 }


@@ -403,35 +493,97 @@ 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.Warn("first connect failed, retrying", "err", cause)

        }
        }

+
+       return true
+}
+
+// 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()
 }
 
 // close ends the connection and the timer of the notice, and stops all notices.
 func (w *WhatsApp) close() {
        w.mutex.Lock()

+

        w.closed = true
        if w.timer != nil {
                w.timer.Stop()
        }
 
        w.closed = true
        if w.timer != nil {
                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()
 

+       w.inbox.close()
+

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


@@ -444,19 +596,21 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
                return nil
        }
 
                return nil
        }
 

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

        if err != nil {
                return err
        }
 
        err = w.removeSession()
        if err != nil {
        if err != nil {
                return err
        }
 
        err = w.removeSession()
        if err != nil {

-               w.logger.Printf("delete the session after the logout: %v", err)
+               w.logger.Error("session delete failed", "err", 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.Error("chat note failed", "err", 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.")


@@ -471,21 +625,24 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
 // file.
 func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) error {
        w.mutex.Lock()
 // 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.Unlock()
 
        if !linked {
                answer("WhatsApp is not linked.")
        linked := w.linked
        client := w.client
        w.mutex.Unlock()
 
        if !linked {
                answer("WhatsApp is not linked.")

+

                return nil
        }
 
                return nil
        }
 

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

        if err != nil {
                return err
        }
 
        var logoutErr error
        if err != nil {
                return err
        }
 
        var logoutErr error

+

        if client != nil {
                ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
                defer cancel()
        if client != nil {
                ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
                defer cancel()


@@ -496,141 +653,44 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
        err = w.removeSession()
        if err != nil {
                answer("The unlink failed: " + w.redact(err.Error()))
        err = w.removeSession()
        if err != nil {
                answer("The unlink failed: " + w.redact(err.Error()))

+

                return nil
        }
 
                return nil
        }
 

+       w.logger.Info("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.Error("chat note failed", "err", 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 nil
-       }

 
 

-       answer("WhatsApp is unlinked.")
-
-       return nil
-}
-
-// deliver logs the closed batches in l in order, each as a work message of
-// 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.batches.CloseAll()
-       case catchingUp:

                return nil
                return nil

-       default:
-               _, err = w.batches.CloseDue(time.Now())
-       }
-
-       if err != nil {
-               return err
-       }
-
-       var turns []Message
-       for _, batch := range w.batches.Closed() {
-               if batch.Chat.Group && batch.Chat.Name == "" {
-                       batch.Chat.Name = w.groupName(ctx, batch.Chat.ID)
-               }
-
-               message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "")
-               if err != nil {
-                       return fmt.Errorf("log a WhatsApp batch: %w", err)
-               }
-
-               // A stop of the daemon during the flush is no failure: the
-               // batch stays in the state file and repeats once at the next
-               // start.
-               err = l.Flush(ctx)
-               if ctx.Err() != nil {
-                       return nil
-               }
-
-               if err != nil {
-                       return fmt.Errorf("log a WhatsApp batch: %w", err)
-               }
-
-               err = w.batches.Remove(batch.Number)
-               if err != nil {
-                       return err
-               }
-
-               if batch.Turn() {
-                       turns = append(turns, message)
-               }

        }
 
        }
 

-       l.Wake(turns...)
+       answer("WhatsApp is unlinked.")

 
        return nil
 }
 
 
        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 {
-       w.mutex.Lock()
-       name, found := w.groupNames[id]
-       client := w.client
-       fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
-       w.mutex.Unlock()
-
-       if found {
-               return name
-       }
-
-       if client == nil || fresh {
-               return whatsappUnknownGroup
-       }
-
-       ctx, cancel := context.WithTimeout(ctx, whatsappLookupTime)
-       defer cancel()
-
-       groups, err := client.GetJoinedGroups(ctx)
-       if err != nil {
-               w.logger.Printf("read the groups: %s", w.redact(err.Error()))
-       }
-
-       w.mutex.Lock()
-       defer w.mutex.Unlock()
-
-       w.groupsAt = time.Now()
-       for _, group := range groups {
-               w.groupNames[group.JID.String()] = group.Name
-       }
-
-       name, found = w.groupNames[id]
-       if !found || name == "" {
-               return whatsappUnknownGroup
-       }
-
-       return name
-}
-

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

-// its files.
+// its files. The session lock covers the cleanup after mutex is released, so a
+// snapshot or a new session cannot open files that cleanup removes.

 func (w *WhatsApp) removeSession() error {
 func (w *WhatsApp) removeSession() error {

+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+

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

+

        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.catchingUp = false
+       w.disconnectedAt = time.Time{}

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


@@ -641,11 +701,14 @@ 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()
        }
 
        var err error
        if client != nil {
                client.Disconnect()
        }
 
        var err error

+

        if container != nil {
                err = container.Close()
        }
        if container != nil {
                err = container.Close()
        }


@@ -665,10 +728,17 @@ 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())

+

                return
        }
 
                return
        }
 


@@ -682,11 +752,12 @@ 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 {
                answer("The connection to WhatsApp failed: " + err.Error())
        }
 
        if err != nil {
                answer("The connection to WhatsApp failed: " + err.Error())

+

                return
        }
 
                return
        }
 


@@ -694,6 +765,7 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
        case item, open := <-qr:
                if !open || item.Event != whatsmeow.QRChannelEventCode {
                        answer("WhatsApp did not start the pairing. Try again later.")
        case item, open := <-qr:
                if !open || item.Event != whatsmeow.QRChannelEventCode {
                        answer("WhatsApp did not start the pairing. Try again later.")

+

                        return
                }
        case <-ctx.Done():
                        return
                }
        case <-ctx.Done():


@@ -704,9 +776,12 @@ 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.")

+

                return
        }
 
                return
        }
 


@@ -715,6 +790,7 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
 
        for {
                var item whatsmeow.QRChannelItem
 
        for {
                var item whatsmeow.QRChannelItem

+

                open := true
                select {
                case item, open = <-qr:
                open := true
                select {
                case item, open = <-qr:


@@ -729,16 +805,19 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
                switch {
                case !open || item.Event == whatsmeow.QRChannelTimeout.Event:
                        answer(whatsappPairExpired)
                switch {
                case !open || item.Event == whatsmeow.QRChannelTimeout.Event:
                        answer(whatsappPairExpired)

+

                        return
                case item.Event == whatsmeow.QRChannelEventCode:
                        continue
                case item.Event == whatsmeow.QRChannelSuccess.Event:
                        linked = true
                        return
                case item.Event == whatsmeow.QRChannelEventCode:
                        continue
                case item.Event == whatsmeow.QRChannelSuccess.Event:
                        linked = true

+

                        w.linkedBy(client)
                        w.linkedBy(client)

+                       w.logger.Info("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.Error("chat note failed", "err", err)

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


@@ -746,6 +825,7 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
                        return
                default:
                        answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.")
                        return
                default:
                        answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.")

+

                        return
                }
        }
                        return
                }
        }


@@ -755,6 +835,9 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
 // directory and the file of the session first, with their modes, when they do
 // not exist.
 func (w *WhatsApp) newDevice(ctx context.Context) (*store.Device, error) {
 // directory and the file of the session first, with their modes, when they do
 // not exist.
 func (w *WhatsApp) newDevice(ctx context.Context) (*store.Device, error) {

+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+

        w.mutex.Lock()
        defer w.mutex.Unlock()
 
        w.mutex.Lock()
        defer w.mutex.Unlock()
 


@@ -795,42 +878,63 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 }
 
 // handle takes one event of the library and tells if it was handled. A message
 }
 
 // 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
-// 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.
+// 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 {

-       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.inbox.receive(w.link(), 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
+       case *events.OfflineSyncCompleted:
+               w.inbox.endCatchup()
+
+               return true
+       case *events.Connected:
+               w.inbox.startCatchup()
+       }
+
+       var notice, line string
+
+       level := slog.LevelInfo
+
+       var attrs []any
+
+       w.mutex.Lock()
+
+       switch event := event.(type) {

        case *events.PairSuccess:
                w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
        case *events.Connected:
        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()
+               switch {
+               case !w.linked || w.connected:
+               case w.disconnectedAt.IsZero():
+                       line = "connected"
+               default:
+                       line = "connected again"
+                       attrs = append(attrs, "after", w.clock().Sub(w.disconnectedAt))

                }
 
                }
 

-               w.catchupTimer = time.AfterFunc(w.catchupLimit, func() {
-                       w.caughtUpBy(catchups)
-               })
+               w.connected = true
+               w.retrying = false
+               w.connectedAt = w.clock()

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


@@ -840,196 +944,54 @@ 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() {
+                       level = slog.LevelWarn
+                       line = "disconnected, retrying"
+                       if !connected {
+                               line = "first connect failed, retrying"
+                       }

                }
                }

-
-               w.connected = false
-       case *events.OfflineSyncCompleted:
-               w.endCatchup()

        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."

+                       level = slog.LevelError
+                       line = "disconnected for good, restart to retry"
+                       attrs = append(attrs, "err", whatsappRedact(w.own, event.PermanentDisconnectDescription()))

                }
        }
                }
        }

-       w.mutex.Unlock()

 
 

-       if notice != "" {
-               w.broadcast(notice)
+       if w.closed {
+               line = ""

        }
 
        }
 

-       return true
-}
-
-// receive puts the text of event into its batch and wakes Run. It returns false
-// when the state file cannot hold the message, so that the library does not
-// acknowledge it, and Run stops the daemon. A message that is not text, or that
-// the batches do not take, is handled with nothing to do.
-func (w *WhatsApp) receive(event *events.Message) bool {
-       ctx, cancel := context.WithTimeout(context.Background(), whatsappLookupTime)
-       defer cancel()
-
-       chat, message, found := w.message(ctx, event)
-       if !found {
-               return true
-       }
-
-       _, err := w.batches.Add(chat, message, time.Now())
-       if err != nil {
-               select {
-               case w.failures <- err:
-               default:
-               }
-
-               return false
-       }
-
-       select {
-       case w.wake <- struct{}{}:
-       default:
-       }
-
-       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) {
-       w.mutex.Lock()
-       device := w.device
-       own := slices.Clone(w.own)

        w.mutex.Unlock()
 
        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)
-       }
-
-       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")
-       }
-
-       message.Text = 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
-}
-
-// 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()
-       defer w.mutex.Unlock()
-
-       if w.catchups == catchups {
-               w.endCatchup()
+       if line != "" {
+               w.logger.Log(context.Background(), level, line, attrs...)

        }
        }

-}

 
 

-// 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
-       }
-
-       w.catchingUp = false
-       w.caughtUp = true
-       if w.catchupTimer != nil {
-               w.catchupTimer.Stop()
+       if notice != "" {
+               w.broadcast(notice)

        }
 
        }
 

-       select {
-       case w.wake <- struct{}{}:
-       default:
-       }
+       return true

 }
 
 // disconnectedLong gives the notice of a long disconnection, unless the
 // disconnection with the number disconnections ended.
 func (w *WhatsApp) disconnectedLong(disconnections int) {
        w.mutex.Lock()
 }
 
 // disconnectedLong gives the notice of a long disconnection, unless the
 // disconnection with the number disconnections ended.
 func (w *WhatsApp) disconnectedLong(disconnections int) {
        w.mutex.Lock()

+

        long := !w.closed && w.linked && !w.connected && !w.noticed && w.disconnections == disconnections
        if long {
                w.noticed = true
        long := !w.closed && w.linked && !w.connected && !w.noticed && w.disconnections == disconnections
        if long {
                w.noticed = true


@@ -1046,6 +1008,7 @@ func (w *WhatsApp) disconnectedLong(disconnections int) {
 // broadcast gives text as a notice to all clients.
 func (w *WhatsApp) broadcast(text string) {
        w.mutex.Lock()
 // broadcast gives text as a notice to all clients.
 func (w *WhatsApp) broadcast(text string) {
        w.mutex.Lock()

+

        notify := w.notify
        closed := w.closed
        w.mutex.Unlock()
        notify := w.notify
        closed := w.closed
        w.mutex.Unlock()


@@ -1063,11 +1026,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


@@ -1078,14 +1047,24 @@ 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)


@@ -1138,6 +1117,7 @@ func whatsappContactName(ctx context.Context, device *store.Device, jid types.JI
 // 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

+

        for _, id := range ids {
                if id != "" {
                        own = append(own, id)
        for _, id := range ids {
                if id != "" {
                        own = append(own, id)


@@ -1147,6 +1127,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.