1.8.5

.gitignore

@@ -0,0 +1,21 @@
+config.env
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        git \
+        build-essential \
+        libssl-dev \
+    && apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+
+RUN pip install --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["python", "-m", "Thunder"]

LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org>

Procfile

@@ -0,0 +1 @@
+web: python -m Thunder

README.md

@@ -0,0 +1,471 @@
+<p align="center">
+  <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/Thunder.jpg?text=Thunder" alt="Thunder Logo" width="120">
+  <h1 align="center">⚡ Thunder</h1>
+</p>
+
+<p align="center">
+  <b>High-performance Telegram File to Link Bot</b>
+</p>
+
+<p align="center">
+  <a href="https://github.com/fyaz05/FileToLink">
+    <img src="https://img.shields.io/badge/version-1.8.0-blue" alt="Version">
+  </a>
+  <a href="https://www.python.org/">
+    <img src="https://img.shields.io/badge/python-3.13%2B-brightgreen" alt="Python">
+  </a>
+  <a href="https://github.com/KurimuzonAkuma/pyrogram/">
+    <img src="https://img.shields.io/badge/kurigram-blue" alt="Kurigram">
+  </a>
+  <a href="LICENSE">
+    <img src="https://img.shields.io/github/license/fyaz05/FileToLink.svg?color=brightgreen" alt="License">
+  </a>
+</p>
+
+<hr>
+
+<p align="center">
+  <a href="#about-the-project">ℹ️ About</a> •
+  <a href="#-features">✨ Features</a> •
+  <a href="#-how-it-works">🔍 How It Works</a> •
+  <a href="#-prerequisites">📋 Prerequisites</a> •
+  <a href="#-configuration">⚙️ Configuration</a> •
+  <a href="#-deployment">📦 Deployment</a> •
+  <a href="#-usage">📱 Usage</a> •
+  <a href="#-commands">⌨️ Commands</a>
+</p>
+
+<hr>
+
+## ℹ️ About The Project
+
+> **Thunder** is a powerful, high-performance Telegram bot that transforms media files into streamable direct links. Share and access files via HTTP(S) links instead of downloading from Telegram, for a seamless media experience.
+
+**Perfect for:**
+
+- 📤 Download Telegram media at high speed.
+- 🎬 Content creators sharing media files.
+- 👥 Communities distributing resources.
+- 🎓 Educational platforms sharing materials.
+- 🌍 Anyone needing to share Telegram media.
+
+---
+
+## ✨ Features
+
+### 🚀 Core Functionality
+
+- **Generate Direct Links:** Convert Telegram media files into direct streaming links.
+- **Permanent Links:** Links remain active as long as the file exists in the storage channel.
+- **Multi-Client Support:** Distribute workload across multiple Telegram accounts.
+- **HTTP/HTTPS Streaming:** Stream media with custom player support for all devices and browsers.
+
+### 🧩 Advanced Features
+
+- **MongoDB Integration:** Store user data and file info with advanced database capabilities.
+- **User Authentication:** Require users to join channels before generating links.
+- **Admin Commands:** Manage users and control bot behavior.
+- **Custom Domain Support:** Use your own domain for streaming links.
+- **Customizable Templates:** Personalize HTML templates for download pages.
+
+### ⚙️ Technical Capabilities
+
+- **Asynchronous Architecture:** Built with aiohttp and asyncio for high concurrency.
+- **Rate Limiting:** Prevent abuse with advanced rate-limiting.
+- **Media Info Display:** Show file size, duration, format, and more.
+- **Multiple File Types:** Supports videos, audio, documents, images, stickers, and more.
+- **Forwarding Control:** Restrict or allow file forwarding.
+- **Caching System:** Reduce Telegram API calls and improve responsiveness.
+
+---
+
+## 🔍 How It Works
+
+1. **Upload:** User sends a media file to the bot. The bot forwards it to a storage channel and stores metadata.
+2. **Link Generation:** A unique, secure link is generated and sent to the user.
+3. **Streaming:** When the link is opened, the server authenticates, retrieves the file from Telegram, and streams it directly to the browser.
+4. **Load Balancing:** Multiple Telegram clients distribute workload, with automatic switching and smart queuing for high traffic.
+
+---
+
+## 📋 Prerequisites
+
+- 🐍 Python 3.13 or higher
+- 🍃 MongoDB
+- 🔑 Telegram API ID and Hash ([my.telegram.org/apps](https://my.telegram.org/apps))
+- 🤖 Bot Token from [@BotFather](https://t.me/BotFather)
+- 🌐 Server with public IP or domain
+- 📦 Telegram storage channel
+
+---
+
+## ⚙️ Configuration
+
+Rename `config_sample.env` to `config.env` and edit the following variables:
+
+### Required
+
+| Variable         | Description                                 | Example                                 |
+|------------------|---------------------------------------------|-----------------------------------------|
+| `API_ID`         | Telegram API ID from my.telegram.org         | `12345`                                 |
+| `API_HASH`       | Telegram API Hash from my.telegram.org       | `abc123def456`                          |
+| `BOT_TOKEN`      | Bot token from @BotFather                   | `123456789:ABCdefGHIjklMNOpqrsTUVwxyz`  |
+| `BIN_CHANNEL`    | Channel ID for storing files (add bot as admin) | `-1001234567890`                    |
+| `OWNER_ID`       | Your Telegram user ID(s) (space-separated)   | `12345678 87654321`                     |
+| `OWNER_USERNAME` | Your Telegram username (without @)           | `yourusername`                          |
+| `FQDN`           | Your domain name or server IP                | `files.yourdomain.com`                  |
+| `HAS_SSL`        | Set to "True" if using HTTPS                | `True` or `False`                       |
+| `PORT`           | Web server port                              | `8080`                                  |
+| `NO_PORT`        | Hide port in URLs                            | `True` or `False`                       |
+
+### Optional
+
+| Variable             | Description                              | Default   | Example                       |
+|----------------------|------------------------------------------|-----------|-------------------------------|
+| `MULTI_BOT_TOKENS`   | Additional bot tokens for load balancing | *(empty)* | `MULTI_TOKEN1=`              |
+| `FORCE_CHANNEL_ID`   | Channel ID users must join               | *(empty)* | `-1001234567890`              |
+| `BANNED_CHANNELS`    | Space-separated banned channel IDs       | *(empty)* | `-1001234567890 -100987654321`|
+| `SLEEP_THRESHOLD`    | Threshold for client switching           | `60`      | `30`                          |
+| `WORKERS`            | Number of async workers                  | `100`     | `200`                         |
+| `DATABASE_URL`       | MongoDB connection string                | *(empty)* | `mongodb+srv://user:pass@host/db` |
+| `NAME`               | Bot application name                     | `ThunderF2L` | `MyFileBot`                |
+| `BIND_ADDRESS`       | Address to bind web server               | `0.0.0.0` | `127.0.0.1`                   |
+| `PING_INTERVAL`      | Ping interval in seconds                 | `840`     | `1200`                        |
+| `CACHE_SIZE`         | Cache size in MB                         | `100`     | `200`                         |
+| `TOKEN_ENABLED`      | Enable token authentication system      | `False`   | `True`                         |
+| `SHORTEN_ENABLED`    | Enable URL shortening for tokens        | `False`   | `True`                         |
+| `SHORTEN_MEDIA_LINKS`| Enable URL shortening for media links   | `False`   | `True`                         |
+| `URL_SHORTENER_API_KEY` | API key for URL shortening service    | `""`      | `"abc123def456"`               |
+| `URL_SHORTENER_SITE` | URL shortening service to use           | `""`      | `"example.com"`                  |
+
+> ℹ️ For all options, see `config_sample.env`.
+
+---
+
+## 📦 Deployment
+
+### Using Docker (Recommended)
+
+```bash
+# Ensure you have configured config.env as per the Configuration section
+# Build and run with Docker
+docker build -t Thunder .
+docker run -d --name Thunder -p 8080:8080 Thunder
+```
+
+### Manual Installation
+
+```bash
+# Ensure you have completed the "Getting Started" and "Configuration" sections
+# Run the bot
+python -m Thunder
+```
+
+### ⚡ Scaling for High Traffic
+
+- Use multiple bot instances.
+- Increase `WORKERS` in `config.env` based on your server's capabilities.
+
+---
+
+## 📱 Usage
+
+### Basic
+
+1. **Start:** Send `/start` to your bot.
+2. **Authenticate:** Join required channels if configured by the admin.
+3. **Token Authentication:** If token system is enabled, you'll need a valid token to use the bot. When you try to use a feature requiring authorization, the bot will automatically generate a token for you with an activation link.
+4. **Upload:** Send any media file to the bot.
+5. **Get Link:** Receive a direct streaming link.
+6. **Share:** Anyone with the link can stream or download the file.
+
+### Advanced
+
+- **Batch Processing:** Forward multiple files to the bot for batch link generation.
+- **Custom Thumbnails:** Send a photo with `/set_thumbnail` as its caption to set a custom thumbnail for subsequent files.
+- **Remove Thumbnail:** Use `/del_thumbnail` to remove a previously set custom thumbnail.
+- **User Settings:** Users might have access to a settings menu (if implemented) to configure preferences.
+
+---
+
+## ⌨️ Commands
+
+### User Commands
+
+| Command   | Description |
+|-----------|-------------|
+| `/start`  | Start the bot and get a welcome message. Also used for token activation. |
+| `/link`   | Generate a direct link for a file in a group. Supports batch files by replying to the first file in a group (e.g., `/link 5`). |
+| `/dc`     | Get the data center (DC) of a user or file. Use `/dc id`, or reply to a file or user. Works in both groups and private chats. |
+| `/ping`   | Check if the bot is online and measure response time. |
+| `/about`  | Get information about the bot. |
+| `/help`   | Show help and usage instructions. |
+
+### Admin Commands (for Bot Owner)
+
+| Command        | Description                                                          |
+|----------------|----------------------------------------------------------------------|
+| `/status`      | Check bot status, uptime, and resource usage.                        |
+| `/broadcast`   | Send a message to all users (supports text, media, buttons).         |
+| `/stats`       | View usage statistics and analytics.                                 |
+| `/ban`         | Ban a user (reply to message or use user ID).                        |
+| `/unban`       | Unban a user.                                                        |
+| `/log`         | Send bot logs.                                                       |
+| `/restart`     | Restart the bot.                                                     |
+| `/shell`       | Execute a shell command (Use with extreme caution!).                 |
+| `/users`       | Show total number of users.                                          |
+| `/authorize`   | Permanently authorize a user to use the bot (bypasses token system). |
+| `/unauthorize` | Remove permanent authorization from a user.                          |
+| `/listauth`    | List all permanently authorized users.                              |
+
+### Commands for @BotFather
+
+Paste the following into the BotFather "Edit Commands" section for your bot:
+
+```text
+start - Start the bot and get a welcome message
+link - Generate a direct link for a file (supports batch in groups)
+dc - Get the data center (DC) of a user or file
+ping - Check if the bot is online
+about - Get information about the bot
+help - Show help and usage instructions
+status - (Admin) Check bot status, uptime, and resource usage
+broadcast - (Admin) Send a message to all users
+stats - (Admin) View usage statistics and analytics
+ban - (Admin) Ban a user
+unban - (Admin) Unban a user
+log - (Admin) Send bot logs
+restart - (Admin) Restart the bot
+shell - (Admin) Execute a shell command
+users - (Admin) Show total number of users
+authorize - (Admin) Grant permanent access to a user
+unauthorize - (Admin) Remove permanent access from a user
+listauth - (Admin) List all authorized users
+```
+
+---
+
+## 🔑 Token System
+
+Thunder Bot includes an optional token-based access control system that allows admins to control who can use the bot.
+
+### How It Works
+
+1. Enable the token system by setting `TOKEN_ENABLED=True` in your config.
+2. Users without a valid token will receive an "Access Denied" message when trying to use the bot
+3. Admins can authorize users permanently, or users receive automatically generated tokens
+
+### Admin Commands
+
+| Command | Description |
+|---------|-------------|
+| `/authorize <user_id>` | Grant a user permanent access to the bot |
+| `/deauthorize <user_id>` | Remove a user's permanent access |
+| `/listauth` | List all permanently authorized users |
+
+---
+
+<details>
+<summary><b>Reverse Proxy with Cloudflare SSL</b></summary>
+
+## Reverse Proxy Setup for File Streaming Bot with Cloudflare SSL
+ 
+This guide will help you set up a secure reverse proxy using **NGINX** for your file streaming bot with **Cloudflare SSL protection**.
+
+---
+
+## ✅ What You Need
+
+- A **VPS or server** running Ubuntu/Debian with NGINX installed
+- Your **file streaming bot** running on a local port (e.g., `5063`)
+- A **subdomain** (e.g., `dl.yoursite.com`) set up in **Cloudflare**
+- **Cloudflare Origin Certificate** files:
+  - `cert.pem` (Certificate file)
+  - `key.key` (Private key file)
+
+---
+
+## 🔐 Step 1: Configure Cloudflare
+
+**Set up DNS:**
+- Go to your domain in [Cloudflare Dashboard](https://dash.cloudflare.com)
+- Navigate to **DNS** → Add an `A` record:
+  - **Name:** `dl` (or your preferred subdomain)
+  - **Content:** Your server's IP address
+  - **Proxy Status:** **Proxied (orange cloud)**
+
+**Configure SSL:**
+- Go to **SSL/TLS** → **Overview**
+- Set encryption mode to **Full (strict)**
+- Create your **Origin Certificate** if you haven't already
+
+---
+
+## 🛡️ Step 2: Set Up SSL Certificates
+
+Create a folder for your SSL certificates:
+
+```bash
+sudo mkdir -p /etc/ssl/cloudflare/dl.yoursite.com
+```
+
+**If you have the certificate files already:**
+```bash
+sudo mv cert.pem key.key /etc/ssl/cloudflare/dl.yoursite.com/
+```
+
+**If you need to create them:**
+```bash
+# Create certificate file
+sudo nano /etc/ssl/cloudflare/dl.yoursite.com/cert.pem
+# Paste your Origin Certificate here and save
+
+# Create private key file  
+sudo nano /etc/ssl/cloudflare/dl.yoursite.com/key.key
+# Paste your Private Key here and save
+```
+
+**Make the files secure:**
+```bash
+sudo chmod 600 /etc/ssl/cloudflare/dl.yoursite.com/key.key
+sudo chmod 644 /etc/ssl/cloudflare/dl.yoursite.com/cert.pem
+```
+
+---
+
+## 🛠️ Step 3: Create NGINX Configuration
+
+Create a new configuration file:
+```bash
+sudo nano /etc/nginx/sites-available/dl.yoursite.conf
+```
+
+**Paste this configuration** (replace `dl.yoursite.com` and `5063` with your values):
+
+```nginx
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+    server_name dl.yoursite.com;
+
+    # SSL Configuration
+    ssl_certificate     /etc/ssl/cloudflare/dl.yoursite.com/cert.pem;
+    ssl_certificate_key /etc/ssl/cloudflare/dl.yoursite.com/key.key;
+
+    # Basic security
+    add_header X-Frame-Options DENY;
+    add_header X-Content-Type-Options nosniff;
+
+    # Logging
+    access_log /var/log/nginx/dl.yoursite.com.access.log;
+    error_log /var/log/nginx/dl.yoursite.com.error.log;
+
+    location / {
+        # Forward requests to your bot
+        proxy_pass http://localhost:5063;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        
+        # Settings for file streaming
+        proxy_buffering off;
+        proxy_request_buffering off;
+        
+        # Allow large files
+        client_max_body_size 0;
+    }
+}
+
+# Redirect HTTP to HTTPS
+server {
+    listen 80;
+    listen [::]:80;
+    server_name dl.yoursite.com;
+    
+    return 301 https://$host$request_uri;
+}
+```
+
+**Enable the configuration:**
+```bash
+sudo ln -s /etc/nginx/sites-available/dl.yoursite.conf /etc/nginx/sites-enabled/
+```
+
+---
+
+## 🔄 Step 4: Test and Apply Changes
+
+**Check if configuration is correct:**
+```bash
+sudo nginx -t
+```
+
+**If no errors, restart NGINX:**
+```bash
+sudo systemctl reload nginx
+```
+
+---
+
+## ✅ Step 5: Test Your Setup
+
+**Test if your site is working:**
+```bash
+curl -I https://dl.yoursite.com
+```
+
+**Test a file download:**
+```bash
+curl -I https://dl.yoursite.com/dl/<your_file_id>
+```
+
+---
+
+## 🎉 Done!
+
+Your reverse proxy is now securely streaming files behind Cloudflare, powered by NGINX!
+
+</details>
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please follow these steps:
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`).
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`).
+4. Push to the branch (`git push origin feature/AmazingFeature`).
+5. Open a Pull Request.
+
+---
+
+## 📄 License
+
+This repository is unlicensed and provided as-is without any warranty. No permission is granted to use, copy, modify, or distribute this software for any purpose.
+
+---
+
+## 👏 Acknowledgements
+
+- [Kurigram](https://github.com/KurimuzonAkuma/pyrogram/) – Telegram MTProto API Client Library
+- [AIOHTTP](https://github.com/aio-libs/aiohttp) – Async HTTP client/server framework
+- [Motor](https://github.com/mongodb/motor) – Async MongoDB driver
+- [TgCrypto](https://github.com/pyrogram/tgcrypto) – Fast cryptography library for Telegram
+- All contributors who have helped improve the project.
+
+---
+
+## 📢 Disclaimer
+
+> This project is not affiliated with Telegram. Use at your own risk and responsibility.
+> Comply with Telegram's Terms of Service and your local regulations regarding content distribution.
+
+---
+
+<p align="center">
+  ⭐ <b>Like this project? Give it a star!</b> ⭐<br>
+  🐛 <b>Found a bug or have a feature request?</b> <a href="https://github.com/fyaz05/FileToLink/issues/new">Open an issue</a>
+</p>

Thunder/__init__.py

@@ -0,0 +1,9 @@
+# Thunder/__init__.py
+
+import time
+
+# Record the start time of the module
+StartTime = time.time()
+
+# Define the version
+__version__ = "1.8.5"

Thunder/__main__.py

@@ -0,0 +1,182 @@
+# Thunder/__main__.py
+
+import os
+import sys
+import glob
+import asyncio
+import importlib.util
+from pathlib import Path
+from datetime import datetime
+
+from pyrogram import idle
+from aiohttp import web
+from Thunder import __version__
+from Thunder.bot import StreamBot
+from Thunder.vars import Var
+from Thunder.server import web_server
+from Thunder.utils.keepalive import ping_server
+from Thunder.bot.clients import initialize_clients
+from Thunder.utils.logger import logger
+from Thunder.utils.database import db
+from Thunder.utils.messages import MSG_ADMIN_RESTART_DONE
+
+
+# Constants
+PLUGIN_PATH = "Thunder/bot/plugins/*.py"
+VERSION = __version__
+
+
+def print_banner():
+    """Print a visually appealing banner at startup."""
+    banner = f"""
+╔═══════════════════════════════════════════════════════════════════╗
+║                                                                   ║
+║   ████████╗██╗  ██╗██╗   ██╗███╗   ██╗██████╗ ███████╗██████╗     ║
+║   ╚══██╔══╝██║  ██║██║   ██║████╗  ██║██╔══██╗██╔════╝██╔══██╗    ║
+║      ██║   ███████║██║   ██║██╔██╗ ██║██║  ██║█████╗  ██████╔╝    ║
+║      ██║   ██╔══██║██║   ██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗    ║
+║      ██║   ██║  ██║╚██████╔╝██║ ╚████║██████╔╝███████╗██║  ██║    ║
+║      ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝    ║
+║                                                                   ║
+║                  File Streaming Bot v{VERSION}                        ║
+╚═══════════════════════════════════════════════════════════════════╝
+    """
+    logger.info(banner)
+
+
+async def import_plugins():
+    """Import all plugins from the plugins directory."""
+    logger.info("╔══════════════════ IMPORTING PLUGINS ═══════════════════╗")
+    plugins = glob.glob(PLUGIN_PATH)
+    
+    if not plugins:
+        logger.warning("No plugins found to import!")
+        return 0
+    
+    success_count = 0
+    failed_plugins = []
+    
+    for file_path in plugins:
+        try:
+            plugin_path = Path(file_path)
+            plugin_name = plugin_path.stem
+            import_path = f"Thunder.bot.plugins.{plugin_name}"
+            
+            spec = importlib.util.spec_from_file_location(import_path, plugin_path)
+            if spec is None or spec.loader is None:
+                logger.error(f"Invalid plugin specification for {plugin_name}")
+                failed_plugins.append(plugin_name)
+                continue
+                
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[import_path] = module
+            spec.loader.exec_module(module)
+            
+            success_count += 1
+            logger.info(f"▶ Successfully imported: {plugin_name}")
+        except Exception as e:
+            plugin_name = Path(file_path).stem
+            logger.error(f"✖ Failed to import plugin {plugin_name}: {e}")
+            failed_plugins.append(plugin_name)
+    
+    logger.info(f"▶ Total: {len(plugins)} | Success: {success_count} | Failed: {len(failed_plugins)}")
+    
+    if failed_plugins:
+        logger.warning(f"▶ Failed plugins: {', '.join(failed_plugins)}")
+        
+    logger.info("╚════════════════════════════════════════════════════════╝")
+    return success_count
+
+
+async def start_services():
+    """Initialize and start all essential services for the bot."""
+    start_time = datetime.now()
+    
+    print_banner()
+    
+    logger.info("╔══════════════ INITIALIZING BOT SERVICES ═══════════════╗")
+    # Initialize Telegram Bot
+    logger.info("▶ Starting Telegram Bot initialization...")
+    try:
+        await StreamBot.start()
+        bot_info = await StreamBot.get_me()
+        StreamBot.username = bot_info.username
+        logger.info(f"✓ Bot initialized successfully as @{StreamBot.username}")
+
+        # Check for restart message
+        restart_message_data = await db.get_restart_message()
+        if restart_message_data:
+            logger.debug(f"Found restart message: {restart_message_data}")
+            try:
+                await StreamBot.edit_message_text(
+                    chat_id=restart_message_data["chat_id"],
+                    message_id=restart_message_data["message_id"],
+                    text=MSG_ADMIN_RESTART_DONE
+                )
+                await db.delete_restart_message(restart_message_data["message_id"])
+                logger.debug("Restart message updated and deleted from DB.")
+            except Exception as e:
+                logger.error(f"Error processing restart message: {e}")
+        else:
+            logger.debug("No restart message found, starting normally.")
+
+    except Exception as e:
+        logger.error(f"✖ Failed to initialize Telegram Bot: {e}")
+        return
+    
+    # Initialize Clients
+    logger.info("▶ Starting Client initialization...")
+    try:
+        await initialize_clients()
+        logger.info("✓ Clients initialized successfully")
+    except Exception as e:
+        logger.error(f"✖ Failed to initialize clients: {e}")
+        return
+    # Import Plugins
+    await import_plugins()
+    
+    # Initialize Web Server
+    logger.info("▶ Starting Web Server initialization...")
+    try:
+        app_runner = web.AppRunner(await web_server())
+        await app_runner.setup()
+        bind_address = Var.BIND_ADDRESS
+        site = web.TCPSite(app_runner, bind_address, Var.PORT)
+        await site.start()
+        logger.info(f"✓ Web Server started at {bind_address}:{Var.PORT}")
+        
+        # Start keep-alive ping service
+        logger.info("▶ Starting keep-alive service...")
+        asyncio.create_task(ping_server())
+        logger.info("✓ Keep-alive service started")
+    except Exception as e:
+        logger.error(f"✖ Failed to start Web Server: {e}")
+        return
+    
+    # Print completion message
+    elapsed_time = (datetime.now() - start_time).total_seconds()
+    logger.info("╠════════════════════════════════════════════════════════╣")
+    logger.info(f"▶ Bot Name: {bot_info.first_name}")
+    logger.info(f"▶ Username: @{bot_info.username}")
+    logger.info(f"▶ Server: {bind_address}:{Var.PORT}")
+    logger.info(f"▶ Owner: {Var.OWNER_USERNAME}")
+    logger.info(f"▶ Startup Time: {elapsed_time:.2f} seconds")
+    logger.info("╚════════════════════════════════════════════════════════╝")
+    logger.info("▶ Bot is now running! Press CTRL+C to stop.")
+    
+    # Keep the bot running
+    await idle()
+
+
+if __name__ == '__main__':
+    loop = asyncio.get_event_loop()
+    try:
+        loop.run_until_complete(start_services())
+    except KeyboardInterrupt:
+        logger.info("╔═══════════════════════════════════════════════════════╗")
+        logger.info("║              Bot stopped by user (CTRL+C)             ║")
+        logger.info("╚═══════════════════════════════════════════════════════╝")
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+    finally:
+        loop.close()

Thunder/bot/__init__.py

@@ -0,0 +1,23 @@
+# Thunder/bot/__init__.py
+
+from pyrogram import Client
+import pyromod.listen
+from Thunder.vars import Var
+from os import getcwd
+from Thunder.utils.logger import logger
+
+# Initialize the main bot client
+StreamBot = Client(
+    name="Web Streamer",
+    api_id=Var.API_ID,
+    api_hash=Var.API_HASH,
+    bot_token=Var.BOT_TOKEN,
+    sleep_threshold=Var.SLEEP_THRESHOLD,
+    workers=Var.WORKERS
+)
+
+# Dictionary to hold multiple client instances if needed
+multi_clients = {}
+
+# Dictionary to manage workloads and distribution across clients
+work_loads = {}

Thunder/bot/clients.py

@@ -0,0 +1,89 @@
+# Thunder/bot/clients.py
+
+import asyncio
+from pyrogram import Client
+from Thunder.vars import Var
+from Thunder.utils.config_parser import TokenParser
+from Thunder.bot import multi_clients, work_loads, StreamBot
+from Thunder.utils.logger import logger
+
+
+async def initialize_clients():
+    """Initializes multiple Pyrogram client instances based on tokens found in the environment."""
+    
+    logger.info("╔═══════════════ INITIALIZING PRIMARY CLIENT ═══════════════╗")
+    multi_clients[0] = StreamBot
+    work_loads[0] = 0
+    logger.info("✓ Primary client initialized successfully")
+    logger.info("╚═══════════════════════════════════════════════════════════╝")
+    
+    # Parse tokens from the environment
+    logger.info("╔═══════════════ PARSING ADDITIONAL TOKENS ═════════════════╗")
+    try:
+        all_tokens = TokenParser().parse_from_env()
+        if not all_tokens:
+            logger.info("▶ No additional clients found. Default client will be used.")
+            logger.info("╚═══════════════════════════════════════════════════════════╝")
+            return
+    except Exception as e:
+        logger.error(f"▶ Error parsing additional tokens: {e}")
+        logger.info("▶ Default client will be used.")
+        logger.info("╚═══════════════════════════════════════════════════════════╝")
+        return
+
+    logger.info(f"▶ Found {len(all_tokens)} additional tokens")
+    logger.info("╚═══════════════════════════════════════════════════════════╝")
+
+    async def start_client(client_id, token):
+        """Starts an individual Pyrogram client."""
+        try:
+            logger.info(f"▶ Initializing Client ID: {client_id}...")
+            if client_id == len(all_tokens):
+                await asyncio.sleep(2)
+                logger.info("▶ This is the last client. Initialization may take a while, please wait...")
+
+            client = await Client(
+                name=str(client_id),
+                api_id=Var.API_ID,
+                api_hash=Var.API_HASH,
+                bot_token=token,
+                sleep_threshold=Var.SLEEP_THRESHOLD,
+                no_updates=True,
+                in_memory=True
+            ).start()
+            work_loads[client_id] = 0
+            logger.info(f"✓ Client ID {client_id} started successfully")
+            return client_id, client
+        except Exception as e:
+            logger.error(f"✖ Failed to start Client ID {client_id}. Error: {e}")
+            return None
+
+    # Start all clients concurrently and filter out any that failed
+    logger.info("╔═════════════ STARTING ADDITIONAL CLIENTS ═════════════════╗")
+    clients = await asyncio.gather(*[start_client(i, token) for i, token in all_tokens.items() if token])
+    clients = [client for client in clients if client]  # Filter out None values
+
+    # Update the global multi_clients dictionary
+    multi_clients.update(dict(clients))
+    
+    if len(multi_clients) > 1:
+        Var.MULTI_CLIENT = True
+        logger.info("╔════════════════ MULTI-CLIENT SUMMARY ══════════════════╗")
+        logger.info(f"✓ Multi-Client Mode Enabled")
+        logger.info(f"✓ Total Clients: {len(multi_clients)} (Including primary client)")
+        
+        # Display workload distribution
+        logger.info("▶ Initial workload distribution:")
+        for client_id, load in work_loads.items():
+            logger.info(f"  • Client {client_id}: {load} tasks")
+            
+        logger.info("╚════════════════════════════════════════════════════════╝")
+    else:
+        logger.info("╔════════════════════════════════════════════════════════╗")
+        logger.info("▶ No additional clients were initialized")
+        logger.info("▶ Default client will handle all requests")
+        logger.info("╚════════════════════════════════════════════════════════╝")
+
+    logger.info("╔════════════════════════════════════════════════════════╗")
+    logger.info("✓ Client initialization completed successfully")
+    logger.info("╚════════════════════════════════════════════════════════╝")

Thunder/bot/plugins/admin.py

@@ -0,0 +1,557 @@
+"""
+Thunder/bot/plugins/admin.py - Administrative commands and functionality
+"""
+
+import os
+import sys
+import time
+import asyncio
+import shutil
+import psutil
+import random
+import string
+import html
+import uuid
+
+from datetime import datetime
+from typing import List, Dict
+
+from pyrogram.client import Client
+from pyrogram import filters, StopPropagation
+from pyrogram.enums import ParseMode
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+    LinkPreviewOptions
+)
+from pyrogram.errors import (
+    FloodWait,
+    UserDeactivated,
+    ChatWriteForbidden,
+    UserIsBlocked,
+    PeerIdInvalid,
+    FileReferenceExpired,
+    FileReferenceInvalid
+)
+
+from Thunder.bot import StreamBot, multi_clients, work_loads
+from Thunder.vars import Var
+from Thunder import StartTime, __version__
+from Thunder.utils.human_readable import humanbytes
+from Thunder.utils.time_format import get_readable_time
+from Thunder.utils.logger import logger, LOG_FILE
+from Thunder.utils.tokens import authorize, deauthorize, list_allowed
+from Thunder.utils.database import db
+from Thunder.utils.messages import *
+
+broadcast_ids = {}
+MAX_CONCURRENT_TASKS = 10
+
+def generate_unique_id(length=6):
+    while True:
+        random_id = ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+        if random_id not in broadcast_ids:
+            return random_id
+
+async def get_users_in_batches(batch_size=100):
+    users_cursor = await db.get_all_users()
+    current_batch = []
+    async for user in users_cursor:
+        current_batch.append(user)
+        if len(current_batch) >= batch_size:
+            yield current_batch
+            current_batch = []
+    if current_batch:
+        yield current_batch
+
+async def handle_broadcast_completion(message, output, failures, successes, total_users, start_time, broadcast_id):
+    elapsed_time = get_readable_time(time.time() - start_time)
+    try:
+        await output.delete()
+    except:
+        pass
+    message_text = MSG_BROADCAST_COMPLETE.format(
+        elapsed_time=elapsed_time,
+        total_users=total_users,
+        successes=successes,
+        failures=failures,
+        deleted_accounts=broadcast_ids[broadcast_id]['deleted']
+    )
+    reply_markup = InlineKeyboardMarkup([
+        [InlineKeyboardButton(MSG_ADMIN_RESTART_BROADCAST, callback_data="restart_broadcast")]
+    ])
+    await message.reply_text(
+        message_text,
+        parse_mode=ParseMode.MARKDOWN,
+        link_preview_options=LinkPreviewOptions(is_disabled=True),
+        reply_markup=reply_markup
+    )
+
+@StreamBot.on_message(filters.command("users") & filters.private & filters.user(Var.OWNER_ID))
+async def get_total_users(client, message):
+    try:
+        total_users = await db.total_users_count()
+        reply_markup = InlineKeyboardMarkup([
+            [InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ])
+        await message.reply_text(
+            MSG_DB_STATS.format(total_users=total_users),
+            quote=True,
+            parse_mode=ParseMode.MARKDOWN,
+            reply_markup=reply_markup
+        )
+    except:
+        await message.reply_text(MSG_DB_ERROR)
+
+@StreamBot.on_message(filters.command("broadcast") & filters.private & filters.user(Var.OWNER_ID))
+async def broadcast_message(client, message):
+    if not message.reply_to_message:
+        await message.reply_text(MSG_INVALID_BROADCAST_CMD, quote=True)
+        return
+    try:
+        broadcast_id = generate_unique_id()
+        broadcast_ids[broadcast_id] = {
+            "total": 0,
+            "current": 0,
+            "success": 0,
+            "failed": 0,
+            "deleted": 0,
+            "start_time": time.time(),
+            "is_cancelled": False
+        }
+        reply_markup = InlineKeyboardMarkup([
+            [InlineKeyboardButton(MSG_BUTTON_CANCEL_BROADCAST, callback_data=f"cancel_broadcast_{broadcast_id}")]
+        ])
+        output = await message.reply_text(MSG_BROADCAST_START, reply_markup=reply_markup)
+        self_id = client.me.id
+        start_time = time.time()
+        total_users = await db.total_users_count()
+        processed = 0
+        successes = 0
+        failures = 0
+        broadcast_ids[broadcast_id]["total"] = total_users
+        semaphore = asyncio.Semaphore(MAX_CONCURRENT_TASKS)
+        broadcast_lock = asyncio.Lock()
+        processed_lock = asyncio.Lock()
+
+        async def update_progress():
+            while processed < total_users and not broadcast_ids[broadcast_id]["is_cancelled"]:
+                try:
+                    await output.edit_text(
+                        MSG_BROADCAST_PROGRESS.format(
+                            total_users=total_users,
+                            processed=processed,
+                            elapsed_time=get_readable_time(int(time.time() - start_time)),
+                            successes=successes,
+                            failures=failures
+                        )
+                    )
+                except:
+                    pass
+                await asyncio.sleep(3)
+
+        progress_task = asyncio.create_task(update_progress())
+
+        async def send_message_to_user(user_id):
+            nonlocal successes, failures, processed
+            if not isinstance(user_id, int) or user_id == self_id:
+                return
+            async with semaphore:
+                retries = 0
+                for attempt in range(3):
+                    if broadcast_ids[broadcast_id]["is_cancelled"]:
+                        return
+                    try:
+                        if message.reply_to_message.text or message.reply_to_message.caption:
+                            await client.send_message(
+                                chat_id=user_id,
+                                text=message.reply_to_message.text or message.reply_to_message.caption,
+                                parse_mode=ParseMode.MARKDOWN,
+                                link_preview_options=LinkPreviewOptions(is_disabled=True)
+                            )
+                        elif message.reply_to_message.media:
+                            await message.reply_to_message.copy(chat_id=user_id)
+                        async with broadcast_lock:
+                            successes += 1
+                        async with processed_lock:
+                            processed += 1
+                            broadcast_ids[broadcast_id]["current"] = processed
+                        break
+                    except FloodWait as e:
+                        await asyncio.sleep(e.value + 1)
+                        continue
+                    except (FileReferenceExpired, FileReferenceInvalid):
+                        retries += 1
+                        if retries >= 3:
+                            break
+                    except (UserDeactivated, ChatWriteForbidden, UserIsBlocked, PeerIdInvalid):
+                        try:
+                            await db.delete_user(user_id)
+                            async with broadcast_lock:
+                                failures += 1
+                                broadcast_ids[broadcast_id]["deleted"] += 1
+                            async with processed_lock:
+                                processed += 1
+                                broadcast_ids[broadcast_id]["current"] = processed
+                        except:
+                            pass
+                        break
+                    except Exception:
+                        async with broadcast_lock:
+                            failures += 1
+                        async with processed_lock:
+                            processed += 1
+                            broadcast_ids[broadcast_id]["current"] = processed
+                        if attempt == 2:
+                            break
+                        await asyncio.sleep(1)
+
+        async for user_batch in get_users_in_batches():
+            if broadcast_ids[broadcast_id]["is_cancelled"]:
+                break
+            batch_tasks = [send_message_to_user(int(user['id'])) for user in user_batch]
+            await asyncio.gather(*batch_tasks)
+
+        progress_task.cancel()
+        try:
+            await progress_task
+        except asyncio.CancelledError:
+            pass
+
+        await handle_broadcast_completion(
+            message, output, failures, successes, total_users, start_time, broadcast_id
+        )
+        broadcast_ids.pop(broadcast_id, None)
+
+    except Exception as e:
+        await message.reply_text(
+            MSG_BROADCAST_FAILED.format(error=str(e), error_id=uuid.uuid4().hex[:8])
+        )
+
+@StreamBot.on_message(filters.command("cancel_broadcast") & filters.private & filters.user(Var.OWNER_ID))
+async def cancel_broadcast(client, message):
+    if not broadcast_ids:
+        await message.reply_text(MSG_NO_ACTIVE_BROADCASTS)
+        return
+    if len(broadcast_ids) == 1:
+        broadcast_id = list(broadcast_ids.keys())[0]
+        broadcast_ids[broadcast_id]["is_cancelled"] = True
+        await message.reply_text(MSG_BROADCAST_CANCEL.format(broadcast_id=broadcast_id))
+        return
+    keyboard = []
+    for broadcast_id, info in broadcast_ids.items():
+        progress = f"{info['current']}/{info['total']}" if info['total'] else "Unknown"
+        elapsed = get_readable_time(time.time() - info['start_time'])
+        keyboard.append([
+            InlineKeyboardButton(
+                MSG_ADMIN_BROADCAST_PROGRESS_ITEM.format(
+                    broadcast_id=broadcast_id,
+                    progress=progress,
+                    elapsed=elapsed
+                ),
+                callback_data=f"cancel_broadcast_{broadcast_id}"
+            )
+        ])
+    await message.reply_text(
+        MSG_MULTIPLE_BROADCASTS,
+        reply_markup=InlineKeyboardMarkup(keyboard)
+    )
+
+@StreamBot.on_callback_query(filters.regex(r"^cancel_broadcast_(.+)$"))
+async def handle_cancel_broadcast(client, callback_query):
+    broadcast_id = callback_query.data.split("_")[-1]
+    if broadcast_id in broadcast_ids:
+        broadcast_ids[broadcast_id]["is_cancelled"] = True
+        await callback_query.edit_message_text(
+            MSG_CANCELLING_BROADCAST.format(broadcast_id=broadcast_id)
+        )
+    else:
+        await callback_query.edit_message_text(MSG_BROADCAST_NOT_FOUND)
+
+@StreamBot.on_message(filters.command("status") & filters.private & filters.user(Var.OWNER_ID))
+async def show_status(client, message):
+    try:
+        uptime = get_readable_time(int(time.time() - StartTime))
+        workloads_text = MSG_ADMIN_BOT_WORKLOAD_HEADER
+        workloads = {
+            f"🔹 Bot {c + 1}": load
+            for c, (bot, load) in enumerate(
+                sorted(work_loads.items(), key=lambda x: x[1], reverse=True)
+            )
+        }
+        for bot_name, load in workloads.items():
+            workloads_text += MSG_ADMIN_BOT_WORKLOAD_ITEM.format(bot_name=bot_name, load=load)
+        stats_text = MSG_SYSTEM_STATUS.format(
+            uptime=uptime,
+            active_bots=len(multi_clients),
+            workloads=workloads_text,
+            version=__version__
+        )
+        reply_markup = InlineKeyboardMarkup([
+            [InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ])
+        await message.reply_text(stats_text, parse_mode=ParseMode.MARKDOWN, reply_markup=reply_markup)
+    except:
+        await message.reply_text(MSG_STATUS_ERROR)
+
+@StreamBot.on_message(filters.command("stats") & filters.private & filters.user(Var.OWNER_ID))
+async def show_stats(client, message):
+    try:
+        current_time = get_readable_time(int(time.time() - StartTime))
+        total, used, free = shutil.disk_usage('.')
+        stats_text = MSG_SYSTEM_STATS.format(
+            uptime=current_time,
+            total=humanbytes(total),
+            used=humanbytes(used),
+            free=humanbytes(free),
+            upload=humanbytes(psutil.net_io_counters().bytes_sent),
+            download=humanbytes(psutil.net_io_counters().bytes_recv)
+        )
+        stats_text += MSG_PERFORMANCE_STATS.format(
+            cpu_percent=psutil.cpu_percent(interval=0.5),
+            ram_percent=psutil.virtual_memory().percent,
+            disk_percent=psutil.disk_usage('.').percent
+        )
+        reply_markup = InlineKeyboardMarkup([
+            [InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ])
+        await message.reply_text(stats_text, parse_mode=ParseMode.MARKDOWN, reply_markup=reply_markup)
+    except:
+        await message.reply_text(MSG_STATUS_ERROR)
+
+@StreamBot.on_message(filters.command("restart") & filters.private & filters.user(Var.OWNER_ID))
+async def restart_bot(client, message):
+    try:
+        sent_message = await message.reply_text(MSG_RESTARTING)
+        await db.add_restart_message(sent_message.id, message.chat.id)
+        os.execv(sys.executable, [sys.executable, "-m", "Thunder"])
+    except Exception as e:
+        logger.error(f"Error during restart: {e}")
+        await message.reply_text(MSG_RESTART_FAILED)
+
+@StreamBot.on_message(filters.command("log") & filters.private & filters.user(Var.OWNER_ID))
+async def send_logs(client, message):
+    try:
+        if not os.path.exists(LOG_FILE):
+            await message.reply_text(MSG_LOG_FILE_MISSING)
+            return
+        file_size = os.path.getsize(LOG_FILE)
+        if file_size == 0:
+            await message.reply_text(MSG_LOG_FILE_EMPTY)
+            return
+        await client.send_document(
+            chat_id=message.chat.id,
+            document=LOG_FILE,
+            caption=MSG_LOG_FILE_CAPTION,
+            parse_mode=ParseMode.MARKDOWN
+        )
+    except Exception as e:
+        await message.reply_text(MSG_LOG_ERROR.format(error=str(e)))
+
+@StreamBot.on_message(filters.command("authorize") & filters.private & filters.user(Var.OWNER_ID))
+async def authorize_command(client, message):
+    if len(message.command) < 2:
+        await message.reply_text(MSG_AUTHORIZE_USAGE)
+        return
+    try:
+        user_id_to_authorize = int(message.command[1])
+        authorized = await authorize(user_id_to_authorize, authorized_by=message.from_user.id)
+        if authorized:
+            await message.reply_text(MSG_AUTHORIZE_SUCCESS.format(user_id=user_id_to_authorize))
+        else:
+            await message.reply_text(MSG_AUTHORIZE_FAILED.format(user_id=user_id_to_authorize))
+    except ValueError:
+        await message.reply_text(MSG_INVALID_USER_ID)
+    except:
+        await message.reply_text(MSG_ERROR_GENERIC)
+
+@StreamBot.on_message(filters.command("deauthorize") & filters.private & filters.user(Var.OWNER_ID))
+async def deauthorize_command(client, message):
+    if len(message.command) < 2:
+        await message.reply_text(MSG_DEAUTHORIZE_USAGE)
+        return
+    try:
+        user_id_to_deauthorize = int(message.command[1])
+        deauthorized = await deauthorize(user_id_to_deauthorize)
+        if deauthorized:
+            await message.reply_text(MSG_DEAUTHORIZE_SUCCESS.format(user_id=user_id_to_deauthorize))
+        else:
+            await message.reply_text(MSG_DEAUTHORIZE_FAILED.format(user_id=user_id_to_deauthorize))
+    except ValueError:
+        await message.reply_text(MSG_INVALID_USER_ID)
+    except:
+        await message.reply_text(MSG_ERROR_GENERIC)
+
+@StreamBot.on_message(filters.command("listauth") & filters.private & filters.user(Var.OWNER_ID))
+async def list_authorized_command(client, message):
+    try:
+        authorized_users = await list_allowed()
+        if not authorized_users:
+            await message.reply_text(MSG_NO_AUTH_USERS)
+            return
+        message_text = MSG_ADMIN_AUTH_LIST_HEADER
+        for i, user in enumerate(authorized_users, 1):
+            message_text += MSG_AUTH_USER_INFO.format(
+                i=i,
+                user_id=user['user_id'],
+                authorized_by=user['authorized_by'],
+                auth_time=user['authorized_at']
+            )
+        reply_markup = InlineKeyboardMarkup([
+            [InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ])
+        await message.reply_text(
+            message_text,
+            parse_mode=ParseMode.MARKDOWN,
+            link_preview_options=LinkPreviewOptions(is_disabled=True),
+            reply_markup=reply_markup
+        )
+    except:
+        await message.reply_text(MSG_ERROR_GENERIC)
+
+@StreamBot.on_message(filters.command("ban") & filters.private & filters.user(Var.OWNER_ID))
+async def ban_user_command(client, message):
+    try:
+        if len(message.command) < 2:
+            await message.reply_text(MSG_BAN_USAGE)
+            return
+        try:
+            user_id_to_ban = int(message.command[1])
+        except ValueError:
+            await message.reply_text(MSG_INVALID_USER_ID)
+            return
+        if user_id_to_ban in (Var.OWNER_ID if isinstance(Var.OWNER_ID, list) else [Var.OWNER_ID]):
+            await message.reply_text(MSG_CANNOT_BAN_OWNER)
+            return
+        reason = " ".join(message.command[2:]) if len(message.command) > 2 else MSG_ADMIN_NO_BAN_REASON
+        ban_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        await db.add_banned_user(
+            user_id=user_id_to_ban,
+            reason=reason,
+            ban_time=ban_time,
+            banned_by=message.from_user.id
+        )
+        reply_text = MSG_ADMIN_USER_BANNED.format(user_id=user_id_to_ban)
+        if reason != MSG_ADMIN_NO_BAN_REASON:
+            reply_text += MSG_BAN_REASON_SUFFIX.format(reason=reason)
+        await message.reply_text(reply_text)
+        try:
+            await client.send_message(
+                chat_id=user_id_to_ban,
+                text=MSG_USER_BANNED_NOTIFICATION
+            )
+        except:
+            pass
+    except Exception as e:
+        await message.reply_text(MSG_BAN_ERROR.format(error=str(e)))
+
+@StreamBot.on_message(filters.command("unban") & filters.private & filters.user(Var.OWNER_ID))
+async def unban_user_command(client, message):
+    try:
+        if len(message.command) < 2:
+            await message.reply_text(MSG_UNBAN_USAGE)
+            return
+        try:
+            user_id_to_unban = int(message.command[1])
+        except ValueError:
+            await message.reply_text(MSG_INVALID_USER_ID)
+            return
+        removed = await db.remove_banned_user(user_id=user_id_to_unban)
+        if removed:
+            await message.reply_text(MSG_ADMIN_USER_UNBANNED.format(user_id=user_id_to_unban))
+            try:
+                await client.send_message(
+                    chat_id=user_id_to_unban,
+                    text=MSG_USER_UNBANNED_NOTIFICATION
+                )
+            except:
+                pass
+        else:
+            await message.reply_text(MSG_USER_NOT_IN_BAN_LIST.format(user_id=user_id_to_unban))
+    except Exception as e:
+        await message.reply_text(MSG_UNBAN_ERROR.format(error=str(e)))
+
+@StreamBot.on_message(filters.command("shell") & filters.private & filters.user(Var.OWNER_ID))
+async def run_shell_command(client: Client, message: Message):
+    if len(message.command) < 2:
+        await message.reply_text(MSG_SHELL_USAGE, parse_mode=ParseMode.HTML)
+        return
+    command_to_run = " ".join(message.command[1:])
+    reply_msg = await message.reply_text(
+        MSG_SHELL_EXECUTING.format(command=html.escape(command_to_run)),
+        parse_mode=ParseMode.HTML,
+        quote=True
+    )
+    try:
+        process = await asyncio.create_subprocess_shell(
+            command_to_run,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await process.communicate()
+        output = ""
+        if stdout:
+            output += MSG_SHELL_OUTPUT_STDOUT.format(output=html.escape(stdout.decode().strip()))
+        if stderr:
+            output += MSG_SHELL_OUTPUT_STDERR.format(error=html.escape(stderr.decode().strip()))
+        if not output:
+            output = MSG_SHELL_NO_OUTPUT
+    except Exception as e:
+        output = MSG_SHELL_ERROR.format(error=html.escape(str(e)))
+    if len(output) > 4096:
+        try:
+            filename = f"shell_output_{int(time.time())}.txt"
+            with open(filename, "w", encoding="utf-8") as file:
+                if stdout:
+                    file.write(f"STDOUT:\n{stdout.decode()}\n\n")
+                if stderr:
+                    file.write(f"STDERR:\n{stderr.decode()}")
+            await client.send_document(
+                chat_id=message.chat.id,
+                document=filename,
+                caption=MSG_SHELL_OUTPUT.format(command=html.escape(command_to_run)),
+                parse_mode=ParseMode.HTML
+            )
+            os.remove(filename)
+        except Exception as e:
+            await message.reply_text(
+                MSG_SHELL_LARGE_OUTPUT.format(error=html.escape(str(e))),
+                parse_mode=ParseMode.HTML
+            )
+    else:
+        await message.reply_text(output, parse_mode=ParseMode.HTML)
+    try:
+        await reply_msg.delete()
+    except:
+        pass
+
+@StreamBot.on_callback_query(filters.regex("close_panel"))
+async def close_panel(client, callback_query):
+    """Handler for Close button - deletes current panel and command message."""
+    try:
+        await callback_query.answer()
+        await callback_query.message.delete()
+        logger.debug(f"User {callback_query.from_user.id} closed panel")
+        if callback_query.message.reply_to_message:
+            try:
+                ctx = callback_query.message.reply_to_message
+                await ctx.delete()
+                if ctx.reply_to_message:
+                    await ctx.reply_to_message.delete()
+            except Exception as e:
+                logger.warning(f"Error deleting command messages: {e}")
+    except Exception as e:
+        logger.error(f"Error in close_panel: {e}")
+    finally:
+        raise StopPropagation
+
+@StreamBot.on_callback_query(filters.regex("restart_broadcast"))
+async def restart_broadcast(client, callback_query):
+    try:
+        await callback_query.edit_message_text(
+            "Please use `/broadcast` command with a reply to the message you want to broadcast.",
+            parse_mode=ParseMode.MARKDOWN
+        )
+    except:
+        pass

Thunder/bot/plugins/callbacks.py

@@ -0,0 +1,166 @@
+"""
+Thunder/bot/plugins/callbacks.py - Callback query handlers for Thunder bot.
+"""
+
+import uuid
+from pyrogram import Client, filters, StopPropagation
+from pyrogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, LinkPreviewOptions
+from pyrogram.errors import MessageNotModified
+from Thunder.bot import StreamBot
+from Thunder.vars import Var
+from Thunder.utils.logger import logger
+from Thunder.utils.messages import *
+from Thunder.utils.decorators import owner_only
+
+# Helper Functions
+async def handle_callback_error(callback_query, error, operation="callback"):
+    """Standardized error handling for callback queries."""
+    error_id = uuid.uuid4().hex[:8]
+    logger.error(f"Error in {operation}: {error}")
+    await callback_query.answer(
+        MSG_ERROR_GENERIC_CALLBACK.format(error_id=error_id), 
+        show_alert=True
+    )
+
+async def get_force_channel_button(client):
+    """Get force channel button if configured."""
+    if not Var.FORCE_CHANNEL_ID:
+        return None
+    
+    try:
+        chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
+        invite_link = chat.invite_link or (f"https://t.me/{chat.username}" if chat.username else None)
+        
+        if invite_link:
+            return [InlineKeyboardButton(
+                MSG_BUTTON_JOIN_CHANNEL.format(channel_title=chat.title), 
+                url=invite_link
+            )]
+        else:
+            logger.warning(f"Could not construct invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID}")
+            return None
+    except Exception as e:
+        logger.error(f"Error creating force channel button: {e}")
+        return None
+
+# Callback Handlers
+@StreamBot.on_callback_query(filters.regex(r"^help_command$"))
+async def help_callback(client: Client, callback_query: CallbackQuery):
+    """Handler for Help button."""
+    try:
+        await callback_query.answer()
+        
+        # Build buttons list - About button first
+        buttons = [[InlineKeyboardButton(MSG_BUTTON_ABOUT, callback_data="about_command")]]
+        
+        # Add force channel button if configured
+        force_button = await get_force_channel_button(client)
+        if force_button:
+            buttons.append(force_button)
+        
+        # Add close button at the end
+        buttons.append([InlineKeyboardButton("🗙 Close", callback_data="close_panel")])
+        
+        await callback_query.message.edit_text(
+            text=MSG_HELP,
+            reply_markup=InlineKeyboardMarkup(buttons),
+            link_preview_options=LinkPreviewOptions(is_disabled=True)
+        )
+        
+        logger.debug(f"User {callback_query.from_user.id} accessed help panel.")
+        
+    except MessageNotModified:
+        logger.debug(f"Help panel already displayed for user {callback_query.from_user.id}")
+    except Exception as e:
+        await handle_callback_error(callback_query, e, "help_callback")
+    finally:
+        raise StopPropagation
+
+@StreamBot.on_callback_query(filters.regex(r"^about_command$"))
+async def about_callback(client: Client, callback_query: CallbackQuery):
+    """Handler for About button."""
+    try:
+        await callback_query.answer()
+
+        buttons = [
+            [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")],
+            [InlineKeyboardButton(MSG_BUTTON_GITHUB, url="https://github.com/fyaz05/FileToLink"),
+             InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ]
+        
+        await callback_query.message.edit_text(
+            text=MSG_ABOUT,
+            reply_markup=InlineKeyboardMarkup(buttons),
+            link_preview_options=LinkPreviewOptions(is_disabled=True)
+        )
+        
+        logger.debug(f"User {callback_query.from_user.id} accessed about panel.")
+        
+    except MessageNotModified:
+        logger.debug(f"About panel already displayed for user {callback_query.from_user.id}")
+    except Exception as e:
+        await handle_callback_error(callback_query, e, "about_callback")
+    finally:
+        raise StopPropagation
+
+@StreamBot.on_callback_query(filters.regex(r"^restart_broadcast$"))
+@owner_only
+async def restart_broadcast_callback(client: Client, callback_query: CallbackQuery):
+    """Handler for Restart Broadcast button."""
+    try:
+        await callback_query.answer(MSG_ERROR_BROADCAST_RESTART, show_alert=True)
+        
+        # Create back and close buttons
+        buttons = [
+            [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command"),
+             InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ]
+        
+        await callback_query.message.edit_text(
+            MSG_ERROR_BROADCAST_INSTRUCTION,
+            reply_markup=InlineKeyboardMarkup(buttons),
+            link_preview_options=LinkPreviewOptions(is_disabled=True)
+        )
+        
+        logger.debug(f"User {callback_query.from_user.id} viewed broadcast restart instruction.")
+        
+    except Exception as e:
+        await handle_callback_error(callback_query, e, "restart_broadcast_callback")
+    finally:
+        raise StopPropagation
+
+@StreamBot.on_callback_query(filters.regex(r"^close_panel$"))
+async def close_panel_callback(client: Client, callback_query: CallbackQuery):
+    """Handler for Close button - deletes current panel and command message."""
+    try:
+        await callback_query.answer()
+        
+        # Delete the current panel message
+        await callback_query.message.delete()
+        logger.debug(f"User {callback_query.from_user.id} closed panel")
+        
+        # Clean up original command message and replies
+        if callback_query.message.reply_to_message:
+            try:
+                ctx = callback_query.message.reply_to_message
+                await ctx.delete()
+                if ctx.reply_to_message:
+                    await ctx.reply_to_message.delete()
+            except Exception as e:
+                logger.warning(f"Error deleting command messages: {e}")
+                
+    except Exception as e:
+        await handle_callback_error(callback_query, e, "close_panel_callback")
+    finally:
+        raise StopPropagation
+
+# Fallback handler for unmatched callback queries
+@StreamBot.on_callback_query(group=999)
+async def fallback_callback(client: Client, callback_query: CallbackQuery):
+    """Fallback handler for any unmatched callback query."""
+    try:
+        logger.debug(f"Unhandled callback query: {callback_query.data} from user {callback_query.from_user.id}")
+        await callback_query.answer(MSG_ERROR_CALLBACK_UNSUPPORTED, show_alert=True)
+    except Exception as e:
+        logger.error(f"Error in fallback_callback: {e}")
+    raise StopPropagation

Thunder/bot/plugins/common.py

@@ -0,0 +1,458 @@
+"""
+Thunder/bot/plugins/common.py - Common plugin handlers and helpers for Thunder bot.
+"""
+
+import time
+import asyncio
+import uuid
+from typing import Tuple, Optional
+from urllib.parse import quote_plus
+
+from pyrogram import filters, StopPropagation
+from pyrogram.client import Client
+from pyrogram.errors import RPCError, MessageNotModified
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+    User,
+    CallbackQuery,
+    LinkPreviewOptions
+)
+
+from Thunder.bot import StreamBot
+from Thunder.vars import Var
+from Thunder.utils.database import db
+from Thunder.utils.messages import *
+from Thunder.utils.human_readable import humanbytes
+from Thunder.utils.file_properties import get_media_file_size, get_name
+from Thunder.utils.force_channel import force_channel_check
+from Thunder.utils.logger import logger
+from Thunder.utils.tokens import get, check, validate_activation_token
+from Thunder.utils.decorators import check_banned
+from Thunder.utils.bot_utils import (
+    notify_channel,
+    log_new_user,
+    generate_media_links,
+    handle_user_error,
+    generate_dc_text,
+    get_user_safely
+)
+
+def has_media(message):
+    """Check if message contains media"""
+    return any(
+        hasattr(message, attr) and getattr(message, attr)
+        for attr in ["document", "photo", "video", "audio", "voice",
+                    "sticker", "animation", "video_note"]
+    )
+
+# ====== COMMAND HANDLERS ======
+
+@check_banned
+@StreamBot.on_message(filters.command("start") & filters.private)
+async def start_command(bot: Client, message: Message):
+    try:
+        user_id_str = str(message.from_user.id) if message.from_user else 'unknown'
+        
+        if message.from_user:
+            await log_new_user(bot, message.from_user.id, message.from_user.first_name)
+
+        if len(message.command) == 2:
+            token = message.command[1]
+            try:
+                if token.startswith("token"):
+                    validation_result = await validate_activation_token(token)
+                    if validation_result["valid"]:
+                        await db.update_user_token(message.from_user.id, token)
+                        await message.reply_text(
+                            MSG_TOKEN_ACTIVATED.format(
+                                expiry_date=validation_result['expiry_date'],
+                                description=validation_result['description']
+                            ),
+                            link_preview_options=LinkPreviewOptions(is_disabled=True),
+                            quote=True
+                        )
+                        return
+                    else:
+                        await message.reply_text(
+                            MSG_TOKEN_FAILED.format(
+                                reason=validation_result['reason'],
+                                error_id=uuid.uuid4().hex[:8]
+                            ),
+                            link_preview_options=LinkPreviewOptions(is_disabled=True),
+                            quote=True
+                        )
+                        return
+                else:
+                    record = await get(token)
+                    if record and record["user_id"] == message.from_user.id and await check(message.from_user.id):
+                        await message.reply_text(MSG_TOKEN_VERIFIED, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))
+                        return
+                    else:
+                        await message.reply_text(MSG_TOKEN_INVALID, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))
+                        return
+            except Exception as e:
+                logger.error(f"Token activation error: {e}")
+                await message.reply_text(MSG_TOKEN_ERROR.format(error_id=uuid.uuid4().hex[:8]), quote=True)
+                return
+
+        parts = message.text.strip().split(maxsplit=1)
+        if len(parts) == 1 or (len(parts) > 1 and parts[1].lower() == "start"):
+            welcome_text = MSG_WELCOME.format(user_name=message.from_user.first_name)
+            
+            if Var.FORCE_CHANNEL_ID:
+                error_id_context = uuid.uuid4().hex[:8]
+                try:
+                    chat = await bot.get_chat(Var.FORCE_CHANNEL_ID)
+                    invite_link = getattr(chat, 'invite_link', None)
+                    chat_username = getattr(chat, 'username', None)
+                    chat_title = getattr(chat, 'title', 'Channel')
+                    
+                    if not invite_link and chat_username:
+                        invite_link = f"https://t.me/{chat_username}"
+                    
+                    if invite_link:
+                        welcome_text += f"\n\n{MSG_COMMUNITY_CHANNEL.format(channel_title=chat_title)}"
+                    else:
+                        logger.warning(f"(ID: {error_id_context}) Could not retrieve invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID} for /start message text (Channel: {chat_title}, User: {user_id_str}).")
+                        welcome_text += f"\n\n{MSG_COMMUNITY_CHANNEL.format(channel_title=chat_title)}"
+                        
+                except asyncio.TimeoutError as e_timeout:
+                    logger.error(f"(ID: {error_id_context}) Timeout fetching Force Channel details for /start text (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_timeout}")
+                    welcome_text += f"\n\n{MSG_DEFAULT_WELCOME}"
+                except RPCError as e_rpc:
+                    logger.error(f"(ID: {error_id_context}) RPCError fetching Force Channel details for /start text (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_rpc}")
+                    welcome_text += f"\n\n{MSG_DEFAULT_WELCOME}"
+                except Exception as e:
+                    logger.error(f"(ID: {error_id_context}) Error adding force channel link to /start message text (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e}")
+                    welcome_text += f"\n\n{MSG_DEFAULT_WELCOME}"
+
+            reply_markup = InlineKeyboardMarkup([
+                [
+                    InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command"),
+                    InlineKeyboardButton(MSG_BUTTON_ABOUT, callback_data="about_command"),
+                ],
+                [
+                    InlineKeyboardButton(MSG_BUTTON_GITHUB, url="https://github.com/fyaz05/FileToLink/"),
+                    InlineKeyboardButton("🗙 Close", callback_data="close_panel")
+                ]
+            ])
+
+            if Var.FORCE_CHANNEL_ID:
+                error_id_context_button = uuid.uuid4().hex[:8]
+                try:
+                    chat = await bot.get_chat(Var.FORCE_CHANNEL_ID)
+                    invite_link = getattr(chat, 'invite_link', None)
+                    chat_username = getattr(chat, 'username', None)
+                    chat_title = getattr(chat, 'title', 'Channel')
+                    
+                    if not invite_link and chat_username:
+                        invite_link = f"https://t.me/{chat_username}"
+                    
+                    if invite_link:
+                        reply_markup.inline_keyboard.append([InlineKeyboardButton(MSG_BUTTON_JOIN_CHANNEL.format(channel_title=chat_title), url=invite_link)])
+                    else:
+                        logger.warning(f"(ID: {error_id_context_button}) Could not retrieve invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID} for /start message button (Channel: {chat_title}, User: {user_id_str}).")
+                        
+                except asyncio.TimeoutError as e_timeout_btn:
+                    logger.error(f"(ID: {error_id_context_button}) Timeout fetching Force Channel details for /start button (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_timeout_btn}")
+                except RPCError as e_rpc_btn:
+                    logger.error(f"(ID: {error_id_context_button}) RPCError fetching Force Channel details for /start button (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_rpc_btn}")
+                except Exception as e_btn:
+                    logger.error(f"(ID: {error_id_context_button}) Error adding force channel button to /start message (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_btn}")
+
+            await message.reply_text(text=welcome_text, reply_markup=reply_markup, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))
+            return
+
+        payload = parts[1]
+        try:
+            msg_id = int(payload)
+            
+            # Ensure file_msg is a single Message object
+            retrieved_messages = await bot.get_messages(chat_id=Var.BIN_CHANNEL, message_ids=msg_id)
+            if not retrieved_messages:
+                await handle_user_error(message, MSG_ERROR_FILE_INVALID)
+                return
+            
+            # If get_messages returns a list, take the first one.
+            file_msg = retrieved_messages[0] if isinstance(retrieved_messages, list) else retrieved_messages
+            
+            if not file_msg:
+                await handle_user_error(message, MSG_ERROR_FILE_INVALID)
+                return
+
+            stream_link, download_link, file_name, file_size = await generate_media_links(file_msg)
+            
+            reply_text = MSG_LINKS.format(
+                file_name=file_name,
+                file_size=file_size,
+                download_link=download_link,
+                stream_link=stream_link
+            )
+
+            await message.reply_text(
+                text=reply_text,
+                reply_markup=InlineKeyboardMarkup([
+                    [
+                        InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=stream_link),
+                        InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=download_link)
+                    ]
+                ]),
+                quote=True,
+                link_preview_options=LinkPreviewOptions(is_disabled=True)
+            )
+
+        except ValueError:
+            await handle_user_error(message, MSG_ERROR_FILE_INVALID_ID)
+        except Exception as e:
+            logger.error(f"Error processing /start with payload: {e}")
+            await handle_user_error(message, MSG_FILE_ACCESS_ERROR)
+
+    except Exception as e:
+        logger.error(f"Error in start_command: {e}")
+        await handle_user_error(message, MSG_ERROR_GENERIC)
+
+@check_banned
+@StreamBot.on_message(filters.command("help") & filters.private)
+async def help_command(bot: Client, message: Message):
+    try:
+        user_id_str = str(message.from_user.id) if message.from_user else 'unknown'
+        
+        if message.from_user:
+            await log_new_user(bot, message.from_user.id, message.from_user.first_name)
+
+        help_text = MSG_HELP
+        buttons = [
+            [InlineKeyboardButton(MSG_BUTTON_ABOUT, callback_data="about_command")]
+        ]
+
+        if Var.FORCE_CHANNEL_ID:
+            error_id_context_help = uuid.uuid4().hex[:8]
+            try:
+                chat = await bot.get_chat(Var.FORCE_CHANNEL_ID)
+                invite_link = getattr(chat, 'invite_link', None)
+                chat_username = getattr(chat, 'username', None)
+                chat_title = getattr(chat, 'title', 'Channel')
+                
+                if not invite_link and chat_username:
+                    invite_link = f"https://t.me/{chat_username}"
+                
+                if invite_link:
+                    buttons.append([
+                        InlineKeyboardButton(MSG_BUTTON_JOIN_CHANNEL.format(channel_title=chat_title), url=invite_link)
+                    ])
+                else:
+                    logger.warning(f"(ID: {error_id_context_help}) Could not retrieve or construct invite link for FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID} for /help command (User: {user_id_str}).")
+                    
+            except Exception as e_help:
+                logger.error(f"(ID: {error_id_context_help}) Error adding force channel button to /help command (User: {user_id_str}, FChannel: {Var.FORCE_CHANNEL_ID}): {e_help}")
+
+        buttons.append([InlineKeyboardButton("🗙 Close", callback_data="close_panel")])
+        reply_markup = InlineKeyboardMarkup(buttons)
+
+        await message.reply_text(
+            text=help_text,
+            reply_markup=reply_markup,
+            quote=True,
+            link_preview_options=LinkPreviewOptions(is_disabled=True)
+        )
+
+    except Exception as e:
+        logger.error(f"Error in help_command: {e}")
+        await handle_user_error(message, MSG_ERROR_GENERIC)
+
+@check_banned
+@StreamBot.on_message(filters.command("about") & filters.private)
+async def about_command(bot: Client, message: Message):
+    try:
+        if message.from_user:
+            await log_new_user(bot, message.from_user.id, message.from_user.first_name)
+
+        about_text = MSG_ABOUT
+        buttons = [
+            [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")],
+            [InlineKeyboardButton(MSG_BUTTON_GITHUB, url="https://github.com/fyaz05/FileToLink"),
+             InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ]
+
+        reply_markup = InlineKeyboardMarkup(buttons)
+
+        await message.reply_text(
+            text=about_text,
+            reply_markup=reply_markup,
+            quote=True,
+            link_preview_options=LinkPreviewOptions(is_disabled=True)
+        )
+
+    except Exception as e:
+        logger.error(f"Error in about_command: {e}")
+        await handle_user_error(message, MSG_ERROR_GENERIC)
+
+@check_banned
+@force_channel_check
+@StreamBot.on_message(filters.command("dc"))
+async def dc_command(bot: Client, message: Message):
+    try:
+        # Early exit conditions
+        if not message.from_user and not message.reply_to_message:
+            await handle_user_error(message, MSG_DC_ANON_ERROR)
+            return
+
+        async def process_dc_info(user: User):
+            dc_text = await generate_dc_text(user)
+            buttons = []
+            if user.username:
+                profile_url = f"https://t.me/{user.username}"
+            else:
+                profile_url = f"tg://user?id={user.id}"
+            buttons.append([
+                InlineKeyboardButton(MSG_BUTTON_VIEW_PROFILE, url=profile_url)
+            ])
+            buttons.append([
+                InlineKeyboardButton("🗙 Close", callback_data="close_panel")
+            ])
+            dc_keyboard = InlineKeyboardMarkup(buttons)
+
+            await message.reply_text(
+                dc_text,
+                reply_markup=dc_keyboard,
+                quote=True,
+                link_preview_options=LinkPreviewOptions(is_disabled=True)
+            )
+
+        async def process_file_dc_info(file_msg: Message):
+            try:
+                file_name = get_name(file_msg) or "Untitled File"
+                file_size = humanbytes(get_media_file_size(file_msg))
+                file_type_map = {
+                    "document": MSG_FILE_TYPE_DOCUMENT,
+                    "photo": MSG_FILE_TYPE_PHOTO,
+                    "video": MSG_FILE_TYPE_VIDEO,
+                    "audio": MSG_FILE_TYPE_AUDIO,
+                    "voice": MSG_FILE_TYPE_VOICE,
+                    "sticker": MSG_FILE_TYPE_STICKER,
+                    "animation": MSG_FILE_TYPE_ANIMATION,
+                    "video_note": MSG_FILE_TYPE_VIDEO_NOTE
+                }
+
+                file_type_attr = next((attr for attr in file_type_map if getattr(file_msg, attr, None)), "unknown")
+                file_type_display = file_type_map.get(file_type_attr, MSG_FILE_TYPE_UNKNOWN)
+
+                actual_media = None
+                if file_type_attr == "photo" and file_msg.photo and file_msg.photo.sizes:
+                    actual_media = file_msg.photo.sizes[-1]
+                elif file_type_attr != "unknown":
+                    potential = getattr(file_msg, file_type_attr, None)
+                    if potential:
+                        actual_media = potential
+
+                dc_id = MSG_DC_UNKNOWN
+                if hasattr(file_msg, 'raw') and hasattr(file_msg.raw, 'media'):
+                    if hasattr(file_msg.raw.media, 'document') and hasattr(file_msg.raw.media.document, 'dc_id'):
+                        dc_id = file_msg.raw.media.document.dc_id
+
+                dc_text = MSG_DC_FILE_INFO.format(
+                    file_name=file_name,
+                    file_size=file_size,
+                    file_type=file_type_display,
+                    dc_id=dc_id
+                )
+                await message.reply_text(
+                    dc_text,
+                    quote=True,
+                    link_preview_options=LinkPreviewOptions(is_disabled=True)
+                )
+            except Exception as e:
+                logger.error(f"Error processing file info for DC command: {e}")
+                await handle_user_error(message, MSG_DC_FILE_ERROR)
+
+        # If DC command has an argument, treat it as user lookup
+        args = message.text.strip().split(maxsplit=1)
+        if len(args) > 1:
+            query = args[1].strip()
+            user = await get_user_safely(bot, query)
+            if user:
+                await process_dc_info(user)
+            else:
+                await handle_user_error(message, MSG_ERROR_USER_INFO)
+            return
+
+        # Handle replied message cases
+        if message.reply_to_message:
+            if has_media(message.reply_to_message):
+                await process_file_dc_info(message.reply_to_message)
+                return
+            elif message.reply_to_message.from_user:
+                await process_dc_info(message.reply_to_message.from_user)
+                return
+            else:
+                await handle_user_error(message, MSG_DC_INVALID_USAGE)
+                return
+
+        # Otherwise, show info for the command sender
+        if message.from_user:
+            await process_dc_info(message.from_user)
+        else:
+            await handle_user_error(message, MSG_DC_ANON_ERROR)
+
+    except Exception as e:
+        logger.error(f"Error in dc_command: {e}")
+        await handle_user_error(message, MSG_ERROR_GENERIC)
+
+@check_banned
+@force_channel_check
+@StreamBot.on_message(filters.command("ping") & filters.private)
+async def ping_command(bot: Client, message: Message):
+    try:
+        start_time = time.time()
+        sent_msg = await message.reply_text(MSG_PING_START, quote=True, link_preview_options=LinkPreviewOptions(is_disabled=True))
+        end_time = time.time()
+        time_taken_ms = (end_time - start_time) * 1000
+        buttons = [
+            [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command"),
+             InlineKeyboardButton("🗙 Close", callback_data="close_panel")]
+        ]
+        
+        await sent_msg.edit_text(
+            MSG_PING_RESPONSE.format(time_taken_ms=time_taken_ms),
+            reply_markup=InlineKeyboardMarkup(buttons),
+            link_preview_options=LinkPreviewOptions(is_disabled=True)
+        )
+    except Exception as e:
+        logger.error(f"Error in ping_command: {e}")
+        await handle_user_error(message, MSG_ERROR_GENERIC)
+
+# ====== CALLBACK HANDLERS ======
+
+async def handle_callback_error(callback_query, error, operation="callback"):
+    """Standardized error handling for callback queries."""
+    error_id = uuid.uuid4().hex[:8]
+    logger.error(f"Error in {operation}: {error}")
+    try:
+        await callback_query.answer(
+            MSG_ERROR_GENERIC_CALLBACK.format(error_id=error_id),
+            show_alert=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to send error callback: {e}")
+
+@StreamBot.on_callback_query(filters.regex(r"^close_panel$"))
+async def close_panel_callback(client: Client, callback_query: CallbackQuery):
+    """Handler for Close button - deletes current panel and command message."""
+    try:
+        await callback_query.answer()
+        await callback_query.message.delete()
+        if callback_query.message.reply_to_message:
+            try:
+                ctx = callback_query.message.reply_to_message
+                await ctx.delete()
+                if ctx.reply_to_message:
+                    await ctx.reply_to_message.delete()
+            except Exception as e:
+                logger.warning(f"Error deleting command messages: {e}")
+                
+    except Exception as e:
+        await handle_callback_error(callback_query, e, "close_panel_callback")
+    finally:
+        raise StopPropagation

Thunder/bot/plugins/stream.py

@@ -0,0 +1,802 @@
+"""
+Thunder/bot/plugins/stream.py - Streaming and file link plugin handlers for Thunder bot.
+"""
+
+import time
+import asyncio
+import random
+import uuid
+from urllib.parse import quote
+from typing import Optional, Tuple, Dict, Union, List, Set
+from datetime import datetime, timedelta
+
+from pyrogram.client import Client
+from pyrogram import filters, enums
+from pyrogram.errors import (
+    FloodWait,
+    RPCError,
+    MediaEmpty,
+    FileReferenceExpired,
+    FileReferenceInvalid,
+    MessageNotModified
+)
+
+from pyrogram.types import (
+    InlineKeyboardMarkup,
+    InlineKeyboardButton,
+    Message,
+    CallbackQuery,
+    LinkPreviewOptions
+)
+
+from pyrogram.enums import ChatMemberStatus
+from Thunder.bot import StreamBot
+from Thunder.utils.database import db
+from Thunder.utils.messages import *
+from Thunder.utils.file_properties import get_hash, get_media_file_size, get_name
+from Thunder.utils.human_readable import humanbytes
+from Thunder.utils.logger import logger
+from Thunder.vars import Var
+from Thunder.utils.decorators import check_banned, require_token, shorten_link
+from Thunder.utils.force_channel import force_channel_check
+from Thunder.utils.shortener import shorten
+from Thunder.utils.bot_utils import (
+    notify_owner,
+    handle_user_error,
+    log_new_user,
+    generate_media_links,
+    send_links_to_user,
+    check_admin_privileges
+)
+
+
+class LRUCache:
+    def __init__(self, max_size=1000, ttl=86400):
+        self.cache = {}
+        self.max_size = max_size
+        self.ttl = ttl
+        self.access_order = []
+        self._lock = asyncio.Lock()
+
+    async def get(self, key):
+        if key is None:
+            return None
+        
+        async with self._lock:
+            if key not in self.cache:
+                return None
+            
+            item = self.cache[key]
+            if time.time() - item['timestamp'] > self.ttl:
+                self._remove_item(key)
+                return None
+            
+            self._update_access_order(key)
+            return item
+
+    def _update_access_order(self, key):
+        try:
+            self.access_order.remove(key)
+        except ValueError:
+            pass
+        self.access_order.append(key)
+
+    def _remove_item(self, key):
+        try:
+            del self.cache[key]
+            self.access_order.remove(key)
+        except (KeyError, ValueError):
+            pass
+
+    async def set(self, key, value):
+        if key is None or not isinstance(value, dict):
+            return
+        
+        async with self._lock:
+            if key in self.cache:
+                self._update_access_order(key)
+            elif len(self.cache) >= self.max_size:
+                lru_key = self.access_order[0]
+                self._remove_item(lru_key)
+            
+            self.cache[key] = value
+            self._update_access_order(key)
+
+    async def clean_expired(self):
+        count = 0
+        current_time = time.time()
+        
+        async with self._lock:
+            keys_to_remove = []
+            for key in self.cache:
+                if current_time - self.cache[key]['timestamp'] > self.ttl:
+                    keys_to_remove.append(key)
+            
+            for key in keys_to_remove:
+                self._remove_item(key)
+                count += 1
+        
+        return count
+
+
+# Initialize cache
+CACHE = LRUCache(max_size=getattr(Var, "CACHE_SIZE", 1000), ttl=86400)
+
+
+async def clean_cache_task():
+    while True:
+        try:
+            cleaned_count = await CACHE.clean_expired()
+            if cleaned_count > 0:
+                logger.info(f"Cache cleanup: Removed {cleaned_count} expired items")
+            await asyncio.sleep(3600)
+        except Exception as e:
+            logger.error(f"Error in cache cleaning task: {e}")
+            await asyncio.sleep(60)
+
+
+class RateLimiter:
+    def __init__(self, max_calls, time_period):
+        self.max_calls = max_calls
+        self.time_period = time_period
+        self.calls = {}
+        self._lock = asyncio.Lock()
+        self._cleanup_task = None
+        self._stopping = False
+
+    def start_cleanup_task(self):
+        if self._cleanup_task is None or self._cleanup_task.done():
+            self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
+            self._cleanup_task.add_done_callback(self._cleanup_task_done)
+
+    def stop_cleanup_task(self):
+        self._stopping = True
+        if self._cleanup_task and not self._cleanup_task.done():
+            self._cleanup_task.cancel()
+
+    def _cleanup_task_done(self, task):
+        try:
+            task.result()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"Error in rate limiter cleanup task: {e}")
+            if not self._stopping:
+                asyncio.create_task(self._delayed_restart())
+
+    async def _delayed_restart(self):
+        await asyncio.sleep(5)
+        if not self._stopping:
+            self.start_cleanup_task()
+
+    async def _periodic_cleanup(self):
+        while not self._stopping:
+            try:
+                await asyncio.sleep(60)
+                await self._cleanup_old_entries()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in periodic cleanup: {e}")
+                await asyncio.sleep(30)
+
+    async def _cleanup_old_entries(self):
+        now = time.time()
+        async with self._lock:
+            for user_id in list(self.calls.keys()):
+                self.calls[user_id] = [ts for ts in self.calls[user_id]
+                                     if now - ts <= self.time_period]
+                if not self.calls[user_id]:
+                    del self.calls[user_id]
+
+    async def is_rate_limited(self, user_id):
+        if user_id is None:
+            return False
+        
+        async with self._lock:
+            now = time.time()
+            if user_id not in self.calls:
+                self.calls[user_id] = []
+            
+            self.calls[user_id] = [
+                ts for ts in self.calls[user_id]
+                if now - ts <= self.time_period
+            ]
+            
+            if len(self.calls[user_id]) >= self.max_calls:
+                return True
+            
+            self.calls[user_id].append(now)
+            return False
+
+    async def get_reset_time(self, user_id):
+        if user_id is None:
+            return 0
+        
+        async with self._lock:
+            if user_id not in self.calls or not self.calls[user_id]:
+                return 0
+            
+            now = time.time()
+            oldest_call = min(self.calls[user_id])
+            return max(0, self.time_period - (now - oldest_call))
+
+
+# Initialize rate limiter
+rate_limiter = RateLimiter(max_calls=20, time_period=60)
+
+
+# Helper Functions
+async def handle_flood_wait(e):
+    wait_time = e.value
+    logger.debug(f"FloodWait encountered. Sleeping for {wait_time} seconds.")
+    jitter = random.uniform(0, 0.05 * wait_time)
+    await asyncio.sleep(wait_time + jitter)
+
+
+def get_file_unique_id(media_message):
+    media_types = [
+        'document', 'video', 'audio', 'photo', 'animation',
+        'voice', 'video_note', 'sticker'
+    ]
+    
+    for media_type in media_types:
+        media = getattr(media_message, media_type, None)
+        if media:
+            return media.file_unique_id
+    
+    return None
+
+
+async def forward_media(media_message):
+    for retry in range(3):
+        try:
+            result = await media_message.copy(chat_id=Var.BIN_CHANNEL)
+            return result
+        except Exception:
+            try:
+                result = await media_message.forward(chat_id=Var.BIN_CHANNEL)
+                return result
+            except FloodWait as flood_error:
+                if retry < 2:
+                    await handle_flood_wait(flood_error)
+                else:
+                    raise
+            except Exception as forward_error:
+                if retry == 2:
+                    logger.error(f"Error forwarding media: {forward_error}")
+                    raise
+                await asyncio.sleep(0.5)
+    
+    raise Exception("Failed to forward media after multiple attempts")
+
+
+async def log_request(log_msg, user, stream_link, online_link):
+    try:
+        user_name = user.first_name if hasattr(user, 'first_name') else user.title
+        await log_msg.reply_text(
+            MSG_NEW_FILE_REQUEST.format(
+                user_name=user_name,
+                user_id=user.id,
+                online_link=online_link,
+                stream_link=stream_link
+            ),
+            link_preview_options=LinkPreviewOptions(is_disabled=True),
+            quote=True
+        )
+    except Exception:
+        pass
+
+
+async def process_media_message(client, command_message, media_message, notify=True, shortener=True):
+    retries = 0
+    max_retries = 3
+    cache_key = get_file_unique_id(media_message)
+    
+    if cache_key is None:
+        if notify:
+            await command_message.reply_text(MSG_ERROR_FILE_ID_EXTRACT, quote=True)
+        return None
+
+    cached_data = await CACHE.get(cache_key)
+    if cached_data:
+        if notify:
+            await send_links_to_user(
+                client,
+                command_message,
+                cached_data['media_name'],
+                cached_data['media_size'],
+                cached_data['stream_link'],
+                cached_data['online_link']
+            )
+        return cached_data['online_link']
+
+    while retries < max_retries:
+        try:
+            log_msg = await forward_media(media_message)
+            stream_link, online_link, media_name, media_size = await generate_media_links(log_msg, shortener=shortener)
+            
+            await CACHE.set(cache_key, {
+                'media_name': media_name,
+                'media_size': media_size,
+                'stream_link': stream_link,
+                'online_link': online_link,
+                'message_id': log_msg.id,
+                'timestamp': time.time()
+            })
+            
+            if notify:
+                await send_links_to_user(
+                    client,
+                    command_message,
+                    media_name,
+                    media_size,
+                    stream_link,
+                    online_link
+                )
+            
+            await log_request(log_msg, command_message.from_user, stream_link, online_link)
+            return online_link
+            
+        except FloodWait as e:
+            await handle_flood_wait(e)
+            retries += 1
+            continue
+        except (FileReferenceExpired, FileReferenceInvalid):
+            retries += 1
+            await asyncio.sleep(0.3)
+            continue
+        except MediaEmpty:
+            if notify:
+                await command_message.reply_text(MSG_MEDIA_ERROR, quote=True)
+            return None
+        except Exception as e:
+            logger.error(f"Error processing media: {e}")
+            if retries < max_retries - 1:
+                retries += 1
+                await asyncio.sleep(0.3)
+                continue
+            
+            if notify:
+                await handle_user_error(
+                    command_message,
+                    MSG_ERROR_PROCESSING_MEDIA
+                )
+            
+            await notify_owner(
+                client,
+                MSG_CRITICAL_ERROR.format(error=e, error_id=uuid.uuid4().hex[:8])
+            )
+            return None
+    
+    return None
+
+
+async def retry_failed_media(client, command_message, media_messages, status_msg=None, shortener=True):
+    results = []
+    for i, msg in enumerate(media_messages):
+        try:
+            result = await process_media_message(client, command_message, msg, notify=False, shortener=shortener)
+            if result:
+                results.append(result)
+            
+            if status_msg and i % 2 == 0:
+                try:
+                    await status_msg.edit(f"🔄 **Retrying Failed Files:** {len(results)}/{len(media_messages)} processed")
+                except MessageNotModified:
+                    pass
+        except Exception as e:
+            logger.error(f"Error retrying media: {e}")
+    
+    return results
+
+
+async def process_multiple_messages(client, command_message, reply_msg, num_files, status_msg, shortener=True):
+    chat_id = command_message.chat.id
+    start_message_id = reply_msg.id
+    end_message_id = start_message_id + num_files - 1
+    message_ids = list(range(start_message_id, end_message_id + 1))
+    
+    batch_size = 10
+    processed_count = 0
+    failed_count = 0
+    download_links = []
+    failed_messages = []
+    last_status_text = ""
+
+    try:
+        for i in range(0, len(message_ids), batch_size):
+            batch_ids = message_ids[i:i+batch_size]
+            new_status_text = MSG_PROCESSING_BATCH.format(
+                batch_number=(i//batch_size)+1,
+                total_batches=(len(message_ids)+batch_size-1)//batch_size,
+                file_count=len(batch_ids)
+            )
+            
+            if new_status_text != last_status_text:
+                try:
+                    await status_msg.edit(new_status_text)
+                    last_status_text = new_status_text
+                except MessageNotModified:
+                    pass
+            
+            await asyncio.sleep(1.0)
+            
+            messages = []
+            for retry in range(3):
+                try:
+                    messages = await client.get_messages(
+                        chat_id=chat_id,
+                        message_ids=batch_ids
+                    )
+                    break
+                except FloodWait as e:
+                    await handle_flood_wait(e)
+                except Exception as e:
+                    if retry == 2:
+                        logger.error(f"Failed to get batch {i//batch_size+1}: {e}")
+                    await asyncio.sleep(0.5)
+            
+            for msg in messages:
+                if msg and msg.media:
+                    try:
+                        result = await process_media_message(
+                            client, command_message, msg, notify=False, shortener=shortener
+                        )
+                        
+                        if result:
+                            download_links.append(result)
+                            processed_count += 1
+                        else:
+                            failed_count += 1
+                            failed_messages.append(msg)
+                    except Exception as e:
+                        failed_count += 1
+                        failed_messages.append(msg)
+                        logger.error(f"Failed to process {msg.id}: {e}")
+                
+                await asyncio.sleep(1.0)
+            
+            if processed_count % 5 == 0 or processed_count + failed_count == len(message_ids):
+                new_status_text = MSG_PROCESSING_STATUS.format(
+                    processed=processed_count,
+                    total=num_files,
+                    failed=failed_count
+                )
+                
+                if new_status_text != last_status_text:
+                    try:
+                        await status_msg.edit(new_status_text)
+                        last_status_text = new_status_text
+                    except MessageNotModified:
+                        pass
+
+        # Handle retries for failed messages
+        if failed_messages and len(failed_messages) < num_files / 2:
+            new_status_text = MSG_RETRYING_FILES.format(count=len(failed_messages))
+            if new_status_text != last_status_text:
+                try:
+                    await status_msg.edit(new_status_text)
+                    last_status_text = new_status_text
+                except MessageNotModified:
+                    pass
+            
+            retry_results = await retry_failed_media(
+                client, command_message, failed_messages, status_msg, shortener
+            )
+            
+            if retry_results:
+                download_links.extend(retry_results)
+                processed_count += len(retry_results)
+                failed_count -= len(retry_results)
+
+        # Send batch links to user
+        def chunk_list(lst, n):
+            for i in range(0, len(lst), n):
+                yield lst[i:i + n]
+
+        for chunk in chunk_list(download_links, 20):
+            links_text = "\n".join(chunk)
+            batch_links_message = MSG_BATCH_LINKS_READY.format(
+                count=len(chunk),
+                links=links_text
+            )
+            
+            await command_message.reply_text(
+                batch_links_message,
+                quote=True,
+                link_preview_options=LinkPreviewOptions(is_disabled=True),
+                parse_mode=enums.ParseMode.MARKDOWN
+            )
+            
+            if len(chunk) > 10:
+                await asyncio.sleep(0.5)
+
+        # Update final status
+        new_status_text = MSG_PROCESSING_RESULT.format(
+            processed=processed_count,
+            total=num_files,
+            failed=failed_count
+        )
+        
+        if new_status_text != last_status_text:
+            try:
+                await status_msg.edit(new_status_text)
+                last_status_text = new_status_text
+            except MessageNotModified:
+                pass
+
+    except Exception as e:
+        logger.error(f"Error in batch processing: {e}")
+        new_status_text = MSG_PROCESSING_ERROR.format(
+            error=str(e),
+            processed=processed_count,
+            total=num_files,
+            error_id=uuid.uuid4().hex[:8]
+        )
+        
+        if new_status_text != last_status_text:
+            try:
+                await status_msg.edit(new_status_text)
+                last_status_text = new_status_text
+            except MessageNotModified:
+                pass
+
+
+@StreamBot.on_message(filters.command("link") & ~filters.private)
+@check_banned
+@require_token
+@shorten_link
+@force_channel_check
+async def link_handler(client, message, shortener=True):
+    user_id = message.from_user.id
+    
+    if not await db.is_user_exist(user_id):
+        try:
+            invite_link = f"https://t.me/{client.me.username}?start=start"
+            await message.reply_text(
+                MSG_ERROR_START_BOT.format(invite_link=invite_link),
+                link_preview_options=LinkPreviewOptions(is_disabled=True),
+                parse_mode=enums.ParseMode.MARKDOWN,
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(MSG_BUTTON_START_CHAT, url=invite_link)]]),
+                quote=True
+            )
+        except Exception:
+            pass
+        return
+
+    if await rate_limiter.is_rate_limited(user_id):
+        reset_time = await rate_limiter.get_reset_time(user_id)
+        await message.reply_text(
+            MSG_ERROR_RATE_LIMIT.format(seconds=f"{reset_time:.0f}"),
+            quote=True
+        )
+        return
+
+    if message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
+        is_admin = await check_admin_privileges(client, message.chat.id)
+        if not is_admin:
+            await message.reply_text(
+                MSG_ERROR_NOT_ADMIN,
+                quote=True
+            )
+            return
+
+    if not message.reply_to_message:
+        await message.reply_text(
+            MSG_ERROR_REPLY_FILE,
+            quote=True
+        )
+        return
+
+    reply_msg = message.reply_to_message
+    if not reply_msg.media:
+        await message.reply_text(
+            MSG_ERROR_NO_FILE,
+            quote=True
+        )
+        return
+
+    command_parts = message.text.strip().split()
+    num_files = 1
+    
+    if len(command_parts) > 1:
+        try:
+            num_files = int(command_parts[1])
+            if num_files < 1 or num_files > 100:
+                await message.reply_text(
+                    MSG_ERROR_NUMBER_RANGE,
+                    quote=True
+                )
+                return
+        except ValueError:
+            await message.reply_text(
+                MSG_ERROR_INVALID_NUMBER,
+                quote=True
+            )
+            return
+
+    processing_msg = await message.reply_text(
+        MSG_PROCESSING_REQUEST,
+        quote=True
+    )
+
+    try:
+        if num_files == 1:
+            result = await process_media_message(client, message, reply_msg, shortener=shortener)
+            if result:
+                if message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
+                    try:
+                        cached_data = await CACHE.get(get_file_unique_id(reply_msg))
+                        if cached_data:
+                            msg_text = (
+                                MSG_LINKS.format(
+                                    file_name=cached_data['media_name'],
+                                    file_size=cached_data['media_size'],
+                                    download_link=cached_data['online_link'],
+                                    stream_link=cached_data['stream_link']
+                                )
+                            )
+                            await client.send_message(
+                                chat_id=message.from_user.id,
+                                text=MSG_BATCH_LINKS_FROM.format(
+                                    chat_title=message.chat.title,
+                                    links_message=msg_text
+                                ),
+                                link_preview_options=LinkPreviewOptions(is_disabled=True),
+                                parse_mode=enums.ParseMode.MARKDOWN,
+                                reply_markup=InlineKeyboardMarkup([
+                                    [
+                                        InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=cached_data['stream_link']),
+                                        InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=cached_data['online_link'])
+                                    ]
+                                ]),
+                            )
+                    except Exception:
+                        await message.reply_text(
+                            MSG_ERROR_DM_FAILED,
+                            quote=True
+                        )
+                
+                await processing_msg.delete()
+            else:
+                try:
+                    await processing_msg.edit(MSG_ERROR_PROCESSING_MEDIA)
+                except MessageNotModified:
+                    pass
+        else:
+            await process_multiple_messages(client, message, reply_msg, num_files, processing_msg, shortener)
+
+    except Exception as e:
+        logger.error(f"Error handling link command: {e}")
+        try:
+            await processing_msg.edit(MSG_ERROR_PROCESSING_MEDIA)
+        except MessageNotModified:
+            pass
+
+
+@StreamBot.on_message(
+    filters.private & filters.incoming & (
+        filters.document | filters.video | filters.photo | filters.audio |
+        filters.voice | filters.animation | filters.video_note
+    ),
+    group=4
+)
+@check_banned
+@require_token
+@shorten_link
+@force_channel_check
+async def private_receive_handler(client, message, shortener=True):
+    if not message.from_user:
+        return
+
+    if await rate_limiter.is_rate_limited(message.from_user.id):
+        reset_time = await rate_limiter.get_reset_time(message.from_user.id)
+        await message.reply_text(
+            MSG_ERROR_RATE_LIMIT.format(seconds=f"{reset_time:.0f}"),
+            quote=True
+        )
+        return
+
+    await log_new_user(
+        bot=client,
+        user_id=message.from_user.id,
+        first_name=message.from_user.first_name
+    )
+
+    processing_msg = await message.reply_text(
+        MSG_PROCESSING_FILE,
+        quote=True
+    )
+
+    try:
+        result = await process_media_message(client, message, message, shortener=shortener)
+        if result:
+            await processing_msg.delete()
+        else:
+            try:
+                await processing_msg.edit(MSG_ERROR_PROCESSING_MEDIA)
+            except MessageNotModified:
+                pass
+    except Exception as e:
+        logger.error(f"Error in private handler: {e}")
+        try:
+            await processing_msg.edit(MSG_ERROR_PROCESSING_MEDIA)
+        except MessageNotModified:
+            pass
+
+
+@StreamBot.on_message(
+    filters.channel & filters.incoming & (
+        filters.document | filters.video | filters.photo | filters.audio |
+        filters.voice | filters.animation | filters.video_note
+    ),
+    group=-1
+)
+@shorten_link
+async def channel_receive_handler(client, broadcast, shortener=True):
+    if hasattr(Var, 'BANNED_CHANNELS') and int(broadcast.chat.id) in Var.BANNED_CHANNELS:
+        await client.leave_chat(broadcast.chat.id)
+        return
+
+    can_edit = False
+    try:
+        member = await client.get_chat_member(broadcast.chat.id, client.me.id)
+        can_edit = member.status in [
+            enums.ChatMemberStatus.ADMINISTRATOR,
+            enums.ChatMemberStatus.OWNER
+        ]
+    except Exception:
+        can_edit = False
+
+    retries = 0
+    max_retries = 3
+    
+    while retries < max_retries:
+        try:
+            log_msg = await forward_media(broadcast)
+            stream_link, online_link, media_name, media_size = await generate_media_links(log_msg, shortener=shortener)
+            
+            await log_request(log_msg, broadcast.chat, stream_link, online_link)
+            
+            if can_edit:
+                try:
+                    await client.edit_message_reply_markup(
+                        chat_id=broadcast.chat.id,
+                        message_id=broadcast.id,
+                        reply_markup=InlineKeyboardMarkup([
+                            [
+                                InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=stream_link),
+                                InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=online_link)
+                            ]
+                        ])
+                    )
+                except Exception:
+                    pass
+            
+            break
+            
+        except FloodWait as e:
+            await handle_flood_wait(e)
+            retries += 1
+            continue
+        except (FileReferenceExpired, FileReferenceInvalid):
+            retries += 1
+            await asyncio.sleep(0.5)
+            continue
+        except Exception as e:
+            logger.error(f"Error handling channel message: {e}")
+            if retries < max_retries - 1:
+                retries += 1
+                await asyncio.sleep(0.5)
+                continue
+            
+            await notify_owner(
+                client,
+                MSG_CRITICAL_ERROR.format(error=e, error_id=uuid.uuid4().hex[:8])
+            )
+            break
+
+# Start background tasks
+StreamBot.loop.create_task(clean_cache_task())
+rate_limiter.start_cleanup_task()

Thunder/server/__init__.py

@@ -0,0 +1,9 @@
+# Thunder/server/__init__.py
+
+from aiohttp import web
+from .stream_routes import routes
+
+async def web_server():
+    web_app = web.Application(client_max_size=30000000)
+    web_app.add_routes(routes)
+    return web_app

Thunder/server/exceptions.py

@@ -0,0 +1,10 @@
+# Thunder/server/exceptions.py
+
+class InvalidHash(Exception):
+    """Exception raised for an invalid hash."""
+    message = "Invalid hash"
+
+
+class FileNotFound(Exception):
+    """Exception raised when a file is not found."""
+    message = "File not found"

Thunder/server/stream_routes.py

@@ -0,0 +1,297 @@
+# Thunder/server/stream_routes.py
+
+import asyncio
+import inspect
+import mimetypes
+import re
+import secrets
+import time
+import json
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+from aiohttp import web
+from aiohttp.client_exceptions import ClientConnectionError
+from cachetools import LRUCache
+from functools import wraps
+from urllib.parse import unquote, quote
+from contextlib import asynccontextmanager
+from pyrogram.errors import RPCError
+
+from Thunder import StartTime, __version__
+from Thunder.bot import multi_clients, StreamBot, work_loads
+from Thunder.server.exceptions import FileNotFound, InvalidHash
+from Thunder.utils.custom_dl import ByteStreamer
+from Thunder.utils.logger import logger
+from Thunder.utils.render_template import render_page
+from Thunder.utils.time_format import get_readable_time
+from Thunder.vars import Var
+from Thunder.utils.messages import (
+    MSG_INVALID_SECURITY_CREDENTIALS,
+    MSG_FILE_NOT_FOUND,
+    MSG_MALFORMED_RANGE_HEADER,
+    MSG_INTERNAL_SERVER_ERROR
+)
+
+routes = web.RouteTableDef()
+
+# Configuration constants.
+SECURE_HASH_LENGTH = 6
+CHUNK_SIZE = 1 * 1024 * 1024
+MAX_CLIENTS = 50
+
+# Updated regex: Correctly capture start and end values with named groups.
+PATTERN_HASH_FIRST = re.compile(rf"^([a-zA-Z0-9_-]{{{SECURE_HASH_LENGTH}}})(\d+)(?:/.*)?$")
+PATTERN_ID_FIRST = re.compile(r"^(\d+)(?:/.*)?$")
+RANGE_REGEX = re.compile(r"bytes=(?P<start>\d*)-(?P<end>\d*)")
+
+# Global LRU cache for ByteStreamer instances.
+class_cache = LRUCache(maxsize=Var.CACHE_SIZE)
+cache_lock = asyncio.Lock()
+
+def json_error(status, message, error_id=None):
+    if error_id and "{error_id}" in message:
+        message = message.format(error_id=error_id)
+    return json.dumps({"error": message})
+
+def exception_handler(func):
+    @wraps(func)
+    async def wrapper(request):
+        try:
+            return await func(request)
+        except InvalidHash as e:
+            logger.debug(f"InvalidHash exception: {e}")
+            error_id = secrets.token_hex(6)
+            raise web.HTTPForbidden(
+                text=json_error(403, MSG_INVALID_SECURITY_CREDENTIALS, error_id=error_id),
+                content_type="application/json"
+            )
+        except FileNotFound as e:
+            logger.debug(f"FileNotFound exception: {e}")
+            error_id = secrets.token_hex(6)
+            raise web.HTTPNotFound(
+                text=json_error(404, MSG_FILE_NOT_FOUND, error_id=error_id),
+                content_type="application/json"
+            )
+        except (TimeoutError, RPCError) as e:
+            error_id = secrets.token_hex(6)
+            logger.warning(f"A {type(e).__name__} occurred after retries (ID: {error_id}): {e}")
+            raise web.HTTPInternalServerError(
+                text=json_error(500, MSG_INTERNAL_SERVER_ERROR, error_id=error_id),
+                content_type="application/json"
+            )
+        except (ClientConnectionError, asyncio.CancelledError):
+            return web.Response(status=499)
+        except web.HTTPException:
+            raise
+        except Exception as e:
+            error_id = secrets.token_hex(6)
+            logger.error(f"Unhandled exception (ID: {error_id}): {str(e)}")
+            logger.error(f"Stack trace for error {error_id}:\n{traceback.format_exc()}")
+            
+            raise web.HTTPInternalServerError(
+                text=json_error(500, MSG_INTERNAL_SERVER_ERROR, error_id=error_id),
+                content_type="application/json"
+            )
+    return wrapper
+
+def parse_media_request(path: str, query: dict) -> tuple[int, str]:
+    clean_path = unquote(path).strip('/')
+    match = PATTERN_HASH_FIRST.match(clean_path)
+    if match:
+        try:
+            message_id = int(match.group(2))
+            secure_hash = match.group(1)
+            if not re.match(r'^[a-zA-Z0-9_-]+$', secure_hash):
+                raise InvalidHash("Security token contains invalid characters")
+            return message_id, secure_hash
+        except ValueError:
+            raise InvalidHash("Invalid message ID format")
+    match = PATTERN_ID_FIRST.match(clean_path)
+    if match:
+        try:
+            message_id = int(match.group(1))
+            secure_hash = query.get("hash", "").strip()
+            if len(secure_hash) != SECURE_HASH_LENGTH:
+                raise InvalidHash("Security token length mismatch")
+            if not re.match(r'^[a-zA-Z0-9_-]+$', secure_hash):
+                raise InvalidHash("Security token contains invalid characters")
+            return message_id, secure_hash
+        except ValueError:
+            raise InvalidHash("Invalid message ID format")
+    raise InvalidHash("Invalid URL structure")
+
+def optimal_client_selection():
+    if not work_loads:
+        error_id = secrets.token_hex(6)
+        raise web.HTTPInternalServerError(
+            text=json_error(500, MSG_INTERNAL_SERVER_ERROR, error_id=error_id),
+            content_type="application/json"
+        )
+    client_id, _ = min(work_loads.items(), key=lambda item: item[1])
+    return client_id, multi_clients[client_id]
+
+async def get_cached_streamer(client) -> ByteStreamer:
+    streamer = class_cache.get(client)
+    if streamer is None:
+        async with cache_lock:
+            streamer = class_cache.get(client)
+            if streamer is None:
+                streamer = ByteStreamer(client)
+                class_cache[client] = streamer
+    return streamer
+
+def sanitize_filename(filename: str) -> str:
+    return re.sub(r'[\n\r";]', '', filename)
+
+@asynccontextmanager
+async def track_workload(client_id):
+    work_loads[client_id] += 1
+    try:
+        yield
+    finally:
+        work_loads[client_id] -= 1
+
+@routes.get("/", allow_head=True)
+@exception_handler
+async def root_redirect(request):
+    raise web.HTTPFound("https://github.com/fyaz05/FileToLink")
+
+@routes.get("/status", allow_head=True)
+async def status_endpoint(request):
+    uptime_seconds = time.time() - StartTime
+    uptime_formatted = get_readable_time(int(uptime_seconds))
+    
+    sorted_workloads = dict(sorted(
+        {f"client_{k}": v for k, v in work_loads.items()}.items(),
+        key=lambda item: item[1]
+    ))
+    
+    total_load = sum(work_loads.values())
+    if total_load < MAX_CLIENTS * 0.5:
+        status_level = "optimal"
+    elif total_load < MAX_CLIENTS * 0.8:
+        status_level = "high"
+    else:
+        status_level = "critical"
+    
+    status_data = {
+        "server": {
+            "status": "operational",
+            "status_level": status_level,
+            "version": __version__,
+            "uptime": uptime_formatted,
+            "uptime_seconds": int(uptime_seconds),
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime())
+        },
+        "telegram_bot": {
+            "username": f"@{StreamBot.username}",
+            "active_clients": len(multi_clients)
+        },
+        "resources": {
+            "total_workload": total_load,
+            "max_clients": MAX_CLIENTS,
+            "workload_distribution": sorted_workloads,
+            "cache": {
+                "current": len(class_cache),
+                "maximum": Var.CACHE_SIZE,
+                "utilization_percent": round((len(class_cache) / Var.CACHE_SIZE) * 100, 2)
+            }
+        },
+        "system": {
+            "chunk_size": f"{CHUNK_SIZE / (1024 * 1024):.1f} MB",
+        }
+    }
+    
+    return web.json_response(
+        status_data,
+        dumps=lambda obj: json.dumps(obj, indent=2, sort_keys=False)
+    )
+
+@routes.get(r"/watch/{path:.+}", allow_head=True)
+@exception_handler
+async def media_preview(request: web.Request):
+    path = request.match_info["path"]
+    message_id, secure_hash = parse_media_request(path, request.query)
+    rendered_page = await render_page(message_id, secure_hash, requested_action='stream')
+    return web.Response(
+        text=rendered_page,
+        content_type='text/html',
+        headers={
+            "Cache-Control": "no-cache, must-revalidate",
+            "Content-Security-Policy": "default-src 'self' https:; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://cdnjs.cloudflare.com https://cdn.plyr.io; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://cdn.jsdelivr.net https://cdnjs.cloudflare.com https://cdn.plyr.io; img-src 'self' data: https:; font-src 'self' https://fonts.gstatic.com https://cdnjs.cloudflare.com; connect-src 'self' https:; media-src 'self' https:;",
+            "X-Content-Type-Options": "nosniff",
+            "X-Frame-Options": "SAMEORIGIN",  
+            "X-XSS-Protection": "1; mode=block",
+            "Referrer-Policy": "strict-origin-when-cross-origin"
+        }
+    )
+
+@routes.get(r"/{path:.+}", allow_head=True)
+@exception_handler
+async def media_delivery(request: web.Request):
+    client_id, client = optimal_client_selection()
+    async with track_workload(client_id):
+        path = request.match_info["path"]
+        message_id, secure_hash = parse_media_request(path, request.query)
+        return await handle_media_stream(request, message_id, secure_hash, client_id, client)
+
+async def handle_media_stream(request, message_id, secure_hash, client_id, client):
+    streamer = await get_cached_streamer(client)
+    file_meta = await streamer.get_file_properties(message_id)
+    if file_meta.unique_id[:SECURE_HASH_LENGTH] != secure_hash:
+        raise InvalidHash("Security token mismatch")
+    file_size = file_meta.file_size
+    range_header = request.headers.get("Range", "")
+    if range_header:
+        range_match = RANGE_REGEX.fullmatch(range_header)
+        if not range_match:
+            logger.debug(f"Malformed range header received: {range_header}")
+            error_id = secrets.token_hex(6)
+            raise web.HTTPBadRequest(
+                text=json_error(400, MSG_MALFORMED_RANGE_HEADER, error_id=error_id),
+                content_type="application/json"
+            )
+        start = int(range_match.group("start")) if range_match.group("start") else 0
+        end = int(range_match.group("end")) if range_match.group("end") else file_size - 1
+    else:
+        try:
+            if hasattr(request, "http_range") and request.http_range:
+                start = request.http_range.start or 0
+                end = (request.http_range.stop or file_size) - 1
+            else:
+                start, end = 0, file_size - 1
+        except Exception:
+            start, end = 0, file_size - 1
+    if start < 0 or end >= file_size or start > end:
+        logger.debug(f"Invalid range request: start={start}, end={end}, file_size={file_size}")
+        raise web.HTTPRequestRangeNotSatisfiable(
+            headers={"Content-Range": f"bytes */{file_size}"}
+        )
+    offset = start - (start % CHUNK_SIZE)
+    first_chunk_cut = start - offset
+    last_chunk_cut = (end % CHUNK_SIZE) + 1
+    total_chunks = ((end - offset) // CHUNK_SIZE) + 1
+    mime_type = file_meta.mime_type or mimetypes.guess_type(file_meta.file_name)[0] or "application/octet-stream"
+    disposition = "inline" if mime_type.startswith(("video/", "audio/")) else "attachment"
+    original_filename = unquote(file_meta.file_name) if file_meta.file_name else f"file_{secrets.token_hex(4)}"
+    safe_filename = sanitize_filename(original_filename)
+    encoded_filename = quote(safe_filename)
+    headers = {
+        "Content-Type": mime_type,
+        "Content-Range": f"bytes {start}-{end}/{file_size}",
+        "Content-Length": str(end - start + 1),
+        "Content-Disposition": f"{disposition}; filename*=UTF-8''{encoded_filename}",
+        "Accept-Ranges": "bytes",
+        "Cache-Control": "public, max-age=31536000, immutable",
+        "Connection": "keep-alive",
+        "X-Content-Type-Options": "nosniff",
+        "Referrer-Policy": "strict-origin-when-cross-origin"
+    }
+    stream_generator = streamer.yield_file(
+        file_meta, client_id, offset, first_chunk_cut, last_chunk_cut, total_chunks, CHUNK_SIZE
+    )
+    return web.Response(
+        status=206 if range_header else 200,
+        body=stream_generator,
+        headers=headers
+    )

Thunder/template/dl.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta property="og:image" content="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/live.png">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Downloading: {{ file_name }}</title>
+    <meta http-equiv="refresh" content="0;url={{ src }}">
+    <style>
+        body { font-family: Arial, sans-serif; text-align: center; padding: 40px; color: #333; margin: 0; }
+        .container { max-width: 600px; margin: auto; }
+        p { margin-bottom: 20px; font-size: 1em; }
+        a { color: #0066cc; text-decoration: none; font-weight: bold; }
+        a:hover { text-decoration: underline; }
+        .message { padding: 20px; border: 1px solid #ddd; border-radius: 5px; background-color: #f9f9f9; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="message">
+            <p>Your download for <strong>{{ file_name }}</strong> should start automatically.</p>
+            <p>If it doesn't, please <a href="{{ src }}" download="{{ file_name }}">click here to download</a>.</p>
+        </div>
+    </div>
+</body>
+</html>

Thunder/template/req.html

@@ -0,0 +1,164 @@
+<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ heading }}</title>
+
+    <meta name="description" content="Easily share and distribute files">
+    <meta property="og:title" content="Thunder FileToLink">
+    <meta property="og:description" content="File Streamer">
+    <meta property="og:type" content="website">
+    <meta property="og:image" content="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/live.png">
+    <meta name="theme-color" content="#1a1a2e">
+    <meta name="msapplication-navbutton-color" content="#1a1a2e">
+    <meta name="apple-mobile-web-app-status-bar-style" content="#1a1a2e">
+    <meta name="color-scheme" content="dark light">
+    <meta name="application-name" content="Thunder FileToLink">
+    
+    <link rel="icon" href="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/Thunder.jpg">
+    <link rel="apple-touch-icon" href="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/Thunder.jpg">
+
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.7.2/css/all.min.css">
+    <link rel="stylesheet" href="https://cdn.plyr.io/3.7.8/plyr.css">
+
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/reqstyle.css">
+</head>
+<body>
+    <div class="loading-overlay" id="loading-overlay">
+        <div class="loading-spinner">
+            <div></div>
+            <div></div>
+        </div>
+    </div>
+    <button class="toggle-dark-mode" onclick="app.toggleDarkMode()" aria-label="Toggle Light/Dark Mode" aria-pressed="false" title="Toggle Light/Dark Mode"><i class="fas fa-moon"></i></button>
+    <div class="bg-animation"><div class="bg-gradient"></div></div>
+
+    <div class="container">
+        <header class="header">
+            <div class="file-info">
+                <h1 id="file-name">{{ file_name }}</h1>
+                <div class="file-meta"></div>
+            </div>
+        </header>
+
+        <main id="main-content" role="main" aria-label="Main content">
+            <div class="player-container">
+                <{{ tag }} id="player" playsinline controls preload="metadata" controlsList="nodownload">
+                <source src="{{ src }}" type="{{ tag }}/mp4">
+                    Your browser does not support the {{ tag }} tag.
+                </{{ tag }}>
+            </div>
+
+            <section class="controls-section" aria-label="File options">
+                <div class="dropdown-container" id="stream-dropdown-container">
+                    <button type="button" class="action-button secondary-button stream-btn" onclick="app.toggleStreamMenu(event)" aria-haspopup="true" aria-expanded="false" aria-controls="stream-menu" id="stream-btn-label">
+                        <i class="fas fa-play-circle" aria-hidden="true"></i><span>Stream</span>
+                    </button>
+                    <div class="dropdown-menu" id="stream-menu" aria-labelledby="stream-btn-label">
+                        <div class="stream-menu-header">
+                            <h3>Open with external player</h3>
+                            <button type="button" aria-label="Close menu" onclick="app.closeStreamMenu()" class="stream-menu-close">
+                                <i class="fas fa-times" aria-hidden="true"></i>
+                            </button>
+                        </div>
+                        <div class="stream-menu-content" role="menu">
+                            <div class="stream-category">
+                                <div class="category-heading" role="presentation">
+                                    <i class="fas fa-desktop" aria-hidden="true"></i>
+                                    <span>Desktop Players</span>
+                                </div>
+                                <div class="player-grid">
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('vlc-pc')" title="Open in VLC Player (PC)">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/vlc.png" alt="VLC Player icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">VLC Player</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('potplayer')" title="Open in PotPlayer">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/pot.png" alt="PotPlayer icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">PotPlayer</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('mpc')" title="Open in MPC-HC">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/classic.png" alt="MPC-HC icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">MPC-HC</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('kmpc')" title="Open in KM Player (PC)">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/km.webp" alt="KM Player icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">KM Player</span>
+                                    </button>
+                                </div>
+                            </div>
+                            <div class="stream-category">
+                                <div class="category-heading" role="presentation">
+                                    <i class="fas fa-mobile-alt" aria-hidden="true"></i>
+                                    <span>Mobile Players</span>
+                                </div>
+                                <div class="player-grid">
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('vlc')">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/vlc.png" alt="VLC Mobile icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">VLC Mobile</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('mxpro')">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/mx.png" alt="MX Pro icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">MX Pro</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('mx')">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/mx.png" alt="MX Player icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">MX Player</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('nplayer')">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/nPlayer.webp" alt="nPlayer icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">nPlayer</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('splayer')">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/splayer.webp" alt="S Player icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">S Player</span>
+                                    </button>
+                                    <button type="button" class="player-card dropdown-item" tabindex="0" role="menuitem" onclick="app.playOnline('km')">
+                                        <div class="player-icon">
+                                            <img src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/HydroStreamerBot/km.webp" alt="KM Player Mobile icon" loading="lazy" width="32" height="32">
+                                        </div>
+                                        <span class="player-name">KM Player</span>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <button type="button" class="action-button secondary-button" onclick="app.download()" title="Download the video"><i class="fas fa-cloud-download-alt" aria-hidden="true"></i><span>Download</span></button>
+                <button type="button" class="action-button secondary-button" onclick="app.copyLink()" title="Copy video link"><i class="fas fa-link" aria-hidden="true"></i><span>Copy Link</span></button>
+            </section>
+        </main>
+    </div>
+
+    <footer>
+        <p>Made by AI © 2025 | <a href="https://github.com/fyaz05/FileToLink" target="_blank" rel="noopener noreferrer"><i class="fab fa-github" aria-hidden="true"></i> GitHub</a></p>
+    </footer>
+
+    <div class="toast" id="toast" role="alert" aria-live="polite" aria-hidden="true">
+        <div class="toast-icon" aria-hidden="true"><i class="fas fa-info-circle"></i></div>
+        <div class="toast-message">Action completed.</div>
+    </div>
+
+    <script src="https://cdn.plyr.io/3.7.8/plyr.polyfilled.js"></script>
+    <script src="https://cdn.jsdelivr.net/gh/fyaz05/Resources@main/FileToLink/reqscript.js"></script>
+</body>
+</html>

Thunder/utils/bot_utils.py

@@ -0,0 +1,191 @@
+# Thunder/utils/bot_utils.py
+
+import asyncio
+import time
+import random
+import hashlib
+import uuid
+from typing import Optional, Tuple
+from urllib.parse import quote_plus, quote
+
+from pyrogram import Client, enums
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, User, CallbackQuery, LinkPreviewOptions
+from pyrogram.enums import ChatMemberStatus
+from pyrogram.raw.functions.messages import DeleteHistory
+from pyrogram.errors import FloodWait, UserNotParticipant, PeerIdInvalid, ChannelPrivate, ChatAdminRequired, BadRequest
+
+from Thunder.bot import StreamBot
+from Thunder.vars import Var
+from Thunder.utils.database import db
+from Thunder.utils.human_readable import humanbytes
+from Thunder.utils.logger import logger
+from Thunder.utils.messages import (
+    MSG_BUTTON_GET_HELP,
+    MSG_NEW_USER,
+    MSG_DC_UNKNOWN,
+    MSG_DC_USER_INFO,
+    MSG_LINKS,
+    MSG_BUTTON_STREAM_NOW,
+    MSG_BUTTON_DOWNLOAD,
+    MSG_ERROR_GENERIC_CALLBACK
+)
+from Thunder.utils.file_properties import get_name, get_media_file_size, get_hash
+from Thunder.utils.shortener import shorten
+
+
+async def notify_channel(bot: Client, text: str):
+    try:
+        if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
+            await bot.send_message(chat_id=Var.BIN_CHANNEL, text=text)
+    except Exception:
+        pass
+
+async def notify_owner(client: Client, text: str):
+    try:
+        owner_ids = Var.OWNER_ID
+        if isinstance(owner_ids, (list, tuple, set)):
+            tasks = [
+                client.send_message(chat_id=owner_id, text=text)
+                for owner_id in owner_ids
+            ]
+            results = await asyncio.gather(*tasks)
+            await asyncio.sleep(0.1)
+        else:
+            await client.send_message(chat_id=owner_ids, text=text)
+            await asyncio.sleep(0.1)
+        
+        if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0:
+            await client.send_message(chat_id=Var.BIN_CHANNEL, text=text)
+            await asyncio.sleep(0.1)
+    except Exception as e:
+        logger.error(f"Failed to send message to owner: {e}")
+
+async def handle_user_error(message: Message, error_msg: str):
+    try:
+        await message.reply_text(
+            error_msg,
+            quote=True,
+            link_preview_options=LinkPreviewOptions(is_disabled=True),
+            reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton(MSG_BUTTON_GET_HELP, callback_data="help_command")]
+            ])
+        )
+    except Exception:
+        pass
+
+async def log_new_user(bot: Client, user_id: int, first_name: str):
+    try:
+        if not await db.is_user_exist(user_id): 
+            await db.add_user(user_id)
+            if hasattr(Var, 'BIN_CHANNEL') and isinstance(Var.BIN_CHANNEL, int) and Var.BIN_CHANNEL != 0: 
+                await bot.send_message(
+                    Var.BIN_CHANNEL,
+                    MSG_NEW_USER.format(
+                        first_name=first_name,
+                        user_id=user_id
+                    )
+                )
+    except Exception:
+        pass
+
+async def generate_media_links(log_msg: Message, shortener: bool = True) -> Tuple[str, str, str, str]:
+    try:
+        base_url = Var.URL.rstrip("/")
+        
+        file_id = log_msg.id
+        
+        media_name = get_name(log_msg)
+        if isinstance(media_name, bytes):
+            media_name = media_name.decode('utf-8', errors='replace')
+        else:
+            media_name = str(media_name)
+        
+        media_size = humanbytes(get_media_file_size(log_msg))
+        file_name_encoded = quote(media_name)
+        hash_value = get_hash(log_msg)
+        
+        stream_link_raw = f"{base_url}/watch/{hash_value}{file_id}/{file_name_encoded}"
+        online_link_raw = f"{base_url}/{hash_value}{file_id}/{file_name_encoded}"
+        
+        stream_link = stream_link_raw
+        online_link = online_link_raw
+        
+        if shortener and getattr(Var, "SHORTEN_MEDIA_LINKS", False):
+            stream_link = await shorten(stream_link_raw)
+            online_link = await shorten(online_link_raw)
+        
+        return stream_link, online_link, media_name, media_size
+    except Exception as e:
+        logger.error(f"Error generating media links: {e}")
+        return "", "", "", ""
+
+async def send_links_to_user(client: Client, command_message: Message, media_name: str, media_size: str, stream_link: str, online_link: str):
+    msg_text = MSG_LINKS.format(
+        file_name=media_name,
+        file_size=media_size,
+        download_link=online_link,
+        stream_link=stream_link
+    )
+    
+    try:
+        await command_message.reply_text(
+            msg_text,
+            quote=True,
+            link_preview_options=LinkPreviewOptions(is_disabled=True),
+            parse_mode=enums.ParseMode.MARKDOWN,
+            reply_markup=InlineKeyboardMarkup([
+                [
+                    InlineKeyboardButton(MSG_BUTTON_STREAM_NOW, url=stream_link),
+                    InlineKeyboardButton(MSG_BUTTON_DOWNLOAD, url=online_link)
+                ]
+            ]),
+        )
+        await asyncio.sleep(0.3)
+    except Exception as e:
+        logger.error(f"Error sending links to user: {e}")
+        raise
+
+async def generate_dc_text(user: User) -> str:
+    dc_id = user.dc_id if user.dc_id is not None else MSG_DC_UNKNOWN
+    return MSG_DC_USER_INFO.format(
+        user_name=user.first_name or 'User',
+        user_id=user.id,
+        dc_id=dc_id
+    )
+
+async def get_user_safely(bot: Client, query) -> Optional[User]:
+    try:
+        if isinstance(query, str):
+            if query.startswith('@'):
+                return await bot.get_users(query)
+            elif query.isdigit():
+                return await bot.get_users(int(query))
+        elif isinstance(query, int):
+            return await bot.get_users(query)
+        return None
+    except Exception:
+        return None
+
+async def check_admin_privileges(client: Client, chat_id: int) -> bool:
+    try:
+        member = await client.get_chat_member(chat_id, client.me.id)
+        return member.status in [
+            ChatMemberStatus.ADMINISTRATOR,
+            ChatMemberStatus.OWNER
+        ]
+    except Exception:
+        return False
+
+async def _execute_command_from_callback(client: Client, callback_query: CallbackQuery, command_name: str, command_func):
+    try:
+        await callback_query.answer()
+        mock_message = callback_query.message
+        mock_message.from_user = callback_query.from_user
+        mock_message.chat = callback_query.message.chat
+        mock_message.text = f"/{command_name}"
+        mock_message.command = [command_name]
+        await command_func(client, mock_message)
+        logger.info(f"User {callback_query.from_user.id} used {command_name} via callback")
+    except Exception as e:
+        logger.error(f"Error in {command_name}_callback: {e}")
+        await callback_query.answer(MSG_ERROR_GENERIC_CALLBACK.format(error_id=uuid.uuid4().hex[:8]), show_alert=True)

Thunder/utils/broadcast_helper.py

@@ -0,0 +1,41 @@
+# Thunder/utils/broadcast_helper.py
+
+import asyncio
+import traceback
+from typing import Tuple
+
+from pyrogram.errors import FloodWait, InputUserDeactivated, UserIsBlocked, PeerIdInvalid
+from pyrogram.types import Message
+from Thunder.utils.logger import logger
+
+
+async def send_msg(user_id: int, message: Message) -> Tuple[int, str]:
+    # Attempt to forward a message to a user and handle exceptions
+    try:
+        await message.forward(chat_id=user_id)
+        return 200, None  # Success code
+
+    except FloodWait as e:
+        logger.warning(f"FloodWait error: sleeping for {e.value} seconds.")
+        await asyncio.sleep(e.value + 1)
+        return await send_msg(user_id, message)  # Retry after wait
+
+    except InputUserDeactivated:
+        error_msg = f"{user_id} : deactivated"
+        logger.error(error_msg)
+        return 400, error_msg
+
+    except UserIsBlocked:
+        error_msg = f"{user_id} : blocked the bot"
+        logger.error(error_msg)
+        return 400, error_msg
+
+    except PeerIdInvalid:
+        error_msg = f"{user_id} : user ID invalid"
+        logger.error(error_msg)
+        return 400, error_msg
+
+    except Exception as e:
+        error_msg = f"{user_id} : {traceback.format_exc()}"
+        logger.error(f"Unexpected error: {error_msg}", exc_info=True)
+        return 500, error_msg

Thunder/utils/config_parser.py

@@ -0,0 +1,45 @@
+# Thunder/utils/config_parser.py
+
+import os
+from typing import Dict, Optional
+from Thunder.utils.logger import logger
+
+
+class TokenParser:
+    # Class to parse multiple bot tokens from environment variables
+    
+    def __init__(self, config_file: Optional[str] = None):
+        # Initialize the TokenParser
+        self.tokens: Dict[int, str] = {}
+        self.config_file = config_file
+
+    def parse_from_env(self) -> Dict[int, str]:
+        # Parse bot tokens from environment variables
+        # MULTI_TOKEN1=token_1, MULTI_TOKEN2=token_2, etc.
+        
+        # Filter environment variables that start with "MULTI_TOKEN"
+        multi_tokens = {
+            key: value for key, value in os.environ.items() 
+            if key.startswith("MULTI_TOKEN") and value.strip()
+        }
+
+        if not multi_tokens:
+            logger.info("No MULTI_TOKEN environment variables found. Running with primary bot only.")
+            return {}
+
+        # Extract numeric part and sort tokens
+        sorted_tokens = sorted(
+            multi_tokens.items(),
+            key=lambda item: int(''.join(filter(str.isdigit, item[0])) or 0)
+        )
+
+        # Map to a dictionary with integer keys starting at 1
+        self.tokens = {
+            index + 1: token for index, (_, token) in enumerate(sorted_tokens) if token.strip()
+        }
+
+        if not self.tokens:
+            logger.info("No valid MULTI_TOKEN environment variables found. Running with primary bot only.")
+            return {}
+
+        return self.tokens

Thunder/utils/custom_dl.py

@@ -0,0 +1,396 @@
+# Thunder/utils/custom_dl.py
+
+import math
+import asyncio
+import time
+from typing import Dict, Union, Optional, AsyncGenerator
+from pyrogram import Client, utils, raw
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid, RPCError, FloodWait, FileReferenceExpired, FileReferenceInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from Thunder.vars import Var
+from Thunder.bot import work_loads
+from Thunder.server.exceptions import FileNotFound
+from .file_properties import get_file_ids
+from Thunder.utils.logger import logger
+
+class ByteStreamer:
+    # A custom class that handles streaming of media files from Telegram servers
+    
+    def __init__(self, client: Client):
+        self.client = client
+        self.clean_timer = 30 * 60  # Cache clean interval in seconds (30 minutes)
+        self.cached_file_ids: Dict[int, FileId] = {}
+        self.file_references_cache: Dict[int, Dict[str, Union[FileId, float]]] = {}
+        self.cache_lock = asyncio.Lock()
+        self.media_sessions_lock = asyncio.Lock()
+        
+        # Start cache cleaning tasks
+        self.cache_cleaner_task = asyncio.create_task(self.clean_cache())
+        self.session_cleaner_task = asyncio.create_task(self.cleanup_media_sessions())
+    
+    async def shutdown(self):
+        if hasattr(self, 'cache_cleaner_task'):
+            self.cache_cleaner_task.cancel()
+            try:
+                await self.cache_cleaner_task
+            except asyncio.CancelledError:
+                pass
+        
+        if hasattr(self, 'session_cleaner_task'):
+            self.session_cleaner_task.cancel()
+            try:
+                await self.session_cleaner_task
+            except asyncio.CancelledError:
+                pass
+        
+        # Clean up all media sessions
+        for dc_id, session in list(self.client.media_sessions.items()):
+            try:
+                await session.stop()
+            except Exception as e:
+                logger.debug(f"Error stopping media session for DC {dc_id}: {e}")
+        
+        self.client.media_sessions.clear()
+    
+    async def get_file_properties(self, message_id: int) -> FileId:
+        async with self.cache_lock:
+            file_id = self.cached_file_ids.get(message_id)
+        
+        if not file_id:
+            file_id = await self.generate_file_properties(message_id)
+            async with self.cache_lock:
+                self.cached_file_ids[message_id] = file_id
+        
+        return file_id
+    
+    async def generate_file_properties(self, message_id: int) -> FileId:
+        file_id = await get_file_ids(self.client, Var.BIN_CHANNEL, message_id)
+        
+        if not file_id:
+            logger.debug(f"Message ID {message_id} not found in the channel.")
+            raise FileNotFound(f"File with message ID {message_id} not found.")
+        
+        async with self.cache_lock:
+            self.cached_file_ids[message_id] = file_id
+        
+        return file_id
+    
+    async def refresh_file_reference(self, file_id: FileId) -> Optional[FileId]:
+        logger.debug(f"Refreshing file reference for message ID {file_id.message_id}")
+        
+        # Check if we have a fresh cached reference
+        async with self.cache_lock:
+            cached_ref = self.file_references_cache.get(file_id.message_id)
+            if cached_ref and time.time() - cached_ref["timestamp"] < 3600:  # Less than 1 hour old
+                return cached_ref["file_id"]
+        
+        try:
+            # Fetch the message again to get fresh file reference
+            message = await self.client.get_messages(
+                chat_id=Var.BIN_CHANNEL,
+                message_ids=file_id.message_id
+            )
+            
+            if not message or not message.media:
+                logger.debug(f"Media message {file_id.message_id} not found when refreshing file reference")
+                return None
+            
+            # Extract new file ID
+            new_file_id = await get_file_ids(self.client, Var.BIN_CHANNEL, file_id.message_id)
+            if not new_file_id:
+                logger.error(f"Failed to extract file ID from message {file_id.message_id}")
+                return None
+            
+            # Cache the new file reference
+            async with self.cache_lock:
+                self.file_references_cache[file_id.message_id] = {
+                    "file_id": new_file_id,
+                    "timestamp": time.time()
+                }
+            
+            return new_file_id
+        except Exception as e:
+            logger.error(f"Error refreshing file reference: {e}")
+            return None
+    
+    async def generate_media_session(self, client: Client, file_id: FileId) -> Session:
+        async with self.media_sessions_lock:
+            media_session = client.media_sessions.get(file_id.dc_id, None)
+            
+            if media_session is None:
+                if file_id.dc_id != await client.storage.dc_id():
+                    media_session = Session(
+                        client,
+                        file_id.dc_id,
+                        await Auth(
+                            client, file_id.dc_id, await client.storage.test_mode()
+                        ).create(),
+                        await client.storage.test_mode(),
+                        is_media=True,
+                    )
+                    await media_session.start()
+                    
+                    for attempt in range(6):
+                        if attempt > 0:
+                            # Add exponential backoff between attempts
+                            await asyncio.sleep(1 * (2 ** (attempt - 1)))
+                        
+                        try:
+                            exported_auth = await client.invoke(
+                                raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id)
+                            )
+                            
+                            try:
+                                await media_session.send(
+                                    raw.functions.auth.ImportAuthorization(
+                                        id=exported_auth.id, bytes=exported_auth.bytes
+                                    )
+                                )
+                                break
+                            except AuthBytesInvalid:
+                                continue
+                        except FloodWait as e:
+                            logger.warning(f"FloodWait during auth export: {e.value} seconds")
+                            await asyncio.sleep(e.value + 1)
+                            continue
+                    else:
+                        await media_session.stop()
+                        raise AuthBytesInvalid
+                else:
+                    media_session = Session(
+                        client,
+                        file_id.dc_id,
+                        await client.storage.auth_key(),
+                        await client.storage.test_mode(),
+                        is_media=True,
+                    )
+                    await media_session.start()
+                
+                # Mark the session creation time for cleanup
+                setattr(media_session, 'last_used', time.time())
+                client.media_sessions[file_id.dc_id] = media_session
+            else:
+                # Update last used time
+                setattr(media_session, 'last_used', time.time())
+        
+        return media_session
+    
+    @staticmethod
+    async def get_location(file_id: FileId) -> Union[
+        raw.types.InputPhotoFileLocation,
+        raw.types.InputDocumentFileLocation,
+        raw.types.InputPeerPhotoFileLocation,
+        None
+    ]:
+        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:
+            if not file_id.file_reference:
+                logger.debug("Missing file_reference for PHOTO type")
+                return None
+            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:
+            if not file_id.file_reference:
+                logger.debug("Missing file_reference for DOCUMENT type")
+                return None
+            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,
+        index: int,
+        offset: int,
+        first_part_cut: int,
+        last_part_cut: int,
+        part_count: int,
+        chunk_size: int,
+    ) -> AsyncGenerator[bytes, None]:
+        client = self.client
+        work_loads[index] += 1
+        
+        try:
+            media_session = await self.generate_media_session(client, file_id)
+            current_part = 1
+            
+            # Get file location
+            location = await self.get_location(file_id)
+            
+            # Handle missing file reference
+            if location is None:
+                logger.warning(f"Missing file reference for {file_id.message_id}, attempting to refresh")
+                refreshed_file_id = await self.refresh_file_reference(file_id)
+                if refreshed_file_id:
+                    location = await self.get_location(refreshed_file_id)
+                    file_id = refreshed_file_id
+                
+                if location is None:
+                    logger.error(f"Failed to get location for {file_id.message_id} even after refreshing file reference")
+                    raise FileNotFound(f"File location not found after refresh for {file_id.message_id}")
+            
+            max_retries = 5
+            
+            while current_part <= part_count:
+                try:
+                    r = await media_session.send(
+                        raw.functions.upload.GetFile(
+                            location=location, offset=offset, limit=chunk_size
+                        ),
+                        timeout=Var.TIMEOUT
+                    )
+                except FloodWait as e:
+                    logger.warning(f"FloodWait encountered: waiting for {e.value} seconds.")
+                    await asyncio.sleep(e.value + 1)
+                    continue
+                except (FileReferenceExpired, FileReferenceInvalid) as e:
+                    logger.warning(f"File reference for {file_id.message_id} expired/invalid: {e}. Attempting refresh.")
+                    refreshed_file_id = await self.refresh_file_reference(file_id)
+                    if refreshed_file_id:
+                        file_id = refreshed_file_id # Update file_id
+                        location = await self.get_location(file_id)
+                        if location is None:
+                            logger.error(f"Failed to get location for {file_id.message_id} after file reference refresh.")
+                            raise FileNotFoundError(f"File location not found after refresh for {file_id.message_id}")
+                        logger.info(f"Successfully refreshed file reference for {file_id.message_id} and got new location.")
+                        retry_count = 0
+                        continue
+                    else:
+                        logger.error(f"Failed to refresh file reference for {file_id.message_id}.")
+                        raise FileNotFoundError(f"Failed to refresh file reference for {file_id.message_id}")
+                except asyncio.TimeoutError as e: # Specific handling for asyncio.TimeoutError
+                    retry_count += 1
+                    logger.warning(f"TimeoutError during file fetch for {file_id.message_id} (attempt {retry_count}/{max_retries}): {e}")
+                    if retry_count >= max_retries:
+                        logger.error(f"Max retries reached for TimeoutError on {file_id.message_id}: {e}")
+                        raise TimeoutError(f"Max retries for TimeoutError on {file_id.message_id} after {max_retries} attempts.")
+                    await asyncio.sleep(1 * (2 ** (retry_count - 1)))
+                    continue
+                except RPCError as e:
+                    retry_count += 1
+                    logger.warning(f"RPC Error during file fetch for {file_id.message_id} (attempt {retry_count}/{max_retries}): {e}")
+                    if retry_count >= max_retries:
+                        logger.error(f"Max retries reached for RPCError on {file_id.message_id}: {e}")
+                        raise RPCError(f"Max retries for RPCError on {file_id.message_id}: {e}")
+                    await asyncio.sleep(1 * (2 ** (retry_count - 1)))
+                    continue
+                except ConnectionError as e:
+                    retry_count += 1
+                    logger.warning(f"Connection error during file fetch for {file_id.message_id} (attempt {retry_count}/{max_retries}): {e}")
+                    if retry_count >= max_retries:
+                        logger.error(f"Max retries reached for ConnectionError on {file_id.message_id}: {e}")
+                        raise ConnectionError(f"Max retries for ConnectionError on {file_id.message_id}: {e}")
+                    await asyncio.sleep(1)  # Brief pause before retry
+                    continue
+                except Exception as e:
+                    logger.error(f"Unexpected error during file fetch for {file_id.message_id}: {str(e)}", exc_info=True)
+                    raise
+                
+                if isinstance(r, raw.types.upload.File):
+                    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
+                    retry_count = 0  # Reset retry count after success
+
+                    if current_part > part_count:
+                        break
+        except (AttributeError) as e:
+            logger.error(f"Error while yielding file for {file_id.message_id if 'file_id' in locals() else 'unknown file'} (AttributeError): {e}", exc_info=True)
+            raise
+        finally:
+            work_loads[index] -= 1
+    
+    async def clean_cache(self) -> None:
+        while True:
+            try:
+                await asyncio.sleep(self.clean_timer)
+                
+                async with self.cache_lock:
+                    # Instead of clearing everything, we could selectively clean
+                    # based on timestamps if we tracked them
+                    self.cached_file_ids.clear()
+                    
+                    # Clean file reference cache based on age
+                    now = time.time()
+                    expired_refs = [
+                        key for key, value in self.file_references_cache.items()
+                        if now - value["timestamp"] > 3600  # 1 hour expiry
+                    ]
+                    for key in expired_refs:
+                        self.file_references_cache.pop(key, None)
+                
+                if expired_refs:
+                    logger.debug(f"Cache cleaned. Removed {len(expired_refs)} expired file references.")
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in cache cleaning task: {e}")
+                await asyncio.sleep(60)  # Wait before retrying
+    
+    async def cleanup_media_sessions(self) -> None:
+        while True:
+            try:
+                await asyncio.sleep(1800)  # 30 minutes
+                
+                async with self.media_sessions_lock:
+                    now = time.time()
+                    sessions_to_remove = []
+                    
+                    for dc_id, session in list(self.client.media_sessions.items()):
+                        if hasattr(session, 'last_used') and now - session.last_used > 1800:  # 30 minutes
+                            sessions_to_remove.append(dc_id)
+                    
+                    for dc_id in sessions_to_remove:
+                        try:
+                            await self.client.media_sessions[dc_id].stop()
+                            self.client.media_sessions.pop(dc_id, None)
+                        except Exception as e:
+                            logger.error(f"Error stopping media session for DC {dc_id}: {e}")
+                
+                if sessions_to_remove:
+                    logger.debug(f"Cleaned up {len(sessions_to_remove)} inactive media sessions")
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error in media session cleaning task: {e}")
+                await asyncio.sleep(60)  # Wait before retrying

