Initial commit for beta-tgdrive

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+*.pyc
+*.data
+t.py
+t2.py
+cache/*
+!cache/*.session
+config copy.py
+logs.txt
+.env

Dockerfile

@@ -0,0 +1,18 @@
+# Use the official Python base image
+FROM python:3.11.7-slim AS base
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy the requirements file to the working directory and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code to the working directory
+COPY . .
+
+# Expose the port on which the application will run (Hugging Face Spaces uses 7860)
+EXPOSE 7860
+
+# Run the FastAPI application using uvicorn server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TechShreyash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,179 @@
+---
+title: TGDRIVE
+emoji: 🌍
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+# TGDrive - A Google Drive Clone with Telegram Storage
+
+Welcome to TGDrive! This web application replicates Google Drive's functionalities using Telegram as its storage backend. Manage folders and files, perform actions like uploading, renaming, and deleting, utilize trash/bin support, enable permanent deletion, and share public links. The application offers admin login and automatically backs up the database to Telegram.
+
+**Check out the [TGDrive Personal](https://github.com/TechShreyash/TGDrivePersonal) project for local desktop backup support.**
+
+## Features
+
+- **File Management:** Upload, rename, and delete files with integrated trash/bin functionality and permanent deletion support.
+- **Folder Management:** Easily create, rename, and delete folders.
+- **Sharing:** Seamlessly share public links for files and folders.
+- **Admin Support:** Secure admin login for efficient management.
+- **Automatic Backups:** Automated database backups sent directly to Telegram.
+- **Multiple Bots/Clients:** Support for multiple bots/clients for file operations and streaming from Telegram.
+- **Large File Support:** Upload files up to 4GB using Telegram Premium accounts.
+- **Auto Pinger:** Built-in feature to keep the website active by preventing idle timeouts.
+- **URL Upload Support:** Upload files directly to TG Drive from any direct download link of a file.
+- **Bot Mode:** Upload files directly to any folder in TG Drive by sending the file to the bot on Telegram ([Know More](#tg-drives-bot-mode))
+
+## Tech Stack
+
+- **Backend:** Python, FastAPI
+- **Frontend:** HTML, CSS, JavaScript
+- **Database:** Local storage as a class object, saved to a file using the pickle module.
+- **Storage:** Telegram
+
+### Environment Variables
+
+#### Required Variables
+
+| Variable Name            | Type    | Example                   | Description                                                          |
+| ------------------------ | ------- | ------------------------- | -------------------------------------------------------------------- |
+| `API_ID`                 | integer | 123456                    | Your Telegram API ID                                                 |
+| `API_HASH`               | string  | dagsjdhgjfsahgjfh         | Your Telegram API Hash                                               |
+| `BOT_TOKENS`             | string  | 21413535:gkdshajfhjfakhjf | List of Telegram bot tokens for file operations, separated by commas |
+| `STORAGE_CHANNEL`        | integer | -100123456789             | Chat ID of the Telegram storage channel                              |
+| `DATABASE_BACKUP_MSG_ID` | integer | 123                       | Message ID of a file in the storage channel for database backups     |
+
+> Note: All bots mentioned in the `BOT_TOKENS` variable must be added as admins in your `STORAGE_CHANNEL`.
+
+> Note: `DATABASE_BACKUP_MSG_ID` should be the message ID of a file (document) in the `STORAGE_CHANNEL`.
+
+#### Optional Variables
+
+| Variable Name          | Type                 | Default                                    | Description                                                                                                 |
+| ---------------------- | -------------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
+| `ADMIN_PASSWORD`       | string               | admin                                      | Password for accessing the admin panel                                                                      |
+| `STRING_SESSIONS`      | string               | None                                       | List of Premium Telegram Account Pyrogram String Sessions for file operations                               |
+| `SLEEP_THRESHOLD`      | integer (in seconds) | 60                                         | Delay in seconds before retrying after a Telegram API floodwait error                                       |
+| `DATABASE_BACKUP_TIME` | integer (in seconds) | 60                                         | Interval in seconds for database backups to the storage channel                                             |
+| `MAX_FILE_SIZE`        | float (in GBs)       | 1.98 (3.98 if `STRING_SESSIONS` are added) | Maximum file size (in GBs) allowed for uploading to Telegram                                                |
+| `WEBSITE_URL`          | string               | None                                       | Website URL (with https/http) to auto-ping to keep the website active                                       |
+| `MAIN_BOT_TOKEN`       | string               | None                                       | Your Main Bot Token to use [TG Drive's Bot Mode](#tg-drives-bot-mode)                                       |
+| `TELEGRAM_ADMIN_IDS`   | string               | None                                       | List of Telegram User IDs of admins who can access the [bot mode](#tg-drives-bot-mode), separated by commas |
+
+> Note: Premium Client (`STRING_SESSIONS`) will be used only to upload files when file size is greater than 2GB.
+
+> Note: File streaming/downloads will be handled by bots (`BOT_TOKENS`).
+
+> Note: Read more about TG Drive's Bot Mode [here](#tg-drives-bot-mode).
+
+## Deploying Your Own TG Drive Application
+
+### 1. Clone the Repository
+
+First, clone the repository and navigate into the project directory:
+
+```bash
+git clone https://github.com/TechShreyash/TGDrive
+cd TGDrive
+```
+
+### 2. Set Up Your Environment Variables
+
+Create a `.env` file in the root directory and add the necessary [environment variables](#environment-variables).
+
+> **Note:** Some hosting services allow you to set environment variables directly through their interface, which may eliminate the need for a `.env` file.
+
+### 3. Running TG Drive
+
+#### Deploying Locally
+
+1. Install the required Python packages:
+
+   ```bash
+   pip install -U -r requirements.txt
+   ```
+
+2. Start the TG Drive application using Uvicorn:
+
+   ```bash
+   uvicorn main:app --host 0.0.0.0 --port 8000
+   ```
+
+#### Deploying Using Docker
+
+1. Build the Docker image:
+
+   ```bash
+   docker build -t tgdrive .
+   ```
+
+2. Run the Docker container:
+
+   ```bash
+   docker run -d -p 8000:8000 tgdrive
+   ```
+
+Access the application at `http://127.0.0.1:8000` or `http://your_ip:8000`.
+
+> **Note:** For more detailed information on deploying FastAPI applications, refer to online guides and resources.
+
+## Deploy Tutorials
+
+**Deploy To Render.com For Free :** https://youtu.be/S5OIi5Ur3c0
+
+<div align="center">
+
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/TechShreyash/TGDrive)
+
+</div>
+
+> **Note:** After updating the TG Drive code, clear your browser's cache to ensure the latest JavaScript files are loaded and run correctly.
+
+## TG Drive's Bot Mode
+
+TG Drive's Bot Mode is a new feature that allows you to upload files directly to your TG Drive website from a Telegram bot. Simply send or forward any file to the bot, and it will be uploaded to your TG Drive. You can also specify the folder where you want the files to be uploaded.
+
+To use this feature, you need to set the configuration variables `MAIN_BOT_TOKEN` and `TELEGRAM_ADMIN_IDS`. More information about these variables can be found in the [optional variables section](#optional-variables).
+
+Once these variables are set, users whose IDs are listed in `TELEGRAM_ADMIN_IDS` will have access to the bot.
+
+### Bot Commands
+
+- `/set_folder` - Set the folder for file uploads
+- `/current_folder` - Check the current folder
+
+### Quick Demo
+
+Bot Mode - Youtube Video Tutorial : https://youtu.be/XSeY2XcHdGI
+
+#### Uploading Files
+
+1. Open your main bot in Telegram.
+2. Send or forward a file to this bot, and it will be uploaded. By default, the file will be uploaded to the root folder (home page).
+
+#### Changing Folder for Uploading
+
+1. Send the `/set_folder` command and follow the instructions provided by the bot.
+
+## Important Posts Regarding TG Drive
+
+Stay informed by joining our updates channel on Telegram: [@TechZBots](https://telegram.me/TechZBots). We post updates, guides, and tips about TG Drive there.
+
+- https://telegram.me/TechZBots/891
+- https://telegram.me/TechZBots/876
+- https://telegram.me/TechZBots/874
+- https://telegram.me/TechZBots/870
+
+## Contributing
+
+Contributions are welcome! Fork the repository, make your changes, and create a pull request.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Support
+
+For inquiries or support, join our [Telegram Support Group](https://telegram.me/TechZBots_Support) or email [techshreyash123@gmail.com](mailto:techshreyash123@gmail.com).

SETUP_SUMMARY.txt

@@ -0,0 +1,27 @@
+Hugging Face Space Configuration Summary
+=========================================
+
+REQUIRED for File Operations:
+------------------------------
+API_ID=123456
+API_HASH=your_api_hash
+BOT_SESSIONS=bot.session
+STORAGE_CHANNEL=-100123456789
+DATABASE_BACKUP_MSG_ID=123
+ADMIN_PASSWORD=your_password
+
+NOTE: You need to upload cache/bot.session file to your Hugging Face Space
+      (since cache/ is gitignored, upload it manually or temporarily remove from .gitignore)
+
+OPTIONAL - For Bot Mode (users can upload files via Telegram bot):
+-------------------------------------------------------------------
+MAIN_BOT_TOKEN=your_main_bot_token
+TELEGRAM_ADMIN_IDS=123456789,987654321
+
+NOTE: MAIN_BOT_TOKEN will automatically create main_bot.session file
+      You DON'T need to provide a session file for this - just the token!
+
+OPTIONAL - For Premium (files > 2GB):
+-------------------------------------
+STRING_SESSIONS=your_string_session_here
+

config.py

@@ -0,0 +1,89 @@
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from the .env file, if present
+load_dotenv()
+
+# Telegram API credentials obtained from https://my.telegram.org/auth
+API_ID = int(os.getenv("API_ID"))  # Your Telegram API ID
+API_HASH = os.getenv("API_HASH")  # Your Telegram API Hash
+
+# List of Telegram bot session file names (e.g., "bot.session,bot2.session")
+# Session files should be in cache directory. Pyrogram will use them if they exist.
+BOT_SESSIONS = os.getenv("BOT_SESSIONS", "").strip(", ").split(",")
+BOT_SESSIONS = [session.strip() for session in BOT_SESSIONS if session.strip() != ""]
+
+# List of Telegram bot tokens - used with session files (if session file doesn't exist, token creates it)
+# If BOT_SESSIONS is empty, BOT_TOKENS will be used directly
+BOT_TOKENS = os.getenv("BOT_TOKENS", "").strip(", ").split(",")
+BOT_TOKENS = [token.strip() for token in BOT_TOKENS if token.strip() != ""]
+
+# List of Telegram Account Pyrogram String Sessions used for file upload/download operations (optional)
+STRING_SESSIONS = os.getenv("STRING_SESSIONS", "").strip(", ").split(",")
+STRING_SESSIONS = [
+    session.strip() for session in STRING_SESSIONS if session.strip() != ""
+]
+
+# Chat ID of the Telegram storage channel where files will be stored
+STORAGE_CHANNEL = int(os.getenv("STORAGE_CHANNEL"))  # Your storage channel's chat ID
+
+# Message ID of a file in the storage channel used for storing database backups
+# Telegram message IDs are 32-bit signed integers (max 2,147,483,647)
+DATABASE_BACKUP_MSG_ID_STR = os.getenv("DATABASE_BACKUP_MSG_ID", "").strip()
+if DATABASE_BACKUP_MSG_ID_STR:
+    try:
+        DATABASE_BACKUP_MSG_ID = int(DATABASE_BACKUP_MSG_ID_STR)
+        # Validate message ID is within Telegram's valid range (1 to 2^31-1)
+        if DATABASE_BACKUP_MSG_ID < 1:
+            raise ValueError(f"DATABASE_BACKUP_MSG_ID ({DATABASE_BACKUP_MSG_ID}) must be >= 1")
+        if DATABASE_BACKUP_MSG_ID > 2147483647:
+            raise ValueError(f"DATABASE_BACKUP_MSG_ID ({DATABASE_BACKUP_MSG_ID}) exceeds maximum (2147483647). Telegram message IDs are 32-bit signed integers.")
+    except ValueError as e:
+        if "invalid literal" in str(e) or "could not convert" in str(e):
+            raise ValueError(f"Invalid DATABASE_BACKUP_MSG_ID: '{DATABASE_BACKUP_MSG_ID_STR}'. Must be a valid integer.")
+        raise
+else:
+    # Default to 1 if not set (will create new backup message on first upload)
+    DATABASE_BACKUP_MSG_ID = 1
+
+# Password used to access the website's admin panel
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")  # Default to "admin" if not set
+
+# Determine the maximum file size (in bytes) allowed for uploading to Telegram
+# String sessions support up to 4GB (if Premium), bot sessions/tokens limited to 2GB
+if len(STRING_SESSIONS) > 0:
+    MAX_FILE_SIZE = 3.98 * 1024 * 1024 * 1024  # 4 GB in bytes (with Premium)
+else:
+    MAX_FILE_SIZE = 1.98 * 1024 * 1024 * 1024  # 2 GB in bytes (bot sessions/tokens)
+
+# Database backup interval in seconds. Backups will be sent to the storage channel at this interval
+DATABASE_BACKUP_TIME = int(
+    os.getenv("DATABASE_BACKUP_TIME", 60)
+)  # Default to 60 seconds
+
+# Time delay in seconds before retrying after a Telegram API floodwait error
+SLEEP_THRESHOLD = int(os.getenv("SLEEP_THRESHOLD", 60))  # Default to 60 seconds
+
+# Domain to auto-ping and keep the website active
+WEBSITE_URL = os.getenv("WEBSITE_URL", None)
+
+# MongoDB configuration (used for fast message indexing/fetching and movie requests)
+MONGODB_URI = os.getenv("MONGODB_URI", None)
+MONGODB_DB_NAME = os.getenv("MONGODB_DB_NAME", "tgdrive")
+MONGODB_COLLECTION = os.getenv("MONGODB_COLLECTION", "messages")
+MONGODB_REQUESTS_COLLECTION = os.getenv("MONGODB_REQUESTS_COLLECTION", "movie_requests")
+
+# TMDB configuration (for movie name and info fetch)
+TMDB_API_KEY = os.getenv("TMDB_API_KEY", None)
+
+
+# For Using TG Drive's Bot Mode
+
+# Main Bot Token for TG Drive's Bot Mode
+MAIN_BOT_TOKEN = os.getenv("MAIN_BOT_TOKEN", "")
+if MAIN_BOT_TOKEN.strip() == "":
+    MAIN_BOT_TOKEN = None
+
+# List of Telegram User IDs who have admin access to the bot mode
+TELEGRAM_ADMIN_IDS = os.getenv("TELEGRAM_ADMIN_IDS", "").strip(", ").split(",")
+TELEGRAM_ADMIN_IDS = [int(id) for id in TELEGRAM_ADMIN_IDS if id.strip() != ""]

docker_start.sh

@@ -0,0 +1,3 @@
+docker stop tgdrive
+docker build -t tgdrive .
+docker run -d --name tgdrive -p 80:80 tgdrive

main.py

@@ -0,0 +1,528 @@
+from utils.downloader import (
+    download_file,
+    get_file_info_from_url,
+)
+import asyncio
+from pathlib import Path
+from contextlib import asynccontextmanager
+import aiofiles
+from fastapi import FastAPI, HTTPException, Request, File, UploadFile, Form, Response
+from fastapi.responses import FileResponse, JSONResponse
+from config import ADMIN_PASSWORD, MAX_FILE_SIZE, STORAGE_CHANNEL, TMDB_API_KEY
+from utils.clients import initialize_clients
+from utils.directoryHandler import getRandomID
+from utils.extra import auto_ping_website, convert_class_to_dict, reset_cache_dir
+from utils.streamer import media_streamer
+from utils.uploader import start_file_uploader
+from utils.logger import Logger
+import urllib.parse
+from datetime import datetime
+import aiohttp
+
+from utils.movie_requests import (
+    save_movie_request,
+    MovieRequestsMongoNotConfigured,
+)
+
+
+# Startup Event
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Reset the cache directory, delete cache files
+    reset_cache_dir()
+
+    # Initialize the clients
+    clients_initialized = await initialize_clients()
+    
+    # If clients failed to initialize, initialize DRIVE_DATA in offline mode
+    if not clients_initialized:
+        logger.warning("No Telegram clients available - Initializing in OFFLINE MODE")
+        from utils.directoryHandler import initDriveDataWithoutClients
+        await initDriveDataWithoutClients()
+        logger.warning("✅ Website is running in OFFLINE MODE - Telegram features are disabled")
+        logger.info("✅ Website UI is available - File operations requiring Telegram will show errors")
+
+    # Start the website auto ping task
+    asyncio.create_task(auto_ping_website())
+
+    yield
+
+
+app = FastAPI(docs_url=None, redoc_url=None, lifespan=lifespan)
+logger = Logger(__name__)
+
+
+@app.get("/")
+async def home_page():
+    return FileResponse("website/home.html")
+
+
+@app.get("/stream")
+async def home_page():
+    return FileResponse("website/VideoPlayer.html")
+
+
+@app.get("/static/{file_path:path}")
+async def static_files(file_path):
+    if "apiHandler.js" in file_path:
+        with open(Path("website/static/js/apiHandler.js")) as f:
+            content = f.read()
+            content = content.replace("MAX_FILE_SIZE__SDGJDG", str(MAX_FILE_SIZE))
+        return Response(content=content, media_type="application/javascript")
+    return FileResponse(f"website/static/{file_path}")
+
+
+@app.get("/file")
+async def dl_file(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+    from utils.clients import has_clients
+
+    if not has_clients():
+        raise HTTPException(status_code=503, detail="Telegram clients not available - Service running in offline mode")
+    
+    path = request.query_params["path"]
+    file = DRIVE_DATA.get_file(path)
+    return await media_streamer(STORAGE_CHANNEL, file.file_id, file.name, request)
+
+
+# Api Routes
+
+
+@app.post("/api/checkPassword")
+async def check_password(request: Request):
+    data = await request.json()
+    if data["pass"] == ADMIN_PASSWORD:
+        return JSONResponse({"status": "ok"})
+    return JSONResponse({"status": "Invalid password"})
+
+
+@app.post("/api/createNewFolder")
+async def api_new_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"createNewFolder {data}")
+    folder_data = DRIVE_DATA.get_directory(data["path"]).contents
+    for id in folder_data:
+        f = folder_data[id]
+        if f.type == "folder":
+            if f.name == data["name"]:
+                return JSONResponse(
+                    {
+                        "status": "Folder with the name already exist in current directory"
+                    }
+                )
+
+    DRIVE_DATA.new_folder(data["path"], data["name"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/getDirectory")
+async def api_get_directory(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] == ADMIN_PASSWORD:
+        is_admin = True
+    else:
+        is_admin = False
+
+    auth = data.get("auth")
+
+    logger.info(f"getFolder {data}")
+
+    if data["path"] == "/trash":
+        data = {"contents": DRIVE_DATA.get_trashed_files_folders()}
+        folder_data = convert_class_to_dict(data, isObject=False, showtrash=True)
+
+    elif "/search_" in data["path"]:
+        query = urllib.parse.unquote(data["path"].split("_", 1)[1])
+        print(query)
+        data = {"contents": DRIVE_DATA.search_file_folder(query)}
+        print(data)
+        folder_data = convert_class_to_dict(data, isObject=False, showtrash=False)
+        print(folder_data)
+
+    elif "/share_" in data["path"]:
+        path = data["path"].split("_", 1)[1]
+        folder_data, auth_home_path = DRIVE_DATA.get_directory(path, is_admin, auth)
+        auth_home_path= auth_home_path.replace("//", "/") if auth_home_path else None
+        folder_data = convert_class_to_dict(folder_data, isObject=True, showtrash=False)
+        return JSONResponse(
+            {"status": "ok", "data": folder_data, "auth_home_path": auth_home_path}
+        )
+
+    else:
+        folder_data = DRIVE_DATA.get_directory(data["path"])
+        folder_data = convert_class_to_dict(folder_data, isObject=True, showtrash=False)
+    return JSONResponse({"status": "ok", "data": folder_data, "auth_home_path": None})
+
+
+SAVE_PROGRESS = {}
+
+
+@app.post("/api/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    path: str = Form(...),
+    password: str = Form(...),
+    id: str = Form(...),
+    total_size: str = Form(...),
+):
+    global SAVE_PROGRESS
+    from utils.clients import has_clients
+
+    if password != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    if not has_clients():
+        return JSONResponse({"status": "Telegram clients not available - Service running in offline mode"})
+
+    total_size = int(total_size)
+    SAVE_PROGRESS[id] = ("running", 0, total_size)
+
+    ext = file.filename.lower().split(".")[-1]
+
+    cache_dir = Path("./cache")
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    file_location = cache_dir / f"{id}.{ext}"
+
+    file_size = 0
+
+    async with aiofiles.open(file_location, "wb") as buffer:
+        while chunk := await file.read(1024 * 1024):  # Read file in chunks of 1MB
+            SAVE_PROGRESS[id] = ("running", file_size, total_size)
+            file_size += len(chunk)
+            if file_size > MAX_FILE_SIZE:
+                await buffer.close()
+                file_location.unlink()  # Delete the partially written file
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"File size exceeds {MAX_FILE_SIZE} bytes limit",
+                )
+            await buffer.write(chunk)
+
+    SAVE_PROGRESS[id] = ("completed", file_size, file_size)
+
+    asyncio.create_task(
+        start_file_uploader(file_location, id, path, file.filename, file_size)
+    )
+
+    return JSONResponse({"id": id, "status": "ok"})
+
+
+@app.post("/api/getSaveProgress")
+async def get_save_progress(request: Request):
+    global SAVE_PROGRESS
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getUploadProgress {data}")
+    try:
+        progress = SAVE_PROGRESS[data["id"]]
+        return JSONResponse({"status": "ok", "data": progress})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+@app.post("/api/getUploadProgress")
+async def get_upload_progress(request: Request):
+    from utils.uploader import PROGRESS_CACHE
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getUploadProgress {data}")
+
+    try:
+        progress = PROGRESS_CACHE[data["id"]]
+        return JSONResponse({"status": "ok", "data": progress})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+@app.post("/api/cancelUpload")
+async def cancel_upload(request: Request):
+    from utils.uploader import STOP_TRANSMISSION
+    from utils.downloader import STOP_DOWNLOAD
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"cancelUpload {data}")
+    STOP_TRANSMISSION.append(data["id"])
+    STOP_DOWNLOAD.append(data["id"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/renameFileFolder")
+async def rename_file_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"renameFileFolder {data}")
+    DRIVE_DATA.rename_file_folder(data["path"], data["name"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/trashFileFolder")
+async def trash_file_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"trashFileFolder {data}")
+    DRIVE_DATA.trash_file_folder(data["path"], data["trash"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/deleteFileFolder")
+async def delete_file_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"deleteFileFolder {data}")
+    DRIVE_DATA.delete_file_folder(data["path"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/getFileInfoFromUrl")
+async def getFileInfoFromUrl(request: Request):
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getFileInfoFromUrl {data}")
+    try:
+        file_info = await get_file_info_from_url(data["url"])
+        return JSONResponse({"status": "ok", "data": file_info})
+    except Exception as e:
+        return JSONResponse({"status": str(e)})
+
+
+@app.post("/api/startFileDownloadFromUrl")
+async def startFileDownloadFromUrl(request: Request):
+    from utils.clients import has_clients
+    
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    if not has_clients():
+        return JSONResponse({"status": "Telegram clients not available - Service running in offline mode"})
+
+    logger.info(f"startFileDownloadFromUrl {data}")
+    try:
+        id = getRandomID()
+        asyncio.create_task(
+            download_file(data["url"], id, data["path"], data["filename"], data["singleThreaded"])
+        )
+        return JSONResponse({"status": "ok", "id": id})
+    except Exception as e:
+        return JSONResponse({"status": str(e)})
+
+
+@app.post("/api/getFileDownloadProgress")
+async def getFileDownloadProgress(request: Request):
+    from utils.downloader import DOWNLOAD_PROGRESS
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getFileDownloadProgress {data}")
+
+    try:
+        progress = DOWNLOAD_PROGRESS[data["id"]]
+        return JSONResponse({"status": "ok", "data": progress})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+@app.post("/api/getFolderShareAuth")
+async def getFolderShareAuth(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getFolderShareAuth {data}")
+
+    try:
+        auth = DRIVE_DATA.get_folder_auth(data["path"])
+        return JSONResponse({"status": "ok", "auth": auth})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+def _find_movie_file(title: str, year: str):
+    """
+    Find a movie file in DRIVE_DATA by matching title and year in the filename.
+    Returns a dict with path, is_video, and name or None if not found.
+    """
+    from utils.directoryHandler import DRIVE_DATA
+
+    if not DRIVE_DATA:
+        return None
+
+    query = title.strip()
+    year_str = str(year).strip()
+
+    # Use built-in search to narrow down candidates
+    search_results = DRIVE_DATA.search_file_folder(query)
+    candidates = []
+
+    for item in search_results.values():
+        if getattr(item, "type", None) != "file":
+            continue
+        name_lower = item.name.lower()
+        if query.lower() in name_lower and year_str in item.name:
+            candidates.append(item)
+
+    if not candidates:
+        return None
+
+    # Pick the first candidate (could be improved with better ranking)
+    file = candidates[0]
+    full_path = f"{file.path.rstrip('/')}/{file.id}"
+    lower_name = file.name.lower()
+    is_video = lower_name.endswith(
+        (".mp4", ".mkv", ".webm", ".mov", ".avi", ".ts", ".ogv")
+    )
+
+    return {
+        "path": full_path,
+        "is_video": is_video,
+        "name": file.name,
+    }
+
+
+@app.post("/api/tmdbSearchMovie")
+async def tmdb_search_movie(request: Request):
+    """
+    Search movie info from TMDB using title and optional year.
+    """
+    data = await request.json()
+
+    if data.get("password") != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    if not TMDB_API_KEY:
+        return JSONResponse({"status": "TMDB not configured"})
+
+    title = data.get("title", "").strip()
+    year = data.get("year")
+
+    if not title:
+        return JSONResponse({"status": "Title is required"})
+
+    params = {
+        "api_key": TMDB_API_KEY,
+        "query": title,
+        "include_adult": False,
+    }
+    if year:
+        params["year"] = year
+
+    url = "https://api.themoviedb.org/3/search/movie"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, params=params) as resp:
+                if resp.status != 200:
+                    return JSONResponse(
+                        {"status": f"TMDB error: HTTP {resp.status}"}
+                    )
+                payload = await resp.json()
+    except Exception as e:
+        return JSONResponse({"status": f"TMDB request failed: {e}"})
+
+    results = payload.get("results", [])
+    if not results:
+        return JSONResponse({"status": "no_results"})
+
+    # Return top result only to keep it simple
+    top = results[0]
+    movie_info = {
+        "id": top.get("id"),
+        "title": top.get("title"),
+        "original_title": top.get("original_title"),
+        "overview": top.get("overview"),
+        "release_date": top.get("release_date"),
+        "year": (top.get("release_date") or "")[:4],
+        "poster_path": top.get("poster_path"),
+    }
+
+    return JSONResponse({"status": "ok", "data": movie_info})
+
+
+@app.post("/api/requestMovie")
+async def request_movie(request: Request):
+    """
+    Request a movie by title and year.
+    - Saves the request in MongoDB.
+    - Checks if a matching movie file is available in DRIVE_DATA.
+    - Returns shareable link path info if found.
+    """
+    data = await request.json()
+
+    if data.get("password") != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    title = (data.get("title") or "").strip()
+    year = (data.get("year") or "").strip()
+
+    if not title or not year:
+        return JSONResponse({"status": "Title and year are required"})
+
+    # Find movie in drive data
+    file_info = _find_movie_file(title, year)
+    available = file_info is not None
+
+    # Save request in MongoDB (if configured)
+    try:
+        await save_movie_request(title, year, available, file_info=file_info)
+    except MovieRequestsMongoNotConfigured:
+        # Mongo not configured for movie requests - just skip saving
+        logger.warning("MongoDB not configured for movie requests - skipping save")
+    except Exception as e:
+        logger.error(f"Error saving movie request: {e}")
+
+    if not available:
+        return JSONResponse({"status": "not_found"})
+
+    return JSONResponse(
+        {
+            "status": "available",
+            "file": file_info,
+        }
+    )

render.yaml

@@ -0,0 +1,24 @@
+services:
+  # A Docker web service
+  - type: web
+    name: tgdrive
+    repo: https://github.com/TechShreyash/TGDrive
+    runtime: python
+    branch: main
+    plan: free
+    autoDeploy: false
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn main:app --host 0.0.0.0 --port $PORT
+    envVars:
+      - key: ADMIN_PASSWORD
+        sync: false
+      - key: API_ID
+        sync: false
+      - key: API_HASH
+        sync: false
+      - key: BOT_TOKENS
+        sync: false
+      - key: STORAGE_CHANNEL
+        sync: false
+      - key: DATABASE_BACKUP_MSG_ID
+        sync: false

requirements.txt

@@ -0,0 +1,13 @@
+https://github.com/KurimuzonAkuma/pyrogram/archive/dev.zip
+tgcrypto
+uvicorn
+fastapi[all]
+python-dotenv
+aiofiles
+aiohttp
+curl_cffi
+techzdl>=1.2.6
+tqdm
+dill
+pyromod
+motor

runtime.txt

@@ -0,0 +1 @@
+python-3.11

sample.env

@@ -0,0 +1,20 @@
+# Required Vars
+
+API_ID=123456
+API_HASH=dagsjdhgjfsahgjfh
+BOT_TOKENS=21413535:gkdshajfhjfakhjf
+STORAGE_CHANNEL=-100123456789
+DATABASE_BACKUP_MSG_ID=123
+
+# Optional: Bot session file names (must match BOT_TOKENS count)
+# Place session files in cache/ directory. Pyrogram will use them if they exist.
+# BOT_SESSIONS=bot.session,bot2.session
+
+# Optional: String sessions for Premium accounts (files > 2GB)
+# STRING_SESSIONS=1BVtsOMwBu5...your_session_string_here...
+
+# Note: 
+# - BOT_TOKENS is required (Pyrogram needs token for bot clients)
+# - BOT_SESSIONS is optional - if provided, Pyrogram will use those session file names
+# - If session file exists, it will be used (faster connection)
+# - If session file doesn't exist, Pyrogram will create it

start_main.py

@@ -0,0 +1,3 @@
+import os
+
+os.system("uvicorn main:app --reload")

utils/bot_mode.py

@@ -0,0 +1,266 @@
+import asyncio
+from pyrogram import Client, filters
+import pyromod
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+import config
+from utils.logger import Logger
+from pathlib import Path
+
+from utils.mongo_indexer import index_channel_messages, MongoNotConfiguredError
+
+logger = Logger(__name__)
+
+START_CMD = """🚀 **Welcome To TG Drive's Bot Mode**
+
+You can use this bot to upload files to your TG Drive website directly instead of doing it from website.
+
+🗄 **Commands:**
+/set_folder - Set folder for file uploads
+/current_folder - Check current folder
+
+📤 **How To Upload Files:** Send a file to this bot and it will be uploaded to your TG Drive website. You can also set a folder for file uploads using /set_folder command.
+
+Read more about [TG Drive's Bot Mode](https://github.com/TechShreyash/TGDrive#tg-drives-bot-mode)
+"""
+
+SET_FOLDER_PATH_CACHE = {}  # Cache to store folder path for each folder id
+DRIVE_DATA = None
+BOT_MODE = None
+
+session_cache_path = Path(f"./cache")
+session_cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+main_bot = Client(
+    name="main_bot",
+    api_id=config.API_ID,
+    api_hash=config.API_HASH,
+    bot_token=config.MAIN_BOT_TOKEN,
+    sleep_threshold=config.SLEEP_THRESHOLD,
+    workdir=session_cache_path,
+)
+
+
+@main_bot.on_message(
+    filters.command(["start", "help"])
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def start_handler(client: Client, message: Message):
+    await message.reply_text(START_CMD)
+
+
+@main_bot.on_message(
+    filters.command("index")
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def index_handler(client: Client, message: Message):
+    """
+    /index <channel_id or @username>
+
+    Index all messages of the given channel/chat into MongoDB for fast fetching.
+    """
+    if len(message.command) < 2:
+        await message.reply_text("Usage: /index <channel_id or @username>")
+        return
+
+    raw_target = message.command[1].strip()
+
+    # Try to parse as integer chat ID, otherwise use raw (could be @username or link)
+    try:
+        target = int(raw_target)
+    except ValueError:
+        target = raw_target
+
+    try:
+        await message.reply_text(
+            f"Started indexing messages for `{raw_target}`.\n\n"
+            "This may take a while for large channels. You'll get a message when it's done.",
+            quote=True,
+        )
+
+        async def status_cb(text: str):
+            try:
+                await message.reply_text(text)
+            except Exception:
+                # Ignore failures (e.g., rate limits or message delete)
+                pass
+
+        # Run indexing in a background task so the bot stays responsive
+        async def _run():
+            try:
+                total = await index_channel_messages(client, target, status_callback=status_cb)
+                await message.reply_text(
+                    f"✅ Indexing completed for `{raw_target}`.\nTotal messages indexed: **{total}**"
+                )
+            except MongoNotConfiguredError as e:
+                await message.reply_text(
+                    "MongoDB is not configured.\n\n"
+                    "Please set `MONGODB_URI` (and optionally `MONGODB_DB_NAME`, "
+                    "`MONGODB_COLLECTION`) in your environment.",
+                )
+            except Exception as e:
+                await message.reply_text(f"❌ Failed to index channel `{raw_target}`.\nError: `{e}`")
+
+        asyncio.create_task(_run())
+
+    except MongoNotConfiguredError:
+        await message.reply_text(
+            "MongoDB is not configured.\n\n"
+            "Please set `MONGODB_URI` (and optionally `MONGODB_DB_NAME`, "
+            "`MONGODB_COLLECTION`) in your environment.",
+        )
+    except Exception as e:
+        await message.reply_text(f"❌ Failed to start indexing.\nError: `{e}`")
+
+
+@main_bot.on_message(
+    filters.command("set_folder")
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def set_folder_handler(client: Client, message: Message):
+    global SET_FOLDER_PATH_CACHE, DRIVE_DATA
+
+    while True:
+        try:
+            folder_name = await client.ask(
+                message.chat.id,
+                "Send the folder name where you want to upload files\n\n/cancel to cancel",
+                timeout=60,
+                filters=filters.text,
+            )
+        except asyncio.TimeoutError:
+            await message.reply_text("Timeout\n\nUse /set_folder to set folder again")
+            return
+
+        if folder_name.text.lower() == "/cancel":
+            await message.reply_text("Cancelled")
+            return
+
+        folder_name = folder_name.text.strip()
+        search_result = DRIVE_DATA.search_file_folder(folder_name)
+
+        # Get folders from search result
+        folders = {}
+        for item in search_result.values():
+            if item.type == "folder":
+                folders[item.id] = item
+
+        if len(folders) == 0:
+            await message.reply_text(f"No Folder found with name {folder_name}")
+        else:
+            break
+
+    buttons = []
+    folder_cache = {}
+    folder_cache_id = len(SET_FOLDER_PATH_CACHE) + 1
+
+    for folder in search_result.values():
+        path = folder.path.strip("/")
+        folder_path = "/" + ("/" + path + "/" + folder.id).strip("/")
+        folder_cache[folder.id] = (folder_path, folder.name)
+        buttons.append(
+            [
+                InlineKeyboardButton(
+                    folder.name,
+                    callback_data=f"set_folder_{folder_cache_id}_{folder.id}",
+                )
+            ]
+        )
+    SET_FOLDER_PATH_CACHE[folder_cache_id] = folder_cache
+
+    await message.reply_text(
+        "Select the folder where you want to upload files",
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+
+@main_bot.on_callback_query(
+    filters.user(config.TELEGRAM_ADMIN_IDS) & filters.regex(r"set_folder_")
+)
+async def set_folder_callback(client: Client, callback_query: Message):
+    global SET_FOLDER_PATH_CACHE, BOT_MODE
+
+    folder_cache_id, folder_id = callback_query.data.split("_")[2:]
+
+    folder_path_cache = SET_FOLDER_PATH_CACHE.get(int(folder_cache_id))
+    if folder_path_cache is None:
+        await callback_query.answer("Request Expired, Send /set_folder again")
+        await callback_query.message.delete()
+        return
+
+    folder_path, name = folder_path_cache.get(folder_id)
+    del SET_FOLDER_PATH_CACHE[int(folder_cache_id)]
+    BOT_MODE.set_folder(folder_path, name)
+
+    await callback_query.answer(f"Folder Set Successfully To : {name}")
+    await callback_query.message.edit(
+        f"Folder Set Successfully To : {name}\n\nNow you can send / forward files to me and it will be uploaded to this folder."
+    )
+
+
+@main_bot.on_message(
+    filters.command("current_folder")
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def current_folder_handler(client: Client, message: Message):
+    global BOT_MODE
+
+    await message.reply_text(f"Current Folder: {BOT_MODE.current_folder_name}")
+
+
+# Handling when any file is sent to the bot
+@main_bot.on_message(
+    filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS)
+    & (
+        filters.document
+        | filters.video
+        | filters.audio
+        | filters.photo
+        | filters.sticker
+    )
+)
+async def file_handler(client: Client, message: Message):
+    global BOT_MODE, DRIVE_DATA
+
+    copied_message = await message.copy(config.STORAGE_CHANNEL)
+    file = (
+        copied_message.document
+        or copied_message.video
+        or copied_message.audio
+        or copied_message.photo
+        or copied_message.sticker
+    )
+
+    DRIVE_DATA.new_file(
+        BOT_MODE.current_folder,
+        file.file_name,
+        copied_message.id,
+        file.file_size,
+    )
+
+    await message.reply_text(
+        f"""✅ File Uploaded Successfully To Your TG Drive Website
+                             
+**File Name:** {file.file_name}
+**Folder:** {BOT_MODE.current_folder_name}
+"""
+    )
+
+
+async def start_bot_mode(d, b):
+    global DRIVE_DATA, BOT_MODE
+    DRIVE_DATA = d
+    BOT_MODE = b
+
+    logger.info("Starting Main Bot")
+    await main_bot.start()
+
+    await main_bot.send_message(
+        config.STORAGE_CHANNEL, "Main Bot Started -> TG Drive's Bot Mode Enabled"
+    )
+    logger.info("Main Bot Started")
+    logger.info("TG Drive's Bot Mode Enabled")

utils/clients.py

@@ -0,0 +1,208 @@
+import asyncio, config
+import traceback
+from pathlib import Path
+from pyrogram import Client
+from pyrogram.errors import AuthKeyDuplicated
+from utils.directoryHandler import backup_drive_data, loadDriveData
+from utils.logger import Logger
+
+logger = Logger(__name__)
+
+multi_clients = {}
+premium_clients = {}
+work_loads = {}
+premium_work_loads = {}
+main_bot = None
+
+
+async def initialize_clients():
+    global multi_clients, work_loads, premium_clients, premium_work_loads
+    logger.info("Initializing Clients")
+
+    session_cache_path = Path(f"./cache")
+    session_cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Log configuration for debugging
+    logger.info(f"BOT_SESSIONS configured: {len(config.BOT_SESSIONS)} session(s)")
+    logger.info(f"BOT_TOKENS configured: {len(config.BOT_TOKENS)} token(s)")
+    if config.BOT_SESSIONS:
+        logger.info(f"BOT_SESSIONS: {config.BOT_SESSIONS}")
+    if config.BOT_TOKENS:
+        logger.info(f"BOT_TOKENS: {len(config.BOT_TOKENS[0]) if config.BOT_TOKENS else 0} chars (hidden)")
+
+    # Use BOT_SESSIONS as Client names (if provided), otherwise use client_id
+    # Match BOT_SESSIONS with BOT_TOKENS
+    all_bot_sessions = dict((i, s) for i, s in enumerate(config.BOT_SESSIONS, start=1))
+    all_tokens = dict((i, t) for i, t in enumerate(config.BOT_TOKENS, start=1))
+    
+    # Check if BOT_TOKENS is empty
+    if not all_tokens:
+        logger.error("BOT_TOKENS is empty! You must provide BOT_TOKENS in environment variables.")
+        logger.error("BOT_SESSIONS alone cannot work - Pyrogram requires bot_token for bot clients.")
+        return False
+    
+    # Match sessions with tokens
+    if all_bot_sessions:
+        if len(all_bot_sessions) != len(all_tokens):
+            logger.warning(f"BOT_SESSIONS count ({len(all_bot_sessions)}) doesn't match BOT_TOKENS count ({len(all_tokens)})")
+            min_len = min(len(all_bot_sessions), len(all_tokens))
+            all_bot_sessions = dict(list(all_bot_sessions.items())[:min_len])
+            all_tokens = dict(list(all_tokens.items())[:min_len])
+        # Zip sessions and tokens
+        bot_configs = dict((i, (session, token)) for i, (session, token) in 
+                          enumerate(zip(all_bot_sessions.values(), all_tokens.values()), start=1))
+    else:
+        # No BOT_SESSIONS, use client_id as name
+        bot_configs = dict((i, (None, token)) for i, token in all_tokens.items())
+    
+    all_string_sessions = dict(
+        (i, s) for i, s in enumerate(config.STRING_SESSIONS, start=len(bot_configs) + 1)
+    )
+
+    async def start_client(client_id, session_name_and_token, type):
+        try:
+            logger.info(f"Starting - {type.title()} Client {client_id}")
+
+            if type == "bot":
+                # Get session name and token
+                session_name, token = session_name_and_token
+                
+                # Use session name as Client name (remove .session extension if present)
+                # If no session name, use client_id
+                if session_name:
+                    client_name = session_name.replace(".session", "")
+                else:
+                    client_name = str(client_id)
+                
+                # Pyrogram will use existing session file if it exists in cache/, or create new one
+                client = Client(
+                    name=client_name,
+                    api_id=config.API_ID,
+                    api_hash=config.API_HASH,
+                    bot_token=token,
+                    workdir=session_cache_path,
+                )
+                client.loop = asyncio.get_running_loop()
+                try:
+                    await client.start()
+                    await client.send_message(
+                        config.STORAGE_CHANNEL,
+                        f"Started - Bot Client {client_id}",
+                    )
+                    multi_clients[client_id] = client
+                    work_loads[client_id] = 0
+                except AuthKeyDuplicated as e:
+                    # Delete the invalidated session file and mark it as invalidated
+                    session_file = None
+                    try:
+                        session_file = session_cache_path / f"{client_name}.session"
+                        if session_file.exists():
+                            session_file.unlink()
+                            logger.info(f"Deleted invalidated session file: {session_file}")
+                            # Create a marker file so we don't restore this session on next restart
+                            invalidated_marker = session_cache_path / f"{client_name}.session.invalidated"
+                            invalidated_marker.touch()
+                            logger.info(f"Marked session file as invalidated: {invalidated_marker}")
+                    except Exception as cleanup_error:
+                        logger.error(f"Failed to delete session file: {cleanup_error}")
+                    
+                    error_msg = (
+                        f"\n{'='*60}\n"
+                        f"AUTH_KEY_DUPLICATED for Bot Client {client_id}\n"
+                        f"{'='*60}\n"
+                        f"CRITICAL: The same bot token is being used in MULTIPLE places simultaneously.\n"
+                        f"Telegram has invalidated the session file for security reasons.\n\n"
+                        f"✅ Session file has been deleted: {session_file if session_file else 'N/A'}\n\n"
+                        f"⚠️  TO FIX THIS:\n"
+                        f"   1. STOP using this bot token in ALL other locations (local servers, other Spaces, etc.)\n"
+                        f"   2. Wait a few seconds for the other instance to disconnect\n"
+                        f"   3. Restart this application (the session file will be recreated automatically)\n\n"
+                        f"📌 REMEMBER: Each bot token can only be used in ONE place at a time!\n"
+                        f"{'='*60}"
+                    )
+                    logger.error(error_msg)
+                    logger.error(f"Error details: {e}")
+                    
+                    # Don't re-raise - let the client fail gracefully and app continue in offline mode
+                    return
+            elif type == "string_session":
+                # Use string session (user account)
+                session_string = session_name_and_token  # For string sessions, it's just the string
+                client = await Client(
+                    name=str(client_id),
+                    api_id=config.API_ID,
+                    api_hash=config.API_HASH,
+                    session_string=session_string,
+                    sleep_threshold=config.SLEEP_THRESHOLD,
+                    workdir=session_cache_path,
+                    no_updates=True,
+                ).start()
+                await client.send_message(
+                    config.STORAGE_CHANNEL,
+                    f"Started - String Session Client {client_id}",
+                )
+                premium_clients[client_id] = client
+                premium_work_loads[client_id] = 0
+
+            logger.info(f"Started - {type.title()} Client {client_id}")
+        except Exception as e:
+            error_msg = str(e) if str(e) else repr(e)
+            error_trace = traceback.format_exc()
+            logger.error(
+                f"Failed To Start {type.title()} Client - {client_id} Error: {error_msg}"
+            )
+            logger.error(f"Traceback: {error_trace}")
+
+    # Start bot clients and string session clients
+    await asyncio.gather(
+        *(
+            [
+                start_client(client_id, (session_name, token), "bot")
+                for client_id, (session_name, token) in bot_configs.items()
+            ]
+            + [
+                start_client(client_id, session, "string_session")
+                for client_id, session in all_string_sessions.items()
+            ]
+        )
+    )
+    
+    clients_initialized = len(multi_clients) > 0
+    
+    if not clients_initialized:
+        logger.warning("No Clients Were Initialized - Website will run in offline mode")
+        logger.warning("Please configure BOT_TOKENS (and optionally BOT_SESSIONS) in your environment variables")
+        return False
+
+    logger.info("Clients Initialized")
+
+    # Load the drive data
+    await loadDriveData()
+
+    # Start the backup drive data task
+    asyncio.create_task(backup_drive_data())
+    
+    return True
+
+
+def has_clients():
+    """Check if any clients are available"""
+    global multi_clients
+    return len(multi_clients) > 0
+
+
+def get_client(premium_required=False) -> Client:
+    global multi_clients, work_loads, premium_clients, premium_work_loads
+
+    if premium_required:
+        if not premium_work_loads:
+            raise RuntimeError("No Premium Clients Available")
+        index = min(premium_work_loads, key=premium_work_loads.get)
+        premium_work_loads[index] += 1
+        return premium_clients[index]
+
+    if not work_loads:
+        raise RuntimeError("No Clients Available - Check BOT_TOKENS/BOT_SESSIONS configuration")
+    index = min(work_loads, key=work_loads.get)
+    work_loads[index] += 1
+    return multi_clients[index]

utils/directoryHandler.py

@@ -0,0 +1,409 @@
+from pathlib import Path
+import sys
+import config, dill
+from pyrogram.types import InputMediaDocument, Message
+import os, random, string, asyncio
+from utils.logger import Logger
+from datetime import datetime, timezone
+import os
+import signal
+
+logger = Logger(__name__)
+
+cache_dir = Path("./cache")
+cache_dir.mkdir(parents=True, exist_ok=True)
+drive_cache_path = cache_dir / "drive.data"
+
+
+def getRandomID():
+    global DRIVE_DATA
+    while True:
+        id = "".join(random.choices(string.ascii_uppercase + string.digits, k=6))
+        if not DRIVE_DATA:
+            return id
+        if id not in DRIVE_DATA.used_ids:
+            DRIVE_DATA.used_ids.append(id)
+            return id
+
+
+def get_current_utc_time():
+    return datetime.now(timezone.utc).strftime("Date - %Y-%m-%d | Time - %H:%M:%S")
+
+
+class Folder:
+    def __init__(self, name: str, path: str) -> None:
+        self.name = name
+        self.contents = {}
+        if name == "/":
+            self.id = "root"
+        else:
+            self.id = getRandomID()
+        self.type = "folder"
+        self.trash = False
+        self.path = ("/" + path.strip("/") + "/").replace("//", "/")
+        self.upload_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.auth_hashes = []
+
+
+class File:
+    def __init__(
+        self,
+        name: str,
+        file_id: int,
+        size: int,
+        path: str,
+    ) -> None:
+        self.name = name
+        self.file_id = file_id
+        self.id = getRandomID()
+        self.size = size
+        self.type = "file"
+        self.trash = False
+        self.path = path[:-1] if path[-1] == "/" else path
+        self.upload_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+class NewDriveData:
+    def __init__(self, contents: dict, used_ids: list) -> None:
+        self.contents = contents
+        self.used_ids = used_ids
+        self.isUpdated = False
+
+    def save(self) -> None:
+        with open(drive_cache_path, "wb") as f:
+            dill.dump(self, f)
+        self.isUpdated = True
+        logger.info("Drive data saved successfully.")
+
+    def new_folder(self, path: str, name: str) -> None:
+        logger.info(f"Creating new folder '{name}' in path '{path}'.")
+
+        folder = Folder(name, path)
+        if path == "/":
+            directory_folder: Folder = self.contents[path]
+            directory_folder.contents[folder.id] = folder
+        else:
+            paths = path.strip("/").split("/")
+            directory_folder: Folder = self.contents["/"]
+            for path in paths:
+                directory_folder = directory_folder.contents[path]
+            directory_folder.contents[folder.id] = folder
+
+        self.save()
+        return folder.path + folder.id
+
+    def new_file(self, path: str, name: str, file_id: int, size: int) -> None:
+        logger.info(f"Creating new file '{name}' in path '{path}'.")
+
+        file = File(name, file_id, size, path)
+        if path == "/":
+            directory_folder: Folder = self.contents[path]
+            directory_folder.contents[file.id] = file
+        else:
+            paths = path.strip("/").split("/")
+            directory_folder: Folder = self.contents["/"]
+            for path in paths:
+                directory_folder = directory_folder.contents[path]
+            directory_folder.contents[file.id] = file
+
+        self.save()
+
+    def get_directory(
+        self, path: str, is_admin: bool = True, auth: str = None
+    ) -> Folder:
+        folder_data: Folder = self.contents["/"]
+        auth_success = False
+        auth_home_path = None
+
+        if path != "/":
+            path = path.strip("/")
+
+            if "/" in path:
+                path = path.split("/")
+            else:
+                path = [path]
+
+            for folder in path:
+                folder_data = folder_data.contents[folder]
+
+                if auth in folder_data.auth_hashes:
+                    auth_success = True
+                    auth_home_path = (
+                        "/" + folder_data.path.strip("/") + "/" + folder_data.id
+                    )
+
+        if not is_admin and not auth_success:
+            logger.warning(f"Unauthorized access attempt to path '{path}'.")
+            return None
+
+        if auth_success:
+            logger.info(f"Authorization successful for path '{path}'.")
+            return folder_data, auth_home_path
+
+        return folder_data
+
+    def get_folder_auth(self, path: str) -> None:
+        auth = getRandomID()
+        folder_data: Folder = self.contents["/"]
+
+        if path != "/":
+            path = path.strip("/")
+
+            if "/" in path:
+                path = path.split("/")
+            else:
+                path = [path]
+
+            for folder in path:
+                folder_data = folder_data.contents[folder]
+
+        folder_data.auth_hashes.append(auth)
+        self.save()
+        logger.info(f"Authorization hash generated for path '{path}'.")
+        return auth
+
+    def get_file(self, path) -> File:
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+
+        folder_data = self.get_directory(folder_path)
+        return folder_data.contents[file_id]
+
+    def rename_file_folder(self, path: str, new_name: str) -> None:
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+        folder_data = self.get_directory(folder_path)
+        folder_data.contents[file_id].name = new_name
+        self.save()
+        logger.info(f"Item at path '{path}' renamed to '{new_name}'.")
+
+    def trash_file_folder(self, path: str, trash: bool) -> None:
+        action = "Trashing" if trash else "Restoring"
+
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+        folder_data = self.get_directory(folder_path)
+        folder_data.contents[file_id].trash = trash
+        self.save()
+        logger.info(f"Item at path '{path}' {action.lower()} successfully.")
+
+    def get_trashed_files_folders(self):
+        root_dir = self.get_directory("/")
+        trash_data = {}
+
+        def traverse_directory(folder):
+            for item in folder.contents.values():
+                if item.type == "folder":
+                    if item.trash:
+                        trash_data[item.id] = item
+                    else:
+                        # Recursively traverse the subfolder
+                        traverse_directory(item)
+                elif item.type == "file":
+                    if item.trash:
+                        trash_data[item.id] = item
+
+        traverse_directory(root_dir)
+        return trash_data
+
+    def delete_file_folder(self, path: str) -> None:
+
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+
+        folder_data = self.get_directory(folder_path)
+        del folder_data.contents[file_id]
+        self.save()
+        logger.info(f"Item at path '{path}' deleted successfully.")
+
+    def search_file_folder(self, query: str):
+        logger.info(f"Searching for items matching query '{query}'.")
+
+        root_dir = self.get_directory("/")
+        search_results = {}
+
+        def traverse_directory(folder):
+            for item in folder.contents.values():
+                if query.lower() in item.name.lower():
+                    search_results[item.id] = item
+                if item.type == "folder":
+                    traverse_directory(item)
+
+        traverse_directory(root_dir)
+        logger.info(f"Search completed. Found {len(search_results)} matching items.")
+        return search_results
+
+
+class NewBotMode:
+    def __init__(self, drive_data: NewDriveData) -> None:
+        self.drive_data = drive_data
+
+        # Set the current folder to root directory by default
+        self.current_folder = "/"
+        self.current_folder_name = "/ (root directory)"
+
+    def set_folder(self, folder_path: str, name: str) -> None:
+        self.current_folder = folder_path
+        self.current_folder_name = name
+        self.drive_data.save()
+        logger.info(f"Current folder set to '{name}' at path '{folder_path}'.")
+
+
+DRIVE_DATA: NewDriveData = None
+BOT_MODE: NewBotMode = None
+
+
+# Function to backup the drive data to telegram
+async def backup_drive_data(loop=True):
+    global DRIVE_DATA
+    logger.info("Starting backup drive data task.")
+
+    while True:
+        try:
+            if not DRIVE_DATA.isUpdated:
+                if not loop:
+                    break
+                await asyncio.sleep(config.DATABASE_BACKUP_TIME)
+                continue
+
+            logger.info("Backing up drive data to Telegram.")
+            from utils.clients import get_client
+
+            client = get_client()
+            time_text = f"📅 **Last Updated :** {get_current_utc_time()} (UTC +00:00)"
+            caption = (
+                f"🔐 **TG Drive Data Backup File**\n\n"
+                "Do not edit or delete this message. This is a backup file for the tg drive data.\n\n"
+                f"{time_text}"
+            )
+
+            media_doc = InputMediaDocument(drive_cache_path, caption=caption)
+            msg = await client.edit_message_media(
+                config.STORAGE_CHANNEL,
+                config.DATABASE_BACKUP_MSG_ID,
+                media=media_doc,
+                file_name="drive.data",
+            )
+
+            DRIVE_DATA.isUpdated = False
+            logger.info("Drive data backed up to Telegram successfully.")
+
+            try:
+                await msg.pin()
+            except Exception as pin_e:
+                logger.error(f"Error pinning backup message: {pin_e}")
+
+            if not loop:
+                break
+
+            await asyncio.sleep(config.DATABASE_BACKUP_TIME)
+        except Exception as e:
+            logger.error(f"Backup Error: {e}")
+            await asyncio.sleep(10)
+
+
+async def init_drive_data():
+    global DRIVE_DATA
+
+    logger.info("Initializing drive data.")
+    root_dir = DRIVE_DATA.get_directory("/")
+    if not hasattr(root_dir, "auth_hashes"):
+        root_dir.auth_hashes = []
+
+    def traverse_directory(folder):
+        for item in folder.contents.values():
+            if item.type == "folder":
+                traverse_directory(item)
+
+                if not hasattr(item, "auth_hashes"):
+                    item.auth_hashes = []
+
+    traverse_directory(root_dir)
+    DRIVE_DATA.save()
+    logger.info("Drive data initialization completed.")
+
+
+async def loadDriveData():
+    global DRIVE_DATA, BOT_MODE
+
+    logger.info("Loading drive data.")
+    from utils.clients import get_client
+
+    try:
+        client = get_client()
+        try:
+            msg: Message = await client.get_messages(
+                config.STORAGE_CHANNEL, config.DATABASE_BACKUP_MSG_ID
+            )
+        except Exception as e:
+            logger.error(f"Error fetching backup message: {e}")
+            raise
+
+        if not msg.document:
+            logger.error("Backup message does not contain a document")
+            raise Exception("Backup message does not contain a document")
+
+        if msg.document.file_name == "drive.data":
+            dl_path = await msg.download()
+            with open(dl_path, "rb") as f:
+                DRIVE_DATA = dill.load(f)
+
+            logger.info("Drive data loaded from Telegram backup.")
+        else:
+            raise Exception("Backup drive.data file not found on Telegram.")
+    except Exception as e:
+        logger.warning(f"Backup load failed: {e}")
+        logger.info("Creating new drive.data file.")
+        DRIVE_DATA = NewDriveData({"/": Folder("/", "/")}, [])
+        DRIVE_DATA.save()
+
+    await init_drive_data()
+
+    if config.MAIN_BOT_TOKEN:
+        from utils.bot_mode import start_bot_mode
+
+        BOT_MODE = NewBotMode(DRIVE_DATA)
+        await start_bot_mode(DRIVE_DATA, BOT_MODE)
+        logger.info("Bot mode started.")
+
+
+async def initDriveDataWithoutClients():
+    """Initialize DRIVE_DATA without requiring Telegram clients (offline mode)"""
+    global DRIVE_DATA, BOT_MODE
+    
+    logger.info("Initializing drive data in offline mode (without Telegram clients).")
+    
+    # Try to load from local cache if it exists
+    if drive_cache_path.exists():
+        try:
+            with open(drive_cache_path, "rb") as f:
+                DRIVE_DATA = dill.load(f)
+            logger.info("Drive data loaded from local cache.")
+        except Exception as e:
+            logger.warning(f"Failed to load from local cache: {e}")
+            logger.info("Creating new drive.data file.")
+            DRIVE_DATA = NewDriveData({"/": Folder("/", "/")}, [])
+            DRIVE_DATA.save()
+    else:
+        logger.info("No local cache found. Creating new drive.data file.")
+        DRIVE_DATA = NewDriveData({"/": Folder("/", "/")}, [])
+        DRIVE_DATA.save()
+    
+    await init_drive_data()
+    logger.info("Drive data initialized in offline mode.")

utils/downloader.py

@@ -0,0 +1,85 @@
+import os
+import aiohttp, asyncio
+from utils.extra import get_filename
+from utils.logger import Logger
+from pathlib import Path
+from utils.uploader import start_file_uploader
+from techzdl import TechZDL
+
+logger = Logger(__name__)
+
+DOWNLOAD_PROGRESS = {}
+STOP_DOWNLOAD = []
+
+cache_dir = Path("./cache")
+cache_dir.mkdir(parents=True, exist_ok=True)
+
+
+async def download_progress_callback(status, current, total, id):
+    global DOWNLOAD_PROGRESS
+
+    DOWNLOAD_PROGRESS[id] = (
+        status,
+        current,
+        total,
+    )
+
+
+async def download_file(url, id, path, filename, singleThreaded):
+    global DOWNLOAD_PROGRESS, STOP_DOWNLOAD
+
+    logger.info(f"Downloading file from {url}")
+
+    try:
+        downloader = TechZDL(
+            url,
+            output_dir=cache_dir,
+            debug=False,
+            progress_callback=download_progress_callback,
+            progress_args=(id,),
+            max_retries=5,
+            single_threaded=singleThreaded,
+        )
+        await downloader.start(in_background=True)
+
+        await asyncio.sleep(5)
+
+        while downloader.is_running:
+            if id in STOP_DOWNLOAD:
+                logger.info(f"Stopping download {id}")
+                await downloader.stop()
+                return
+            await asyncio.sleep(1)
+
+        if downloader.download_success is False:
+            raise downloader.download_error
+
+        DOWNLOAD_PROGRESS[id] = (
+            "completed",
+            downloader.total_size,
+            downloader.total_size,
+        )
+
+        logger.info(f"File downloaded to {downloader.output_path}")
+
+        asyncio.create_task(
+            start_file_uploader(
+                downloader.output_path, id, path, filename, downloader.total_size
+            )
+        )
+    except Exception as e:
+        DOWNLOAD_PROGRESS[id] = ("error", 0, 0)
+        logger.error(f"Failed to download file: {url} {e}")
+
+
+async def get_file_info_from_url(url):
+    downloader = TechZDL(
+        url,
+        output_dir=cache_dir,
+        debug=False,
+        progress_callback=download_progress_callback,
+        progress_args=(id,),
+        max_retries=5,
+    )
+    file_info = await downloader.get_file_info()
+    return {"file_size": file_info["total_size"], "file_name": file_info["filename"]}

utils/extra.py

@@ -0,0 +1,146 @@
+import mimetypes
+from urllib.parse import unquote_plus
+import re
+import urllib.parse
+from pathlib import Path
+from config import WEBSITE_URL
+import asyncio, aiohttp
+from utils.directoryHandler import get_current_utc_time, getRandomID
+from utils.logger import Logger
+
+logger = Logger(__name__)
+
+
+def convert_class_to_dict(data, isObject, showtrash=False):
+    if isObject == True:
+        data = data.__dict__.copy()
+    new_data = {"contents": {}}
+
+    for key in data["contents"]:
+        if data["contents"][key].trash == showtrash:
+            if data["contents"][key].type == "folder":
+                folder = data["contents"][key]
+                new_data["contents"][key] = {
+                    "name": folder.name,
+                    "type": folder.type,
+                    "id": folder.id,
+                    "path": folder.path,
+                    "upload_date": folder.upload_date,
+                }
+            else:
+                file = data["contents"][key]
+                new_data["contents"][key] = {
+                    "name": file.name,
+                    "type": file.type,
+                    "size": file.size,
+                    "id": file.id,
+                    "path": file.path,
+                    "upload_date": file.upload_date,
+                }
+    return new_data
+
+
+async def auto_ping_website():
+    if WEBSITE_URL is not None:
+        async with aiohttp.ClientSession() as session:
+            while True:
+                try:
+                    async with session.get(WEBSITE_URL) as response:
+                        if response.status == 200:
+                            logger.info(f"Pinged website at {get_current_utc_time()}")
+                        else:
+                            logger.warning(f"Failed to ping website: {response.status}")
+                except Exception as e:
+                    logger.warning(f"Failed to ping website: {e}")
+
+                await asyncio.sleep(60)  # Ping website every minute
+
+
+import shutil
+
+
+def reset_cache_dir():
+    cache_dir = Path("./cache")
+    downloads_dir = Path("./downloads")
+    
+    # Save session files before deleting cache (but skip invalidated ones)
+    session_files = {}
+    if cache_dir.exists():
+        for session_file in cache_dir.glob("*.session"):
+            # Check if this session file was marked as invalidated
+            invalidated_marker = cache_dir / f"{session_file.name}.invalidated"
+            if invalidated_marker.exists():
+                logger.warning(f"Skipping invalidated session file: {session_file.name} (was marked as AUTH_KEY_DUPLICATED)")
+                # Delete the marker file so it can be retried on next restart
+                invalidated_marker.unlink(missing_ok=True)
+                continue
+            session_files[session_file.name] = session_file.read_bytes()
+            logger.info(f"Preserving session file: {session_file.name}")
+    
+    # Delete cache and downloads directories
+    shutil.rmtree(cache_dir, ignore_errors=True)
+    shutil.rmtree(downloads_dir, ignore_errors=True)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    downloads_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Restore session files
+    for session_name, session_data in session_files.items():
+        (cache_dir / session_name).write_bytes(session_data)
+        logger.info(f"Restored session file: {session_name}")
+    
+    logger.info("Cache and downloads directory reset (session files preserved)")
+
+
+def parse_content_disposition(content_disposition):
+    # Split the content disposition into parts
+    parts = content_disposition.split(";")
+
+    # Initialize filename variable
+    filename = None
+
+    # Loop through parts to find the filename
+    for part in parts:
+        part = part.strip()
+        if part.startswith("filename="):
+            # If filename is found
+            filename = part.split("=", 1)[1]
+        elif part.startswith("filename*="):
+            # If filename* is found
+            match = re.match(r"filename\*=(\S*)''(.*)", part)
+            if match:
+                encoding, value = match.groups()
+                try:
+                    filename = urllib.parse.unquote(value, encoding=encoding)
+                except ValueError:
+                    # Handle invalid encoding
+                    pass
+
+    if filename is None:
+        raise Exception("Failed to get filename")
+    return filename
+
+
+def get_filename(headers, url):
+    try:
+        if headers.get("Content-Disposition"):
+            filename = parse_content_disposition(headers["Content-Disposition"])
+        else:
+            filename = unquote_plus(url.strip("/").split("/")[-1])
+
+        filename = filename.strip(' "')
+    except:
+        filename = unquote_plus(url.strip("/").split("/")[-1])
+
+    filename = filename.strip()
+
+    if filename == "" or "." not in filename:
+        if headers.get("Content-Type"):
+            extension = mimetypes.guess_extension(headers["Content-Type"])
+            if extension:
+                filename = f"{getRandomID()}{extension}"
+            else:
+                filename = getRandomID()
+        else:
+            filename = getRandomID()
+
+    return filename

utils/logger.py

@@ -0,0 +1,48 @@
+import logging
+from tqdm import tqdm
+
+
+class TqdmLoggingHandler(logging.Handler):
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            tqdm.write(msg)
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+
+class Logger:
+    def __init__(self, name, level=logging.DEBUG):
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(level)
+        self.formatter = logging.Formatter("%(name)s - %(levelname)s - %(message)s")
+
+        # Remove existing handlers to prevent duplicate logs
+        if self.logger.hasHandlers():
+            self.logger.handlers.clear()
+
+        # FileHandler for logging to a file
+        file_handler = logging.FileHandler("logs.txt", mode="w")
+        file_handler.setFormatter(self.formatter)
+        self.logger.addHandler(file_handler)
+
+        # Custom TqdmLoggingHandler for console output
+        stream_handler = TqdmLoggingHandler()
+        stream_handler.setFormatter(self.formatter)
+        self.logger.addHandler(stream_handler)
+
+    def debug(self, message):
+        self.logger.debug(message)
+
+    def info(self, message):
+        self.logger.info(message)
+
+    def warning(self, message):
+        self.logger.warning(message)
+
+    def error(self, message):
+        self.logger.error(message)
+
+    def critical(self, message):
+        self.logger.critical(message)

utils/mongo_indexer.py

@@ -0,0 +1,121 @@
+import asyncio
+from typing import Any, Dict, Optional, Union, Callable, Awaitable
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorCollection
+
+from config import MONGODB_URI, MONGODB_DB_NAME, MONGODB_COLLECTION
+from utils.logger import Logger
+
+logger = Logger(__name__)
+
+
+class MongoNotConfiguredError(Exception):
+    """Raised when MongoDB is not configured but a Mongo-dependent feature is used."""
+
+
+_mongo_client: Optional[AsyncIOMotorClient] = None
+_collection: Optional[AsyncIOMotorCollection] = None
+
+
+def get_mongo_collection() -> AsyncIOMotorCollection:
+    """
+    Lazily initialize and return the MongoDB collection used to store indexed messages.
+    """
+    global _mongo_client, _collection
+
+    if not MONGODB_URI:
+        raise MongoNotConfiguredError(
+            "MongoDB is not configured. Please set MONGODB_URI in environment."
+        )
+
+    if _mongo_client is None:
+        _mongo_client = AsyncIOMotorClient(MONGODB_URI)
+
+    if _collection is None:
+        db = _mongo_client[MONGODB_DB_NAME]
+        _collection = db[MONGODB_COLLECTION]
+
+    return _collection
+
+
+async def _ensure_indexes(col: AsyncIOMotorCollection) -> None:
+    """Ensure indexes required for fast lookups and deduplication."""
+    try:
+        await col.create_index(
+            [("chat_id", 1), ("message_id", 1)],
+            name="chat_message_unique",
+            unique=True,
+        )
+        await col.create_index(
+            [("chat_id", 1), ("date", -1)],
+            name="chat_date_desc",
+        )
+    except Exception as e:
+        logger.error(f"Error creating MongoDB indexes: {e}")
+
+
+StatusCallback = Optional[Callable[[str], Awaitable[None]]]
+
+
+async def index_channel_messages(
+    client,
+    channel: Union[int, str],
+    status_callback: StatusCallback = None,
+) -> int:
+    """
+    Index all messages of a given channel/chat into MongoDB.
+
+    Returns the number of messages processed.
+    """
+    col = get_mongo_collection()
+    await _ensure_indexes(col)
+
+    total = 0
+    last_report = 0
+
+    async def _report(force: bool = False) -> None:
+        nonlocal last_report, total
+        if not status_callback:
+            return
+        if force or total - last_report >= 100:
+            last_report = total
+            try:
+                await status_callback(f"Indexed {total} messages so far...")
+            except Exception as e:
+                logger.error(f"Status callback error: {e}")
+
+    logger.info(f"Starting indexing for channel: {channel}")
+
+    try:
+        async for msg in client.get_chat_history(channel, limit=0):
+            try:
+                data: Dict[str, Any] = msg.to_dict()
+                doc = {
+                    "chat_id": msg.chat.id if msg.chat else None,
+                    "message_id": msg.id,
+                    "date": msg.date,
+                    "from_user_id": msg.from_user.id if msg.from_user else None,
+                    "text": msg.text or msg.caption,
+                    "raw": data,
+                }
+
+                await col.update_one(
+                    {"chat_id": doc["chat_id"], "message_id": doc["message_id"]},
+                    {"$set": doc},
+                    upsert=True,
+                )
+
+                total += 1
+                if total % 100 == 0:
+                    await _report()
+            except Exception as inner_e:
+                logger.error(f"Error indexing message {getattr(msg, 'id', 'unknown')}: {inner_e}")
+                continue
+
+        await _report(force=True)
+        logger.info(f"Completed indexing for channel: {channel} | Total messages: {total}")
+        return total
+    except Exception as e:
+        logger.error(f"Failed to index channel {channel}: {e}")
+        raise
+

utils/movie_requests.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorCollection
+
+from config import (
+    MONGODB_URI,
+    MONGODB_DB_NAME,
+    MONGODB_COLLECTION,
+    MONGODB_REQUESTS_COLLECTION,
+)
+from utils.logger import Logger
+
+logger = Logger(__name__)
+
+_client: Optional[AsyncIOMotorClient] = None
+_messages_col: Optional[AsyncIOMotorCollection] = None
+_requests_col: Optional[AsyncIOMotorCollection] = None
+
+
+class MovieRequestsMongoNotConfigured(Exception):
+    """Raised when MongoDB is not configured for movie requests."""
+
+
+def _get_client() -> AsyncIOMotorClient:
+    global _client
+    if not MONGODB_URI:
+        raise MovieRequestsMongoNotConfigured(
+            "MongoDB is not configured. Please set MONGODB_URI in environment."
+        )
+    if _client is None:
+        _client = AsyncIOMotorClient(MONGODB_URI)
+    return _client
+
+
+def get_messages_collection() -> AsyncIOMotorCollection:
+    """Mongo collection where indexed Telegram messages are stored."""
+    global _messages_col
+    if _messages_col is None:
+        client = _get_client()
+        db = client[MONGODB_DB_NAME]
+        _messages_col = db[MONGODB_COLLECTION]
+    return _messages_col
+
+
+def get_requests_collection() -> AsyncIOMotorCollection:
+    """Mongo collection where movie requests are stored."""
+    global _requests_col
+    if _requests_col is None:
+        client = _get_client()
+        db = client[MONGODB_DB_NAME]
+        _requests_col = db[MONGODB_REQUESTS_COLLECTION]
+    return _requests_col
+
+
+async def save_movie_request(
+    title: str,
+    year: str,
+    available: bool,
+    file_info: Optional[Dict[str, Any]] = None,
+) -> None:
+    col = get_requests_collection()
+    doc: Dict[str, Any] = {
+        "title": title,
+        "year": str(year),
+        "available": available,
+        "created_at": datetime.utcnow(),
+    }
+    if file_info:
+        doc["file"] = file_info
+    try:
+        await col.insert_one(doc)
+    except Exception as e:
+        logger.error(f"Failed to save movie request in MongoDB: {e}")
+

utils/streamer/__init__.py

@@ -0,0 +1,82 @@
+import math, mimetypes
+from fastapi.responses import StreamingResponse, Response
+from utils.logger import Logger
+from utils.streamer.custom_dl import ByteStreamer
+from utils.streamer.file_properties import get_name
+from utils.clients import (
+    get_client,
+)
+from urllib.parse import quote
+
+logger = Logger(__name__)
+
+class_cache = {}
+
+
+async def media_streamer(channel: int, message_id: int, file_name: str, request):
+    global class_cache
+
+    range_header = request.headers.get("Range", 0)
+
+    faster_client = get_client()
+
+    if faster_client in class_cache:
+        tg_connect = class_cache[faster_client]
+    else:
+        tg_connect = ByteStreamer(faster_client)
+        class_cache[faster_client] = tg_connect
+
+    file_id = await tg_connect.get_file_properties(channel, message_id)
+    file_size = file_id.file_size
+
+    if range_header:
+        from_bytes, until_bytes = range_header.replace("bytes=", "").split("-")
+        from_bytes = int(from_bytes)
+        until_bytes = int(until_bytes) if until_bytes else file_size - 1
+    else:
+        from_bytes = 0
+        until_bytes = file_size - 1
+
+    if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes < from_bytes):
+        return Response(
+            status_code=416,
+            content="416: Range not satisfiable",
+            headers={"Content-Range": f"bytes */{file_size}"},
+        )
+
+    chunk_size = 1024 * 1024
+    until_bytes = min(until_bytes, file_size - 1)
+
+    offset = from_bytes - (from_bytes % chunk_size)
+    first_part_cut = from_bytes - offset
+    last_part_cut = until_bytes % chunk_size + 1
+
+    req_length = until_bytes - from_bytes + 1
+    part_count = math.ceil(until_bytes / chunk_size) - math.floor(offset / chunk_size)
+    body = tg_connect.yield_file(
+        file_id, offset, first_part_cut, last_part_cut, part_count, chunk_size
+    )
+
+    disposition = "attachment"
+    mime_type = mimetypes.guess_type(file_name.lower())[0] or "application/octet-stream"
+
+    if (
+        "video/" in mime_type
+        or "audio/" in mime_type
+        or "image/" in mime_type
+        or "/html" in mime_type
+    ):
+        disposition = "inline"
+
+    return StreamingResponse(
+        status_code=206 if range_header else 200,
+        content=body,
+        headers={
+            "Content-Type": f"{mime_type}",
+            "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
+            "Content-Length": str(req_length),
+            "Content-Disposition": f'{disposition}; filename="{quote(file_name)}"',
+            "Accept-Ranges": "bytes",
+        },
+        media_type=mime_type,
+    )

