feat(ddma_browser_manager) - added singleton browser manager for persistent Chrome instance; updated Selenium service to utilize the manager for session handling and OTP processing

apps/SeleniumService/ddma_browser_manager.py

@@ -0,0 +1,102 @@
+"""
+Minimal browser manager for DDMA - only handles persistent profile and keeping browser alive.
+Does NOT modify any login/OTP logic.
+"""
+import os
+import threading
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+
+class DDMABrowserManager:
+    """
+    Singleton that manages a persistent Chrome browser instance.
+    - Uses --user-data-dir for persistent profile (device trust tokens, cookies)
+    - Keeps browser alive between patient runs
+    """
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._driver = None
+                cls._instance.profile_dir = os.path.abspath("chrome_profile_ddma")
+                cls._instance.download_dir = os.path.abspath("seleniumDownloads")
+                os.makedirs(cls._instance.profile_dir, exist_ok=True)
+                os.makedirs(cls._instance.download_dir, exist_ok=True)
+        return cls._instance
+
+    def get_driver(self, headless=False):
+        """Get or create the persistent browser instance."""
+        with self._lock:
+            if self._driver is None:
+                print("[BrowserManager] Driver is None, creating new driver")
+                self._create_driver(headless)
+            elif not self._is_alive():
+                print("[BrowserManager] Driver not alive, recreating")
+                self._create_driver(headless)
+            else:
+                print("[BrowserManager] Reusing existing driver")
+            return self._driver
+
+    def _is_alive(self):
+        """Check if browser is still responsive."""
+        try:
+            url = self._driver.current_url
+            print(f"[BrowserManager] Driver alive, current URL: {url[:50]}...")
+            return True
+        except Exception as e:
+            print(f"[BrowserManager] Driver not alive: {e}")
+            return False
+
+    def _create_driver(self, headless=False):
+        """Create browser with persistent profile."""
+        if self._driver:
+            try:
+                self._driver.quit()
+            except:
+                pass
+
+        options = webdriver.ChromeOptions()
+        if headless:
+            options.add_argument("--headless")
+        
+        # Persistent profile - THIS IS THE KEY for device trust
+        options.add_argument(f"--user-data-dir={self.profile_dir}")
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        
+        prefs = {
+            "download.default_directory": self.download_dir,
+            "plugins.always_open_pdf_externally": True,
+            "download.prompt_for_download": False,
+            "download.directory_upgrade": True
+        }
+        options.add_experimental_option("prefs", prefs)
+
+        service = Service(ChromeDriverManager().install())
+        self._driver = webdriver.Chrome(service=service, options=options)
+        self._driver.maximize_window()
+
+    def quit_driver(self):
+        """Quit browser (only call on shutdown)."""
+        with self._lock:
+            if self._driver:
+                try:
+                    self._driver.quit()
+                except:
+                    pass
+                self._driver = None
+
+
+# Singleton accessor
+_manager = None
+
+def get_browser_manager():
+    global _manager
+    if _manager is None:
+        _manager = DDMABrowserManager()
+    return _manager