Update app.py

app.py

@@ -1,486 +1,249 @@
-#!/usr/bin/env python3
-"""
-bootloader.py - Mac OS 15 Sequoia Bootloader 
-Uses download URL as bootable USB and JSON as storage disk for installation.
+"""A local FastAPI UI for downloading authorized TikTok videos through SaveTT.
+
+Run with:
+    uvicorn app:app --host 127.0.0.1 --port 8000
 """
 
-import requests
-import duckdb
+from __future__ import annotations
+
+import asyncio
 import json
-import hashlib
-import os
-import shutil
-import subprocess
+import re
 import tempfile
-import tarfile
-import zipfile
-from datetime import datetime
 from pathlib import Path
-from fastapi import FastAPI, Request, Response, HTTPException, Depends, status
-from fastapi.responses import JSONResponse, HTMLResponse, RedirectResponse
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-
-
-app = FastAPI()
-
-class MacOSBootloader:
-    def __init__(self, iso_url, storage_json_url):
-        self.iso_url = iso_url
-        self.storage_json_url = storage_json_url
-        self.temp_dir = tempfile.mkdtemp(prefix="macos_sequoia_")
-        
-        # Bootable USB (download URL) mount point
-        self.usb_mount_point = os.path.join(self.temp_dir, "bootable_usb")
-        os.makedirs(self.usb_mount_point, exist_ok=True)
-        
-        # Storage disk (JSON) mount point
-        self.storage_mount_point = os.path.join(self.temp_dir, "storage_disk")
-        os.makedirs(self.storage_mount_point, exist_ok=True)
-        
-        # Installation target
-        self.install_target = os.path.join(self.temp_dir, "macos_sequoia")
-        os.makedirs(self.install_target, exist_ok=True)
-        
-    def download_bootable_usb(self):
-        """Download the bootable USB image (ISO) from URL"""
-        print(f"📥 Downloading bootable USB image: {self.iso_url}")
-        
-        try:
-            # Get file info first
-            response = requests.head(self.iso_url, allow_redirects=True, timeout=30)
-            response.raise_for_status()
-            
-            file_size = int(response.headers.get('content-length', 0))
-            print(f"📦 Bootable USB size: {file_size / (1024*1024*1024):.2f} GB")
-            
-            # Download the actual file
-            usb_path = os.path.join(self.temp_dir, "bootable_usb_image.iso")
-            
-            print("⏬ Downloading installation media...")
-            with requests.get(self.iso_url, stream=True, timeout=60) as r:
-                r.raise_for_status()
-                with open(usb_path, 'wb') as f:
-                    for chunk in r.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                        downloaded = os.path.getsize(usb_path)
-                        progress = (downloaded / file_size) * 100
-                        print(f"   📊 Progress: {progress:.1f}%", end='\r')
-            
-            print(f"\n✅ Bootable USB downloaded: {usb_path}")
-            return usb_path
-            
-        except Exception as e:
-            print(f"❌ Bootable USB download error: {e}")
-            return None
-    
-    def mount_bootable_usb(self, usb_path):
-        """Mount the bootable USB image"""
-        print("🔗 Mounting bootable USB...")
-        
+from typing import Final
+from urllib.parse import urlparse
+from uuid import uuid4
+
+from fastapi import FastAPI, Form
+from fastapi.responses import FileResponse, HTMLResponse
+from starlette.background import BackgroundTask
+from playwright.async_api import async_playwright
+
+SAVE_TT_HOME: Final = "https://savett.cc/en1/"
+NAVIGATION_TIMEOUT_MS: Final = 60_000
+MEDIA_TIMEOUT_MS: Final = 90_000
+TMP_DIR: Final = Path(tempfile.gettempdir()) / "savett_fastapi_downloads"
+
+app = FastAPI(title="TikTok MP4 Downloader", docs_url=None, redoc_url=None)
+# The downloader uses a full Chromium browser for each request. Serializing jobs
+# keeps the lightweight local server predictable and avoids concurrent browser load.
+download_lock = asyncio.Lock()
+
+
+def render_home(error: str | None = None) -> str:
+    error_markup = ""
+    if error:
+        error_markup = f'<div class="notice error" role="alert">{error}</div>'
+
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>TikTok MP4 Downloader</title>
+  <style>
+    :root {{ color-scheme: light; }}
+    * {{ box-sizing: border-box; }}
+    body {{
+      margin: 0;
+      min-height: 100vh;
+      display: grid;
+      place-items: center;
+      background: radial-gradient(circle at top left, #203e72, #0b1020 58%);
+      color: #192132;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    }}
+    main {{ width: min(680px, calc(100% - 32px)); padding: 24px 0; }}
+    .card {{
+      overflow: hidden;
+      background: rgba(255,255,255,.98);
+      border: 1px solid rgba(255,255,255,.36);
+      border-radius: 22px;
+      box-shadow: 0 24px 80px rgba(0,0,0,.30);
+    }}
+    .header {{ padding: 36px 38px 28px; background: linear-gradient(135deg, #edf4ff, #f8fbff); }}
+    .eyebrow {{ margin: 0 0 10px; color: #2b5da8; font-size: .78rem; font-weight: 750; letter-spacing: .11em; text-transform: uppercase; }}
+    h1 {{ margin: 0; font-size: clamp(1.8rem, 4.6vw, 2.55rem); letter-spacing: -.04em; }}
+    .subhead {{ max-width: 560px; margin: 12px 0 0; color: #5a6678; font-size: 1rem; line-height: 1.55; }}
+    form {{ padding: 30px 38px 18px; }}
+    label {{ display: block; margin-bottom: 9px; font-size: .9rem; font-weight: 700; }}
+    input {{
+      width: 100%; padding: 15px 16px; border: 1px solid #cfd8e8; border-radius: 12px;
+      outline: none; color: #172033; font: inherit; transition: box-shadow .18s, border-color .18s;
+    }}
+    input:focus {{ border-color: #3e75c6; box-shadow: 0 0 0 4px rgba(62,117,198,.16); }}
+    button {{
+      width: 100%; margin-top: 14px; padding: 15px 18px; border: 0; border-radius: 12px;
+      background: #235fb4; color: white; cursor: pointer; font: 700 1rem/1.2 inherit;
+      transition: background .18s, transform .18s;
+    }}
+    button:hover {{ background: #174d97; }}
+    button:active {{ transform: translateY(1px); }}
+    .notice {{ margin: 0 38px; padding: 12px 14px; border-radius: 10px; font-size: .92rem; line-height: 1.4; }}
+    .error {{ background: #fff0f0; border: 1px solid #f3c2c2; color: #9a2424; }}
+    .footer {{ margin: 0; padding: 6px 38px 34px; color: #697488; font-size: .82rem; line-height: 1.55; }}
+    .loading {{ display: none; margin-top: 12px; color: #526379; font-size: .9rem; text-align: center; }}
+    form.is-submitting button {{ opacity: .75; cursor: wait; }}
+    form.is-submitting .loading {{ display: block; }}
+  </style>
+</head>
+<body>
+  <main>
+    <section class="card" aria-labelledby="page-title">
+      <header class="header">
+        <p class="eyebrow">Local FastAPI utility</p>
+        <h1 id="page-title">Download a TikTok MP4</h1>
+        <p class="subhead">Paste a public TikTok video link. The server fetches the MP4 and your browser saves the completed file.</p>
+      </header>
+      {error_markup}
+      <form id="download-form" action="/download" method="post">
+        <label for="tiktok-url">TikTok video URL</label>
+        <input id="tiktok-url" name="tiktok_url" type="url" required autocomplete="off" placeholder="https://www.tiktok.com/@creator/video/...">
+        <button type="submit">Download MP4</button>
+        <p class="loading" aria-live="polite">Processing the link and preparing your download. This can take up to a minute.</p>
+      </form>
+      <p class="footer">Use this utility only to download videos that you own or are otherwise authorized to save. Download links returned by the source service are temporary.</p>
+    </section>
+  </main>
+  <script>
+    document.getElementById('download-form').addEventListener('submit', (event) => {{
+      event.currentTarget.classList.add('is-submitting');
+    }});
+  </script>
+</body>
+</html>"""
+
+
+def validate_tiktok_url(raw_url: str) -> str:
+    """Return a normalized TikTok URL or raise ValueError for an invalid input."""
+    try:
+        parsed = urlparse(raw_url.strip())
+    except ValueError as exc:
+        raise ValueError("Enter a valid TikTok video URL.") from exc
+
+    host = (parsed.hostname or "").lower()
+    if parsed.scheme not in {"http", "https"} or not (host == "tiktok.com" or host.endswith(".tiktok.com")):
+        raise ValueError("The URL must be from tiktok.com.")
+    if not re.search(r"/video/\d+", parsed.path):
+        raise ValueError("The URL must point to a TikTok video (it should include /video/<id>).")
+    return parsed.geturl()
+
+
+def video_id_from_url(tiktok_url: str) -> str:
+    match = re.search(r"/video/(\d+)", tiktok_url)
+    return match.group(1) if match else uuid4().hex
+
+
+def looks_like_video(body: bytes, content_type: str) -> bool:
+    """Reject HTML/JSON error pages returned in place of media."""
+    if len(body) < 32:
+        return False
+    if "text/html" in content_type or "application/json" in content_type:
+        return False
+    return body[4:8] == b"ftyp" or content_type.startswith("video/")
+
+
+async def fetch_mp4(tiktok_url: str) -> tuple[Path, str]:
+    """Use Playwright to get SaveTT's MP4 URLs and store the first usable file."""
+    TMP_DIR.mkdir(parents=True, exist_ok=True)
+    video_id = video_id_from_url(tiktok_url)
+    output_path = TMP_DIR / f"tiktok_{video_id}_{uuid4().hex[:8]}.mp4"
+
+    async with async_playwright() as playwright:
+        browser = await playwright.chromium.launch(headless=True)
+        context = await browser.new_context(
+            user_agent=(
+                "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+                "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+            ),
+            viewport={"width": 1365, "height": 900},
+        )
+        page = await context.new_page()
+        page.set_default_timeout(NAVIGATION_TIMEOUT_MS)
+
         try:
-            # For ISO files, we need to extract or mount them
-            if usb_path.endswith('.iso'):
-                # Try to mount using system commands (Linux/Mac)
+            await page.goto(SAVE_TT_HOME, wait_until="domcontentloaded")
+            await page.locator('input[name="url"]').fill(tiktok_url)
+            await asyncio.gather(
+                page.wait_for_url(re.compile(r"/en1/download(?:$|\?)"), timeout=NAVIGATION_TIMEOUT_MS),
+                page.locator('form#go button[type="submit"]').click(),
+            )
+
+            # SaveTT places temporary media URLs as JSON in the MP4 option value.
+            mp4_payload = await page.locator("#formatselect option").evaluate_all(
+                """options => {
+                  const mp4 = options.find(option => option.textContent.trim() === 'MP4');
+                  return mp4 ? mp4.value : null;
+                }"""
+            )
+            if not mp4_payload:
+                raise RuntimeError("The downloader did not return an MP4 option for that URL.")
+
+            try:
+                media_urls = json.loads(mp4_payload).get("URL", [])
+            except json.JSONDecodeError as exc:
+                raise RuntimeError("The downloader returned an invalid MP4 response.") from exc
+
+            if not isinstance(media_urls, list) or not media_urls:
+                raise RuntimeError("The downloader did not supply a media URL.")
+
+            last_error: Exception | None = None
+            for media_url in media_urls:
                 try:
