aird 0.4.23.dev20__tar.gz → 0.4.23.dev22__tar.gz

{aird-0.4.23.dev20/aird.egg-info → aird-0.4.23.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aird
-Version: 0.4.23.dev20
+Version: 0.4.23.dev22
 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
@@ -23,6 +23,7 @@ Requires-Dist: pysmbserver>=0.1.0; python_version >= "3.13"
 Requires-Dist: wsgidav>=4.3.0
 Requires-Dist: cheroot>=10.0.0
 Requires-Dist: pyasn1>=0.6.2
+Requires-Dist: webauthn>=2.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{aird-0.4.23.dev20 → aird-0.4.23.dev22}/aird/cli/main.py

@@ -42,27 +42,92 @@ def cmd_config_show(_args: argparse.Namespace) -> int:
     cfg = load_config()
     if not cfg:
         print("(no config — use: aird-cli config set server https://host)")
-        return 0
-    for k, v in sorted(cfg.items()):
-        if k == "password":
-            print(f"{k}: ***")
-        else:
-            print(f"{k}: {v}")
+    else:
+        for k, v in sorted(cfg.items()):
+            if k == "password":
+                print(f"{k}: ***")
+            else:
+                print(f"{k}: {v}")
     return 0
 
 
-def cmd_login(args: argparse.Namespace) -> int:
+def _resolve_login_server(args: argparse.Namespace) -> str | None:
     server = get_server_url()
     if not server and args.server:
         cfg = load_config()
         cfg["server"] = args.server.rstrip("/")
         save_config(cfg)
         server = cfg["server"]
+    return server
+
+
+def _try_token_login(client: AirdClient, server: str, args: argparse.Namespace) -> int | None:
+    if not args.token:
+        return None
+    client.set_bearer_token(args.token)
+    client.refresh_xsrf()
+    client.save()
+    try:
+        client.check_auth()
+        print(f"Logged in to {server} (access token)")
+        return 0
+    except (AirdAuthError, AirdAPIError) as exc:
+        print(f"Token login failed: {exc}", file=sys.stderr)
+        return 1
+
+
+def _run_authelia_login(
+    client: AirdClient,
+    authelia_url: str,
+    username: str,
+    password: str,
+    totp: str | None,
+    server: str,
+) -> int | None:
+    try:
+        authelia_login(
+            client.http,
+            authelia_url,
+            username,
+            password,
+            totp=totp,
+            target_url=f"{server}/login",
+        )
+    except AutheliaError as exc:
+        if str(exc) != "second_factor_required":
+            print(f"Authelia login failed: {exc}", file=sys.stderr)
+            return 1
+        totp = totp or _prompt_totp()
+        try:
+            second_factor(client.http, authelia_url, totp)
+        except AutheliaError as exc2:
+            print(f"Authelia login failed: {exc2}", file=sys.stderr)
+            return 1
+    return None
+
+
+def _save_login_config(
+    username: str, server: str, authelia_url: str | None
+) -> None:
+    cfg = load_config()
+    cfg["username"] = username
+    cfg["server"] = server
+    if authelia_url:
+        cfg["authelia_url"] = authelia_url
+    save_config(cfg)
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    server = _resolve_login_server(args)
     if not server:
         print("Set server URL first: aird-cli config set server https://your-host", file=sys.stderr)
         return 1
 
     client = AirdClient(server)
+    token_result = _try_token_login(client, server, args)
+    if token_result is not None:
+        return token_result
+
     authelia_url = get_authelia_url() or args.authelia_url
 
     username = args.username or load_config().get("username") or input("Username: ").strip()
@@ -70,55 +135,22 @@ def cmd_login(args: argparse.Namespace) -> int:
         print("Username required", file=sys.stderr)
         return 1
 
-    if args.token:
-        client.set_bearer_token(args.token)
-        client.refresh_xsrf()
-        client.save()
-        try:
-            client.check_auth()
-            print(f"Logged in to {server} (access token)")
-            return 0
-        except (AirdAuthError, AirdAPIError) as exc:
-            print(f"Token login failed: {exc}", file=sys.stderr)
-            return 1
-
     password = args.password or _prompt_password()
     totp = args.totp
 
     if authelia_url:
-        try:
-            authelia_login(
-                client.http,
-                authelia_url,
-                username,
-                password,
-                totp=totp,
-                target_url=f"{server}/login",
-            )
-        except AutheliaError as exc:
-            if str(exc) == "second_factor_required":
-                totp = totp or _prompt_totp()
-                try:
-                    second_factor(client.http, authelia_url, totp)
-                except AutheliaError as exc2:
-                    print(f"Authelia login failed: {exc2}", file=sys.stderr)
-                    return 1
-            else:
-                print(f"Authelia login failed: {exc}", file=sys.stderr)
-                return 1
+        authelia_result = _run_authelia_login(
+            client, authelia_url, username, password, totp, server
+        )
+        if authelia_result is not None:
+            return authelia_result
 
-    aird_token = args.aird_token
-    if aird_token:
-        client.login_password("", "", token=aird_token)
+    if args.aird_token:
+        client.login_password("", "", token=args.aird_token)
     else:
         client.login_password(username, password)
 
-    cfg = load_config()
-    cfg["username"] = username
-    cfg["server"] = server
-    if authelia_url:
-        cfg["authelia_url"] = authelia_url
-    save_config(cfg)
+    _save_login_config(username, server, authelia_url)
     client.save()
 
     try:
@@ -250,6 +282,24 @@ def cmd_upload(args: argparse.Namespace) -> int:
         return 1
 
 
+def _print_my_shares(mine) -> None:
+    print("My shares:")
+    items = mine.values() if isinstance(mine, dict) else mine
+    for s in items:
+        sid = s.get("id", "?")
+        paths = s.get("paths") or []
+        print(f"  {sid}\t{len(paths)} path(s)\t{s.get('created_at', '')}")
+
+
+def _print_shared_with_me(shared) -> None:
+    print("Shared with me:")
+    for s in shared:
+        sid = s.get("id", "?")
+        creator = s.get("creator") or s.get("username") or "?"
+        paths = s.get("paths") or []
+        print(f"  {sid}\tfrom {creator}\t{len(paths)} path(s)")
+
+
 def cmd_shares_list(_args: argparse.Namespace) -> int:
     try:
         client = AirdClient()
@@ -260,19 +310,9 @@ def cmd_shares_list(_args: argparse.Namespace) -> int:
             print("(no shares)")
             return 0
         if mine:
-            print("My shares:")
-            items = mine.values() if isinstance(mine, dict) else mine
-            for s in items:
-                sid = s.get("id", "?")
-                paths = s.get("paths") or []
-                print(f"  {sid}\t{len(paths)} path(s)\t{s.get('created_at', '')}")
+            _print_my_shares(mine)
         if shared:
-            print("Shared with me:")
-            for s in shared:
-                sid = s.get("id", "?")
-                creator = s.get("creator") or s.get("username") or "?"
-                paths = s.get("paths") or []
-                print(f"  {sid}\tfrom {creator}\t{len(paths)} path(s)")
+            _print_shared_with_me(shared)
         return 0
     except (AirdAuthError, AirdAPIError) as exc:
         print(str(exc), file=sys.stderr)

{aird-0.4.23.dev20 → aird-0.4.23.dev22}/aird/cli/session.py

@@ -91,6 +91,43 @@ def _load_cookies(session: requests.Session) -> bool:
     return bool(data.get("cookies") or token)
 
 
+def _collect_local_upload_files(
+    local_dir: Path, remote_dir: str
+) -> list[tuple[Path, str]]:
+    files: list[tuple[Path, str]] = []
+
+    def walk(base: Path, rel_remote: str) -> None:
+        for child in sorted(base.iterdir()):
+            rel = f"{rel_remote}/{child.name}" if rel_remote else child.name
+            if child.is_dir():
+                walk(child, rel)
+            elif child.is_file():
+                remote_parent = (
+                    f"{remote_dir}/{rel_remote}".strip("/") if rel_remote else remote_dir
+                )
+                files.append((child, remote_parent.strip("/")))
+
+    walk(local_dir, "")
+    return files
+
+
+def _run_path_jobs(
+    file_paths: list[str],
+    job: Callable[[str], str],
+    workers: int,
+    on_progress: Callable[[str], None] | None,
+) -> int:
+    count = 0
+    with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
+        futures = [pool.submit(job, p) for p in file_paths]
+        for fut in as_completed(futures):
+            p = fut.result()
+            count += 1
+            if on_progress:
+                on_progress(p)
+    return count
+
+
 class AirdClient:
     def __init__(self, server_url: str | None = None, *, _reuse: "AirdClient | None" = None):
         if _reuse is not None:
@@ -309,29 +346,15 @@ class AirdClient:
     ) -> int:
         if not local_dir.is_dir():
             raise NotADirectoryError(local_dir)