Thunder/utils/database.py

@@ -0,0 +1,228 @@
+"""Database utilities for managing users, bans, and tokens via MongoDB."""
+import datetime
+from typing import Optional, Dict, Any
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorCollection
+from Thunder.utils.logger import logger
+from Thunder.vars import Var
+
+class Database:
+    # Database class for handling user data using MongoDB
+    
+    def __init__(self, uri: str, database_name: str, *args, **kwargs):
+        # Initialize database connection
+        self._client = AsyncIOMotorClient(uri, *args, **kwargs)
+        self.db = self._client[database_name]
+        self.col: AsyncIOMotorCollection = self.db.users
+        self.banned_users_col: AsyncIOMotorCollection = self.db.banned_users
+        self.token_col: AsyncIOMotorCollection = self.db.tokens
+        self.authorized_users_col: AsyncIOMotorCollection = self.db.authorized_users
+        self.restart_message_col: AsyncIOMotorCollection = self.db.restart_message
+    
+    async def ensure_indexes(self):
+        # Ensure necessary indexes are created
+        await self.banned_users_col.create_index("user_id", unique=True)
+        await self.token_col.create_index("token", unique=True)
+        await self.authorized_users_col.create_index("user_id", unique=True)
+        # Add unique index on users.id
+        await self.col.create_index("id", unique=True)
+
+        # TTL index to auto-remove expired tokens
+        await self.token_col.create_index("expires_at", expireAfterSeconds=0)
+        await self.restart_message_col.create_index("message_id", unique=True)
+        # TTL index to auto-remove expired restart messages
+        await self.restart_message_col.create_index("timestamp", expireAfterSeconds=3600)
+
+    def new_user(self, user_id: int) -> dict:
+        # Create new user document
+        return {
+            'id': user_id,
+            'join_date': datetime.datetime.utcnow()
+        }
+    
+    async def add_user(self, user_id: int):
+        # Add new user if not exists
+        if not await self.is_user_exist(user_id):
+            user = self.new_user(user_id)
+            await self.col.insert_one(user)
+    
+    async def add_user_pass(self, user_id: int, ag_pass: str):
+        # Add or update user password
+        await self.add_user(user_id)
+        await self.col.update_one({'id': user_id}, {'$set': {'ag_p': ag_pass}})
+    
+    async def get_user_pass(self, user_id: int) -> Optional[str]:
+        # Get user password
+        user_pass = await self.col.find_one({'id': user_id}, {'ag_p': 1})
+        return user_pass.get('ag_p') if user_pass else None
+    
+    async def is_user_exist(self, user_id: int) -> bool:
+        # Check if user exists
+        user = await self.col.find_one({'id': user_id}, {'_id': 1})
+        return bool(user)
+    
+    async def total_users_count(self) -> int:
+        # Count total users
+        return await self.col.count_documents({})
+    
+    async def get_all_users(self):
+        # Get all users (returns cursor)
+        return self.col.find({})
+    
+    async def delete_user(self, user_id: int):
+        # Delete user
+        await self.col.delete_one({'id': user_id})
+    
+    async def create_index(self):
+        # Create index for faster queries
+        await self.col.create_index("id", unique=True)
+        
+    async def get_active_users(self, days: int = 7):
+        # Get users active within specified days
+        cutoff = datetime.datetime.utcnow() - datetime.timedelta(days=days)
+        return self.col.find({'join_date': {'$gte': cutoff}})
+        
+    async def add_banned_user(
+        self, user_id: int, banned_by: Optional[int] = None,
+        reason: Optional[str] = None, ban_time: Optional[str] = None
+    ):
+        # Add or update banned user with upsert
+        ban_data = {
+            "user_id": user_id,
+            "banned_at": datetime.datetime.utcnow(),
+            "banned_by": banned_by,
+            "reason": reason
+        }
+        try:
+            await self.banned_users_col.update_one(
+                {"user_id": user_id},
+                {"$set": ban_data},
+                upsert=True
+            )
+        except Exception as e:
+            logger.error(
+                f"Database error in add_banned_user for user {user_id}: {e}"
+            )
+            raise RuntimeError(f"Failed to ban user {user_id}: {e}")
+
+    async def remove_banned_user(self, user_id: int) -> bool:
+        # Remove banned user and return if document was deleted
+        try:
+            result = await self.banned_users_col.delete_one(
+                {"user_id": user_id}
+            )
+            return result.deleted_count > 0
+        except Exception as e:
+            logger.error(
+                f"Database error in remove_banned_user for user {user_id}: {e}"
+            )
+            return False
+
+    async def is_user_banned(self, user_id: int) -> Optional[Dict[str, Any]]:
+        # Check if user is banned and return ban details
+        try:
+            return await self.banned_users_col.find_one({"user_id": user_id})
+        except Exception as e:
+            logger.error(
+                f"Database error in is_user_banned for user {user_id}: {e}"
+            )
+            return None
+
+    async def check_user_token(self, user_id: int) -> Dict[str, bool]:
+        """Check if user has valid token."""
+        try:
+            # Only return active (not expired) tokens
+            token_data = await self.token_col.find_one({
+                "user_id": user_id,
+                "expires_at": {"$gt": datetime.datetime.utcnow()}
+            })
+            return {"has_token": bool(token_data)}
+        except Exception as e:
+            logger.error(f"Database error checking token for {user_id}: {e}")
+            return {"has_token": False}
+            
+    async def update_user_token(self, user_id: int, token: str) -> None:
+        """Update user's active token in database."""
+        try:
+            # Find the token data first
+            token_data = await self.token_col.find_one({"token": token})
+            
+            if token_data:
+                # Link token to user and refresh expiration
+                await self.token_col.update_one(
+                    {"token": token},
+                    {"$set": {
+                        "user_id": user_id,
+                        "expires_at": datetime.datetime.utcnow() + datetime.timedelta(hours=Var.TOKEN_TTL_HOURS)
+                    }}
+                )
+            else:
+                # If no token data found, create a basic entry (this is a fallback)
+                logger.warning(f"Token {token} not found in database when assigning to user {user_id}")
+                await self.token_col.insert_one({
+                    "user_id": user_id,
+                    "token": token,
+                    "created_at": datetime.datetime.utcnow(),
+                    "expires_at": datetime.datetime.utcnow() + datetime.timedelta(hours=Var.TOKEN_TTL_HOURS)
+                })
+        except Exception as e:
+            logger.error(f"Database error updating token for {user_id}: {e}")
+            raise RuntimeError(f"Failed to update token: {e}")
+
+    async def save_broadcast_state(self, broadcast_id, state_data):
+        broadcast_collection = self.db.broadcasts
+        await broadcast_collection.update_one(
+            {"_id": broadcast_id},
+            {"$set": state_data},
+            upsert=True
+        )
+
+    async def get_broadcast_state(self, broadcast_id):
+        broadcast_collection = self.db.broadcasts
+        state = await broadcast_collection.find_one({"_id": broadcast_id})
+        return state
+
+    async def list_active_broadcasts(self):
+        broadcast_collection = self.db.broadcasts
+        cursor = broadcast_collection.find({"is_cancelled": False})
+        return await cursor.to_list(length=100)
+
+    async def add_restart_message(self, message_id: int, chat_id: int) -> None:
+        """Store the restart message ID and chat ID."""
+        try:
+            await self.restart_message_col.insert_one(
+                {"message_id": message_id, "chat_id": chat_id, "timestamp": datetime.datetime.utcnow()}
+            )
+            logger.debug(f"Restart message {message_id} in chat {chat_id} saved to DB.")
+        except Exception as e:
+            logger.error(f"Database error saving restart message: {e}")
+
+    async def get_restart_message(self) -> Optional[Dict[str, Any]]:
+        """Retrieve the restart message from the database."""
+        try:
+            # Get the most recent restart message
+            restart_msg = await self.restart_message_col.find_one(sort=[("timestamp", -1)])
+            if restart_msg:
+                logger.debug(f"Retrieved restart message {restart_msg['message_id']} from DB.")
+            return restart_msg
+        except Exception as e:
+            logger.error(f"Database error retrieving restart message: {e}")
+            return None
+
+    async def delete_restart_message(self, message_id: int) -> None:
+        """Delete the restart message from the database."""
+        try:
+            result = await self.restart_message_col.delete_one({"message_id": message_id})
+            if result.deleted_count > 0:
+                logger.debug(f"Restart message {message_id} deleted from DB.")
+            else:
+                logger.debug(f"Attempted to delete non-existent restart message {message_id}.")
+        except Exception as e:
+            logger.error(f"Database error deleting restart message: {e}")
+
+    async def close(self):
+        # Close database connection
+        if self._client:
+            self._client.close()
+
+# Initialize the Database instance
+db = Database(Var.DATABASE_URL, Var.NAME)

