app.py

import gradio as gr
import subprocess
import asyncio
import threading
from queue import Queue, Empty
import os
import time
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

BOT_TOKEN = os.environ.get("BOT_TOKEN", "YOUR_BOT_TOKEN")

bot_app = None
bot_thread = None
bot_running = False
log_queue = Queue()
telegram_cmd_logs = []

# Telegram bot handler
async def bash_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    cmd = ' '.join(context.args)
    if not cmd:
        await update.message.reply_text("Usage: /bash <command>")
        return

    log_queue.put(f"[Telegram] Received command: {cmd}")

    try:
        proc = await asyncio.create_subprocess_shell(
            cmd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.STDOUT,
        )
        stdout, _ = await proc.communicate()
        output = stdout.decode().strip()
        if len(output) > 4000:
            output = output[:4000] + "\n...[truncated]"
    except Exception as e:
        output = f"Error: {e}"

    await update.message.reply_text(f"$ {cmd}\n{output}")
    telegram_cmd_logs.append(f"$ {cmd}\n{output}")
    if len(telegram_cmd_logs) > 50:
        telegram_cmd_logs.pop(0)

def start_bot():
    global bot_app, bot_running, bot_thread
    if bot_running:
        log_queue.put("[Bot] Already running.")
        return

    async def run_bot():
        global bot_app, bot_running
        bot_app = ApplicationBuilder().token(BOT_TOKEN).build()
        bot_app.add_handler(CommandHandler("bash", bash_command))
        bot_running = True
        log_queue.put("[Bot] Bot started.")
        await bot_app.run_polling()

    loop = asyncio.new_event_loop()

    def runner():
        asyncio.set_event_loop(loop)
        try:
            loop.run_until_complete(run_bot())
        except Exception as e:
            log_queue.put(f"[Bot Error] {e}")

    bot_thread = threading.Thread(target=runner, daemon=True)
    bot_thread.start()

def stop_bot():
    global bot_app, bot_running
    if not bot_running:
        log_queue.put("[Bot] Bot is not running.")
        return

    async def shutdown():
        await bot_app.shutdown()
        await bot_app.stop()
        log_queue.put("[Bot] Bot stopped.")

    asyncio.run(shutdown())
    bot_running = False

# Real live terminal generator
def live_terminal(cmd):
    if not cmd.strip():
        yield gr.TextArea.update(value="$ ")
        return
    yield gr.TextArea.update(value=f"$ {cmd}\n")
    process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    output = f"$ {cmd}\n"
    for line in iter(process.stdout.readline, ''):
        output += line
        yield gr.TextArea.update(value=output)
    process.stdout.close()
    process.wait()
    output += "$ "
    yield gr.TextArea.update(value=output)

# Update log output
def update_log_box():
    logs = []
    try:
        while True:
            logs.append(log_queue.get_nowait())
    except Empty:
        pass
    logs.extend(telegram_cmd_logs[-20:])
    return "\n".join(logs[-20:])

# UI
with gr.Blocks(title="📚 TheMovieProviderBot Interface") as demo:
    gr.Markdown("## 🖥️ Live Terminal + Telegram Bot Interface")

    with gr.Row():
        terminal_output = gr.TextArea(label="📟 Live Terminal", lines=20)
        cmd_input = gr.Textbox(label="⌨️ Enter Command")
        run_btn = gr.Button("▶️ Run")

    with gr.Row():
        start_btn = gr.Button("🤖 Start Telegram Bot")
        stop_btn = gr.Button("🛑 Stop Telegram Bot")

    log_output = gr.Textbox(label="📜 Bot Logs", lines=15, interactive=False)

    # Stream terminal output
    run_btn.stream(live_terminal, inputs=cmd_input, outputs=terminal_output)

    # Start/Stop handlers
    def start_click():
        start_bot()
        return update_log_box()

    def stop_click():
        stop_bot()
        return update_log_box()

    start_btn.click(start_click, outputs=log_output)
    stop_btn.click(stop_click, outputs=log_output)

    # Background log auto-updater
    def background_log_updater():
        while True:
            time.sleep(3)
            yield gr.Textbox.update(value=update_log_box())

    demo.load(background_log_updater, outputs=log_output)

demo.launch()