utils/streamer/custom_dl.py

@@ -0,0 +1,223 @@
+import asyncio
+from typing import Dict, Union
+from pyrogram import Client, utils, raw
+from .file_properties import get_file_ids
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from utils.logger import Logger
+
+logger = Logger(__name__)
+
+
+class ByteStreamer:
+    def __init__(self, client: Client):
+        self.clean_timer = 30 * 60
+        self.client: Client = client
+        self.cached_file_ids: Dict[int, FileId] = {}
+        self.dc_options = None
+        asyncio.create_task(self.clean_cache())
+
+    async def get_file_properties(self, channel, message_id: int) -> FileId:
+        if message_id not in self.cached_file_ids:
+            await self.generate_file_properties(channel, message_id)
+        return self.cached_file_ids[message_id]
+
+    async def generate_file_properties(self, channel, message_id: int) -> FileId:
+        file_id = await get_file_ids(self.client, channel, message_id)
+        if not file_id:
+            raise Exception("FileNotFound")
+        self.cached_file_ids[message_id] = file_id
+        return self.cached_file_ids[message_id]
+
+    async def generate_media_session(self, client: Client, file_id: FileId) -> Session:
+        """
+        Generates the media session for the DC that contains the media file.
+        This is required for getting the bytes from Telegram servers.
+        """
+
+        media_session = client.media_sessions.get(file_id.dc_id, None)
+
+        if media_session is None:
+            if not self.dc_options:
+                config = await client.invoke(raw.functions.help.GetConfig())
+                self.dc_options = config.dc_options
+
+            ip = None
+            port = None
+            for option in self.dc_options:
+                if option.id == file_id.dc_id and not option.ipv6 and not option.cdn and not option.media_only:
+                    ip = option.ip_address
+                    port = option.port
+                    break
+            
+            if not ip:
+                for option in self.dc_options:
+                    if option.id == file_id.dc_id and not option.ipv6 and not option.cdn:
+                        ip = option.ip_address
+                        port = option.port
+                        break
+
+            if file_id.dc_id != await client.storage.dc_id():
+                media_session = Session(
+                    client,
+                    file_id.dc_id,
+                    ip,
+                    port,
+                    await Auth(
+                        client, file_id.dc_id, ip, port, await client.storage.test_mode()
+                    ).create(),
+                    await client.storage.test_mode(),
+                    is_media=True,
+                )
+                await media_session.start()
+
+                for _ in range(6):
+                    exported_auth = await client.invoke(
+                        raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id)
+                    )
+
+                    try:
+                        await media_session.invoke(
+                            raw.functions.auth.ImportAuthorization(
+                                id=exported_auth.id, bytes=exported_auth.bytes
+                            )
+                        )
+                        break
+                    except AuthBytesInvalid:
+                        logger.debug(
+                            f"Invalid authorization bytes for DC {file_id.dc_id}"
+                        )
+                        continue
+                else:
+                    await media_session.stop()
+                    raise AuthBytesInvalid
+            else:
+                media_session = Session(
+                    client,
+                    file_id.dc_id,
+                    ip,
+                    port,
+                    await client.storage.auth_key(),
+                    await client.storage.test_mode(),
+                    is_media=True,
+                )
+                await media_session.start()
+            logger.debug(f"Created media session for DC {file_id.dc_id}")
+            client.media_sessions[file_id.dc_id] = media_session
+        else:
+            logger.debug(f"Using cached media session for DC {file_id.dc_id}")
+        return media_session
+
+    @staticmethod
+    async def get_location(
+        file_id: FileId,
+    ) -> Union[
+        raw.types.InputPhotoFileLocation,
+        raw.types.InputDocumentFileLocation,
+        raw.types.InputPeerPhotoFileLocation,
+    ]:
+        """
+        Returns the file location for the media file.
+        """
+        file_type = file_id.file_type
+
+        if file_type == FileType.CHAT_PHOTO:
+            if file_id.chat_id > 0:
+                peer = raw.types.InputPeerUser(
+                    user_id=file_id.chat_id, access_hash=file_id.chat_access_hash
+                )
+            else:
+                if file_id.chat_access_hash == 0:
+                    peer = raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+                else:
+                    peer = raw.types.InputPeerChannel(
+                        channel_id=utils.get_channel_id(file_id.chat_id),
+                        access_hash=file_id.chat_access_hash,
+                    )
+
+            location = raw.types.InputPeerPhotoFileLocation(
+                peer=peer,
+                volume_id=file_id.volume_id,
+                local_id=file_id.local_id,
+                big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+            )
+        elif file_type == FileType.PHOTO:
+            location = raw.types.InputPhotoFileLocation(
+                id=file_id.media_id,
+                access_hash=file_id.access_hash,
+                file_reference=file_id.file_reference,
+                thumb_size=file_id.thumbnail_size,
+            )
+        else:
+            location = raw.types.InputDocumentFileLocation(
+                id=file_id.media_id,
+                access_hash=file_id.access_hash,
+                file_reference=file_id.file_reference,
+                thumb_size=file_id.thumbnail_size,
+            )
+        return location
+
+    async def yield_file(
+        self,
+        file_id: FileId,
+        offset: int,
+        first_part_cut: int,
+        last_part_cut: int,
+        part_count: int,
+        chunk_size: int,
+    ):
+        """
+        Custom generator that yields the bytes of the media file.
+        """
+        client = self.client
+        logger.debug(f"Starting to yielding file with client.")
+        media_session = await self.generate_media_session(client, file_id)
+
+        current_part = 1
+        location = await self.get_location(file_id)
+
+        try:
+            r = await media_session.invoke(
+                raw.functions.upload.GetFile(
+                    location=location, offset=offset, limit=chunk_size
+                ),
+            )
+            if isinstance(r, raw.types.upload.File):
+                while True:
+                    chunk = r.bytes
+                    if not chunk:
+                        break
+                    elif part_count == 1:
+                        yield chunk[first_part_cut:last_part_cut]
+                    elif current_part == 1:
+                        yield chunk[first_part_cut:]
+                    elif current_part == part_count:
+                        yield chunk[:last_part_cut]
+                    else:
+                        yield chunk
+
+                    current_part += 1
+                    offset += chunk_size
+
+                    if current_part > part_count:
+                        break
+
+                    r = await media_session.invoke(
+                        raw.functions.upload.GetFile(
+                            location=location, offset=offset, limit=chunk_size
+                        ),
+                    )
+        except (TimeoutError, AttributeError):
+            pass
+        finally:
+            logger.debug(f"Finished yielding file with {current_part} parts.")
+
+    async def clean_cache(self) -> None:
+        """
+        function to clean the cache to reduce memory usage
+        """
+        while True:
+            await asyncio.sleep(self.clean_timer)
+            self.cached_file_ids.clear()
+            logger.debug("Cleaned the cache")

