upload-assistant 3.9__py3-none-any.whl

bin/download_integrity.py

@@ -0,0 +1,58 @@
+"""Pinned SHA-256 verification for third-party executable downloads."""
+
+import hashlib
+from pathlib import Path
+
+SHA256_BY_ASSET = {
+    "ffmpeg-9.0.1-essentials_build.zip": "fec81ae03971d9dd4be3ebe02e263bd2ec1d789483f931bdba5f5715e65da2e9",
+    "MediaInfo_CLI_23.04_Windows_x64.zip": "b1beafae0a15168ca37db8a3061d55eba55c1a120d6a6423ac1d3f30ed869270",
+    "MediaInfo_CLI_26.05_Lambda_arm64.zip": "57268dcfc044cdcbe4641e26432392f002b7fa4bcb06e9d738be04cd047a2c1e",
+    "MediaInfo_CLI_26.05_Lambda_x86_64.zip": "1ae3744a78c93492b69f0b38bb2d1de1433c3eae04030ff1ea82ee1f60ac9a99",
+    "MediaInfo_CLI_26.05_Mac.dmg": "507605a7c8f1054a6996d99a4ef5b5a0711cfbf2f8ca2ef5161d6ee701ea8015",
+    "MediaInfo_CLI_26.05_Windows_ARM64.zip": "6b403fa1411730672adefa8d49d97cbf7163eed7fc5c1256c9a6e9f915fde1a8",
+    "MediaInfo_CLI_26.05_Windows_x64.zip": "f7f80620ce6d14f4995f0de6f98e3ef18ad29496db01899571152ee3311229f9",
+    "mkbrr_1.24.0_windows_x86_64.zip": "23b923a26d50e3afabcd99938ea70a510904a98365f698bbeaae057ec1a51711",
+    "mkbrr_1.24.0_darwin_arm64.tar.gz": "99c939d1b3e7329d1cf82c90adceb93291eefc34f72ca263577b9c4826172c1e",
+    "mkbrr_1.24.0_darwin_x86_64.tar.gz": "26092fa6b59ec79ede4be8d09f9f6f3135af1ccf0f4df312215b2ed92691e7dd",
+    "mkbrr_1.24.0_linux_x86_64.tar.gz": "bd23b2e2aa62a943eb5cfea23fa250e60b9ba2169a36e27aaeec980d82dc47a5",
+    "mkbrr_1.24.0_linux_arm64.tar.gz": "dada7d9aab0bd0854cdf3b5473b77d7f04b7dcf99ef519b45b522959f9db78e7",
+    "mkbrr_1.24.0_linux_arm.tar.gz": "7480a96b9dafd458be1769d8c743bc85c53034a9673252b831b3130e8c1b758d",
+    "mkbrr_1.24.0_freebsd_x86_64.tar.gz": "d3c2fe3bc9bad2467faa38124f7f1ebf3e70b8b32300486ee21f0667bd7fc6c7",
+    "mkbrr_1.18.0_linux_x86_64.tar.gz": "a796bd97dfb093e18a1a509c8986580498e65253582983a462b977b359f987b9",
+    "mkbrr_1.18.0_linux_arm64.tar.gz": "1c187ab2b860e637296d6f0deb4c2e7754a4c1e249b0226f0be671170689de24",
+    "mkbrr_1.18.0_linux_arm.tar.gz": "f622595f6afee302c72c89abdd9f31ad3197bd85d45a8b482f97ebd21930ac51",
+    "bdinfo_0.4.0_windows_amd64.zip": "2291df819388739287b042694adc5bc8e9b90583968802ff3a4ab1ace3f658f9",
+    "bdinfo_0.4.0_darwin_amd64.tar.gz": "ecb47628798aa1bde3188b4d47f135e9baeee628345921b2f993590b42e22b61",
+    "bdinfo_0.4.0_darwin_arm64.tar.gz": "27bb0f0dcc252850075bf6e30b65c0ce42a07c5afa9c52f42c69422df36c6428",
+    "bdinfo_0.4.0_linux_amd64.tar.gz": "78fd90627c5d9a2bddd3126875d036e73bb4178192fe786c29b0d6c6ccc3b3eb",
+    "bdinfo_0.4.0_linux_arm64.tar.gz": "b98a58f903984b86622387db45be9142485c6171dcd5de41c951c7a3de34d6bf",
+    "bdinfo_0.4.0_linux_arm.tar.gz": "94bd7a32d90ce6118695ab50940b048d91d42f9e48f3d9e879ac3d0721c83463",
+    "7zr.exe": "abcf64ae1cbafddb5395e4cdd3bdc7e3e0561d54a0c6380e3dd43bdbffe519a2",
+    "7z2601-mac.tar.xz": "0b6b930dbf82742e3f1014c35072a6b8b3aab183fece348e7f723675f1c5bea2",
+    "7z2601-linux-x64.tar.xz": "8ea0fc8a135e7b848e80a4116fe22dff56c8c4518dde1f43cce67f4e340b437a",
+    "7z2601-linux-arm64.tar.xz": "39f8c9070c300a63c7484d9a983119ef3edf841e1ddf69f1affae29fdec5f612",
+    "7z2601-linux-arm.tar.xz": "72c19911abb6964fcf85ebe213dfcee57bad892345e03bb940c5a27a1050b3bf",
+    "pesto-windows-x86_64.exe": "25306273eb6ed91abfb465d9a3e60adceb868883f7c456926d2de4eee1e57236",
+    "pesto-linux-x86_64": "4a357e37c5f867694fa95d025a7aba836d43f6cfa410f1ab78e86f817f4c656c",
+    "par2cmdline-turbo-1.4.0-win-x64.zip": "7905d1d6aced2b2ca30d824b4954e6bf740dc9d6cfec718b0ab146b5fc0d6327",
+    "par2cmdline-turbo-1.4.0-win-arm64.zip": "89870943c142b1360ab79bb287e47d5bffc686e159581750917207bbad2f6dcb",
+    "par2cmdline-turbo-1.4.0-macos-arm64.zip": "926139d3cf18f6c4e4aeb25d6fc12b758cdf4936788fb46acd18caf21ffa9a15",
+    "par2cmdline-turbo-1.4.0-macos-amd64.zip": "29ebb3629911a5b3ce4cdd8723a551a2877771b633630f443d99637559ef76be",
+    "par2cmdline-turbo-1.4.0-linux-amd64.zip": "0be495172b4b8aeabda39c493e47de652813fab88ae745c8633e901c05494281",
+    "par2cmdline-turbo-1.4.0-linux-arm64.zip": "1bb2acb2c549bb3a2e91be3ac6291b00d4b657a56ab23f763f2161ffe7df0fcd",
+    "nyuu-v0.4.2-win32.7z": "b14eb105e064ec2bd8f6d872c1c652a9943ea54d767c80554617f4eff6c801b8",
+    "nyuu-v0.4.2-linux-aarch64.tar.xz": "8a94f3f775996e4469736494074ac7663ff463748b0e302c2bc13d0ff4a88c0b",
+    "nyuu-v0.4.2-linux-amd64.tar.xz": "bbea69ffaf1d8ed3465935157e3842fe7a38bade2703504879eb8bc7c0a83dff",
+    "nyuu-v0.4.2-macos-x64.tar.xz": "040c56a486bc4ac7e3b0eed7a482ffce1bbf747ff731ad45ffd99d7230fcb2a0",
+}
+
+
+def verify_downloaded_asset(path: Path, asset: str) -> None:
+    """Fail closed unless a downloaded executable archive matches its pinned hash."""
+    expected = SHA256_BY_ASSET.get(asset)
+    if expected is None:
+        raise RuntimeError(f"No SHA-256 checksum is pinned for {asset}")
+    with path.open("rb") as asset_file:
+        actual = hashlib.file_digest(asset_file, "sha256").hexdigest()
+    if actual != expected:
+        raise RuntimeError(f"SHA-256 checksum mismatch for {asset}")

