Update app.py

app.py

@@ -1,167 +1,157 @@
-import os
+import gradio as gr
+import subprocess
 import asyncio
 import threading
-from pyrogram import Client, filters
-import gradio as gr
+from queue import Queue, Empty
+import os
+from telegram import Update
+from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
 
-API_ID = int(os.environ.get("API_ID", "6"))
-API_HASH = os.environ.get("API_HASH", "eb06d4abfb49dc3eeb1aeb98ae0f581e")
+# Env vars or hardcode your Telegram bot token here
 BOT_TOKEN = os.environ.get("BOT_TOKEN", "7510817339:AAHFZoFzPkUO_-nAwfh9bjY_qHsWMprM2PI")
+# Globals
+bot_app = None  # Telegram Application instance
+bot_thread = None
+bot_running = False
+log_queue = Queue()
+telegram_cmd_logs = []
+
+# -- Telegram Bot Handlers --
+
+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}")
+
+    # Run command and collect output (limit max 4000 chars for Telegram)
+    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 running command: {e}"
+
+    await update.message.reply_text(f"$ {cmd}\n{output}")
+
+    telegram_cmd_logs.append(f"$ {cmd}\n{output}")
+    # Limit logs to last 50 commands
+    if len(telegram_cmd_logs) > 50:
+        telegram_cmd_logs.pop(0)
 
+def start_bot():
+    global bot_app, bot_running
 
-app = Client("my_bot", api_id=API_ID, api_hash=API_HASH, bot_token=BOT_TOKEN)
-
-bot_running = False
-bot_lock = threading.Lock()
+    if bot_running:
+        log_queue.put("[Bot] Already running.")
+        return
 
-command_history = []
-history_pos = -1
-output_logs = ""
+    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()
 
-def append_log(text):
-    global output_logs
-    output_logs += text + "\n"
-    # Limit to last 20k chars to keep it manageable
-    if len(output_logs) > 20000:
-        output_logs = output_logs[-20000:]
+    loop = asyncio.new_event_loop()
 
-# Telegram /start command handler
-@app.on_message(filters.command("start"))
-async def start_handler(client, message):
-    await message.reply_text("Hi 👋")
-    append_log(f"[BOT] Replied 'Hi' to user {message.from_user.id}")
+    def runner():
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(run_bot())
 
-def start_bot():
-    global bot_running
-    with bot_lock:
-        if not bot_running:
-            asyncio.run(app.start())
-            bot_running = True
-            append_log("[SYSTEM] Bot started")
-        else:
-            append_log("[SYSTEM] Bot already running")
+    global bot_thread
+    bot_thread = threading.Thread(target=runner, daemon=True)
+    bot_thread.start()
 
 def stop_bot():
-    global bot_running
-    with bot_lock:
-        if bot_running:
-            asyncio.run(app.stop())
-            bot_running = False
-            append_log("[SYSTEM] Bot stopped")
-        else:
-            append_log("[SYSTEM] Bot already stopped")
-
-def run_command(cmd):
-    """
-    This simulates running a command in the 'terminal'.
-    We support:
-    - telegram commands: /start etc will be sent to the bot (simulate)
-    - shell commands: run on local shell and return output
-    """
-    append_log(f"> {cmd}")
-    # For example purposes, just handle /start command specially
-    if cmd.strip() == "/start":
-        # simulate bot reply (because real bot interaction needs telegram user)
-        append_log("[BOT] Hi 👋")
-    else:
-        # Run shell command and capture output
-        import subprocess
-        try:
-            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT, timeout=10, text=True)
-            append_log(output.strip())
-        except subprocess.CalledProcessError as e:
-            append_log(f"Error:\n{e.output}")
-        except Exception as e:
-            append_log(f"Exception: {str(e)}")
-    return output_logs
-
-# --- Gradio interface callbacks ---
-
-def on_send_command(cmd, hist_pos):
-    global command_history, history_pos
-    if cmd.strip():
-        command_history.append(cmd.strip())
-        history_pos = len(command_history)  # reset position after new command
-        logs = run_command(cmd)
-        return "", logs, history_pos
-    else:
-        return "", output_logs, hist_pos
-
-def on_up_arrow(hist_pos):
-    global command_history
-    if command_history and hist_pos > 0:
-        hist_pos -= 1
-        return command_history[hist_pos], output_logs, hist_pos
-    return gr.Textbox.update(), output_logs, hist_pos
-
-def on_down_arrow(hist_pos):
-    global command_history
-    if command_history and hist_pos < len(command_history) - 1:
-        hist_pos += 1
-        return command_history[hist_pos], output_logs, hist_pos
-    elif hist_pos == len(command_history) - 1:
-        hist_pos += 1
-        return "", output_logs, hist_pos
-    return gr.Textbox.update(), output_logs, hist_pos
-
-def start_bot_ui():
-    threading.Thread(target=start_bot).start()
-    return output_logs
-
-def stop_bot_ui():
-    threading.Thread(target=stop_bot).start()
-    return output_logs
+    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
+
+# -- Gradio Web Terminal --
+
+def live_terminal(cmd):
+    if not cmd.strip():
+        yield "$ "
+        return
+    yield f"$ {cmd}\n"
+    process = subprocess.Popen(
+        cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+    )
+    for line in iter(process.stdout.readline, ''):
+        yield line
+    process.stdout.close()
+    process.wait()
+    yield "$ "
+
+def run_terminal(cmd):
+    return live_terminal(cmd)
+
+def update_log_box():
+    # Show last 20 logs
+    logs = []
+    try:
+        while True:
+            log = log_queue.get_nowait()
+            logs.append(log)
+    except Empty:
+        pass
+
+    logs.extend(telegram_cmd_logs[-20:])
+    return "\n".join(logs[-20:])
+
+# -- Gradio UI --
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Telegram Bot Terminal with Start/Stop and Command History")
+    gr.Markdown("### Live Terminal with Telegram Bot Control")
 
     with gr.Row():
