Send stored images to WhatsApp chats

[onechat] / whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 95e1d54ea01e80f8216f29e38d63a56a479cc07a..57bfab078301a01907a3c6d898421f24c37df814 100644 (file)
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -2,6 +2,7 @@ package main
 
 import (
        "context"
 
 import (
        "context"

+       "database/sql"

        "errors"
        "fmt"
        "log/slog"
        "errors"
        "fmt"
        "log/slog"


@@ -53,17 +54,17 @@ const (
        // whatsappTimeLayout is the layout of the times in the answers.
        whatsappTimeLayout = "2006-01-02 15:04"
 
        // whatsappTimeLayout is the layout of the times in the answers.
        whatsappTimeLayout = "2006-01-02 15:04"
 

-       // whatsappPairTime is the longest time of a pairing. The library closes
-       // the pairing connection after about 160 seconds.
-       whatsappPairTime = 3 * time.Minute
+       // whatsappPairTimeout is the longest time of a pairing. The library
+       // closes the pairing connection after about 160 seconds.
+       whatsappPairTimeout = 3 * time.Minute

 
 

-       // whatsappLogoutTime is the longest time of the logout call of an
+       // whatsappLogoutTimeout is the longest time of the logout call of an

        // unlink.
        // unlink.

-       whatsappLogoutTime = 30 * time.Second
+       whatsappLogoutTimeout = 30 * time.Second

 
 

-       // whatsappNoticeDelay is how long a disconnection lasts before the user
-       // gets a notice.
-       whatsappNoticeDelay = 10 * time.Minute
+       // whatsappOutageNoticeDelay is the delay from a disconnection to its
+       // notice to the user.
+       whatsappOutageNoticeDelay = 10 * time.Minute

 
        // whatsappRetryDelay is the first wait after a failed starting
        // connection.
 
        // whatsappRetryDelay is the first wait after a failed starting
        // connection.


@@ -76,10 +77,6 @@ const (
        // wait for Run.
        whatsappRequests = 8
 
        // 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."
 )
        // 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."
 )


@@ -94,6 +91,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)

+       Download(ctx context.Context, message whatsmeow.DownloadableMessage) ([]byte, error)
+       Upload(ctx context.Context, data []byte, mediaType whatsmeow.MediaType) (whatsmeow.UploadResponse, error)

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


@@ -105,24 +104,24 @@ type WhatsAppClient interface {
 // the client of a device with its event handler.
 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{
 // the client of a device with its event handler.
 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,
-               logger:      logger,
-               newClient:   newClient,
-               noticeDelay: whatsappNoticeDelay,
-               requests:    make(chan WhatsAppRequest, whatsappRequests),
-               logouts:     make(chan struct{}, 1),
-               groups:      newWhatsAppGroups(logger),
+               ctx:       ctx,
+               dir:       filepath.Join(dir, whatsappDirName),
+               clock:     clock,
+               logger:    logger,
+               newClient: newClient,
+               requests:  make(chan WhatsAppRequest, whatsappRequests),
+               logouts:   make(chan struct{}, 1),
+               groups:    newWhatsAppGroups(logger),

        }
 
        var err error
 
        }
 
        var err error
 

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

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

-       w.inbox = newWhatsAppInbox(w.state, clock, w.groups)
+       w.inbox = newWhatsAppInbox(w.state, clock, w.groups, &ImageStore{dir: filepath.Join(dir, imageDirName)}, logger)

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


@@ -163,11 +162,16 @@ 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.
+// 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.
+//
+// ctx is the caller context until Run sets its context for library callbacks.
+// The mutex protects it, so callbacks follow daemon cancellation.

 //
 //

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


@@ -177,17 +181,19 @@ 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      *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
-
+       ctx       context.Context
+       dir       string
+       clock     func() time.Time
+       logger    *slog.Logger
+       newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient
+       requests  chan WhatsAppRequest
+       logouts   chan struct{}
+       state     *WhatsAppState
+       groups    *WhatsAppGroups
+       inbox     *WhatsAppInbox
+       routes    *Routes
+
+       sessionMutex   sync.Mutex

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


@@ -218,6 +224,7 @@ type WhatsApp struct {
 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.ctx = ctx

        w.notify = notify
        linked := w.linked
        w.retrying = linked
        w.notify = notify
        linked := w.linked
        w.retrying = linked


@@ -303,7 +310,7 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err
                        case w.isLinked():
                                request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
                        default:
                        case w.isLinked():
                                request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
                        default:

-                               pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTime)
+                               pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTimeout)

                                cancel = cancelPair
                                pairing.Go(func() {
                                        defer cancelPair()
                                cancel = cancelPair
                                pairing.Go(func() {
                                        defer cancelPair()


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

-// linked and disconnected, with the times of the connection. It never holds the
-// phone number.
+// linked and disconnected, with the times of the connection and the routes.
+// Route source IDs can hold the phone numbers of other chats.

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

+       routes := ""
+       if w.routes != nil {
+               listed := w.routes.List()
+               if listed != "No routes." {
+                       routes = "\nWhatsApp routes:\n" + listed
+               }
+       }
+

        switch {
        case !w.linked:
        switch {
        case !w.linked:

-               return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it."
+               return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it." + routes

        case w.connected:
        case w.connected:

-               return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "."
+               return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes

        case w.disconnectedAt.IsZero():
        case w.disconnectedAt.IsZero():

-               return "WhatsApp is linked and not connected yet."
+               return "WhatsApp is linked and not connected yet." + routes

        case w.connectedAt.IsZero():
        case w.connectedAt.IsZero():

-               return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "."
+               return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "." + routes

        default:
        default:

-               return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "."
+               return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes
+       }
+}
+
+// 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()
 


@@ -394,10 +463,10 @@ func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {
        return whatsappFind(ctx, w.link(), w.groups, name)
 }
 
        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)
+// Send returns the answer of whatsapp_send for text and an optional stored
+// image to chat, with the durable send id that whatsappSend describes.
+func (w *WhatsApp) Send(ctx context.Context, id, chat, text, image string) (string, error) {
+       return whatsappSend(ctx, w.link(), w.groups, w.state, w.inbox.images, w.clock, id, chat, text, image)

 }
 
 func (w *WhatsApp) sessionPath() string {
 }
 
 func (w *WhatsApp) sessionPath() string {


@@ -501,7 +570,7 @@ func (w *WhatsApp) startOutage() bool {
                w.disconnectedAt = w.clock()
                w.disconnections++
                disconnections := w.disconnections
                w.disconnectedAt = w.clock()
                w.disconnections++
                disconnections := w.disconnections

-               w.timer = time.AfterFunc(w.noticeDelay, func() {
+               w.timer = time.AfterFunc(whatsappOutageNoticeDelay, func() {

                        w.disconnectedLong(disconnections)
                })
        }
                        w.disconnectedLong(disconnections)
                })
        }


@@ -586,7 +655,7 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
        var logoutErr error
 
        if client != nil {
        var logoutErr error
 
        if client != nil {

-               ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
+               ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTimeout)

                defer cancel()
 
                logoutErr = client.Logout(ctx)
                defer cancel()
 
                logoutErr = client.Logout(ctx)


@@ -618,8 +687,12 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 }
 
 // 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()
 
        client := w.client
        w.mutex.Lock()
 
        client := w.client


@@ -773,6 +846,9 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string,
 // 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()
 


@@ -815,19 +891,25 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 // 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
 // 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.
+// or after whatsappCatchupTimeout. A disconnection keeps the time of its start
+// while Run or the library tries again. After whatsappOutageNoticeDelay 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 {
 //
 // 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 {

+       w.mutex.Lock()
+
+       ctx := w.ctx
+       w.mutex.Unlock()
+

        switch event := event.(type) {
        case *events.Message:
        switch event := event.(type) {
        case *events.Message:

-               return w.inbox.receive(w.link(), event)
+               return w.inbox.receive(ctx, w.link(), event)

        case *events.GroupInfo:
                if event.Name != nil {
                        w.groups.set(event.JID.String(), event.Name.Name)
        case *events.GroupInfo:
                if event.Name != nil {
                        w.groups.set(event.JID.String(), event.Name.Name)


@@ -912,7 +994,7 @@ func (w *WhatsApp) handle(event any) bool {
        w.mutex.Unlock()
 
        if line != "" {
        w.mutex.Unlock()
 
        if line != "" {

-               w.logger.Log(context.Background(), level, line, attrs...)
+               w.logger.Log(ctx, level, line, attrs...)

        }
 
        if notice != "" {
        }
 
        if notice != "" {