aird 0.4.23.dev11__tar.gz → 0.4.23.dev12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aird
-Version: 0.4.23.dev11
+Version: 0.4.23.dev12
 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.dev12}/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.dev12}/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.dev12}/aird/constants/__init__.py

@@ -41,6 +41,7 @@ FEATURE_FLAGS = {
     "storage_quotas": False,
     "abac_engine": False,
     "abac_audit_decisions": True,
+    "email_notifications": False,
 }
 
 # WebSocket connection configuration
@@ -59,13 +60,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)

{aird-0.4.23.dev11 → aird-0.4.23.dev12}/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.dev12/aird/core/folder_size.py

@@ -0,0 +1,51 @@
+"""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

aird-0.4.23.dev12/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.dev12/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"]

aird-0.4.23.dev12/aird/email/brevo.py

@@ -0,0 +1,83 @@
+"""Brevo (Sendinblue) transactional email client."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+BREVO_API_URL = "https://api.brevo.com/v3/smtp/email"
+
+
+class BrevoError(RuntimeError):
+    pass
+
+
+class BrevoClient:
+    def __init__(
+        self,
+        api_key: str | None,
+        *,
+        sender_email: str | None,
+        sender_name: str = "Aird",
+    ):
+        self.api_key = (api_key or "").strip()
+        self.sender_email = (sender_email or "").strip()
+        self.sender_name = (sender_name or "Aird").strip() or "Aird"
+
+    @property
+    def configured(self) -> bool:
+        return bool(self.api_key and self.sender_email)
+
+    def send(
+        self,
+        to_email: str,
+        subject: str,
+        *,
+        html_content: str,
+        text_content: str | None = None,
+        to_name: str | None = None,
+    ) -> bool:
+        if not self.configured:
+            logger.debug("Brevo not configured; skipping email to %s", to_email)
+            return False
+        to_email = to_email.strip()
+        if not to_email:
+            return False
+
+        payload: dict[str, Any] = {
+            "sender": {"email": self.sender_email, "name": self.sender_name},
+            "to": [{"email": to_email, "name": (to_name or to_email).strip()}],
+            "subject": subject,
+            "htmlContent": html_content,
+        }
+        if text_content:
+            payload["textContent"] = text_content
+
+        try:
+            resp = requests.post(
+                BREVO_API_URL,
+                headers={
+                    "api-key": self.api_key,
+                    "Content-Type": "application/json",
+                    "accept": "application/json",
+                },
+                json=payload,
+                timeout=30,
+            )
+        except requests.RequestException as exc:
+            logger.warning("Brevo request failed for %s: %s", to_email, exc)
+            return False
+
+        if resp.status_code >= 400:
+            logger.warning(
+                "Brevo API error %s for %s: %s",
+                resp.status_code,
+                to_email,
+                resp.text[:500],
+            )
+            return False
+        return True

aird-0.4.23.dev12/aird/email/resolve.py

@@ -0,0 +1,36 @@
+"""Resolve a delivery email address for an Aird username."""
+
+from __future__ import annotations
+
+import re
+import sqlite3
+
+from aird.db.user_attributes import get_user_attributes
+
+_EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+
+def looks_like_email(value: str) -> bool:
+    return bool(_EMAIL_RE.match((value or "").strip()))
+
+
+def resolve_user_email(conn: sqlite3.Connection | None, username: str) -> str | None:
+    """
+    Return an email for *username*.
+
+    Order: user_attributes ``email`` → username when it is an email address.
+    """
+    username = (username or "").strip()
+    if not username:
+        return None
+    if conn is not None:
+        try:
+            attrs = get_user_attributes(conn, username)
+            raw = (attrs.get("email") or attrs.get("mail") or "").strip()
+            if looks_like_email(raw):
+                return raw
+        except Exception:
+            pass
+    if looks_like_email(username):
+        return username
+    return None

{aird-0.4.23.dev11 → aird-0.4.23.dev12}/aird/handlers/api_handlers.py

@@ -63,7 +63,8 @@ from aird.core.mmap_handler import MMapFileHandler
 class FeatureFlagSocketHandler(
     ManagedWebSocketMixin, tornado.websocket.WebSocketHandler
 ):
-    # Use connection manager with configurable limits for feature flags
+    """Legacy WebSocket kept for backward compatibility; new clients use GET /api/features."""
+
     connection_manager = WebSocketConnectionManager(
         "feature_flags", default_max_connections=50, default_idle_timeout=600
     )
@@ -76,25 +77,30 @@ class FeatureFlagSocketHandler(
         if not self.register_connection():
             return
 
-        # Load current feature flags from SQLite and send to client
         current_flags = self._get_current_feature_flags()
         self.write_message(json.dumps(current_flags))
 
     def check_origin(self, origin):
-        # Improved origin validation (Priority 2)
         return is_valid_websocket_origin(self, origin)
 
     def _get_current_feature_flags(self):
-        """Get current feature flags using the consolidated implementation."""
         return get_current_feature_flags()
 
     @classmethod
     def send_updates(cls):
-        """Send feature flag updates to all connected clients."""
         current_flags = get_current_feature_flags()
         cls.connection_manager.broadcast_message(json.dumps(current_flags))
 
 
+class FeatureFlagAPIHandler(BaseHandler):
+    """GET /api/features — lightweight JSON endpoint for on-demand flag checks."""
+
+    @tornado.web.authenticated
+    def get(self):
+        self.set_header("Content-Type", "application/json")
+        self.write(json.dumps(get_current_feature_flags()))
+
+
 class FileStreamHandler(ManagedWebSocketMixin, tornado.websocket.WebSocketHandler):
     # Use connection manager with configurable limits for file streaming
     connection_manager = WebSocketConnectionManager(