Update app.py

app.py

@@ -1,3 +1,6 @@
+# الملف الكامل المصحح - app.py
+# فقط التغييرات المهمة موضحة
+
 import gradio as gr
 import subprocess
 import os
@@ -8,36 +11,38 @@ import psutil
 import time
 import threading
 import json
+import hashlib
 import secrets
+from pathlib import Path
+from datetime import datetime, timedelta
 from collections import deque
-from datetime import datetime
 
-# إعداد مسار العمل ليكون داخل مجلد التطبيق الحالي لتجنب مشاكل الصلاحيات
-BASE_DIR = os.getcwd()
-WORKSPACE = os.path.join(BASE_DIR, "workspace")
+WORKSPACE = "/home/user/workspace"
 LOGS_DIR = os.path.join(WORKSPACE, ".system_logs")
 SESSIONS_DIR = os.path.join(WORKSPACE, ".sessions")
 BACKUP_DIR = os.path.join(WORKSPACE, ".backups")
 CONFIG_FILE = os.path.join(WORKSPACE, ".vps_config.json")
 
-# إنشاء المجلدات
 for d in [WORKSPACE, LOGS_DIR, SESSIONS_DIR, BACKUP_DIR]:
     os.makedirs(d, exist_ok=True)
 
-# تغيير مسار العمل
 os.chdir(WORKSPACE)
 
 bg_processes = {}
 proc_lock = threading.Lock()
 cmd_history = deque(maxlen=500)
 resource_history = deque(maxlen=100)
+active_monitors = {}
 
 DEFAULT_CONFIG = {
     "max_bg_processes": 20,
     "command_timeout": 300,
+    "max_log_size_mb": 50,
+    "auto_cleanup_hours": 24,
     "monitor_interval": 30,
 }
 
+
 def load_config():
     try:
         if os.path.exists(CONFIG_FILE):
@@ -50,193 +55,1386 @@ def load_config():
         pass
     return DEFAULT_CONFIG.copy()
 
+
+def save_config(cfg):
+    try:
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(cfg, f, indent=2)
+    except:
+        pass
+
+
 config = load_config()
 
-# --- Resource Monitor ---
+
 def resource_monitor():
     while True:
         try:
             mem = psutil.virtual_memory()
             cpu = psutil.cpu_percent(interval=1)
+            disk = psutil.disk_usage("/")
             resource_history.append({
                 "time": datetime.now().strftime("%H:%M:%S"),
                 "cpu": cpu,
                 "ram_percent": mem.percent,
                 "ram_used": mem.used,
                 "ram_total": mem.total,
+                "disk_percent": disk.percent,
             })
-            # Cleanup logic
-            with proc_lock:
-                to_del = []
-                for pid, info in bg_processes.items():
-                    if info["proc"].poll() is not None:
-                        try: info["log_f"].close()
-                        except: pass
-                        # Don't delete immediately to allow viewing logs of stopped/crashed processes
+            cleanup_dead_processes()
         except:
             pass
         time.sleep(config.get("monitor_interval", 30))
 
+
 monitor_thread = threading.Thread(target=resource_monitor, daemon=True)
 monitor_thread.start()
 
-# --- Helper Functions ---
+
+def cleanup_dead_processes():
+    with proc_lock:
+        dead = []
+        for pid, info in bg_processes.items():
+            if info["proc"].poll() is not None:
+                try:
+                    info["log_f"].close()
+                except:
+                    pass
+                dead.append(pid)
+
+
 def fmt_size(size_bytes):
-    if size_bytes < 0: return "0B"
+    if size_bytes < 0:
+        return "0B"
     units = ["B", "KB", "MB", "GB", "TB"]
-    idx = 0; size = float(size_bytes)
+    idx = 0
+    size = float(size_bytes)
     while size >= 1024 and idx < len(units) - 1:
-        size /= 1024; idx += 1
+        size /= 1024
+        idx += 1
     return f"{size:.1f}{units[idx]}"
 
-def resolve_path(path):
-    if not path: return WORKSPACE
+
+def file_icon(name):
+    ext = name.rsplit(".", 1)[-1].lower() if "." in name else ""
+    m = {
+        "py": "🐍", "js": "📜", "ts": "📘", "jsx": "⚛️", "tsx": "⚛️",
+        "html": "🌐", "css": "🎨", "scss": "🎨", "less": "🎨",
+        "json": "📋", "yml": "⚙️", "yaml": "⚙️", "toml": "⚙️", "ini": "⚙️",
+        "md": "📝", "txt": "📄", "log": "📃", "csv": "📊", "xml": "📰",
+        "jpg": "🖼️", "jpeg": "🖼️", "png": "🖼️", "gif": "🖼️", "svg": "🖼️",
+        "webp": "🖼️",
+        "mp3": "🎵", "wav": "🎵", "mp4": "🎬", "avi": "🎬", "mkv": "🎬",
+        "zip": "📦", "tar": "📦", "gz": "📦", "rar": "📦", "7z": "📦",
+        "sh": "⚡", "bash": "⚡", "zsh": "⚡", "fish": "⚡",
+        "env": "🔐", "key": "🔑", "pem": "🔑", "crt": "🔑",
+        "db": "🗄️", "sqlite": "🗄️", "sqlite3": "🗄️", "sql": "🗄️",
+        "dockerfile": "🐳", "dockerignore": "🐳",
+        "gitignore": "📌", "gitmodules": "📌",
+        "lock": "🔒", "pid": "🔒",
+        "whl": "📀", "egg": "📀",
+        "cfg": "⚙️", "conf": "⚙️", "config": "⚙️",
+        "rst": "📝", "tex": "📝", "pdf": "📕",
+        "c": "🔧", "cpp": "🔧", "h": "🔧", "hpp": "🔧",
+        "java": "☕", "class": "☕", "jar": "☕",
+        "go": "🔵", "rs": "🦀", "rb": "💎", "php": "🐘",
+        "r": "📈", "rmd": "📈", "ipynb": "📓",
+    }
+    return m.get(ext, "📄")
+
+
+def resolve_path(path, base=None):
+    if not path:
+        return os.getcwd()
     path = path.strip()
-    if path.startswith("~"): path = path.replace("~", WORKSPACE, 1)
-    if not os.path.isabs(path): path = os.path.join(WORKSPACE, path)
+    if path.startswith("~"):
+        path = path.replace("~", WORKSPACE, 1)
+    if not os.path.isabs(path):
+        base = base or os.getcwd()
+        path = os.path.join(base, path)
     return os.path.abspath(path)
 
-# --- Core Functions ---
+
+def log_command(cmd, output, duration):
+    entry = {
+        "time": datetime.now().isoformat(),
+        "command": cmd,
+        "output_length": len(output),
+        "duration": round(duration, 3),
+    }
+    cmd_history.append(entry)
+    try:
+        log_file = os.path.join(
+            LOGS_DIR, f"commands_{datetime.now().strftime('%Y%m%d')}.log"
+        )
+        with open(log_file, "a") as f:
+            f.write(f"[{entry['time']}] ({duration:.3f}s) $ {cmd}\n")
+    except:
+        pass
+
+
 def execute_terminal(command, work_dir):
-    if not command or not command.strip(): return "", work_dir or WORKSPACE
-    
+    if not command or not command.strip():
+        return "$ _", work_dir or WORKSPACE
+    command = command.strip()
     wd = resolve_path(work_dir) if work_dir else WORKSPACE