-        start_btn = gr.Button("🚀 Start Bot")
-        stop_btn = gr.Button("🛑 Stop Bot")
-    logs = gr.Textbox(label="Logs / Terminal Output", lines=20, interactive=False)
-    cmd_input = gr.Textbox(label="Enter command", lines=1, interactive=True)
-
-    # Hidden state for history position
-    hist_pos_state = gr.State(value=len(command_history))
-
-    # Button clicks
-    start_btn.click(start_bot_ui, outputs=logs)
-    stop_btn.click(stop_bot_ui, outputs=logs)
-
-    # Send command on Enter
-    cmd_input.submit(on_send_command, inputs=[cmd_input, hist_pos_state], outputs=[cmd_input, logs, hist_pos_state])
-
-    # JavaScript events to detect arrow keys
-    # We use custom JS to send event to Gradio for arrow keys pressed in the textbox
-    # Note: Gradio does not natively support up/down key callbacks,
-    # so we inject this JS trick below.
-
-    cmd_input.js(
-        """
-        () => {
-            const input = document.querySelector('textarea[aria-label="Enter command"]');
-            input.addEventListener('keydown', e => {
-                if (e.key === "ArrowUp") {
-                    e.preventDefault();
-                    gradioApp().getElementById('up-arrow-btn').click();
-                }
-                if (e.key === "ArrowDown") {
-                    e.preventDefault();
-                    gradioApp().getElementById('down-arrow-btn').click();
-                }
-            });
-        }
-        """
-    )
+        terminal_output = gr.Textbox(value="$ ", label="Live Terminal", lines=20, interactive=False)
+        cmd_input = gr.Textbox(placeholder="Type command here and press Enter", label="Command Input")
+
+    with gr.Row():
+        start_btn = gr.Button("Start Telegram Bot")
+        stop_btn = gr.Button("Stop Telegram Bot")
+
+    log_output = gr.Textbox(value="", label="Bot Logs & Telegram Bash Command Logs", lines=15, interactive=False)
+
+    # Command input triggers terminal
+    cmd_input.submit(run_terminal, inputs=cmd_input, outputs=terminal_output)
+
+    # Start/stop buttons update logs
+    def start_click():
+        start_bot()
+        return update_log_box()
+
+    def stop_click():
+        stop_bot()
+        return update_log_box()
 
-    # Hidden buttons for up/down arrow to call Python
-    up_btn = gr.Button(visible=False, elem_id="up-arrow-btn")
-    down_btn = gr.Button(visible=False, elem_id="down-arrow-btn")
+    start_btn.click(start_click, outputs=log_output)
+    stop_btn.click(stop_click, outputs=log_output)
 
-    up_btn.click(on_up_arrow, inputs=hist_pos_state, outputs=[cmd_input, logs, hist_pos_state])
-    down_btn.click(on_down_arrow, inputs=hist_pos_state, outputs=[cmd_input, logs, hist_pos_state])
+    # Auto-update logs every 3 seconds
+    def auto_update():
+        return update_log_box()
 
-    # Initialize logs textbox content
-    logs.value = output_logs
+    demo.load(auto_update, None, log_output, every=3)
 
 demo.launch()