Thunder/utils/decorators.py

@@ -0,0 +1,119 @@
+from functools import wraps
+from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
+from Thunder.vars import Var
+from Thunder.utils.messages import (
+    MSG_DECORATOR_BANNED,
+    MSG_TOKEN_INVALID,
+    MSG_ERROR_UNAUTHORIZED
+)
+from Thunder.utils.database import db
+from Thunder.utils.logger import logger
+from Thunder.utils.tokens import check, allowed, generate
+from Thunder.utils.shortener import shorten
+
+def _check_message_user(message):
+    """Helper to validate message and user."""
+    if not message.from_user:
+        return None
+    return message.from_user.id
+
+def check_banned(func):
+    @wraps(func)
+    async def wrapper(client, message: Message, *args, **kwargs):
+        user_id = _check_message_user(message)
+        if not user_id:
+            return await func(client, message, *args, **kwargs)
+            
+        if user_id in Var.OWNER_ID:
+            return await func(client, message, *args, **kwargs)
+            
+        ban_details = await db.is_user_banned(user_id)
+        if ban_details:
+            banned_at = ban_details.get('banned_at')
+            if banned_at and hasattr(banned_at, 'strftime'):
+                ban_time = banned_at.strftime('%B %d, %Y, %I:%M %p UTC')
+            else:
+                ban_time = str(banned_at) if banned_at else 'N/A'
+            
+            ban_message = MSG_DECORATOR_BANNED.format(
+                reason=ban_details.get('reason', 'Not specified'),
+                ban_time=ban_time
+            )
+            await message.reply_text(ban_message, quote=True)
+            return
+            
+        return await func(client, message, *args, **kwargs)
+    return wrapper
+
+def require_token(func):
+    @wraps(func)
+    async def wrapper(client, message: Message, *args, **kwargs):
+        user_id = _check_message_user(message)
+        if not user_id:
+            return await func(client, message, *args, **kwargs)
+        
+        if not getattr(Var, "TOKEN_ENABLED", False):
+            return await func(client, message, *args, **kwargs)
+        
+        if user_id in Var.OWNER_ID:
+            return await func(client, message, *args, **kwargs)
+        
+        if await allowed(user_id):
+            return await func(client, message, *args, **kwargs)
+        
+        if not await check(user_id):
+            token_data = await generate(user_id)
+            me = await client.get_me()
+            deep_link = f"https://t.me/{me.username}?start={token_data['token']}"
+            
+            try:
+                short_url = await shorten(deep_link)
+            except Exception as e:
+                logger.error(f"URL shortening failed: {e}")
+                short_url = deep_link
+
+            await message.reply_text(
+                MSG_TOKEN_INVALID,
+                reply_markup=InlineKeyboardMarkup(
+                    [[InlineKeyboardButton("Get Token", url=short_url)]]
+                ),
+                quote=True
+            )
+            return
+        
+        return await func(client, message, *args, **kwargs)
+    return wrapper
+
+def shorten_link(func):
+    @wraps(func)
+    async def wrapper(client, message: Message, *args, **kwargs):
+        user_id = None
+        if message.from_user:
+            user_id = message.from_user.id
+
+        if user_id and (user_id in Var.OWNER_ID or await allowed(user_id)):
+            kwargs['shortener'] = False
+        else:
+            kwargs['shortener'] = getattr(Var, "SHORTEN_MEDIA_LINKS", False)
+        
+        return await func(client, message, *args, **kwargs)
+    return wrapper
+
+
+def get_owner_ids():
+    """Helper function to safely get owner IDs."""
+    owner_ids = Var.OWNER_ID if hasattr(Var, 'OWNER_ID') and Var.OWNER_ID is not None else []
+    if isinstance(owner_ids, int):
+        owner_ids = [owner_ids]
+    return owner_ids
+
+
+def owner_only(func):
+    """Decorator to restrict access to bot owners."""
+    async def wrapper(client, callback_query):
+        owner_ids = get_owner_ids()
+        if callback_query.from_user.id not in owner_ids:
+            await callback_query.answer(MSG_ERROR_UNAUTHORIZED, show_alert=True)
+            return
+        await func(client, callback_query)
+    return wrapper

