Update app.py

app.py

@@ -21,6 +21,28 @@ warnings.filterwarnings("ignore")
 BASE = "https://www.croxyproxy.com"
 app = Flask(__name__)
 
+# ── Headers à garder dans la réponse (tout le reste = poubelle) ──
+KEEP_HEADERS = {
+    "content-type", "content-length", "content-encoding",
+    "server", "date", "connection",
+    "access-control-allow-origin",
+    "access-control-allow-credentials",
+    "cache-control", "etag", "last-modified",
+    "x-ratelimit-limit", "x-ratelimit-remaining",
+    "x-request-id", "location", "retry-after",
+}
+
+# ── Headers toujours exclus (bruit du proxy) ──
+DROP_HEADERS = {
+    "set-cookie", "__cph", "__cpc",
+    "content-security-policy", "strict-transport-security",
+    "referrer-policy", "access-control-allow-headers",
+    "x-frame-options", "x-content-type-options",
+    "permissions-policy", "cross-origin-opener-policy",
+    "cross-origin-embedder-policy",
+}
+
+
 class S:
     servers = []
     idx = 0
@@ -28,15 +50,101 @@ class S:
     last = None
     stats = {"req": 0, "ok": 0, "fail": 0}
 
+
 def dec(e):
     try:
         return json.loads(bytes.fromhex(base64.b64decode(e).decode()).decode())
-    except:
+    except Exception:
+        return None
+
+
+def filter_headers(raw_headers, include_all=False):
+    """Filtre les headers : garde uniquement les utiles."""
+    if include_all:
+        return dict(raw_headers)
+    
+    cleaned = {}
+    for k, v in raw_headers.items():
+        kl = k.lower()
+        if kl in DROP_HEADERS:
+            continue
+        if kl in KEEP_HEADERS:
+            cleaned[k] = v
+    return cleaned
+
+
+def parse_body(text, content_type=""):
+    """Parse le body en JSON si possible, sinon tronque le texte."""
+    if not text:
         return None
+    
+    # Tente JSON
+    if "json" in content_type.lower() or text.strip().startswith(("{", "[")):
+        try:
+            return json.loads(text)
+        except (json.JSONDecodeError, ValueError):
+            pass
+    
+    # HTML → tronqué
+    if "html" in content_type.lower() or text.strip().startswith("<"):
+        return {
+            "_type": "html",
+            "_length": len(text),
+            "_preview": text[:300].strip() + ("..." if len(text) > 300 else ""),
+        }
+    
+    # Texte brut → tronqué si long
+    if len(text) > 2000:
+        return {
+            "_type": "text",
+            "_length": len(text),
+            "_preview": text[:500].strip() + "...",
+        }
+    
+    return text
+
+
+def extract_ip(url_str):
+    """Extrait l'IP d'une URL de serveur proxy."""
+    return (url_str or "").replace("https://", "").replace("http://", "").split("/")[0]
+
+
+def format_result(raw, include_raw_headers=False):
+    """Formate proprement le résultat d'un fetch."""
+    if not raw.get("success"):
+        return {
+            "success": False,
+            "error": raw.get("error"),
+            "server": raw.get("server"),
+        }
+    
+    ct = ""
+    if raw.get("headers"):
+        ct = raw["headers"].get("Content-Type", raw["headers"].get("content-type", ""))
+    
+    result = {
+        "success": True,
+        "status": raw.get("status"),
+        "url": raw.get("url"),
+        "body": parse_body(raw.get("body", ""), ct),
+        "proxy": raw.get("proxy"),
+        "servers_available": raw.get("servers_available"),
+    }
+    
+    # Headers filtrés
+    if raw.get("headers"):
+        result["headers"] = filter_headers(raw["headers"], include_all=include_raw_headers)
+    
+    return result
 
-def fetch(url, sid=None):
-    sc = cloudscraper.create_scraper(browser={"browser":"chrome","platform":"windows","desktop":True})
+
+def fetch_raw(url, sid=None):
+    """Fetch via CroxyProxy — retourne les données brutes."""
+    sc = cloudscraper.create_scraper(
+        browser={"browser": "chrome", "platform": "windows", "desktop": True}
+    )
     S.stats["req"] += 1
+    
     try:
         # 1. GET / → csrf
         r1 = sc.get(BASE, timeout=30)
