Create app.py

app.py

@@ -0,0 +1,572 @@
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+import os
+import time
+import traceback
+from pathlib import Path
+import threading
+import atexit
+import random
+import math
+from PIL import Image, ImageDraw
+import requests
+import uuid
+from datetime import datetime, timedelta
+from collections import deque
+import string
+
+app = Flask(__name__)
+CORS(app)
+
+BASE_DIR = Path(__file__).parent
+PUBLIC_DIR = BASE_DIR / 'public'
+PUBLIC_DIR.mkdir(exist_ok=True)
+
+PORT = int(os.environ.get('PORT', 7860))
+
+VIEWPORT_WIDTH = 1920
+VIEWPORT_HEIGHT = 1080
+
+VIEWPORT_CONFIG = {
+    'width': VIEWPORT_WIDTH,
+    'height': VIEWPORT_HEIGHT,
+    'device_scale_factor': 1
+}
+
+MAX_ROOMS = 5
+ROOM_TIMEOUT_MINUTES = 10
+SCREENSHOT_EXPIRY_MINUTES = 10
+JOB_EXPIRY_MINUTES = 30
+
+SCREENSHOT_BASE_URL = "http://pnode1.danbot.host:1149"
+
+class Job:
+    def __init__(self, job_id, code, lang, base_url):
+        self.job_id = job_id
+        self.code = code
+        self.lang = lang
+        self.base_url = base_url
+        self.status = 'queued'
+        self.result = None
+        self.error = None
+        self.created_at = datetime.now()
+        self.started_at = None
+        self.completed_at = None
+        self.room_id = None
+        self.screenshots = []
+        
+    def to_dict(self):
+        return {
+            'job_id': self.job_id,
+            'status': self.status,
+            'result': self.result,
+            'error': self.error,
+            'created_at': self.created_at.isoformat(),
+            'started_at': self.started_at.isoformat() if self.started_at else None,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'room_id': self.room_id,
+            'screenshots': self.screenshots
+        }
+        
+    def is_expired(self):
+        return (datetime.now() - self.created_at) > timedelta(minutes=JOB_EXPIRY_MINUTES)
+
+class BrowserRoom:
+    def __init__(self, room_id):
+        self.room_id = room_id
+        self.browser = None
+        self.context = None
+        self.page = None
+        self.cookies = []
+        self.created_at = datetime.now()
+        self.last_activity = datetime.now()
+        self.is_busy = False
+        self.current_job_id = None
+        self.lock = threading.Lock()
+        self.screenshots_dir = PUBLIC_DIR / f'room_{room_id}'
+        self.screenshots_dir.mkdir(exist_ok=True)
+        
+    def update_activity(self):
+        self.last_activity = datetime.now()
+        
+    def is_expired(self):
+        return (datetime.now() - self.last_activity) > timedelta(minutes=ROOM_TIMEOUT_MINUTES)
+        
+    def cleanup_screenshots(self):
+        try:
+            current_time = time.time()
+            for file in self.screenshots_dir.glob('*.png'):
+                file_age = current_time - file.stat().st_mtime
+                if file_age > (SCREENSHOT_EXPIRY_MINUTES * 60):
+                    file.unlink()
+                    print(f"[ROOM-{self.room_id}] Deleted expired screenshot: {file.name}")
+        except Exception as e:
+            print(f"[ROOM-{self.room_id}] Screenshot cleanup error: {e}")
+    
+    def reset_browser(self):
+        try:
+            if self.page:
+                self.page.close()
+                self.page = None
+            if self.context:
+                try:
+                    self.cookies = self.context.cookies()
+                    print(f"[ROOM-{self.room_id}] Saved {len(self.cookies)} cookies")
+                except:
+                    pass
+                self.context.close()
+                self.context = None
+            if self.browser:
+                self.browser.close()
+                self.browser = None
+        except Exception as e:
+            print(f"[ROOM-{self.room_id}] Browser reset error: {e}")
+            
+    def cleanup(self):
+        try:
+            self.reset_browser()
+            self.cleanup_screenshots()
+            if self.screenshots_dir.exists():
+                try:
+                    self.screenshots_dir.rmdir()
+                except:
+                    pass
+        except Exception as e:
+            print(f"[ROOM-{self.room_id}] Cleanup error: {e}")
+
+class JobManager:
+    def __init__(self):
+        self.jobs = {}
+        self.lock = threading.Lock()
+        
+    def generate_job_id(self):
+        while True:
+            job_id = ''.join(random.choices(string.ascii_uppercase + string.digits, k=3))
+            if job_id not in self.jobs:
+                return job_id
+                
+    def create_job(self, code, lang, base_url):
+        with self.lock:
+            job_id = self.generate_job_id()
+            job = Job(job_id, code, lang, base_url)
+            self.jobs[job_id] = job
+            return job
+            
+    def get_job(self, job_id):
+        with self.lock:
+            return self.jobs.get(job_id)
+            
+    def update_job(self, job_id, **kwargs):
+        with self.lock:
+            if job_id in self.jobs:
+                job = self.jobs[job_id]
+                for key, value in kwargs.items():
+                    setattr(job, key, value)
+                    
+    def cleanup_expired_jobs(self):
+        with self.lock:
+            expired = [jid for jid, job in self.jobs.items() if job.is_expired()]
+            for jid in expired:
+                del self.jobs[jid]
+                print(f"[JOB-{jid}] Deleted expired job")
+
+class RoomManager:
+    def __init__(self):
+        self.rooms = {}
+        self.available_rooms = deque(range(1, MAX_ROOMS + 1))
+        self.lock = threading.Lock()
+        self.cleanup_thread = None
+        self.stop_cleanup = threading.Event()
+        
+    def acquire_room(self, job_id, timeout=300):
+        start_time = time.time()
+        while True:
+            with self.lock:
+                if self.available_rooms:
+                    room_id = self.available_rooms.popleft()
+                    if room_id not in self.rooms:
+                        self.rooms[room_id] = BrowserRoom(room_id)
+                    room = self.rooms[room_id]
+                    room.is_busy = True
+                    room.current_job_id = job_id
+                    room.update_activity()
+                    print(f"[ROOM-{room_id}] Acquired for job {job_id}. Available rooms: {len(self.available_rooms)}/{MAX_ROOMS}")
+                    return room
+                    
+            if time.time() - start_time > timeout:
+                raise Exception(f"Timeout waiting for available room after {timeout}s. All {MAX_ROOMS} rooms are busy.")
+                
+            print(f"[QUEUE] All {MAX_ROOMS} rooms busy. Waiting for available room...")
+            time.sleep(1)
+            
+    def release_room(self, room):
+        with self.lock:
+            room.is_busy = False
+            room.current_job_id = None
+            room.update_activity()
+            if room.room_id not in self.available_rooms:
+                self.available_rooms.append(room.room_id)
+            print(f"[ROOM-{room.room_id}] Released. Available rooms: {len(self.available_rooms)}/{MAX_ROOMS}")
+            
+    def cleanup_expired_rooms(self):
+        while not self.stop_cleanup.is_set():
+            try:
+                current_time = time.time()
+                
+                with self.lock:
+                    for room_id, room in list(self.rooms.items()):
+                        if not room.is_busy:
+                            try:
+                                for file in room.screenshots_dir.glob('*.png'):
+                                    file_age = current_time - file.stat().st_mtime
+                                    if file_age > (SCREENSHOT_EXPIRY_MINUTES * 60):
+                                        file.unlink()
+                                        print(f"[ROOM-{room_id}] Auto-deleted expired screenshot: {file.name}")
+                            except Exception as e:
+                                print(f"[ROOM-{room_id}] Auto cleanup screenshot error: {e}")
+                        
+                        if not room.is_busy and room.is_expired():
+                            print(f"[ROOM-{room_id}] Cleaning up expired room")
+                            self.rooms[room_id].cleanup()
+                            del self.rooms[room_id]
+                        
+            except Exception as e:
+                print(f"[CLEANUP] Error: {e}")
+            self.stop_cleanup.wait(60)
+            
+    def start_cleanup(self):
+        self.cleanup_thread = threading.Thread(target=self.cleanup_expired_rooms, daemon=True)
+        self.cleanup_thread.start()
+        
+    def stop_cleanup_thread(self):
+        self.stop_cleanup.set()
+        if self.cleanup_thread:
+            self.cleanup_thread.join(timeout=5)
+            
+    def shutdown_all(self):
+        with self.lock:
+            for room in self.rooms.values():
+                room.cleanup()
+            self.rooms.clear()
+            self.available_rooms.clear()
+
+room_manager = RoomManager()
+job_manager = JobManager()
+
+def execute_in_room(code_snippet, room, job_id):
+    result = {'screenshots': [], 'data': None, 'error': None}
+    
+    room.reset_browser()
+    
+    browser_obj = None
+    
+    try:
+        print(f"[ROOM-{room.room_id}] [JOB-{job_id}] Starting execution at {time.time()}")
+        
+        from camoufox.sync_api import Camoufox
+        
+        proxy_server = "http://pnode1.danbot.host:1271"
+        
+        browser_obj = Camoufox(
+            headless=True,
+            humanize=True,
+            proxy={'server': proxy_server}
+        )
+        
+        browser_obj = browser_obj.__enter__()
+        
+        if room.cookies:
+            print(f"[ROOM-{room.room_id}] [JOB-{job_id}] Restoring {len(room.cookies)} cookies")
+        
+        viewport_inject_code = """
+import sys
+_original_goto = None
+
+def _patched_goto(self, url, **kwargs):
+    result = _original_goto(self, url, **kwargs)
+    try:
+        self.evaluate('''
+            let meta = document.querySelector('meta[name="viewport"]');
+            if (!meta) {
+                meta = document.createElement('meta');
+                meta.name = 'viewport';
+                document.head.appendChild(meta);
+            }
+            meta.content = 'width=1920, height=1080, initial-scale=1.0, maximum-scale=1.0, user-scalable=no';
+            document.documentElement.style.width = '1920px';
+            document.documentElement.style.height = '1080px';
+            document.body.style.width = '1920px';
+            document.body.style.height = '1080px';
+        ''')
+    except:
+        pass
+    return result
+
+if 'browser' in dir() and browser is not None:
+    try:
+        from playwright.sync_api import Page
+        if not hasattr(Page, '_viewport_patched'):
+            _original_goto = Page.goto
+            Page.goto = _patched_goto
+            Page._viewport_patched = True
+    except:
+        pass
+"""
+        
+        namespace = {
+            'browser': browser_obj,
+            'room_cookies': room.cookies,
+            'public_dir': str(room.screenshots_dir),
+            'room_id': room.room_id,
+            'job_id': job_id,
+            'time': time,
+            'result': result,
+            'Path': Path,
+            'random': random,
+            'math': math,
+            'Image': Image,
+            'ImageDraw': ImageDraw,
+            'requests': requests,
+            'print': print,
+            'len': len,
+            'int': int,
+            'str': str,
+            'dict': dict,
+            'list': list,
+            'VIEWPORT_WIDTH': VIEWPORT_WIDTH,
+            'VIEWPORT_HEIGHT': VIEWPORT_HEIGHT,
+        }
+        
+        exec(viewport_inject_code, namespace)
+        
+        print(f"[ROOM-{room.room_id}] [JOB-{job_id}] Executing code...")
+        exec(code_snippet, namespace)
+        
+        if 'return_value' in namespace:
+            result['data'] = namespace['return_value']
+            
+        print(f"[ROOM-{room.room_id}] [JOB-{job_id}] Execution completed successfully")
+        
+    except Exception as e:
+        error_msg = str(e) + "\n" + traceback.format_exc()
+        result['error'] = error_msg
+        print(f"[ROOM-{room.room_id}] [JOB-{job_id}] ERROR: {error_msg}")
+    finally:
+        if browser_obj:
+            try:
+                browser_obj.__exit__(None, None, None)
+            except:
+                pass
+    
+    return result
+
+def process_job(job):
+    room = None
+    try:
+        job_manager.update_job(job.job_id, status='running', started_at=datetime.now())
+        
+        room = room_manager.acquire_room(job.job_id, timeout=900)
+        job_manager.update_job(job.job_id, room_id=room.room_id)
+        
+        result = execute_in_room(job.code, room, job.job_id)
+        
+        screenshot_files = []
+        for file in sorted(room.screenshots_dir.glob('*.png'), key=lambda x: x.stat().st_mtime):
+            screenshot_files.append({
+                'name': file.name,
+                'publicURL': f"{SCREENSHOT_BASE_URL}/files/room_{room.room_id}/{file.name}"
+            })
+        
+        if result.get('error'):
+            job_manager.update_job(
+                job.job_id,
+                status='failed',
+                error=result['error'],
+                completed_at=datetime.now(),
+                screenshots=screenshot_files
+            )
+        else:
+            job_manager.update_job(
+                job.job_id,
+                status='completed',
+                result=result.get('data'),
+                completed_at=datetime.now(),
+                screenshots=screenshot_files
+            )
+            
+    except Exception as e:
+        error_msg = str(e) + "\n" + traceback.format_exc()
+        job_manager.update_job(
+            job.job_id,
+            status='failed',
+            error=error_msg,
+            completed_at=datetime.now()
+        )
+    finally:
+        if room:
+            room.cleanup_screenshots()
+            room_manager.release_room(room)
+
+@app.route('/api/s-playwright', methods=['POST'])
+def execute_playwright():
+    try:
+        data = request.get_json()
+        
+        if not data or 'code' not in data or 'lang' not in data:
+            return jsonify({
+                'success': False,
+                'error': 'Missing required fields: code and lang'
+            }), 400
+        
+        code = data['code']
+        lang = data['lang'].lower()
+        
+        if lang != 'python':
+            return jsonify({
+                'success': False,
+                'error': f'Only Python is supported, got: {lang}'
+            }), 400
+        
+        base_url = request.url_root.rstrip('/')
+        job = job_manager.create_job(code, lang, base_url)
+        
+        thread = threading.Thread(target=process_job, args=(job,))
+        thread.daemon = True
+        thread.start()
+        
+        return jsonify({
+            'success': True,
+            'job_id': job.job_id,
+            'status': 'queued',
+            'check_url': f'/job/{job.job_id}'
+        })
+        
+    except Exception as e:
+        print(f"[API ERROR] {str(e)}\n{traceback.format_exc()}")
+        return jsonify({
+            'success': False,
+            'error': str(e),
+            'stack': traceback.format_exc()
+        }), 500
+
+@app.route('/job/<string:job_id>', methods=['GET'])
+def get_job_status(job_id):
+    job = job_manager.get_job(job_id.upper())
+    
+    if not job:
+        return jsonify({
+            'success': False,
+            'error': 'Job not found'
+        }), 404
+    
+    return jsonify({
+        'success': True,
+        'job': job.to_dict()
+    })
+
+@app.route('/files/room_<int:room_id>/<path:filename>')
+def serve_file(room_id, filename):
+    room_dir = PUBLIC_DIR / f'room_{room_id}'
+    return send_from_directory(room_dir, filename)
+
+@app.route('/health', methods=['GET'])
+def health():
+    with room_manager.lock:
+        busy_rooms = sum(1 for r in room_manager.rooms.values() if r.is_busy)
+        available = len(room_manager.available_rooms)
+    
+    with job_manager.lock:
+        total_jobs = len(job_manager.jobs)
+        queued_jobs = sum(1 for j in job_manager.jobs.values() if j.status == 'queued')
+        running_jobs = sum(1 for j in job_manager.jobs.values() if j.status == 'running')
+        
+    return jsonify({
+        'status': 'healthy',
+        'rooms': {
+            'total': MAX_ROOMS,
+            'available': available,
+            'busy': busy_rooms
+        },
+        'jobs': {
+            'total': total_jobs,
+            'queued': queued_jobs,
+            'running': running_jobs
+        },
+        'viewport': {
+            'width': VIEWPORT_WIDTH,
+            'height': VIEWPORT_HEIGHT,
+            'locked': True
+        },
+        'timestamp': int(time.time() * 1000)
+    })
+
+@app.route('/', methods=['GET'])
+def index():
+    with room_manager.lock:
+        busy_rooms = sum(1 for r in room_manager.rooms.values() if r.is_busy)
+        available = len(room_manager.available_rooms)
+        
+    return jsonify({
+        'message': 'Multi-Room Camoufox Anti-Detection API with Job System',
+        'endpoints': {
+            'POST /api/s-playwright': 'Execute camoufox code (returns job_id)',
+            'GET /job/:id': 'Check job status (3-character job ID)',
+            'GET /health': 'Check API health status'
+        },
+        'features': [
+            f'{MAX_ROOMS} Isolated Browser Rooms',
+            'Job Queue System with 3-char IDs',
+            'Async Job Processing',
+            f'Viewport LOCKED at {VIEWPORT_WIDTH}x{VIEWPORT_HEIGHT}',
+            'Camoufox Anti-Detection Browser',
+            'Human-like Mouse Movement',
+            'Advanced Cloudflare WAF Bypass',
+            'Auto Room & Job Cleanup',
+            'Concurrent Request Protection'
+        ],
+        'configuration': {
+            'viewport': {'width': VIEWPORT_WIDTH, 'height': VIEWPORT_HEIGHT, 'locked': True},
+            'port': PORT,
+            'rooms': {
+                'total': MAX_ROOMS,
+                'available': available,
+                'busy': busy_rooms
+            },
+            'timeout': '1200 seconds per execution',
+            'room_timeout': f'{ROOM_TIMEOUT_MINUTES} minutes',
+            'job_expiry': f'{JOB_EXPIRY_MINUTES} minutes',
+            'screenshot_base_url': SCREENSHOT_BASE_URL
+        }
+    })
+
+if __name__ == '__main__':
+    print(f"🚀 Multi-Room Camoufox API with Job System")
+    print(f"🌐 Port: {PORT}")
+    print(f"🏠 Browser Rooms: {MAX_ROOMS}")
+    print(f"📐 Viewport: LOCKED at {VIEWPORT_WIDTH}x{VIEWPORT_HEIGHT}")
+    print(f"📍 Endpoints: POST /api/s-playwright, GET /job/:id")
+    print(f"🎭 Features: Job queue, 3-char IDs, Async processing")
+    print(f"🖱️  Human mouse movement: ENABLED")
+    print(f"🌍 Proxy: http://pnode1.danbot.host:1271")
+    print(f"📸 Screenshot URL: {SCREENSHOT_BASE_URL}")
+    print(f"⏱️  Execution timeout: 1200 seconds")
+    print(f"🔒 Room timeout: {ROOM_TIMEOUT_MINUTES} minutes")
+    print(f"📦 Job expiry: {JOB_EXPIRY_MINUTES} minutes")
+    
+    room_manager.start_cleanup()
+    
+    def cleanup_jobs():
+        while True:
+            job_manager.cleanup_expired_jobs()
+            time.sleep(300)
+    
+    job_cleanup_thread = threading.Thread(target=cleanup_jobs, daemon=True)
+    job_cleanup_thread.start()
+    
+    def cleanup_on_exit():
+        room_manager.stop_cleanup_thread()
+        room_manager.shutdown_all()
+    
+    atexit.register(cleanup_on_exit)
+    
+    app.run(host='0.0.0.0', port=PORT, debug=False, threaded=True)