Update app.py

app.py

@@ -2,12 +2,13 @@ import gradio as gr
 import subprocess
 import asyncio
 import threading
-from queue import Queue, Empty
+from queue import Queue
 import os
+import shlex
 from telegram import Update
 from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
 
-BOT_TOKEN = os.environ.get("BOT_TOKEN")  # Set it only via environment for safety
+BOT_TOKEN = os.environ.get("BOT_TOKEN")
 
 log_queue = Queue()
 MAX_LOGS = 20000
@@ -16,79 +17,82 @@ bot_logs = []
 bot_app = None
 bot_running = False
 bot_thread = None
+current_dir = os.getcwd()
 
-# --- Telegram 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
-
-    entry = f"[Bot] $ {cmd}"
-    log_queue.put(entry)
-    add_bot_log(entry)
-
-    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}"
-
-    result = f"$ {cmd}\n{output}"
-    log_queue.put(result)
-    add_bot_log(result)
-    await update.message.reply_text(result)
-
-# --- Logging Functions ---
+# --- Logging ---
 def add_terminal_log(entry):
     terminal_logs.append(entry)
     if len(terminal_logs) > MAX_LOGS:
-        del terminal_logs[0]
+        terminal_logs.pop(0)
 
 def add_bot_log(entry):
     bot_logs.append(entry)
     if len(bot_logs) > MAX_LOGS:
-        del bot_logs[0]
-
-# --- Terminal ---
-def live_terminal(cmd):
-    if not cmd.strip():
-        yield "$ "
-        return
-    yield f"$ {cmd}\n"
-
-    try:
-        proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        bot_logs.pop(0)
+
+# --- Command Execution ---
+def execute_command(cmd):
+    global current_dir
+    output = []
+    add_terminal_log(f"$ {cmd}")
+    if cmd.strip().startswith("cd"):
+        parts = shlex.split(cmd)
+        if len(parts) > 1:
+            new_path = os.path.join(current_dir, parts[1])
+            if os.path.isdir(new_path):
+                current_dir = os.path.abspath(new_path)
+                msg = f"Changed directory to {current_dir}"
+                output.append(msg)
+                add_terminal_log(msg)
+            else:
+                msg = f"Directory not found: {new_path}"
+                output.append(msg)
+                add_terminal_log(msg)
+        else:
+            msg = "Usage: cd <path>"
+            output.append(msg)
+            add_terminal_log(msg)
+    else:
+        proc = subprocess.Popen(cmd, cwd=current_dir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
         for line in iter(proc.stdout.readline, ''):
             line = line.strip()
-            log_queue.put(line)
-            add_terminal_log(line)
-            yield line + "\n"
+            if line:
+                output.append(line)
+                add_terminal_log(line)
         proc.stdout.close()
         proc.wait()
+    return "\n".join(output)
+
+# --- 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
+
+    prefix = f"[Bot] $ {cmd}"
+    add_bot_log(prefix)
+
+    try:
+        result = execute_command(cmd)
     except Exception as e:
-        error = f"[Error] {e}"
-        log_queue.put(error)
-        add_terminal_log(error)
-        yield error + "\n"
-    yield "$ "
+        result = f"Error: {e}"
 
-# --- Bot ---
+    add_bot_log(result)
+    await update.message.reply_text(f"$ {cmd}\n{result}")
+
+# --- Bot Start/Stop Logic ---
 def start_bot():
     global bot_app, bot_running, bot_thread
-
     if bot_running or not BOT_TOKEN:
-        log_queue.put("[Bot] Already running or token missing.")
+        add_bot_log("[Bot] Already running or token missing.")
         return
 
     async def run_bot():
         global bot_app
         bot_app = ApplicationBuilder().token(BOT_TOKEN).build()
         bot_app.add_handler(CommandHandler("bash", bash_command))
-        log_queue.put("[Bot] Starting bot...")
+        add_bot_log("[Bot] Starting bot...")
         await bot_app.run_polling()
 
     def runner():
@@ -97,69 +101,77 @@ def start_bot():
     bot_thread = threading.Thread(target=runner, daemon=True)
     bot_thread.start()
     bot_running = True
-    log_queue.put("[Bot] Bot started.")
+    add_bot_log("[Bot] Bot started.")
 
 def stop_bot():
     global bot_app, bot_running
     if not bot_running:
-        log_queue.put("[Bot] Bot not running.")
+        add_bot_log("[Bot] Bot not running.")
         return
 
     async def shutdown():
         await bot_app.shutdown()
         await bot_app.stop()
-        log_queue.put("[Bot] Bot stopped.")
+        add_bot_log("[Bot] Bot stopped.")
 
     asyncio.run(shutdown())
     bot_running = False
 
-# --- UI Log Updates ---
+# --- UI Update Functions ---
 def update_terminal_logs():
     return "\n".join(terminal_logs[-100:])
 
 def update_bot_logs():
     return "\n".join(bot_logs[-100:])
 
+def live_terminal(cmd):
+    result = [f"$ {cmd}"]
+    try:
+        result.append(execute_command(cmd))
+    except Exception as e:
+        result.append(f"[Error] {e}")
+    result.append(f"$ {current_dir} >")
+    return "\n".join(result)
+
 # --- Gradio UI ---
 with gr.Blocks() as demo:
-    gr.Markdown("## 🖥️ Terminal + 🤖 Telegram Bot (Live Logs)")
-
-    with gr.Row():
-        terminal_output = gr.Textbox(label="📟 Terminal Output", lines=20, interactive=False)
-        bot_output = gr.Textbox(label="🤖 Telegram Bot Logs", lines=20, interactive=False)
-
-    with gr.Row():
-        cmd_input = gr.Textbox(placeholder="Enter shell command", label="Command Input")
-        run_btn = gr.Button("▶️ Run Command")
+    with gr.Tab("💻 Terminal"):
+        gr.Markdown("## 🖥️ Interactive Terminal")
 
-    with gr.Row():
-        start_btn = gr.Button("🚀 Start Telegram Bot")
-        stop_btn = gr.Button("🛑 Stop Telegram Bot")
+        with gr.Row():
+            terminal_output = gr.Textbox(label="📟 Terminal Output", lines=20, interactive=False)
+        with gr.Row():
+            cmd_input = gr.Textbox(placeholder="Enter shell command", label="Command Input")
+            run_btn = gr.Button("▶️ Run Command")
 
-    run_btn.click(fn=live_terminal, inputs=cmd_input, outputs=terminal_output)
+        run_btn.click(fn=live_terminal, inputs=cmd_input, outputs=terminal_output)
+        demo.load(fn=lambda: update_terminal_logs(), outputs=terminal_output, every=3)
 
-    def handle_start():
-        start_bot()
-        return update_bot_logs()
+    with gr.Tab("🤖 Telegram Bot"):
+        gr.Markdown("## 🤖 Telegram Bot Controls")
 
-    def handle_stop():
-        stop_bot()
-        return update_bot_logs()
+        with gr.Row():
+            bot_output = gr.Textbox(label="🤖 Telegram Bot Logs", lines=20, interactive=False)
+        with gr.Row():
+            token_box = gr.Textbox(label="Bot Token", placeholder="Enter Telegram Bot Token")
+        with gr.Row():
+            start_btn = gr.Button("🚀 Start Telegram Bot")
+            stop_btn = gr.Button("🛑 Stop Telegram Bot")
 
-    start_btn.click(fn=handle_start, outputs=bot_output)
-    stop_btn.click(fn=handle_stop, outputs=bot_output)
+        def set_token_and_start(token):
+            global BOT_TOKEN
+            BOT_TOKEN = token
+            start_bot()
+            return update_bot_logs()
 
-    def auto_update_terminal():
-        while True:
-            import time; time.sleep(3)
-            yield update_terminal_logs()
+        start_btn.click(fn=set_token_and_start, inputs=token_box, outputs=bot_output)
 
-    def auto_update_bot():
-        while True:
-            import time; time.sleep(3)
-            yield update_bot_logs()
+        def handle_stop():
+            stop_bot()
+            return update_bot_logs()
 
-    demo.load(fn=auto_update_terminal, outputs=terminal_output)
-    demo.load(fn=auto_update_bot, outputs=bot_output)
+        stop_btn.click(fn=handle_stop, outputs=bot_output)
+        demo.load(fn=lambda: update_bot_logs(), outputs=bot_output, every=3)
 
+# --- Launch the App ---
 demo.launch()