Fixed

Auto_install.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+## Set default commands
+pipCommand="pip"
+pythonCommand="python"
+useBale=0
+
+## Display help for commands
+showHelp() {
+    echo -e "Autoinstall usage: $0 [option..]\n
+   	-b, --bale		For install bale api instead of Telegram API \n
+	  -h, --help		This help message\n
+	  -d, --debug		Enable bash debug\n
+	  -i, --interactive	Install requirements for interactive commands\n
+	  -u, --useful		Install useful commands\n
+	  -3, --python3		Use python3 instead of Python2\n
+    "
+    exit 0
+}
+
+## Use virtualenv
+useVenv() {
+    ## Create virtual environment
+    virtualenv -p $pythonCommand venv
+    ## Activate virtual environment
+    source venv/bin/activate
+}
+
+
+useBaleAPI() {
+    ## Change telegram API URL to Bale API URL
+    find ./ -name bot.py -exec sed -i 's/api\.telegram\.org/tapi.bale.ai/mg' {} \;
+}
+
+
+## to use interactive commands like htop we need these packages
+installAha() {
+    [ -f "/etc/debian_version" ] && apt-get update && apt-get install -y aha && return 0
+    (git clone https://github.com/theZiz/aha.git && cd aha && make && make install return 0) || ( echo "cannot install aha, please use -d to debug \nPlease submit an issue here:\n https://github.com/MParvin/TSMB/issues/new" && exit 1)
+
+}
+
+## Install useful commands
+installUsefulCMD() {
+    echo "Installing htop, please wait a moment..."
+    yum install -y htop &> /dev/null ||  apt install -y htop &> /dev/null
+}
+
+configureBot(){
+    echo -e "To configure your bot, you must have a Telegram or Bale token\n
+		How to create Telegram bot: https://core.telegram.org/bots#3-how-do-i-create-a-bot\n
+    How to create Bale bot: https://devbale.ir/quick-start\n"
+    read -p "Enter your bot token here:"
+
+    telegramToken=$REPLY
+
+    echo -e "Get chat_id and enter here:\n
+		To get chat_id do:
+			- In telegram:\n start a chat with @id_chatbot
+			- In Bale:\n start a chat with chatid_bot
+    "
+    chatId=$REPLY
+}
+
+while :
+do
+    case "$1" in
+        -b | --bale)
+            which virtualenv &> /dev/null || (echo "Cannot use Bale without virtualenv, please run \"pip install virtualenv\" before run this script with -b option" && exit 1)
+            useBale = "True"
+            break
+            ;;
+        -h | --help)
+            showHelp
+            exit 0
+            ;;
+        -d | --debug)
+            set -x
+            break
+            ;;
+        -i | --interactive)
+            installAha
+            break
+            ;;
+        -u | --useful)
+            installUsefulCMD
+            break
+            ;;
+        -3 | --python3)
+            pythonCommand="python3"
+            pipCommand="pip3"
+            break
+            ;;
+        *)
+            break
+            ;;
+
+    esac
+done
+
+
+## Check is python installed
+which $pythonCommand &> /dev/null || (echo "Please install python, and run this script again" && exit 1)
+## Check is pip installed
+which $pipCommand &> /dev/null || (echo -e "Please install pip, and run this script again\n
+				In Debian base system for python2.* use apt-get install python-pip\n
+for python3.* use apt-get install python3-pip" && exit 1)
+
+## Install virtualenv if is not installed
+(which virtualenv &> /dev/null && useVenv) || read -p "Do you want to install virtualenv(y/n)? " -n 1 -r
+## User accepted
+[[ ! $REPLY =~ ^[yY]$ ]] && $pipCommand install virtualenv --user && useVenv
+
+## Install requirements
+([ -f requirements.txt ] && $pipCommand install -r requirements.txt) || echo "Could not find requirements.txt, please clone complete this repository from here:\nhttps://github.com/MParvin/TSMB/, \nthen run Autoinstall.sh"
+if [ "$useBale" -eq 1 ]
+then
+    useBaleAPI
+fi
+
+
+read -p "Do you want to configure your bot now(y/n)?"
+if [ $REPLY =~ ^[yY] ]
+then
+    configureBot
+else
+    echo -e "To use this bot, first change variables in \"config\" file\n
+		then executable bot script \"chmod +x bot.py \"
+    and run it: \"./bot.py \""
+fi

Dockerfile

@@ -0,0 +1,77 @@
+FROM python:3.9.5-buster
+
+# Fix apt sources for old Buster release
+RUN sed -i 's|deb.debian.org|archive.debian.org|g' /etc/apt/sources.list && \
+    sed -i 's|security.debian.org|archive.debian.org|g' /etc/apt/sources.list && \
+    sed -i '/stretch-updates/d' /etc/apt/sources.list && \
+    echo 'Acquire::Check-Valid-Until "false";' > /etc/apt/apt.conf.d/99no-check-valid-until
+    
+# Set timezone
+ENV TZ=Asia/Kolkata
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN sed -i 's/main/main contrib non-free/' /etc/apt/sources.list && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+        neofetch \
+        git \
+        curl \
+        wget \
+        mediainfo \
+        ffmpeg \
+        p7zip-full \
+        unrar \
+        unzip \
+        libssl-dev \
+        libffi-dev \
+        python3-dev && \
+    apt-get autoremove --purge -y && \
+    rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /Ult
+
+# Copy the application code
+COPY . .
+
+# --- FIX 1: Connection Speed & Stability ---
+# Installing cryptg speeds up encryption, preventing timeouts.
+# pysocks helps with connection routing.
+RUN pip3 install --no-cache-dir pysocks cryptg
+
+RUN if [ -f reqs.txt ]; then pip3 install --no-cache-dir -r reqs.txt; fi
+RUN pip3 install -U pip
+RUN pip3 install -U redis
+
+RUN if [ -f addons.txt ]; then pip3 install --no-cache-dir -r addons.txt; fi
+RUN pip3 install --no-cache-dir -r requirements.txt
+RUN if [ -f resources/startup/optional-requirements.txt ]; then pip3 install --no-cache-dir -r resources/startup/optional-requirements.txt; fi || true
+
+# --- FIX 2: Resolve Crash (Server.py) ---
+# Downgrade FastAPI to be compatible with Pydantic v1 (which your bot likely uses)
+# This fixes: ImportError: cannot import name 'TypeAdapter' from 'pydantic'
+RUN pip3 install "fastapi<0.100.0" "pydantic<2.0.0" uvicorn
+
+# Set appropriate permissions
+RUN chown -R 1000:0 /Ult \
+    && chown -R 1000:0 . \
+    && chmod 777 . \
+    && chmod 777 /usr \
+    && chown -R 1000:0 /usr \
+    && chmod -R 755 /Ult \
+    && chmod +x /Ult/start.sh
+
+# Install FFmpeg
+RUN wget https://johnvansickle.com/ffmpeg/builds/ffmpeg-git-amd64-static.tar.xz && \
+    wget https://johnvansickle.com/ffmpeg/builds/ffmpeg-git-amd64-static.tar.xz.md5 && \
+    md5sum -c ffmpeg-git-amd64-static.tar.xz.md5 && \
+    tar xvf ffmpeg-git-amd64-static.tar.xz && \
+    mv ffmpeg-git*/ffmpeg ffmpeg-git*/ffprobe /usr/local/bin/ && \
+    rm -rf ffmpeg-git* *.tar.xz *.md5
+
+# Expose port
+EXPOSE 7860
+
+# --- TRICK 3: Auto-delete session + Force IPv4 ---
+# Deletes old sessions AND forces Python to use IPv4 for DNS (helps with connection blocks)
+CMD ["bash", "-c", "echo '🔄 TRICK: Cleaning sessions...' && find . -name '*.session' -type f -delete && python3 server.py & python3 bot.py"]

README.md

@@ -0,0 +1,81 @@
+---
+title: Telegram Remote Command Runner
+emoji: 🤖
+colorFrom: blue
+colorTo: gray
+sdk: docker
+pinned: false
+---
+
+# Telegram Server Manager Bot
+
+The Telegram Server Manager Bot is a tool that allows you to remotely manage your Raspberry Pi, PC, or server using Telegram. With this bot, you can run commands from anywhere using your smartphone or computer, without needing to log in to your server directly. This can be especially useful if you want to check on your server's status, restart a service, or troubleshoot an issue while you're away from your desk.
+
+## Hugging Face Spaces Deployment
+
+This repository is now compatible with Hugging Face Spaces! You can deploy this bot to Hugging Face Spaces for 24/7 availability.
+
+### Features for Hugging Face Spaces:
+- ✅ Runs on Python 3.9.5
+- ✅ Web interface on port 7860
+- ✅ Automatic session cleanup
+- ✅ FastAPI health monitoring
+- ✅ Support for eval command to run Python code
+
+### Deploy to Hugging Face Spaces:
+1. Fork this repository
+2. Create a new Space on Hugging Face
+3. Select "Docker" as the SDK
+4. Connect your GitHub repository
+5. Add your Telegram bot token and admin chat ID as Space secrets
+6. Deploy!
+
+## Prerequisites
+
+To use the Telegram Server Manager Bot, you will need the following:
+
+* A Telegram account.
+* A Telegram bot token. You can generate this by talking to @BotFather on Telegram.
+* Python 3.x installed on your RaspberryPi, PC, or server.
+
+
+## Installation
+
+1. Clone this repository to your RaspberryPi, PC, or server.
+
+2. Install the required dependencies by running `pip install -r requirements.txt` in the terminal.
+
+3. Rename config.example to config and replace YOUR_TOKEN with your Telegram bot token, YOUR_CHAT_ID with your Telegram chat ID, and ADMIN_CID with the chat ID of the admin who is authorized to execute commands.
+
+4. Make the bot.py file executable by running chmod +x bot.py in the terminal.
+
+5. Run the bot by running ./bot.py in the terminal.
+
+
+## Usage
+
+To use the Telegram Server Manager Bot, simply open Telegram and start a chat with your bot. Only the admin can execute commands, so make sure to add the admin chat ID to the configuration file. You can then run any of the built-in commands or enter any Linux command that you want to run on your RaspberryPi, PC, or server.
+
+It also supports the following commands:
+
+```bash
+  /ping8: Pings 8.8.8.8 and returns the results.
+
+  /top: Runs the top command and returns the results.
+
+  /htop: Runs the htop command and returns the results.
+
+  /eval: Execute Python code and return the result (NEW!)
+
+  /help - Shows help and usage information.
+```
+
+** You can also run any Linux command by simply entering it in the Telegram chat with the bot.
+
+## Contributions
+
+Contributions to this project are welcome! If you have ideas for new features or improvements, feel free to submit a pull request or open an issue.
+
+## License
+
+This project is licensed under the MIT License.

addons.txt

@@ -0,0 +1,5 @@
+# Additional add-ons and utilities
+requests
+beautifulsoup4
+lxml
+pillow

bot.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Apr  4 19:06:08 2018
+
+@author: mparvin
+"""
+
+import subprocess
+import configparser
+import os
+import sys
+from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
+import logging
+
+
+# Configure logging - reduce noise from telegram library
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
+)
+
+# Suppress verbose logging from telegram and urllib3
+logging.getLogger('telegram.vendor.ptb_urllib3.urllib3.connectionpool').setLevel(logging.ERROR)
+logging.getLogger('telegram.ext.updater').setLevel(logging.ERROR)
+
+logger = logging.getLogger(__name__)
+
+# Try to read config file
+config = configparser.ConfigParser()
+try:
+    if not os.path.exists("config"):
+        logger.error("Config file not found. Please create a 'config' file based on config.example")
+        logger.info("Bot cannot start without configuration. Exiting gracefully...")
+        sys.exit(0)  # Exit gracefully so the web server can continue
+    
+    config.read("config")
+    ### Get admin chat_id from config file
+    ### For more security replies only send to admin chat_id
+    adminCID = config["SecretConfig"]["admincid"]
+except (KeyError, configparser.Error) as e:
+    logger.error(f"Error reading config file: {e}")
+    logger.info("Bot cannot start without valid configuration. Exiting gracefully...")
+    sys.exit(0)  # Exit gracefully so the web server can continue
+### This function run command and send output to user
+def runCMD(bot, update):
+    if not isAdmin(bot, update):
+        return
+    usercommand = update.message.text
+    cmdProc = subprocess.Popen(
+        usercommand, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+    )
+    cmdOut, cmdErr = cmdProc.communicate()
+    if cmdOut:
+        bot.sendMessage(text=str(cmdOut, "utf-8"), chat_id=adminCID)
+    else:
+        bot.sendMessage(text=str(cmdErr, "utf-8"), chat_id=adminCID)
+
+
+### This function ping 8.8.8.8 and send you result
+def ping8(bot, update):
+    if not isAdmin(bot, update):
+        return
+    cmdOut = str(
+        subprocess.check_output(
+            "ping 8.8.8.8 -c4", stderr=subprocess.STDOUT, shell=True
+        ),
+        "utf-8",
+    )
+    bot.sendMessage(text=cmdOut, chat_id=adminCID)
+
+
+def startCMD(bot, update):
+    if not isAdmin(bot, update):
+        return
+    bot.sendMessage(
+        text="Welcome to TSMB bot, this is Linux server/PC manager, Please use /help and read carefully!!",
+        chat_id=adminCID,
+    )
+
+
+def helpCMD(bot, update):
+    if not isAdmin(bot, update):
+        return
+    bot.sendMessage(
+        text="This bot has access to your server/PC, So it can do anything. Please use Telegram local password to prevent others from accessing to this bot.",
+        chat_id=adminCID,
+    )
+
+
+def evalCMD(bot, update):
+    """Execute Python code and return the result
+    
+    SECURITY NOTE: This command allows arbitrary Python code execution.
+    It is restricted to admin users only via isAdmin() check.
+    This is intentional for remote server management but should be used
+    with caution. Only authorized administrators should have access.
+    """
+    if not isAdmin(bot, update):
+        return
+    
+    # Get the Python code from the message (remove /eval command)
+    code = update.message.text.replace("/eval", "", 1).strip()
+    
+    if not code:
+        bot.sendMessage(
+            text="Please provide Python code to evaluate.\nUsage: /eval <python_code>",
+            chat_id=adminCID,
+        )
+        return
+    
+    try:
+        # Create a safe namespace for eval
+        namespace = {
+            '__builtins__': __builtins__,
+            'os': os,
+            'subprocess': subprocess,
+        }
+        
+        # Try to evaluate as expression first
+        try:
+            result = eval(code, namespace)
+            output = str(result)
+        except SyntaxError:
+            # If it fails, try to execute as statement
+            exec(code, namespace)
+            output = "Code executed successfully (no return value)"
+        
+        bot.sendMessage(text=f"✅ Result:\n{output}", chat_id=adminCID)
+    except Exception as e:
+        bot.sendMessage(text=f"❌ Error:\n{type(e).__name__}: {str(e)}", chat_id=adminCID)
+
+
+def topCMD(bot, update):
+    if not isAdmin(bot, update):
+        return
+    cmdOut = str(subprocess.check_output("top -n 1", shell=True), "utf-8")
+    bot.sendMessage(text=cmdOut, chat_id=adminCID)
+
+
+def HTopCMD(bot, update):
+    ## Is this user admin?
+    if not isAdmin(bot, update):
+        return
+    ## Checking requirements on your system
+    htopCheck = subprocess.call(["which", "htop"])
+    if htopCheck != 0:
+        bot.sendMessage(
+            text="htop is not installed on your system, Please install it first and try again",
+            chat_id=adminCID,
+        )
+        return
+    ahaCheck = subprocess.call(["which", "aha"])
+    if ahaCheck != 0:
+        bot.sendMessage(
+            text="aha is not installed on your system, Please install it first and try again",
+            chat_id=adminCID,
+        )
+        return
+    os.system("echo q | htop | aha --black --line-fix  > ./htop-output.html")
+    with open("./htop-output.html", "rb") as fileToSend:
+        bot.sendDocument(document=fileToSend, chat_id=adminCID)
+    if os.path.exists("./htop-output.html"):
+        os.remove("./htop-output.html")
+
+
+def error(bot, update, error):
+    """Log Errors caused by Updates."""
+    logger.warning('Update "%s" caused error "%s"', update, error)
+
+
+def isAdmin(bot, update):
+    chat_id = update.message.chat_id
+    if str(chat_id) == adminCID:
+        return True
+    
+    update.message.reply_text(
+        "You cannot use this bot, because you are not Admin!!!!"
+    )
+    alertMessage = """Some one try to use this bot with this information:\n chat_id is {} and username is {} """.format(
+        update.message.chat_id, update.message.from_user.username
+    )
+    bot.sendMessage(text=alertMessage, chat_id=adminCID)
+    return False
+
+
+def main():
+    try:
+        logger.info("Starting Telegram bot...")
+        updater = Updater(config["SecretConfig"]["Token"])
+        dp = updater.dispatcher
+
+        dp.add_handler(CommandHandler("start", startCMD))
+        dp.add_handler(CommandHandler("ping8", ping8))
+        dp.add_handler(CommandHandler("top", topCMD))
+        dp.add_handler(CommandHandler("htop", HTopCMD))
+        dp.add_handler(CommandHandler("help", helpCMD))
+        dp.add_handler(CommandHandler("eval", evalCMD))
+        dp.add_handler(MessageHandler(Filters.text, runCMD))
+
+        dp.add_error_handler(error)
+        
+        logger.info("Bot configured successfully. Starting polling...")
+        updater.start_polling()
+        logger.info("✅ Telegram bot is now running and listening for commands!")
+        updater.idle()
+    except Exception as e:
+        logger.error(f"Failed to start Telegram bot: {type(e).__name__}: {str(e)}")
+        logger.info("This is normal if running in an environment without Telegram API access (e.g., Hugging Face Spaces)")
+        logger.info("The web server will continue to run. Configure the bot with valid credentials to enable Telegram functionality.")
+        # Exit gracefully - let the web server continue running
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

config.example

@@ -0,0 +1,4 @@
+[SecretConfig]
+token = 193025875:AAHZ3hIanIau-Hg04B-mZREFBjLl6GvM9fk
+admincid = 131728488
+

reqs.txt

@@ -0,0 +1,15 @@
+# Core telegram requirements
+python-telegram-bot==10.0.1
+configparser==4.0.2
+certifi==2024.7.4
+future==0.18.3
+
+# Web server requirements
+fastapi<0.100.0
+pydantic<2.0.0
+uvicorn
+python-multipart
+
+# Additional utilities
+redis
+aiohttp

requirements.txt

@@ -0,0 +1,4 @@
+certifi==2024.7.4
+future==0.18.3
+configparser==4.0.2
+python-telegram-bot==10.0.1

server.py

@@ -0,0 +1,842 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Simple FastAPI server for Hugging Face Spaces
+This keeps the space alive and provides a basic web interface
+"""
+
+from fastapi import FastAPI, Request, HTTPException, Form, UploadFile, File
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import os
+import logging
+import subprocess
+import configparser
+import tempfile
+import traceback
+
+# Configure logging
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
+    level=logging.INFO
+)
+
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Load config for authentication
+def load_config():
+    """Load configuration file"""
+    config = configparser.ConfigParser()
+    if os.path.exists("config"):
+        config.read("config")
+        return config
+    return None
+
+def verify_admin(chat_id: str):
+    """Verify if the provided chat_id matches admin"""
+    config = load_config()
+    if config and "SecretConfig" in config:
+        admin_cid = config["SecretConfig"].get("admincid", "")
+        return str(chat_id) == str(admin_cid)
+    # If no config, allow access for demo purposes in restricted environments
+    # WARNING: This is insecure in production. Always use a config file with proper admin_id
+    logger.warning("No config file found - running in insecure demo mode")
+    return True
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Root endpoint that returns a professional web interface"""
+    
+    # Check if config file exists
+    config_exists = os.path.exists("config")
+    
+    return f"""
+    <!DOCTYPE html>
+    <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Telegram Server Manager - Web Console</title>
+            <style>
+                * {{
+                    margin: 0;
+                    padding: 0;
+                    box-sizing: border-box;
+                }}
+                
+                body {{
+                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    min-height: 100vh;
+                    padding: 20px;
+                }}
+                
+                .container {{
+                    max-width: 1200px;
+                    margin: 0 auto;
+                }}
+                
+                .header {{
+                    background: white;
+                    padding: 25px;
+                    border-radius: 10px;
+                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+                    margin-bottom: 20px;
+                }}
+                
+                .header h1 {{
+                    color: #333;
+                    font-size: 2em;
+                    margin-bottom: 10px;
+                }}
+                
+                .status-badge {{
+                    display: inline-block;
+                    padding: 8px 15px;
+                    border-radius: 20px;
+                    font-size: 0.9em;
+                    font-weight: bold;
+                }}
+                
+                .status-online {{
+                    background: #d4edda;
+                    color: #155724;
+                }}
+                
+                .status-warning {{
+                    background: #fff3cd;
+                    color: #856404;
+                }}
+                
+                .main-content {{
+                    display: grid;
+                    grid-template-columns: 1fr;
+                    gap: 20px;
+                }}
+                
+                @media (min-width: 768px) {{
+                    .main-content {{
+                        grid-template-columns: 1fr 1fr;
+                    }}
+                }}
+                
+                .card {{
+                    background: white;
+                    padding: 25px;
+                    border-radius: 10px;
+                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+                }}
+                
+                .card h2 {{
+                    color: #333;
+                    margin-bottom: 15px;
+                    font-size: 1.5em;
+                    border-bottom: 2px solid #667eea;
+                    padding-bottom: 10px;
+                }}
+                
+                .form-group {{
+                    margin-bottom: 15px;
+                }}
+                
+                label {{
+                    display: block;
+                    margin-bottom: 5px;
+                    color: #555;
+                    font-weight: 600;
+                }}
+                
+                input[type="text"],
+                input[type="password"],
+                textarea,
+                select {{
+                    width: 100%;
+                    padding: 10px;
+                    border: 2px solid #e0e0e0;
+                    border-radius: 5px;
+                    font-size: 1em;
+                    font-family: inherit;
+                    transition: border-color 0.3s;
+                }}
+                
+                input:focus,
+                textarea:focus,
+                select:focus {{
+                    outline: none;
+                    border-color: #667eea;
+                }}
+                
+                textarea {{
+                    min-height: 120px;
+                    font-family: 'Courier New', monospace;
+                    resize: vertical;
+                }}
+                
+                button {{
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                    border: none;
+                    padding: 12px 25px;
+                    border-radius: 5px;
+                    font-size: 1em;
+                    font-weight: 600;
+                    cursor: pointer;
+                    transition: transform 0.2s, box-shadow 0.2s;
+                }}
+                
+                button:hover {{
+                    transform: translateY(-2px);
+                    box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+                }}
+                
+                button:active {{
+                    transform: translateY(0);
+                }}
+                
+                button:disabled {{
+                    background: #ccc;
+                    cursor: not-allowed;
+                    transform: none;
+                }}
+                
+                .output {{
+                    background: #1e1e1e;
+                    color: #d4d4d4;
+                    padding: 15px;
+                    border-radius: 5px;
+                    font-family: 'Courier New', monospace;
+                    font-size: 0.9em;
+                    max-height: 400px;
+                    overflow-y: auto;
+                    white-space: pre-wrap;
+                    word-wrap: break-word;
+                    margin-top: 15px;
+                }}
+                
+                .output.empty {{
+                    color: #888;
+                    font-style: italic;
+                }}
+                
+                .loading {{
+                    display: inline-block;
+                    width: 20px;
+                    height: 20px;
+                    border: 3px solid rgba(255,255,255,.3);
+                    border-radius: 50%;
+                    border-top-color: white;
+                    animation: spin 1s ease-in-out infinite;
+                }}
+                
+                @keyframes spin {{
+                    to {{ transform: rotate(360deg); }}
+                }}
+                
+                .info-box {{
+                    background: #e7f3ff;
+                    border-left: 4px solid #2196F3;
+                    padding: 15px;
+                    margin: 15px 0;
+                    border-radius: 5px;
+                }}
+                
+                .warning-box {{
+                    background: #fff3cd;
+                    border-left: 4px solid #ffc107;
+                    padding: 15px;
+                    margin: 15px 0;
+                    border-radius: 5px;
+                }}
+                
+                .success-box {{
+                    background: #d4edda;
+                    border-left: 4px solid #28a745;
+                    padding: 15px;
+                    margin: 15px 0;
+                    border-radius: 5px;
+                }}
+                
+                .error-box {{
+                    background: #f8d7da;
+                    border-left: 4px solid #dc3545;
+                    padding: 15px;
+                    margin: 15px 0;
+                    border-radius: 5px;
+                }}
+                
+                .file-upload {{
+                    border: 2px dashed #667eea;
+                    padding: 20px;
+                    text-align: center;
+                    border-radius: 5px;
+                    cursor: pointer;
+                    transition: background 0.3s;
+                }}
+                
+                .file-upload:hover {{
+                    background: #f0f0f0;
+                }}
+                
+                .tabs {{
+                    display: flex;
+                    gap: 10px;
+                    margin-bottom: 20px;
+                    border-bottom: 2px solid #e0e0e0;
+                }}
+                
+                .tab {{
+                    padding: 10px 20px;
+                    cursor: pointer;
+                    border: none;
+                    background: none;
+                    font-weight: 600;
+                    color: #666;
+                    border-bottom: 3px solid transparent;
+                    transition: all 0.3s;
+                }}
+                
+                .tab.active {{
+                    color: #667eea;
+                    border-bottom-color: #667eea;
+                }}
+                
+                .tab-content {{
+                    display: none;
+                }}
+                
+                .tab-content.active {{
+                    display: block;
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <div class="header">
+                    <h1>🚀 Telegram Server Manager</h1>
+                    <span class="status-badge {'status-online' if config_exists else 'status-warning'}">
+                        {'✅ Web Console Active' if config_exists else '⚠️ Demo Mode'}
+                    </span>
+                    <p style="margin-top: 10px; color: #666;">Professional web interface for server management</p>
+                </div>
+                
+                {'<div class="warning-box"><strong>⚠️ Demo Mode:</strong> Config file not found. Some features may be restricted. Create a <code>config</code> file to enable full functionality.</div>' if not config_exists else ''}
+                
+                <div class="main-content">
+                    <!-- Command Execution Card -->
+                    <div class="card">
+                        <h2>💻 Command Executor</h2>
+                        <div class="info-box">
+                            <strong>💡 Tip:</strong> Run any shell command directly from the browser
+                        </div>
+                        
+                        <div class="form-group">
+                            <label for="cmd-input">Command:</label>
+                            <input type="text" id="cmd-input" placeholder="ls -la" />
+                        </div>
+                        
+                        <button onclick="runCommand()" id="cmd-btn">
+                            Execute Command
+                        </button>
+                        
+                        <div class="output empty" id="cmd-output">
+                            Output will appear here...
+                        </div>
+                    </div>
+                    
+                    <!-- Python Evaluator Card -->
+                    <div class="card">
+                        <h2>🐍 Python Evaluator</h2>
+                        <div class="info-box">
+                            <strong>💡 Tip:</strong> Execute Python code with full system access
+                        </div>
+                        
+                        <div class="form-group">
+                            <label for="py-input">Python Code:</label>
+                            <textarea id="py-input" placeholder="print('Hello World')&#x0a;import os&#x0a;print(os.getcwd())"></textarea>
+                        </div>
+                        
+                        <button onclick="runPython()" id="py-btn">
+                            Execute Python
+                        </button>
+                        
+                        <div class="output empty" id="py-output">
+                            Output will appear here...
+                        </div>
+                    </div>
+                    
+                    <!-- File Uploader Card -->
+                    <div class="card">
+                        <h2>📁 Python File Executor</h2>
+                        <div class="info-box">
+                            <strong>💡 Tip:</strong> Upload and run Python files
+                        </div>
+                        
+                        <div class="form-group">
+                            <label>Upload Python File (.py):</label>
+                            <input type="file" id="file-input" accept=".py" style="margin-bottom: 10px;" />
+                        </div>
+                        
+                        <button onclick="uploadAndRun()" id="file-btn">
+                            Upload & Execute
+                        </button>
+                        
+                        <div class="output empty" id="file-output">
+                            Output will appear here...
+                        </div>
+                    </div>
+                    
+                    <!-- System Info Card -->
+                    <div class="card">
+                        <h2>📊 Quick System Info</h2>
+                        
+                        <div class="tabs">
+                            <button class="tab active" onclick="showTab('system')">System</button>
+                            <button class="tab" onclick="showTab('disk')">Disk</button>
+                            <button class="tab" onclick="showTab('network')">Network</button>
+                        </div>
+                        
+                        <div id="system" class="tab-content active">
+                            <button onclick="getSystemInfo('uname -a')" style="width: 100%; margin-bottom: 10px;">
+                                System Information
+                            </button>
+                            <button onclick="getSystemInfo('df -h')" style="width: 100%; margin-bottom: 10px;">
+                                Disk Usage
+                            </button>
+                            <button onclick="getSystemInfo('free -h')" style="width: 100%;">
+                                Memory Usage
+                            </button>
+                        </div>
+                        
+                        <div id="disk" class="tab-content">
+                            <button onclick="getSystemInfo('du -sh /* 2>/dev/null')" style="width: 100%; margin-bottom: 10px;">
+                                Root Directories Size
+                            </button>
+                            <button onclick="getSystemInfo('lsblk')" style="width: 100%;">
+                                Block Devices
+                            </button>
+                        </div>
+                        
+                        <div id="network" class="tab-content">
+                            <button onclick="getSystemInfo('ip addr')" style="width: 100%; margin-bottom: 10px;">
+                                IP Addresses
+                            </button>
+                            <button onclick="getSystemInfo('ping -c 4 8.8.8.8')" style="width: 100%;">
+                                Network Test (ping)
+                            </button>
+                        </div>
+                        
+                        <div class="output empty" id="sys-output">
+                            Click a button to see system info...
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="warning-box" style="margin-top: 20px;">
+                    <h4>🔒 Security Notice:</h4>
+                    <p><strong>⚠️ IMPORTANT:</strong> This web interface provides full system access and is designed for trusted environments only.</p>
+                    <p>In production environments:</p>
+                    <ul style="margin-left: 20px; margin-top: 10px;">
+                        <li>Use strong authentication (configure admin chat ID in config file)</li>
+                        <li>Deploy behind a reverse proxy with HTTPS</li>
+                        <li>Implement rate limiting and input validation</li>
+                        <li>Monitor and log all command executions</li>
+                        <li>Restrict network access to trusted IPs only</li>
+                    </ul>
+                    <p style="margin-top: 10px;"><strong>Note:</strong> This tool intentionally allows shell command execution and Python eval - features equivalent to the Telegram bot. Use responsibly.</p>
+                </div>
+            </div>
+            
+            <script>
+                function showTab(tabName) {{
+                    // Hide all tab contents
+                    document.querySelectorAll('.tab-content').forEach(content => {{
+                        content.classList.remove('active');
+                    }});
+                    
+                    // Remove active class from all tabs
+                    document.querySelectorAll('.tab').forEach(tab => {{
+                        tab.classList.remove('active');
+                    }});
+                    
+                    // Show selected tab
+                    document.getElementById(tabName).classList.add('active');
+                    event.target.classList.add('active');
+                }}
+                
+                async function runCommand() {{
+                    const input = document.getElementById('cmd-input');
+                    const output = document.getElementById('cmd-output');
+                    const btn = document.getElementById('cmd-btn');
+                    
+                    const command = input.value.trim();
+                    if (!command) {{
+                        output.textContent = '❌ Please enter a command';
+                        output.classList.remove('empty');
+                        return;
+                    }}
+                    
+                    btn.disabled = true;
+                    btn.innerHTML = '<span class="loading"></span> Executing...';
+                    output.textContent = 'Executing command...';
+                    output.classList.remove('empty');
+                    
+                    try {{
+                        const response = await fetch('/api/execute', {{
+                            method: 'POST',
+                            headers: {{ 'Content-Type': 'application/json' }},
+                            body: JSON.stringify({{ command: command, admin_id: 'web-console' }})
+                        }});
+                        
+                        const data = await response.json();
+                        
+                        if (data.success) {{
+                            output.textContent = '✅ Command executed successfully:\\n\\n' + data.output;
+                        }} else {{
+                            output.textContent = '❌ Error:\\n\\n' + data.error;
+                        }}
+                    }} catch (error) {{
+                        output.textContent = '❌ Network error: ' + error.message;
+                    }} finally {{
+                        btn.disabled = false;
+                        btn.innerHTML = 'Execute Command';
+                    }}
+                }}
+                
+                async function runPython() {{
+                    const input = document.getElementById('py-input');
+                    const output = document.getElementById('py-output');
+                    const btn = document.getElementById('py-btn');
+                    
+                    const code = input.value.trim();
+                    if (!code) {{
+                        output.textContent = '❌ Please enter Python code';
+                        output.classList.remove('empty');
+                        return;
+                    }}
+                    
+                    btn.disabled = true;
+                    btn.innerHTML = '<span class="loading"></span> Executing...';
+                    output.textContent = 'Executing Python code...';
+                    output.classList.remove('empty');
+                    
+                    try {{
+                        const response = await fetch('/api/eval', {{
+                            method: 'POST',
+                            headers: {{ 'Content-Type': 'application/json' }},
+                            body: JSON.stringify({{ code: code, admin_id: 'web-console' }})
+                        }});
+                        
+                        const data = await response.json();
+                        
+                        if (data.success) {{
+                            output.textContent = '✅ Python executed successfully:\\n\\n' + data.output;
+                        }} else {{
+                            output.textContent = '❌ Error:\\n\\n' + data.error;
+                        }}
+                    }} catch (error) {{
+                        output.textContent = '❌ Network error: ' + error.message;
+                    }} finally {{
+                        btn.disabled = false;
+                        btn.innerHTML = 'Execute Python';
+                    }}
+                }}
+                
+                async function uploadAndRun() {{
+                    const input = document.getElementById('file-input');
+                    const output = document.getElementById('file-output');
+                    const btn = document.getElementById('file-btn');
+                    
+                    if (!input.files || input.files.length === 0) {{
+                        output.textContent = '❌ Please select a Python file';
+                        output.classList.remove('empty');
+                        return;
+                    }}
+                    
+                    const file = input.files[0];
+                    if (!file.name.endsWith('.py')) {{
+                        output.textContent = '❌ Please select a .py file';
+                        output.classList.remove('empty');
+                        return;
+                    }}
+                    
+                    btn.disabled = true;
+                    btn.innerHTML = '<span class="loading"></span> Uploading & Executing...';
+                    output.textContent = 'Uploading and executing file...';
+                    output.classList.remove('empty');
+                    
+                    try {{
+                        const formData = new FormData();
+                        formData.append('file', file);
+                        formData.append('admin_id', 'web-console');
+                        
+                        const response = await fetch('/api/run-file', {{
+                            method: 'POST',
+                            body: formData
+                        }});
+                        
+                        const data = await response.json();
+                        
+                        if (data.success) {{
+                            output.textContent = '✅ File executed successfully:\\n\\n' + data.output;
+                        }} else {{
+                            output.textContent = '❌ Error:\\n\\n' + data.error;
+                        }}
+                    }} catch (error) {{
+                        output.textContent = '❌ Network error: ' + error.message;
+                    }} finally {{
+                        btn.disabled = false;
+                        btn.innerHTML = 'Upload & Execute';
+                    }}
+                }}
+                
+                async function getSystemInfo(command) {{
+                    const output = document.getElementById('sys-output');
+                    output.textContent = 'Loading...';
+                    output.classList.remove('empty');
+                    
+                    try {{
+                        const response = await fetch('/api/execute', {{
+                            method: 'POST',
+                            headers: {{ 'Content-Type': 'application/json' }},
+                            body: JSON.stringify({{ command: command, admin_id: 'web-console' }})
+                        }});
+                        
+                        const data = await response.json();
+                        
+                        if (data.success) {{
+                            output.textContent = data.output;
+                        }} else {{
+                            output.textContent = '❌ Error: ' + data.error;
+                        }}
+                    }} catch (error) {{
+                        output.textContent = '❌ Network error: ' + error.message;
+                    }}
+                }}
+                
+                // Enable Enter key for command input
+                document.getElementById('cmd-input').addEventListener('keypress', function(e) {{
+                    if (e.key === 'Enter') {{
+                        runCommand();
+                    }}
+                }});
+            </script>
+        </body>
+    </html>
+    """
+
+@app.post("/api/execute")
+async def execute_command(request: Request):
+    """Execute a shell command"""
+    try:
+        data = await request.json()
+        command = data.get("command", "").strip()
+        admin_id = data.get("admin_id", "")
+        
+        if not command:
+            return JSONResponse({"success": False, "error": "No command provided"})
+        
+        # Verify admin (basic check)
+        if not verify_admin(admin_id):
+            return JSONResponse({"success": False, "error": "Unauthorized"})
+        
+        logger.info(f"Executing command: {command}")
+        
+        # Execute command with timeout
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            output = result.stdout if result.stdout else result.stderr
+            if not output:
+                output = "Command executed successfully (no output)"
+            
+            return JSONResponse({
+                "success": True,
+                "output": output,
+                "return_code": result.returncode
+            })
+            
+        except subprocess.TimeoutExpired:
+            return JSONResponse({
+                "success": False,
+                "error": "Command timed out after 30 seconds"
+            })
+        except Exception as e:
+            return JSONResponse({
+                "success": False,
+                "error": f"Execution error: {str(e)}"
+            })
+            
+    except Exception as e:
+        logger.error(f"Error in execute_command: {e}")
+        return JSONResponse({
+            "success": False,
+            "error": f"Server error: {str(e)}"
+        })
+
+@app.post("/api/eval")
+async def evaluate_python(request: Request):
+    """Execute Python code"""
+    try:
+        data = await request.json()
+        code = data.get("code", "").strip()
+        admin_id = data.get("admin_id", "")
+        
+        if not code:
+            return JSONResponse({"success": False, "error": "No code provided"})
+        
+        # Verify admin
+        if not verify_admin(admin_id):
+            return JSONResponse({"success": False, "error": "Unauthorized"})
+        
+        logger.info(f"Executing Python code (length: {len(code)})")
+        
+        try:
+            # Create a namespace for execution
+            namespace = {
+                '__builtins__': __builtins__,
+                'os': os,
+                'subprocess': subprocess,
+            }
+            
+            # Capture stdout
+            import sys
+            from io import StringIO
+            
+            old_stdout = sys.stdout
+            sys.stdout = StringIO()
+            
+            try:
+                # Try to evaluate as expression first
+                try:
+                    result = eval(code, namespace)
+                    if result is not None:
+                        print(result)
+                except SyntaxError:
+                    # If it fails, execute as statement
+                    exec(code, namespace)
+                
+                output = sys.stdout.getvalue()
+                if not output:
+                    output = "Code executed successfully (no output)"
+                
+                return JSONResponse({
+                    "success": True,
+                    "output": output
+                })
+                
+            finally:
+                sys.stdout = old_stdout
+                
+        except Exception as e:
+            return JSONResponse({
+                "success": False,
+                "error": f"{type(e).__name__}: {str(e)}\\n{traceback.format_exc()}"
+            })
+            
+    except Exception as e:
+        logger.error(f"Error in evaluate_python: {e}")
+        return JSONResponse({
+            "success": False,
+            "error": f"Server error: {str(e)}"
+        })
+
+@app.post("/api/run-file")
+async def run_python_file(file: UploadFile = File(...), admin_id: str = Form(...)):
+    """Upload and execute a Python file"""
+    try:
+        # Verify admin
+        if not verify_admin(admin_id):
+            return JSONResponse({"success": False, "error": "Unauthorized"})
+        
+        # Verify file type
+        if not file.filename.endswith('.py'):
+            return JSONResponse({
+                "success": False,
+                "error": "Only .py files are allowed"
+            })
+        
+        logger.info(f"Executing uploaded file: {file.filename}")
+        
+        # Save file to temp location
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tmp:
+            content = await file.read()
+            tmp.write(content.decode('utf-8'))
+            tmp_path = tmp.name
+        
+        try:
+            # Execute the file
+            result = subprocess.run(
+                ['python3', tmp_path],  # Use python3 from PATH instead of hardcoded path
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            output = result.stdout if result.stdout else result.stderr
+            if not output:
+                output = "File executed successfully (no output)"
+            
+            return JSONResponse({
+                "success": True,
+                "output": output,
+                "return_code": result.returncode,
+                "filename": file.filename
+            })
+            
+        except subprocess.TimeoutExpired:
+            return JSONResponse({
+                "success": False,
+                "error": "Execution timed out after 30 seconds"
+            })
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(tmp_path)
+            except (FileNotFoundError, PermissionError) as e:
+                logger.warning(f"Could not delete temp file {tmp_path}: {e}")
+                
+    except Exception as e:
+        logger.error(f"Error in run_python_file: {e}")
+        return JSONResponse({
+            "success": False,
+            "error": f"Server error: {str(e)}"
+        })
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {"status": "healthy", "bot": "running"}
+
+@app.get("/api/status")
+async def status():
+    """Status endpoint"""
+    return {
+        "status": "online",
+        "service": "Telegram Server Manager Bot",
+        "port": 7860,
+        "web_console": "enabled"
+    }
+
+if __name__ == "__main__":
+    # Run on port 7860 for Hugging Face Spaces
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"Starting web server on port {port}...")
+    uvicorn.run(app, host="0.0.0.0", port=port)

start.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -e  # Exit on error
+
+echo "🚀 Starting Telegram Server Manager Bot..."
+echo "🔄 Cleaning old session files..."
+
+# Delete old session files
+find . -name "*.session" -type f -delete || echo "No session files to clean"
+
+echo "🌐 Starting web server..."
+# Start the FastAPI server in the background
+python3 server.py &
+SERVER_PID=$!
+
+# Check if server started successfully
+sleep 2
+if ! kill -0 $SERVER_PID 2>/dev/null; then
+    echo "❌ Failed to start web server"
+    exit 1
+fi
+
+echo "✅ Web server started (PID: $SERVER_PID)"
+echo "🤖 Starting Telegram bot..."
+
+# Start the Telegram bot
+python3 bot.py