slidge-whatsapp 0.2.2__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/gateway.go

@@ -0,0 +1,181 @@
+package whatsapp
+
+import (
+	// Standard library.
+	"fmt"
+	"log/slog"
+	"os"
+	"runtime"
+
+	// Internal packages.
+	"codeberg.org/slidge/slidge-whatsapp/slidge_whatsapp/media"
+
+	// Third-party libraries.
+	_ "github.com/mattn/go-sqlite3"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/store/sqlstore"
+	"go.mau.fi/whatsmeow/types"
+	walog "go.mau.fi/whatsmeow/util/log"
+)
+
+const (
+	// Maximum number of concurrent gateway calls to handle before blocking.
+	maxConcurrentGatewayCalls = 1024
+)
+
+// A LinkedDevice represents a unique pairing session between the gateway and WhatsApp. It is not
+// unique to the underlying "main" device (or phone number), as multiple linked devices may be paired
+// with any main device.
+type LinkedDevice struct {
+	// ID is an opaque string identifying this LinkedDevice to the Session. Noted that this string
+	// is currently equivalent to a password, and needs to be protected accordingly.
+	ID string
+}
+
+// JID returns the WhatsApp JID corresponding to the LinkedDevice ID. Empty or invalid device IDs
+// may return invalid JIDs, and this function does not handle errors.
+func (d LinkedDevice) JID() types.JID {
+	jid, _ := types.ParseJID(d.ID)
+	return jid
+}
+
+// A Gateway represents a persistent process for establishing individual sessions between linked
+// devices and WhatsApp.
+type Gateway struct {
+	DBPath   string // The filesystem path for the client database.
+	Name     string // The name to display when linking devices on WhatsApp.
+	LogLevel string // The verbosity level to use when logging messages.
+	TempDir  string // The directory to create temporary files under.
+
+	// Internal variables.
+	container *sqlstore.Container
+	callChan  chan (func())
+	logger    walog.Logger
+}
+
+// NewGateway returns a new, un-initialized Gateway. This function should always be followed by calls
+// to [Gateway.Init], assuming a valid [Gateway.DBPath] is set.
+func NewGateway() *Gateway {
+	return &Gateway{}
+}
+
+// Init performs initialization procedures for the Gateway, and is expected to be run before any
+// calls to [Gateway.Session].
+func (w *Gateway) Init() error {
+	w.logger = logger{
+		module: "Slidge",
+		logger: slog.New(
+			slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: logLevel(w.LogLevel)}),
+		),
+	}
+
+	container, err := sqlstore.New("sqlite3", w.DBPath, w.logger)
+	if err != nil {
+		return err
+	}
+
+	if w.Name != "" {
+		store.SetOSInfo(w.Name, [...]uint32{1, 0, 0})
+	}
+
+	if w.TempDir != "" {
+		media.SetTempDirectory(w.TempDir)
+	}
+
+	w.callChan = make(chan func(), maxConcurrentGatewayCalls)
+	w.container = container
+
+	go func() {
+		// Don't allow other Goroutines from using this thread, as this might lead to concurrent use of
+		// the GIL, which can lead to crashes.
+		runtime.LockOSThread()
+		defer runtime.UnlockOSThread()
+		for fn := range w.callChan {
+			fn()
+		}
+	}()
+
+	return nil
+}
+
+// NewSession returns a new [Session] for the LinkedDevice given. If the linked device does not have
+// a valid ID, a pair operation will be required, as described in [Session.Login].
+func (w *Gateway) NewSession(device LinkedDevice) *Session {
+	return &Session{device: device, gateway: w}
+}
+
+// CleanupSession will remove all invalid and obsolete references to the given device, and should be
+// used when pairing a new device or unregistering from the Gateway.
+func (w *Gateway) CleanupSession(device LinkedDevice) error {
+	devices, err := w.container.GetAllDevices()
+	if err != nil {
+		return err
+	}
+
+	for _, d := range devices {
+		if d.ID == nil {
+			w.logger.Infof("Removing invalid device %s from database", d.ID.String())
+			_ = d.Delete()
+		} else if device.ID != "" {
+			if jid := device.JID(); d.ID.ToNonAD() == jid.ToNonAD() && *d.ID != jid {
+				w.logger.Infof("Removing obsolete device %s from database", d.ID.String())
+				_ = d.Delete()
+			}
+		}
+	}
+
+	return nil
+}
+
+// A LogLevel represents a mapping between Python standard logging levels and Go standard logging
+// levels.
+type logLevel string
+
+var _ slog.Leveler = logLevel("")
+
+// Level returns the Go equivalent logging level for the Python logging level represented.
+func (l logLevel) Level() slog.Level {
+	switch l {
+	case "FATAL", "CRITICAL", "ERROR":
+		return slog.LevelError
+	case "WARN", "WARNING":
+		return slog.LevelWarn
+	case "DEBUG":
+		return slog.LevelDebug
+	default:
+		return slog.LevelInfo
+	}
+}
+
+// A Logger represents a mapping between a WhatsMeow logger and Go standard logging functions.
+type logger struct {
+	module string
+	logger *slog.Logger
+}
+
+var _ walog.Logger = logger{}
+
+// Errorf handles the given message as representing a (typically) fatal error.
+func (l logger) Errorf(msg string, args ...interface{}) {
+	l.logger.Error(fmt.Sprintf(msg, args...))
+}
+
+// Warn handles the given message as representing a non-fatal error or warning thereof.
+func (l logger) Warnf(msg string, args ...interface{}) {
+	l.logger.Warn(fmt.Sprintf(msg, args...))
+}
+
+// Infof handles the given message as representing an informational notice.
+func (l logger) Infof(msg string, args ...interface{}) {
+	l.logger.Info(fmt.Sprintf(msg, args...))
+}
+
+// Debugf handles the given message as representing an internal-only debug message.
+func (l logger) Debugf(msg string, args ...interface{}) {
+	l.logger.Debug(fmt.Sprintf(msg, args...))
+}
+
+// Sub is a no-op and will return the receiver itself.
+func (l logger) Sub(module string) walog.Logger {
+	return logger{logger: l.logger.With(slog.String("module", l.module+"."+module))}
+}