bin/get_7z.py

@@ -0,0 +1,146 @@
+# Upload Assistant © 2026 Audionut & wastaken7 — Licensed under UAPL v1.0
+import os
+import platform
+import shutil
+import stat
+import tarfile
+from pathlib import Path
+
+import aiofiles
+import httpx
+
+from bin.download_integrity import verify_downloaded_asset
+
+try:
+    from src.console import console, logger
+except ImportError:
+    import logging
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    class SimpleConsole:
+        def print(self, message: str, markup: bool = False) -> None:  # noqa: ARG002
+            print(message)
+
+    console = SimpleConsole()
+    logger = logging.getLogger(__name__)
+
+
+class SevenZipBinaryManager:
+    """Download 7-Zip binaries for the host architecture."""
+
+    @staticmethod
+    async def ensure_7z_binary(base_dir: str | Path, version: str = "26.01") -> str:
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+        logger.debug(f"[blue]7-Zip: Detected system: {system}, architecture: {machine}[/blue]")
+
+        platform_map: dict[str, dict[str, dict[str, str]]] = {
+            "windows": {
+                "x86_64": {"file": "7zr.exe", "folder": "windows/x86_64"},
+                "amd64": {"file": "7zr.exe", "folder": "windows/x86_64"},
+                "x86": {"file": "7zr.exe", "folder": "windows/x86"},
+                "arm64": {"file": "7zr.exe", "folder": "windows/arm64"},
+            },
+            "darwin": {
+                "arm64": {"file": "7z2601-mac.tar.xz", "folder": "macos/arm64"},
+                "x86_64": {"file": "7z2601-mac.tar.xz", "folder": "macos/x86_64"},
+                "amd64": {"file": "7z2601-mac.tar.xz", "folder": "macos/x86_64"},
+            },
+            "linux": {
+                "x86_64": {"file": "7z2601-linux-x64.tar.xz", "folder": "linux/amd64"},
+                "amd64": {"file": "7z2601-linux-x64.tar.xz", "folder": "linux/amd64"},
+                "arm64": {"file": "7z2601-linux-arm64.tar.xz", "folder": "linux/arm64"},
+                "aarch64": {"file": "7z2601-linux-arm64.tar.xz", "folder": "linux/arm64"},
+                "arm": {"file": "7z2601-linux-arm.tar.xz", "folder": "linux/arm"},
+                "armv7l": {"file": "7z2601-linux-arm.tar.xz", "folder": "linux/arm"},
+                "armv6l": {"file": "7z2601-linux-arm.tar.xz", "folder": "linux/arm"},
+            },
+        }
+
+        if system not in platform_map or machine not in platform_map[system]:
+            raise Exception(f"Unsupported platform for 7z: {system} {machine}")
+
+        platform_info = platform_map[system][machine]
+        file_pattern = platform_info["file"]
+        folder_path = platform_info["folder"]
+
+        bin_dir = Path(base_dir) / "bin" / "7z" / folder_path
+        bin_dir.mkdir(parents=True, exist_ok=True)
+
+        binary_name = "7zr.exe" if system == "windows" else "7zz"
+        binary_path = bin_dir / binary_name
+        version_path = bin_dir / version
+
+        binary_exists = binary_path.exists() and binary_path.is_file()
+        binary_executable = system == "windows" or os.access(binary_path, os.X_OK)
+        binary_valid = binary_exists and binary_executable
+
+        if version_path.exists() and version_path.is_file() and binary_valid:
+            logger.debug("[blue]7-Zip binary is up to date[/blue]")
+            return str(binary_path)
+
+        logger.info("[yellow]Binary '7z' not found. Attempting to download automatically...[/yellow]")
+
+        # Cleanup old files
+        if binary_path.exists():
+            binary_path.unlink()
+        if version_path.exists():
+            version_path.unlink()
+
+        download_url = f"https://github.com/ip7z/7zip/releases/download/{version}/{file_pattern}"
+        logger.debug(f"[blue]7-Zip Download URL: {download_url}[/blue]")
+
+        try:
+            async with (
+                httpx.AsyncClient(timeout=60.0, follow_redirects=True) as client,
+                client.stream("GET", download_url, timeout=60.0) as response,
+            ):
+                response.raise_for_status()
+                temp_file = bin_dir / f"temp_{file_pattern}"
+                async with aiofiles.open(temp_file, "wb") as f:
+                    async for chunk in response.aiter_bytes(chunk_size=8192):
+                        await f.write(chunk)
+
+            logger.debug(f"[green]Downloaded 7-Zip package: {file_pattern}[/green]")
+            verify_downloaded_asset(temp_file, file_pattern)
+
+            if file_pattern.endswith(".exe"):
+                # Windows 7zr.exe is a raw executable
+                shutil.move(str(temp_file), str(binary_path))
+            else:
+                # Linux/macOS are tar.xz archives
+                try:
+                    with tarfile.open(temp_file, "r:xz") as tar_ref:
+                        # Secure extract: prevent path traversal
+                        for member in tar_ref.getmembers():
+                            if member.islnk() or member.issym():
+                                continue
+                            if Path(member.name).is_absolute() or ".." in member.name or member.name.startswith("/"):
+                                continue
+                            full_path = os.path.realpath(Path(bin_dir) / member.name)
+                            base_path = os.path.realpath(bin_dir)
+                            if not full_path.startswith(base_path + os.sep) and full_path != base_path:
+                                continue
+                            tar_ref.extract(member, str(bin_dir))
+
+                    # Locate 7zz binary in extracted output
+                    if not binary_path.exists():
+                        for p in bin_dir.rglob("7zz"):
+                            if p.is_file():
+                                shutil.move(str(p), str(binary_path))
+                                break
+                finally:
+                    if temp_file.exists():
+                        temp_file.unlink()
+
+            if system != "windows" and binary_path.exists():
+                binary_path.chmod(binary_path.stat().st_mode | stat.S_IEXEC)
+
+            async with aiofiles.open(version_path, "w", encoding="utf-8") as version_file:
+                await version_file.write(f"7-Zip version {version} installed successfully.")
+
+            return str(binary_path)
+
+        except Exception as e:
+            raise Exception(f"Failed to setup 7z binary: {e}") from e

