chore: Disable debug images and video recording for production

Author: goxofy

README.md

@@ -97,5 +97,7 @@ python3 startup.py
 | `MQTT_USER` | MQTT 用户名 | (空) |
 | `MQTT_PASSWORD` | MQTT 密码 | (空) |
 | `JOB_START_TIME` | 每天定时运行时间 | `07:00` |
-| `SLIDER_OFFSET` | 验证码滑块偏移微调，如果持续登录报错，考虑调整这个数值（-10 ~ 10） | `5` |
+| `SLIDER_OFFSET` | 验证码滑块偏移微调（-2 ~ 10） | `5` |
 | `IGNORE_USER_ID` | 忽略的户号(逗号分隔) | (空) |
+
+*SLIDER_OFFSET 这个参数非常重要！如果持续登录报错，请不断调整这个数值，我这里是 5 最合适*

captcha_solver.py

@@ -103,7 +103,7 @@ def solve_gap(self, image):
             model_width = 416
             scale_ratio = original_width / model_width
 
-            x_coordinate = boxes[..., :4].astype(np.int32)[0][0]
-            scaled_x = int(x_coordinate * scale_ratio)
+            x_coordinate = boxes[..., :4][0][0] # Keep as float
+            scaled_x = x_coordinate * scale_ratio
 
             return scaled_x

recorder.py

@@ -0,0 +1,69 @@
+import cv2
+import numpy as np
+import threading
+import time
+import logging
+import os
+
+class ScreenRecorder:
+    def __init__(self, driver, output_path, fps=5.0):
+        self.driver = driver
+        self.output_path = output_path
+        self.fps = fps
+        self.stop_event = threading.Event()
+        self.thread = None
+        self.logger = logging.getLogger(__name__)
+
+    def start(self):
+        self.stop_event.clear()
+        self.thread = threading.Thread(target=self._record_loop)
+        self.thread.start()
+        self.logger.info(f"Started screen recording to {self.output_path}")
+
+    def stop(self):
+        if self.thread and self.thread.is_alive():
+            self.stop_event.set()
+            self.thread.join()
+            self.logger.info(f"Stopped screen recording. Saved to {self.output_path}")
+
+    def _record_loop(self):
+        video_writer = None
+        
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(self.output_path), exist_ok=True)
+
+        try:
+            while not self.stop_event.is_set():
+                start_time = time.time()
+                
+                try:
+                    # Capture screenshot as PNG binary
+                    png_data = self.driver.get_screenshot_as_png()
+                    
+                    # Convert to numpy array
+                    nparr = np.frombuffer(png_data, np.uint8)
+                    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+                    
+                    if img is None:
+                        continue
+
+                    # Initialize video writer on first frame
+                    if video_writer is None:
+                        height, width, _ = img.shape
+                        # MJPG is more compatible in headless docker
+                        fourcc = cv2.VideoWriter_fourcc(*'MJPG')
+                        video_writer = cv2.VideoWriter(self.output_path, fourcc, self.fps, (width, height))
+                    
+                    video_writer.write(img)
+                    
+                except Exception as e:
+                    self.logger.warning(f"Error capturing frame: {e}")
+                
+                # Maintain FPS
+                elapsed = time.time() - start_time
+                wait_time = max(0, (1.0 / self.fps) - elapsed)
+                time.sleep(wait_time)
+                
+        finally:
+            if video_writer:
+                video_writer.release()

requirements.txt

@@ -6,4 +6,5 @@ openai
 onnxruntime
 numpy
 paho-mqtt==1.6.1
-python-dotenv
+python-dotenv
+opencv-python-headless

sgcc_client.py

@@ -76,44 +76,51 @@ def get_tracks(self, distance):
         :return: List of x-offsets
         """
         tracks = []
-        current = 0
+        current = 0 # Integer current position
         mid = distance * 4 / 5 # Decelerate after 4/5
-        t = 0.2 # Time interval
+        t = 0.02 # Time interval (simulated) - reduced for smoother steps
         v = 0 # Initial velocity
 
         while current < distance:
             if current < mid:
                 # Acceleration phase
-                a = 2 + random.uniform(-0.5, 0.5)
+                a = random.randint(400, 600)
             else:
                 # Deceleration phase
-                a = -3 + random.uniform(-0.5, 0.5)
+                a = -random.randint(600, 800)
 
             v0 = v
             v = v0 + a * t
             move = v0 * t + 0.5 * a * t * t
-            current += move
-            tracks.append(round(move))
-
-        # Correction
-        generated_distance = sum(tracks)
-        diff = distance - generated_distance
-        if diff != 0:
-            tracks.append(diff)
 
+            # Ensure forward movement
+            if move < 1: move = 1
+            
+            move_int = round(move)
+            
+            # Check if this move overshoots
+            if current + move_int > distance:
+                move_int = distance - current
+            
+            tracks.append(move_int)
+            current += move_int
+            
+            if current >= distance:
+                break
+                
         return tracks
 
     def get_tracks_with_jitter(self, distance):
         """
