Update app.py

app.py

@@ -79,9 +79,147 @@ def verify_playwright_installation():
     logger.warning("Playwright browser not found in expected locations")
     return False
 
+def human_delay(min_seconds=1, max_seconds=5):
+    """Wait for a random amount of time to simulate human behavior"""
+    delay = min_seconds + random.random() * (max_seconds - min_seconds)
+    time.sleep(delay)
+    return delay
+
+def human_scroll(page, min_pixels=100, max_pixels=800):
+    """Scroll a random amount in a human-like manner"""
+    # Decide scroll direction (occasionally scroll up to look more human)
+    direction = 1 if random.random() < 0.9 else -1
+    
+    # Decide scroll amount
+    scroll_amount = direction * random.randint(min_pixels, max_pixels)
+    
+    # Sometimes do a smooth scroll, sometimes do a quick scroll
+    if random.random() < 0.7:
+        # Smooth scroll
+        page.evaluate(f"""() => {{
+            window.scrollBy({{
+                top: {scroll_amount},
+                left: 0,
+                behavior: 'smooth'
+            }});
+        }}""")
+    else:
+        # Quick scroll
+        page.evaluate(f"window.scrollBy(0, {scroll_amount});")
+    
+    # Sometimes perform multiple small scrolls instead of one big one
+    if random.random() < 0.3 and direction > 0:
+        human_delay(0.5, 1.5)
+        second_amount = random.randint(50, 200)
+        page.evaluate(f"window.scrollBy(0, {second_amount});")
+    
+    return scroll_amount
+
+def human_click(page, x, y, click_type="normal"):
+    """Perform a more human-like click with mouse movement and occasional double-clicks"""
+    
+    # Move to a random position first (sometimes)
+    if random.random() < 0.6:
+        random_x = random.randint(100, 1000)
+        random_y = random.randint(100, 600)
+        page.mouse.move(random_x, random_y)
+        human_delay(0.1, 0.5)
+    
+    # Move to target with slight randomness
+    jitter_x = x + random.randint(-5, 5)
+    jitter_y = y + random.randint(-3, 3)
+    page.mouse.move(jitter_x, jitter_y)
+    human_delay(0.1, 0.3)
+    
+    # Click behavior
+    if click_type == "double" or (click_type == "normal" and random.random() < 0.1):
+        # Double click (rarely)
+        page.mouse.dblclick(jitter_x, jitter_y)
+    elif click_type == "slow" or (click_type == "normal" and random.random() < 0.2):
+        # Slow click (sometimes)
+        page.mouse.down()
+        human_delay(0.1, 0.4)
+        page.mouse.up()
+    else:
+        # Normal click
+        page.mouse.click(jitter_x, jitter_y)
+    
+    # Sometimes move mouse after clicking
+    if random.random() < 0.4:
+        human_delay(0.2, 0.6)
+        after_x = jitter_x + random.randint(-100, 100)
+        after_y = jitter_y + random.randint(-80, 80)
+        page.mouse.move(after_x, after_y)
+
+def handle_automation_warning(page, status_updates):
+    """Handle Instagram's automation warning dialog"""
+    try:
+        # Check for the warning dialog
+        automation_warning_selectors = [
+            "text=We suspect automated behavior",
+            "text=automated behavior on your account",
+            "button:has-text('Dismiss')",
+            "button:has-text('Ok')",
+            "button:has-text('Close')"
+        ]
+        
+        for selector in automation_warning_selectors:
+            if page.query_selector(selector):
+                status_updates.append("Detected automation warning dialog")
+                
+                # Take a screenshot of the warning
+                try:
+                    warning_screenshot = f"screenshots/automation_warning_{int(time.time())}.png"
+                    page.screenshot(path=warning_screenshot)
+                    status_updates.append("Automation warning screenshot saved")
+                except Exception as e:
+                    status_updates.append(f"Error taking warning screenshot: {str(e)}")
+                
+                # Try to find the dismiss button using various selectors
+                dismiss_selectors = [
+                    "button:has-text('Dismiss')",
+                    "button:has-text('Ok')",
+                    "button:has-text('Close')",
+                    "button[type='button']"
+                ]
+                
+                for dismiss_selector in dismiss_selectors:
+                    try:
+                        dismiss_button = page.query_selector(dismiss_selector)
+                        if dismiss_button:
+                            # Get button coordinates
+                            coords = dismiss_button.bounding_box()
+                            x = coords['x'] + coords['width'] / 2
+                            y = coords['y'] + coords['height'] / 2
+                            
+                            # Click using human-like behavior
+                            human_delay(1, 3)  # Think before dismissing
+                            human_click(page, x, y)
+                            status_updates.append(f"Dismissed automation warning using: {dismiss_selector}")
+                            
+                            # Wait after dismissing
+                            human_delay(2, 4)
+                            return True
+                    except Exception as e:
+                        logger.debug(f"Dismiss button {dismiss_selector} failed: {str(e)}")
+                
+                # If no buttons found, try clicking in the middle of the screen
+                if random.random() < 0.5:
+                    human_delay(1, 2)
+                    human_click(page, 640, 360)  # Click in middle of screen
+                    status_updates.append("Attempted to dismiss by clicking middle of screen")
+                    human_delay(2, 3)
+                
+                return True
+        
+        return False  # No warning detected
+    except Exception as e:
+        status_updates.append(f"Error handling automation warning: {str(e)}")
+        return False
+
 def run_instagram_liker(username, password, max_likes):
     """Run the Instagram auto-liker with Playwright"""