Thunder/utils/file_properties.py

@@ -0,0 +1,75 @@
+# Thunder/utils/file_properties.py
+
+from pyrogram import Client
+from pyrogram.types import Message
+from pyrogram.file_id import FileId
+from Thunder.server.exceptions import FileNotFound
+from Thunder.utils.logger import logger
+from typing import Any, Optional
+
+def get_media_from_message(message: Message) -> Optional[Any]:
+    # Extract media from message using known media type attributes
+    media_types = ("audio", "document", "photo", "sticker", 
+                  "animation", "video", "voice", "video_note")
+    
+    for attr in media_types:
+        if media := getattr(message, attr, None):
+            return media
+    return None
+
+def parse_file_id(message: Message) -> Optional[FileId]:
+    # Decode FileId from media if available
+    if media := get_media_from_message(message):
+        return FileId.decode(media.file_id)
+    logger.warning(f"No media found in message: {message.id}")
+    return None
+
+def parse_file_unique_id(message: Message) -> Optional[str]:
+    # Extract unique file ID from media if available
+    if media := get_media_from_message(message):
+        return media.file_unique_id
+    logger.warning("No media found for unique ID extraction")
+    return None
+
+async def get_file_ids(client: Client, chat_id: int, message_id: int) -> FileId:
+    # Fetch and process media file details from message
+    try:
+        message = await client.get_messages(chat_id, message_id)
+        if not message or message.empty:
+            logger.debug("Message not found or empty")
+            raise FileNotFound("Message not found/empty")
+
+        if not (media := get_media_from_message(message)):
+            logger.debug("Message contains no media")
+            raise FileNotFound("No media in message")
+
+        file_id = parse_file_id(message)
+        if not file_id:
+            logger.debug("Failed to parse file ID")
+            raise FileNotFound("Invalid file ID")
+
+        # Enhance FileId object with additional metadata
+        file_id.file_size = getattr(media, "file_size", 0)
+        file_id.mime_type = getattr(media, "mime_type", "")
+        file_id.file_name = getattr(media, "file_name", "")
+        file_id.unique_id = parse_file_unique_id(message)
+
+        return file_id
+
+    except Exception as e:
+        logger.debug(f"File ID processing failed: {str(e)}")
+        raise
+
+def get_hash(media_msg: Message) -> str:
+    # Generate short hash from file unique ID
+    if media := get_media_from_message(media_msg):
+        return media.file_unique_id[:6]
+    return ""
+
+def get_name(media_msg: Message) -> str:
+    # Extract filename from media if available
+    return getattr(get_media_from_message(media_msg), "file_name", "")
+
+def get_media_file_size(message: Message) -> int:
+    # Get file size from media content
+    return getattr(get_media_from_message(message), "file_size", 0)

