Update app.py

app.py

@@ -1,68 +1,81 @@
 from fastapi import FastAPI, HTTPException
 from playwright.sync_api import sync_playwright
+import re
 
 app = FastAPI()
 
-# IMPORTANT: You need to confirm the text/selector of the download button.
-# Based on typical Pixeldrain layout, let's assume the button has the text "Download" or "Download File".
-# We'll use a robust selector that looks for the button element containing the text "Download".
-# --- app.py code ---
-
-# ... imports ...
-
+# --- Configuration ---
+# You MUST confirm the exact text on the download button.
+# Assuming the text is exactly "Download"
 DOWNLOAD_BUTTON_SELECTOR = 'button:has-text("Download")' 
-# Make sure to confirm the button text: "Download", "Download File", etc.
+
+# Set a long timeout for the entire Playwright operation (in milliseconds)
+PLAYWRIGHT_TIMEOUT_MS = 60000
 
 def get_pixeldrain_info(pixeldrain_url: str):
+    """
+    Launches a headless Chromium browser using Playwright to bypass Pixeldrain's 
+    client-side hotlink detection, extracts the final tokenized URL and cookies.
+    """
+    
+    # 1. Initialization and Stealth Headers
+    user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    final_download_url = None
+
     try:
         with sync_playwright() as p:
-            # 1. Add User-Agent spoofing to the context creation
-            user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-            
+            # 2. Launch Browser with Stealth Context
+            # Set a slower speed (slow_mo) to give the page a chance to react
             browser = p.chromium.launch(headless=True, slow_mo=50) 
-            # Create a new context with a realistic User-Agent
-            context = browser.new_context(user_agent=user_agent)
-            page = context.new_page()
-
-            # 2. Navigate to the Pixeldrain page with a less strict wait condition
-            # Changed 'networkidle' to 'domcontentloaded' (or just 'load')
-            page.goto(pixeldrain_url, wait_until="domcontentloaded", timeout=30000) 
-            print("Successfully navigated to Pixeldrain page (DOM loaded).")
             
-            # --- Network Listener (Keep this logic) ---
-            final_download_url = None
+            # Use a custom context with realistic viewport and locale
+            context = browser.new_context(
+                user_agent=user_agent,
+                viewport={"width": 1920, "height": 1080},
+                locale="en-US"
+            )
+            # Set the overall operation timeout
+            context.set_default_timeout(PLAYWRIGHT_TIMEOUT_MS) 
+            
+            page = context.new_page()
             
+            # 3. Setup Network Listener
             def handle_response(response):
                 nonlocal final_download_url
                 # Look for the final redirect URL pattern (https://pd.pixeldrain.com/api/file/HASH/FILENAME)
-                if "/api/file/" in response.url and response.status == 200:
+                # We check for '/api/file/' and a 200 OK status.
+                if "/api/file/" in response.url and response.status == 200 and len(response.url) > 50:
                     print(f"Captured final link via network: {response.url}")
                     final_download_url = response.url
                     
             page.on("response", handle_response)
             
-            # 3. Wait for the download button to be visible and click it (to trigger s("download"))
+            # 4. Navigate (Using the least strict wait condition: "load")
+            page.goto(pixeldrain_url, wait_until="load", timeout=PLAYWRIGHT_TIMEOUT_MS) 
+            print("Successfully navigated to Pixeldrain page (waiting until 'load').")
+            
+            # 5. Wait for the button and click it (to trigger s("download"))
             try:
-                # Give it a bit more time to appear after DOMContentLoaded
-                page.wait_for_selector(DOWNLOAD_BUTTON_SELECTOR, timeout=15000)
+                # Wait for 30 seconds for the button to appear after the page has loaded
+                page.wait_for_selector(DOWNLOAD_BUTTON_SELECTOR, timeout=30000)
                 print(f"Found button with selector: {DOWNLOAD_BUTTON_SELECTOR}. Clicking...")
                 page.click(DOWNLOAD_BUTTON_SELECTOR)
-            except Exception:
-                raise ValueError(f"Timeout: Could not find or click the button with selector: {DOWNLOAD_BUTTON_SELECTOR}")
+            except Exception as e:
+                raise ValueError(f"Button not found/Timeout during click: {e}")
                 
-            # 4. Wait for the final URL to be captured by the network listener
+            # 6. Wait for the final URL to be captured
+            # Give it 15 seconds for the network request to fire and be captured
             page.wait_for_timeout(15000) 
             
-            # ... (rest of the URL check/cookie extraction remains the same) ...
-
             if not final_download_url:
                 raise ValueError("Could not capture the final tokenized download URL after clicking.")
 
-            # 5. Extract cookies and user-agent
+            # 7. Extract necessary data
             cookies = page.context.cookies()
             cookie_string = "; ".join([f"{c['name']}={c['value']}" for c in cookies])
-            # Use the explicit User-Agent we set earlier
-            # user_agent is already defined at the start of the function
+            
+            # Extract filename from the URL (best guess is the last part)
+            filename = final_download_url.split('/')[-1]
 
             browser.close()
 
@@ -70,21 +83,20 @@ def get_pixeldrain_info(pixeldrain_url: str):
                 "download_url": final_download_url,
                 "cookies": cookie_string,
                 "user_agent": user_agent,
-                "filename": filename # This comes from the URL split
+                "filename": filename 
             }
 
     except Exception as e:
         print(f"Error during Playwright execution: {e}")
-        # Re-raise the exception details for debugging, but return None to signal failure
+        # The Cloudflare Worker will catch the 500 error raised below
         return None
 
-# ... (FastAPI routes remain the same) ...
-# FastAPI routes remain the same
+# --- FastAPI Routes ---
 @app.get("/resolve_pixeldrain")
 def resolve_url(url: str):
     data = get_pixeldrain_info(url)
     if not data or not data["download_url"]:
-        # 500 status will trigger the error handling in the Cloudflare Worker
+        # Raise 500 to send the failure detail back to the Cloudflare Worker
         raise HTTPException(status_code=500, detail="Failed to resolve URL via Playwright.")
     return data