-    status_updates = ["Starting Instagram Auto-Liker with Playwright..."]
+    status_updates = ["Starting Instagram Auto-Liker with human-like behavior..."]
     image_path = save_placeholder_image("start")
     
     # Check if browsers are installed, if not install them
@@ -113,7 +251,11 @@ def run_instagram_liker(username, password, max_likes):
         status_updates.append("Launching Playwright browser...")
         with sync_playwright() as p:
             try:
-                # Launch chromium with specific arguments to ensure it works in containerized environments
+                # Use random viewport size to look less like automation
+                viewport_width = random.choice([1280, 1366, 1440, 1536, 1600, 1920])
+                viewport_height = random.choice([720, 768, 800, 864, 900, 1080])
+                
+                # Launch chromium with specific arguments
                 browser = p.chromium.launch(
                     headless=True,
                     args=[
@@ -125,18 +267,39 @@ def run_instagram_liker(username, password, max_likes):
                     ]
                 )
                 
-                # Create a new browser context
+                # Create a browser context with random user agent
+                user_agents = [
+                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
+                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
+                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0'
+                ]
+                user_agent = random.choice(user_agents)
+                
                 context = browser.new_context(
-                    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',
-                    viewport={'width': 1280, 'height': 720}
+                    user_agent=user_agent,
+                    viewport={'width': viewport_width, 'height': viewport_height},
+                    locale=random.choice(['en-US', 'en-GB', 'en-CA']),
+                    timezone_id=random.choice(['America/New_York', 'America/Los_Angeles', 'Europe/London', 'Asia/Tokyo'])
                 )
                 
+                # Set random geolocation (if allowed)
+                if random.random() < 0.5:
+                    try:
+                        context.set_geolocation({
+                            'latitude': random.uniform(30, 50),
+                            'longitude': random.uniform(-120, -70)
+                        })
+                    except:
+                        pass
+                
                 # Open a new page
                 page = context.new_page()
                 
                 # Test browser by visiting Google
                 status_updates.append("Testing browser connection...")
                 page.goto("https://www.google.com")
+                human_delay(1, 3)  # Wait like a human
                 status_updates.append(f"Browser working. Title: {page.title()}")
                 
                 # Take a screenshot
@@ -148,10 +311,14 @@ def run_instagram_liker(username, password, max_likes):
                 except Exception as e:
                     status_updates.append(f"Error taking screenshot: {str(e)}")
                 
-                # Navigate to Instagram
+                # Navigate to Instagram with delay
                 status_updates.append("Navigating to Instagram...")
                 page.goto("https://www.instagram.com/")
