Update app.py

app.py

@@ -1,45 +1,366 @@
-from fastapi import FastAPI, Request, UploadFile, File, HTTPException
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from pc_agent import run_command, list_files, cleanup, ensure_workspace
-import aiofiles
+"""
+╔══════════════════════════════════════════════════════════════╗
+║       THE Z AI/AGENT — LINUX SYSTEM SERVER                   ║
+║   🖥️  سيرفر نظام Linux — يتحكم فيه الذكاء الاصطناعي         ║
+╚══════════════════════════════════════════════════════════════╝
+
+هذا الملف خاص بـ: سيرفر 2 (سيرفر نظام Linux)
+This file belongs to: SERVER 2 (Linux System Server)
+
+✅ تنفيذ أوامر Terminal
+✅ تصفح الإنترنت (browser automation)
+✅ كتابة وتشغيل Python/JS
+✅ إدارة الملفات والمجلدات
+✅ حماية بـ API Token
+"""
+
 import os
+import json
+import subprocess
+import shutil
+import tempfile
+import signal
+import platform
+import psutil
+import time
+from pathlib import Path
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+
+app = Flask(__name__)
+CORS(app)
+
+# ══════════════════════════════════════════
+#  Security — API Token
+# ══════════════════════════════════════════
+API_TOKEN = os.environ.get("LINUX_API_TOKEN", "zyz-linux-secret-2025")
+WORKSPACE  = "/workspace"
+os.makedirs(WORKSPACE, exist_ok=True)
+
+
+def check_token():
+    token = request.headers.get("X-API-Token", "")
+    if token != API_TOKEN:
+        return False
+    return True
+
+
+def require_token(fn):
+    from functools import wraps
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        if not check_token():
+            return jsonify({"error": "Unauthorized — invalid or missing API token"}), 401
+        return fn(*args, **kwargs)
+    return wrapper
+
+
+# ══════════════════════════════════════════
+#  /api/status — حالة السيرفر
+# ══════════════════════════════════════════
+@app.route("/api/status", methods=["GET"])
+@require_token
+def status():
+    return jsonify({
+        "status":    "online",
+        "server":    "Linux System Server — THE Z AI",
+        "platform":  platform.system() + " " + platform.release(),
+        "python":    platform.python_version(),
+        "workspace": WORKSPACE,
+        "uptime":    int(time.time())
+    })
+
+
+# ══════════════════════════════════════════
+#  /api/execute — تنفيذ أمر Terminal
+# ══════════════════════════════════════════
+@app.route("/api/execute", methods=["POST"])
+@require_token
+def execute():
+    data    = request.json or {}
+    command = data.get("command", "").strip()
+    cwd     = data.get("cwd", WORKSPACE)
+    timeout = int(data.get("timeout", 60))
+
+    if not command:
+        return jsonify({"error": "No command provided"}), 400
+
+    # تأكد من مجلد العمل موجود
+    if not os.path.isdir(cwd):
+        cwd = WORKSPACE
+
+    try:
+        proc = subprocess.run(
+            command,
+            shell=True,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env={**os.environ, "HOME": "/root", "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/nodejs/bin"}
+        )
+        return jsonify({
+            "stdout":     proc.stdout,
+            "stderr":     proc.stderr,
+            "returncode": proc.returncode,
+            "command":    command,
+            "cwd":        cwd
+        })
+    except subprocess.TimeoutExpired:
+        return jsonify({
+            "stdout":     "",
+            "stderr":     f"⏰ Command timed out after {timeout}s",
+            "returncode": -1,
+            "command":    command,
+            "cwd":        cwd
+        })
+    except Exception as e:
+        return jsonify({
+            "stdout":     "",
+            "stderr":     str(e),
+            "returncode": -1,
+            "command":    command,
+            "cwd":        cwd
+        })
+
+
+# ══════════════════════════════════════════
+#  /api/sysinfo — معلومات النظام الكاملة
+# ═���════════════════════════════════════════
+@app.route("/api/sysinfo", methods=["GET"])
+@require_token
+def sysinfo():
+    try:
+        cpu_percent = psutil.cpu_percent(interval=1)
+        mem         = psutil.virtual_memory()
+        disk        = psutil.disk_usage("/")
+        boot_time   = psutil.boot_time()
+        uptime_sec  = int(time.time() - boot_time)
+        h           = uptime_sec // 3600
+        m           = (uptime_sec % 3600) // 60
+        s           = uptime_sec % 60
+
+        return jsonify({
+            "platform":      platform.system(),
+            "platform_ver":  platform.release(),
+            "python_ver":    platform.python_version(),
+            "cpu_count":     psutil.cpu_count(),
+            "cpu_percent":   cpu_percent,
+            "ram_total_gb":  round(mem.total / (1024**3), 2),
+            "ram_used_gb":   round(mem.used  / (1024**3), 2),
+            "ram_percent":   mem.percent,
+            "disk_total_gb": round(disk.total / (1024**3), 2),
+            "disk_used_gb":  round(disk.used  / (1024**3), 2),
+            "disk_percent":  disk.percent,
+            "uptime":        f"{h}h {m}m {s}s",
+            "workspace":     WORKSPACE
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ══════════════════════════════════════════
+#  /api/files/list — قائمة الملفات
+# ══════════════════════════════════════════
+@app.route("/api/files/list", methods=["GET"])
+@require_token
+def files_list():
+    path = request.args.get("path", WORKSPACE)
+    if not os.path.isdir(path):
+        return jsonify({"error": "Directory not found"}), 404
+    try:
+        items = []
+        for name in sorted(os.listdir(path)):
+            full = os.path.join(path, name)
+            items.append({
+                "name":   name,
+                "type":   "dir" if os.path.isdir(full) else "file",
+                "size":   os.path.getsize(full) if os.path.isfile(full) else 0,
+                "path":   full
+            })
+        return jsonify({"path": path, "items": items})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ══════════════════════════════════════════
+#  /api/files/read — قراءة محتوى ملف
+# ══════════════════════════════════════════
+@app.route("/api/files/read", methods=["GET"])
+@require_token
+def files_read():
+    path = request.args.get("path", "")
+    if not path or not os.path.isfile(path):
+        return jsonify({"error": "File not found"}), 404
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        return jsonify({"path": path, "content": content, "size": len(content)})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ══════════════════════════════════════════
+#  /api/files/write — كتابة ملف
+# ══════════════════════════════════════════
+@app.route("/api/files/write", methods=["POST"])
+@require_token
+def files_write():
+    data    = request.json or {}
+    path    = data.get("path", "")
+    content = data.get("content", "")
+    if not path:
+        return jsonify({"error": "path required"}), 400
+    try:
+        os.makedirs(os.path.dirname(path) or WORKSPACE, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return jsonify({"success": True, "path": path, "size": len(content)})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ══════════════════════════════════════════
+#  /api/files/delete — حذف ملف أو مجلد
+# ══════════════════════════════════════════
+@app.route("/api/files/delete", methods=["POST"])
+@require_token
+def files_delete():
+    data = request.json or {}
+    path = data.get("path", "")
+    if not path or not os.path.exists(path):
+        return jsonify({"error": "Path not found"}), 404
+    try:
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+        return jsonify({"success": True, "path": path})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ══════════════════════════════════════════
+#  /api/files/download — تنزيل ملف
+# ══════════════════════════════════════════
+@app.route("/api/files/download", methods=["GET"])
+@require_token
+def files_download():
+    path = request.args.get("path", "")
+    if not path or not os.path.isfile(path):
+        return jsonify({"error": "File not found"}), 404
+    directory = os.path.dirname(path)
+    filename  = os.path.basename(path)
+    return send_from_directory(directory, filename, as_attachment=True)
+
+
+# ══════════════════════════════════════════
+#  /api/files/upload — رفع ملف
+# ══════════════════════════════════════════
+@app.route("/api/files/upload", methods=["POST"])
+@require_token
+def files_upload():
+    if "file" not in request.files:
+        return jsonify({"error": "No file"}), 400
+    f    = request.files["file"]
+    dest = request.form.get("dest", WORKSPACE)
+    os.makedirs(dest, exist_ok=True)
+    save_path = os.path.join(dest, os.path.basename(f.filename))
+    f.save(save_path)
+    return jsonify({"success": True, "path": save_path, "size": os.path.getsize(save_path)})
+
+
+# ══════════════════════════════════════════
+#  /api/run/python — تشغيل Python مباشرة
+# ══════════════════════════════════════════
+@app.route("/api/run/python", methods=["POST"])
+@require_token
+def run_python():
+    data    = request.json or {}
+    code    = data.get("code", "")
+    timeout = int(data.get("timeout", 30))
+    if not code:
+        return jsonify({"error": "No code provided"}), 400
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", dir=WORKSPACE, delete=False, encoding="utf-8") as tmp:
+        tmp.write(code)
+        tmp_path = tmp.name
+
+    try:
+        proc = subprocess.run(
+            ["python3", tmp_path],
+            capture_output=True, text=True,
+            timeout=timeout, cwd=WORKSPACE
+        )
+        return jsonify({
+            "stdout":     proc.stdout,
+            "stderr":     proc.stderr,
+            "returncode": proc.returncode
+        })
+    except subprocess.TimeoutExpired:
+        return jsonify({"stdout": "", "stderr": f"Timeout after {timeout}s", "returncode": -1})
+    except Exception as e:
+        return jsonify({"stdout": "", "stderr": str(e), "returncode": -1})
+    finally:
+        try:
+            os.remove(tmp_path)
+        except Exception:
+            pass
+
+
+# ══════════════════════════════════════════
+#  /api/run/javascript — تشغيل JavaScript
+# ══════════════════════════════════════════
+@app.route("/api/run/javascript", methods=["POST"])
+@require_token
+def run_javascript():
+    data    = request.json or {}
+    code    = data.get("code", "")
+    timeout = int(data.get("timeout", 30))
+    if not code:
+        return jsonify({"error": "No code provided"}), 400
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".js", dir=WORKSPACE, delete=False, encoding="utf-8") as tmp:
+        tmp.write(code)
+        tmp_path = tmp.name
+
+    try:
+        proc = subprocess.run(
+            ["node", tmp_path],
+            capture_output=True, text=True,
+            timeout=timeout, cwd=WORKSPACE
+        )
+        return jsonify({
+            "stdout":     proc.stdout,
+            "stderr":     proc.stderr,
+            "returncode": proc.returncode
+        })
+    except subprocess.TimeoutExpired:
+        return jsonify({"stdout": "", "stderr": f"Timeout after {timeout}s", "returncode": -1})
+    except Exception as e:
+        return jsonify({"stdout": "", "stderr": str(e), "returncode": -1})
+    finally:
+        try:
+            os.remove(tmp_path)
+        except Exception:
+            pass
+
+
+# ══════════════════════════════════════════
+#  Root — ping check
+# ══════════════════════════════════════════
+@app.route("/")
+def root():
+    return jsonify({
+        "server": "THE Z AI — Linux System Server",
+        "status": "online",
+        "docs":   "/api/status"
+    })
+
 
-app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-
-class CommandRequest(BaseModel):
-    cmd: str
-
-@app.post("/agent/run")
-async def execute_command(req: CommandRequest):
-    res = run_command(req.cmd)
-    status = res.pop("code", 200)
-    return JSONResponse(status_code=status, content=res)
-
-@app.get("/agent/files")
-async def get_files():
-    return {"files": list_files()}
-
-@app.post("/agent/cleanup")
-async def reset_workspace():
-    cleanup()
-    return {"status": "workspace cleared"}
-
-@app.post("/agent/upload")
-async def upload_file(file: UploadFile = File(...)):
-    ws = ensure_workspace()
-    dest = ws / "uploads" / file.filename
-    # منع تجاوز المسار
-    if not str(dest.resolve()).startswith(str(ws.resolve())):
-        raise HTTPException(400, "Invalid file path")
-    
-    async with aiofiles.open(dest, "wb") as out_file:
-        content = await file.read()
-        await out_file.write(content)
-    return {"status": "uploaded", "path": f"uploads/{file.filename}"}
-
-@app.get("/health")
-def health():
-    return {"status": "pc_agent_online"}
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    print(f"🖥️  Linux System Server starting on port {port}")
+    print(f"📁  Workspace: {WORKSPACE}")
+    print(f"🔑  Token: {'SET' if API_TOKEN else 'NOT SET'}")
+    app.run(host="0.0.0.0", port=port, debug=False, threaded=True)