slidge_whatsapp/gateway.py

@@ -0,0 +1,82 @@
+from logging import getLevelName, getLogger
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from slidge import BaseGateway, FormField, GatewayUser, global_config
+
+from . import config
+from .generated import whatsapp
+
+if TYPE_CHECKING:
+    from .session import Session
+
+REGISTRATION_INSTRUCTIONS = (
+    "Continue and scan the resulting QR codes on your main device, or alternatively, "
+    "use the 'pair-phone' command to complete registration. More information at "
+    "https://slidge.im/slidge-whatsapp/user.html"
+)
+
+WELCOME_MESSAGE = (
+    "Thank you for registering! Please scan the following QR code on your main device "
+    "or use the 'pair-phone' command to complete registration, or type 'help' to list "
+    "other available commands."
+)
+
+
+class Gateway(BaseGateway):
+    COMPONENT_NAME = "WhatsApp (slidge)"
+    COMPONENT_TYPE = "whatsapp"
+    COMPONENT_AVATAR = "https://www.whatsapp.com/apple-touch-icon.png"
+    ROSTER_GROUP = "WhatsApp"
+
+    REGISTRATION_INSTRUCTIONS = REGISTRATION_INSTRUCTIONS
+    WELCOME_MESSAGE = WELCOME_MESSAGE
+    REGISTRATION_FIELDS = []
+
+    SEARCH_FIELDS = [
+        FormField(var="phone", label="Phone number", required=True),
+    ]
+
+    MARK_ALL_MESSAGES = True
+    GROUPS = True
+    PROPER_RECEIPTS = True
+
+    def __init__(self):
+        super().__init__()
+        self.whatsapp = whatsapp.NewGateway()
+        self.whatsapp.Name = "Slidge on " + str(global_config.JID)
+        self.whatsapp.LogLevel = getLevelName(getLogger().level)
+
+        assert config.DB_PATH is not None
+        Path(config.DB_PATH.parent).mkdir(exist_ok=True)
+        self.whatsapp.DBPath = str(config.DB_PATH)
+
+        (global_config.HOME_DIR / "tmp").mkdir(exist_ok=True)
+        self.whatsapp.TempDir = str(global_config.HOME_DIR / "tmp")
+        self.whatsapp.Init()
+
+    async def validate(self, user_jid, registration_form):
+        """
+        Validate registration form. A no-op for WhatsApp, as actual registration takes place
+        after in-band registration commands complete; see :meth:`.Session.login` for more.
+        """
+        pass
+
+    async def unregister(self, user: GatewayUser):
+        """
+        Logout from the active WhatsApp session. This will also force a remote log-out, and thus
+        require pairing on next login. For simply disconnecting the active session, look at the
+        :meth:`.Session.disconnect` function.
+        """
+        session: "Session" = self.get_session_from_user(user)  # type:ignore
+        session.whatsapp.Logout()
+        try:
+            device_id = session.user.legacy_module_data["device_id"]
+            self.whatsapp.CleanupSession(whatsapp.LinkedDevice(ID=device_id))
+        except KeyError:
+            pass
+        except RuntimeError as err:
+            log.error("Failed to clean up WhatsApp session: %s", err)
+
+
+log = getLogger(__name__)