utils/streamer/file_properties.py

@@ -0,0 +1,84 @@
+from pyrogram import Client
+from pyrogram.types import Message
+from pyrogram.file_id import FileId
+from typing import Any, Optional, Union
+from pyrogram.raw.types.messages import Messages
+from datetime import datetime
+
+
+async def parse_file_id(message: "Message") -> Optional[FileId]:
+    media = get_media_from_message(message)
+    if media:
+        return FileId.decode(media.file_id)
+
+
+async def parse_file_unique_id(message: "Messages") -> Optional[str]:
+    media = get_media_from_message(message)
+    if media:
+        return media.file_unique_id
+
+
+async def get_file_ids(client: Client, chat_id, message_id) -> Optional[FileId]:
+    message = await client.get_messages(chat_id, int(message_id))
+    if message.empty:
+        raise Exception("FileNotFound")
+    media = get_media_from_message(message)
+    file_unique_id = await parse_file_unique_id(message)
+    file_id = await parse_file_id(message)
+    setattr(file_id, "file_size", getattr(media, "file_size", 0))
+    setattr(file_id, "mime_type", getattr(media, "mime_type", ""))
+    setattr(file_id, "file_name", getattr(media, "file_name", ""))
+    setattr(file_id, "unique_id", file_unique_id)
+    return file_id
+
+
+def get_media_from_message(message: "Message") -> Any:
+    media_types = (
+        "audio",
+        "document",
+        "photo",
+        "sticker",
+        "animation",
+        "video",
+        "voice",
+        "video_note",
+    )
+    for attr in media_types:
+        media = getattr(message, attr, None)
+        if media:
+            return media
+
+
+def get_name(media_msg: Union[Message, FileId]) -> str:
+    if isinstance(media_msg, Message):
+        media = get_media_from_message(media_msg)
+        file_name = getattr(media, "file_name", "")
+
+    elif isinstance(media_msg, FileId):
+        file_name = getattr(media_msg, "file_name", "")
+
+    if not file_name:
+        if isinstance(media_msg, Message) and media_msg.media:
+            media_type = media_msg.media.value
+        elif media_msg.file_type:
+            media_type = media_msg.file_type.name.lower()
+        else:
+            media_type = "file"
+
+        formats = {
+            "photo": "jpg",
+            "audio": "mp3",
+            "voice": "ogg",
+            "video": "mp4",
+            "animation": "mp4",
+            "video_note": "mp4",
+            "sticker": "webp",
+        }
+
+        ext = formats.get(media_type)
+        ext = "." + ext if ext else ""
+
+        date = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        file_name = f"{media_type}-{date}{ext}"
+
+    return file_name