-    if not os.path.isdir(wd): wd = WORKSPACE
-    
-    cmd = command.strip()
-    if cmd.startswith("cd "):
-        target = cmd[3:].strip()
-        new_path = resolve_path(target)
-        if os.path.isdir(new_path):
-            return f"Changed directory to {new_path}", new_path
-        return f"Directory not found: {target}", wd
+    if not os.path.isdir(wd):
+        wd = WORKSPACE
+    start = time.time()
+    parts = command.split()
+    base_cmd = parts[0] if parts else ""
+
+    if base_cmd == "cd":
+        target = parts[1] if len(parts) > 1 else WORKSPACE
+        target = resolve_path(target, wd)
+        if os.path.isdir(target):
+            os.chdir(target)
+            elapsed = time.time() - start
+            log_command(command, target, elapsed)
+            return f"$ cd {target}\n{target}", target
+        return f"bash: cd: {target}: No such file or directory", wd
+
+    if base_cmd in ("clear", "cls", "reset"):
+        return "", wd
+
+    if base_cmd == "history":
+        lines = []
+        for i, entry in enumerate(cmd_history):
+            lines.append(f"  {i+1}  {entry['command']}")
+        return "\n".join(lines[-50:]) if lines else "No history", wd
+
+    if base_cmd == "export":
+        if len(parts) >= 2 and "=" in parts[1]:
+            key, val = parts[1].split("=", 1)
+            os.environ[key] = val
+            return f"export {key}={val}", wd
 
     try:
+        env = os.environ.copy()
+        env["PYTHONUNBUFFERED"] = "1"
+        env["PIP_PROGRESS_BAR"] = "off"
+        env["TERM"] = "xterm-256color"
+        env["HOME"] = os.path.expanduser("~")
+        env["WORKSPACE"] = WORKSPACE
+        timeout = config.get("command_timeout", 300)
+
         result = subprocess.run(
-            cmd, shell=True, capture_output=True, text=True, timeout=120, cwd=wd, executable="/bin/bash"
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=wd,
+            env=env,
+            executable="/bin/bash",
         )
-        output = result.stdout + result.stderr
-        if not output and result.returncode == 0: output = "Done."
+        elapsed = time.time() - start
+        output_parts = []
+        if result.stdout:
+            output_parts.append(result.stdout.rstrip())
+        if result.stderr:
+            output_parts.append(result.stderr.rstrip())
+        output = "\n".join(output_parts) if output_parts else ""
+        if not output and result.returncode != 0:
+            output = f"Process exited with code {result.returncode}"
+        elif not output:
+            output = ""
+        log_command(command, output, elapsed)
         return output, wd
+
+    except subprocess.TimeoutExpired:
+        elapsed = time.time() - start
+        log_command(command, "TIMEOUT", elapsed)
+        return (
+            f"Command timed out after {timeout}s. "
+            f"Use background execution for long tasks.",
+            wd,
+        )
     except Exception as e:
+        elapsed = time.time() - start
+        log_command(command, str(e), elapsed)
         return f"Error: {str(e)}", wd
 
+
 def execute_background(command, work_dir):
-    if not command: return "No command"
-    wd = resolve_path(work_dir)
-    
+    if not command or not command.strip():
+        return "No command specified"
+    with proc_lock:
+        if len(bg_processes) >= config.get("max_bg_processes", 20):
+            return (
+                f"Process limit reached ({config['max_bg_processes']}). "
+                f"Stop existing processes first."
+            )
+    wd = resolve_path(work_dir) if work_dir else WORKSPACE
+    if not os.path.isdir(wd):
+        wd = WORKSPACE
     try:
         ts = datetime.now().strftime("%Y%m%d_%H%M%S")
         proc_id = secrets.token_hex(4)
         log_path = os.path.join(LOGS_DIR, f"bg_{ts}_{proc_id}.log")
         log_f = open(log_path, "w", buffering=1)
-        
+        header = (
+            f"=== Process Started ===\n"
+            f"Command: {command}\n"
+            f"Directory: {wd}\n"
+            f"Time: {datetime.now().isoformat()}\n"
+            f"{'=' * 40}\n\n"
+        )
+        log_f.write(header)
+        log_f.flush()
+
+        env = os.environ.copy()
+        env["PYTHONUNBUFFERED"] = "1"
+        env["TERM"] = "xterm-256color"
+        env["WORKSPACE"] = WORKSPACE
+
         proc = subprocess.Popen(
-            command, shell=True, stdout=log_f, stderr=subprocess.STDOUT, 
-            cwd=wd, executable="/bin/bash", preexec_fn=os.setsid
+            command,
+            shell=True,
+            stdout=log_f,
+            stderr=subprocess.STDOUT,
+            cwd=wd,
+            env=env,
+            preexec_fn=os.setsid,
+            executable="/bin/bash",
         )
-        
+
         with proc_lock:
             bg_processes[proc.pid] = {
-                "id": proc_id, "cmd": command, "pid": proc.pid, 
-                "start": datetime.now().strftime("%H:%M:%S"),
-                "start_ts": time.time(), "log": log_path, 
-                "proc": proc, "log_f": log_f, "dir": wd
+                "cmd": command,
+                "pid": proc.pid,
+                "start": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "start_ts": time.time(),
+                "log": log_path,
+                "proc": proc,
+                "log_f": log_f,
+                "dir": wd,
+                "id": proc_id,
             }
-        return f"Started PID: {proc.pid} (ID: {proc_id})"
+
+        return (
+            f"Process started successfully\n"
+            f"{'─' * 45}\n"
+            f"  PID     : {proc.pid}\n"
+            f"  ID      : {proc_id}\n"
+            f"  Command : {command}\n"
+            f"  Dir     : {wd}\n"
+            f"  Log     : {log_path}\n"
+            f"{'─' * 45}\n"
+            f"View log  : cat {log_path}\n"
+            f"Stop      : Use Process Manager tab"
+        )
+    except Exception as e:
+        return f"Failed to start process: {str(e)}"
+
+
+def get_system_info():
+    try:
+        mem = psutil.virtual_memory()
+        swap = psutil.swap_memory()
+        disk = psutil.disk_usage("/")
+        cpu_freq = psutil.cpu_freq()
+        boot = datetime.fromtimestamp(psutil.boot_time())
+        uptime = datetime.now() - boot
+        net = psutil.net_io_counters()
+        freq_str = f"{cpu_freq.current:.0f}MHz" if cpu_freq else "N/A"
+        days = uptime.days
+        hours = uptime.seconds // 3600
+        mins = (uptime.seconds % 3600) // 60
+
+        with proc_lock:
+            bg_count = len(bg_processes)
+            bg_alive = sum(
+                1 for p in bg_processes.values() if p["proc"].poll() is None
+            )
+
+        info = f"""╔══════════════════════════════════════════════╗
+║            SYSTEM INFORMATION                ║
+╠══════════════════════════════════════════════╣
+║  OS       : {os.uname().sysname} {os.uname().release[:22]}
+║  Arch     : {os.uname().machine}
+║  Python   : {sys.version.split()[0]}
+║  Uptime   : {days}d {hours}h {mins}m
+║  CPU      : {psutil.cpu_count()} cores @ {freq_str}
+║  CPU Load : {psutil.cpu_percent():.1f}%
+║  RAM Total: {fmt_size(mem.total)}
+║  RAM Used : {fmt_size(mem.used)} ({mem.percent}%)
+║  RAM Free : {fmt_size(mem.available)}
+║  Swap     : {fmt_size(swap.used)}/{fmt_size(swap.total)}
+║  Disk Tot : {fmt_size(disk.total)}
+║  Disk Used: {fmt_size(disk.used)} ({disk.percent}%)
+║  Disk Free: {fmt_size(disk.free)}
+║  Net Sent : {fmt_size(net.bytes_sent)}
+║  Net Recv : {fmt_size(net.bytes_recv)}
+║  BG Procs : {bg_alive} running / {bg_count} total
+║  Work Dir : {os.getcwd()}
+╚══════════════════════════════════════════════╝"""
+        return info
     except Exception as e:
-        return f"Failed: {e}"
+        return f"Error: {str(e)}"
+
+
+def browse_directory(path):
+    target = resolve_path(path)
+    if not os.path.isdir(target):
+        return f"Not a directory: {target}"
+    try:
+        all_items = sorted(
+            os.listdir(target),
+            key=lambda x: (not os.path.isdir(os.path.join(target, x)), x.lower()),
+        )
+        lines = [
+            f" {target}",
+            f"{'═' * 70}",
+            f" {'Type':<6} {'Size':>10}  {'Modified':<18} {'Name'}",
+            f"{'─' * 70}",
+        ]
+        if target != "/":
+            lines.append(f" {'📁':<6} {'':>10}  {'':.<18} ..")
+
+        dirs_c = 0
+        files_c = 0
+        total_sz = 0
+
+        for item in all_items:
+            fp = os.path.join(target, item)
+            try:
+                st = os.stat(fp, follow_symlinks=False)
+                mtime = datetime.fromtimestamp(st.st_mtime).strftime(
+                    "%Y-%m-%d %H:%M"
+                )
+                if os.path.islink(fp):
+                    real = os.path.realpath(fp)
+                    lines.append(
+                        f" {'🔗':<6} {'':>10}  {mtime:<18} {item} -> {real}"
+                    )
+                elif os.path.isdir(fp):
+                    sub_count = 0
+                    try:
+                        sub_count = len(os.listdir(fp))
+                    except:
+                        pass
+                    lines.append(
+                        f" {'📁':<6} {f'{sub_count} items':>10}  {mtime:<18} {item}/"
+                    )
+                    dirs_c += 1
+                else:
+                    sz = st.st_size
+                    total_sz += sz
+                    ico = file_icon(item)
+                    perm = ""
+                    if os.access(fp, os.X_OK):
+                        perm = " *"
+                    lines.append(
+                        f" {ico:<6} {fmt_size(sz):>10}  {mtime:<18} {item}{perm}"
+                    )
+                    files_c += 1
+            except PermissionError:
+                lines.append(f" {'🔒':<6} {'denied':>10}  {'':.<18} {item}")
+            except Exception:
+                lines.append(f" {'❓':<6} {'error':>10}  {'':.<18} {item}")
+
+        lines.append(f"{'─' * 70}")
+        lines.append(
+            f" {dirs_c} directories  {files_c} files  {fmt_size(total_sz)} total"
+        )
+        return "\n".join(lines)
+    except PermissionError:
+        return f"Permission denied: {target}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def read_file(filepath):
+    if not filepath or not filepath.strip():
+        return ""
+    fp = resolve_path(filepath)
+    if not os.path.exists(fp):
+        return f"File not found: {fp}"
+    if os.path.isdir(fp):
+        return f"Is a directory: {fp}"
+    size = os.path.getsize(fp)
+    if size > 10 * 1024 * 1024:
+        return f"File too large: {fmt_size(size)}. Use 'head' or 'tail' commands."
+    try:
+        with open(fp, "r", encoding="utf-8", errors="replace") as f:
+            return f.read()
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def write_file(filepath, content):
+    if not filepath or not filepath.strip():
+        return "No filename specified"
+    fp = resolve_path(filepath)
+    try:
+        parent = os.path.dirname(fp)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        with open(fp, "w", encoding="utf-8") as f:
+            f.write(content if content else "")
+        sz = os.path.getsize(fp)
+        return f"Saved: {fp} ({fmt_size(sz)})"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def delete_path(filepath):
+    if not filepath or not filepath.strip():
+        return "No path specified"
+    fp = resolve_path(filepath)
+    if not os.path.exists(fp):
+        return f"Not found: {fp}"
+    if fp in (WORKSPACE, "/", os.path.expanduser("~")):
+        return "Cannot delete system directories"
+    try:
+        if os.path.isdir(fp):
+            item_count = sum(
+                len(files) + len(dirs) for _, dirs, files in os.walk(fp)
+            )
+            shutil.rmtree(fp)
+            return f"Deleted directory: {fp} ({item_count} items)"
+        else:
+            sz = os.path.getsize(fp)
+            os.remove(fp)
+            return f"Deleted: {fp} ({fmt_size(sz)})"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def create_dir(dirpath):
+    if not dirpath or not dirpath.strip():
+        return "No directory name specified"
+    dp = resolve_path(dirpath)
+    try:
+        os.makedirs(dp, exist_ok=True)
+        return f"Created: {dp}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def rename_item(old_path, new_path):
+    if not old_path or not new_path:
+        return "Specify both old and new paths"
+    old = resolve_path(old_path)
+    new = resolve_path(new_path)
+    if not os.path.exists(old):
+        return f"Not found: {old}"
+    try:
+        shutil.move(old, new)
+        return f"Renamed: {old} -> {new}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def copy_item(src_path, dst_path):
+    if not src_path or not dst_path:
+        return "Specify both source and destination"
+    src = resolve_path(src_path)
+    dst = resolve_path(dst_path)
+    if not os.path.exists(src):
+        return f"Not found: {src}"
+    try:
+        if os.path.isdir(src):
+            shutil.copytree(src, dst)
+        else:
+            os.makedirs(os.path.dirname(dst) or ".", exist_ok=True)
+            shutil.copy2(src, dst)
+        return f"Copied: {src} -> {dst}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def upload_handler(file_obj):
+    if file_obj is None:
+        return "No file selected"
+    try:
+        src = (
+            file_obj
+            if isinstance(file_obj, str)
+            else (file_obj.name if hasattr(file_obj, "name") else str(file_obj))
+        )
+        fname = os.path.basename(src)
+        dest = os.path.join(os.getcwd(), fname)
+        counter = 1
+        base, ext = os.path.splitext(fname)
+        while os.path.exists(dest):
+            dest = os.path.join(os.getcwd(), f"{base}_{counter}{ext}")
+            counter += 1
+        shutil.copy2(src, dest)
+        sz = os.path.getsize(dest)
+        return f"Uploaded: {os.path.basename(dest)} ({fmt_size(sz)})"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def chmod_item(filepath, mode):
+    if not filepath or not mode:
+        return "Specify file and mode (e.g., 755)"
+    fp = resolve_path(filepath)
+    if not os.path.exists(fp):
+        return f"Not found: {fp}"
+    try:
+        os.chmod(fp, int(mode, 8))
+        return f"Changed permissions: {fp} -> {mode}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def load_file_to_editor(filepath):
+    content = read_file(filepath)
+    if content.startswith(("File not found", "Error", "Is a directory", "File too large")):
+        return gr.update(), content
+    return content, f"Loaded: {resolve_path(filepath)}"
+
+
+def editor_save(filepath, code):
+    return write_file(filepath, code)
+
+
+def editor_save_run(filepath, code):
+    if not filepath or not filepath.strip():
+        return "No filename specified"
+    fp = resolve_path(filepath)
+    save_result = write_file(filepath, code)
+    ext = fp.rsplit(".", 1)[-1].lower() if "." in fp else ""
+    runners = {
+        "py": f'python3 "{fp}"',
+        "js": f'node "{fp}"',
+        "ts": f'npx ts-node "{fp}"',
+        "sh": f'bash "{fp}"',
+        "bash": f'bash "{fp}"',
+        "rb": f'ruby "{fp}"',
+        "php": f'php "{fp}"',
+        "go": f'go run "{fp}"',
+        "rs": f'rustc "{fp}" -o /tmp/rs_out && /tmp/rs_out',
+        "c": f'gcc "{fp}" -o /tmp/c_out && /tmp/c_out',
+        "cpp": f'g++ "{fp}" -o /tmp/cpp_out && /tmp/cpp_out',
+    }
+    if ext in runners:
+        result, _ = execute_terminal(runners[ext], os.path.dirname(fp))
+        return f"{save_result}\n{'─' * 45}\n{result}"
+    return save_result
+
+
+def editor_run_bg(filepath, code):
+    if not filepath or not filepath.strip():
+        return "No filename specified"
+    fp = resolve_path(filepath)
+    write_file(filepath, code)
+    ext = fp.rsplit(".", 1)[-1].lower() if "." in fp else ""
+    runners = {
+        "py": f'python3 "{fp}"',
+        "js": f'node "{fp}"',
+        "sh": f'bash "{fp}"',
+    }
+    if ext in runners:
+        return execute_background(runners[ext], os.path.dirname(fp))
+    return "File type not supported for direct execution"
+
 
 def get_process_list():