bin/get_bdinfo.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# Upload Assistant © 2025 Audionut & wastaken7 — Licensed under UAPL v1.0
+import os
+import platform
+import shutil
+import stat
+import tarfile
+import zipfile
+from pathlib import Path
+
+import aiofiles
+import httpx
+
+from bin.download_integrity import verify_downloaded_asset
+
+try:
+    from src.console import console, logger
+except ImportError:
+    import logging
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    class SimpleConsole:
+        def print(self, message: str, markup: bool = False) -> None:  # noqa: ARG002
+            print(message)
+
+    console = SimpleConsole()
+    logger = logging.getLogger(__name__)
+
+
+class BDInfoBinaryManager:
+    """Download autobrr/go-bdinfo binaries for the host architecture.
+
+    Default version pinned (see https://github.com/autobrr/go-bdinfo/releases).
+    """
+
+    @staticmethod
+    async def ensure_bdinfo_binary(base_dir: str | Path, version: str = "v0.4.0") -> str:
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+        logger.debug(f"[blue]Detected system: {system}, architecture: {machine}[/blue]")
+
+        platform_map: dict[str, dict[str, dict[str, str]]] = {
+            "windows": {
+                "x86_64": {"asset": "windows_amd64.zip", "folder": "windows/x86_64"},
+                "amd64": {"asset": "windows_amd64.zip", "folder": "windows/x86_64"},
+            },
+            "darwin": {
+                "arm64": {"asset": "darwin_arm64.tar.gz", "folder": "macos/arm64"},
+                "x86_64": {"asset": "darwin_amd64.tar.gz", "folder": "macos/x86_64"},
+                "amd64": {"asset": "darwin_amd64.tar.gz", "folder": "macos/x86_64"},
+            },
+            "linux": {
+                "x86_64": {"asset": "linux_amd64.tar.gz", "folder": "linux/amd64"},
+                "amd64": {"asset": "linux_amd64.tar.gz", "folder": "linux/amd64"},
+                "arm64": {"asset": "linux_arm64.tar.gz", "folder": "linux/arm64"},
+                "aarch64": {"asset": "linux_arm64.tar.gz", "folder": "linux/arm64"},
+                "armv7l": {"asset": "linux_arm.tar.gz", "folder": "linux/arm"},
+                "armv6l": {"asset": "linux_arm.tar.gz", "folder": "linux/arm"},
+                "arm": {"asset": "linux_arm.tar.gz", "folder": "linux/arm"},
+            },
+        }
+
+        if system not in platform_map or machine not in platform_map[system]:
+            raise Exception(f"Unsupported platform: {system} {machine}")
+
+        platform_info = platform_map[system][machine]
+        release_version = version.removeprefix("v")
+        file_pattern = f"bdinfo_{release_version}_{platform_info['asset']}"
+        folder_path = platform_info["folder"]
+        logger.debug(f"[blue]Using file pattern: {file_pattern}[/blue]")
+        logger.debug(f"[blue]Target folder: {folder_path}[/blue]")
+
+        bin_dir = Path(base_dir) / "bin" / "bdinfo" / folder_path
+        bin_dir.mkdir(parents=True, exist_ok=True)
+        logger.debug(f"[blue]Binary directory: {bin_dir}[/blue]")
+
+        binary_name = "bdinfo.exe" if system == "windows" else "bdinfo"
+        binary_path = bin_dir / binary_name
+        logger.debug(f"[blue]Binary path: {binary_path}[/blue]")
+
+        version_path = bin_dir / version
+        binary_exists = binary_path.exists() and binary_path.is_file()
+        binary_executable = system == "windows" or os.access(binary_path, os.X_OK)
+        binary_valid = binary_exists and binary_executable
+
+        def cleanup_old_version_files() -> None:
+            for candidate in bin_dir.iterdir():
+                if not candidate.is_file():
+                    continue
+                if candidate.name == version or candidate.name == binary_name:
+                    continue
+                if candidate.name.startswith("v"):
+                    if system != "windows":
+                        Path(candidate).chmod(0o644)
+                    candidate.unlink()
+                    logger.debug(f"[blue]Removed old version file at: {candidate}[/blue]")
+
+        if version_path.exists() and version_path.is_file() and binary_valid:
+            cleanup_old_version_files()
+            logger.debug("[blue]bdinfo version is up to date[/blue]")
+            return str(binary_path)
+
+        # Remove any old binary/version markers
+        if binary_path.exists() and binary_path.is_file():
+            if system != "windows":
+                Path(binary_path).chmod(0o600)
+            binary_path.unlink()
+            logger.debug(f"[blue]Removed existing binary at: {binary_path}[/blue]")
+
+        if version_path.exists():
+            if system != "windows":
+                Path(version_path).chmod(0o644)
+            version_path.unlink()
+            logger.debug(f"[blue]Removed existing version file at: {version_path}[/blue]")
+
+        cleanup_old_version_files()
+
+        # Construct download URL using autobrr/go-bdinfo release asset filename.
+        download_url = f"https://github.com/autobrr/go-bdinfo/releases/download/{version}/{file_pattern}"
+        logger.debug(f"[blue]Download URL: {download_url}[/blue]")
+
+        try:
+            async with (
+                httpx.AsyncClient(timeout=60.0, follow_redirects=True) as client,
+                client.stream("GET", download_url, timeout=60.0) as response,
+            ):
+                response.raise_for_status()
+                temp_archive = bin_dir / f"temp_{file_pattern}"
+                async with aiofiles.open(temp_archive, "wb") as f:
+                    async for chunk in response.aiter_bytes(chunk_size=8192):
+                        await f.write(chunk)
+            logger.debug(f"[green]Downloaded {file_pattern}[/green]")
+            verify_downloaded_asset(temp_archive, file_pattern)
+
+            # Extract archive safely and ensure temporary archive is always removed.
+            try:
+                if file_pattern.endswith(".zip"):
+                    with zipfile.ZipFile(temp_archive, "r") as zip_ref:
+
+                        def safe_extract_zip(zip_file: zipfile.ZipFile, path: str = ".") -> None:
+                            for member in zip_file.namelist():
+                                info = zip_file.getinfo(member)
+                                perm = info.external_attr >> 16
+                                if stat.S_ISLNK(perm):
+                                    logger.debug(f"[yellow]Warning: Skipping symlink: {member}[/yellow]")
+                                    continue
+
+                                # Check for absolute paths and directory traversal
+                                if Path(member).is_absolute() or ".." in member or member.startswith("/"):
+                                    logger.debug(f"[yellow]Warning: Skipping dangerous path: {member}[/yellow]")
+                                    continue
+
+                                # Verify final path is inside target directory
+                                full_path = os.path.realpath(Path(path) / member)
+                                base_path = os.path.realpath(path)
+                                if not full_path.startswith(base_path + os.sep) and full_path != base_path:
+                                    logger.debug(f"[yellow]Warning: Skipping path outside target directory: {member}[/yellow]")
+                                    continue
+
+                                # Check for reasonable file sizes (prevent zip bombs)
+                                try:
+                                    file_size = info.file_size
+                                except Exception:
+                                    file_size = 0
+
+                                if file_size > 100 * 1024 * 1024:
+                                    logger.debug(f"[yellow]Warning: Skipping oversized file: {member} ({file_size} bytes)[/yellow]")
+                                    continue
+
+                                # Extract the safe member
+                                zip_file.extract(member, path)
+                                logger.debug(f"[cyan]Extracted: {member}[/cyan]")
+
+                        safe_extract_zip(zip_ref, str(bin_dir))
+
+                elif file_pattern.endswith(".tar.gz"):
+                    with tarfile.open(temp_archive, "r:gz") as tar_ref:
+
+                        def safe_extract_tar(tar_file: tarfile.TarFile, path: str = ".") -> None:
+                            for member in tar_file.getmembers():
+                                if member.islnk() or member.issym():
+                                    logger.debug(f"[yellow]Warning: Skipping link entry: {member.name}[/yellow]")
+                                    continue
+                                if Path(member.name).is_absolute() or ".." in member.name or member.name.startswith("/"):
+                                    logger.debug(f"[yellow]Warning: Skipping dangerous path: {member.name}[/yellow]")
+                                    continue
+                                full_path = os.path.realpath(Path(path) / member.name)
+                                base_path = os.path.realpath(path)
+                                if not full_path.startswith(base_path + os.sep) and full_path != base_path:
+                                    logger.debug(f"[yellow]Warning: Skipping path outside target directory: {member.name}[/yellow]")
+                                    continue
+                                if member.size > 100 * 1024 * 1024:
+                                    logger.debug(f"[yellow]Warning: Skipping oversized file: {member.name} ({member.size} bytes)[/yellow]")
+                                    continue
+                                tar_file.extract(member, path)
+                                logger.debug(f"[cyan]Extracted: {member.name}[/cyan]")
+
+                        safe_extract_tar(tar_ref, str(bin_dir))
+
+                # If extraction created a nested directory (common for GitHub release zips),
+                # search for the bdinfo executable and move it to the expected binary path.
+                if not binary_path.exists():
+                    binary_basename = binary_name
+                    found = None
+                    for p in bin_dir.rglob(binary_basename):
+                        if p.is_file():
+                            found = p
+                            break
+
+                    if found:
+                        # Move to target location
+                        shutil.move(str(found), str(binary_path))
+
+                if system != "windows" and binary_path.exists():
+                    binary_path.chmod(binary_path.stat().st_mode | stat.S_IEXEC)
+
+                async with aiofiles.open(version_path, "w", encoding="utf-8") as version_file:
+                    await version_file.write(f"autobrr/go-bdinfo version {version} installed successfully.")
+                return str(binary_path)
+            finally:
+                try:
+                    if temp_archive.exists():
+                        temp_archive.unlink()
+                        logger.debug(f"[blue]Removed temporary archive: {temp_archive}[/blue]")
+                except Exception as unlink_exc:
+                    logger.debug(f"[yellow]Warning: Failed to remove temporary archive {temp_archive}: {unlink_exc}[/yellow]")
+        except httpx.RequestError as e:
+            raise Exception(f"Failed to download bdinfo binary: {e}") from e
+        except (zipfile.BadZipFile, tarfile.TarError) as e:
+            raise Exception(f"Failed to extract bdinfo binary: {e}") from e