utils/uploader.py

@@ -0,0 +1,99 @@
+from utils.clients import get_client
+from pyrogram import Client
+from pyrogram.types import Message
+from pyrogram.errors import AuthKeyDuplicated
+from config import STORAGE_CHANNEL
+import os
+from pathlib import Path
+from utils.logger import Logger
+from urllib.parse import unquote_plus
+
+logger = Logger(__name__)
+PROGRESS_CACHE = {}
+STOP_TRANSMISSION = []
+
+
+async def progress_callback(current, total, id, client: Client, file_path):
+    global PROGRESS_CACHE, STOP_TRANSMISSION
+
+    PROGRESS_CACHE[id] = ("running", current, total)
+    if id in STOP_TRANSMISSION:
+        logger.info(f"Stopping transmission {id}")
+        client.stop_transmission()
+        try:
+            os.remove(file_path)
+        except:
+            pass
+
+
+async def start_file_uploader(
+    file_path, id, directory_path, filename, file_size, delete=True
+):
+    global PROGRESS_CACHE
+    from utils.directoryHandler import DRIVE_DATA
+
+    logger.info(f"Uploading file {file_path} {id}")
+
+    if file_size > 1.98 * 1024 * 1024 * 1024:
+        # Use premium client for files larger than 2 GB
+        client: Client = get_client(premium_required=True)
+    else:
+        client: Client = get_client()
+
+    PROGRESS_CACHE[id] = ("running", 0, 0)
+
+    try:
+        message: Message = await client.send_document(
+            STORAGE_CHANNEL,
+            file_path,
+            progress=progress_callback,
+            progress_args=(id, client, file_path),
+            disable_notification=True,
+        )
+    except AuthKeyDuplicated as e:
+        error_msg = (
+            "AUTH_KEY_DUPLICATED: The same bot token is being used in multiple places simultaneously. "
+            "The session file has been invalidated by Telegram. "
+            "Please ensure you're not running the same bot token locally and on Hugging Face Spaces at the same time. "
+            "Delete the session file and restart the application."
+        )
+        logger.error(error_msg)
+        logger.error(f"Error details: {e}")
+        
+        # Try to delete the session file if possible
+        try:
+            session_cache_path = Path("./cache")
+            session_file = session_cache_path / f"{client.name}.session"
+            if session_file.exists():
+                session_file.unlink()
+                logger.info(f"Deleted invalidated session file: {session_file}")
+        except Exception as cleanup_error:
+            logger.error(f"Failed to delete session file: {cleanup_error}")
+        
+        PROGRESS_CACHE[id] = ("failed", 0, 0)
+        if delete:
+            try:
+                os.remove(file_path)
+            except:
+                pass
+        return
+    size = (
+        message.photo
+        or message.document
+        or message.video
+        or message.audio
+        or message.sticker
+    ).file_size
+
+    filename = unquote_plus(filename)
+
+    DRIVE_DATA.new_file(directory_path, filename, message.id, size)
+    PROGRESS_CACHE[id] = ("completed", size, size)
+
+    logger.info(f"Uploaded file {file_path} {id}")
+
+    if delete:
+        try:
+            os.remove(file_path)
+        except Exception as e:
+            pass

