Spaces:

triflix
/

testingproxy123

Paused

App Files Files Community

triflix commited on Mar 14, 2025

Commit

f459e61

verified ·

1 Parent(s): 365d093

Update main.py

Browse files

Files changed (1) hide show

main.py +67 -29

main.py CHANGED Viewed

@@ -5,23 +5,21 @@ import urllib.parse
 app = FastAPI()
-# JavaScript code that will be injected into proxied HTML pages.
-# It intercepts dynamic URL changes and client-side network requests.
 INJECTED_JS = """
 <script>
-// Intercept History API to rewrite URLs for proxying
 (function() {
     const originalPushState = history.pushState;
     history.pushState = function(state, title, url) {
         if (url) {
-            // Rewrite the URL to use our proxy endpoint
-            const proxiedUrl = '/proxy_full?url=' + encodeURIComponent(url);
             return originalPushState.call(history, state, title, proxiedUrl);
         }
         return originalPushState.call(history, state, title, url);
     };
-    // Intercept fetch to ensure all dynamic requests go through the proxy
     const originalFetch = window.fetch;
     window.fetch = function(input, init) {
         let url;
@@ -32,7 +30,7 @@ INJECTED_JS = """
         } else {
             return originalFetch(input, init);
         }
-        const proxiedUrl = '/proxy_full?url=' + encodeURIComponent(url);
         if (typeof input === 'object') {
             input = new Request(proxiedUrl, input);
         } else {
@@ -41,42 +39,54 @@ INJECTED_JS = """
         return originalFetch(input, init);
     };
-    // Intercept XMLHttpRequest open() method to proxy XHR requests
     const originalOpen = XMLHttpRequest.prototype.open;
     XMLHttpRequest.prototype.open = function(method, url) {
-        const proxiedUrl = '/proxy_full?url=' + encodeURIComponent(url);
         return originalOpen.apply(this, [method, proxiedUrl, true]);
     };
 })();
 </script>
 """
-@app.get("/proxy_full")
-async def proxy_full(url: str):
-    if not url:
-        raise HTTPException(status_code=400, detail="Missing 'url' query parameter")
-    # Fetch the target URL using an async HTTP client.
     async with httpx.AsyncClient() as client:
-        resp = await client.get(url)
     content_type = resp.headers.get("Content-Type", "")
-    # For non-HTML content (images, CSS, JS, etc.), simply return the response.
     if "text/html" not in content_type:
         return Response(content=resp.content, media_type=content_type, status_code=resp.status_code)
-    # Parse HTML with BeautifulSoup
     soup = BeautifulSoup(resp.text, "html.parser")
-    # Inject our JavaScript to intercept client-side navigation and network calls.
     if soup.head:
-        soup.head.append(BeautifulSoup(INJECTED_JS, "html.parser"))
-    elif soup.body:
         soup.body.insert(0, BeautifulSoup(INJECTED_JS, "html.parser"))
     else:
         soup.insert(0, BeautifulSoup(INJECTED_JS, "html.parser"))
-    # Rewrite URLs for key elements so that they go through the proxy.
     tags_attrs = {
         "a": "href",
         "img": "src",
@@ -87,12 +97,40 @@ async def proxy_full(url: str):
     for tag, attr in tags_attrs.items():
         for element in soup.find_all(tag):
             if element.has_attr(attr):
-                original = element[attr]
-                # Skip if already proxied
-                if original.startswith("/proxy_full?url="):
                     continue
-                # Build an absolute URL and rewrite it to include our proxy
-                new_url = urllib.parse.urljoin(url, original)
-                element[attr] = "/proxy_full?url=" + urllib.parse.quote(new_url)
     return Response(content=str(soup), media_type="text/html", status_code=resp.status_code)

 app = FastAPI()
+# JavaScript injected into HTML to intercept dynamic navigation and AJAX calls.
 INJECTED_JS = """
 <script>
 (function() {
+    // Intercept history.pushState so dynamic URL changes use our proxy.
     const originalPushState = history.pushState;
     history.pushState = function(state, title, url) {
         if (url) {
+            const proxiedUrl = '/?url=' + encodeURIComponent(url);
             return originalPushState.call(history, state, title, proxiedUrl);
         }
         return originalPushState.call(history, state, title, url);
     };
+    // Intercept fetch() requests to route them through our proxy.
     const originalFetch = window.fetch;
     window.fetch = function(input, init) {
         let url;
         } else {
             return originalFetch(input, init);
         }
+        const proxiedUrl = '/?url=' + encodeURIComponent(url);
         if (typeof input === 'object') {
             input = new Request(proxiedUrl, input);
         } else {
         return originalFetch(input, init);
     };
+    // Intercept XMLHttpRequest open() calls.
     const originalOpen = XMLHttpRequest.prototype.open;
     XMLHttpRequest.prototype.open = function(method, url) {
+        const proxiedUrl = '/?url=' + encodeURIComponent(url);
         return originalOpen.apply(this, [method, proxiedUrl, true]);
     };
 })();
 </script>
 """
+async def fetch_and_rewrite(target_url: str) -> Response:
     async with httpx.AsyncClient() as client:
+        # Fetch the target URL.
+        resp = await client.get(target_url)
     content_type = resp.headers.get("Content-Type", "")
+    # If not HTML (CSS, JS, images, etc.), return content directly.
     if "text/html" not in content_type:
         return Response(content=resp.content, media_type=content_type, status_code=resp.status_code)
+    # Parse HTML content.
     soup = BeautifulSoup(resp.text, "html.parser")
+    # --- Inject a <base> Tag ---
+    # This makes sure that all relative URLs in the HTML resolve correctly.
+    parsed_target = urllib.parse.urlparse(target_url)
+    base_href = f"{parsed_target.scheme}://{parsed_target.netloc}"
     if soup.head:
+        # Remove any existing <base> tags.
+        for base in soup.head.find_all('base'):
+            base.decompose()
+        base_tag = soup.new_tag("base", href=base_href)
+        soup.head.insert(0, base_tag)
+    else:
+        head_tag = soup.new_tag("head")
+        base_tag = soup.new_tag("base", href=base_href)
+        head_tag.insert(0, base_tag)
+        soup.insert(0, head_tag)
+    # --- Inject JavaScript for Dynamic Routing ---
+    # Place the JS in the <body> (or at the top if no body tag exists).
+    if soup.body:
         soup.body.insert(0, BeautifulSoup(INJECTED_JS, "html.parser"))
     else:
         soup.insert(0, BeautifulSoup(INJECTED_JS, "html.parser"))
+    # --- Rewrite Resource URLs ---
+    # Update links, images, scripts, CSS links, and form actions to route via the proxy.
     tags_attrs = {
         "a": "href",
         "img": "src",
     for tag, attr in tags_attrs.items():
         for element in soup.find_all(tag):
             if element.has_attr(attr):
+                orig = element[attr]
+                # Skip javascript: or mailto: links.
+                if orig.startswith("javascript:") or orig.startswith("mailto:"):
                     continue
+                # Build an absolute URL using the target URL as base.
+                new_url = urllib.parse.urljoin(target_url, orig)
+                # Route it through the proxy.
+                element[attr] = "/?url=" + urllib.parse.quote(new_url)
     return Response(content=str(soup), media_type="text/html", status_code=resp.status_code)
+# Catch-all route to handle any path.
+@app.get("/{full_path:path}")
+async def catch_all(full_path: str, request: Request):
+    query_params = dict(request.query_params)
+    # If a "url" query parameter is provided, this is the initial load.
+    if "url" in query_params:
+        target_url = query_params["url"]
+    else:
+        # Otherwise, try to rebuild the target URL using a stored cookie.
+        target_base = request.cookies.get("target_base")
+        if not target_base:
+            return Response("No target URL provided.", status_code=400)
+        qs = request.url.query  # Preserve any query string.
+        target_url = urllib.parse.urljoin(target_base, full_path)
+        if qs:
+            target_url += "?" + qs
+    response = await fetch_and_rewrite(target_url)
+    # Store the base URL (scheme + host) in a cookie for subsequent requests.
+    parsed_target = urllib.parse.urlparse(target_url)
+    base_url = f"{parsed_target.scheme}://{parsed_target.netloc}"
+    response.set_cookie("target_base", base_url)
+    return response