-                page.wait_for_load_state('networkidle')
+                
+                # Wait for load with natural variation
+                wait_strategy = random.choice(['domcontentloaded', 'networkidle', 'load'])
+                page.wait_for_load_state(wait_strategy)
+                human_delay(2, 5)  # Additional human-like wait
                 
                 # Take a screenshot to see what's happening
                 try:
@@ -162,22 +329,25 @@ def run_instagram_liker(username, password, max_likes):
                 except Exception as e:
                     status_updates.append(f"Error taking screenshot: {str(e)}")
                 
-                # Introduce delay to let the page fully load
-                status_updates.append("Waiting for page to fully load...")
-                page.wait_for_timeout(5000)
+                # Random initial interactions (to look human)
+                if random.random() < 0.7:
+                    # Maybe move mouse randomly on the page
+                    for _ in range(random.randint(1, 3)):
+                        random_x = random.randint(100, viewport_width - 100)
+                        random_y = random.randint(100, viewport_height - 100)
+                        page.mouse.move(random_x, random_y)
+                        human_delay(0.3, 1.5)
                 
-                # Take another screenshot after waiting
-                try:
-                    loaded_screenshot = f"screenshots/fully_loaded_{int(time.time())}.png"
-                    page.screenshot(path=loaded_screenshot)
-                    image_path = loaded_screenshot
-                    status_updates.append("Page fully loaded, screenshot saved")
-                except Exception as e:
-                    status_updates.append(f"Error taking screenshot: {str(e)}")
+                # Maybe scroll a bit before doing anything
+                if random.random() < 0.5:
+                    human_scroll(page, 100, 300)
+                    human_delay(1, 3)
                 
-                # Try clicking outside any potential popups
+                # Click outside any potential popups (more natural location)
                 try:
-                    page.mouse.click(10, 10)
+                    random_x = random.randint(50, 150)
+                    random_y = random.randint(50, 100)
+                    human_click(page, random_x, random_y)
                     status_updates.append("Clicked to dismiss any initial popups")
                 except Exception as e:
                     status_updates.append(f"Click error: {str(e)}")
@@ -194,10 +364,20 @@ def run_instagram_liker(username, password, max_likes):
                     
                     for button_selector in cookie_buttons:
                         try:
-                            if page.query_selector(button_selector):
-                                page.click(button_selector)
+                            button = page.query_selector(button_selector)
+                            if button:
+                                # Get coordinates
+                                coords = button.bounding_box()
+                                x = coords['x'] + coords['width'] / 2
+                                y = coords['y'] + coords['height'] / 2
+                                
+                                # Human-like delay before clicking
+                                human_delay(0.8, 2)
+                                
+                                # Human-like click
+                                human_click(page, x, y)
                                 status_updates.append(f"Clicked cookie consent button: {button_selector}")
-                                page.wait_for_timeout(2000)
+                                human_delay(1, 3)
                                 break
                         except Exception as e:
                             logger.debug(f"Button {button_selector} not found: {str(e)}")
@@ -205,7 +385,7 @@ def run_instagram_liker(username, password, max_likes):
                 except Exception as e:
                     status_updates.append(f"Cookie dialog handling: {str(e)}")
                 
-                # Look for the login form
+                # Interact with login form like a human
                 status_updates.append("Looking for login form...")
                 
                 # Take a screenshot to see what we're working with
@@ -217,6 +397,10 @@ def run_instagram_liker(username, password, max_likes):
                 except Exception as e:
                     status_updates.append(f"Error taking screenshot: {str(e)}")
                 