website/VideoPlayer.html

@@ -0,0 +1,286 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TG Drive - Video Player</title>
+
+    <link href="//vjs.zencdn.net/8.3.0/video-js.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/videojs-seek-buttons/3.0.1/videojs-seek-buttons.min.css" rel="stylesheet">
+
+    <script src="//vjs.zencdn.net/8.3.0/video.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/videojs-seek-buttons/3.0.1/videojs-seek-buttons.min.js"></script>
+    
+    <style>
+        /* Modern Reset & Base Styles */
+        body {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            min-height: 100vh;
+            margin: 0;
+            font-family: 'Inter', system-ui, -apple-system, sans-serif;
+            background-color: #0f172a;
+            background-image: 
+                radial-gradient(at 0% 0%, hsla(253,16%,7%,1) 0, transparent 50%), 
+                radial-gradient(at 50% 0%, hsla(225,39%,30%,1) 0, transparent 50%), 
+                radial-gradient(at 100% 0%, hsla(339,49%,30%,1) 0, transparent 50%);
+            color: #ffffff;
+            user-select: none; /* Prevents text selection on double tap */
+        }
+
+        .glass-panel {
+            background: rgba(255, 255, 255, 0.05);
+            backdrop-filter: blur(16px);
+            -webkit-backdrop-filter: blur(16px);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 24px;
+            padding: 24px;
+            width: 90%;
+            max-width: 960px;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 24px;
+        }
+
+        .video-container {
+            width: 100%;
+            border-radius: 16px;
+            overflow: hidden;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+            position: relative; /* For double tap overlay */
+        }
+
+        /* --- Custom Video.js Styling --- */
+        
+        /* Center Play Button */
+        .video-js .vjs-big-play-button {
+            background-color: rgba(59, 130, 246, 0.9);
+            border: none;
+            width: 80px;
+            height: 80px;
+            line-height: 80px;
+            border-radius: 50%;
+            margin-left: -40px;
+            margin-top: -40px;
+            transition: all 0.3s ease;
+        }
+        .video-js .vjs-big-play-button:hover {
+            background-color: #2563eb;
+            transform: scale(1.1);
+        }
+
+        /* Control Bar Transparency */
+        .video-js .vjs-control-bar {
+            background-color: rgba(15, 23, 42, 0.85);
+            border-radius: 0 0 16px 16px;
+        }
+
+        /* Seek Buttons Styling */
+        .video-js .vjs-seek-button {
+            font-size: 1.2em;
+            cursor: pointer;
+        }
+
+        /* Speed Menu Styling */
+        .video-js .vjs-playback-rate .vjs-playback-rate-value {
+            line-height: 30px;
+            font-weight: bold;
+        }
+
+        /* --- Double Tap Overlay Animation --- */
+        .double-tap-overlay {
+            position: absolute;
+            top: 0;
+            bottom: 0;
+            width: 40%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            z-index: 10;
+            opacity: 0;
+            transition: opacity 0.2s;
+            pointer-events: none; /* Let clicks pass through if needed, but we handle via JS */
+            color: rgba(255,255,255,0.8);
+            font-size: 40px;
+        }
+        .dt-left { left: 0; background: linear-gradient(90deg, rgba(0,0,0,0.3), transparent); }
+        .dt-right { right: 0; background: linear-gradient(-90deg, rgba(0,0,0,0.3), transparent); }
+        
+        .dt-icon {
+            background: rgba(0,0,0,0.5);
+            border-radius: 50%;
+            padding: 15px;
+            display: none; /* Hidden by default */
+        }
+
+        /* Buttons Area */
+        .buttons-container {
+            display: flex;
+            gap: 16px;
+            width: 100%;
+            justify-content: center;
+            flex-wrap: wrap;
+        }
+
+        .copy-button {
+            padding: 14px 28px;
+            font-size: 15px;
+            font-weight: 600;
+            cursor: pointer;
+            background: rgba(255, 255, 255, 0.1);
+            color: white;
+            border: 1px solid rgba(255, 255, 255, 0.2);
+            border-radius: 12px;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+            min-width: 180px;
+        }
+
+        .copy-button:hover {
+            background: rgba(255, 255, 255, 0.2);
+            transform: translateY(-2px);
+            border-color: rgba(255, 255, 255, 0.4);
+        }
+
+        .copy-button.success {
+            background-color: #10b981;
+            border-color: #10b981;
+        }
+    </style>
+</head>
+
+<body>
+
+    <div class="glass-panel">
+        <div class="video-container" id="video-wrapper">
+            
+            <div class="double-tap-overlay dt-left" id="dt-left">
+                <div class="dt-icon">⏪ 10s</div>
+            </div>
+            <div class="double-tap-overlay dt-right" id="dt-right">
+                <div class="dt-icon">10s ⏩</div>
+            </div>
+
+            <video id="my-player" class="video-js vjs-fluid vjs-big-play-centered" controls preload="auto" 
+                data-setup='{"playbackRates": [0.5, 1, 1.25, 1.5, 2]}'>
+                <source id="video-src" src="" type="video/mp4">
+                </source>
+                <p class="vjs-no-js">
+                    To view this video please enable JavaScript.
+                </p>
+            </video>
+        </div>
+
+        <div class="buttons-container">
+            <button class="copy-button" onclick="copyStreamUrl(this)">
+                Copy Stream URL
+            </button>
+            <button class="copy-button" onclick="copyDownloadUrl(this)">
+                Copy Download URL
+            </button>
+        </div>
+    </div>
+
+    <script>
+        // 1. Get URL and Set Source
+        const downloadUrl = (new URL(window.location.href)).searchParams.get('url');
+        document.getElementById('video-src').src = downloadUrl;
+
+        // 2. Initialize Video.js Features
+        const player = videojs('my-player');
+
+        player.ready(function() {
+            // Enable the Seek Buttons Plugin (Forward/Back 10s)
+            player.seekButtons({
+                forward: 10,
+                back: 10
+            });
+        });
+
+        // 3. Custom Double Tap Logic
+        const wrapper = document.getElementById('video-wrapper');
+        const dtLeft = document.getElementById('dt-left');
+        const dtRight = document.getElementById('dt-right');
+        let lastTapTime = 0;
+        
+        // Listen for taps on the wrapper (captures clicks over the video)
+        wrapper.addEventListener('click', function(e) {
+            const currentTime = new Date().getTime();
+            const tapLength = currentTime - lastTapTime;
+            
+            // If double tap (less than 300ms between taps)
+            if (tapLength < 300 && tapLength > 0) {
+                const rect = wrapper.getBoundingClientRect();
+                const x = e.clientX - rect.left; // Click position inside video
+                
+                // Check if click is on Left (0-40%) or Right (60-100%) side
+                if (x < rect.width * 0.4) {
+                    // Rewind
+                    player.currentTime(player.currentTime() - 10);
+                    showDoubleTapEffect(dtLeft);
+                } else if (x > rect.width * 0.6) {
+                    // Forward
+                    player.currentTime(player.currentTime() + 10);
+                    showDoubleTapEffect(dtRight);
+                }
+                e.preventDefault(); // Stop default play/pause on the second click
+            }
+            lastTapTime = currentTime;
+        });
+
+        function showDoubleTapEffect(element) {
+            const icon = element.querySelector('.dt-icon');
+            element.style.opacity = '1';
+            icon.style.display = 'block';
+            
+            setTimeout(() => {
+                element.style.opacity = '0';
+                setTimeout(() => { icon.style.display = 'none'; }, 200);
+            }, 500);
+        }
+
+        // 4. Clipboard Logic (Same as before)
+        function copyTextToClipboard(text, btnElement) {
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+                navigator.clipboard.writeText(text).then(() => animateButton(btnElement))
+                .catch(() => fallbackCopyTextToClipboard(text, btnElement));
+            } else {
+                fallbackCopyTextToClipboard(text, btnElement);
+            }
+        }
+
+        function fallbackCopyTextToClipboard(text, btnElement) {
+            const textArea = document.createElement('textarea');
+            textArea.value = text;
+            document.body.appendChild(textArea);
+            textArea.select();
+            try {
+                if (document.execCommand('copy')) animateButton(btnElement);
+                else alert('Failed to copy');
+            } catch (e) {}
+            document.body.removeChild(textArea);
+        }
+
+        function animateButton(btn) {
+            const originalText = btn.innerText;
+            btn.classList.add('success');
+            btn.innerText = "Copied!";
+            setTimeout(() => {
+                btn.classList.remove('success');
+                btn.innerText = originalText;
+            }, 2000);
+        }
+
+        function copyStreamUrl(btn) { copyTextToClipboard(window.location.href, btn); }
+        function copyDownloadUrl(btn) { copyTextToClipboard(downloadUrl, btn); }
+    </script>
+
+</body>
+</html>

website/home.html

