aird 0.4.23.dev3__tar.gz → 0.4.23.dev11__tar.gz

aird-0.4.23.dev11/MANIFEST.in

@@ -0,0 +1,6 @@
+recursive-include aird/templates *.html
+recursive-include aird/static/css *.css
+recursive-include aird/static/js *.js
+recursive-include aird/static/img *
+include aird/static/favicon.png
+include aird/static/favicon.ico

{aird-0.4.23.dev3 → aird-0.4.23.dev11}/PKG-INFO

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

@@ -0,0 +1,3 @@
+"""Aird command-line client for upload, download, and shares."""
+
+__version__ = "0.1.0"

aird-0.4.23.dev11/aird/cli/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from aird.cli.main import main
+
+sys.exit(main())

aird-0.4.23.dev11/aird/cli/authelia.py

@@ -0,0 +1,86 @@
+"""Authelia first/second factor login for CLI sessions."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class AutheliaError(RuntimeError):
+    pass
+
+
+def _needs_second_factor(payload: dict[str, Any]) -> bool:
+    if payload.get("status") == "OK" and not payload.get("data"):
+        return False
+    data = payload.get("data") or {}
+    if data.get("methods"):
+        return True
+    if payload.get("status") in ("OK", "200"):
+        return bool(data.get("devices") or data.get("authentication_level") == 1)
+    return payload.get("status") in ("Unauthorized", "401")
+
+
+def second_factor(session: requests.Session, authelia_base: str, totp: str) -> None:
+    base = authelia_base.rstrip("/")
+    token = totp.strip()
+    if not token:
+        raise AutheliaError("second_factor_required")
+    r = session.post(
+        f"{base}/api/secondfactor",
+        json={"token": token, "method": "totp"},
+        timeout=60,
+    )
+    if r.status_code == 401:
+        raise AutheliaError("Invalid one-time code (TOTP)")
+    if r.status_code >= 400:
+        raise AutheliaError(f"Authelia second factor failed (HTTP {r.status_code})")
+
+
+def login(
+    session: requests.Session,
+    authelia_base: str,
+    username: str,
+    password: str,
+    *,
+    totp: str | None = None,
+    target_url: str | None = None,
+) -> None:
+    """
+    Complete Authelia login on *session* (sets Authelia cookies).
+
+    Raises AutheliaError on failure. Prompts are handled by the caller; pass *totp*
+    when second factor is required.
+    """
+    base = authelia_base.rstrip("/")
+    body: dict[str, Any] = {
+        "username": username,
+        "password": password,
+        "keepMeLoggedIn": False,
+    }
+    if target_url:
+        body["targetURL"] = target_url
+        body["requestMethod"] = "GET"
+
+    r = session.post(f"{base}/api/firstfactor", json=body, timeout=60)
+    if r.status_code == 401:
+        raise AutheliaError("Authelia rejected username or password")
+    if r.status_code >= 400:
+        raise AutheliaError(f"Authelia first factor failed (HTTP {r.status_code})")
+
+    try:
+        payload = r.json()
+    except ValueError as exc:
+        raise AutheliaError("Authelia returned a non-JSON response") from exc
+
+    if not _needs_second_factor(payload):
+        return
+
+    if totp:
+        second_factor(session, base, totp)
+        return
+    raise AutheliaError("second_factor_required")

aird-0.4.23.dev11/aird/cli/config.py

@@ -0,0 +1,94 @@
+"""CLI configuration and session file paths."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR_ENV = "AIRD_CLI_CONFIG_DIR"
+DEFAULT_DIR_NAME = "aird"
+
+
+def config_dir() -> Path:
+    override = os.environ.get(CONFIG_DIR_ENV, "").strip()
+    if override:
+        return Path(override).expanduser()
+    if sys.platform == "win32":
+        base = os.environ.get("APPDATA") or str(Path.home())
+        return Path(base) / DEFAULT_DIR_NAME
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    if xdg:
+        return Path(xdg) / DEFAULT_DIR_NAME
+    return Path.home() / ".config" / DEFAULT_DIR_NAME
+
+
+def config_path() -> Path:
+    return config_dir() / "config.json"
+
+
+def session_path() -> Path:
+    return config_dir() / "session.json"
+
+
+def ensure_config_dir() -> Path:
+    d = config_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def load_config() -> dict[str, Any]:
+    path = config_path()
+    if not path.is_file():
+        return {}
+    try:
+        with path.open(encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save_config(data: dict[str, Any]) -> None:
+    ensure_config_dir()
+    with config_path().open("w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    try:
+        os.chmod(config_path(), 0o600)
+    except OSError:
+        pass
+
+
+def get_server_url(cfg: dict[str, Any] | None = None) -> str | None:
+    cfg = cfg if cfg is not None else load_config()
+    url = (
+        os.environ.get("AIRD_SERVER", "").strip()
+        or str(cfg.get("server") or "").strip()
+    )
+    return url.rstrip("/") if url else None
+
+
+def get_authelia_url(cfg: dict[str, Any] | None = None) -> str | None:
+    cfg = cfg if cfg is not None else load_config()
+    url = (
+        os.environ.get("AIRD_AUTHELIA_URL", "").strip()
+        or str(cfg.get("authelia_url") or "").strip()
+    )
+    return url.rstrip("/") if url else None
+
+
+def get_parallel_jobs(cfg: dict[str, Any] | None = None, default: int = 2) -> int:
+    cfg = cfg if cfg is not None else load_config()
+    raw = (
+        os.environ.get("AIRD_PARALLEL_JOBS", "").strip()
+        or cfg.get("parallel_uploads")
+        or cfg.get("parallel_downloads")
+    )
+    try:
+        n = int(raw)
+        return max(1, n) if n > 0 else default
+    except (TypeError, ValueError):
+        return default

aird-0.4.23.dev11/aird/cli/main.py

@@ -0,0 +1,410 @@
+"""aird-cli entry point."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import logging
+import sys
+from pathlib import Path
+
+from aird.cli import __version__
+from aird.cli.authelia import AutheliaError, login as authelia_login, second_factor
+from aird.cli.config import (
+    get_authelia_url,
+    get_parallel_jobs,
+    get_server_url,
+    load_config,
+    save_config,
+)
+from aird.cli.session import AirdAPIError, AirdAuthError, AirdClient
+
+log = logging.getLogger(__name__)
+
+
+def _prompt_password(prompt: str = "Password: ") -> str:
+    return getpass.getpass(prompt)
+
+
+def _prompt_totp() -> str:
+    return input("One-time code (TOTP): ").strip()
+
+
+def cmd_config_set(args: argparse.Namespace) -> int:
+    cfg = load_config()
+    cfg[args.key] = args.value
+    save_config(cfg)
+    print(f"Set {args.key} = {args.value}")
+    return 0
+
+
+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}")
+    return 0
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    server = get_server_url()
+    if not server and args.server:
+        cfg = load_config()
+        cfg["server"] = args.server.rstrip("/")
+        save_config(cfg)
+        server = cfg["server"]
+    if not server:
+        print("Set server URL first: aird-cli config set server https://your-host", file=sys.stderr)
+        return 1
+
+    client = AirdClient(server)
+    authelia_url = get_authelia_url() or args.authelia_url
+
+    username = args.username or load_config().get("username") or input("Username: ").strip()
+    if not username:
+        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
+
+    aird_token = args.aird_token
+    if aird_token:
+        client.login_password("", "", token=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)
+    client.save()
+
+    try:
+        client.check_auth()
+    except (AirdAuthError, AirdAPIError) as exc:
+        print(f"Login failed: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Logged in to {server} as {username}")
+    return 0
+
+
+def cmd_logout(_args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        client.clear_session()
+    except AirdAuthError:
+        pass
+    print("Session cleared")
+    return 0
+
+
+def _default_jobs(args: argparse.Namespace) -> int:
+    jobs = getattr(args, "jobs", None)
+    return jobs if jobs is not None else get_parallel_jobs()
+
+
+def cmd_whoami(_args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        client.check_auth()
+        username = client.http.cookies.get("user") or load_config().get("username") or "?"
+        print(f"OK — {username} @ {client.server}")
+        return 0
+    except AirdAuthError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    except AirdAPIError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def cmd_ls(args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        entries = client.list_dir(args.path or "")
+        if not entries:
+            print("(empty)")
+            return 0
+        for e in entries:
+            name = e.get("name", "?")
+            if e.get("is_dir"):
+                print(f"{name}/")
+            else:
+                size = e.get("size_bytes") or e.get("size") or 0
+                print(f"{name}\t{size}")
+        return 0
+    except (AirdAuthError, AirdAPIError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def cmd_download(args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        remote = (args.remote or "").strip("/")
+        local = Path(args.output or ".").resolve()
+
+        if args.recursive:
+            base_name = Path(remote).name if remote else "files"
+            dest = (local / base_name) if local.is_dir() else local
+            dest.mkdir(parents=True, exist_ok=True)
+
+            def on_progress(p: str) -> None:
+                if args.verbose:
+                    print(p)
+
+            n = client.download_tree(
+                remote,
+                dest,
+                workers=_default_jobs(args),
+                on_progress=on_progress if args.verbose else None,
+            )
+            print(f"Downloaded {n} file(s) to {dest}")
+            return 0
+
+        if not remote:
+            print("Remote path required", file=sys.stderr)
+            return 1
+        dest = local
+        if dest.is_dir():
+            dest = dest / Path(remote).name
+        client.download_file(remote, dest)
+        print(f"Saved {dest}")
+        return 0
+    except (AirdAuthError, AirdAPIError, OSError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def cmd_upload(args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        local = Path(args.local).resolve()
+        remote_dir = (args.remote or "").strip("/")
+
+        def on_progress(p: str) -> None:
+            if args.verbose:
+                print(p)
+
+        if local.is_dir():
+            n = client.upload_tree(
+                local,
+                remote_dir,
+                workers=_default_jobs(args),
+                on_progress=on_progress if args.verbose else None,
+            )
+            print(f"Uploaded {n} file(s) to /{remote_dir or ''}")
+        elif local.is_file():
+            client.upload_file(local, remote_dir)
+            print(f"Uploaded {local.name} to /{remote_dir or ''}")
+            n = 1
+        else:
+            print(f"Not found: {local}", file=sys.stderr)
+            return 1
+        return 0
+    except (AirdAuthError, AirdAPIError, OSError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def cmd_shares_list(_args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        data = client.list_shares()
+        mine = data.get("shares") or []
+        shared = data.get("shared_with_me") or []
+        if not mine and not shared:
+            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', '')}")
+        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)")
+        return 0
+    except (AirdAuthError, AirdAPIError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def cmd_shares_download(args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        dest = Path(args.output or ".").resolve() / args.share_id
+        dest.mkdir(parents=True, exist_ok=True)
+        token = args.token
+
+        def on_progress(p: str) -> None:
+            if args.verbose:
+                print(p)
+
+        n = client.download_share(
+            args.share_id,
+            dest,
+            share_token=token,
+            workers=_default_jobs(args),
+            on_progress=on_progress if args.verbose else None,
+        )
+        print(f"Downloaded {n} file(s) from share {args.share_id} to {dest}")
+        return 0
+    except (AirdAuthError, AirdAPIError, OSError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def cmd_shares_download_all(args: argparse.Namespace) -> int:
+    try:
+        client = AirdClient()
+        dest = Path(args.output or ".").resolve()
+
+        def on_progress(p: str) -> None:
+            if args.verbose:
+                print(p)
+
+        n = client.download_all_shares(
+            dest,
+            workers=_default_jobs(args),
+            on_progress=on_progress if args.verbose else None,
+        )
+        print(f"Downloaded {n} file(s) from all shares to {dest}")
+        return 0
+    except (AirdAuthError, AirdAPIError, OSError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="aird-cli",
+        description="Aird CLI — upload, download, and shares (session saved after login)",
+    )
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    p.add_argument("-v", "--verbose", action="store_true", help="Progress per file")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    cfg = sub.add_parser("config", help="Manage CLI config")
+    cfg_sub = cfg.add_subparsers(dest="config_cmd", required=True)
+    cs = cfg_sub.add_parser("set", help="Set config key")
+    cs.add_argument(
+        "key",
+        choices=["server", "authelia_url", "username", "parallel_uploads", "parallel_downloads"],
+    )
+    cs.add_argument("value")
+    cs.set_defaults(func=cmd_config_set)
+    cfg_sub.add_parser("show", help="Show config").set_defaults(func=cmd_config_show)
+
+    login = sub.add_parser("login", help="Authenticate (Authelia + Aird); session persisted")
+    login.add_argument("--server", help="Aird base URL")
+    login.add_argument("--authelia-url", dest="authelia_url", help="Authelia portal URL")
+    login.add_argument("-u", "--username")
+    login.add_argument("-p", "--password", help="Password (avoid on shell history)")
+    login.add_argument("--totp", help="Authelia TOTP code")
+    login.add_argument(
+        "--token",
+        help="Aird ACCESS_TOKEN (Bearer); skips username/password",
+    )
+    login.add_argument(
+        "--aird-token",
+        dest="aird_token",
+        help="Aird login form token field (not Bearer)",
+    )
+    login.set_defaults(func=cmd_login)
+
+    sub.add_parser("logout", help="Clear saved session").set_defaults(func=cmd_logout)
+    sub.add_parser("whoami", help="Check current session").set_defaults(func=cmd_whoami)
+
+    ls = sub.add_parser("ls", help="List remote directory")
+    ls.add_argument("path", nargs="?", default="", help="Remote path under your files root")
+    ls.set_defaults(func=cmd_ls)
+
+    dl = sub.add_parser("download", help="Download file or folder (no zip)")
+    dl.add_argument("remote", help="Remote path")
+    dl.add_argument("-o", "--output", help="Local file or directory")
+    dl.add_argument("-r", "--recursive", action="store_true", help="Download folder tree")
+    dl.add_argument("-j", "--jobs", type=int, default=None, help="Parallel downloads (default from config)")
+    dl.set_defaults(func=cmd_download)
+
+    up = sub.add_parser("upload", help="Upload file or folder")
+    up.add_argument("local", help="Local file or directory")
+    up.add_argument("remote", nargs="?", default="", help="Remote destination directory")
+    up.add_argument("-j", "--jobs", type=int, default=None, help="Parallel file uploads (default from config)")
+    up.set_defaults(func=cmd_upload)
+
+    shares = sub.add_parser("shares", help="Share operations")
+    sh_sub = shares.add_subparsers(dest="shares_cmd", required=True)
+    sh_sub.add_parser("list", help="List shares").set_defaults(func=cmd_shares_list)
+    sh_dl = sh_sub.add_parser("download", help="Download all files in a share")
+    sh_dl.add_argument("share_id")
+    sh_dl.add_argument("-o", "--output", help="Local parent directory")
+    sh_dl.add_argument("--token", help="Share access token if required")
+    sh_dl.add_argument("-j", "--jobs", type=int, default=None)
+    sh_dl.set_defaults(func=cmd_shares_download)
+    sh_all = sh_sub.add_parser("download-all", help="Download every share you can access")
+    sh_all.add_argument("-o", "--output", help="Local parent directory")
+    sh_all.add_argument("-j", "--jobs", type=int, default=None)
+    sh_all.set_defaults(func=cmd_shares_download_all)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    logging.basicConfig(level=logging.WARNING)
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())