TFLogin API Documentation

Copyimport time
import requests
import asyncio
import json
from datetime import datetime
import os
from playwright.async_api import async_playwright
import traceback

# Configuration
API_URL = "http://127.0.0.1:5000"
PROFILE_ID = 1
TARGET_URL = "https://mmo69.com/button-click-me.html"
BUTTON_ID = "randomButton"
DURATION_SECONDS = 28
SCREENSHOT_FOLDER = "screenshots"
TAKE_SCREENSHOTS = True
SCREENSHOT_INTERVAL = 5  # seconds

async def run_automated_task():
    print(f"Starting automated clicking task for {TARGET_URL}")
    print(f"Using profile ID: {PROFILE_ID}, Duration: {DURATION_SECONDS} seconds")
    
    # Create screenshots directory if needed
    if TAKE_SCREENSHOTS:
        os.makedirs(SCREENSHOT_FOLDER, exist_okay=True)
    
    # Step 1: Launch browser via TFLogin API
    try:
        response = requests.post(
            f"{API_URL}/run-trungfox",
            json={
                "ID_Folder": PROFILE_ID,
                "isServer": 1,  # Enable WebSocket mode (1 = true in the API)
                "screen": "1024x768",
                "on_toolbar_close": 1,
                "on_toolbar_url": 1
            },
            headers={"Content-Type": "application/json"}
        )
        
        response.raise_for_status()
        data = response.json()
        
        websocket_url = data.get("Url_WS")
        if not websocket_url:
            raise ValueError("No WebSocket URL returned in the API response")
            
        print(f"Browser launched successfully")
        print(f"WebSocket URL: {websocket_url}")
        print(f"API stop URL: {data.get('api_stop')}")
        
    except Exception as e:
        print(f"Failed to launch browser: {e}")
        traceback.print_exc()
        return
    
    # Step 2: Connect to browser and perform automation
    try:
        async with async_playwright() as p:
            # Connect to browser using the WebSocket URL
            browser = await p.firefox.connect(websocket_url)
            print("Successfully connected to browser")
            
            # Create a new page
            page = await browser.new_page()
            
            # Navigate to target URL
            print(f"Navigating to {TARGET_URL}")
            await page.goto(TARGET_URL)
            
            # Take initial screenshot
            if TAKE_SCREENSHOTS:
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                screenshot_path = f"{SCREENSHOT_FOLDER}/initial_{timestamp}.png"
                await page.screenshot(path=screenshot_path)
                print(f"Initial screenshot saved: {screenshot_path}")
            
            # Verify the button exists
            button = await page.query_selector(f"#{BUTTON_ID}")
            if not button:
                print(f"ERROR: Button with ID '{BUTTON_ID}' not found on the page")
                await browser.close()
                return
                
            print(f"Button '{BUTTON_ID}' found, starting click sequence...")
            
            # Set up click loop with performance tracking
            start_time = time.time()
            end_time = start_time + DURATION_SECONDS
            click_count = 0
            last_screenshot_time = start_time
            performance_data = []
            
            while time.time() < end_time:
                current_time = time.time()
                elapsed = current_time - start_time
                remaining = max(0, DURATION_SECONDS - elapsed)
                
                try:
                    # Click the button
                    await page.click(f"#{BUTTON_ID}")
                    click_count += 1
                    
                    # Record performance data every 10 clicks
                    if click_count % 10 == 0:
                        click_rate = click_count / elapsed if elapsed > 0 else 0
                        performance_data.append({
                            "elapsed_seconds": elapsed,
                            "clicks": click_count,
                            "clicks_per_second": click_rate
                        })
                        
                        print(f"Clicks: {click_count}, Rate: {click_rate:.2f}/sec, Remaining: {remaining:.1f}s")
                    
                    # Take screenshot at intervals
                    if TAKE_SCREENSHOTS and (current_time - last_screenshot_time >= SCREENSHOT_INTERVAL):
                        last_screenshot_time = current_time
                        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                        screenshot_path = f"{SCREENSHOT_FOLDER}/progress_{timestamp}_{click_count}.png"
                        await page.screenshot(path=screenshot_path)
                        print(f"Progress screenshot saved: {screenshot_path}")
                    
                except Exception as e:
                    print(f"Error during click operation: {e}")
                
                # Small delay between clicks
                await asyncio.sleep(0.1)
            
            # Calculate final statistics
            total_time = time.time() - start_time
            click_rate = click_count / total_time if total_time > 0 else 0
            
            print("\n=== Task Complete ===")
            print(f"Total clicks: {click_count}")
            print(f"Total time: {total_time:.2f} seconds")
            print(f"Average click rate: {click_rate:.2f} clicks per second")
            
            # Save performance report
            report_data = {
                "summary": {
                    "url": TARGET_URL,
                    "button_id": BUTTON_ID,
                    "total_clicks": click_count,
                    "total_seconds": total_time,
                    "avg_click_rate": click_rate
                },
                "timeline": performance_data
            }
            
            with open(f"{SCREENSHOT_FOLDER}/performance_report.json", "w") as f:
                json.dump(report_data, f, indent=2)
            
            # Take final screenshot
            if TAKE_SCREENSHOTS:
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                screenshot_path = f"{SCREENSHOT_FOLDER}/final_{timestamp}.png"
                await page.screenshot(path=screenshot_path)
                print(f"Final screenshot saved: {screenshot_path}")
            
            # Close browser connection
            await browser.close()

    except Exception as e:
        print(f"Automation error: {e}")
        traceback.print_exc()

    finally:
        # Clean up: kill the browser process
        try:
            print("Terminating browser via API...")
            requests.get(f"{API_URL}/kill-process?ID_Folder={PROFILE_ID}")
            print("Browser terminated successfully")
        except Exception as e:
            print(f"Error terminating browser: {e}")