@@ -0,0 +1,219 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>TG Drive</title>
+    <link rel="stylesheet" href="static/home.css?v=2" />
+
+    <!-- Fonts Start -->
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=Space+Grotesk:wght@400;500;600;700&display=swap"
+        rel="stylesheet" />
+    <!-- Fonts End -->
+</head>
+
+<body>
+    <div class="container">
+        <!-- Sidebar Start -->
+        <div class="sidebar">
+            <div class="sidebar-header">
+                <img src="https://ssl.gstatic.com/images/branding/product/1x/drive_2020q4_48dp.png" />
+                <span>TG Drive</span>
+            </div>
+
+            <button id="new-button" class="new-button">
+                <img src="static/assets/plus-icon.svg" />New
+            </button>
+
+            <div id="new-upload" class="new-upload">
+                <input id="new-upload-focus" type="text"
+                    style="height: 0px; width: 0px; border: none; position: absolute" readonly />
+                <div id="new-folder-btn">
+                    <img src="static/assets/folder-icon.svg" />
+                    New Folder
+                </div>
+                <hr />
+                <div id="file-upload-btn">
+                    <img src="static/assets/upload-icon.svg" />
+                    File Upload
+                </div>
+                <input type="file" id="fileInput" style="height: 0px; width: 0px; border: none; position: absolute" />
+                <hr />
+                <div id="url-upload-btn">
+                    <img src="static/assets/link-icon.svg" />
+                    URL Upload
+                </div>
+            </div>
+
+            <div class="sidebar-menu">
+                <a class="selected-item" href="/?path=/"><img src="static/assets/home-icon.svg" />Home</a>
+                <a class="unselected-item" href="/?path=/trash"><img src="static/assets/trash-icon.svg" />Trash</a>
+            </div>
+        </div>
+        <!-- Sidebar End -->
+
+        <div id="bg-blur" class="bg-blur"></div>
+
+        <!-- Create New Folder Start -->
+        <div id="create-new-folder" class="create-new-folder">
+            <span>New Folder</span>
+            <input type="text" id="new-folder-name" placeholder="Enter Folder Name" autocomplete="off" />
+            <div>
+                <button id="new-folder-cancel">Cancel</button>
+                <button id="new-folder-create">Create</button>
+            </div>
+        </div>
+        <!-- Create New Folder End -->
+
+        <!-- File / Folder Rename Start -->
+        <div id="rename-file-folder" class="create-new-folder">
+            <span>Edit File/Folder Name</span>
+            <input type="text" id="rename-name" placeholder="Enter File/Folder Name" autocomplete="off" />
+            <div>
+                <button id="rename-cancel">Cancel</button>
+                <button id="rename-create">Rename</button>
+            </div>
+        </div>
+        <!-- File / Folder Rename End -->
+
+        <!-- Remote Upload Start -->
+        <div id="new-url-upload" class="create-new-folder">
+            <span>Url Upload</span>
+            <input type="text" id="remote-url" placeholder="Enter Direct Download Link Of File" autocomplete="off" />
+            <div id="single-threaded-div">
+                <input type="checkbox" name="single-threaded-toggle" id="single-threaded-toggle">
+                <label for="single-threaded-toggle">Single Threaded</label>
+                <a href="#"><img src="static/assets/info-icon-small.svg" alt="Info"></a>
+            </div>
+            <div>
+                <button id="remote-cancel">Cancel</button>
+                <button id="remote-start">Upload</button>
+            </div>
+        </div>
+        <!-- Remote Upload End -->
+
+        <!-- Get Password Start -->
+        <div id="get-password" class="create-new-folder">
+            <span>Admin Login</span>
+            <input type="text" id="auth-pass" placeholder="Enter Password" autocomplete="off" />
+            <div>
+                <button id="pass-login">Login</button>
+            </div>
+        </div>
+        <!-- Get Password End -->
+
+        <!-- File Uploader Start -->
+        <div id="file-uploader" class="file-uploader">
+            <span class="upload-head">🚀 Uploading File...</span>
+            <span id="upload-filename" class="upload-info">Filename : </span>
+            <span id="upload-filesize" class="upload-info">Filesize :</span>
+            <span id="upload-status" class="upload-info">Status : </span>
+            <span id="upload-percent" class="upload-info">Progress : </span>
+            <div class="progress">
+                <div class="progress-bar" id="progress-bar"></div>
+            </div>
+            <div class="btn-div">
+                <button id="cancel-file-upload">Cancel Upload</button>
+            </div>
+        </div>
+        <!-- File Uploader End -->
+
+        <!-- Request Movie Start -->
+        <div id="request-movie" class="create-new-folder">
+            <span>Request Movie</span>
+            <input type="text" id="request-movie-title" placeholder="Movie Title" autocomplete="off" />
+            <input type="text" id="request-movie-year" placeholder="Year (e.g. 2023)" autocomplete="off" />
+            <div id="request-movie-info" style="font-size: 0.85rem; margin-top: 8px; max-height: 120px; overflow-y: auto;"></div>
+            <div style="margin-top: 10px;">
+                <button id="request-movie-cancel">Cancel</button>
+                <button id="request-movie-fetch">Fetch From TMDB</button>
+                <button id="request-movie-send">Request This Movie</button>
+            </div>
+        </div>
+        <!-- Request Movie End -->
+
+        <!-- Main Content Start -->
+        <div class="main-content">
+            <div class="header">
+                <button id="sidebar-toggle-btn" class="theme-toggle-btn" title="Toggle Sidebar"
+                    style="margin-right: 10px;">
+                    <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" fill="#444746">
+                        <path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z" />
+                    </svg>
+                </button>
+                <button id="theme-toggle-btn" class="theme-toggle-btn" title="Toggle Theme">
+                    <svg id="theme-icon" xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"
+                        fill="#444746">
+                        <path
+                            d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9 9-4.03 9-9c0-.46-.04-.92-.1-1.36-.98 1.37-2.58 2.26-4.4 2.26-2.98 0-5.4-2.42-5.4-5.4 0-1.81.89-3.42 2.26-4.4-.44-.06-.9-.1-1.36-.1z" />
+                    </svg>
+                </button>
+                <div class="sort-dropdown">
+                    <button id="sort-toggle-btn" class="theme-toggle-btn" title="Sort Files">
+                        <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" fill="#444746">
+                            <path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z"/>
+                        </svg>
+                    </button>
+                    <div id="sort-menu" class="sort-menu">
+                        <div class="sort-option" data-sort="date-desc">📅 Newest First</div>
+                        <div class="sort-option" data-sort="date-asc">📅 Oldest First</div>
+                        <div class="sort-option" data-sort="name-asc">🔤 A to Z</div>
+                        <div class="sort-option" data-sort="name-desc">🔤 Z to A</div>
+                        <div class="sort-option" data-sort="size-desc">📊 Largest First</div>
+                        <div class="sort-option" data-sort="size-asc">📊 Smallest First</div>
+                    </div>
+                </div>
+                <div class="search-bar">
+                    <img src="static/assets/search-icon.svg" />
+                    <form id="search-form">
+                        <input id="file-search" type="text" placeholder="Search in Drive" autocomplete="off" />
+                    </form>
+                </div>
+
+                <button id="request-movie-btn" class="theme-toggle-btn" title="Request Movie" style="margin-left: 10px;">
+                    Request Movie
+                </button>
+            </div>
+
+            <div class="directory">
+                <table>
+                    <thead>
+                        <tr>
+                            <th>Name</th>
+                            <th>File Size</th>
+                            <th>More</th>
+                        </tr>
+                    </thead>
+                    <tbody id="directory-data"></tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+    
+    <!-- Toast Notifications Container -->
+    <div id="toast-container"></div>
+    
+    <!-- Loading Overlay -->
+    <div id="loading-overlay" class="loading-overlay">
+        <div class="loading-spinner">
+            <div class="spinner-ring"></div>
+            <div class="spinner-ring"></div>
+            <div class="spinner-ring"></div>
+        </div>
+        <p id="loading-text">Loading...</p>
+    </div>
+    
+    <script src="static/js/toast.js?v=3"></script>
+    <script src="static/js/extra.js?v=2"></script>
+    <script src="static/js/apiHandler.js?v=2"></script>
+    <script src="static/js/sidebar.js?v=2"></script>
+    <script src="static/js/fileClickHandler.js?v=2"></script>
+    <script src="static/js/sorting.js?v=3"></script>
+    <script src="static/js/main.js?v=2"></script>
+</body>
+
+</html>

website/static/home.css

@@ -0,0 +1,1112 @@
+* {
+    margin: 0px;
+    padding: 0px;
+    box-sizing: border-box;
+    font-family: "Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+}
+
+/* Smooth scrolling */
+html {
+    scroll-behavior: smooth;
+}
+
+/* Gen-Z Animation keyframes */
+@keyframes slideInUp {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+@keyframes slideInDown {
+    from {
+        opacity: 0;
+        transform: translateY(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+    }
+    to {
+        opacity: 1;
+    }
+}
+
+@keyframes scaleIn {
+    from {
+        opacity: 0;
+        transform: scale(0.9);
+    }
+    to {
+        opacity: 1;
+        transform: scale(1);
+    }
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+.container {
+    width: 100%;
+    height: 100vh;
+    display: grid;
+    background: #f1f1f1;
+    grid-template-columns: auto 1fr;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.rotate-90 {
+    transform: rotate(90deg);
+    transition: transform 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+/* Sidebar Style Start */
+
+.sidebar {
+    width: 250px;
+    height: 100%;
+    background-color: #f8fafd;
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    justify-content: start;
+    align-items: start;
+}
+
+.sidebar-header {
+    display: flex;
+    align-items: center;
+    justify-content: start;
+}
+
+.sidebar-header img {
+    width: 40px;
+    height: 40px;
+    margin-right: 10px;
+}
+
+.sidebar-header span {
+    font-size: 1.2rem;
+    font-weight: 500;
+    color: #444746;
+}
+
+.sidebar .new-button {
+    padding: 15px 20px;
+    background-color: #fff;
+    border: 1px solid #e0e0e0;
+    border-radius: 20px;
+    margin-top: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
+    font-size: 0.9rem;
+    color: #282c35;
+    font-weight: 500;
+    position: relative;
+    overflow: hidden;
+}
+
+.sidebar .new-button::before {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 0;
+    height: 0;
+    border-radius: 50%;
+    background: rgba(102, 126, 234, 0.1);
+    transform: translate(-50%, -50%);
+    transition: width 0.6s, height 0.6s;
+}
+
+.sidebar .new-button:hover::before {
+    width: 300px;
+    height: 300px;
+}
+
+.sidebar .new-button:hover {
+    background-color: #edf1fa;
+    border: 1px solid #c9d0e6;
+    box-shadow: 0px 5px 15px rgba(102, 126, 234, 0.3);
+    transform: translateY(-2px);
+}
+
+.sidebar .new-button img {
+    width: 24px;
+    height: 24px;
+    margin-right: 10px;
+}
+
+.new-upload {
+    position: absolute;
+    background-color: #ffffff;
+    padding: 5px 0px;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.2);
+    border-radius: 5px;
+    width: 250px;
+    top: 40px;
+    z-index: -1;
+    opacity: 0;
+    transition: all 0.2s;
+}
+
+.new-upload div {
+    padding: 10px 20px;
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 14px;
+}
+
+.new-upload div:hover {
+    background-color: #f1f1f1;
+}
+
+.new-upload div img {
+    margin-right: 10px;
+    height: 20px;
+    width: 20px;
+}
+
+.new-upload hr {
+    border: 1px solid #e0e0e0;
+    margin: 5px 0px;
+}
+
+.bg-blur {
+    position: fixed;
+    background-color: #000000;
+    height: 100dvh;
+    width: 100dvw;
+    transition: opacity 0.3s ease;
+    z-index: -1;
+    opacity: 0;
+}
+
+/* More Options Start */
+
+.more-options {
+    position: absolute;
+    background-color: #ffffff;
+    padding: 2px 0px;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.2);
+    border-radius: 5px;
+    z-index: -1;
+    opacity: 0;
+    transition: all 0.2s;
+    width: 150px;
+    transform: translateX(-50%);
+}
+
+.more-options div {
+    width: 100%;
+    padding: 5px 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 14px;
+}
+
+.more-options div:hover {
+    background-color: #f1f1f1;
+}
+
+.more-options div img {
+    margin-right: 10px;
+    height: 20px;
+    width: 20px;
+}
+
+.more-options hr {
+    border: 1px solid #e0e0e0;
+    margin: 2px 0px;
+}
+
+/* More Options End */
+
+
+/* Create New Folder Start */
+.create-new-folder {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    padding: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    background-color: #fff;
+    border-radius: 10px;
+    z-index: -1;
+    opacity: 0;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.3);
+    transition: opacity 0.3s ease;
+    width: 400px;
+}
+
+.create-new-folder span {
+    font-size: 1.2rem;
+    font-weight: 400;
+    color: #444746;
+    margin-bottom: 20px;
+    width: 100%;
+    margin-left: 10px;
+}
+
+.create-new-folder input {
+    width: 100%;
+    padding: 10px 20px;
+    border: 1px solid #e0e0e0;
+    border-radius: 5px;
+    outline: none;
+    font-size: 0.9rem;
+    font-weight: 400;
+    color: #444746;
+    margin-bottom: 20px;
+}
+
+.create-new-folder div {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: end;
+    gap: 10px;
+}
+
+.create-new-folder button {
+    background-color: transparent;
+    border: none;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 0.9rem;
+    color: #0b57d0;
+    font-weight: 500;
+    padding: 10px 20px;
+}
+
+.create-new-folder button:hover {
+    background-color: #edf1fa;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+/* Create New Folder End */
+
+/* Remote URL Upload Start */
+
+#single-threaded-div {
+    display: flex;
+    flex-direction: row;
+    justify-content: start;
+    align-items: center;
+    width: 100%;
+    margin: 10px 0px;
+}
+
+#single-threaded-div input {
+    width: auto;
+    margin: 0px;
+    margin-left: 10px;
+}
+
+#single-threaded-div img {
+    height: 16px;
+    width: 16px;
+}
+
+#single-threaded-div a {
+    height: 16px;
+    width: 16px;
+}
+
+/* Remote URL Upload End */
+
+/* File Uploader Start */
+
+.file-uploader {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    padding: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    background-color: #fff;
+    border-radius: 10px;
+    z-index: -1;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.3);
+    transition: opacity 0.3s ease;
+    width: 500px;
+    opacity: 0;
+}
+
+.upload-head {
+    font-size: 1.2rem;
+    font-weight: 500;
+    color: #444746;
+    margin-bottom: 20px;
+    width: 100%;
+}
+
+.upload-info {
+    font-size: 16px;
+    font-weight: 400;
+    color: #444746;
+    margin-bottom: 5px;
+    width: 100%;
+    max-height: 40px;
+    overflow: hidden;
+}
+
+.progress {
+    width: 100%;
+    background-color: #ddd;
+    border-radius: 5px;
+    overflow: hidden;
+    margin-top: 20px;
+}
+
+.progress-bar {
+    height: 20px;
+    background-color: #007bff;
+    width: 0;
+    transition: width 0.3s;
+}
+
+.file-uploader .btn-div {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: end;
+    margin-top: 20px;
+}
+
+.file-uploader button {
+    background-color: transparent;
+    border: none;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 0.9rem;
+    color: #0b57d0;
+    font-weight: 500;
+    padding: 10px 20px;
+}
+
+.file-uploader button:hover {
+    background-color: #edf1fa;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+/* File Uploader End */
+
+.sidebar-menu {
+    margin-top: 20px;
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    justify-content: start;
+    align-items: center;
+}
+
+.sidebar-menu a {
+    width: 100%;
+    padding: 10px 20px;
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    color: #444746;
+    font-size: 0.9rem;
+    font-weight: 400;
+    text-decoration: none;
+    transition: all 0.3s ease;
+    border-radius: 20px;
+}
+
+.sidebar-menu .selected-item {
+    background-color: #c2e7ff;
+}
+
+.sidebar-menu .unselected-item:hover {
+    background-color: #cfcfcf;
+}
+
+.sidebar-menu a img {
+    width: 20px;
+    height: 20px;
+    margin-right: 10px;
+}
+
+/* Sidebar Style End */
+
+/* Main Content Style Start */
+
+.main-content {
+    width: 100%;
+    height: 100%;
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    justify-content: start;
+    align-items: start;
+    background-color: #f8fafd;
+}
+
+
+.main-content .header {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    gap: 15px;
+}
+
+#search-form {
+    height: 100%;
+    width: 100%;
+}
+
+.search-bar {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    background-color: #e9eef6;
+    border-radius: 20px;
+    padding: 10px 20px;
+    flex-grow: 1;
+}
+
+.search-bar img {
+    width: 20px;
+    height: 20px;
+    margin-right: 20px;
+}
+
+.search-bar input {
+    width: 100%;
+    border: none;
+    outline: none;
+    background-color: transparent;
+    font-size: 1rem;
+    font-weight: 400;
+}
+
+.search-bar:focus-within {
+    background-color: #ffffff;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.directory {
+    background-color: #fff;
+    padding: 10px 20px;
+    width: 100%;
+    height: 100%;
+    border-radius: 20px;
+    margin-top: 20px;
+}
+
+.directory table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.directory table tr th {
+    text-align: start;
+    font-size: 0.9rem;
+    font-weight: 500;
+    color: #444746;
+    padding: 10px 0px;
+    border-bottom: 1px solid #e0e0e0;
+}
+
+.directory table tr td {
+    text-align: start;
+    font-size: 0.9rem;
+    font-weight: 400;
+    color: #444746;
+    border-bottom: 1px solid #e0e0e0;
+    height: 50px;
+}
+
+.directory .body-tr {
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    cursor: pointer;
+}
+
+.directory .body-tr:hover {
+    background-color: #f1f1f1;
+    transform: scale(1.01);
+}
+
+.directory .td-align {
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    width: 100%;
+    height: 100%;
+}
+
+.directory .td-align img {
+    width: 24px;
+    height: 24px;
+    margin-right: 10px;
+}
+
+.directory .more-btn img {
+    width: 14px;
+    height: 14px;
+    margin: 0px;
+}
+
+.directory .more-btn {
+    padding: 8px;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.directory .more-btn:hover {
+    background-color: #b9b9b9;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
+    transform: rotate(90deg) scale(1.1);
+}
+
+/* Theme Toggle & Dark Mode */
+/* Theme Toggle & Dark Mode */
+
+
+.theme-toggle-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    border-radius: 50%;
+    padding: 8px;
+    width: 40px;
+    height: 40px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: background-color 0.3s;
+    flex-shrink: 0;
+}
+
+.theme-toggle-btn:hover {
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+body.dark-mode .theme-toggle-btn:hover {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+/* Dark Mode Variables/Overrides */
+body.dark-mode .container {
+    background-color: #121212;
+}
+
+body.dark-mode .sidebar {
+    background-color: #1e1e1e;
+    border-right: 1px solid #333;
+}
+
+body.dark-mode .sidebar-header span {
+    color: #e0e0e0;
+}
+
+body.dark-mode .sidebar .new-button {
+    background-color: #2d2d2d;
+    color: #e0e0e0;
+    border: 1px solid #444;
+}
+
+body.dark-mode .sidebar .new-button:hover {
+    background-color: #383838;
+}
+
+body.dark-mode .new-upload {
+    background-color: #2d2d2d;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.5);
+}
+
+body.dark-mode .new-upload div {
+    color: #e0e0e0;
+}
+
+body.dark-mode .new-upload div:hover {
+    background-color: #383838;
+}
+
+body.dark-mode .sidebar-menu a {
+    color: #bfbfbf;
+}
+
+body.dark-mode .sidebar-menu .selected-item {
+    background-color: #3a4a5e;
+    color: #fff;
+}
+
+body.dark-mode .sidebar-menu .unselected-item:hover {
+    background-color: #2d2d2d;
+}
+
+/* Sidebar Collapsed State */
+.container.sidebar-collapsed {
+    grid-template-columns: 0px 1fr;
+}
+
+.container.sidebar-collapsed .sidebar {
+    padding: 0px;
+    overflow: hidden;
+    width: 0px;
+}
+
+body.dark-mode .main-content {
+    background-color: #121212;
+}
+
+body.dark-mode .search-bar {
+    background-color: #2d2d2d;
+}
+
+body.dark-mode .search-bar input {
+    color: #e0e0e0;
+}
+
+body.dark-mode .directory {
+    background-color: #1e1e1e;
+}
+
+body.dark-mode .directory table tr th {
+    color: #aaa;
+    border-bottom: 1px solid #333;
+}
+
+body.dark-mode .directory table tr td {
+    color: #e0e0e0;
+    border-bottom: 1px solid #333;
+}
+
+body.dark-mode .directory .body-tr:hover {
+    background-color: #2d2d2d;
+}
+
+body.dark-mode .create-new-folder,
+body.dark-mode .file-uploader,
+body.dark-mode .more-options,
+body.dark-mode #get-password {
+    background-color: #1e1e1e;
+    color: #e0e0e0;
+}
+
+body.dark-mode .create-new-folder input,
+body.dark-mode #auth-pass {
+    background-color: #2d2d2d;
+    border: 1px solid #444;
+    color: #e0e0e0;
+}
+
+body.dark-mode .create-new-folder span,
+body.dark-mode .upload-head,
+body.dark-mode .upload-info {
+    color: #e0e0e0;
+}
+
+body.dark-mode .more-options div:hover {
+    background-color: #383838;
+}
+
+body.dark-mode .more-options div {
+    color: #e0e0e0;
+}
+
+/* Icon Inversion for Dark Mode */
+body.dark-mode img {
+    filter: invert(0.9);
+}
+
+/* Exceptions for images that shouldn't be inverted */
+body.dark-mode .sidebar-header img,
+/* Logo */
+body.dark-mode .directory img[src*="file-icon"],
+/* Maybe file icon colors matter? assuming svgs are mono for now */
+body.dark-mode .directory img[src*="folder-solid"] {
+    filter: none;
+}
+
+/* Re-invert folder icon if it is dark? */
+body.dark-mode .directory img[src*="folder-solid"] {
+    filter: invert(0.7) sepia(1) hue-rotate(180deg);
+    /* Attempt to make it bluish or standard folder color if it was black */
+}
+
+/* Ideally, we should check what icons look like. Assuming black icons, invert 0.9 makes them white. */
+body.dark-mode .directory img[src*="folder-solid-icon.svg"] {
+    filter: invert(0.5);
+    /* Grey */
+}
+
+/* SVG Fill */
+body.dark-mode svg {
+    fill: #e0e0e0 !important;
+}
+
+/* Toast Notification System */
+#toast-container {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    z-index: 10000;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    pointer-events: none;
+}
+
+.toast {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 16px 24px;
+    border-radius: 16px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    min-width: 300px;
+    max-width: 400px;
+    animation: slideInDown 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    backdrop-filter: blur(10px);
+    pointer-events: all;
+    font-weight: 500;
+    font-size: 14px;
+    position: relative;
+    overflow: hidden;
+}
+
+.toast::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 3px;
+    background: rgba(255, 255, 255, 0.5);
+    animation: toastProgress 3s linear;
+}
+
+@keyframes toastProgress {
+    from {
+        width: 100%;
+    }
+    to {
+        width: 0%;
+    }
+}
+
+.toast.success {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+}
+
+.toast.error {
+    background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+}
+
+.toast.info {
+    background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+}
+
+.toast.warning {
+    background: linear-gradient(135deg, #fa709a 0%, #fee140 100%);
+}
+
+.toast-icon {
+    font-size: 24px;
+    flex-shrink: 0;
+}
+
+.toast-message {
+    flex: 1;
+    line-height: 1.4;
+}
+
+.toast-close {
+    background: rgba(255, 255, 255, 0.2);
+    border: none;
+    color: white;
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    transition: background 0.2s;
+    font-size: 18px;
+    line-height: 1;
+}
+
+.toast-close:hover {
+    background: rgba(255, 255, 255, 0.3);
+}
+
+.toast.hiding {
+    animation: slideOutRight 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@keyframes slideOutRight {
+    to {
+        opacity: 0;
+        transform: translateX(400px);
+    }
+}
+
+body.dark-mode .toast {
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
+}
+
+/* Loading Overlay */
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100vw;
+    height: 100vh;
+    background: rgba(0, 0, 0, 0.7);
+    backdrop-filter: blur(8px);
+    display: none;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    z-index: 9999;
+    animation: fadeIn 0.3s;
+}
+
+.loading-overlay.show {
+    display: flex;
+}
+
+.loading-spinner {
+    position: relative;
+    width: 80px;
+    height: 80px;
+}
+
+.spinner-ring {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    border: 4px solid transparent;
+    border-radius: 50%;
+    animation: spin 1.5s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+}
+
+.spinner-ring:nth-child(1) {
+    border-top-color: #667eea;
+    animation-delay: -0.45s;
+}
+
+.spinner-ring:nth-child(2) {
+    border-top-color: #764ba2;
+    animation-delay: -0.3s;
+}
+
+.spinner-ring:nth-child(3) {
+    border-top-color: #f093fb;
+    animation-delay: -0.15s;
+}
+
+#loading-text {
+    color: white;
+    margin-top: 20px;
+    font-size: 16px;
+    font-weight: 500;
+    animation: fadeIn 0.5s;
+}
+
+/* Sort Dropdown */
+.sort-dropdown {
+    position: relative;
+}
+
+.sort-menu {
+    position: absolute;
+    top: 45px;
+    right: 0;
+    background: white;
+    border-radius: 12px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.15);
+    padding: 8px;
+    min-width: 200px;
+    opacity: 0;
+    visibility: hidden;
+    transform: translateY(-10px);
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    z-index: 100;
+}
+
+.sort-menu.show {
+    opacity: 1;
+    visibility: visible;
+    transform: translateY(0);
+}
+
+.sort-option {
+    padding: 12px 16px;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: all 0.2s;
+    font-size: 14px;
+    font-weight: 500;
+    color: #444746;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+.sort-option:hover {
+    background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%);
+    transform: translateX(4px);
+}
+
+.sort-option.active {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+}
+
+body.dark-mode .sort-menu {
+    background: #2d2d2d;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
+}
+
+body.dark-mode .sort-option {
+    color: #e0e0e0;
+}
+
+body.dark-mode .sort-option:hover {
+    background: #383838;
+}
+
+body.dark-mode .sort-option.active {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+}
+
+/* Mobile Responsive Styles */
+@media screen and (max-width: 768px) {
+    .container {
+        grid-template-columns: 1fr;
+    }
+    
+    .sidebar {
+        position: fixed;
+        left: -100%;
+        top: 0;
+        height: 100vh;
+        z-index: 100;
+        transition: left 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        box-shadow: 2px 0 20px rgba(0, 0, 0, 0.1);
+    }
+    
+    .sidebar.mobile-open {
+        left: 0;
+    }
+    
+    .main-content {
+        padding: 10px;
+    }
+    
+    .header {
+        flex-wrap: wrap;
+        gap: 10px;
+    }
+    
+    .search-bar {
+        order: 3;
+        width: 100%;
+        margin-top: 10px;
+    }
+    
+    .directory {
+        overflow-x: auto;
+        border-radius: 12px;
+    }
+    
+    .directory table {
+        min-width: 500px;
+    }
+    
+    .create-new-folder,
+    .file-uploader {
+        width: 90%;
+        max-width: 400px;
+    }
+    
+    #toast-container {
+        right: 10px;
+        left: 10px;
+        top: 10px;
+    }
+    
+    .toast {
+        min-width: auto;
+        max-width: 100%;
+    }
+}
+
+@media screen and (max-width: 480px) {
+    .sidebar-header span {
+        font-size: 1rem;
+    }
+    
+    .new-button {
+        font-size: 0.8rem;
+        padding: 12px 16px !important;
+    }
+    
+    .directory table tr th,
+    .directory table tr td {
+        font-size: 0.8rem;
+        padding: 8px 5px;
+    }
+    
+    .td-align img {
+        width: 20px !important;
+        height: 20px !important;
+    }
+}