Thunder/utils/force_channel.py

@@ -0,0 +1,99 @@
+"""
+Decorator to enforce channel membership before allowing command execution in Pyrogram bots.
+"""
+
+from typing import Any, Callable, Coroutine
+import asyncio
+import uuid
+
+from pyrogram import Client
+from pyrogram.enums import ChatMemberStatus
+from pyrogram.errors import UserNotParticipant, ChatAdminRequired, RightForbidden, RPCError, FloodWait
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+
+from Thunder.vars import Var
+from Thunder.utils.logger import logger
+from Thunder.utils.messages import (
+    MSG_FORCE_CHANNEL_ERROR,
+    MSG_FORCE_CHANNEL_RPC_ERROR,
+    MSG_FORCE_CHANNEL_GENERIC_ERROR,
+    MSG_FORCE_CHANNEL_NO_LINK,
+    MSG_FORCE_CHANNEL_MEMBERSHIP_REQUIRED,
+    MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION,
+    MSG_FORCE_CHANNEL_ACCESS_REQUIRED
+)
+
+def force_channel_check(
+    func: Callable[[Client, Message], Coroutine[Any, Any, Any]]
+) -> Callable[[Client, Message], Coroutine[Any, Any, Any]]:
+    """Decorator to enforce channel membership before allowing command execution."""
+    async def wrapper(client: Client, message: Message, *args, **kwargs) -> None:
+        if not Var.FORCE_CHANNEL_ID:
+            await func(client, message, *args, **kwargs)
+            return
+
+        if message.chat.id == Var.FORCE_CHANNEL_ID:
+            await func(client, message, *args, **kwargs)
+            return
+
+        user_id = message.from_user.id
+        try:
+            member = await client.get_chat_member(
+                chat_id=Var.FORCE_CHANNEL_ID,
+                user_id=user_id
+            )
+            if member.status in [ChatMemberStatus.MEMBER, ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.OWNER]:
+                await func(client, message, *args, **kwargs)
+                return
+        except UserNotParticipant:
+            logger.debug(f"[ForceChannelCheck] User {user_id} is not a participant of FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID}. Prompting to join.")
+        except (ChatAdminRequired, RightForbidden):
+            logger.error(f"[ForceChannelCheck] Bot lacks permissions in FORCE_CHANNEL_ID {Var.FORCE_CHANNEL_ID}.")
+            await message.reply(MSG_FORCE_CHANNEL_ERROR.format(error_id=uuid.uuid4().hex[:8]))
+            return
+        except asyncio.TimeoutError:
+            error_id = uuid.uuid4().hex[:8]
+            logger.error(f"[ForceChannelCheck] TimeoutError (ID: {error_id}) for user {user_id} while checking membership in {Var.FORCE_CHANNEL_ID}.")
+            await message.reply(MSG_FORCE_CHANNEL_RPC_ERROR.format(error_id=error_id))
+            return
+        except RPCError as e:
+            logger.error(f"[ForceChannelCheck] RPCError for user {user_id} in {Var.FORCE_CHANNEL_ID}: {e}")
+            await message.reply(MSG_FORCE_CHANNEL_RPC_ERROR.format(error_id=uuid.uuid4().hex[:8]))
+            return
+        except FloodWait as e:
+            wait_time: int = e.value
+            logger.debug(f"[ForceChannelCheck] Flood wait for {wait_time} seconds")
+            await asyncio.sleep(wait_time)
+            return await wrapper(client, message, *args, **kwargs)
+        except Exception as e:
+            logger.error(f"[ForceChannelCheck] Unexpected error for user {user_id} in {Var.FORCE_CHANNEL_ID}: {e}")
+            await message.reply(MSG_FORCE_CHANNEL_GENERIC_ERROR.format(error_id=uuid.uuid4().hex[:8]))
+            return
+
+        try:
+            chat = await client.get_chat(Var.FORCE_CHANNEL_ID)
+            invite_link = f"https://t.me/{chat.username}" if chat.username else chat.invite_link
+            if not invite_link:
+                logger.warning(f"[ForceChannelCheck] No invite link for {Var.FORCE_CHANNEL_ID} ({chat.title})")
+                await message.reply(MSG_FORCE_CHANNEL_NO_LINK)
+                return
+
+            await message.reply(
+                MSG_FORCE_CHANNEL_MEMBERSHIP_REQUIRED.format(channel_name=chat.title, error_id=uuid.uuid4().hex[:8]),
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton(MSG_FORCE_CHANNEL_ACCESS_REQUIRED, url=invite_link)],
+                ]),
+            )
+        except asyncio.TimeoutError:
+            error_id = uuid.uuid4().hex[:8]
+            logger.error(f"[ForceChannelCheck] TimeoutError (ID: {error_id}) getting chat/invite link for {Var.FORCE_CHANNEL_ID}.")
+            await message.reply(MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION.format(error_id=error_id))
+        except RPCError as e:
+            logger.error(f"[ForceChannelCheck] RPCError getting chat/invite link for {Var.FORCE_CHANNEL_ID}: {e}")
+            await message.reply(MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION.format(error_id=uuid.uuid4().hex[:8]))
+        except Exception as e:
+            logger.error(f"[ForceChannelCheck] Unexpected error getting chat/invite link for {Var.FORCE_CHANNEL_ID}: {e}")
+            await message.reply(MSG_FORCE_CHANNEL_GENERIC_ERROR.format(error_id=uuid.uuid4().hex[:8]))
+    return wrapper
+
+