@@ -51,13 +159,21 @@ def fetch(url, sid=None):
             return {"success": False, "error": "No CSRF"}
         
         # 2. POST /servers → selector page
-        r2 = sc.post(f"{BASE}/servers", data={
-            "url": url, "proxyServerId": "274", "csrf": ci["value"],
-            "demo": "0", "frontOrigin": BASE,
-        }, headers={
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Origin": BASE, "Referer": BASE + "/",
-        }, allow_redirects=True, timeout=30)
+        r2 = sc.post(
+            f"{BASE}/servers",
+            data={
+                "url": url, "proxyServerId": "274",
+                "csrf": ci["value"], "demo": "0",
+                "frontOrigin": BASE,
+            },
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Origin": BASE,
+                "Referer": BASE + "/",
+            },
+            allow_redirects=True,
+            timeout=30,
+        )
         
         if r2.status_code != 200:
             S.stats["fail"] += 1
@@ -70,7 +186,10 @@ def fetch(url, sid=None):
             return {"success": False, "error": "No selector"}
         
         # 3. Parse servers + csrf2
-        ss = [x for x in (dec(i) for i in json.loads(unescape(sel.get("data-ss","")))) if x and x.get("id")]
+        ss = [
+            x for x in (dec(i) for i in json.loads(unescape(sel.get("data-ss", ""))))
+            if x and x.get("id")
+        ]
         csrf2 = unescape(sel.get("data-csrf", "")).strip('"')
         fo = unescape(sel.get("data-fo", "")).strip('"')
         
@@ -78,10 +197,11 @@ def fetch(url, sid=None):
             S.stats["fail"] += 1
             return {"success": False, "error": "No servers"}
         
+        # Mettre à jour le cache
         S.servers = ss
         S.last = datetime.now(timezone.utc).isoformat()
         
-        # Choose server
+        # Choisir le serveur
         ch = None
         if sid:
             ch = next((x for x in ss if x["id"] == sid), None)
@@ -90,38 +210,53 @@ def fetch(url, sid=None):
                 ch = ss[S.idx % len(ss)]
                 S.idx += 1
         
-        # 4. POST /requests?fso= → 302
-        r3 = sc.post(f"{BASE}/requests?fso=", data={
-            "url": url, "proxyServerId": str(ch["id"]),
-            "csrf": csrf2, "demo": "0", "frontOrigin": fo,
-        }, headers={
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Origin": BASE, "Referer": f"{BASE}/servers",
-        }, allow_redirects=False, timeout=30)
+        # 4. POST /requests → 302
+        r3 = sc.post(
+            f"{BASE}/requests?fso=",
+            data={
+                "url": url, "proxyServerId": str(ch["id"]),
+                "csrf": csrf2, "demo": "0", "frontOrigin": fo,
+            },
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Origin": BASE,
+                "Referer": f"{BASE}/servers",
+            },
+            allow_redirects=False,
+            timeout=30,
+        )
         
         loc = r3.headers.get("Location") or r3.headers.get("location")
         if not loc:
             S.stats["fail"] += 1
-            return {"success": False, "error": f"No redirect ({r3.status_code})", "server": ch.get("name")}
+            return {
+                "success": False,
+                "error": f"No redirect ({r3.status_code})",
+                "server": ch.get("name"),
+            }
         
-        # 5. GET redirect → launching page → data-r
+        # 5. GET redirect → data-r
         r4 = sc.get(loc, timeout=30, allow_redirects=True)
         dr = re.search(r'data-r="([^"]+)"', r4.text)
         if not dr:
             S.stats["fail"] += 1
             return {"success": False, "error": "No data-r", "server": ch.get("name")}
         
-        # 6. decode data-r → GET final
+        # 6. GET final
         final = base64.b64decode(dr.group(1)).decode()
         r5 = sc.get(final, timeout=30, allow_redirects=True)
         
         S.stats["ok"] += 1
         return {
-            "success": True, "status": r5.status_code,
-            "headers": dict(r5.headers), "body": r5.text, "url": url,
+            "success": True,
+            "status": r5.status_code,
+            "headers": dict(r5.headers),
+            "body": r5.text,
+            "url": url,
             "proxy": {
-                "server_id": ch["id"], "server_name": ch.get("name"),
-                "ip": ch.get("url","").replace("https://","").replace("/__cp2.php",""),
+                "server_id": ch["id"],
+                "server_name": ch.get("name"),
+                "ip": extract_ip(ch.get("url", "")),
             },
             "servers_available": len(ss),
         }