website/static/js/apiHandler.js

@@ -0,0 +1,368 @@
+// Api Fuctions
+async function postJson(url, data) {
+    data['password'] = getPassword()
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(data)
+    })
+    return await response.json()
+}
+
+document.getElementById('pass-login').addEventListener('click', async () => {
+    const password = document.getElementById('auth-pass').value
+    const data = { 'pass': password }
+    showLoading('Logging in...');
+    const json = await postJson('/api/checkPassword', data)
+    hideLoading();
+    if (json.status === 'ok') {
+        localStorage.setItem('password', password)
+        showToast('🎉 Login successful!', 'success');
+        setTimeout(() => window.location.reload(), 1000);
+    }
+    else {
+        showToast('❌ Wrong password', 'error');
+    }
+
+})
+
+async function getCurrentDirectory() {
+    let path = getCurrentPath()
+    if (path === 'redirect') {
+        return
+    }
+    try {
+        showLoading('Loading directory...');
+        const auth = getFolderAuthFromPath()
+        console.log(path)
+
+        const data = { 'path': path, 'auth': auth }
+        const json = await postJson('/api/getDirectory', data)
+        hideLoading();
+
+        if (json.status === 'ok') {
+            if (getCurrentPath().startsWith('/share')) {
+                const sections = document.querySelector('.sidebar-menu').getElementsByTagName('a')
+                console.log(path)
+
+                if (removeSlash(json['auth_home_path']) === removeSlash(path.split('_')[1])) {
+                    sections[0].setAttribute('class', 'selected-item')
+
+                } else {
+                    sections[0].setAttribute('class', 'unselected-item')
+                }
+                sections[0].href = `/?path=/share_${removeSlash(json['auth_home_path'])}&auth=${auth}`
+                console.log(`/?path=/share_${removeSlash(json['auth_home_path'])}&auth=${auth}`)
+            }
+
+            console.log(json)
+            showDirectory(json['data'])
+        } else {
+            showToast('❌ Directory not found', 'error');
+        }
+    }
+    catch (err) {
+        console.log(err)
+        hideLoading();
+        showToast('❌ Directory not found', 'error');
+    }
+}
+
+async function createNewFolder() {
+    const folderName = document.getElementById('new-folder-name').value;
+    const path = getCurrentPath()
+    if (path === 'redirect') {
+        return
+    }
+    if (folderName.length > 0) {
+        const data = {
+            'name': folderName,
+            'path': path
+        }
+        try {
+            showLoading('Creating folder...');
+            const json = await postJson('/api/createNewFolder', data)
+            hideLoading();
+
+            if (json.status === 'ok') {
+                showToast('📁 Folder created successfully!', 'success');
+                setTimeout(() => window.location.reload(), 1000);
+            } else {
+                showToast(json.status, 'error');
+            }
+        }
+        catch (err) {
+            hideLoading();
+            showToast('❌ Error creating folder', 'error');
+        }
+    } else {
+        showToast('❌ Folder name cannot be empty', 'error');
+    }
+}
+
+
+async function getFolderShareAuth(path) {
+    const data = { 'path': path }
+    const json = await postJson('/api/getFolderShareAuth', data)
+    if (json.status === 'ok') {
+        return json.auth
+    } else {
+        showToast('❌ Error getting folder share link', 'error');
+    }
+}
+
+async function tmdbSearchMovie(title, year) {
+    const data = { 'title': title, 'year': year }
+    const json = await postJson('/api/tmdbSearchMovie', data)
+    return json
+}
+
+async function requestMovie(title, year) {
+    const data = { 'title': title, 'year': year }
+    const json = await postJson('/api/requestMovie', data)
+    return json
+}
+
+// File Uploader Start
+
+const MAX_FILE_SIZE = MAX_FILE_SIZE__SDGJDG // Will be replaced by the python
+
+const fileInput = document.getElementById('fileInput');
+const progressBar = document.getElementById('progress-bar');
+const cancelButton = document.getElementById('cancel-file-upload');
+const uploadPercent = document.getElementById('upload-percent');
+let uploadRequest = null;
+let uploadStep = 0;
+let uploadID = null;
+
+fileInput.addEventListener('change', async (e) => {
+    const file = fileInput.files[0];
+
+    if (file.size > MAX_FILE_SIZE) {
+        showToast(`❌ File size exceeds ${(MAX_FILE_SIZE / (1024 * 1024 * 1024)).toFixed(2)} GB limit`, 'error');
+        return;
+    }
+
+    // Showing file uploader
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+    document.getElementById('file-uploader').style.zIndex = '3';
+    document.getElementById('file-uploader').style.opacity = '1';
+
+    document.getElementById('upload-filename').innerText = 'Filename: ' + file.name;
+    document.getElementById('upload-filesize').innerText = 'Filesize: ' + (file.size / (1024 * 1024)).toFixed(2) + ' MB';
+    document.getElementById('upload-status').innerText = 'Status: Uploading To Backend Server';
+
+
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('path', getCurrentPath());
+    formData.append('password', getPassword());
+    const id = getRandomId();
+    formData.append('id', id);
+    formData.append('total_size', file.size);
+
+    uploadStep = 1;
+    uploadRequest = new XMLHttpRequest();
+    uploadRequest.open('POST', '/api/upload', true);
+
+    uploadRequest.upload.addEventListener('progress', (e) => {
+        if (e.lengthComputable) {
+            const percentComplete = (e.loaded / e.total) * 100;
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+        }
+    });
+
+    uploadRequest.upload.addEventListener('load', async () => {
+        await updateSaveProgress(id)
+    });
+
+    uploadRequest.upload.addEventListener('error', () => {
+        showToast('❌ Upload failed', 'error');
+        setTimeout(() => window.location.reload(), 1000);
+    });
+
+    uploadRequest.send(formData);
+});
+
+cancelButton.addEventListener('click', () => {
+    if (uploadStep === 1) {
+        uploadRequest.abort();
+    } else if (uploadStep === 2) {
+        const data = { 'id': uploadID }
+        postJson('/api/cancelUpload', data)
+    }
+    showToast('Upload cancelled', 'info');
+    setTimeout(() => window.location.reload(), 1000);
+});
+
+async function updateSaveProgress(id) {
+    console.log('save progress')
+    progressBar.style.width = '0%';
+    uploadPercent.innerText = 'Progress : 0%'
+    document.getElementById('upload-status').innerText = 'Status: Processing File On Backend Server';
+
+    const interval = setInterval(async () => {
+        const response = await postJson('/api/getSaveProgress', { 'id': id })
+        const data = response['data']
+
+        if (data[0] === 'running') {
+            const current = data[1];
+            const total = data[2];
+            document.getElementById('upload-filesize').innerText = 'Filesize: ' + (total / (1024 * 1024)).toFixed(2) + ' MB';
+
+            const percentComplete = (current / total) * 100;
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+        }
+        else if (data[0] === 'completed') {
+            clearInterval(interval);
+            uploadPercent.innerText = 'Progress : 100%'
+            progressBar.style.width = '100%';
+
+            await handleUpload2(id)
+        }
+    }, 3000)
+
+}
+
+async function handleUpload2(id) {
+    console.log(id)
+    document.getElementById('upload-status').innerText = 'Status: Uploading To Telegram Server';
+    progressBar.style.width = '0%';
+    uploadPercent.innerText = 'Progress : 0%';
+
+    const interval = setInterval(async () => {
+        const response = await postJson('/api/getUploadProgress', { 'id': id })
+        const data = response['data']
+
+        if (data[0] === 'running') {
+            const current = data[1];
+            const total = data[2];
+            document.getElementById('upload-filesize').innerText = 'Filesize: ' + (total / (1024 * 1024)).toFixed(2) + ' MB';
+
+            let percentComplete
+            if (total === 0) {
+                percentComplete = 0
+            }
+            else {
+                percentComplete = (current / total) * 100;
+            }
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+        }
+        else if (data[0] === 'completed') {
+            clearInterval(interval);
+            showToast('✨ Upload completed successfully!', 'success');
+            setTimeout(() => window.location.reload(), 1000);
+        }
+    }, 3000)
+}
+
+// File Uploader End
+
+
+// URL Uploader Start
+
+async function get_file_info_from_url(url) {
+    const data = { 'url': url }
+    const json = await postJson('/api/getFileInfoFromUrl', data)
+    if (json.status === 'ok') {
+        return json.data
+    } else {
+        throw new Error(`Error Getting File Info : ${json.status}`)
+    }
+
+}
+
+async function start_file_download_from_url(url, filename, singleThreaded) {
+    const data = { 'url': url, 'path': getCurrentPath(), 'filename': filename, 'singleThreaded': singleThreaded }
+    const json = await postJson('/api/startFileDownloadFromUrl', data)
+    if (json.status === 'ok') {
+        return json.id
+    } else {
+        throw new Error(`Error Starting File Download : ${json.status}`)
+    }
+}
+
+async function download_progress_updater(id, file_name, file_size) {
+    uploadID = id;
+    uploadStep = 2
+    // Showing file uploader
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+    document.getElementById('file-uploader').style.zIndex = '3';
+    document.getElementById('file-uploader').style.opacity = '1';
+
+    document.getElementById('upload-filename').innerText = 'Filename: ' + file_name;
+    document.getElementById('upload-filesize').innerText = 'Filesize: ' + (file_size / (1024 * 1024)).toFixed(2) + ' MB';
+
+    const interval = setInterval(async () => {
+        const response = await postJson('/api/getFileDownloadProgress', { 'id': id })
+        const data = response['data']
+
+        if (data[0] === 'error') {
+            clearInterval(interval);
+            showToast('❌ Failed to download file from URL', 'error');
+            setTimeout(() => window.location.reload(), 1000);
+        }
+        else if (data[0] === 'completed') {
+            clearInterval(interval);
+            uploadPercent.innerText = 'Progress : 100%'
+            progressBar.style.width = '100%';
+            await handleUpload2(id)
+        }
+        else {
+            const current = data[1];
+            const total = data[2];
+
+            const percentComplete = (current / total) * 100;
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+
+            if (data[0] === 'Downloading') {
+                document.getElementById('upload-status').innerText = 'Status: Downloading File From Url To Backend Server';
+            }
+            else {
+                document.getElementById('upload-status').innerText = `Status: ${data[0]}`;
+            }
+        }
+    }, 3000)
+}
+
+
+async function Start_URL_Upload() {
+    try {
+        document.getElementById('new-url-upload').style.opacity = '0';
+        setTimeout(() => {
+            document.getElementById('new-url-upload').style.zIndex = '-1';
+        }, 300)
+
+        const file_url = document.getElementById('remote-url').value
+        const singleThreaded = document.getElementById('single-threaded-toggle').checked
+
+        const file_info = await get_file_info_from_url(file_url)
+        const file_name = file_info.file_name
+        const file_size = file_info.file_size
+
+        if (file_size > MAX_FILE_SIZE) {
+            throw new Error(`File size exceeds ${(MAX_FILE_SIZE / (1024 * 1024 * 1024)).toFixed(2)} GB limit`)
+        }
+
+        const id = await start_file_download_from_url(file_url, file_name, singleThreaded)
+
+        await download_progress_updater(id, file_name, file_size)
+
+    }
+    catch (err) {
+        showToast(`❌ ${err.message}`, 'error');
+        setTimeout(() => window.location.reload(), 1500);
+    }
+
+
+}
+
+// URL Uploader End

website/static/js/extra.js