Thunder/utils/human_readable.py

@@ -0,0 +1,16 @@
+# Thunder/utils/human_readable.py
+
+def humanbytes(size: int, decimal_places: int = 2) -> str:
+    # Converts bytes to human-readable format (KB, MB, GB, etc.)
+    if not size:
+        return "0 B"
+        
+    power = 2 ** 10
+    n = 0
+    units = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
+    
+    while size >= power and n < len(units) - 1:
+        size /= power
+        n += 1
+        
+    return f"{round(size, decimal_places)} {units[n]}B"

Thunder/utils/keepalive.py

@@ -0,0 +1,22 @@
+# Thunder/utils/keepalive.py
+
+import asyncio
+import aiohttp
+from Thunder.vars import Var
+from Thunder.utils.logger import logger
+
+async def ping_server():
+    # Periodically pings server URL to keep it alive
+    sleep_time = Var.PING_INTERVAL
+    
+    while True:
+        await asyncio.sleep(sleep_time)
+        try:
+            async with aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=10)            ) as session:
+                async with session.get(Var.URL) as resp:
+                    pass
+        except asyncio.TimeoutError:
+            logger.warning("Server ping timeout")
+        except Exception as e:
+            logger.error(f"Ping error: {str(e)}")

Thunder/utils/logger.py

@@ -0,0 +1,42 @@
+# Thunder/utils/logger.py
+
+import logging
+from logging.handlers import RotatingFileHandler
+import sys
+import os
+
+# Get project root and setup log directory
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+LOG_DIR = os.path.join(PROJECT_ROOT, 'logs')
+os.makedirs(LOG_DIR, exist_ok=True)
+LOG_FILE = os.path.join(LOG_DIR, 'bot.txt')
+
+# Configure logger
+logger = logging.getLogger('ThunderBot')
+logger.setLevel(logging.INFO)
+logger.propagate = False
+
+# Setup log formatting
+log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+# Configure rotating file handler (10MB max, 5 backup files)
+file_handler = RotatingFileHandler(
+    LOG_FILE,
+    maxBytes=10 * 1024 * 1024,
+    backupCount=5
+)
+file_handler.setFormatter(log_formatter)
+file_handler.setLevel(logging.INFO)
+
+
+# Configure console output
+console_handler = logging.StreamHandler(sys.stdout)
+console_handler.setFormatter(log_formatter)
+console_handler.setLevel(logging.INFO)
+
+
+# Add handlers to our logger instance
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
+
+__all__ = ['logger', 'LOG_FILE']