@@ -130,54 +265,95 @@ def fetch(url, sid=None):
         return {"success": False, "error": str(e)}
 
 
+# ═══════════════════════════════════════════════
+#  ROUTES
+# ═══════════════════════════════════════════════
+
 @app.route("/")
 def index():
     return jsonify({
         "name": "CroxyProxy Rotating Proxy API",
+        "version": "2.0",
         "endpoints": {
             "GET /health": "Status + stats",
             "GET /servers": "List all servers",
-            "POST /proxy/fetch": "Rotating proxy {url, server_id?}",
-            "POST /proxy/random": "Random server {url}",
-            "POST /proxy/batch": "Multiple URLs {urls: [...]}",
+            "POST /proxy/fetch": "Rotating proxy {url, server_id?, raw_headers?}",
+            "POST /proxy/random": "Random server {url, raw_headers?}",
+            "POST /proxy/batch": "Multiple URLs {urls: [...], raw_headers?}",
+        },
+        "notes": {
+            "raw_headers": "Set to true to get ALL response headers (default: filtered)",
+            "body": "JSON bodies are auto-parsed. HTML is truncated with preview.",
         },
-        "example": 'curl -X POST /proxy/fetch -H "Content-Type: application/json" -d \'{"url":"https://httpbin.org/ip"}\'',
     })
 
+
 @app.route("/health")
 def health():
-    return jsonify({"status": "ready", "servers": len(S.servers), "last_refresh": S.last, "stats": S.stats})
+    return jsonify({
+        "status": "ready",
+        "servers": len(S.servers),
+        "last_refresh": S.last,
+        "stats": S.stats,
+    })
+
 
 @app.route("/servers")
 def servers():
-    return jsonify({"count": len(S.servers), "servers": [
-        {"id": s.get("id"), "name": s.get("name"), "ip": s.get("url","").replace("https://","").replace("/__cp2.php","")}
-        for s in S.servers
-    ]})
+    return jsonify({
+        "count": len(S.servers),
+        "servers": [
+            {
+                "id": s.get("id"),
+                "name": s.get("name"),
+                "ip": extract_ip(s.get("url", "")),
+            }
+            for s in S.servers
+        ],
+    })
+
 
 @app.route("/proxy/fetch", methods=["POST"])
-def pf():
+def proxy_fetch():
     d = request.get_json() or {}
-    if not d.get("url"): return jsonify({"error": "url required"}), 400
-    return jsonify(fetch(d["url"], d.get("server_id")))
+    if not d.get("url"):
+        return jsonify({"error": "url required"}), 400
+    
+    raw = fetch_raw(d["url"], d.get("server_id"))
+    return jsonify(format_result(raw, include_raw_headers=d.get("raw_headers", False)))
+
 
 @app.route("/proxy/random", methods=["POST"])
-def pr():
+def proxy_random():
     d = request.get_json() or {}
-    if not d.get("url"): return jsonify({"error": "url required"}), 400
+    if not d.get("url"):
+        return jsonify({"error": "url required"}), 400
+    
     sid = random.choice(S.servers)["id"] if S.servers else None
-    return jsonify(fetch(d["url"], sid))
+    raw = fetch_raw(d["url"], sid)
+    return jsonify(format_result(raw, include_raw_headers=d.get("raw_headers", False)))
+
 
 @app.route("/proxy/batch", methods=["POST"])
-def pb():
+def proxy_batch():
     d = request.get_json() or {}
     urls = d.get("urls", [])
-    if not urls: return jsonify({"error": "urls required"}), 400
-    res = []
+    if not urls:
+        return jsonify({"error": "urls required"}), 400
+    
+    include_raw = d.get("raw_headers", False)
+    results = []
     for u in urls:
-        res.append(fetch(u))
+        raw = fetch_raw(u)
+        results.append(format_result(raw, include_raw_headers=include_raw))
         time.sleep(0.5)
-    return jsonify({"results": res})
+    
+    return jsonify({
+        "count": len(results),
+        "success_count": sum(1 for r in results if r.get("success")),
+        "results": results,
+    })
+
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)