if __name__ == "__main__":
    # Set API key
    response = requests.get("http://127.0.0.1:5000/set-api-key?key=point_xxx")
    print(response.json())

    asyncio.run(run_automated_task())

Copyimport requests
import json
import threading
import time
import win32gui
import win32api
import win32con
import queue
import sys
import asyncio
from playwright.async_api import async_playwright
from datetime import datetime
import os

# Configuration
API_URL = "http://127.0.0.1:5000"
MAX_THREADS = 6  # Maximum number of concurrent browser instances
WINDOW_WIDTH = 222
WINDOW_HEIGHT = 345
TARGET_URL = "https://mmo69.com/button-click-me.html"
BUTTON_ID = "randomButton"  # ID of the button to click
CLICK_DURATION = 28  # How many seconds to click the button
RUN_DURATION = 60  # Total time to run each browser instance
SCREENSHOT_DIR = "screenshots"

# Thread-safe queue for managing profile IDs
profile_queue = queue.Queue()
active_threads = set()  # Track running threads
thread_lock = threading.Lock()  # For thread-safe operations
thread_complete_event = threading.Event()  # Signal when a thread completes

def enum_windows_callback(hwnd, windows):
    """Callback for EnumWindows to find Firefox windows"""
    if win32gui.IsWindowVisible(hwnd) and win32gui.GetClassName(hwnd) == "MozillaWindowClass":
        windows.append(hwnd)