-    lines = ["PID | ID | Uptime | Command"]
+    lines = ["BACKGROUND PROCESSES", "═" * 65]
     with proc_lock:
-        for pid, info in bg_processes.items():
-            status = "RUN" if info["proc"].poll() is None else "STOP"
-            lines.append(f"{pid} | {info['id']} | {status} | {info['cmd']}")
-    return "\n".join(lines)
-
-def stop_process(pid_str):
+        if not bg_processes:
+            lines.append("No background processes running")
+        else:
+            running = 0
+            stopped = 0
+            for pid, info in sorted(bg_processes.items()):
+                alive = info["proc"].poll() is None
+                if alive:
+                    running += 1
+                    elapsed = time.time() - info["start_ts"]
+                    hours = int(elapsed // 3600)
+                    mins = int((elapsed % 3600) // 60)
+                    secs = int(elapsed % 60)
+                    uptime_str = f"{hours:02d}:{mins:02d}:{secs:02d}"
+                    mem_str = "N/A"
+                    cpu_str = "N/A"
+                    try:
+                        p = psutil.Process(pid)
+                        mem_mb = p.memory_info().rss / 1048576
+                        mem_str = f"{mem_mb:.1f}MB"
+                        cpu_str = f"{p.cpu_percent():.1f}%"
+                    except:
+                        pass
+                    lines.append(
+                        f"\n  [{info['id']}] PID {pid} - RUNNING\n"
+                        f"  Command  : {info['cmd']}\n"
+                        f"  Dir      : {info['dir']}\n"
+                        f"  Uptime   : {uptime_str}\n"
+                        f"  Memory   : {mem_str}\n"
+                        f"  CPU      : {cpu_str}\n"
+                        f"  Log      : {info['log']}"
+                    )
+                else:
+                    stopped += 1
+                    rc = info["proc"].returncode
+                    lines.append(
+                        f"\n  [{info['id']}] PID {pid} - STOPPED (exit: {rc})\n"
+                        f"  Command  : {info['cmd']}\n"
+                        f"  Started  : {info['start']}\n"
+                        f"  Log      : {info['log']}"
+                    )
+            lines.append(f"\n{'─' * 65}")
+            lines.append(
+                f"  Running: {running}  Stopped: {stopped}  Total: {running + stopped}"
+            )
     try:
-        target_pid = int(pid_str)
-        if target_pid in bg_processes:
-            os.killpg(os.getpgid(target_pid), signal.SIGTERM)
-            return f"Stopped {target_pid}"
+        mem = psutil.virtual_memory()
+        lines.append(f"\n{'═' * 65}")
+        lines.append(
+            f"  System: CPU {psutil.cpu_percent()}% | "
+            f"RAM {mem.percent}% ({fmt_size(mem.used)}/{fmt_size(mem.total)})"
+        )
     except:
         pass
-    return "Failed or not found"
+    return "\n".join(lines)
 
-def read_file(path):
-    p = resolve_path(path)
-    if os.path.exists(p) and os.path.isfile(p):
-        with open(p, 'r', encoding='utf-8', errors='ignore') as f: return f.read()
-    return "File not found"
 
-def write_file(path, content):
-    p = resolve_path(path)
-    with open(p, 'w', encoding='utf-8') as f: f.write(content)
-    return f"Saved to {p}"
+def stop_process(pid_input):
+    if not pid_input or not pid_input.strip():
+        return "No PID specified"
+    pid_str = pid_input.strip()
+    target_pid = None
+    with proc_lock:
+        try:
+            target_pid = int(pid_str)
+        except ValueError:
+            for pid, info in bg_processes.items():
+                if info["id"] == pid_str:
+                    target_pid = pid
+                    break
+            if target_pid is None:
+                return f"Invalid PID or ID: {pid_str}"
+        if target_pid in bg_processes:
+            info = bg_processes[target_pid]
+            try:
+                if info["proc"].poll() is None:
+                    os.killpg(os.getpgid(target_pid), signal.SIGTERM)
+                    try:
+                        info["proc"].wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        os.killpg(os.getpgid(target_pid), signal.SIGKILL)
+                        info["proc"].wait(timeout=3)
+                try:
+                    info["log_f"].close()
+                except:
+                    pass
+                rc = info["proc"].returncode
+                del bg_processes[target_pid]
+                return f"Process {target_pid} stopped (exit code: {rc})"
+            except Exception as e:
+                try:
+                    del bg_processes[target_pid]
+                except:
+                    pass
+                return f"Force killed {target_pid}: {str(e)}"
+    try:
+        os.kill(target_pid, signal.SIGTERM)
+        return f"Sent SIGTERM to {target_pid}"
+    except ProcessLookupError:
+        return f"Process {target_pid} not found"
+    except PermissionError:
+        return f"Permission denied for PID {target_pid}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def stop_all_processes():
+    results = []
+    with proc_lock:
+        pids = list(bg_processes.keys())
+    for pid in pids:
+        result = stop_process(str(pid))
+        results.append(result)
+    if not results:
+        return "No processes to stop"
+    return "\n".join(results)
+
+
+def restart_process(pid_input):
+    if not pid_input or not pid_input.strip():
+        return "No PID specified"
+    target_pid = None
+    cmd = None
+    wd = None
+    with proc_lock:
+        try:
+            target_pid = int(pid_input.strip())
+        except ValueError:
+            for pid, info in bg_processes.items():
+                if info["id"] == pid_input.strip():
+                    target_pid = pid
+                    break
+        if target_pid and target_pid in bg_processes:
+            cmd = bg_processes[target_pid]["cmd"]
+            wd = bg_processes[target_pid]["dir"]
+    if not cmd:
+        return f"Process not found: {pid_input}"
+    stop_process(str(target_pid))
+    time.sleep(1)
+    return execute_background(cmd, wd)
+
+
+def view_log(pid_input):
+    if not pid_input or not pid_input.strip():
+        return "No PID specified"
+    target_pid = None
+    with proc_lock:
+        try:
+            target_pid = int(pid_input.strip())
+        except ValueError:
+            for pid, info in bg_processes.items():
+                if info["id"] == pid_input.strip():
+                    target_pid = pid
+                    break
+        if target_pid and target_pid in bg_processes:
+            log_path = bg_processes[target_pid]["log"]
+            try:
+                with open(log_path, "r") as f:
+                    content = f.read()
+                if not content.strip():
+                    return "Log is empty..."
+                lines = content.split("\n")
+                if len(lines) > 200:
+                    return (
+                        f"... (showing last 200 of {len(lines)} lines)\n\n"
+                        + "\n".join(lines[-200:])
+                    )
+                return content
+            except Exception as e:
+                return f"Error reading log: {str(e)}"
+    return f"Process not found: {pid_input}"
+
 
 def install_package(name):
-    return execute_terminal(f"pip install {name}", WORKSPACE)[0]
+    if not name or not name.strip():
+        return "No package specified"
+    name = name.strip()
+    result, _ = execute_terminal(f"pip install {name}", WORKSPACE)
+    return result
+
+
+def pip_list():
+    result, _ = execute_terminal("pip list --format=columns", WORKSPACE)
+    return result
+
+
+def pip_upgrade():
+    result, _ = execute_terminal("pip install --upgrade pip", WORKSPACE)
+    return result
+
+
+def search_files(pattern, search_path):
+    sp = resolve_path(search_path) if search_path else os.getcwd()
+    if not os.path.isdir(sp):
+        return f"Not a directory: {sp}"
+    result, _ = execute_terminal(
+        f'find "{sp}" -name "{pattern}" -type f 2>/dev/null | head -50', sp
+    )
+    return result if result else "No files found"
+
+
+def search_in_files(text, search_path):
+    sp = resolve_path(search_path) if search_path else os.getcwd()
+    if not os.path.isdir(sp):
+        return f"Not a directory: {sp}"
+    result, _ = execute_terminal(
+        f"grep -rn \"{text}\" \"{sp}\" --include='*.py' --include='*.js' "
+        f"--include='*.txt' --include='*.md' --include='*.json' "
+        f"--include='*.yml' --include='*.yaml' --include='*.html' "
+        f"--include='*.css' --include='*.sh' 2>/dev/null | head -50",
+        sp,
+    )
+    return result if result else "No matches found"
+
+
+def create_backup(name):
+    if not name or not name.strip():
+        name = datetime.now().strftime("backup_%Y%m%d_%H%M%S")
+    name = name.strip().replace(" ", "_")
+    backup_path = os.path.join(BACKUP_DIR, f"{name}.tar.gz")
+    result, _ = execute_terminal(
+        f'tar -czf "{backup_path}" -C "{WORKSPACE}" '
+        f"--exclude='.system_logs' --exclude='.backups' --exclude='.sessions' .",
+        WORKSPACE,
+    )
+    if os.path.exists(backup_path):
+        sz = os.path.getsize(backup_path)
+        return f"Backup created: {backup_path} ({fmt_size(sz)})"
+    return f"Backup failed: {result}"
+
+
+def list_backups():
+    if not os.path.isdir(BACKUP_DIR):
+        return "No backups found"
+    backups = sorted(os.listdir(BACKUP_DIR), reverse=True)
+    if not backups:
+        return "No backups found"
+    lines = ["BACKUPS", "═" * 50]
+    for b in backups:
+        fp = os.path.join(BACKUP_DIR, b)
+        sz = os.path.getsize(fp)
+        mtime = datetime.fromtimestamp(os.path.getmtime(fp)).strftime(
+            "%Y-%m-%d %H:%M"
+        )
+        lines.append(f"  {b:<35} {fmt_size(sz):>8}  {mtime}")
+    return "\n".join(lines)
+
+
+def get_resource_chart():
+    if not resource_history:
+        return "No resource data yet. Wait for monitoring..."
+    lines = ["RESOURCE MONITOR", "═" * 60, "", "CPU Usage:"]
+    for entry in list(resource_history)[-20:]:
+        bar_len = int(entry["cpu"] / 2)
+        bar = "█" * bar_len + "░" * (50 - bar_len)
+        lines.append(f"  {entry['time']} [{bar}] {entry['cpu']:.1f}%")
+    lines.append("")
+    lines.append("RAM Usage:")
+    for entry in list(resource_history)[-20:]:
+        bar_len = int(entry["ram_percent"] / 2)
+        bar = "█" * bar_len + "░" * (50 - bar_len)
+        lines.append(f"  {entry['time']} [{bar}] {entry['ram_percent']:.1f}%")
+    return "\n".join(lines)
+
+
+TEMPLATES = {
+    "telegram_bot": {
+        "name": "telegram_bot.py",
+        "code": '''import asyncio
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
+
+TOKEN = "YOUR_TOKEN"
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await update.message.reply_text("Bot is running!")
+
+async def handle(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    text = update.message.text
+    await update.message.reply_text(f"You said: {text}")
+
+def main():
+    app = Application.builder().token(TOKEN).build()
+    app.add_handler(CommandHandler("start", start))
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle))
+    print("Bot started...")
+    app.run_polling(drop_pending_updates=True)
+
+if __name__ == "__main__":
+    main()
+''',
+    },
+    "flask_app": {
+        "name": "server.py",
+        "code": '''from flask import Flask, jsonify, request
+
+app = Flask(__name__)
+
+@app.route("/")
+def index():
+    return jsonify({"status": "running", "message": "Hello World"})
+
+@app.route("/api/data", methods=["GET", "POST"])
+def data():
+    if request.method == "POST":
+        payload = request.get_json()
+        return jsonify({"received": payload})
+    return jsonify({"data": []})
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7861, debug=False)
+''',
+    },
+    "discord_bot": {
+        "name": "discord_bot.py",
+        "code": '''import discord
+from discord.ext import commands
+
+TOKEN = "YOUR_TOKEN"
+bot = commands.Bot(command_prefix="!", intents=discord.Intents.all())
+
+@bot.event
+async def on_ready():
+    print(f"Bot ready: {bot.user}")
+
+@bot.command()
+async def ping(ctx):
+    await ctx.send(f"Pong! {round(bot.latency * 1000)}ms")
+
+bot.run(TOKEN)
+''',
+    },
+    "fastapi_app": {
+        "name": "api_server.py",
+        "code": '''from fastapi import FastAPI
+import uvicorn
+
+app = FastAPI()
+
+@app.get("/")
+async def root():
+    return {"status": "running"}
+
+@app.get("/api/{item_id}")
+async def get_item(item_id: int, q: str = None):
+    return {"item_id": item_id, "query": q}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7861)
+''',
+    },
+    "scraper": {
+        "name": "scraper.py",
+        "code": '''import requests
+from bs4 import BeautifulSoup
+import json
+
+def scrape(url):
+    headers = {"User-Agent": "Mozilla/5.0"}
+    resp = requests.get(url, headers=headers, timeout=15)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, "html.parser")
+    title = soup.title.string if soup.title else "N/A"
+    links = [a.get("href") for a in soup.find_all("a", href=True)]
+    return {"url": url, "title": title, "links_count": len(links), "links": links[:20]}
+
+if __name__ == "__main__":
+    result = scrape("https://example.com")
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+''',
+    },
+    "scheduler": {
+        "name": "scheduler.py",
+        "code": '''import time
+import datetime
+
+class Scheduler:
+    def __init__(self):
+        self.tasks = []
+        self.running = True
 
-# --- UI Layout ---
+    def every(self, seconds, func, *args):
+        self.tasks.append({"interval": seconds, "func": func, "args": args, "last": 0})
+
+    def start(self):
+        print(f"Scheduler started with {len(self.tasks)} tasks")
+        while self.running:
+            now = time.time()
+            for task in self.tasks:
+                if now - task["last"] >= task["interval"]:
+                    try:
+                        task["func"](*task["args"])
+                    except Exception as e:
+                        print(f"Task error: {e}")
+                    task["last"] = now
+            time.sleep(1)
+
+def heartbeat():
+    print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Heartbeat")
+
+if __name__ == "__main__":
+    s = Scheduler()
+    s.every(10, heartbeat)
+    s.start()
+''',
+    },
+    "keep_alive": {
+        "name": "keep_alive.py",
+        "code": '''import time
+import urllib.request
+import datetime
+
+SPACE_URL = "https://YOUR-SPACE-URL.hf.space"
+INTERVAL = 280
+
+def ping():
+    while True:
+        try:
+            urllib.request.urlopen(SPACE_URL, timeout=15)
+            print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] OK")
+        except Exception as e:
+            print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] FAIL: {e}")
+        time.sleep(INTERVAL)
+
+if __name__ == "__main__":
+    print(f"Keep-alive started for {SPACE_URL}")
+    ping()
+''',
+    },
+}
+
+
+# ============================================================
+# CSS
+# ============================================================
 CSS = """
-.term textarea { font-family: monospace; background: #1e1e1e; color: #00ff00; }
+.term textarea {
+    font-family: 'Courier New', monospace !important;
+    font-size: 13px !important;
+    background: #0a0e14 !important;
+    color: #b3b1ad !important;
+    border: 1px solid #1c2433 !important;
+    border-radius: 6px !important;
+    padding: 12px !important;
+}
+footer { display: none !important; }
 """
 
-with gr.Blocks(css=CSS, title="Cloud VPS", theme=gr.themes.Soft()) as app:
-    gr.Markdown("## ☁️ Python Cloud VPS")
-    
+# ============================================================
+# ✅ المتغير اسمه demo وليس app
+# ============================================================
+demo = gr.Blocks(css=CSS, title="Cloud VPS", theme=gr.themes.Default(
+    primary_hue="blue", neutral_hue="gray"
+))
+
+with demo:
+    gr.Markdown("# ☁️ Cloud VPS Terminal")
+
     with gr.Tabs():
-        with gr.Tab("Terminal"):
+
+        # ===== Terminal Tab =====
+        with gr.TabItem("🖥️ Terminal"):
+            with gr.Row():
+                t_cmd = gr.Textbox(
+                    label="Command", lines=1, scale=4,
+                    placeholder="Enter any Linux command..."
+                )
+                t_dir = gr.Textbox(
+                    label="Working Directory", value=WORKSPACE,
+                    lines=1, scale=2
+                )
             with gr.Row():
-                t_cmd = gr.Textbox(label="Command", placeholder="ls -la", scale=3)
-                t_dir = gr.Textbox(label="Dir", value=WORKSPACE, scale=1)
-                t_run = gr.Button("Run", variant="primary")
-            t_out = gr.Textbox(label="Output", lines=20, elem_classes="term")
+                t_run = gr.Button("▶ Run", variant="primary", size="lg")
+                t_bg = gr.Button("⚡ Background", variant="secondary", size="lg")
+                t_info = gr.Button("ℹ️ System Info", size="lg")
+                t_clear = gr.Button("🗑️ Clear", size="lg")
+
+            t_out = gr.Textbox(
+                label="Output", lines=24, interactive=False,
+                elem_classes=["term"]
+            )
+
+            with gr.Accordion("Quick Commands", open=False):
+                with gr.Row():
+                    qc1 = gr.Button("ls -la", size="sm")
+                    qc2 = gr.Button("pwd", size="sm")
+                    qc3 = gr.Button("whoami", size="sm")
+                    qc4 = gr.Button("df -h", size="sm")
+                    qc5 = gr.Button("free -h", size="sm")
+                    qc6 = gr.Button("top snapshot", size="sm")
+                with gr.Row():
+                    qc7 = gr.Button("pip list", size="sm")
+                    qc8 = gr.Button("python3 --version", size="sm")
+                    qc9 = gr.Button("node --version", size="sm")
+                    qc10 = gr.Button("git --version", size="sm")
+                    qc11 = gr.Button("env", size="sm")
+                    qc12 = gr.Button("netstat", size="sm")
+
             t_run.click(execute_terminal, [t_cmd, t_dir], [t_out, t_dir])
             t_cmd.submit(execute_terminal, [t_cmd, t_dir], [t_out, t_dir])
+            t_bg.click(execute_background, [t_cmd, t_dir], [t_out])
+            t_info.click(get_system_info, None, [t_out])
+            t_clear.click(lambda: ("", WORKSPACE), None, [t_out, t_dir])
 
-        with gr.Tab("Editor"):
+            qc1.click(lambda d: execute_terminal("ls -la", d), [t_dir], [t_out, t_dir])
+            qc2.click(lambda d: execute_terminal("pwd", d), [t_dir], [t_out, t_dir])
+            qc3.click(lambda d: execute_terminal("whoami", d), [t_dir], [t_out, t_dir])
+            qc4.click(lambda d: execute_terminal("df -h", d), [t_dir], [t_out, t_dir])
+            qc5.click(lambda d: execute_terminal("free -h", d), [t_dir], [t_out, t_dir])
+            qc6.click(
+                lambda d: execute_terminal("ps aux --sort=-%mem | head -20", d),
+                [t_dir], [t_out, t_dir],
+            )
+            qc7.click(
+                lambda d: execute_terminal("pip list --format=columns", d),
+                [t_dir], [t_out, t_dir],
+            )
+            qc8.click(
+                lambda d: execute_terminal("python3 --version", d),
+                [t_dir], [t_out, t_dir],
+            )
+            qc9.click(
+                lambda d: execute_terminal(
+                    "node --version 2>/dev/null || echo 'Not installed'", d
+                ),
+                [t_dir], [t_out, t_dir],
+            )
+            qc10.click(
+                lambda d: execute_terminal("git --version", d),
+                [t_dir], [t_out, t_dir],
+            )
+            qc11.click(
+                lambda d: execute_terminal("env | sort", d),
+                [t_dir], [t_out, t_dir],
+            )
+            qc12.click(
+                lambda d: execute_terminal(
+                    "ss -tlnp 2>/dev/null || echo 'Not available'", d
+                ),
+                [t_dir], [t_out, t_dir],
+            )
+
+        # ===== Files Tab =====
+        with gr.TabItem("📁 Files"):
             with gr.Row():
-                e_path = gr.Textbox(label="File Path", value="bot.py")
-                e_load = gr.Button("Load")
-                e_save = gr.Button("Save")
-            e_code = gr.Code(label="Code", language="python", lines=20)
-            e_status = gr.Textbox(label="Status")
-            e_load.click(read_file, [e_path], [e_code])
-            e_save.click(write_file, [e_path, e_code], [e_status])
-
-        with gr.Tab("Processes & Background"):
+                with gr.Column(scale=1):
+                    f_path = gr.Textbox(label="Path", value=WORKSPACE, lines=1)
+                    with gr.Row():
+                        f_browse = gr.Button("Browse", variant="primary", size="sm")
+                        f_up = gr.Button("Up ..", size="sm")
+                        f_home = gr.Button("Home", size="sm")
+                    f_list = gr.Textbox(
+                        label="Directory Contents", lines=22,
+                        interactive=False, elem_classes=["term"]
+                    )
+
+                with gr.Column(scale=1):
+                    with gr.Tabs():
+                        with gr.TabItem("View"):
+                            fv_path = gr.Textbox(label="File Path", lines=1)
+                            fv_btn = gr.Button("Open", variant="primary", size="sm")
+                            fv_content = gr.Textbox(
+                                label="Content", lines=16,
+                                interactive=False, elem_classes=["term"]
+                            )
+
+                        with gr.TabItem("Create/Edit"):
+                            fe_path = gr.Textbox(label="File Path", lines=1)
+                            fe_content = gr.Textbox(label="Content", lines=12)
+                            fe_btn = gr.Button("Save", variant="primary", size="sm")
+                            fe_status = gr.Textbox(label="Status", lines=1, interactive=False)
+
+                        with gr.TabItem("Operations"):
+                            fo_mkdir = gr.Textbox(label="New Directory", lines=1)
+                            fo_mkdir_btn = gr.Button("Create Directory", size="sm")
+                            fo_del = gr.Textbox(label="Delete Path", lines=1)
+                            fo_del_btn = gr.Button("Delete", variant="stop", size="sm")
+                            fo_ren_old = gr.Textbox(label="Rename From", lines=1)
+                            fo_ren_new = gr.Textbox(label="Rename To", lines=1)
+                            fo_ren_btn = gr.Button("Rename/Move", size="sm")
+                            fo_cp_src = gr.Textbox(label="Copy From", lines=1)
+                            fo_cp_dst = gr.Textbox(label="Copy To", lines=1)
+                            fo_cp_btn = gr.Button("Copy", size="sm")
+                            fo_chmod_path = gr.Textbox(label="File Path", lines=1)
+                            fo_chmod_mode = gr.Textbox(label="Mode (e.g. 755)", lines=1)
+                            fo_chmod_btn = gr.Button("Change Permissions", size="sm")
+                            fo_status = gr.Textbox(label="Status", lines=2, interactive=False)
+
+                        with gr.TabItem("Upload"):
+                            fu_file = gr.File(label="Select File")
+                            fu_btn = gr.Button("Upload", variant="primary", size="sm")
+                            fu_status = gr.Textbox(label="Status", lines=1, interactive=False)
+
+                        with gr.TabItem("Search"):
+                            fs_name = gr.Textbox(label="Filename Pattern", lines=1, placeholder="*.py")
+                            fs_text = gr.Textbox(label="Search in Content", lines=1)
+                            fs_path = gr.Textbox(label="Search Directory", lines=1, value=WORKSPACE)
+                            with gr.Row():
+                                fs_name_btn = gr.Button("Search by Name", size="sm")
+                                fs_text_btn = gr.Button("Search in Files", size="sm")
+                            fs_result = gr.Textbox(
+                                label="Results", lines=10,
+                                interactive=False, elem_classes=["term"]
+                            )
+
+            f_browse.click(browse_directory, [f_path], [f_list])
+            f_path.submit(browse_directory, [f_path], [f_list])
+            f_up.click(
+                lambda p: (
+                    os.path.dirname(resolve_path(p)),
+                    browse_directory(os.path.dirname(resolve_path(p))),
+                ),
+                [f_path], [f_path, f_list],
+            )
+            f_home.click(
+                lambda: (WORKSPACE, browse_directory(WORKSPACE)),
+                None, [f_path, f_list],
+            )
+            fv_btn.click(read_file, [fv_path], [fv_content])
+            fe_btn.click(write_file, [fe_path, fe_content], [fe_status])
+            fo_mkdir_btn.click(create_dir, [fo_mkdir], [fo_status])
+            fo_del_btn.click(delete_path, [fo_del], [fo_status])
+            fo_ren_btn.click(rename_item, [fo_ren_old, fo_ren_new], [fo_status])
+            fo_cp_btn.click(copy_item, [fo_cp_src, fo_cp_dst], [fo_status])
+            fo_chmod_btn.click(chmod_item, [fo_chmod_path, fo_chmod_mode], [fo_status])
+            fu_btn.click(upload_handler, [fu_file], [fu_status])
+            fs_name_btn.click(search_files, [fs_name, fs_path], [fs_result])
+            fs_text_btn.click(search_in_files, [fs_text, fs_path], [fs_result])
+
+        # ===== Editor Tab =====
+        with gr.TabItem("📝 Editor"):
+            with gr.Row():
+                e_path = gr.Textbox(label="Filename", value="script.py", lines=1, scale=3)
+                e_lang = gr.Dropdown(
+                    label="Language",
+                    choices=["python", "javascript", "shell", "json", "yaml", "html", "css"],
+                    value="python",
+                    scale=1,
+                )
+            with gr.Row():
+                e_load = gr.Button("📂 Load", size="sm")
+                e_save = gr.Button("💾 Save", variant="primary", size="sm")
+                e_run = gr.Button("▶ Save & Run", variant="primary", size="sm")
+                e_run_bg = gr.Button("⚡ Run Background", variant="secondary", size="sm")
+
+            e_code = gr.Code(label="Code", language="python", lines=24, value="")
+            e_out = gr.Textbox(
+                label="Output", lines=10, interactive=False,
+                elem_classes=["term"]
+            )
+
+            with gr.Accordion("Templates", open=False):
+                with gr.Row():
+                    et1 = gr.Button("Telegram Bot", size="sm")
+                    et2 = gr.Button("Flask App", size="sm")
+                    et3 = gr.Button("Discord Bot", size="sm")
+                    et4 = gr.Button("FastAPI", size="sm")
+                with gr.Row():
+                    et5 = gr.Button("Web Scraper", size="sm")
+                    et6 = gr.Button("Scheduler", size="sm")
+                    et7 = gr.Button("Keep Alive", size="sm")
+
+            e_load.click(load_file_to_editor, [e_path], [e_code, e_out])
+            e_save.click(editor_save, [e_path, e_code], [e_out])
+            e_run.click(editor_save_run, [e_path, e_code], [e_out])
+            e_run_bg.click(editor_run_bg, [e_path, e_code], [e_out])
+
+            def apply_template(key):
+                t = TEMPLATES[key]
+                return t["code"], t["name"]
+
+            et1.click(lambda: apply_template("telegram_bot"), None, [e_code, e_path])
+            et2.click(lambda: apply_template("flask_app"), None, [e_code, e_path])
+            et3.click(lambda: apply_template("discord_bot"), None, [e_code, e_path])
+            et4.click(lambda: apply_template("fastapi_app"), None, [e_code, e_path])
+            et5.click(lambda: apply_template("scraper"), None, [e_code, e_path])
+            et6.click(lambda: apply_template("scheduler"), None, [e_code, e_path])
+            et7.click(lambda: apply_template("keep_alive"), None, [e_code, e_path])
+
+        # ===== Processes Tab =====
+        with gr.TabItem("⚙️ Processes"):
             with gr.Row():
-                b_cmd = gr.Textbox(label="Background Command", placeholder="python3 bot.py")
-                b_run = gr.Button("Start Background Process")
-            b_out = gr.Textbox(label="Start Status")
-            
-            gr.Markdown("### Active Processes")
-            p_refresh = gr.Button("Refresh List")
-            p_list = gr.Textbox(label="List", lines=10)
-            
+                p_refresh = gr.Button("🔄 Refresh", variant="primary", size="lg")
+                p_stop_all = gr.Button("⛔ Stop All", variant="stop", size="lg")
+
+            p_list = gr.Textbox(
+                label="Processes", lines=18, interactive=False,
+                elem_classes=["term"]
+            )
+
             with gr.Row():
-                p_pid = gr.Textbox(label="PID to Stop")
-                p_stop = gr.Button("Stop Process", variant="stop")
-            p_res = gr.Textbox(label="Stop Result")
+                p_pid = gr.Textbox(label="PID or Process ID", lines=1, scale=2)
+                p_stop = gr.Button("Stop", variant="stop", scale=1)
+                p_restart = gr.Button("Restart", scale=1)
+                p_log = gr.Button("View Log", scale=1)
+
+            p_result = gr.Textbox(
+                label="Result", lines=12, interactive=False,
+                elem_classes=["term"]
+            )
+
+            with gr.Accordion("Resource Monitor", open=False):
+                p_monitor_btn = gr.Button("Show Resources", size="sm")
+                p_monitor = gr.Textbox(
+                    label="Resources", lines=15, interactive=False,
+                    elem_classes=["term"]
+                )
+                p_monitor_btn.click(get_resource_chart, None, [p_monitor])
 
-            b_run.click(execute_background, [b_cmd, t_dir], [b_out])
             p_refresh.click(get_process_list, None, [p_list])
-            p_stop.click(stop_process, [p_pid], [p_res])
+            p_stop_all.click(stop_all_processes, None, [p_result])
+            p_stop.click(stop_process, [p_pid], [p_result])
+            p_restart.click(restart_process, [p_pid], [p_result])
+            p_log.click(view_log, [p_pid], [p_result])
 
-        with gr.Tab("Package Installer"):
-            pk_name = gr.Textbox(label="Package Name (e.g. py-telegram-bot-api)")
-            pk_btn = gr.Button("Install")
-            pk_log = gr.Textbox(label="Installation Log", lines=10)
-            pk_btn.click(install_package, [pk_name], [pk_log])
+        # ===== Packages Tab =====
+        with gr.TabItem("📦 Packages"):
+            with gr.Row():
+                pk_name = gr.Textbox(
+                    label="Package Name", lines=1, scale=3,
+                    placeholder="package_name"
+                )
+                pk_btn = gr.Button("Install", variant="primary", scale=1, size="lg")
 
-if __name__ == "__main__":
-    # هذا هو الإعداد الصحيح للإطلاق في Hugging Face
-    app.queue(default_concurrency_limit=5)
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
+            pk_out = gr.Textbox(
+                label="Output", lines=15, interactive=False,
+                elem_classes=["term"]
+            )
+
+            with gr.Accordion("Quick Install", open=True):
+                with gr.Row():
+                    pi1 = gr.Button("python-telegram-bot", size="sm")
+                    pi2 = gr.Button("flask", size="sm")
+                    pi3 = gr.Button("requests", size="sm")
+                    pi4 = gr.Button("discord.py", size="sm")
+                    pi5 = gr.Button("aiohttp", size="sm")
+                with gr.Row():
+                    pi6 = gr.Button("beautifulsoup4", size="sm")
+                    pi7 = gr.Button("sqlalchemy", size="sm")
+                    pi8 = gr.Button("pandas", size="sm")
+                    pi9 = gr.Button("fastapi uvicorn", size="sm")
+                    pi10 = gr.Button("celery redis", size="sm")
+                with gr.Row():
+                    pi11 = gr.Button("pillow", size="sm")
+                    pi12 = gr.Button("numpy", size="sm")
+                    pi13 = gr.Button("httpx", size="sm")
+                    pi14 = gr.Button("pyyaml", size="sm")
+                    pi15 = gr.Button("python-dotenv", size="sm")
+
+            with gr.Row():
+                pk_list_btn = gr.Button("List Installed")
+                pk_upgrade_btn = gr.Button("Upgrade pip")
+
+            pk_btn.click(install_package, [pk_name], [pk_out])
+            pk_name.submit(install_package, [pk_name], [pk_out])
+            pk_list_btn.click(pip_list, None, [pk_out])
+            pk_upgrade_btn.click(pip_upgrade, None, [pk_out])
+
+            pi1.click(lambda: install_package("python-telegram-bot"), None, [pk_out])
+            pi2.click(lambda: install_package("flask"), None, [pk_out])
+            pi3.click(lambda: install_package("requests"), None, [pk_out])
+            pi4.click(lambda: install_package("discord.py"), None, [pk_out])
+            pi5.click(lambda: install_package("aiohttp"), None, [pk_out])
+            pi6.click(lambda: install_package("beautifulsoup4 lxml"), None, [pk_out])
+            pi7.click(lambda: install_package("sqlalchemy"), None, [pk_out])
+            pi8.click(lambda: install_package("pandas"), None, [pk_out])
+            pi9.click(lambda: install_package("fastapi uvicorn"), None, [pk_out])
+            pi10.click(lambda: install_package("celery redis"), None, [pk_out])
+            pi11.click(lambda: install_package("Pillow"), None, [pk_out])
+            pi12.click(lambda: install_package("numpy"), None, [pk_out])
+            pi13.click(lambda: install_package("httpx"), None, [pk_out])
+            pi14.click(lambda: install_package("pyyaml"), None, [pk_out])
+            pi15.click(lambda: install_package("python-dotenv"), None, [pk_out])
+
+        # ===== Backup Tab =====
+        with gr.TabItem("💾 Backup"):
+            with gr.Row():
+                bk_name = gr.Textbox(label="Backup Name (optional)", lines=1, scale=3)
+                bk_create = gr.Button("Create Backup", variant="primary", scale=1)
+
+            bk_out = gr.Textbox(label="Output", lines=5, interactive=False)
+
+            bk_list_btn = gr.Button("List Backups")
+            bk_list = gr.Textbox(
+                label="Backups", lines=10, interactive=False,
+                elem_classes=["term"]
+            )
+
+            bk_create.click(create_backup, [bk_name], [bk_out])
+            bk_list_btn.click(list_backups, None, [bk_list])
+
+
+# ============================================================
+# ✅ التشغيل الصحيح
+# ============================================================
+demo.queue()
+demo.launch(
+    server_name="0.0.0.0",
+    server_port=7860,
+    show_error=True,
+    share=False
+)