-                    subprocess.run([
-                        'hdiutil', 'attach', usb_path, 
-                        '-mountpoint', self.usb_mount_point,
-                        '-noverify', '-nobrowse'
-                    ], check=True, capture_output=True)
-                    print("✅ Bootable USB mounted using hdiutil")
-                except:
-                    # Fallback: extract using Python
-                    print("⚠️  Using fallback extraction method")
-                    with open(usb_path, 'rb') as iso_file:
-                        # Simple extraction - actual ISO parsing would be more complex
-                        # This is a simplified version for demonstration
-                        shutil.copyfileobj(iso_file, open(os.path.join(self.usb_mount_point, 'boot.image'), 'wb'))
-            
-            elif usb_path.endswith(('.zip', '.tar.gz', '.tgz')):
-                # Extract compressed files
-                if usb_path.endswith('.zip'):
-                    with zipfile.ZipFile(usb_path, 'r') as zip_ref:
-                        zip_ref.extractall(self.usb_mount_point)
-                else:
-                    with tarfile.open(usb_path, 'r:*') as tar_ref:
-                        tar_ref.extractall(self.usb_mount_point)
-                
-                print("✅ Bootable USB extracted")
-            
-            # Verify USB contents
-            usb_contents = os.listdir(self.usb_mount_point)
-            print(f"📁 USB contents: {len(usb_contents)} items")
-            
-            return True
-            
-        except Exception as e:
-            print(f"❌ Bootable USB mount error: {e}")
-            return False
-    
-    def connect_to_storage_disk(self):
-        """Connect to JSON storage disk"""
-        print(f"💾 Connecting to storage disk: {self.storage_json_url}")
-        
-        try:
-            # Download storage JSON
-            response = requests.get(self.storage_json_url, timeout=30)
-            response.raise_for_status()
-            self.storage_data = response.json()
-            
-            # Create storage disk structure
-            storage_structure = self.storage_data.get('storage_structure', {})
-            self._create_storage_structure(self.storage_mount_point, storage_structure)
-            
-            print(f"✅ Storage disk connected: {len(storage_structure)} directories")
-            return True
-            
-        except Exception as e:
-            print(f"❌ Storage disk connection error: {e}")
-            return False
-    
-    def _create_storage_structure(self, base_path, structure):
-        """Create storage disk directory structure"""
-        for dir_name, dir_content in structure.items():
-            dir_path = os.path.join(base_path, dir_name)
-            os.makedirs(dir_path, exist_ok=True)
-            
-            if isinstance(dir_content, dict):
-                self._create_storage_structure(dir_path, dir_content)
-    
-    def verify_installation_media(self):
-        """Verify the bootable USB contents"""
-        print("🔍 Verifying installation media...")
-        
-        try:
-            required_files = [
-                'boot.efi', 'mach_kernel', 'BaseSystem.dmg',
-                'InstallESD.dmg', 'InstallInfo.plist'
-            ]
-            
-            usb_files = os.listdir(self.usb_mount_point)
-            found_files = [f for f in required_files if any(f in usb_file for usb_file in usb_files)]
-            
-            print(f"��� Found {len(found_files)}/{len(required_files)} required files")
-            return len(found_files) >= 3  # At least 3 critical files
-            
-        except Exception as e:
-            print(f"❌ Media verification error: {e}")
-            return False
-    
-    def prepare_installation(self):
-        """Prepare the installation environment"""
-        print("🛠️ Preparing installation environment...")
-        
-        try:
-            # Create installation directories
-            directories = [
-                'System', 'Library', 'Applications', 'Users', 
-                'private', 'var', 'tmp', 'Volumes'
-            ]
-            
-            for directory in directories:
-                os.makedirs(os.path.join(self.install_target, directory), exist_ok=True)
-            
-            # Copy essential files from USB to installation target
-            essential_files = ['mach_kernel', 'boot.efi']
-            for file in essential_files:
-                src = self._find_file_in_usb(file)
-                if src:
-                    dst = os.path.join(self.install_target, file)
-                    shutil.copy2(src, dst)
-                    print(f"   ✅ Copied: {file}")
-            
-            return True
-            
-        except Exception as e:
-            print(f"❌ Preparation error: {e}")
-            return False
-    
-    def _find_file_in_usb(self, filename):
-        """Find a file in the USB mount point"""
-        for root, dirs, files in os.walk(self.usb_mount_point):
-            if filename in files:
-                return os.path.join(root, filename)
-        return None
-    
-    def install_operating_system(self):
-        """Main installation process"""
-        print("🚀 Installing Mac OS 15 Sequoia...")
-        
-        try:
-            # Step 1: Install base system
-            print("📦 Installing base system...")
-            base_system = self._find_file_in_usb('BaseSystem.dmg')
-            if base_system:
-                self._install_dmg(base_system, self.install_target)
-            
-            # Step 2: Install additional components
-            print("⚙️ Installing system components...")
-            install_esd = self._find_file_in_usb('InstallESD.dmg')
-            if install_esd:
-                self._install_dmg(install_esd, os.path.join(self.install_target, 'System', 'Installation'))
-            
-            # Step 3: Copy installation packages
-            print("📦 Copying installation packages...")
-            pkg_dir = os.path.join(self.usb_mount_point, 'Packages')
-            if os.path.exists(pkg_dir):
-                target_pkg = os.path.join(self.install_target, 'System', 'Installation', 'Packages')
-                shutil.copytree(pkg_dir, target_pkg)
-                print(f"   ✅ Copied {len(os.listdir(pkg_dir))} packages")
-            
-            # Step 4: Create system configuration
-            print("⚙️ Creating system configuration...")
-            self._create_system_configuration()
-            
-            # Step 5: Set up boot files
-            print("👢 Setting up boot configuration...")
-            self._setup_boot_configuration()
-            
-            print("✅ Operating system installation complete")
-            return True
-            
-        except Exception as e:
-            print(f"❌ Installation error: {e}")
-            return False
-    
-    def _install_dmg(self, dmg_path, target_dir):
-        """Simulate DMG installation"""
-        print(f"   🖥️ Installing {os.path.basename(dmg_path)}...")
-        
-        # In a real scenario, this would use hdiutil or similar
-        # For simulation, we'll create the expected directory structure
-        os.makedirs(target_dir, exist_ok=True)
-        
-        # Create essential files that would be in the DMG
-        essential_files = [
-            'System/Library/CoreServices/SystemVersion.plist',
-            'System/Library/CoreServices/boot.efi',
-            'usr/lib/dyld',
-            'bin/bash',
-            'sbin/launchd'
-        ]
-        
-        for file_path in essential_files:
-            full_path = os.path.join(target_dir, file_path)
-            os.makedirs(os.path.dirname(full_path), exist_ok=True)
-            
-            if file_path.endswith('.plist'):
-                # Create plist file
-                plist_content = {
-                    'ProductName': 'Mac OS X',
-                    'ProductVersion': '15.0',
-                    'ProductBuildVersion': '24A344',
-                    'ProductCopyright': '1983-2024 Apple Inc.'
-                }
-                with open(full_path, 'w') as f:
-                    json.dump(plist_content, f, indent=2)
-            else:
-                # Create placeholder file
-                with open(full_path, 'w') as f:
-                    f.write(f"# Placeholder for {os.path.basename(file_path)}\n")
-        
-        print(f"   ✅ Installed {os.path.basename(dmg_path)}")
-    
-    def _create_system_configuration(self):
-        """Create system configuration files"""
-        config_files = {
-            'System/Library/CoreServices/SystemVersion.plist': {
-                'ProductName': 'Mac OS X',
-                'ProductVersion': '15.0',
-                'ProductBuildVersion': '24A344',
-                'ProductCopyright': '1983-2024 Apple Inc.'
-            },
-            'etc/hosts': '127.0.0.1 localhost\n::1 localhost\n',
-            'etc/fstab': ''  # Empty fstab for now
-        }
-        
-        for file_path, content in config_files.items():
-            full_path = os.path.join(self.install_target, file_path)
-            os.makedirs(os.path.dirname(full_path), exist_ok=True)
-            
-            if isinstance(content, dict):
-                with open(full_path, 'w') as f:
-                    json.dump(content, f, indent=2)
-            else:
-                with open(full_path, 'w') as f:
-                    f.write(content)
-    
-    def _setup_boot_configuration(self):
-        """Set up boot configuration"""
-        boot_files = {
-            'boot.efi': '# UEFI bootloader\n',
-            'System/Library/CoreServices/boot.efi': '# macOS bootloader\n',
-            'Library/Preferences/SystemConfiguration/com.apple.Boot.plist': {
-                'Kernel Flags': '',
-                'Kernel Cache': 'prelinkedkernel',
-                'Timeout': '0'
-            }
-        }
-        
-        for file_path, content in boot_files.items():
-            full_path = os.path.join(self.install_target, file_path)
-            os.makedirs(os.path.dirname(full_path), exist_ok=True)
-            
-            if isinstance(content, dict):
-                with open(full_path, 'w') as f:
-                    json.dump(content, f, indent=2)
-            else:
-                with open(full_path, 'w') as f:
-                    f.write(content)
-    
-    def finalize_installation(self):
-        """Finalize the installation"""
-        print("🎯 Finalizing installation...")
-        
-        try:
-            # Update storage disk with installation info
-            installation_info = {
-                'installation_date': datetime.utcnow().isoformat(),
-                'version': '15.0',
-                'build': '24A344',
-                'install_path': self.install_target,
-                'status': 'completed'
-            }
-            
-            info_path = os.path.join(self.storage_mount_point, 'installation_info.json')
-            with open(info_path, 'w') as f:
-                json.dump(installation_info, f, indent=2)
-            
-            # Create success marker
-            success_path = os.path.join(self.install_target, '.installation_complete')
-            with open(success_path, 'w') as f:
-                f.write('Installation completed successfully\n')
-            
-            print("✅ Installation finalized")
-            return True
-            
-        except Exception as e:
-            print(f"❌ Finalization error: {e}")
-            return False
-    
-    def verify_installation(self):
-        """Verify the installation was successful"""
-        print("🔍 Verifying installation...")
-        
-        try:
-            required_files = [
-                'mach_kernel',
-                'System/Library/CoreServices/SystemVersion.plist',
-                'System/Library/CoreServices/boot.efi',
-                'usr/lib/dyld'
-            ]
-            
-            missing_files = []
-            for file_path in required_files:
-                full_path = os.path.join(self.install_target, file_path)
-                if not os.path.exists(full_path):
-                    missing_files.append(file_path)
-            
-            if missing_files:
-                print(f"❌ Missing files: {missing_files}")
-                return False
-            
-            print("✅ Installation verification passed")
-            return True
-            
-        except Exception as e:
-            print(f"❌ Verification error: {e}")
-            return False
-    
-    def run_installation(self):
-        """Main installation process"""
-        print("🚀 Starting Mac OS 15 Sequoia Installation")
-        print("=" * 60)
-        print(f"📀 Bootable USB: {self.iso_url}")
-        print(f"💾 Storage Disk: {self.storage_json_url}")
-        print("=" * 60)
-        
-        # Step 1: Download bootable USB
-        usb_path = self.download_bootable_usb()
-        if not usb_path:
-            return False
-        
-        # Step 2: Mount bootable USB
-        if not self.mount_bootable_usb(usb_path):
-            return False
-        
-        # Step 3: Connect to storage disk
-        if not self.connect_to_storage_disk():
-            return False
-        
-        # Step 4: Verify installation media
-        if not self.verify_installation_media():
-            return False
-        
-        # Step 5: Prepare installation
-        if not self.prepare_installation():
-            return False
-        
-        # Step 6: Install OS
-        if not self.install_operating_system():
-            return False
-        
-        # Step 7: Finalize installation
-        if not self.finalize_installation():
-            return False
-        
-        # Step 8: Verify installation
-        if not self.verify_installation():
-            return False
-        
-        print("=" * 60)
-        print("🎉 Mac OS 15 Sequoia Installation Complete!")
-        print(f"📁 Installed at: {self.install_target}")
-        print(f"💾 Storage updated: {self.storage_mount_point}")
-        
-        return True
-    
-    def cleanup(self):
-        """Clean up temporary files"""
-        try:
-            shutil.rmtree(self.temp_dir)
-            print(f"🧹 Cleaned up temporary files: {self.temp_dir}")
-        except:
-            print(f"⚠️ Could not clean up temporary files: {self.temp_dir}")
-
-def main():
-    # Configuration
-    ISO_URL = "https://archive.org/download/mac-os-15-sequoia-by-metaperso/Mac%20Os%2015%20Sequoia%20by%20Metaperso.iso"
-    STORAGE_JSON_URL = "https://huggingface.co/datasets/Fred808/helium/raw/main/storage.json"
-    
-    # Create bootloader instance
-    bootloader = MacOSBootloader(ISO_URL, STORAGE_JSON_URL)
-    
+                    response = await context.request.get(
+                        media_url,
+                        headers={"Referer": "https://www.tiktok.com/", "Accept": "*/*"},
+                        timeout=MEDIA_TIMEOUT_MS,
+                        max_redirects=10,
+                    )
+                    if not response.ok:
+                        raise RuntimeError(f"The media server returned HTTP {response.status}.")
+
+                    body = await response.body()
+                    content_type = response.headers.get("content-type", "").lower()
+                    if not looks_like_video(body, content_type):
+                        raise RuntimeError("The media server did not return an MP4 file.")
+
+                    await asyncio.to_thread(output_path.write_bytes, body)
+                    return output_path, f"tiktok_{video_id}.mp4"
+                except Exception as exc:  # Try each backup media URL returned by SaveTT.
+                    last_error = exc
+
+            raise RuntimeError(f"Every available media URL failed. Last error: {last_error}")
+        finally:
+            await context.close()
+            await browser.close()
+
+
+def remove_file(path: Path) -> None:
     try:
-        # Run installation
-        success = bootloader.run_installation()
-        
-        if success:
-            print("\n✅ Mac OS 15 Sequoia installed successfully!")
-            print(f"📂 OS Location: {bootloader.install_target}")
-        else:
-            print("\n❌ Installation failed!")
-            return 1
-            
-    except KeyboardInterrupt:
-        print("\n⏹️ Installation interrupted by user")
-        return 1
-    except Exception as e:
-        print(f"\n💥 Unexpected error: {e}")
-        return 1
-    finally:
-        # Ask user if they want to clean up
-        cleanup = input("\n🧹 Clean up installation files? (y/N): ").lower().strip()
-        if cleanup == 'y':
-            bootloader.cleanup()
-        else:
-            print(f"📁 Installation files preserved at: {bootloader.temp_dir}")
-    
-    return 0
-
-if __name__ == "__main__":
-    exit(main())
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+        path.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+@app.get("/", response_class=HTMLResponse)
+async def home() -> HTMLResponse:
+    return HTMLResponse(render_home())
+
+
+@app.post("/download")
+async def download(tiktok_url: str = Form(...)):
+    try:
+        validated_url = validate_tiktok_url(tiktok_url)
+    except ValueError as exc:
+        return HTMLResponse(render_home(str(exc)), status_code=400)
+
+    try:
+        async with download_lock:
+            file_path, download_name = await fetch_mp4(validated_url)
+    except Exception as exc:
+        return HTMLResponse(render_home(f"Download failed: {exc}"), status_code=502)
+
+    return FileResponse(
+        file_path,
+        media_type="video/mp4",
+        filename=download_name,
+        background=BackgroundTask(remove_file, file_path),
+    )