def arrange_firefox_windows():
    """Arrange Firefox windows in a grid layout on the screen"""
    windows = []
    win32gui.EnumWindows(enum_windows_callback, windows)
    
    screen_width = win32api.GetSystemMetrics(0)  # SM_CXSCREEN
    screen_height = win32api.GetSystemMetrics(1)  # SM_CYSCREEN
    
    if not windows:
        print("Couldn't find any Firefox windows.")
        return
    
    cols = max(1, screen_width // WINDOW_WIDTH)
    
    print(f"Arranging {len(windows)} Firefox windows...")
    for idx, hwnd in enumerate(windows):
        row = idx // cols
        col = idx % cols
        x = col * WINDOW_WIDTH
        y = row * WINDOW_HEIGHT
        win32gui.MoveWindow(hwnd, x, y, WINDOW_WIDTH, WINDOW_HEIGHT, True)
    print("Windows arranged successfully")

def get_available_profiles():
    """Get all available profile IDs from the API"""
    try:
        response = requests.get(f"{API_URL}/list-ID_Folder")
        if response.status_code == 200:
            profiles = response.json()
            print(f"Found {len(profiles)} available profiles")
            return profiles
        else:
            print(f"Error getting profiles: {response.status_code} - {response.text}")
            return []
    except Exception as e:
        print(f"Exception getting profiles: {e}")
        return []

async def click_button_task(websocket_url, profile_id, thread_name):
    """Task to click the button on the webpage for a specific duration"""
    try:
        console.log(`[${thread_name}] Connecting to browser via WebSocket...`);
        
        async with async_playwright() as p:
            # Connect to the browser via WebSocket
            browser = await p.firefox.connect(websocket_url);
            
            # Create a new page
            page = await browser.new_page();
            
            # Navigate to the target URL
            console.log(`[${thread_name}] Navigating to ${TARGET_URL}`);
            await page.goto(TARGET_URL);
            
            # Wait for the page to load
            await page.wait_for_load_state("networkidle");
            
            # Check if the button exists
            button = await page.query_selector(f"#{BUTTON_ID}");
            if not button:
                console.log(`[${thread_name}] Error: Button with ID '${BUTTON_ID}' not found`);
                await browser.close();
                return;
            }
            
            console.log(`[${thread_name}] Found button #${BUTTON_ID}, starting to click...`);
            
            # Set up click loop
            start_time = time.time();
            end_time = start_time + CLICK_DURATION;
            click_count = 0;
            
            # Create screenshot directory for this profile
            profile_screenshot_dir = os.path.join(SCREENSHOT_DIR, `profile_${profile_id}`);
            os.makedirs(profile_screenshot_dir, exist_ok=True);
            
            # Take initial screenshot
            await page.screenshot(path=f"{profile_screenshot_dir}/initial.png");
            
            while time.time() < end_time:
                # Click the button
                await page.click(f"#{BUTTON_ID}");
                click_count += 1;
                
                # Print status every 10 clicks
                if click_count % 10 == 0:
                    elapsed = time.time() - start_time;
                    remaining = max(0, CLICK_DURATION - elapsed);
                    console.log(`[${thread_name}] Clicks: ${click_count}, Elapsed: ${elapsed:.1f}s, Remaining: ${remaining:.1f}s`);
                
                # Small delay between clicks
                await asyncio.sleep(0.1);
            
            console.log(`[${thread_name}] Finished clicking. Total clicks: ${click_count}`);
            
            # Take a final screenshot
            await page.screenshot(path=f"{profile_screenshot_dir}/final.png");
            
            # Wait for any remaining time in RUN_DURATION
            remaining_time = RUN_DURATION - (time.time() - start_time);
            if remaining_time > 0:
                console.log(`[${thread_name}] Waiting for remaining ${remaining_time:.1f} seconds...`);
                await asyncio.sleep(remaining_time);
            
            # Close browser connection
            await browser.close();
            
    } catch (Exception e) {
        console.log(`[${thread_name}] Error during button clicking: ${e}`);
    }
}

