X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/0018014ab36f3de61a4b8a5515009dab803d6c38..c3c7bc90eb73e83f48fbeac6be149ade95a726c0:/whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 3c519e8..0c68a44 100644
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -2,22 +2,26 @@ package main
 
 import (
 	"context"
+	"database/sql"
 	"errors"
 	"fmt"
-	"log"
+	"log/slog"
 	"net/url"
 	"os"
 	"path/filepath"
+	"slices"
 	"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/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"
@@ -36,7 +40,8 @@ const (
 	// 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,
@@ -61,9 +66,23 @@ const (
 	// 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
+
+	// 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
@@ -75,6 +94,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
+	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
@@ -82,7 +104,7 @@ 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.
-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{
 		dir:         filepath.Join(dir, whatsappDirName),
 		clock:       clock,
@@ -91,8 +113,18 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 		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
@@ -113,15 +145,17 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 
 	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
 }
 
-// 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
@@ -130,21 +164,34 @@ 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
-// library changes from its own goroutines.
+// 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.
+//
+// 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
-// 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
-	logger      *log.Logger
+	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
@@ -153,6 +200,7 @@ type WhatsApp struct {
 	own            []string
 	notify         func(Event)
 	connected      bool
+	retrying       bool
 	connectedAt    time.Time
 	disconnectedAt time.Time
 	disconnections int
@@ -161,21 +209,54 @@ type WhatsApp struct {
 	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, 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.retrying = linked
 	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
+
 	cancel := func() {}
 	defer func() {
 		cancel()
@@ -183,20 +264,46 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
 		w.close()
 	}()
 
+	if linked {
+		connect()
+	}
+
 	for {
+		err := w.inbox.deliver(ctx, l, w.link(), false)
+		if err != nil {
+			return err
+		}
+
 		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:
-			w.loggedOut(l)
+			stopRetry()
+
+			err = w.loggedOut(ctx, l)
+			if err != nil {
+				return err
+			}
 		case request := <-w.requests:
 			cancel()
 			pairing.Wait()
+
 			cancel = func() {}
 
 			switch {
 			case request.unlink:
-				w.unlink(ctx, l, request.answer)
+				stopRetry()
+
+				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:
@@ -205,7 +312,7 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) {
 				pairing.Go(func() {
 					defer cancelPair()
 
-					w.pair(pairCtx, l, request.phone, request.answer)
+					w.pair(pairCtx, ctx, l, request.phone, request.answer)
 				})
 			}
 		}
@@ -224,6 +331,7 @@ func (w *WhatsApp) Command(args string, answer func(text string)) {
 	switch {
 	case len(fields) == 1 && fields[0] == "status":
 		answer(w.Status())
+
 		return
 	case len(fields) == 1 && fields[0] == "unlink":
 		request.unlink = true
@@ -231,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.")
+
 			return
 		}
 
 		request.phone = phone
 	default:
 		answer(whatsappUsage)
+
 		return
 	}
 
@@ -248,8 +358,8 @@ func (w *WhatsApp) Command(args string, answer func(text string)) {
 }
 
 // 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()
@@ -268,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 {
+	w.sessionMutex.Lock()
+	defer w.sessionMutex.Unlock()
+
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
 
@@ -283,12 +447,23 @@ func (w *WhatsApp) Close() error {
 	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)
 }
 
-// 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 {
@@ -318,23 +493,86 @@ func (w *WhatsApp) isLinked() bool {
 	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()
-	w.client = w.newClient(w.device, w.handle)
+	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()
+
+	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)
-	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
 }
 
-// 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
 	if w.timer != nil {
 		w.timer.Stop()
@@ -344,47 +582,67 @@ func (w *WhatsApp) close() {
 	w.client = nil
 	w.mutex.Unlock()
 
+	w.inbox.close()
+
 	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() {
-		return
+		return nil
+	}
+
+	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()
+	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 {
-		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.")
+
+	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.Unlock()
 
 	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
+
 	if client != nil {
 		ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
 		defer cancel()
@@ -392,34 +650,47 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 		logoutErr = client.Logout(ctx)
 	}
 
-	err := w.removeSession()
+	err = w.removeSession()
 	if err != nil {
 		answer("The unlink failed: " + w.redact(err.Error()))
-		return
+
+		return nil
 	}
 
+	w.logger.Info("unlinked")
+
 	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.")
-		return
+
+		return nil
 	}
 
 	answer("WhatsApp is unlinked.")
+
+	return nil
 }
 
 // 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 {
+	w.sessionMutex.Lock()
+	defer w.sessionMutex.Unlock()
+
 	w.mutex.Lock()
+
 	client := w.client
 	w.client = nil
 	w.linked = false
+	w.retrying = false
 	w.own = nil
 	w.connected = false
+	w.disconnectedAt = time.Time{}
 	if w.timer != nil {
 		w.timer.Stop()
 	}
@@ -430,11 +701,14 @@ func (w *WhatsApp) removeSession() error {
 	w.device = nil
 	w.mutex.Unlock()
 
+	w.inbox.stopCatchup()
+
 	if client != nil {
 		client.Disconnect()
 	}
 
 	var err error
+
 	if container != nil {
 		err = container.Close()
 	}
@@ -449,15 +723,22 @@ func (w *WhatsApp) removeSession() error {
 	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())
+
 		return
 	}
 
@@ -471,11 +752,12 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
 
 	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())
+
 		return
 	}
 
@@ -483,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.")
+
 			return
 		}
 	case <-ctx.Done():
@@ -493,9 +776,12 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
 		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.")
+
 		return
 	}
 
@@ -504,6 +790,7 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f
 
 	for {
 		var item whatsmeow.QRChannelItem
+
 		open := true
 		select {
 		case item, open = <-qr:
@@ -518,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)
+
 			return
 		case item.Event == whatsmeow.QRChannelEventCode:
 			continue
 		case item.Event == whatsmeow.QRChannelSuccess.Event:
 			linked = true
+
 			w.linkedBy(client)
+			w.logger.Info("linked")
 
 			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 + ".")
@@ -535,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
 		}
 	}
