aird 0.4.23.dev11__tar.gz → 0.4.23.dev17__tar.gz

{aird-0.4.23.dev11 → aird-0.4.23.dev17}/MANIFEST.in

@@ -4,3 +4,4 @@ recursive-include aird/static/js *.js
 recursive-include aird/static/img *
 include aird/static/favicon.png
 include aird/static/favicon.ico
+include aird/static/favicon.svg

{aird-0.4.23.dev11/aird.egg-info → aird-0.4.23.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aird
-Version: 0.4.23.dev11
+Version: 0.4.23.dev17
 Summary: Aird - A lightweight web-based file browser, editor, and streamer with real-time capabilities
 Home-page: https://github.com/blinkerbit/aird
 Author: Viswantha Srinivas P

{aird-0.4.23.dev11 → aird-0.4.23.dev17}/aird/cli/session.py

@@ -6,7 +6,6 @@ import json
 import logging
 import os
 import re
-import uuid
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Callable, Iterator
@@ -15,12 +14,10 @@ from urllib.parse import quote, urljoin
 import requests
 
 from aird.cli.config import ensure_config_dir, get_authelia_url, get_server_url, session_path
-from aird.constants import UPLOAD_CHUNK_SIZE_BYTES
 
 logger = logging.getLogger(__name__)
 
 XSRF_COOKIE = "_xsrf"
-CHUNK_SIZE = UPLOAD_CHUNK_SIZE_BYTES
 
 
 def _remote_url(base_path: str, remote_path: str) -> str:
@@ -280,86 +277,28 @@ class AirdClient:
                     on_progress(path)
         return count
 
-    def _upload_chunk(
-        self,
-        upload_id: str,
-        remote_dir: str,
-        filename: str,
-        data: bytes,
-        offset: int,
-        total_size: int,
-        chunk_last: bool,
-    ) -> None:
-        params: dict[str, str | int] = {
-            "upload_id": upload_id,
-            "upload_dir": remote_dir,
-            "upload_filename": filename,
-            "chunk_offset": offset,
-            "total_size": total_size,
-        }
-        if chunk_last:
-            params["chunk_last"] = 1
+    def upload_file(self, local_path: Path, remote_dir: str = "") -> None:
+        self.ensure_auth()
+        if not local_path.is_file():
+            raise FileNotFoundError(local_path)
+        remote_dir = remote_dir.strip("/")
+        filename = local_path.name
         r = self.http.post(
             self._url("/upload"),
-            params=params,
-            data=data,
+            params={"upload_dir": remote_dir, "upload_filename": filename},
+            data=local_path.read_bytes(),
             headers={
                 **self._xsrf_header(),
                 "Content-Type": "application/octet-stream",
             },
-            timeout=300,
+            timeout=600,
         )
         if r.status_code >= 400:
             raise AirdAPIError(
-                f"Upload chunk failed for {filename} (HTTP {r.status_code})",
+                f"Upload failed for {filename} (HTTP {r.status_code})",
                 r.status_code,
             )
 
-    def upload_file(self, local_path: Path, remote_dir: str = "") -> None:
-        self.ensure_auth()
-        if not local_path.is_file():
-            raise FileNotFoundError(local_path)
-        remote_dir = remote_dir.strip("/")
-        filename = local_path.name
-        total = local_path.stat().st_size
-        upload_id = uuid.uuid4().hex
-
-        if total <= CHUNK_SIZE:
-            r = self.http.post(
-                self._url("/upload"),
-                params={"upload_dir": remote_dir, "upload_filename": filename},
-                data=local_path.read_bytes(),
-                headers={
-                    **self._xsrf_header(),
-                    "Content-Type": "application/octet-stream",
-                },
-                timeout=300,
-            )
-            if r.status_code >= 400:
-                raise AirdAPIError(
-                    f"Upload failed for {filename} (HTTP {r.status_code})",
-                    r.status_code,
-                )
-            return
-
-        offset = 0
-        with local_path.open("rb") as f:
-            while offset < total:
-                chunk = f.read(CHUNK_SIZE)
-                if not chunk:
-                    break
-                chunk_last = offset + len(chunk) >= total
-                self._upload_chunk(
-                    upload_id,
-                    remote_dir,
-                    filename,
-                    chunk,
-                    offset,
-                    total,
-                    chunk_last=chunk_last,
-                )
-                offset += len(chunk)
-
     def upload_tree(
         self,
         local_dir: Path,

{aird-0.4.23.dev11 → aird-0.4.23.dev17}/aird/config.py

@@ -16,9 +16,7 @@ from aird.constants import (
     ALLOWED_UPLOAD_EXTENSIONS as _ALLOWED_UPLOAD_EXTENSIONS,
     MMAP_MIN_SIZE as _MMAP_MIN_SIZE,
     CHUNK_SIZE as _CHUNK_SIZE,
-    UPLOAD_CHUNK_SIZE_BYTES as _UPLOAD_CHUNK_SIZE_BYTES,
     UPLOAD_REQUEST_MAX_BODY_SIZE as _UPLOAD_REQUEST_MAX_BODY_SIZE,
-    UPLOAD_MAX_PARALLEL_CHUNKS as _UPLOAD_MAX_PARALLEL_CHUNKS,
 )
 
 # Module-level variables to hold configuration
@@ -49,9 +47,35 @@ MAX_READABLE_FILE_SIZE = _MAX_READABLE_FILE_SIZE
 ALLOWED_UPLOAD_EXTENSIONS = _ALLOWED_UPLOAD_EXTENSIONS
 MMAP_MIN_SIZE = _MMAP_MIN_SIZE
 CHUNK_SIZE = _CHUNK_SIZE
-UPLOAD_CHUNK_SIZE_BYTES = _UPLOAD_CHUNK_SIZE_BYTES
 UPLOAD_REQUEST_MAX_BODY_SIZE = _UPLOAD_REQUEST_MAX_BODY_SIZE
-UPLOAD_MAX_PARALLEL_CHUNKS = _UPLOAD_MAX_PARALLEL_CHUNKS
+BREVO_API_KEY = None
+BREVO_SENDER_EMAIL = None
+BREVO_SENDER_NAME = "Aird"
+PUBLIC_BASE_URL = None
+
+
+def _apply_brevo_settings(config: dict) -> None:
+    global BREVO_API_KEY, BREVO_SENDER_EMAIL, BREVO_SENDER_NAME, PUBLIC_BASE_URL
+    brevo = config.get("brevo") if isinstance(config, dict) else {}
+    if not isinstance(brevo, dict):
+        brevo = {}
+    BREVO_API_KEY = (
+        os.environ.get("AIRD_BREVO_API_KEY", "").strip() or brevo.get("api_key")
+    )
+    BREVO_SENDER_EMAIL = (
+        os.environ.get("AIRD_BREVO_SENDER_EMAIL", "").strip()
+        or brevo.get("sender_email")
+    )
+    BREVO_SENDER_NAME = (
+        os.environ.get("AIRD_BREVO_SENDER_NAME", "").strip()
+        or brevo.get("sender_name")
+        or "Aird"
+    )
+    PUBLIC_BASE_URL = (
+        os.environ.get("AIRD_PUBLIC_BASE_URL", "").strip()
+        or brevo.get("public_base_url")
+        or None
+    )
 
 
 def _configure_google_drive(cloud_config: dict) -> None:
@@ -172,6 +196,7 @@ def init_config():
     global LDAP_BASE_DN, LDAP_USER_TEMPLATE, LDAP_FILTER_TEMPLATE, LDAP_ATTRIBUTES
     global LDAP_ATTRIBUTE_MAP, HOSTNAME, SSL_CERT, SSL_KEY, ADMIN_USERS, FEATURE_FLAGS, CLOUD_MANAGER
     global MULTI_USER, WORKERS
+    global BREVO_API_KEY, BREVO_SENDER_EMAIL, BREVO_SENDER_NAME, PUBLIC_BASE_URL
 
     parser = argparse.ArgumentParser(description="Run Aird")
     parser.add_argument("--config", help="Path to JSON config file")
@@ -251,6 +276,7 @@ def init_config():
     LDAP_ATTRIBUTE_MAP = ldap_settings["attribute_map"]
 
     _apply_feature_flags_from_config(config)
+    _apply_brevo_settings(config)
 
     MULTI_USER = args.multi_user or config.get("multi_user", False)
 

{aird-0.4.23.dev11 → aird-0.4.23.dev17}/aird/constants/__init__.py

@@ -2,6 +2,7 @@
 
 import os
 import sys
+from pathlib import Path
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
 from aird.cloud import CloudManager
@@ -41,6 +42,7 @@ FEATURE_FLAGS = {
     "storage_quotas": False,
     "abac_engine": False,
     "abac_audit_decisions": True,
+    "email_notifications": False,
 }
 
 # WebSocket connection configuration
@@ -59,13 +61,10 @@ UPLOAD_CONFIG = {
     "allow_all_file_types": 0,  # 0 = use whitelist below, 1 = allow any extension
 }
 
-# Per-request body limit (Cloudflare: keep each POST under ~100 MB and ~100s proxy timeout)
-UPLOAD_CHUNK_SIZE_BYTES = 50 * 1024 * 1024  # 50 MiB per HTTP request
-UPLOAD_REQUEST_MAX_BODY_SIZE = UPLOAD_CHUNK_SIZE_BYTES + (1024 * 1024)  # chunk + slack
-UPLOAD_MAX_PARALLEL_CHUNKS = 3  # fewer concurrent POSTs through reverse proxies
-
 # File operation constants (derived from UPLOAD_CONFIG at startup)
 MAX_FILE_SIZE = UPLOAD_CONFIG["max_file_size_mb"] * 1024 * 1024
+# HTTP /upload body limit (browser uploads use WebSocket; CLI may POST whole file)
+UPLOAD_REQUEST_MAX_BODY_SIZE = MAX_FILE_SIZE + (1024 * 1024)
 MAX_READABLE_FILE_SIZE = 50 * 1024 * 1024  # 50 MB
 
 # Default line window for /files/... viewer when no ?end_line= is supplied (protects DOM from huge renders)
@@ -102,6 +101,8 @@ UPLOAD_ALLOWED_EXTENSIONS = set(ALLOWED_UPLOAD_EXTENSIONS)
 # Mmap constants
 MMAP_MIN_SIZE = 1 * 1024 * 1024  # 1 MB
 CHUNK_SIZE = 64 * 1024  # 64 KB
+# WebSocket binary frame size (stay under Cloudflare ~1 MiB message limit)
+WS_TRANSFER_FRAME_BYTES = 768 * 1024
 
 # Network share manager (set at startup)
 NETWORK_SHARE_MANAGER = None
@@ -143,3 +144,42 @@ def _read_app_version() -> str:
 
 
 APP_VERSION = _read_app_version()
+
+_UI_PACKAGE_SUFFIXES = frozenset(
+    {".html", ".css", ".js", ".png", ".ico", ".svg", ".jpg", ".jpeg", ".webp", ".gif"}
+)
+_PKG_ROOT = Path(__file__).resolve().parent.parent
+_static_version_cache: tuple[float, str] | None = None
+_STATIC_VERSION_TTL = 2.0
+
+
+def _ui_fingerprint() -> str:
+    """Hex fingerprint from latest mtime among shipped UI package-data files."""
+    latest = 0
+    for sub in ("static", "templates"):
+        base = _PKG_ROOT / sub
+        if not base.is_dir():
+            continue
+        for path in base.rglob("*"):
+            if not path.is_file():
+                continue
+            if path.suffix.lower() not in _UI_PACKAGE_SUFFIXES:
+                continue
+            try:
+                latest = max(latest, path.stat().st_mtime_ns)
+            except OSError:
+                pass
+    return format(latest, "x")
+
+
+def get_static_version() -> str:
+    """Cache-bust query value: package version plus UI file fingerprint."""
+    import time
+
+    global _static_version_cache
+    now = time.monotonic()
+    if _static_version_cache and now - _static_version_cache[0] < _STATIC_VERSION_TTL:
+        return _static_version_cache[1]
+    version = f"{APP_VERSION}-{_ui_fingerprint()}"
+    _static_version_cache = (now, version)
+    return version

{aird-0.4.23.dev11 → aird-0.4.23.dev17}/aird/core/events.py

@@ -46,6 +46,8 @@ class ShareCreatedEvent:
     creator: str
     path_count: int
     created_at: float
+    allowed_users: tuple[str, ...] = ()
+    modify_users: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)

aird-0.4.23.dev17/aird/core/folder_size.py

@@ -0,0 +1,101 @@
+"""Incremental folder size calculation (sum of file sizes)."""
+
+from __future__ import annotations
+
+import os
+
+
+# Files processed per batch before yielding back to the event loop.
+FOLDER_SIZE_BATCH_FILES = 250
+
+
+class FolderSizeWalker:
+    """Walk a directory tree in batches without loading all paths at once."""
+
+    def __init__(self, root_abspath: str) -> None:
+        self._walk_gen = os.walk(root_abspath)
+        self._current_dir: str | None = None
+        self._pending_files: list[str] = []
+        self.total_bytes = 0
+        self.file_count = 0
+        self.done = False
+
+    def step(self, batch_size: int = FOLDER_SIZE_BATCH_FILES) -> tuple[int, int, bool]:
+        """Process up to *batch_size* files. Returns (total_bytes, file_count, done)."""
+        if self.done:
+            return self.total_bytes, self.file_count, True
+
+        processed = 0
+        while processed < batch_size and not self.done:
+            if not self._pending_files:
+                try:
+                    self._current_dir, _dirnames, filenames = next(self._walk_gen)
+                    self._pending_files = list(filenames)
+                except StopIteration:
+                    self.done = True
+                    break
+
+            while self._pending_files and processed < batch_size:
+                fname = self._pending_files.pop()
+                if not self._current_dir:
+                    continue
+                fpath = os.path.join(self._current_dir, fname)
+                try:
+                    if os.path.isfile(fpath):
+                        self.total_bytes += os.path.getsize(fpath)
+                except OSError:
+                    pass
+                self.file_count += 1
+                processed += 1
+
+        return self.total_bytes, self.file_count, self.done
+
+
+def norm_rel_path(rel_path: str) -> str:
+    return rel_path.replace("\\", "/").strip().strip("/")
+
+
+def resolve_folder_abspath(user_root: str, rel_path: str) -> str | None:
+    """Return absolute folder path or None if invalid / not a directory."""
+    from aird.core.security import is_within_root
+
+    rel = norm_rel_path(rel_path)
+    if not rel or ".." in rel.split("/"):
+        return None
+    abs_path = os.path.abspath(os.path.join(user_root, rel))
+    if not is_within_root(abs_path, user_root) or not os.path.isdir(abs_path):
+        return None
+    return abs_path
+
+
+def compute_folder_size(root_abspath: str) -> tuple[int, int]:
+    """Sum file sizes under *root_abspath*. Returns (total_bytes, file_count)."""
+    walker = FolderSizeWalker(root_abspath)
+    while not walker.done:
+        walker.step(FOLDER_SIZE_BATCH_FILES)
+    return walker.total_bytes, walker.file_count
+
+
+def norm_rel_path(rel_path: str) -> str:
+    return rel_path.replace("\\", "/").strip().strip("/")
+
+
+def resolve_folder_abspath(user_root: str, rel_path: str) -> str | None:
+    """Return absolute folder path or None if invalid / not a directory."""
+    from aird.core.security import is_within_root
+
+    rel = norm_rel_path(rel_path)
+    if not rel or ".." in rel.split("/"):
+        return None
+    abs_path = os.path.abspath(os.path.join(user_root, rel))
+    if not is_within_root(abs_path, user_root) or not os.path.isdir(abs_path):
+        return None
+    return abs_path
+
+
+def compute_folder_size(root_abspath: str) -> tuple[int, int]:
+    """Sum file sizes under *root_abspath*. Returns (total_bytes, file_count)."""
+    walker = FolderSizeWalker(root_abspath)
+    while not walker.done:
+        walker.step(FOLDER_SIZE_BATCH_FILES)
+    return walker.total_bytes, walker.file_count

{aird-0.4.23.dev11 → aird-0.4.23.dev17}/aird/core/mmap_handler.py

@@ -25,20 +25,50 @@ def _read_chunks_sync(
     return chunks
 
 
-def _read_chunks_mmap(
-    file_path: str, start: int, end: int | None, file_size: int, chunk_size: int
-) -> list[bytes]:
-    """Read file chunks using mmap."""
-    chunks = []
-    with open(file_path, "rb") as f:
-        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
-            actual_end = min(end or file_size - 1, file_size - 1)
-            current = start
-            while current <= actual_end:
-                chunk_end = min(current + chunk_size, actual_end + 1)
-                chunks.append(mm[current:chunk_end])
-                current = chunk_end
-    return chunks
+class _SyncChunkReader:
+    """Read one chunk at a time from disk (mmap or plain file)."""
+
+    def __init__(
+        self,
+        file_path: str,
+        start: int,
+        end: int | None,
+        file_size: int,
+        chunk_size: int,
+        use_mmap: bool,
+    ) -> None:
+        self._file_path = file_path
+        self._pos = start
+        self._end = min(end if end is not None else file_size - 1, file_size - 1)
+        self._chunk_size = chunk_size
+        self._use_mmap = use_mmap
+        self._file = None
+        self._mm = None
+
+    def open(self) -> None:
+        self._file = open(self._file_path, "rb")
+        if self._use_mmap:
+            self._mm = mmap.mmap(self._file.fileno(), 0, access=mmap.ACCESS_READ)
+
+    def read_next(self) -> bytes | None:
+        if self._pos > self._end:
+            return None
+        chunk_end = min(self._pos + self._chunk_size, self._end + 1)
+        if self._mm is not None:
+            chunk = self._mm[self._pos : chunk_end]
+        else:
+            self._file.seek(self._pos)
+            chunk = self._file.read(chunk_end - self._pos)
+        self._pos = chunk_end
+        return chunk if chunk else None
+
+    def close(self) -> None:
+        if self._mm is not None:
+            self._mm.close()
+            self._mm = None
+        if self._file is not None:
+            self._file.close()
+            self._file = None
 
 
 class MMapFileHandler:
@@ -53,12 +83,11 @@ class MMapFileHandler:
     async def serve_file_chunk(
         file_path: str, start: int = 0, end: int = None, chunk_size: int = CHUNK_SIZE
     ):
-        """Serve file chunks using mmap for efficient memory usage"""
+        """Serve file chunks; only one chunk is held in memory at a time."""
         try:
             file_size = await asyncio.to_thread(os.path.getsize, file_path)
 
             if not MMapFileHandler.should_use_mmap(file_size):
-                # Use async file API for small files
                 remaining = (end - start + 1) if end is not None else file_size - start
                 async with aiofiles.open(file_path, "rb") as f:
                     await f.seek(start)
@@ -70,21 +99,33 @@ class MMapFileHandler:
                         remaining -= len(chunk)
                 return
 
-            # Use mmap for large files (run in thread pool - mmap requires sync fd)
-            chunks = await asyncio.to_thread(
-                _read_chunks_mmap, file_path, start, end, file_size, chunk_size
+            reader = _SyncChunkReader(
+                file_path, start, end, file_size, chunk_size, use_mmap=True
             )
-            for chunk in chunks:
-                yield chunk
+            try:
+                await asyncio.to_thread(reader.open)
+                while True:
+                    chunk = await asyncio.to_thread(reader.read_next)
+                    if not chunk:
+                        break
+                    yield chunk
+            finally:
+                await asyncio.to_thread(reader.close)
 
         except (OSError, ValueError):
-            # Fallback to traditional method on mmap errors (run in thread pool)
             file_size = await asyncio.to_thread(os.path.getsize, file_path)
-            chunks = await asyncio.to_thread(
-                _read_chunks_sync, file_path, start, end, file_size, chunk_size
+            reader = _SyncChunkReader(
+                file_path, start, end, file_size, chunk_size, use_mmap=False
             )
-            for chunk in chunks:
-                yield chunk
+            try:
+                await asyncio.to_thread(reader.open)
+                while True:
+                    chunk = await asyncio.to_thread(reader.read_next)
+                    if not chunk:
+                        break
+                    yield chunk
+            finally:
+                await asyncio.to_thread(reader.close)
 
     @staticmethod
     def find_line_offsets(file_path: str, max_lines: int = None) -> list[int]:

aird-0.4.23.dev17/aird/core/zip_download.py

@@ -0,0 +1,116 @@
+"""Build ZIP archives from user file paths."""
+
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+import zipfile
+from typing import Iterable
+
+from aird.core.security import is_within_root
+
+logger = logging.getLogger(__name__)
+
+MAX_ZIP_ENTRIES = 10_000
+MAX_ZIP_UNCOMPRESSED_BYTES = 2 * 1024 * 1024 * 1024  # 2 GiB
+
+
+class ZipDownloadError(Exception):
+    """Raised when a zip cannot be built."""
+
+    def __init__(self, message: str, status: int = 400):
+        super().__init__(message)
+        self.status = status
+
+
+def _normalise_rel_path(path: str) -> str:
+    return path.replace("\\", "/").strip().strip("/")
+
+
+def _safe_arcname(rel_path: str) -> str | None:
+    parts = [p for p in _normalise_rel_path(rel_path).split("/") if p and p not in (".", "..")]
+    if not parts:
+        return None
+    return "/".join(parts)
+
+
+def collect_zip_entries(root_dir: str, paths: Iterable[str]) -> list[tuple[str, str]]:
+    """Return (absolute_path, archive_name) pairs for all files under *paths*."""
+    root_dir = os.path.realpath(root_dir)
+    entries: list[tuple[str, str]] = []
+    seen_arc: set[str] = set()
+    total_bytes = 0
+
+    for raw in paths:
+        if not isinstance(raw, str):
+            raise ZipDownloadError("Invalid path", 400)
+        rel = _normalise_rel_path(raw)
+        if not rel:
+            continue
+        abspath = os.path.realpath(os.path.join(root_dir, rel))
+        if not is_within_root(abspath, root_dir):
+            raise ZipDownloadError("Access denied", 403)
+        if not os.path.exists(abspath):
+            raise ZipDownloadError(f"Not found: {rel}", 404)
+
+        def add_file(file_abs: str, arc: str | None) -> None:
+            nonlocal total_bytes
+            if arc is None:
+                return
+            if arc in seen_arc:
+                return
+            try:
+                size = os.path.getsize(file_abs)
+            except OSError:
+                return
+            total_bytes += size
+            if total_bytes > MAX_ZIP_UNCOMPRESSED_BYTES:
+                raise ZipDownloadError("Selection is too large to zip", 413)
+            seen_arc.add(arc)
+            entries.append((file_abs, arc))
+            if len(entries) > MAX_ZIP_ENTRIES:
+                raise ZipDownloadError("Too many files in selection", 400)
+
+        if os.path.isfile(abspath):
+            add_file(abspath, _safe_arcname(rel))
+            continue
+
+        if os.path.isdir(abspath):
+            prefix = _safe_arcname(rel)
+            for dirpath, _dirnames, filenames in os.walk(abspath):
+                for fname in filenames:
+                    full = os.path.join(dirpath, fname)
+                    if not os.path.isfile(full):
+                        continue
+                    file_rel = os.path.relpath(full, root_dir).replace("\\", "/")
+                    add_file(full, _safe_arcname(file_rel))
+            continue
+
+        raise ZipDownloadError(f"Not a file or folder: {rel}", 400)
+
+    return entries
+
+
+def build_zip_file(entries: list[tuple[str, str]]) -> str:
+    """Write entries to a temporary store-only zip (no compression, low CPU)."""
+    if not entries:
+        raise ZipDownloadError("No files to download", 400)
+
+    fd, zip_path = tempfile.mkstemp(prefix="aird_zip_", suffix=".zip")
+    os.close(fd)
+    try:
+        # ZIP_STORED: pack files without deflate — minimal CPU; larger wire size.
+        with zipfile.ZipFile(
+            zip_path, "w", compression=zipfile.ZIP_STORED, allowZip64=True
+        ) as zf:
+            for file_abs, arcname in entries:
+                zf.write(file_abs, arcname, compress_type=zipfile.ZIP_STORED)
+    except Exception:
+        logger.exception("ZIP build failed")
+        try:
+            os.remove(zip_path)
+        except OSError:
+            pass
+        raise ZipDownloadError("Failed to create zip archive", 500) from None
+    return zip_path

aird-0.4.23.dev17/aird/email/__init__.py

@@ -0,0 +1,6 @@
+"""Outbound email (Brevo transactional API)."""
+
+from aird.email.brevo import BrevoClient
+from aird.email.resolve import resolve_user_email
+
+__all__ = ["BrevoClient", "resolve_user_email"]