bin/get_bdinfo_docker.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+# Upload Assistant © 2025 Audionut & wastaken7 — Licensed under UAPL v1.0
+"""
+Docker-specific script to download bdinfo binaries for Linux containers.
+"""
+
+import os
+import platform
+import shutil
+import sys
+import tarfile
+from pathlib import Path
+
+import requests
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from bin.download_integrity import verify_downloaded_asset
+
+try:
+    from src.console import console, logger
+except ImportError:
+    import logging
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    class SimpleConsole:
+        def print(self, message: str, markup: bool = False) -> None:  # noqa: ARG002
+            print(message)
+
+    console = SimpleConsole()
+    logger = logging.getLogger(__name__)
+
+
+BDINFO_VERSION = "v0.4.0"
+BASE_RELEASE_URL = "https://github.com/autobrr/go-bdinfo/releases/download"
+
+
+def download_file(url: str, output_path: Path) -> None:
+    logger.info(f"Downloading: {url}", extra={"markup": False})
+    resp = requests.get(url, stream=True, timeout=60)
+    resp.raise_for_status()
+    with Path(output_path).open("wb") as f:
+        for chunk in resp.iter_content(chunk_size=8192):
+            f.write(chunk)
+    logger.info(f"Downloaded: {output_path.name}", extra={"markup": False})
+
+
+def secure_extract_tar(tar_path: Path, extract_to: Path) -> None:
+    with tarfile.open(tar_path, "r:gz") as tar_ref:
+        base_path = extract_to.resolve()
+        for member in tar_ref.getmembers():
+            if member.issym() or member.islnk():
+                logger.warning(f"Warning: Skipping link: {member.name}", extra={"markup": False})
+                continue
+            if Path(member.name).is_absolute() or ".." in Path(member.name).parts:
+                logger.warning(f"Warning: Skipping dangerous path: {member.name}", extra={"markup": False})
+                continue
+            try:
+                final_path = (base_path / member.name).resolve()
+                try:
+                    os.path.commonpath([str(base_path), str(final_path)])
+                    if not str(final_path).startswith(str(base_path) + os.sep) and final_path != base_path:
+                        logger.warning(f"Warning: Path outside base directory: {member.name}", extra={"markup": False})
+                        continue
+                except ValueError:
+                    logger.warning(f"Warning: Invalid path resolution: {member.name}", extra={"markup": False})
+                    continue
+            except (OSError, ValueError) as e:
+                logger.warning(f"Warning: Path resolution failed for {member.name}: {e}", extra={"markup": False})
+                continue
+
+            if not (member.isfile() or member.isdir()):
+                logger.warning(f"Warning: Skipping non-regular file: {member.name}", extra={"markup": False})
+                continue
+
+            if member.isfile() and member.size > 100 * 1024 * 1024:
+                logger.warning(f"Warning: Skipping oversized file: {member.name} ({member.size} bytes)", extra={"markup": False})
+                continue
+
+            if member.isdir():
+                target_dir = base_path / member.name
+                target_dir.mkdir(parents=True, exist_ok=True)
+                target_dir.chmod(0o700)
+            elif member.isfile():
+                target_file = base_path / member.name
+                target_file.parent.mkdir(parents=True, exist_ok=True)
+                source = tar_ref.extractfile(member)
+                if source is not None:
+                    with source, Path(target_file).open("wb") as out_f:
+                        out_f.write(source.read())
+                    target_file.chmod(0o600)
+
+
+def download_bdinfo_for_docker(base_dir: Path = Path("/Upload-Assistant"), version: str = BDINFO_VERSION) -> str:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    logger.info(f"System: {system}, Architecture: {machine}", extra={"markup": False})
+
+    if system != "linux":
+        raise Exception(f"This script is only for Linux containers, got: {system}")
+
+    if machine in ("amd64", "x86_64"):
+        asset = "linux_amd64.tar.gz"
+        folder = "linux/amd64"
+    elif machine in ("arm64", "aarch64"):
+        asset = "linux_arm64.tar.gz"
+        folder = "linux/arm64"
+    elif machine.startswith("arm"):
+        asset = "linux_arm.tar.gz"
+        folder = "linux/arm"
+    else:
+        raise Exception(f"Unsupported architecture: {machine}")
+
+    file_pattern = f"bdinfo_{version.removeprefix('v')}_{asset}"
+    bin_dir = base_dir / "bin" / "bdinfo" / folder
+    bin_dir.mkdir(parents=True, exist_ok=True)
+    binary_path = bin_dir / "bdinfo"
+    version_path = bin_dir / version
+
+    if version_path.exists() and binary_path.exists() and os.access(binary_path, os.X_OK):
+        logger.info(f"bdinfo {version} already installed", extra={"markup": False})
+        return str(binary_path)
+
+    download_url = f"{BASE_RELEASE_URL}/{version}/{file_pattern}"
+    logger.info(f"Downloading bdinfo from: {download_url}", extra={"markup": False})
+
+    temp_archive = bin_dir / f"temp_{file_pattern}"
+    download_file(download_url, temp_archive)
+    verify_downloaded_asset(temp_archive, file_pattern)
+
+    logger.info(f"Extracting {temp_archive} to {bin_dir}", extra={"markup": False})
+    secure_extract_tar(temp_archive, bin_dir)
+    temp_archive.unlink()
+
+    # Search for extracted bdinfo executable and move it into place if necessary
+    if not binary_path.exists():
+        found = None
+        for p in bin_dir.rglob("bdinfo"):
+            if p.is_file():
+                found = p
+                break
+        if found:
+            shutil.move(str(found), str(binary_path))
+
+    if not binary_path.exists():
+        raise Exception(f"Failed to extract bdinfo binary to {binary_path}")
+
+    Path(binary_path).chmod(0o700)
+
+    with Path(version_path).open("w", encoding="utf-8") as vf:
+        vf.write(f"autobrr/go-bdinfo version {version} installed successfully.")
+
+    logger.info(f"Installed bdinfo: {binary_path}", extra={"markup": False})
+    return str(binary_path)
+
+
+if __name__ == "__main__":
+    try:
+        download_bdinfo_for_docker()
+        logger.info("bdinfo installation completed successfully!", extra={"markup": False})
+    except Exception as exc:
+        logger.info(f"ERROR: Failed to install bdinfo: {exc}", extra={"markup": False})
+        raise SystemExit(1) from exc