+                # Check for automation warning (might appear right away)
+                if handle_automation_warning(page, status_updates):
+                    status_updates.append("Handled initial automation warning")
+                
                 # Try multiple selectors for username input
                 username_selectors = [
                     "input[name='username']",
@@ -276,10 +460,34 @@ def run_instagram_liker(username, password, max_likes):
                     browser.close()
                     return "\n".join(status_updates), image_path
                 
-                # Enter credentials
+                # Enter credentials like a human would
                 status_updates.append(f"Entering username: {username}")
-                username_field.fill(username)
-                password_field.fill(password)
+                
+                # Click the username field first (human behavior)
+                username_coords = username_field.bounding_box()
+                username_x = username_coords['x'] + username_coords['width'] / 2
+                username_y = username_coords['y'] + username_coords['height'] / 2
+                human_click(page, username_x, username_y)
+                
+                # Type username with human-like timing
+                for char in username:
+                    username_field.type(char, delay=random.randint(100, 300))
+                    time.sleep(random.uniform(0.01, 0.15))
+                
+                # Sometimes humans pause after entering username
+                human_delay(0.5, 2)
+                
+                # Now click password field
+                password_coords = password_field.bounding_box()
+                password_x = password_coords['x'] + password_coords['width'] / 2
+                password_y = password_coords['y'] + password_coords['height'] / 2
+                human_click(page, password_x, password_y)
+                
+                # Type password with human-like timing
+                for char in password:
+                    password_field.type(char, delay=random.randint(100, 300))
+                    time.sleep(random.uniform(0.01, 0.15))
+                
                 status_updates.append("Credentials entered")
                 
                 # Take a screenshot of filled form
@@ -321,13 +529,20 @@ def run_instagram_liker(username, password, max_likes):
                     browser.close()
                     return "\n".join(status_updates), image_path
                 
-                # Click login button
+                # Click login button like a human
                 status_updates.append("Clicking login button...")
-                login_button.click()
+                button_coords = login_button.bounding_box()
+                button_x = button_coords['x'] + button_coords['width'] / 2
+                button_y = button_coords['y'] + button_coords['height'] / 2
+                
+                # Pause briefly before clicking (human behavior)
+                human_delay(0.5, 1.5)
+                human_click(page, button_x, button_y)
                 
-                # Wait for navigation to complete
+                # Wait for navigation to complete with human-like variation
                 status_updates.append("Waiting for login process...")
-                page.wait_for_timeout(5000)
+                wait_time = random.uniform(3, 7)
+                time.sleep(wait_time)
                 
                 # Take post-login screenshot
                 try:
@@ -338,6 +553,10 @@ def run_instagram_liker(username, password, max_likes):
                 except Exception as e:
                     status_updates.append(f"Error taking screenshot: {str(e)}")
                 
+                # Check for automation warning after login
+                if handle_automation_warning(page, status_updates):
+                    status_updates.append("Handled post-login automation warning")
+                
                 # Check if login was successful
                 current_url = page.url
                 if "/accounts/login" in current_url or "/login" in current_url:
@@ -372,7 +591,7 @@ def run_instagram_liker(username, password, max_likes):
                 
                 # Handle "Save Login Info" popup if it appears
                 try:
-                    page.wait_for_timeout(2000)  # Wait a bit for dialog to appear
+                    human_delay(1, 3)  # Wait like a human for popup to appear
                     
                     save_info_selectors = [
                         "text=Save Login Info",
@@ -395,15 +614,24 @@ def run_instagram_liker(username, password, max_likes):
                             break
                     
                     if dialog_found:
+                        # Wait like a human would before deciding
+                        human_delay(1, 4)
+                        
                         # Try to click "Not Now"
                         dismissed = False
                         for not_now in not_now_selectors:
                             try:
                                 button = page.query_selector(not_now)
                                 if button:
-                                    button.click()
+                                    # Get button coordinates
+                                    coords = button.bounding_box()
+                                    x = coords['x'] + coords['width'] / 2
+                                    y = coords['y'] + coords['height'] / 2
+                                    
+                                    # Click like a human
+                                    human_click(page, x, y)
                                     status_updates.append(f"Dismissed 'Save Login Info' popup using: {not_now}")
-                                    page.wait_for_timeout(2000)
+                                    human_delay(1, 3)
                                     dismissed = True
                                     break
                             except Exception as e:
@@ -428,7 +656,7 @@ def run_instagram_liker(username, password, max_likes):
                 
                 # Handle notifications popup if it appears
                 try:
-                    page.wait_for_timeout(2000)  # Wait a bit for dialog to appear
+                    human_delay(1, 3)  # Wait like a human
                     
                     notifications_selectors = [
                         "text=Turn on Notifications",
@@ -451,15 +679,24 @@ def run_instagram_liker(username, password, max_likes):
                             break
                     
                     if dialog_found:
+                        # Wait like a human before deciding
+                        human_delay(1, 4)
+                        
                         # Try to click "Not Now"
                         dismissed = False
                         for not_now in not_now_selectors:
                             try:
                                 button = page.query_selector(not_now)
                                 if button:
-                                    button.click()
+                                    # Get button coordinates
+                                    coords = button.bounding_box()
+                                    x = coords['x'] + coords['width'] / 2
+                                    y = coords['y'] + coords['height'] / 2
+                                    
+                                    # Click like a human
+                                    human_click(page, x, y)
                                     status_updates.append(f"Dismissed notifications popup using: {not_now}")
-                                    page.wait_for_timeout(2000)
+                                    human_delay(1, 3)
                                     dismissed = True
                                     break
                             except Exception as e:
@@ -482,148 +719,234 @@ def run_instagram_liker(username, password, max_likes):
                 except Exception as e:
                     status_updates.append(f"Error taking screenshot: {str(e)}")
                 
+                # Check for automation warning again
+                if handle_automation_warning(page, status_updates):
+                    status_updates.append("Handled feed automation warning")
+                
                 status_updates.append("Successfully navigated to Instagram feed!")
                 
-                # Start liking posts
-                status_updates.append(f"Starting to like posts (target: {max_likes})...")
+                # Start liking posts with human-like behavior
+                likes_goal = min(max_likes, random.randint(max_likes - 3, max_likes + 3))
+                status_updates.append(f"Starting to like posts (target: {likes_goal})...")
                 
                 # Like posts
                 likes_count = 0
                 scroll_count = 0
-                max_scrolls = 30
+                max_scrolls = random.randint(25, 35)
                 
                 # Wait for the feed to load fully before looking for posts
-                page.wait_for_timeout(3000)
-                
-                # Try to find posts with multiple selectors
-                article_selectors = [
-                    "article", 
-                    "div[role='presentation']", 
-                    "div[data-testid='post-content']",
-                    "div._aac4._aac5._aac6", 
-                    "div._ab6k"
-                ]
-                
-                article_found = False
-                for selector in article_selectors:
+                # Function to find and like posts with human-like behavior
+                def find_and_like_post():
+                    """Find and like a single post with human-like behavior"""
                     try:
-                        if page.query_selector(selector):
-                            article_found = True
-                            status_updates.append(f"Found posts using selector: {selector}")
-                            break
-                    except Exception as e:
-                        logger.debug(f"Article selector {selector} failed: {str(e)}")
-                
-                if not article_found:
-                    status_updates.append("Could not find posts on feed. Instagram may have changed their interface.")
-                    browser.close()
-                    return "\n".join(status_updates), image_path
-                
-                # Like one post at a time with full scroll stabilization
-                while likes_count < max_likes and scroll_count < max_scrolls:
-                    try:
-                        # Take a screenshot before each scroll to aid debugging
-                        if scroll_count % 5 == 0:
-                            try:
-                                scroll_screenshot = f"screenshots/scroll_{scroll_count}_{int(time.time())}.png"
-                                page.screenshot(path=scroll_screenshot)
-                                image_path = scroll_screenshot
-                            except Exception as e:
-                                status_updates.append(f"Error taking scroll screenshot: {str(e)}")
-                        
-                        # Wait for the page to be stable after scrolling
-                        page.wait_for_timeout(2000)
-                        
-                        # IMPORTANT FIX: Evaluate the selector directly in the page context to get fresh elements
-                        # This addresses the "Element is not attached to the DOM" issue
-                        like_buttons = page.evaluate("""() => {
-                            // Try different selectors to find like buttons that haven't been clicked yet
+                        # Use JavaScript to find like buttons directly in the DOM
+                        like_button_info = page.evaluate("""() => {
+                            // Try different selectors for like buttons (not already liked)
                             const selectors = [
+                                // Generic selectors for Instagram's like buttons
+                                "article svg[aria-label='Like']",  
                                 "article section svg[aria-label='Like']",
-                                "article svg[aria-label='Like']",
                                 "svg[aria-label='Like']",
                                 "span[class*='_aamw'] svg[aria-label='Like']",
-                                "article button[type='button'] svg:not([aria-label='Unlike'])"
+                                "button svg[aria-label='Like']",
+                                // Looser selector that might catch more
+                                "article button[type='button']:not([aria-pressed='true'])"
                             ];
                             
-                            for (const selector of selectors) {
-                                const buttons = Array.from(document.querySelectorAll(selector));
-                                if (buttons.length > 0) {
-                                    // We need to find the actual button elements (parents of the SVGs)
-                                    const buttonElements = buttons.map(svg => {
-                                        // Find closest button parent
-                                        return svg.closest('button');
-                                    }).filter(btn => btn !== null);
+                            // Shuffle the selectors to add randomness
+                            const shuffled = selectors.sort(() => 0.5 - Math.random());
+                            
+                            // Try each selector
+                            for (const selector of shuffled) {
+                                const elements = Array.from(document.querySelectorAll(selector));
+                                
+                                if (elements.length > 0) {
+                                    // Shuffle the elements to add randomness
+                                    const shuffledElements = elements.sort(() => 0.5 - Math.random());
+                                    
+                                    // Choose a random element from the first few found
+                                    const randomIndex = Math.floor(Math.random() * Math.min(3, shuffledElements.length));
+                                    const element = shuffledElements[randomIndex];
                                     
-                                    if (buttonElements.length > 0) {
-                                        // Return info about the first valid button
-                                        const button = buttonElements[0];
-                                        const rect = button.getBoundingClientRect();
+                                    // Find the actual clickable button (might be a parent)
+                                    let button = element;
+                                    if (element.tagName.toLowerCase() === 'svg') {
+                                        button = element.closest('button') || element;
+                                    }
+                                    
+                                    // Get element position
+                                    const rect = button.getBoundingClientRect();
+                                    
+                                    // Check if it's visible in viewport
+                                    if (rect.top >= 0 && rect.left >= 0 && 
+                                        rect.bottom <= window.innerHeight && 
+                                        rect.right <= window.innerWidth) {
                                         
                                         return {
                                             found: true,
-                                            count: buttonElements.length,
                                             x: rect.x + rect.width / 2,
-                                            y: rect.y + rect.height / 2
+                                            y: rect.y + rect.height / 2,
+                                            selector: selector,
+                                            totalFound: elements.length
                                         };
                                     }
                                 }
                             }
                             
-                            return { found: false, count: 0 };
+                            return { found: false };
                         }""")
                         
-                        if like_buttons['found']:
-                            status_updates.append(f"Found {like_buttons['count']} like buttons on scroll {scroll_count}")
+                        if like_button_info['found']:
+                            # Wait a bit before clicking (as if examining the post)
+                            human_delay(1, 4)
                             
-                            # Click the first like button directly by coordinates
+                            # Sometimes explore the post before liking
+                            if random.random() < 0.3:
+                                # Move mouse around post area
+                                explore_x = like_button_info['x'] + random.randint(-100, 100)
+                                explore_y = like_button_info['y'] + random.randint(-100, 100)
+                                page.mouse.move(explore_x, explore_y)
+                                human_delay(0.5, 2)
+                            
+                            # Take screenshot before click
                             try:
-                                # Take pre-click screenshot
+                                before_like_screenshot = f"screenshots/before_like_{likes_count+1}_{int(time.time())}.png"
+                                page.screenshot(path=before_like_screenshot)
+                            except:
+                                pass
+                            
+                            # Click with human-like behavior
+                            like_x = like_button_info['x']
+                            like_y = like_button_info['y']
+                            
+                            # Add slight randomness to click position
+                            human_click(page, like_x, like_y)
+                            
+                            # Wait for the like to register
+                            human_delay(0.5, 2)
+                            
+                            return True
+                        
+                        return False
+                    except Exception as e:
+                        status_updates.append(f"Error finding/clicking like button: {str(e)}")
+                        return False
+                
+                # Variable to track consecutive failures
+                consecutive_failures = 0
+                last_successful_like_time = time.time()
+                
+                # Main loop for scrolling and liking
+                while likes_count < likes_goal and scroll_count < max_scrolls:
+                    try:
+                        # Take screenshot occasionally to track progress
+                        if scroll_count % 5 == 0:
+                            try:
+                                progress_screenshot = f"screenshots/progress_{scroll_count}_{int(time.time())}.png"
+                                page.screenshot(path=progress_screenshot)
+                                image_path = progress_screenshot
+                            except:
+                                pass
+                        
+                        # First check for automation warnings
+                        if handle_automation_warning(page, status_updates):
+                            status_updates.append(f"Handled automation warning during scrolling (#{scroll_count})")
+                            human_delay(3, 6)  # Longer wait after handling warning
+                        
+                        # Try to like a post with human-like behavior
+                        if find_and_like_post():
+                            likes_count += 1
+                            consecutive_failures = 0
+                            last_successful_like_time = time.time()
+                            status_updates.append(f"Liked post {likes_count}/{likes_goal}")
+                            
+                            # Take post-like screenshot occasionally
+                            if random.random() < 0.3:
                                 try:
-                                    pre_like_screenshot = f"screenshots/pre_like_{likes_count}_{int(time.time())}.png"
-                                    page.screenshot(path=pre_like_screenshot)
-                                except Exception as e:
-                                    status_updates.append(f"Error taking pre-like screenshot: {str(e)}")
-                                
-                                # Click by coordinates rather than on the element
-                                page.mouse.click(like_buttons['x'], like_buttons['y'])
+                                    after_like_screenshot = f"screenshots/after_like_{likes_count}_{int(time.time())}.png"
+                                    page.screenshot(path=after_like_screenshot)
+                                    image_path = after_like_screenshot
+                                except:
+                                    pass
+                            
+                            # Calculate a random human-like delay between likes
+                            # Occasionally take longer breaks to seem more human
+                            if random.random() < 0.15:  # 15% chance of a longer break
+                                wait_time = random.uniform(5, 15)
+                                status_updates.append(f"Taking a short break ({wait_time:.1f}s)")
+                                time.sleep(wait_time)
+                            else:
+                                # Normal delay between likes (variable)
+                                human_delay(2, 7)
+                            
+                            # Occasionally interact with the feed in other ways to seem human
+                            if random.random() < 0.25:  # 25% chance after liking
+                                random_action = random.choice([
+                                    "move_mouse_random",
+                                    "small_scroll_up",
+                                    "pause",
+                                    "long_hover"
+                                ])
                                 
-                                likes_count += 1
-                                status_updates.append(f"Liked post {likes_count}/{max_likes}")
+                                if random_action == "move_mouse_random":
+                                    # Move mouse to random position
+                                    random_x = random.randint(100, viewport_width - 100)
+                                    random_y = random.randint(100, viewport_height - 100)
+                                    page.mouse.move(random_x, random_y)
+                                    human_delay(0.5, 2)
                                 
-                                # Take post-click screenshot
-                                try:
-                                    post_like_screenshot = f"screenshots/post_like_{likes_count}_{int(time.time())}.png"
-                                    page.screenshot(path=post_like_screenshot)
-                                    image_path = post_like_screenshot
-                                except Exception as e:
-                                    status_updates.append(f"Error taking post-like screenshot: {str(e)}")
+                                elif random_action == "small_scroll_up":
+                                    # Sometimes scroll back up a bit
+                                    page.evaluate("window.scrollBy(0, -100);")
+                                    human_delay(0.5, 2)
+                                    
+                                elif random_action == "pause":
+                                    # Just pause for a moment
+                                    human_delay(1, 3)
+                                    
+                                elif random_action == "long_hover":
+                                    # Hover over something for a bit
+                                    random_x = random.randint(200, viewport_width - 200)
+                                    random_y = random.randint(200, viewport_height - 200)
+                                    page.mouse.move(random_x, random_y)
+                                    human_delay(2, 4)
+                        else:
+                            consecutive_failures += 1
+                            status_updates.append(f"No new like buttons found on scroll {scroll_count}")
+                            
+                            # If we haven't found anything to like in a while, check if we need to scroll
+                            if consecutive_failures >= 3 or (time.time() - last_successful_like_time > 20):
+                                # Scroll down to load more content
+                                scroll_amount = human_scroll(page, 
+                                    min_pixels=random.randint(200, 400), 
+                                    max_pixels=random.randint(500, 800)
+                                )
+                                status_updates.append(f"Scrolled down {scroll_amount} pixels to load more posts")
                                 
-                                # Add a random delay between likes (2-4 seconds)
-                                delay = 2000 + random.randint(0, 2000)
-                                page.wait_for_timeout(delay)
+                                # Wait for new content with variable timing
+                                wait_time = random.uniform(2, 5)
+                                time.sleep(wait_time)
                                 
-                            except Exception as e:
-                                status_updates.append(f"Error clicking like button: {str(e)}")
-                        else:
-                            status_updates.append(f"No like buttons found on scroll {scroll_count}")
+                                # Reset failure counter after scrolling
+                                consecutive_failures = 0
+                                scroll_count += 1
+                            else:
+                                # Small wait before trying again
+                                human_delay(1, 3)
                         
-                        # Scroll down to load more
-                        # Use a smaller scroll distance to ensure we don't miss posts
-                        page.evaluate("window.scrollBy(0, 500);")
-                        status_updates.append("Scrolled down to load more posts")
+                        # Occasionally take a longer break to seem more human
+                        if likes_count > 0 and likes_count % 5 == 0 and random.random() < 0.7:
+                            break_time = random.uniform(8, 20)
+                            status_updates.append(f"Taking a longer break after {likes_count} likes ({break_time:.1f}s)")
+                            time.sleep(break_time)
                         
-                        # Wait for new content to load
-                        page.wait_for_load_state('networkidle', timeout=5000)
-                        
-                        # Variable delay after scrolling (2-3 seconds)
-                        delay = 2000 + random.randint(0, 1000)
-                        page.wait_for_timeout(delay)
-                        
-                        scroll_count += 1
+                        # Verify we haven't exceeded the target
+                        if likes_count >= likes_goal:
+                            status_updates.append(f"Reached target of {likes_goal} likes")
+                            break
                         
                     except Exception as e:
-                        status_updates.append(f"Error during scroll/like cycle: {str(e)}")
+                        status_updates.append(f"Error during like cycle: {str(e)}")
                         # Take error screenshot
                         try:
                             error_screenshot = f"screenshots/error_{int(time.time())}.png"
@@ -632,8 +955,8 @@ def run_instagram_liker(username, password, max_likes):
                         except:
                             pass
                         
-                        # Continue to the next scroll despite errors
-                        scroll_count += 1
+                        # Continue despite errors after a pause
+                        human_delay(3, 6)
                 
                 # Final status
                 final_message = f"Finished! Liked {likes_count} posts."
@@ -676,7 +999,7 @@ def run_instagram_liker(username, password, max_likes):
 # Gradio Interface
 def create_interface():
     with gr.Blocks(title="Instagram Auto-Liker") as app:
-        gr.Markdown("# Instagram Auto-Liker (Playwright)")
+        gr.Markdown("# Instagram Auto-Liker (Human-like)")
         gr.Markdown("""
         Enter your Instagram credentials and the number of posts to like.
         
@@ -688,7 +1011,7 @@ def create_interface():
             with gr.Column(scale=1):
                 username = gr.Textbox(label="Instagram Username")
                 password = gr.Textbox(label="Instagram Password", type="password")
-                max_likes = gr.Slider(minimum=1, maximum=100, value=10, step=1, label="Number of Posts to Like")
+                max_likes = gr.Slider(minimum=1, maximum=50, value=10, step=1, label="Number of Posts to Like")
                 submit_btn = gr.Button("Start Liking Posts")
             
             with gr.Column(scale=2):