Thunder/utils/messages.py

@@ -0,0 +1,433 @@
+"""
+Centralized message constants for the Thunder File to Link Bot.
+All user-facing strings should be defined here to maintain consistency and ease of maintenance.
+"""
+
+# =====================================================================================
+# ====== ERROR MESSAGES ======
+# =====================================================================================
+
+# ------ General Errors ------
+MSG_ERROR_GENERIC = "⚠️ **Oops!** Something went wrong. Please try again. If the issue persists, contact support."
+MSG_ERROR_USER_INFO = "❗ **User Not Found:** Couldn't find user. Please check the ID or Username."
+MSG_ERROR_INVALID_ARG = "❗ Please provide a valid Telegram user ID or username."
+MSG_ERROR_RATE_LIMIT = "⏳ **Slow Down!** Too many requests. Please wait `{seconds}` seconds."
+MSG_ERROR_PRIVATE_CHAT_ONLY = "⚠️ **Private Chat Only:** This command works only in a private chat with me."
+
+# ------ User Input & Validation Errors ------
+MSG_INVALID_USER_ID = "❌ **Invalid User ID:** Please provide a numeric user ID."
+MSG_ERROR_START_BOT = "⚠️ You need to start the bot in private first to use this command.\n👉 [Click here]({invite_link}) to start a private chat."
+MSG_ERROR_REPLY_FILE = "⚠️ Please use the /link command in reply to a file."
+MSG_ERROR_NO_FILE = "⚠️ The message you're replying to does not contain any file."
+MSG_ERROR_INVALID_NUMBER = "⚠️ **Invalid number specified.**"
+MSG_ERROR_NUMBER_RANGE = "⚠️ **Please specify a number between 1 and 100.**"
+MSG_ERROR_DM_FAILED = "⚠️ I couldn't send you a Direct Message. Please start the bot first."
+
+# ------ File & Media Errors ------
+MSG_ERROR_FILE_INVALID = "🚫 **File Error:** Invalid file. It might be deleted or inaccessible."
+MSG_ERROR_FILE_INVALID_ID = "🚫 **File Error:** Invalid file. It might be deleted or inaccessible. Please provide a valid message ID from the bot's storage channel."
+MSG_ERROR_LINK_GENERATION = "⚠️ **Link Generation Failed!** 🔗 Unable to create links for this file. It might be inaccessible or corrupted."
+MSG_ERROR_FILE_ID_EXTRACT = "⚠️ **File Error:** Could not extract file identifier from the media. Please try sending the file again."
+MSG_MEDIA_ERROR = "⚠️ **Media Error:** The file appears to be empty or corrupted. Please try sending a valid file."
+MSG_ERROR_PROCESSING_MEDIA = "⚠️ **Oops!** Something went wrong while processing your media. Please try again. If the issue persists, contact support."
+MSG_ERROR_CHANNEL_BANNED = "🚫 **Channel Banned:** Files from this channel are blocked."
+MSG_ERROR_NO_MEDIA_FOUND = "⚠️ **No Media Found:** Please send or reply to a valid media file."
+MSG_FILE_ACCESS_ERROR = "⚙️ **Error Retrieving File!** Could not fetch details. File might be unavailable, ID incorrect, or deleted from storage."
+
+# ------ Admin Action Errors (Ban, Auth, etc.) ------
+MSG_BAN_ERROR = "🚨 **Ban error:** {error}"
+MSG_UNBAN_ERROR = "🚨 **Unban error:** {error}"
+MSG_AUTHORIZE_FAILED = (
+    "❌ **Authorization Failed:** "
+    "Could not authorize user `{user_id}`."
+)
+MSG_DEAUTHORIZE_FAILED = (
+    "❌ **Deauthorization Failed:** "
+    "User `{user_id}` was not authorized or an error occurred."
+)
+MSG_TOKEN_FAILED = (
+    "⚠️ **Token Activation Failed!**\n\n"
+    "> ❗ Reason: {reason}\n\n"
+    "🔑 Please check your token or contact support."
+)
+MSG_TOKEN_ERROR = "⚙️ **Token Activation Error:** Something went wrong. Please try again."
+MSG_SHELL_ERROR = """**❌ Shell Command Error ❌**
+<pre>{error}</pre>"""
+MSG_SHELL_LARGE_OUTPUT = """Output is too large, sending as a file.
+Error: {error}"""
+
+# ------ System & Bot Errors ------
+MSG_ERROR_NOT_ADMIN = "⚠️ **Admin Required:** I need admin privileges to work here."
+MSG_DC_INVALID_USAGE = "🤔 **Invalid Usage:** Please reply to a user's message or a media file to get DC info."
+MSG_DC_ANON_ERROR = "😥 **Cannot Get Your DC Info:** Unable to identify you. This command might not work for anonymous users."
+MSG_DC_FILE_ERROR = "⚙️ **Error Getting File DC Info:** Could not fetch details. File might be inaccessible."
+MSG_STATS_ERROR = "❌ **Stats Error:** Could not retrieve system statistics."
+MSG_STATUS_ERROR = "❌ **Status Error:** Could not retrieve system status."
+MSG_DB_ERROR = "❌ **Database Error:** Could not retrieve user count."
+MSG_LOG_ERROR = "❌ **Log Retrieval Error:** Could not get logs\n\n> ❗ Error: `{error}`"
+MSG_RESTART_FAILED = "❌ **Restart Failed:** Could not reboot the bot."
+MSG_CRITICAL_ERROR = (
+    "🚨 **Critical Media Processing Error** 🚨\n\n"
+    "> ⚠️ Details:\n```\n{error}\n```\n\n"
+    "Please investigate immediately! (ID: {error_id})"
+)
+
+# =====================================================================================
+# ====== ADMIN MESSAGES ======
+# =====================================================================================
+
+# ------ Ban/Unban ------
+MSG_DECORATOR_BANNED = "You are currently banned and cannot use this bot.\nReason: {reason}\nBanned on: {ban_time}"
+MSG_BAN_USAGE = "⚠️ **Usage:** /ban [user_id] [reason]"
+MSG_CANNOT_BAN_OWNER = "❌ **Cannot ban an owner.**"
+MSG_ADMIN_USER_BANNED = "✅ **User {user_id} has been banned."
+MSG_BAN_REASON_SUFFIX = "\n📝 **Reason:** {reason}"
+MSG_ADMIN_NO_BAN_REASON = "No reason provided"
+MSG_USER_BANNED_NOTIFICATION = "🚫 **You have been banned from using this bot.**"
+MSG_COULD_NOT_NOTIFY_USER = "⚠️ Could not notify user {user_id}: {error}"
+MSG_UNBAN_USAGE = "⚠️ **Usage:** /unban <user_id>"
+MSG_ADMIN_USER_UNBANNED = "✅ **User {user_id} has been unbanned."
+MSG_USER_UNBANNED_NOTIFICATION = "🎉 **You have been unbanned from using this bot.**"
+MSG_USER_NOT_IN_BAN_LIST = "ℹ️ **User {user_id} was not found in the ban list."
+
+# ------ Token & Authorization ------
+MSG_TOKEN_DISABLED = "🚫 **Token System Disabled:** This feature is not currently enabled."
+MSG_AUTHORIZE_USAGE = "🔑 **Usage:** `/authorize <user_id>`"
+MSG_DEAUTHORIZE_USAGE = "🔒 **Usage:** `/deauthorize <user_id>`"
+MSG_AUTHORIZE_SUCCESS = (
+    "✅ **User Authorized!**\n\n"
+    "> 👤 User ID: `{user_id}`\n"
+    "> 🔑 Access: Permanent"
+)
+MSG_DEAUTHORIZE_SUCCESS = (
+    "✅ **User Deauthorized!**\n\n"
+    "> 👤 User ID: `{user_id}`\n"
+    "> 🔒 Access: Revoked"
+)
+MSG_TOKEN_ACTIVATED = (
+    "✅ **Token Activated Successfully!**\n\n"
+    "> 🗓️ Access granted until: **{expiry_date}**\n"
+    "> 📝 Details: _{description}_\n\n"
+    "✨ Enjoy all the features!"
+)
+MSG_TOKEN_VERIFIED = "🎉 **Token Verified!** You're all set to use the bot's features."
+MSG_TOKEN_INVALID = "🚫 **Expired or Invalid Token.** Please get a new token to continue."
+MSG_NO_AUTH_USERS = "ℹ️ **No Authorized Users Found:** The list is currently empty."
+MSG_AUTH_USER_INFO = """{i}. 👤 User ID: `{user_id}`
+   • Authorized by: `{authorized_by}`
+   • Date: `{auth_time}`\n\n"""
+MSG_ADMIN_AUTH_LIST_HEADER = "🔐 **Authorized Users List**\n\n"
+
+# ------ Shell Commands ------
+MSG_SHELL_USAGE = (
+    "<b>Usage:</b>\n"
+    "/shell <command>\n\n"
+    "<b>Example:</b>\n"
+    "/shell ls -l"
+)
+MSG_SHELL_EXECUTING = "Executing Command... ⚙️\n<pre>{command}</pre>"
+MSG_SHELL_OUTPUT = """**Shell Command Output:**
+<pre>{output}</pre>"""
+MSG_SHELL_OUTPUT_STDOUT = "<b>[stdout]:</b>\n<pre>{output}</pre>"
+MSG_SHELL_OUTPUT_STDERR = "<b>[stderr]:</b>\n<pre>{error}</pre>"
+MSG_SHELL_NO_OUTPUT = "✅ <b>Command Executed:</b> No output."
+MSG_ADMIN_SHELL_STDOUT_PLAIN = "[stdout]:\n{output}\n"
+MSG_ADMIN_SHELL_STDERR_PLAIN = "[stderr]:\n{error}\n"
+MSG_SHELL_OUTPUT_FILENAME = "shell_output.txt"
+
+# ------ Admin View & Control ------
+MSG_ADMIN_RESTART_BROADCAST = "🔄 Restart Broadcast"
+MSG_ADMIN_CANCEL_BROADCAST = "🛑 Cancel Broadcast"
+MSG_ADMIN_CANCEL_BROADCAST_BUTTON_TEXT = "ID: {broadcast_id} | Progress: {progress} | Time: {elapsed}"
+MSG_ADMIN_BOT_WORKLOAD_HEADER = "🤖 **Bot Workload Distribution:**\n\n"
+MSG_ADMIN_BOT_WORKLOAD_ITEM = "   {bot_name}: {load}\n"
+MSG_ADMIN_BROADCAST_PROGRESS_ITEM = "ID: {broadcast_id} | Progress: {progress} | Time: {elapsed}"
+MSG_ADMIN_RESTART_DONE = "✅ **Restart Successful!**"
+
+# =====================================================================================
+# ====== BUTTON TEXTS (User-facing) ======
+# =====================================================================================
+MSG_BUTTON_STREAM_NOW = "🖥️ Stream"
+MSG_BUTTON_DOWNLOAD = "📥 Download"
+MSG_BUTTON_GET_HELP = "📖 Get Help"
+MSG_BUTTON_QUICK_START = "🚀 Quick Start"
+MSG_BUTTON_CANCEL_BROADCAST = "🛑 Cancel Broadcast"
+MSG_BUTTON_VIEW_PROFILE = "👤 View User Profile"
+MSG_BUTTON_ABOUT = "ℹ️ About Bot"
+MSG_BUTTON_STATUS = "📡 Status"
+MSG_BUTTON_JOIN_CHANNEL = "📢 Join {channel_title}"
+MSG_BUTTON_GITHUB = "🛠️ GitHub"
+MSG_BUTTON_START_CHAT = "📩 Start Chat"
+MSG_BUTTON_JOIN_CHAT = "📢 Join {chat_title}"
+
+# ------ Quick Start Guide ------
+MSG_QUICK_START_GUIDE = (
+    "🚀 **Quick Start Guide** 🚀\n\n"
+    "Welcome to the Thunder File to Link Bot! Here's how to get started:\n\n"
+    "1. **Private Chat:** Send any file directly to me, and I'll reply with download and stream links.\n"
+    "2. **Groups:** Reply to a file with the `/link` command. For multiple files, reply to the first file with `/link <number>` (e.g., `/link 5`).\n"
+    "3. **Explore:** Use `/help` to see all available commands and features.\n\n"
+    "Enjoy fast and easy file sharing! ⚡"
+)
+
+# =====================================================================================
+# ====== COMMAND RESPONSES (User-facing) ======
+# =====================================================================================
+
+# ------ Welcome, Help, About ------
+MSG_WELCOME = (
+    "🌟 **Welcome, {user_name}!** 🌟\n\n"
+    "I'm **Thunder File to Link Bot** ⚡\n"
+    "I generate direct download and streaming links for your files.\n\n"
+    "**How to use:**\n"
+    "1. Send any file to me for private links.\n"
+    "2. In groups, reply to a file with `/link`.\n\n"
+    "» Use `/help` for all commands and detailed information.\n\n"
+    "🚀 Send a file to begin!"
+)
+
+MSG_HELP = (
+    "📘 **Thunder Bot - Help Guide** 📖\n\n"
+    "How to get direct download & streaming links:\n\n"
+    "**🚀 Private Chat (with me):**\n"
+    "> 1. Send me **any file** (document, video, audio, photo, etc.).\n"
+    "> 2. I'll instantly reply with your links! ⚡\n\n"
+    "**👥 Using in Groups:**\n"
+    "> • Reply to any file with `/link`.\n"
+    "> • **Batch Mode:** Reply to the *first* file with `/link <number>` (e.g., `/link 5` for 5 files, up to 100).\n"
+    "> • Bot needs administrator rights in the group to function.\n"
+    "> • Links are posted in the group & sent to you privately (if you have started a chat with me).\n"
+    "> • *Optional:* If the bot is an admin with delete rights, it can be configured to auto-link new files.\n\n"
+    "**📢 Using in Channels:**\n"
+    "> • Add me as an administrator with necessary permissions.\n"
+    "> • I can be configured to auto-detect new media files.\n"
+    "> • Inline stream/download buttons can be added to files automatically.\n"
+    "> • Files from banned channels (owner configuration) are rejected.\n"
+    "> • Auto-posting links for new files is a configurable option.\n\n"
+    "**⚙️ Available Commands:**\n"
+    "> `/start` 👋 - Welcome message & quick start information.\n"
+    "> `/help` 📖 - Shows this help message.\n"
+    "> `/link <num>` 🔗 - (Groups) Generate links. For batch processing: `/link <number>` (1-100 files).\n"
+    "> `/about` ℹ️ - Learn more about me and my features.\n"
+    "> `/ping` 📡 - Check my responsiveness and online status.\n"
+    "> `/dc` 🌍 - View DC information (for yourself, another user, or a file).\n\n"
+    "**💡 Pro Tips:**\n"
+    "> • You can forward files from other chats directly to me.\n"
+    "> • If you encounter a rate limit message, please wait the specified time. ⏳\n"
+    "> • For `/link` in groups to work reliably (and for private link delivery), ensure you've started a private chat with me first.\n"
+    "> • Processing batch files might take a bit longer. Please be patient. 🐌\n\n"
+    "❓ Questions? Please ask in our support group!"
+)
+
+MSG_ABOUT = (
+    "🌟 **About Thunder File to Link Bot** ℹ️\n\n"
+    "I'm your go-to bot for **instant direct download & streaming links!** ⚡\n\n"
+    "**🚀 Key Features:**\n"
+    "> **Instant Links:** Get your links within seconds.\n"
+    "> **Online Streaming:** Watch videos or listen to audio directly (for supported formats).\n"
+    "> **Universal File Support:** Handles documents, videos, audio, photos, and more.\n"
+    "> **High-Speed Access:** Optimized for fast link generation and file access.\n"
+    "> **Secure & Reliable:** Your files are handled with care during processing.\n"
+    "> **User-Friendly Interface:** Designed for ease of use on any device.\n"
+    "> **Efficient Processing:** Built for speed and reliability.\n"
+    "> **Batch Mode:** Process multiple files at once in groups using `/link <number>`.\n"
+    "> **Versatile Usage:** Works in private chats, groups, and channels (with admin setup).\n\n"
+    "💖 If you find me useful, please consider sharing me with your friends!"
+)
+
+# ------ Ping ------
+MSG_PING_START = "🛰️ **Pinging...** Please wait."
+MSG_PING_RESPONSE = (
+    "🚀 **PONG! Bot is Online!** ⚡\n"
+    "> ⏱️ **Response Time:** {time_taken_ms:.2f} ms\n"
+    "> 🤖 **Bot Status:** `Active & Ready`"
+)
+
+# ------ DC Info ------
+MSG_DC_USER_INFO = (
+    "📍 **Information**\n"
+    "> 👤 **User:** [{user_name}](tg://user?id={user_id})\n"
+    "> 🆔 **User ID:** `{user_id}`\n"
+    "> 🌍 **DC ID:** `{dc_id}`"
+)
+
+MSG_DC_FILE_INFO = (
+    "🗂️ **File Information**\n"
+    ">`{file_name}`\n"
+    "💾 **File Size:** `{file_size}`\n"
+    "📁 **File Type:** `{file_type}`\n"
+    "🌍 **DC ID:** `{dc_id}`"
+)
+
+MSG_DC_UNKNOWN = "Unknown"
+
+# ------ File Link Generation ------
+MSG_LINKS = (
+    "✨ **Your Links are Ready!** ✨\n\n"
+    "> `{file_name}`\n\n"
+    "📂 **File Size:** `{file_size}`\n\n"
+    "🔗 **Download Link:**\n`{download_link}`\n\n"
+    "🖥️ **Stream Link:**\n`{stream_link}`\n\n"
+    "⌛️ *Note: Links remain active while the bot is running and the file is accessible.*"
+)
+
+# =====================================================================================
+# ====== USER NOTIFICATIONS ======
+# =====================================================================================
+
+MSG_NEW_USER = (
+    "✨ **New User Alert!** ✨\n"
+    "> 👤 **Name:** [{first_name}](tg://user?id={user_id})\n"
+    "> 🆔 **User ID:** `{user_id}`\n\n"
+)
+
+MSG_PRIVATE_CHAT_WELCOME = (
+    "👋 **Welcome!** Send me any file to get started.\n"
+    "> 📤 I'll generate instant download & streaming links for you.\n"
+    "> ⚡ Fast and reliable service.\n"
+    "> 🔒 Your files are handled securely."
+)
+MSG_DEFAULT_WELCOME = "📢 Don't forget our channel for the latest news & features!"
+MSG_COMMUNITY_CHANNEL = "📢 **{channel_title}:** 🔒 Join this channel to use the bot."
+
+# =====================================================================================
+# ====== PROCESSING MESSAGES ======
+# =====================================================================================
+
+# ------ General File Processing ------
+MSG_PROCESSING_REQUEST = "⏳ **Processing your request...**"
+MSG_PROCESSING_FILE = "⏳ **Processing your file...**"
+MSG_DEFAULT_FILENAME = "Untitled File"
+MSG_NEW_FILE_REQUEST = (
+    "> 👤 **Source:** [{user_name}](tg://user?id={user_id})\n"
+    "> 🆔 **ID:** `{user_id}`\n\n"
+    "🔗 **Download:** `{online_link}`\n\n"
+    "🖥️ **Stream:** `{stream_link}`"
+)
+
+# ------ Batch Processing ------
+MSG_PROCESSING_BATCH = "🔄 **Processing Batch {batch_number}/{total_batches}** ({file_count} files)"
+MSG_PROCESSING_STATUS = "📊 **Processing Files:** {processed}/{total} complete, {failed} failed"
+MSG_PROCESSING_WARNING = "⚠️ **Warning:** Too many files failed processing. Please try again with fewer files or contact support."
+MSG_BATCH_LINKS_READY = "🔗 **Batch Links ({count} files):**\n\n`{links}`"
+MSG_BATCH_LINKS_FROM = "📬 **Links from {chat_title}**\n\n`{links_message}`"
+MSG_PROCESSING_RESULT = "✅ **Process Complete:** {processed}/{total} files processed successfully, {failed} failed"
+MSG_PROCESSING_ERROR = "❌ **Error Processing Files:** {error}\n\n{processed}/{total} files were processed (ID: {error_id})"
+MSG_RETRYING_FILES = "🔄 **Retrying {count} Failed Files...**"
+
+# =====================================================================================
+# ====== BROADCAST MESSAGES ======
+# =====================================================================================
+MSG_BROADCAST_START = "📣 **Starting Broadcast...**\n\n> ⏳ Please wait for completion."
+MSG_BROADCAST_PROGRESS = (
+    "📊 **Broadcast Progress**\n\n"
+    "> 👥 **Total Users:** `{total_users}`\n"
+    "> ✅ **Processed:** `{processed}/{total_users}`\n"
+    "> ⏱️ **Elapsed:** `{elapsed_time}`\n\n"
+    "> ✓ **Sent:** `{successes}`\n"
+    "> ✗ **Failed:** `{failures}`"
+)
+
+# =====================================================================================
+# ====== PERMISSION MESSAGES ======
+# =====================================================================================
+MSG_ERROR_UNAUTHORIZED = "You are not authorized to view this information."
+MSG_ERROR_BROADCAST_RESTART = "Please use the /broadcast command to start a new broadcast."
+MSG_ERROR_BROADCAST_INSTRUCTION = "To start a new broadcast, use the /broadcast command and reply to the message you want to broadcast."
+MSG_ERROR_CALLBACK_UNSUPPORTED = "This button is not active or no longer supported."
+MSG_ERROR_GENERIC_CALLBACK = "An error occurred. Please try again later. (ID: {error_id})"
+MSG_BROADCAST_COMPLETE = (
+    "📢 **Broadcast Completed Successfully!** 📢\n"
+    "──────────────────────────────\n"
+    "⏱️ **Duration:** `{elapsed_time}`\n"
+    "👥 **Total Users:** `{total_users}`\n"
+    "✅ **Successful Deliveries:** `{successes}`\n"
+    "❌ **Failed Deliveries:** `{failures}`\n"
+    "──────────────────────────────\n"
+    "🗑️ **Accounts Removed (Blocked/Deactivated):** `{deleted_accounts}`\n" # Clarified
+    "──────────────────────────────"
+)
+MSG_BROADCAST_CANCEL = "🛑 **Cancelling Broadcast:** `{broadcast_id}`\n\n> ⏳ Stopping operations..."
+MSG_BROADCAST_FAILED = (
+    "❌ **Broadcast Failed!** 😞\n\n"
+    "> ❗ **Error Details:**\n```\n{error}\n``` (ID: {error_id})"
+)
+MSG_INVALID_BROADCAST_CMD = "Please reply to the message you want to broadcast."
+MSG_NO_ACTIVE_BROADCASTS = "ℹ️ **No Active Broadcasts:** Nothing to cancel at the moment."
+MSG_BROADCAST_NOT_FOUND = "⚠️ **Broadcast Not Found:** This broadcast is no longer active or has finished."
+MSG_MULTIPLE_BROADCASTS = "🔄 **Multiple Broadcasts Active:** Select one to cancel:"
+MSG_CANCELLING_BROADCAST = "🛑 **Cancelling Broadcast:** `{broadcast_id}`\n\n> ⏳ Stopping operations... Please wait."
+
+# =====================================================================================
+# ====== FORCE CHANNEL MESSAGES ======
+# =====================================================================================
+
+MSG_FORCE_CHANNEL_ERROR = "Sorry, there was an issue verifying access. Please try again later. (ID: {error_id})"
+MSG_FORCE_CHANNEL_RPC_ERROR = "An unexpected error occurred while checking channel membership. Please try again. (ID: {error_id})"
+MSG_FORCE_CHANNEL_GENERIC_ERROR = "An error occurred. Please try again. (ID: {error_id})"
+MSG_FORCE_CHANNEL_NO_LINK = "To use this bot, you must join our main channel. Please contact an admin for assistance."
+MSG_FORCE_CHANNEL_ACCESS_REQUIRED = (
+    "🚫 **Access Required**\n\n"
+    "Please join our channel to use this bot:\n{invite_link}\n\n"
+    "After joining, try your command again."
+)
+MSG_FORCE_CHANNEL_SERVICE_INTERRUPTION = "⚠️ Temporary service interruption. Please try again later. (ID: {error_id})"
+MSG_FORCE_CHANNEL_MEMBERSHIP_REQUIRED = "🔒 This command requires channel membership. Please contact support if you need assistance. (ID: {error_id})"
+
+# =====================================================================================
+# ====== FILE TYPE DESCRIPTIONS ======
+# =====================================================================================
+MSG_FILE_TYPE_DOCUMENT = "📄 Document"
+MSG_FILE_TYPE_PHOTO = "🖼️ Photo"
+MSG_FILE_TYPE_VIDEO = "🎬 Video"
+MSG_FILE_TYPE_AUDIO = "🎵 Audio"
+MSG_FILE_TYPE_VOICE = "🎤 Voice Message"
+MSG_FILE_TYPE_STICKER = "🎨 Sticker"
+MSG_FILE_TYPE_ANIMATION = "🎞️ Animation (GIF)"
+MSG_FILE_TYPE_VIDEO_NOTE = "📹 Video Note"
+MSG_FILE_TYPE_UNKNOWN = "❓ Unknown File Type"
+
+# =====================================================================================
+# ====== SYSTEM & STATUS MESSAGES (Bot Health, Logs, Stats) ======
+# =====================================================================================
+
+MSG_RESTARTING = "🔄 **Restarting Bot...**\n\n> ⏳ Please wait a moment."
+MSG_LOG_FILE_CAPTION = "📄 **System Logs**\n\n> ℹ️ Latest log file"
+MSG_LOG_FILE_EMPTY = "ℹ️ **Log File Empty:** No data found in the log file."
+MSG_LOG_FILE_MISSING = "⚠️ **Log File Missing:** Could not find the log file."
+MSG_SYSTEM_STATUS = (
+    "✅ **System Status:** Operational\n\n"
+    "> 🕒 **Uptime:** `{uptime}`\n"
+    "> 🤖 **Active Bot Instances:** `{active_bots}`\n\n"
+    "{workloads}\n"
+    "> ♻️ **Bot Version:** `{version}`"
+)
+MSG_SYSTEM_STATS = (
+    "📊 **System Statistics**\n\n"
+    "> 🕒 **Uptime:** `{uptime}`\n\n"
+    "💾 **Storage (Server):**\n"
+    "> 📀 Total: `{total}`\n"
+    "> 📝 Used: `{used}`\n"
+    "> 📭 Free: `{free}`\n\n"
+    "📶 **Network (Server):**\n"
+    "> 🔺 Upload: `{upload}`\n"
+    "> 🔻 Download: `{download}`\n\n"
+)
+MSG_PERFORMANCE_STATS = (
+    "⚙️ **Performance (Server):**\n"
+    "> 🖥️ CPU: `{cpu_percent}%`\n"
+    "> 🧠 RAM: `{ram_percent}%`\n"
+    "> 📦 Disk: `{disk_percent}%`"
+)
+MSG_DB_STATS = "📊 **Database Statistics**\n\n> 👥 **Total Users:** `{total_users}`"
+MSG_BOT_WORKLOAD_ITEM = "🔹 Bot {num}: {load}"
+MSG_BOT_WORKLOAD_TEXT = "   {bot_name}: {load}\n"
+
+# =====================================================================================
+# ====== API & SERVER ERROR MESSAGES ======
+# =====================================================================================
+
+MSG_INVALID_SECURITY_CREDENTIALS = "Invalid security credentials"
+MSG_FILE_NOT_FOUND = "File not found"
+MSG_MALFORMED_RANGE_HEADER = "Malformed range header"
+MSG_INTERNAL_SERVER_ERROR = "Internal server error (Reference ID: {error_id})"