@@ -544,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) {
+	w.sessionMutex.Lock()
+	defer w.sessionMutex.Unlock()
+
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
 
@@ -583,19 +877,63 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 	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 {
-	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
+
+	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:
+		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.connected = true
+		w.retrying = false
 		w.connectedAt = w.clock()
 		if w.timer != nil {
 			w.timer.Stop()
@@ -606,30 +944,42 @@ func (w *WhatsApp) handle(event any) bool {
 			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.LoggedOut:
+		w.retrying = false
 		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."
+			level = slog.LevelError
+			line = "disconnected for good, restart to retry"
+			attrs = append(attrs, "err", whatsappRedact(w.own, event.PermanentDisconnectDescription()))
 		}
 	}
+
+	if w.closed {
+		line = ""
+	}
+
 	w.mutex.Unlock()
 
+	if line != "" {
+		w.logger.Log(context.Background(), level, line, attrs...)
+	}
+
 	if notice != "" {
 		w.broadcast(notice)
 	}
@@ -641,6 +991,7 @@ func (w *WhatsApp) handle(event any) bool {
 // 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
@@ -657,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()
+
 	notify := w.notify
 	closed := w.closed
 	w.mutex.Unlock()
@@ -674,11 +1026,17 @@ func (w *WhatsApp) redact(text string) string {
 	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
@@ -689,14 +1047,24 @@ type WhatsAppRequest struct {
 	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
-// 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 {
-	store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})
 	client := whatsmeow.NewClient(device, waLog.Noop)
-	client.InitialAutoReconnect = true
+	client.InitialAutoReconnect = device.ID == nil
 	client.SynchronousAck = true
 	client.ManualHistorySyncDownload = true
 	client.AddEventHandlerWithSuccessStatus(handle)
@@ -704,9 +1072,52 @@ func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsA
 	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
+
 	for _, id := range ids {
 		if id != "" {
 			own = append(own, id)
@@ -716,6 +1127,15 @@ func whatsappOwnIDs(ids ...string) []string {
 	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.
@@ -750,9 +1170,9 @@ func whatsappCommandArgs(line string) (string, bool) {
 	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") == ""