-        local_dir = local_dir.resolve()
-        files: list[tuple[Path, str]] = []
-
-        def walk(base: Path, rel_remote: str) -> None:
-            for child in sorted(base.iterdir()):
-                rel = f"{rel_remote}/{child.name}" if rel_remote else child.name
-                if child.is_dir():
-                    walk(child, rel)
-                elif child.is_file():
-                    remote_parent = (
-                        f"{remote_dir}/{rel_remote}".strip("/") if rel_remote else remote_dir
-                    )
-                    files.append((child, remote_parent.strip("/")))
-
-        walk(local_dir, "")
+        files = _collect_local_upload_files(local_dir.resolve(), remote_dir)
         if not files:
             return 0
 
-        count = 0
         def _upload_job(lp: Path, rd: str) -> Path:
             self.clone().upload_file(lp, rd)
             return lp
 
+        count = 0
         with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
             futures = {pool.submit(_upload_job, lp, rd): (lp, rd) for lp, rd in files}
             for fut in as_completed(futures):
@@ -360,31 +383,34 @@ class AirdClient:
                 return s, False
         return None, False
 
+    def _expand_single_path(self, raw: str, seen: set[str], files: list[str]) -> None:
+        p = (raw or "").strip("/")
+        if not p:
+            return
+        try:
+            self.list_dir(p)
+            for rel, _ in self.iter_tree(p):
+                if rel not in seen:
+                    seen.add(rel)
+                    files.append(rel)
+        except AirdAPIError as exc:
+            if exc.status == 404:
+                if p not in seen:
+                    seen.add(p)
+                    files.append(p)
+            else:
+                raise
+
     def expand_paths_to_files(self, paths: list[str]) -> list[str]:
         """Expand share path entries (files or folders) to file paths in your tree."""
         files: list[str] = []
         seen: set[str] = set()
         for raw in paths:
-            p = (raw or "").strip("/")
-            if not p:
-                continue
-            try:
-                self.list_dir(p)
-                for rel, _ in self.iter_tree(p):
-                    if rel not in seen:
-                        seen.add(rel)
-                        files.append(rel)
-            except AirdAPIError as exc:
-                if exc.status == 404:
-                    if p not in seen:
-                        seen.add(p)
-                        files.append(p)
-                else:
-                    raise
+            self._expand_single_path(raw, seen, files)
         return files
 
     def verify_share(self, share_id: str, token: str) -> None:
-        xsrf = self.refresh_xsrf()
+        self.refresh_xsrf()
         r = self.http.post(
             self._url(f"/shared/{quote(share_id)}/verify"),
             json={"token": token},
@@ -433,6 +459,42 @@ class AirdClient:
                     if chunk:
                         f.write(chunk)
 
+    def _own_share_download_job(self, local_dir: Path) -> Callable[[str], str]:
+        def _own_job(path: str) -> str:
+            dest = local_dir / path
+            self.clone().download_file(path, dest)
+            return path
+
+        return _own_job
+
+    def _shared_download_job(
+        self, share_id: str, local_dir: Path
+    ) -> Callable[[str], str]:
+        def _shared_job(path: str) -> str:
+            dest = local_dir / path
+            self.clone().download_share_file(share_id, path, dest)
+            return path
+
+        return _shared_job
+
+    def _resolve_own_share_paths(self, share: dict) -> list[str]:
+        paths = self.expand_paths_to_files(list(share.get("paths") or []))
+        if not paths:
+            raise AirdAPIError("No files in share")
+        return paths
+
+    def _resolve_shared_file_paths(
+        self, share_id: str, share_token: str | None, share: dict | None
+    ) -> list[str]:
+        if share_token:
+            self.verify_share(share_id, share_token)
+        file_paths = self.share_file_paths(share_id)
+        if not file_paths and share:
+            file_paths = list(share.get("paths") or [])
+        if not file_paths:
+            raise AirdAPIError("No files in share (or access denied — try --token)")
+        return file_paths
+
     def download_share(
         self,
         share_id: str,
@@ -445,42 +507,13 @@ class AirdClient:
         share, is_mine = self.find_share(share_id)
 
         if is_mine and share:
-            paths = self.expand_paths_to_files(list(share.get("paths") or []))
-            if not paths:
-                raise AirdAPIError("No files in share")
-
-            def _own_job(path: str) -> str:
-                dest = local_dir / path
-                self.clone().download_file(path, dest)
-                return path
-
-            jobs = _own_job
-            file_paths = paths
+            file_paths = self._resolve_own_share_paths(share)
+            jobs = self._own_share_download_job(local_dir)
         else:
-            if share_token:
-                self.verify_share(share_id, share_token)
-            file_paths = self.share_file_paths(share_id)
-            if not file_paths and share:
-                file_paths = list(share.get("paths") or [])
-            if not file_paths:
-                raise AirdAPIError("No files in share (or access denied — try --token)")
-
-            def _shared_job(path: str) -> str:
-                dest = local_dir / path
-                self.clone().download_share_file(share_id, path, dest)
-                return path
-
-            jobs = _shared_job
+            file_paths = self._resolve_shared_file_paths(share_id, share_token, share)
+            jobs = self._shared_download_job(share_id, local_dir)
 
-        count = 0
-        with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
-            futures = [pool.submit(jobs, p) for p in file_paths]
-            for fut in as_completed(futures):
-                p = fut.result()
-                count += 1
-                if on_progress:
-                    on_progress(p)
-        return count
+        return _run_path_jobs(file_paths, jobs, workers, on_progress)
 
     def download_all_shares(
         self,

{aird-0.4.23.dev20 → aird-0.4.23.dev22}/aird/config.py

@@ -40,7 +40,7 @@ FEATURE_FLAGS = {}
 CLOUD_MANAGER = CloudManager()
 WEBSOCKET_CONFIG = {}
 MULTI_USER = False
-WORKERS = None  # None = auto (1.25 * threads_per_core * physical_cores)
+WORKERS = None
 DB_CONN = None
 MAX_FILE_SIZE = _MAX_FILE_SIZE
 MAX_READABLE_FILE_SIZE = _MAX_READABLE_FILE_SIZE
@@ -187,6 +187,82 @@ def _apply_feature_flags_from_config(config: dict) -> None:
             FEATURE_FLAGS[feature_name] = bool(feature_value)
 
 
+def _load_config_dict(args) -> dict:
+    global CONFIG_FILE
+    if not args.config:
+        return {}
+    CONFIG_FILE = args.config
+    with open(CONFIG_FILE, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _apply_access_tokens(args, config: dict) -> tuple[bool, bool]:
+    """Apply ACCESS_TOKEN and ADMIN_TOKEN; return (access_explicit, admin_explicit)."""
+    global ACCESS_TOKEN, ADMIN_TOKEN
+
+    token_provided_explicitly = bool(
+        args.token or config.get("token") or os.environ.get("AIRD_ACCESS_TOKEN")
+    )
+    admin_token_provided_explicitly = bool(
+        args.admin_token or config.get("admin_token")
+    )
+
+    ACCESS_TOKEN = (
+        args.token
+        or config.get("token")
+        or os.environ.get("AIRD_ACCESS_TOKEN")
+        or secrets.token_urlsafe(64)
+    )
+    ADMIN_TOKEN = (
+        args.admin_token or config.get("admin_token") or secrets.token_urlsafe(64)
+    )
+    return token_provided_explicitly, admin_token_provided_explicitly
+
+
+def _apply_server_settings(args, config: dict) -> None:
+    global ROOT_DIR, PORT, MULTI_USER, WORKERS, SSL_CERT, SSL_KEY, ADMIN_USERS, HOSTNAME
+
+    ROOT_DIR = args.root or config.get("root") or os.getcwd()
+    PORT = args.port or config.get("port") or 8000
+    MULTI_USER = args.multi_user or config.get("multi_user", False)
+    workers_arg = args.workers if args.workers is not None else config.get("workers")
+    WORKERS = int(workers_arg) if workers_arg is not None else None
+    SSL_CERT = args.ssl_cert or config.get("ssl_cert")
+    SSL_KEY = args.ssl_key or config.get("ssl_key")
+    ADMIN_USERS = config.get("admin_users", [])
+    HOSTNAME = args.hostname or config.get("hostname") or socket.getfqdn()
+
+
+def _apply_ldap_globals(ldap_settings: dict) -> None:
+    global LDAP_ENABLED, LDAP_SERVER, LDAP_BASE_DN, LDAP_USER_TEMPLATE
+    global LDAP_FILTER_TEMPLATE, LDAP_ATTRIBUTES, LDAP_ATTRIBUTE_MAP
+
+    LDAP_ENABLED = ldap_settings["enabled"]
+    LDAP_SERVER = ldap_settings["server"]
+    LDAP_BASE_DN = ldap_settings["base_dn"]
+    LDAP_USER_TEMPLATE = ldap_settings["user_template"]
+    LDAP_FILTER_TEMPLATE = ldap_settings["filter_template"]
+    LDAP_ATTRIBUTES = ldap_settings["attributes"]
+    LDAP_ATTRIBUTE_MAP = ldap_settings["attribute_map"]
+
+
+def _print_generated_tokens(
+    token_provided_explicitly: bool, admin_token_provided_explicitly: bool
+) -> None:
+    if not token_provided_explicitly:
+        print(f"\n{'='*60}")
+        print(f"Access token (generated): {ACCESS_TOKEN}")
+        print(f"{'='*60}")
+        print("Note: Copy the token above exactly as shown .")
+        print("WARNING: Store this token securely. It grants access to your files.")
+        print(f"{'='*60}\n")
+    if not admin_token_provided_explicitly:
+        print(f"\n{'='*60}")
+        print(f"Admin token (generated): {ADMIN_TOKEN}")
+        print("WARNING: Store this token securely. It grants admin access.")
+        print(f"{'='*60}\n")
+
+
 def init_config():
     """
     Initializes the application configuration by parsing command-line arguments,
@@ -236,70 +312,19 @@ def init_config():
     )
     args = parser.parse_args()
 
-    config = {}
-    if args.config:
-        CONFIG_FILE = args.config
-        with open(CONFIG_FILE) as f:
-            config = json.load(f)
-    else:
-        config = {}
+    config = _load_config_dict(args)
 
     _configure_cloud_providers(config)
 
-    ROOT_DIR = args.root or config.get("root") or os.getcwd()
-    PORT = args.port or config.get("port") or 8000
-
-    token_provided_explicitly = bool(
-        args.token or config.get("token") or os.environ.get("AIRD_ACCESS_TOKEN")
-    )
-    admin_token_provided_explicitly = bool(
-        args.admin_token or config.get("admin_token")
-    )
-
-    ACCESS_TOKEN = (
-        args.token
-        or config.get("token")
-        or os.environ.get("AIRD_ACCESS_TOKEN")
-        or secrets.token_urlsafe(64)
-    )
-    ADMIN_TOKEN = (
-        args.admin_token or config.get("admin_token") or secrets.token_urlsafe(64)
+    token_provided_explicitly, admin_token_provided_explicitly = _apply_access_tokens(
+        args, config
     )
+    _apply_server_settings(args, config)
 
     ldap_settings = _parse_ldap_settings(args, config)
-    LDAP_ENABLED = ldap_settings["enabled"]
-    LDAP_SERVER = ldap_settings["server"]
-    LDAP_BASE_DN = ldap_settings["base_dn"]
-    LDAP_USER_TEMPLATE = ldap_settings["user_template"]
-    LDAP_FILTER_TEMPLATE = ldap_settings["filter_template"]
-    LDAP_ATTRIBUTES = ldap_settings["attributes"]
-    LDAP_ATTRIBUTE_MAP = ldap_settings["attribute_map"]
+    _apply_ldap_globals(ldap_settings)
 
     _apply_feature_flags_from_config(config)
     _apply_brevo_settings(config)
 
-    MULTI_USER = args.multi_user or config.get("multi_user", False)
-
-    workers_arg = args.workers if args.workers is not None else config.get("workers")
-    WORKERS = int(workers_arg) if workers_arg is not None else None
-
-    SSL_CERT = args.ssl_cert or config.get("ssl_cert")
-    SSL_KEY = args.ssl_key or config.get("ssl_key")
-
-    ADMIN_USERS = config.get("admin_users", [])
-
-    HOSTNAME = args.hostname or config.get("hostname") or socket.getfqdn()
-
-    # Print tokens when they were not explicitly provided (masked for security)
-    if not token_provided_explicitly:
-        print(f"\n{'='*60}")
-        print(f"Access token (generated): {ACCESS_TOKEN}")
-        print(f"{'='*60}")
-        print("Note: Copy the token above exactly as shown .")
-        print("WARNING: Store this token securely. It grants access to your files.")
-        print(f"{'='*60}\n")
-    if not admin_token_provided_explicitly:
-        print(f"\n{'='*60}")
-        print(f"Admin token (generated): {ADMIN_TOKEN}")
-        print("WARNING: Store this token securely. It grants admin access.")
-        print(f"{'='*60}\n")
+    _print_generated_tokens(token_provided_explicitly, admin_token_provided_explicitly)

{aird-0.4.23.dev20 → aird-0.4.23.dev22}/aird/constants/__init__.py

@@ -43,6 +43,7 @@ FEATURE_FLAGS = {
     "abac_engine": False,
     "abac_audit_decisions": True,
     "email_notifications": False,
+    "webauthn": False,
 }
 
 # WebSocket connection configuration
@@ -63,8 +64,13 @@ UPLOAD_CONFIG = {
 
 # 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)
+# HTTP /upload body limit (browser small uploads + CLI)
 UPLOAD_REQUEST_MAX_BODY_SIZE = MAX_FILE_SIZE + (1024 * 1024)
+# Files below this use single POST /upload; at or above use Content-Range API
+LARGE_FILE_THRESHOLD_BYTES = 500 * 1024 * 1024
+RANGE_CHUNK_BYTES = 16 * 1024 * 1024
+# Max JSON WebSocket control message size (search, stream commands, P2P signaling)
+WS_JSON_MESSAGE_MAX_BYTES = 64 * 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)
@@ -101,8 +107,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
+# Legacy WebSocket frame size (optional fallback; HTTP is primary for transfers)
+WS_TRANSFER_FRAME_BYTES = 2 * 1024 * 1024
 
 # Network share manager (set at startup)
 NETWORK_SHARE_MANAGER = None