Thunder/utils/render_template.py

@@ -0,0 +1,47 @@
+# Thunder/utils/render_template.py
+
+import urllib.parse
+import html as html_module
+from jinja2 import Environment, FileSystemLoader
+from Thunder.vars import Var
+from Thunder.bot import StreamBot
+from Thunder.utils.file_properties import get_file_ids
+from Thunder.server.exceptions import InvalidHash
+from Thunder.utils.logger import logger
+
+# Initialize Jinja2 environment
+template_env = Environment(loader=FileSystemLoader('Thunder/template'), enable_async=True)
+
+async def render_page(id: int, secure_hash: str, requested_action: str | None = None) -> str: # Re-add requested_action
+    file_data = await get_file_ids(StreamBot, int(Var.BIN_CHANNEL), id)
+    if file_data.unique_id[:6] != secure_hash:
+        logger.debug(f'Link hash: {secure_hash} - Expected: {file_data.unique_id[:6]}')
+        logger.debug(f"Invalid hash for message ID {id}")
+        raise InvalidHash
+
+    quoted_filename = urllib.parse.quote(file_data.file_name.replace('/', '_'))
+    src = urllib.parse.urljoin(Var.URL, f'{secure_hash}{str(id)}/{quoted_filename}')
+    
+    safe_filename = html_module.escape(file_data.file_name)
+    
+    template_name: str
+    context: dict
+
+    if requested_action == 'stream':
+        template_name = 'req.html'
+        context = {
+            'tag': "video",
+            'heading': f"View {safe_filename}",
+            'file_name': safe_filename,
+            'src': src
+        }
+    else:  # Default to download
+        template_name = 'dl.html'
+        context = {
+            'file_name': safe_filename,
+            'src': src
+        }
+
+    template = template_env.get_template(template_name)
+    html_content = await template.render_async(**context)
+    return html_content

Thunder/utils/shortener.py

@@ -0,0 +1,243 @@
+'''URL shortening utility.'''
+import asyncio
+from typing import Dict, Optional
+from base64 import b64encode
+from random import random, choice
+from urllib.parse import quote, urlparse
+from warnings import filterwarnings
+import cloudscraper
+
+from Thunder.vars import Var
+from Thunder.utils.logger import logger
+
+# Global shortener dictionary, scraper session, lock, and status flag
+shortener_dict: Dict[str, str] = {}
+_scraper_session: Optional[cloudscraper.CloudScraper] = None
+_init_lock = asyncio.Lock()
+_shortener_system_ready = False
+
+# Suppress insecure HTTPS warnings
+try:
+    import urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+except (ImportError, AttributeError):
+    filterwarnings('ignore', message='Unverified HTTPS request')
+
+def _init_shorteners() -> bool:
+    """Initializes shortener config and the global scraper session."""
+    global shortener_dict, _scraper_session, _shortener_system_ready
+    
+    _shortener_system_ready = False # Assume failure until success
+    shortener_dict = {}
+    _scraper_session = None
+    
+    # Check if shortening is enabled via Var
+    is_enabled = getattr(Var, "SHORTEN_ENABLED", False) or getattr(Var, "SHORTEN_MEDIA_LINKS", False)
+    if not is_enabled:
+        logger.info("ⓘ URL shortening is disabled")
+        return False
+    
+    # Get URL shortener configuration
+    site = getattr(Var, "URL_SHORTENER_SITE", "")
+    api_key = getattr(Var, "URL_SHORTENER_API_KEY", "")
+    
+    if site and api_key:
+        shortener_dict[site] = api_key
+        try:
+            _scraper_session = cloudscraper.create_scraper(
+                browser={
+                    'browser': 'chrome',
+                    'platform': 'android',
+                    'desktop': False
+                }
+            )
+            logger.info(f"✓ Shortener initialized: {site} (session created)")
+            _shortener_system_ready = True
+            return True
+        except Exception as e:
+            logger.error(f"Failed to create scraper session: {e}")
+            # Reset to ensure clean state on session creation failure
+            shortener_dict = {}
+            _scraper_session = None
+            _shortener_system_ready = False
+            return False
+    
+    logger.warning("ⓘ URL shortener not configured or API key missing")
+    _shortener_system_ready = False # Explicitly ensure it's false
+    return False
+
+def _validate_url(url: str) -> bool:
+    """Checks if a string is a well-formed URL."""
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except Exception:
+        return False
+
+async def short_url(longurl: str, attempt: int = 0) -> str:
+    """Shortens a URL using a configured service, with retries and fallback."""
+    global _shortener_system_ready, _scraper_session # Ensure globals are accessible
+
+    if not _shortener_system_ready:  # First check (no lock)
+        async with _init_lock:
+            if not _shortener_system_ready:  # Double check (with lock)
+                _init_shorteners()  # Attempt initialization
+
+    if not _shortener_system_ready:
+        # Initialization failed or not enabled, _init_shorteners logs details
+        return longurl
+        
+    if _scraper_session is None:
+        logger.error(
+            "Critical state: _shortener_system_ready is True, but _scraper_session is None. "
+            "Attempting a locked re-initialization."
+        )
+        async with _init_lock:
+            _init_shorteners()
+        
+        if not _shortener_system_ready or _scraper_session is None:
+            logger.error(
+                "Critical: Scraper session remains uninitialized after re-attempt. "
+                "URL shortening will be skipped for this request."
+            )
+            return longurl
+
+    if attempt >= 3:
+        logger.warning(f"Max attempts reached for {longurl}. Returning original.")
+        return longurl
+    
+    if not _validate_url(longurl):
+        logger.warning(f"Invalid URL format: {longurl}. Returning original.")
+        return longurl
+    
+    try:
+        session = _scraper_session 
+        
+        # Ensure shortener_dict is not empty before trying to access its items
+        if not shortener_dict:
+            logger.error("Shortener dictionary is empty. Cannot proceed with shortening.")
+            return longurl # Or raise an exception if this state is unexpected
+            
+        _shortener, _shortener_api = choice(list(shortener_dict.items()))
+        
+        # --- Shorte.st --- 
+        if "shorte.st" in _shortener:
+            headers = {"public-api-token": _shortener_api}
+            data = {"urlToShorten": quote(longurl)}
+            response = session.put(
+                "https://api.shorte.st/v1/data/url",
+                headers=headers,
+                data=data
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"HTTP error {response.status_code}")
+                
+            return response.json()["shortenedUrl"]
+            
+        # --- Linkvertise ---        
+        elif "linkvertise" in _shortener:
+            url = quote(b64encode(longurl.encode("utf-8")))
+            linkvertise = [
+                f"https://link-to.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+                f"https://up-to-down.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+                f"https://direct-link.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+                f"https://file-link.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+            ]
+            return choice(linkvertise)
+            
+        # --- Bitly.com ---    
+        elif "bitly.com" in _shortener:
+            headers = {"Authorization": f"Bearer {_shortener_api}"}
+            response = session.post(
+                "https://api-ssl.bit.ly/v4/shorten",
+                json={"long_url": longurl},
+                headers=headers
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"HTTP error {response.status_code}")
+                
+            return response.json()["link"]
+            
+        # --- Ouo.io ---    
+        elif "ouo.io" in _shortener:
+            response = session.get(
+                f"http://ouo.io/api/{_shortener_api}?s={longurl}",
+                verify=False
+            )
+            
+            if not response.text or response.status_code != 200:
+                raise Exception(f"HTTP error {response.status_code}")
+                
+            return response.text
+            
+        # --- Cutt.ly ---    
+        elif "cutt.ly" in _shortener:
+            response = session.get(
+                f"http://cutt.ly/api/api.php?key={_shortener_api}&short={longurl}"
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"HTTP error {response.status_code}")
+                
+            return response.json()["url"]["shortLink"]
+            
+        # --- Generic & Fallback ---    
+        else:
+            # Generic shortener handling
+            response = session.get(
+                f"https://{_shortener}/api?api={_shortener_api}&url={quote(longurl)}"
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"Generic API error {response.status_code}")
+                
+            result = response.json()
+            shorted = result.get("shortenedUrl")
+            
+            # Fallback to shrtco.de if generic failed or no result
+            if not shorted:
+                try:
+                    shrtco_response = session.get(
+                        f"https://api.shrtco.de/v2/shorten?url={quote(longurl)}"
+                    )
+                    
+                    if shrtco_response.status_code != 200:
+                        logger.warning(f"shrtco.de fallback failed with status {shrtco_response.status_code}")
+                        return longurl # Return original if fallback also fails badly
+                        
+                    shrtco_result = shrtco_response.json()
+                    if not shrtco_result.get("ok") or "result" not in shrtco_result or "full_short_link" not in shrtco_result["result"]:
+                        logger.warning(f"shrtco.de fallback response malformed: {shrtco_result}")
+                        return longurl
+                        
+                    shrtco_link = shrtco_result["result"]["full_short_link"]
+                    
+                    # Try the configured generic shortener again with the shrtco.de link
+                    response = session.get(
+                        f"https://{_shortener}/api?api={_shortener_api}&url={shrtco_link}"
+                    )
+                    
+                    if response.status_code != 200:
+                        logger.warning(f"Generic shortener retry with shrtco.de link failed: status {response.status_code}")
+                        return longurl # Return original if retry fails
+                        
+                    result = response.json()
+                    shorted = result.get("shortenedUrl")
+                except Exception as fallback_e:
+                    logger.error(f"shrtco.de fallback exception: {fallback_e}")
+                    return longurl # Return original on fallback exception
+            
+            return shorted if shorted else longurl
+            
+    except Exception as e:
+        shortener_name = _shortener if '_shortener' in locals() else 'unknown'
+        logger.error(f"URL shortener error ({shortener_name} for {longurl}): {e}, attempt {attempt + 1}")
+        
+        await asyncio.sleep(1) # Wait before retrying
+        return await short_url(longurl, attempt + 1)
+
+async def shorten(url: str) -> str:
+    """Async public wrapper for short_url."""
+    return await short_url(url)

Thunder/utils/time_format.py

@@ -0,0 +1,18 @@
+# Thunder/utils/time_format.py
+
+def get_readable_time(seconds: int) -> str:
+    # Convert seconds to human-readable time format (e.g., "2d 5h 30m 10s")
+    periods = [
+        ('d', 86400),  # Days
+        ('h', 3600),   # Hours
+        ('m', 60),     # Minutes
+        ('s', 1)       # Seconds
+    ]
+    result = []
+
+    for suffix, period in periods:
+        if seconds >= period:
+            value, seconds = divmod(seconds, period)
+            result.append(f"{int(value)}{suffix}")
+
+    return ' '.join(result) if result else '0s'

Thunder/utils/tokens.py

@@ -0,0 +1,265 @@
+"""
+Token generation, verification, and authorization management for the Thunder bot.
+"""
+
+import uuid
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, AsyncIterator, List, Union
+from motor.motor_asyncio import AsyncIOMotorCursor
+
+from Thunder.utils.database import db
+from Thunder.utils.logger import logger
+from Thunder.vars import Var
+
+async def check(user_id: int) -> bool:
+    """
+    Verify if a user has a valid token.
+    
+    Args:
+        user_id: User's Telegram ID
+        
+    Returns:
+        bool: True if user has valid token, False otherwise
+    """
+    try:
+        # Check if token system is enabled
+        if not getattr(Var, "TOKEN_ENABLED", False):
+            return True  # Token system disabled
+            
+        # Check if user is owner
+        if isinstance(Var.OWNER_ID, (list, tuple, set)):
+            is_owner = user_id in Var.OWNER_ID
+        else:
+            is_owner = user_id == Var.OWNER_ID
+            
+        # Check if user is owner or authorized
+        if is_owner or await allowed(user_id):
+            return True
+            
+        # Check for valid token
+        token_data = await db.token_col.find_one({"user_id": user_id})
+        if not token_data:
+            return False
+            
+        # Check if token is expired
+        if token_data["expires_at"] <= datetime.utcnow():
+            return False
+            
+        return True
+    except Exception as e:
+        logger.error(f"Error in token check for user {user_id}: {e}")
+        return False
+
+async def generate(user_id: int) -> Dict[str, Any]:
+    """
+    Generate a new token for a user.
+    
+    Args:
+        user_id: User's Telegram ID
+        
+    Returns:
+        dict: Token data with expiration time
+    """
+    try:
+        duration = getattr(Var, "TOKEN_TTL_HOURS", 24)
+        token = str(uuid.uuid4())
+        created_at = datetime.utcnow()
+        expires_at = created_at + timedelta(hours=duration)
+        
+        token_data = {
+            "user_id": user_id,
+            "token": token,
+            "created_at": created_at,
+            "expires_at": expires_at
+        }
+        
+        # Store or update token in database
+        await db.token_col.update_one(
+            {"user_id": user_id},
+            {"$set": token_data},
+            upsert=True
+        )
+        
+        return token_data
+    except Exception as e:
+        logger.error(f"Failed to generate token for user {user_id}: {e}")
+        raise
+
+async def allowed(user_id: int) -> bool:
+    """
+    Check if a user is authorized (permanently allowed).
+    
+    Args:
+        user_id: User's Telegram ID
+        
+    Returns:
+        bool: True if user is authorized, False otherwise
+    """
+    try:
+        auth_data = await db.authorized_users_col.find_one({"user_id": user_id})
+        return bool(auth_data)
+    except Exception as e:
+        logger.error(f"Error checking authorization for user {user_id}: {e}")
+        return False
+
+async def authorize(user_id: int, authorized_by: int) -> bool:
+    """
+    Authorize a user to use the bot permanently.
+    
+    Args:
+        user_id: User's Telegram ID to authorize
+        authorized_by: Admin's Telegram ID who authorized
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        auth_data = {
+            "user_id": user_id,
+            "authorized_by": authorized_by,
+            "authorized_at": datetime.utcnow()
+        }
+        
+        await db.authorized_users_col.update_one(
+            {"user_id": user_id},
+            {"$set": auth_data},
+            upsert=True
+        )
+        
+        return True
+    except Exception as e:
+        logger.error(f"Failed to authorize user {user_id}: {e}")
+        return False
+
+async def deauthorize(user_id: int) -> bool:
+    """
+    Remove a user's authorization.
+    
+    Args:
+        user_id: User's Telegram ID to deauthorize
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        result = await db.authorized_users_col.delete_one({"user_id": user_id})
+        return result.deleted_count > 0
+    except Exception as e:
+        logger.error(f"Failed to deauthorize user {user_id}: {e}")
+        return False
+
+async def get_user(user_id: int) -> Optional[Dict[str, Any]]:
+    """
+    Get information about a user's token.
+    
+    Args:
+        user_id: User's Telegram ID
+        
+    Returns:
+        dict or None: Token data if found, None otherwise
+    """
+    try:
+        return await db.token_col.find_one({"user_id": user_id})
+    except Exception as e:
+        logger.error(f"Failed to get token data for user {user_id}: {e}")
+        return None
+
+async def get(token: str) -> Optional[Dict[str, Any]]:
+    """
+    Retrieve token record by token string.
+    
+    Args:
+        token: Token string to look up
+        
+    Returns:
+        dict or None: Token data if found, None otherwise
+    """
+    try:
+        return await db.token_col.find_one({"token": token})
+    except Exception as e:
+        logger.error(f"Failed to get token data: {e}")
+        return None
+
+async def list_allowed() -> List[Dict[str, Any]]:
+    """
+    Get all authorized users.
+    
+    Returns:
+        List[Dict[str, Any]]: List of authorized users data
+    """
+    try:
+        cursor = db.authorized_users_col.find({})
+        return await cursor.to_list(length=None)
+    except Exception as e:
+        logger.error(f"Failed to list authorized users: {e}")
+        return []
+
+async def list_tokens() -> List[Dict[str, Any]]:
+    """
+    Get all active tokens.
+    
+    Returns:
+        List[Dict[str, Any]]: List of active tokens data
+    """
+    try:
+        cursor = db.token_col.find({})
+        return await cursor.to_list(length=None)
+    except Exception as e:
+        logger.error(f"Failed to list tokens: {e}")
+        return []
+
+async def validate_activation_token(token: str) -> Dict[str, Any]:
+    """
+    Validates an activation token and returns validation status.
+    
+    Args:
+        token: The token string to validate
+        
+    Returns:
+        dict: Validation result with status and details
+    """
+    try:
+        # Remove 'token' prefix if present
+        clean_token = token
+        if token.startswith("token"):
+            # Handle different possible separators
+            if len(token) > 5 and token[5] in ('-', '_'):
+                clean_token = token[6:]  # Skip prefix and separator
+            else:
+                clean_token = token[5:]  # Skip just the prefix
+                
+        # Check if token exists in database
+        token_record = await get(clean_token)
+        if not token_record:
+            return {
+                "valid": False,
+                "reason": "Token does not exist or has been revoked",
+                "token": clean_token
+            }
+            
+        # Check if token is expired
+        if token_record["expires_at"] <= datetime.utcnow():
+            return {
+                "valid": False,
+                "reason": "Token has expired",
+                "token": clean_token,
+                "expiry_date": token_record["expires_at"].strftime("%Y-%m-%d %H:%M:%S UTC")
+            }
+            
+        # Token is valid
+        return {
+            "valid": True,
+            "token": clean_token,
+            "user_id": token_record["user_id"],
+            "expiry_date": token_record["expires_at"].strftime("%Y-%m-%d %H:%M:%S UTC"),
+            "created_at": token_record["created_at"].strftime("%Y-%m-%d %H:%M:%S UTC"),
+            "description": "Access token"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error validating token: {e}")
+        return {
+            "valid": False,
+            "reason": f"An error occurred during validation: {str(e)}",
+            "token": token
+        }

Thunder/vars.py

@@ -0,0 +1,111 @@
+"""
+Thunder/vars.py - Configuration variables for the Thunder bot.
+"""
+
+from typing import Set, Optional, List, Dict
+import os
+from dotenv import load_dotenv
+from Thunder.utils.logger import logger
+
+# Load environment variables from config.env
+load_dotenv("config.env")
+
+# Helper functions for parsing environment variables
+def str_to_bool(val: str) -> bool:
+    """Convert string value to boolean."""
+    return val.lower() in ("true", "1", "t", "y", "yes")
+
+def str_to_int_list(val: str) -> List[int]:
+    """Convert space-separated string to list of integers."""
+    if not val:
+        return []
+    return [int(x) for x in val.split() if x.isdigit()]
+
+def str_to_int_set(val: str) -> Set[int]:
+    """Convert space-separated string to set of integers."""
+    if not val:
+        return set()
+    return set(int(x) for x in val.split() if x.isdigit())
+
+class Var:
+    """Configuration variables for the Thunder bot."""
+
+    # Telegram API credentials
+    API_ID: int = int(os.getenv("API_ID", ""))
+    if not API_ID:
+        logger.critical("CRITICAL: API_ID is not configured in config.env!")
+        raise ValueError("CRITICAL: API_ID is not configured in config.env!")
+        
+    API_HASH: str = os.getenv("API_HASH", "")
+    if not API_HASH:
+        logger.critical("CRITICAL: API_HASH is not configured in config.env!")
+        raise ValueError("CRITICAL: API_HASH is not configured in config.env!")
+
+    # Bot token and identity
+    BOT_TOKEN: str = os.getenv("BOT_TOKEN", "")
+    if not BOT_TOKEN:
+        logger.critical("CRITICAL: BOT_TOKEN is not configured in config.env!")
+        raise ValueError("CRITICAL: BOT_TOKEN is not configured in config.env!")
+    NAME: str = os.getenv("NAME", "ThunderF2L")
+    
+    # Performance settings
+    SLEEP_THRESHOLD: int = int(os.getenv("SLEEP_THRESHOLD", "60"))
+    WORKERS: int = int(os.getenv("WORKERS", "100"))
+    TIMEOUT: int = int(os.getenv("TIMEOUT", "30"))
+
+    # Channel for file storage
+    BIN_CHANNEL: int = int(os.getenv("BIN_CHANNEL", "0"))
+    if not BIN_CHANNEL:
+        logger.critical("CRITICAL: BIN_CHANNEL is not configured in config.env!")
+        raise ValueError("CRITICAL: BIN_CHANNEL is not configured in config.env!")
+
+    # Web server configuration
+    PORT: int = int(os.getenv("PORT", "8080"))
+    BIND_ADDRESS: str = os.getenv("BIND_ADDRESS", "0.0.0.0")
+    PING_INTERVAL: int = int(os.getenv("PING_INTERVAL", "840"))
+    NO_PORT: bool = str_to_bool(os.getenv("NO_PORT", "True"))
+    CACHE_SIZE: int = int(os.getenv("CACHE_SIZE", "100"))
+    
+    # Owner details
+    OWNER_ID: List[int] = str_to_int_list(os.getenv("OWNER_ID", ""))
+    if not OWNER_ID:
+        logger.warning("WARNING: OWNER_ID is empty. No user will have admin access.")
+    OWNER_USERNAME: str = os.getenv("OWNER_USERNAME", "")
+    
+    # Domain and URL configuration
+    FQDN: str = os.getenv("FQDN", "") or BIND_ADDRESS
+    HAS_SSL: bool = str_to_bool(os.getenv("HAS_SSL", "False"))
+    PROTOCOL: str = "https" if HAS_SSL else "http"
+    PORT_SEGMENT: str = "" if NO_PORT else f":{PORT}"
+    URL: str = f"{PROTOCOL}://{FQDN}{PORT_SEGMENT}/"
+    
+    # Database configuration
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "")
+    if not DATABASE_URL:
+        logger.critical("CRITICAL: DATABASE_URL is not configured in config.env!")
+        raise ValueError("CRITICAL: DATABASE_URL is not configured in config.env!")
+
+    # Channel configurations
+    BANNED_CHANNELS: Set[int] = str_to_int_set(os.getenv("BANNED_CHANNELS", ""))
+    
+    # Multi-client support flag
+    MULTI_CLIENT: bool = False
+
+    # Force channel configuration
+    FORCE_CHANNEL_ID: Optional[int] = None
+    force_channel_env = os.getenv("FORCE_CHANNEL_ID", "").strip()
+    if force_channel_env:
+        try:
+            FORCE_CHANNEL_ID = int(force_channel_env)
+        except ValueError:
+            logger.warning(f"Invalid FORCE_CHANNEL_ID '{force_channel_env}' in environment; must be an integer.")
+
+    # Token System
+    TOKEN_ENABLED: bool = str_to_bool(os.getenv("TOKEN_ENABLED", "False"))
+    TOKEN_TTL_HOURS: int = int(os.getenv("TOKEN_TTL_HOURS", "24"))
+    
+    # URL Shortener
+    SHORTEN_ENABLED: bool = str_to_bool(os.getenv("SHORTEN_ENABLED", "False"))
+    SHORTEN_MEDIA_LINKS: bool = str_to_bool(os.getenv("SHORTEN_MEDIA_LINKS", "False"))
+    URL_SHORTENER_API_KEY: str = os.getenv("URL_SHORTENER_API_KEY", "")
+    URL_SHORTENER_SITE: str = os.getenv("URL_SHORTENER_SITE", "")

config_sample.env

@@ -0,0 +1,83 @@
+# =============================================================
+# Rename this file to config.env before using
+# =============================================================
+
+####################
+## REQUIRED SETTINGS
+####################
+
+# Telegram API credentials (from https://my.telegram.org/apps)
+API_ID=0 # Example: 1234567
+API_HASH="" # Example: "abc123def456"
+
+# Bot token (from @BotFather)
+BOT_TOKEN="" # Example: "123456789:ABCdef..."
+
+# Storage channel ID (create a channel and add bot as admin)
+BIN_CHANNEL=0 # Example: -1001234567890
+
+# Owner information (get ID from @userinfobot)
+OWNER_ID="" # Your Telegram user ID(s) as a space-separated string. Example: "123456789 098765432"
+OWNER_USERNAME="" # Example: "@YourUsername"
+
+# Database connection string
+DATABASE_URL="" # Example: "mongodb+srv://user:pass@host/db"
+
+# Deployment configuration
+FQDN="" # Your domain name (leave empty to use IP)
+HAS_SSL="False" # Set to "True" if using HTTPS
+PORT=8080 # Web server port
+NO_PORT="True" # Hide port in URLs ("True" or "False")
+
+####################
+## OPTIONAL SETTINGS
+####################
+
+# Force users to join a specific channel before using the bot
+FORCE_CHANNEL_ID="" # Example: -1001234567890 (Leave empty if not needed)
+
+# Banned channels (files from these channels will be rejected)
+BANNED_CHANNELS="" # Example: "-1001234567890 -100987654321" (Space-separated IDs, leave empty if none)
+
+# Multiple bot tokens (can add up to MULTI_TOKEN49) # Example: MULTI_TOKEN49="123456789:ABCdef..."
+MULTI_TOKEN1=""
+
+####################
+## TOKEN SYSTEM SETTINGS
+####################
+
+# Enable token-based access (True/False)
+TOKEN_ENABLED="False"
+
+# Default token validity in hours
+TOKEN_TTL_HOURS="24"
+
+####################
+## URL SHORTENER SETTINGS
+####################
+
+# Enable URL shortening for tokens (True/False)
+SHORTEN_ENABLED="False"
+
+# Enable URL shortening for media links (True/False)
+SHORTEN_MEDIA_LINKS="False"
+
+# URL Shortener
+URL_SHORTENER_API_KEY="" # Example: "abc123def456"
+URL_SHORTENER_SITE="" # Example: "example.com"
+
+####################
+## ADVANCED SETTINGS (modify with caution)
+####################
+
+# Application name
+NAME="ThunderF2L" # Bot application name
+
+# Performance settings
+SLEEP_THRESHOLD=60 # Sleep time in seconds
+WORKERS=100 # Number of worker processes
+
+# Web server configuration
+BIND_ADDRESS="0.0.0.0" # Listen on all network interfaces
+PING_INTERVAL=840 # Ping interval in seconds
+CACHE_SIZE=100 # Cache size in MB

requirements.txt

@@ -0,0 +1,15 @@
+aiofiles
+aiohttp
+aiocache
+apscheduler
+cachetools
+cloudscraper
+dnspython
+Jinja2
+kurigram
+motor
+psutil
+pyromod
+python-dotenv
+requests
+tgcrypto