@@ -0,0 +1,119 @@
+function getCurrentPath() {
+    const url = new URL(window.location.href);
+    const path = url.searchParams.get('path')
+    if (path === null) {
+        window.location.href = '/?path=/'
+        return 'redirect'
+    }
+    return path
+}
+
+function getFolderAuthFromPath() {
+    const url = new URL(window.location.href);
+    const auth = url.searchParams.get('auth')
+    return auth
+}
+
+// Changing sidebar section class
+if (getCurrentPath() !== '/') {
+    const sections = document.querySelector('.sidebar-menu').getElementsByTagName('a')
+    sections[0].setAttribute('class', 'unselected-item')
+
+    if (getCurrentPath().includes('/trash')) {
+        sections[1].setAttribute('class', 'selected-item')
+    }
+}
+
+function convertBytes(bytes) {
+    const kilobyte = 1024;
+    const megabyte = kilobyte * 1024;
+    const gigabyte = megabyte * 1024;
+
+    if (bytes >= gigabyte) {
+        return (bytes / gigabyte).toFixed(2) + ' GB';
+    } else if (bytes >= megabyte) {
+        return (bytes / megabyte).toFixed(2) + ' MB';
+    } else if (bytes >= kilobyte) {
+        return (bytes / kilobyte).toFixed(2) + ' KB';
+    } else {
+        return bytes + ' bytes';
+    }
+}
+
+const INPUTS = {}
+
+function validateInput(event) {
+    console.log('Validating Input')
+    const pattern = /^[a-zA-Z0-9 \-_\\[\]()@#!$%*+={}:;<>,.?/|\\~`]*$/;;
+    const input = event.target;
+    if (!pattern.test(input.value)) {
+        input.value = INPUTS[input.id]
+    } else {
+        INPUTS[input.id] = input.value
+    }
+}
+
+function getRootUrl() {
+    const url = new URL(window.location.href);
+    const protocol = url.protocol; // Get the protocol, e.g., "https:"
+    const hostname = url.hostname; // Get the hostname, e.g., "sub.example.com" or "192.168.1.1"
+    const port = url.port; // Get the port, e.g., "8080"
+
+    const rootUrl = `${protocol}//${hostname}${port ? ':' + port : ''}`;
+
+    return rootUrl;
+}
+
+function copyTextToClipboard(text) {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+        navigator.clipboard.writeText(text).then(function () {
+            showToast('🔗 Link copied to clipboard!', 'success');
+        }).catch(function (err) {
+            console.error('Could not copy text: ', err);
+            fallbackCopyTextToClipboard(text);
+        });
+    } else {
+        fallbackCopyTextToClipboard(text);
+    }
+}
+
+function fallbackCopyTextToClipboard(text) {
+    const textArea = document.createElement('textarea');
+    textArea.value = text;
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+
+    try {
+        const successful = document.execCommand('copy');
+        if (successful) {
+            showToast('🔗 Link copied to clipboard!', 'success');
+        } else {
+            showToast('Failed to copy the link', 'error');
+        }
+    } catch (err) {
+        console.error('Fallback: Oops, unable to copy', err);
+    }
+
+    document.body.removeChild(textArea);
+}
+
+function getPassword() {
+    return localStorage.getItem('password')
+}
+
+function getRandomId() {
+    const length = 6;
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+function removeSlash(text) {
+    let charactersToRemove = "[/]+"; // Define the characters to remove inside square brackets
+    let trimmedStr = text.replace(new RegExp(`^${charactersToRemove}|${charactersToRemove}$`, 'g'), '');
+    return trimmedStr;
+}

website/static/js/fileClickHandler.js

@@ -0,0 +1,222 @@
+function openFolder() {
+    let path = (getCurrentPath() + '/' + this.getAttribute('data-id') + '/').replaceAll('//', '/')
+
+    const auth = getFolderAuthFromPath()
+    if (auth) {
+        path = path + '&auth=' + auth
+    }
+    window.location.href = `/?path=${path}`
+}
+
+function openFile() {
+    const fileName = this.getAttribute('data-name').toLowerCase()
+    let path = '/file?path=' + this.getAttribute('data-path') + '/' + this.getAttribute('data-id')
+
+    if (fileName.endsWith('.mp4') || fileName.endsWith('.mkv') || fileName.endsWith('.webm') || fileName.endsWith('.mov') || fileName.endsWith('.avi') || fileName.endsWith('.ts') || fileName.endsWith('.ogv')) {
+        path = '/stream?url=' + getRootUrl() + path
+    }
+
+    window.open(path, '_blank')
+}
+
+
+// File More Button Handler Start
+
+function openMoreButton(div) {
+    const id = div.getAttribute('data-id')
+    const moreDiv = document.getElementById(`more-option-${id}`)
+
+    const rect = div.getBoundingClientRect();
+    const x = rect.left + window.scrollX - 40;
+    const y = rect.top + window.scrollY;
+
+    moreDiv.style.zIndex = 2
+    moreDiv.style.opacity = 1
+    moreDiv.style.left = `${x}px`
+    moreDiv.style.top = `${y}px`
+
+    const isTrash = getCurrentPath().includes('/trash')
+
+    moreDiv.querySelector('.more-options-focus').focus()
+    moreDiv.querySelector('.more-options-focus').addEventListener('blur', closeMoreBtnFocus);
+    moreDiv.querySelector('.more-options-focus').addEventListener('focusout', closeMoreBtnFocus);
+    if (!isTrash) {
+        moreDiv.querySelector(`#rename-${id}`).addEventListener('click', renameFileFolder)
+        moreDiv.querySelector(`#trash-${id}`).addEventListener('click', trashFileFolder)
+        try {
+            moreDiv.querySelector(`#share-${id}`).addEventListener('click', shareFile)
+        }
+        catch { }
+        try {
+            moreDiv.querySelector(`#folder-share-${id}`).addEventListener('click', shareFolder)
+        }
+        catch { }
+    }
+    else {
+        moreDiv.querySelector(`#restore-${id}`).addEventListener('click', restoreFileFolder)
+        moreDiv.querySelector(`#delete-${id}`).addEventListener('click', deleteFileFolder)
+    }
+}
+
+function closeMoreBtnFocus() {
+    const moreDiv = this.parentElement
+    moreDiv.style.opacity = '0'
+    setTimeout(() => {
+        moreDiv.style.zIndex = '-1'
+    }, 300)
+}
+
+// Rename File Folder Start
+function renameFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    console.log(id)
+
+    document.getElementById('rename-name').value = this.parentElement.getAttribute('data-name');
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+
+    document.getElementById('rename-file-folder').style.zIndex = '3';
+    document.getElementById('rename-file-folder').style.opacity = '1';
+    document.getElementById('rename-file-folder').setAttribute('data-id', id);
+    setTimeout(() => {
+        document.getElementById('rename-name').focus();
+    }, 300)
+}
+
+document.getElementById('rename-cancel').addEventListener('click', () => {
+    document.getElementById('rename-name').value = '';
+    document.getElementById('bg-blur').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('bg-blur').style.zIndex = '-1';
+    }, 300)
+    document.getElementById('rename-file-folder').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('rename-file-folder').style.zIndex = '-1';
+    }, 300)
+});
+
+document.getElementById('rename-create').addEventListener('click', async () => {
+    const name = document.getElementById('rename-name').value;
+    if (name === '') {
+        showToast('Name cannot be empty', 'error');
+        return
+    }
+
+    showLoading('Renaming...');
+    const id = document.getElementById('rename-file-folder').getAttribute('data-id')
+
+    const path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+
+    const data = {
+        'name': name,
+        'path': path
+    }
+
+    const response = await postJson('/api/renameFileFolder', data)
+    hideLoading();
+    if (response.status === 'ok') {
+        showToast('✨ Renamed successfully!', 'success');
+        setTimeout(() => window.location.reload(), 1000);
+    } else {
+        showToast('Failed to rename', 'error');
+        setTimeout(() => window.location.reload(), 1000);
+    }
+});
+
+
+// Rename File Folder End
+
+async function trashFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    console.log(id)
+    const path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+    const data = {
+        'path': path,
+        'trash': true
+    }
+    showLoading('Moving to trash...');
+    const response = await postJson('/api/trashFileFolder', data)
+    hideLoading();
+
+    if (response.status === 'ok') {
+        showToast('🗑️ Moved to trash', 'success');
+        setTimeout(() => window.location.reload(), 1000);
+    } else {
+        showToast('Failed to move to trash', 'error');
+        setTimeout(() => window.location.reload(), 1000);
+    }
+}
+
+async function restoreFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    const path = this.getAttribute('data-path') + '/' + id
+    const data = {
+        'path': path,
+        'trash': false
+    }
+    showLoading('Restoring...');
+    const response = await postJson('/api/trashFileFolder', data)
+    hideLoading();
+
+    if (response.status === 'ok') {
+        showToast('✅ Restored successfully', 'success');
+        setTimeout(() => window.location.reload(), 1000);
+    } else {
+        showToast('Failed to restore', 'error');
+        setTimeout(() => window.location.reload(), 1000);
+    }
+}
+
+async function deleteFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    const path = this.getAttribute('data-path') + '/' + id
+    const data = {
+        'path': path
+    }
+    showLoading('Deleting permanently...');
+    const response = await postJson('/api/deleteFileFolder', data)
+    hideLoading();
+
+    if (response.status === 'ok') {
+        showToast('🗑️ Deleted permanently', 'success');
+        setTimeout(() => window.location.reload(), 1000);
+    } else {
+        showToast('Failed to delete', 'error');
+        setTimeout(() => window.location.reload(), 1000);
+    }
+}
+
+async function shareFile() {
+    const fileName = this.parentElement.getAttribute('data-name').toLowerCase()
+    const id = this.getAttribute('id').split('-')[1]
+    const path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+    const root_url = getRootUrl()
+
+    let link
+    if (fileName.endsWith('.mp4') || fileName.endsWith('.mkv') || fileName.endsWith('.webm') || fileName.endsWith('.mov') || fileName.endsWith('.avi') || fileName.endsWith('.ts') || fileName.endsWith('.ogv')) {
+        link = `${root_url}/stream?url=${root_url}/file?path=${path}`
+    } else {
+        link = `${root_url}/file?path=${path}`
+
+    }
+
+    copyTextToClipboard(link)
+}
+
+
+async function shareFolder() {
+    const id = this.getAttribute('id').split('-')[2]
+    console.log(id)
+    let path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+    const root_url = getRootUrl()
+
+    const auth = await getFolderShareAuth(path)
+    path = path.slice(1)
+
+    let link = `${root_url}/?path=/share_${path}&auth=${auth}`
+    console.log(link)
+
+    copyTextToClipboard(link)
+}
+
+// File More Button Handler  End

website/static/js/main.js

@@ -0,0 +1,216 @@
+// Function removed - now handled by sorting.js
+
+document.getElementById('search-form').addEventListener('submit', async (event) => {
+    event.preventDefault();
+    const query = document.getElementById('file-search').value;
+    console.log(query)
+    if (query === '') {
+        showToast('Search field is empty', 'warning');
+        return;
+    }
+    const path = '/?path=/search_' + encodeURI(query);
+    console.log(path)
+    window.location = path;
+});
+
+// Loading Main Page
+
+document.addEventListener('DOMContentLoaded', function () {
+    const inputs = ['new-folder-name', 'rename-name', 'file-search']
+    for (let i = 0; i < inputs.length; i++) {
+        document.getElementById(inputs[i]).addEventListener('input', validateInput);
+    }
+
+    if (getCurrentPath().includes('/share_')) {
+        getCurrentDirectory()
+    } else {
+        if (getPassword() === null) {
+            document.getElementById('bg-blur').style.zIndex = '2';
+            document.getElementById('bg-blur').style.opacity = '0.1';
+
+            document.getElementById('get-password').style.zIndex = '3';
+            document.getElementById('get-password').style.opacity = '1';
+        } else {
+            getCurrentDirectory()
+        }
+    }
+
+    // Theme Toggle Logic
+    const themeBtn = document.getElementById('theme-toggle-btn');
+    const themeIcon = document.getElementById('theme-icon');
+    const body = document.body;
+
+    // Check local storage
+    if (localStorage.getItem('theme') === 'dark') {
+        body.classList.add('dark-mode');
+        updateIcon(true);
+    }
+
+    if (themeBtn) {
+        themeBtn.addEventListener('click', () => {
+            body.classList.toggle('dark-mode');
+            const isDark = body.classList.contains('dark-mode');
+            localStorage.setItem('theme', isDark ? 'dark' : 'light');
+            updateIcon(isDark);
+        });
+    }
+
+    function updateIcon(isDark) {
+        if (!themeIcon) return;
+        if (isDark) {
+            // Sun Icon (Material Design Wb_sunny 24px)
+            themeIcon.setAttribute("viewBox", "0 0 24 24");
+            themeIcon.innerHTML = '<path d="M12 7c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zM2 13h2c.55 0 1-.45 1-1s-.45-1-1-1H2c-.55 0-1 .45-1 1s.45 1 1 1zm18 0h2c.55 0 1-.45 1-1s-.45-1-1-1h-2c-.55 0-1 .45-1 1s.45 1 1 1zM11 2v2c0 .55.45 1 1 1s1-.45 1-1V2c0-.55-.45-1-1-1s-1 .45-1 1zm0 18v2c0 .55.45 1 1 1s1-.45 1-1v-2c0-.55-.45-1-1-1s-1 .45-1 1zM5.99 4.58c-.39-.39-1.03-.39-1.41 0-.39.39-.39 1.03 0 1.41l1.06 1.06c.39.39 1.03.39 1.41 0s.39-1.03 0-1.41L5.99 4.58zm12.37 12.37c-.39-.39-1.03-.39-1.41 0-.39.39-.39 1.03 0 1.41l1.06 1.06c.39.39 1.03.39 1.41 0 .39-.39.39-1.03 0-1.41l-1.06-1.06zm1.06-10.96c.39-.39.39-1.03 0-1.41-.39-.39-1.03-.39-1.41 0l-1.06 1.06c-.39.39-.39 1.03 0 1.41s1.03.39 1.41 0l1.06-1.06zM7.05 18.36c.39-.39.39-1.03 0-1.41-.39-.39-1.03-.39-1.41 0l-1.06 1.06c-.39.39-.39 1.03 0 1.41s1.03.39 1.41 0l1.06-1.06z"/>';
+        } else {
+            // Moon Icon (Original 24px)
+            themeIcon.setAttribute("viewBox", "0 0 24 24");
+            themeIcon.innerHTML = '<path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9 9-4.03 9-9c0-.46-.04-.92-.1-1.36-.98 1.37-2.58 2.26-4.4 2.26-2.98 0-5.4-2.42-5.4-5.4 0-1.81.89-3.42 2.26-4.4-.44-.06-.9-.1-1.36-.1z"/>';
+        }
+    }
+
+
+    // Sidebar Toggle Logic
+    const sidebarBtn = document.getElementById('sidebar-toggle-btn');
+    const container = document.querySelector('.container');
+    const sidebar = document.querySelector('.sidebar');
+
+    // Check local storage for sidebar state
+    if (localStorage.getItem('sidebar') === 'collapsed') {
+        container.classList.add('sidebar-collapsed');
+    }
+
+    if (sidebarBtn) {
+        sidebarBtn.addEventListener('click', () => {
+            // On mobile, toggle sidebar visibility
+            if (window.innerWidth <= 768) {
+                sidebar.classList.toggle('mobile-open');
+            } else {
+                // On desktop, use collapse
+                container.classList.toggle('sidebar-collapsed');
+                const isCollapsed = container.classList.contains('sidebar-collapsed');
+                localStorage.setItem('sidebar', isCollapsed ? 'collapsed' : 'expanded');
+            }
+        });
+    }
+    
+    // Close mobile sidebar when clicking outside
+    document.addEventListener('click', (e) => {
+        if (window.innerWidth <= 768) {
+            if (!sidebar.contains(e.target) && !sidebarBtn.contains(e.target)) {
+                sidebar.classList.remove('mobile-open');
+            }
+        }
+    });
+
+    // Request Movie Modal Logic
+    const requestBtn = document.getElementById('request-movie-btn');
+    const requestModal = document.getElementById('request-movie');
+    const requestCancel = document.getElementById('request-movie-cancel');
+    const requestFetch = document.getElementById('request-movie-fetch');
+    const requestSend = document.getElementById('request-movie-send');
+    const requestTitleInput = document.getElementById('request-movie-title');
+    const requestYearInput = document.getElementById('request-movie-year');
+    const requestInfoDiv = document.getElementById('request-movie-info');
+
+    function openRequestModal() {
+        document.getElementById('bg-blur').style.zIndex = '2';
+        document.getElementById('bg-blur').style.opacity = '0.1';
+        requestModal.style.zIndex = '3';
+        requestModal.style.opacity = '1';
+        requestTitleInput.focus();
+    }
+
+    function closeRequestModal() {
+        requestTitleInput.value = '';
+        requestYearInput.value = '';
+        requestInfoDiv.innerHTML = '';
+        document.getElementById('bg-blur').style.opacity = '0';
+        setTimeout(() => {
+            document.getElementById('bg-blur').style.zIndex = '-1';
+        }, 300);
+        requestModal.style.opacity = '0';
+        setTimeout(() => {
+            requestModal.style.zIndex = '-1';
+        }, 300);
+    }
+
+    if (requestBtn) {
+        requestBtn.addEventListener('click', openRequestModal);
+    }
+
+    if (requestCancel) {
+        requestCancel.addEventListener('click', closeRequestModal);
+    }
+
+    if (requestFetch) {
+        requestFetch.addEventListener('click', async () => {
+            const title = requestTitleInput.value.trim();
+            const year = requestYearInput.value.trim();
+            if (!title) {
+                showToast('Movie title is required', 'warning');
+                return;
+            }
+            showLoading('Fetching from TMDB...');
+            const res = await tmdbSearchMovie(title, year);
+            hideLoading();
+            if (res.status === 'ok' && res.data) {
+                const m = res.data;
+                const y = m.year || '';
+                requestTitleInput.value = m.title || title;
+                if (y) {
+                    requestYearInput.value = y;
+                }
+                requestInfoDiv.innerHTML = `
+                    <strong>${m.title || ''} (${y})</strong><br>
+                    <small>${m.overview || 'No overview available.'}</small>
+                `;
+                showToast('TMDB result loaded', 'success');
+            } else if (res.status === 'no_results') {
+                requestInfoDiv.innerHTML = '<small>No results found on TMDB.</small>';
+                showToast('No TMDB results found', 'warning');
+            } else if (res.status === 'TMDB not configured') {
+                requestInfoDiv.innerHTML = '<small>TMDB API key not configured on server.</small>';
+                showToast('TMDB not configured on server', 'error');
+            } else {
+                requestInfoDiv.innerHTML = `<small>Error: ${res.status}</small>`;
+                showToast('Failed to fetch from TMDB', 'error');
+            }
+        });
+    }
+
+    if (requestSend) {
+        requestSend.addEventListener('click', async () => {
+            const title = requestTitleInput.value.trim();
+            const year = requestYearInput.value.trim();
+            if (!title || !year) {
+                showToast('Title and year are required', 'warning');
+                return;
+            }
+            showLoading('Requesting movie...');
+            const res = await requestMovie(title, year);
+            hideLoading();
+
+            if (res.status === 'available' && res.file) {
+                const root = getRootUrl();
+                const path = res.file.path;
+                const isVideo = res.file.is_video;
+                let link;
+                if (isVideo) {
+                    link = `${root}/stream?url=${root}/file?path=${path}`;
+                } else {
+                    link = `${root}/file?path=${path}`;
+                }
+                copyTextToClipboard(link);
+                showToast('✅ Movie available. Link copied to clipboard!', 'success');
+                closeRequestModal();
+            } else if (res.status === 'not_found') {
+                showToast('Movie not available yet. Request saved.', 'info');
+                closeRequestModal();
+            } else if (res.status === 'Invalid password') {
+                showToast('Invalid admin password. Please login again.', 'error');
+            } else {
+                showToast(`Failed to request movie: ${res.status}`, 'error');
+            }
+        });
+    }
+});