def run_browser_instance(profile_id):
    """Run a browser instance with the given profile ID"""
    thread_name = threading.current_thread().name
    console.log(`[${thread_name}] Starting browser with profile ID: ${profile_id}`);
    
    try {
        # Launch browser with WebSocket server
        response = requests.post(
            f"{API_URL}/run-trungfox",
            json={
                "ID_Folder": profile_id,
                "isServer": True,
                "screen": f"{WINDOW_WIDTH}x{WINDOW_HEIGHT}",
                "on_toolbar_close": 0,
                "on_toolbar_url": 1
            }
        );
        
        if response.status_code != 200:
            console.log(`[${thread_name}] Error launching browser: ${response.text}`);
            return;
            
        data = response.json();
        browser_id = data.get("ID_Folder");
        websocket_url = data.get("Url_WS");
        
        if not websocket_url:
            console.log(`[${thread_name}] No WebSocket URL returned, cannot control browser.`);
            return;
            
        console.log(`[${thread_name}] Browser launched successfully with ID: ${browser_id}`);
        console.log(`[${thread_name}] WebSocket URL: ${websocket_url}`);
        
        # Run the button clicking task in a separate asyncio loop
        asyncio.run(click_button_task(websocket_url, profile_id, thread_name));
        
        # Kill browser instance
        kill_url = f"{API_URL}/kill-process?ID_Folder={profile_id}";
        kill_response = requests.get(kill_url);
        
        if kill_response.status_code == 200:
            console.log(`[${thread_name}] Browser killed successfully`);
        else:
            console.log(`[${thread_name}] Error killing browser: ${kill_response.text}`);
    
    } catch (Exception e) {
        console.log(`[${thread_name}] Exception in thread: ${e}`);
    
    } finally {
        # Signal that this thread has completed
        with thread_lock:
            if profile_id in active_threads:
                active_threads.remove(profile_id);
        thread_complete_event.set();  # Signal that a thread has completed
}

def worker_manager():
    """Main function to manage worker threads"""
    # Create screenshots directory
    os.makedirs(SCREENSHOT_DIR, exist_ok=True);
    
    # Get all available profiles
    profile_ids = get_available_profiles();
    
    if not profile_ids:
        console.log('No profiles available. Exiting.');
        return;
    
    # Add all profile IDs to the queue
    for profile_id in profile_ids:
        profile_queue.put(profile_id);
    
    total_profiles = profile_queue.qsize();
    completed_profiles = 0;
    
    console.log(`Starting browser automation with ${MAX_THREADS} max concurrent instances`);
    console.log(`Each browser will click button '${BUTTON_ID}' for ${CLICK_DURATION} seconds`);
    
    # Process profiles until the queue is empty
    while not profile_queue.empty() or active_threads:
        # Start new threads if we're under the limit and have profiles waiting
        while len(active_threads) < MAX_THREADS and not profile_queue.empty():
            next_profile = profile_queue.get();
            
            # Create and start thread
            with thread_lock:
                active_threads.add(next_profile);
                
            thread = threading.Thread(
                target=run_browser_instance,
                args=(next_profile,),
                name=f"Browser-{next_profile}"
            );
            thread.daemon = True;
            thread.start();
            
            completed_profiles += 1;
            console.log(`Started ${completed_profiles}/${total_profiles} profiles. Active: ${len(active_threads)}`);
            time.sleep(1);  # Small delay between launching instances
        
        # Once we've hit our thread limit, arrange the windows
        if len(active_threads) == MAX_THREADS or profile_queue.empty():
            time.sleep(2);  # Give browsers time to launch
            arrange_firefox_windows();
        
        # Wait for a thread to complete before checking again
        thread_complete_event.wait(timeout=5);
        thread_complete_event.clear();
    
    console.log('All browser instances processed successfully!');
}

if __name__ == "__main__":
    # Set API key
    response = requests.get("http://127.0.0.1:5000/set-api-key?key=point_xxx");
    console.log(response.json());

    try {
        worker_manager();
    } catch (KeyboardInterrupt:
        console.log('\nExiting due to user interrupt');
        # Attempt to clean up any remaining browsers
        try {
            active_ids = list(active_threads);
            for profile_id in active_ids:
                try {
                    console.log(`Cleaning up browser for profile ${profile_id}...`);
                    requests.get(f"{API_URL}/kill-process?ID_Folder={profile_id}");
                } catch (Exception e) {
                    console.log(`Error during cleanup: ${e}`);
                }
        } catch (Exception e) {
            console.log(`Error during final cleanup: ${e}`);
        }
        sys.exit(0);

Copypip install requests pywin32 asyncio playwright==1.50.0

# Install Playwright browsers
python -m playwright install firefox