-        Advanced tracks with Y-axis jitter and overshoot
+        Advanced tracks with Y-axis jitter
         """
         tracks = self.get_tracks(distance)
 
-        # Simulate overshoot
-        if random.choice([True, False]):
-            overshoot = random.randint(2, 5)
-            tracks.append(overshoot)
-            tracks.append(-overshoot)
+        # Overshoot removed based on user feedback (causes validation failure)
+        # if random.choice([True, False]):
+        #     overshoot = random.randint(2, 5)
+        #     tracks.append(overshoot)
+        #     tracks.append(-overshoot)
 
         return tracks
 
@@ -206,6 +213,11 @@ def init_driver(self):
             options.add_argument('--disable-dev-shm-usage')
             options.add_argument("--window-size=1920,1080")
 
+            # Anti-detection options
+            options.add_argument("--disable-blink-features=AutomationControlled")
+            options.add_experimental_option("excludeSwitches", ["enable-automation"])
+            options.add_experimental_option('useAutomationExtension', False)
+            
             chrome_binary = os.getenv("CHROME_BINARY_PATH")
             # Fallback for Docker if env var is empty (overridden by .env)
             if not chrome_binary and os.environ.get('PYTHON_IN_DOCKER') == 'true':
@@ -226,6 +238,16 @@ def init_driver(self):
                 service = ChromeService(driver_path)
 
             driver = webdriver.Chrome(options=options, service=service)
+            
+            # CDP command to hide webdriver property
+            driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
+                "source": """
+                    Object.defineProperty(navigator, 'webdriver', {
+                        get: () => undefined
+                    })
+                """
+            })
+            
             driver.implicitly_wait(self.wait_time)
         return driver
 
@@ -301,7 +323,8 @@ def perform_login(self, driver):
             base64_img = driver.execute_script(js_img)
 
             # Get rendered width (CSS width)
-            js_width = 'return document.getElementById("slideVerify").childNodes[0].clientWidth;'
+            # Get rendered width (CSS width) - Use getBoundingClientRect for float precision
+            js_width = 'return document.getElementById("slideVerify").childNodes[0].getBoundingClientRect().width;'
             rendered_width = driver.execute_script(js_width)
 
             img_data = base64_img.split(',')[1]
@@ -312,34 +335,34 @@ def perform_login(self, driver):
 
             gap_pos = self.resolver.solve_gap(image)
 
-            # Apply scaling
-            final_distance = int(gap_pos * scale_factor)
+            # Apply scaling and round to nearest integer
+            final_distance = int(round(gap_pos * scale_factor))
 
             # Apply manual offset
-            slider_offset = int(os.getenv("SLIDER_OFFSET", 2))
+            slider_offset = int(os.getenv("SLIDER_OFFSET", 5))
             final_distance += slider_offset
 
             logging.info(f"Captcha: Gap={gap_pos}, Scale={scale_factor:.2f}, Offset={slider_offset}, FinalDist={final_distance}")
 
             # Save debug image with lines
-            try:
-                from PIL import ImageDraw
-                debug_img = image.copy()
-                draw = ImageDraw.Draw(debug_img)
+            # try:
+            #     from PIL import ImageDraw
+            #     debug_img = image.copy()
+            #     draw = ImageDraw.Draw(debug_img)
 
-                # Red line: Original VLM detection
-                draw.line([(gap_pos, 0), (gap_pos, debug_img.height)], fill="red", width=3)
+            #     # Red line: Original VLM detection
+            #     draw.line([(gap_pos, 0), (gap_pos, debug_img.height)], fill="red", width=3)
 
-                # Green line: Final target (converted back to image scale)
-                final_target_on_image = int(final_distance / scale_factor)
-                draw.line([(final_target_on_image, 0), (final_target_on_image, debug_img.height)], fill="green", width=3)
+            #     # Green line: Final target (converted back to image scale)
+            #     final_target_on_image = int(final_distance / scale_factor)
+            #     draw.line([(final_target_on_image, 0), (final_target_on_image, debug_img.height)], fill="green", width=3)
 
-                timestamp = time.strftime("%Y%m%d_%H%M%S")
-                debug_path = f"./errors/captcha_{timestamp}.png"
-                debug_img.save(debug_path)
-                logging.info(f"Saved debug captcha image to {debug_path}")
-            except Exception as e:
-                logging.warning(f"Failed to save debug image: {e}")
+            #     timestamp = time.strftime("%Y%m%d_%H%M%S")
+            #     debug_path = f"./errors/captcha_{timestamp}.png"
+            #     debug_img.save(debug_path)
+            #     logging.info(f"Saved debug captcha image to {debug_path}")
+            # except Exception as e:
+            #     logging.warning(f"Failed to save debug image: {e}")
 
             self.simulate_slide(driver, final_distance)
             time.sleep(self.retry_delay)
@@ -348,13 +371,13 @@ def perform_login(self, driver):
                 logging.info(f"Login failed (Attempt {attempt}), retrying captcha...")
 
                 # Capture screenshot to see the error message
-                try:
-                    timestamp = time.strftime("%Y%m%d_%H%M%S")
-                    error_shot_path = f"./errors/login_fail_{timestamp}.png"
-                    driver.save_screenshot(error_shot_path)
-                    logging.info(f"Saved login failure screenshot to {error_shot_path}")
-                except Exception as e:
-                    logging.warning(f"Failed to save failure screenshot: {e}")
+                # try:
+                #     timestamp = time.strftime("%Y%m%d_%H%M%S")
+                #     error_shot_path = f"./errors/login_fail_{timestamp}.png"
+                #     driver.save_screenshot(error_shot_path)
+                #     logging.info(f"Saved login failure screenshot to {error_shot_path}")
+                # except Exception as e:
+                #     logging.warning(f"Failed to save failure screenshot: {e}")
 
                 self._click_element(driver, By.CLASS_NAME, "el-button.el-button--primary")
                 time.sleep(self.retry_delay * 2)
@@ -369,19 +392,31 @@ def run(self):
         # Force window size for headless mode
         driver.set_window_size(1920, 1080)
         size = driver.get_window_size()
-        logging.info(f"Driver initialized. Window size: {size}")
+        pixel_ratio = driver.execute_script("return window.devicePixelRatio;")
+        logging.info(f"Driver initialized. Window size: {size}, DevicePixelRatio: {pixel_ratio}")
+        
+        # Start Screen Recording
+        # from recorder import ScreenRecorder
+        # timestamp = time.strftime("%Y%m%d_%H%M%S")
+        # video_path = f"./errors/record_{timestamp}.avi"
+        # recorder = ScreenRecorder(driver, video_path, fps=3.0)
+        # recorder.start()
 
         publisher = MQTTPublisher()
 
         try:
             if self.perform_login(driver):
                 logging.info("Login successful!")
+                # Stop recording immediately after success to save time/space
+                # recorder.stop()
             else:
                 logging.error("Login failed!")
+                # recorder.stop()
                 driver.quit()
                 return
         except Exception as e:
             logging.error(f"Login exception: {e}")
+            # recorder.stop()
             driver.quit()
             return
 
@@ -410,6 +445,7 @@ def run(self):
 
         logging.info("All tasks completed successfully.")
         self.cleanup_debug_images()
+        # recorder.stop()
         driver.quit()
 
     def cleanup_debug_images(self):

startup.py

@@ -19,16 +19,20 @@ def setup_logging(level: str):
     logger.addHandler(sh)
 
 def execute_job(spider: SGCCSpider, max_retries: int):
-    for attempt in range(1, max_retries + 1):
-        try:
-            spider.run()
-            next_run = schedule.next_run()
-            if next_run:
-                logging.info(f"Going to sleep. Next run scheduled at: {next_run.strftime('%Y-%m-%d %H:%M:%S')}")
-            return
-        except Exception as e:
-            logging.error(f"Job failed (Attempt {attempt}/{max_retries}): {e}")
-            continue
+    try:
+        spider.run()
+        
+        # Calculate the real next run time (filter out past/current jobs)
+        now = datetime.now()
+        future_runs = [job.next_run for job in schedule.jobs if job.next_run and job.next_run > now]
+        if future_runs:
+            next_run = min(future_runs)
+            logging.info(f"Going to sleep. Next run scheduled at: {next_run.strftime('%Y-%m-%d %H:%M:%S')}")
+        else:
+            logging.info("Going to sleep. No future runs scheduled.")
+            
+    except Exception as e:
+        logging.error(f"Job failed: {e}")
 
 def main():
     if 'PYTHON_IN_DOCKER' not in os.environ: 

vlm_solver.py

@@ -86,7 +86,7 @@ def solve_gap(self, image):
 
             real_x_offset = (x_center_normalized / 1000) * real_width
 
-            return int(real_x_offset)
+            return real_x_offset
 
         except Exception as e:
             logging.error(f"VLM Solver failed: {e}")