Add United SCO eligibility feature and fix issues

- United SCO: Add complete eligibility check workflow with flexible input
  (supports either Member ID + DOB or First Name + Last Name + DOB)
- Tufts SCO (DentaQuest): Fix Date of Service validation by adding proper
  Tab key navigation between date fields
- Delta MA: Improve patient name extraction with more robust selectors
  and pattern matching for saving names to database

apps/Backend/src/routes/index.ts

@@ -10,6 +10,7 @@ import documentsRoutes from "./documents";
 import insuranceStatusRoutes from "./insuranceStatus";
 import insuranceStatusDdmaRoutes from "./insuranceStatusDDMA";
 import insuranceStatusDentaQuestRoutes from "./insuranceStatusDentaQuest";
+import insuranceStatusUnitedSCORoutes from "./insuranceStatusUnitedSCO";
 import paymentsRoutes from "./payments";
 import databaseManagementRoutes from "./database-management";
 import notificationsRoutes from "./notifications";
@@ -31,6 +32,7 @@ router.use("/documents", documentsRoutes);
 router.use("/insurance-status", insuranceStatusRoutes);
 router.use("/insurance-status-ddma", insuranceStatusDdmaRoutes);
 router.use("/insurance-status-dentaquest", insuranceStatusDentaQuestRoutes);
+router.use("/insurance-status-unitedsco", insuranceStatusUnitedSCORoutes);
 router.use("/payments", paymentsRoutes);
 router.use("/database-management", databaseManagementRoutes);
 router.use("/notifications", notificationsRoutes);

apps/Backend/src/routes/insuranceStatusUnitedSCO.ts

@@ -0,0 +1,736 @@
+import { Router, Request, Response } from "express";
+import { storage } from "../storage";
+import {
+  forwardToSeleniumUnitedSCOEligibilityAgent,
+  forwardOtpToSeleniumUnitedSCOAgent,
+  getSeleniumUnitedSCOSessionStatus,
+} from "../services/seleniumUnitedSCOInsuranceEligibilityClient";
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import PDFDocument from "pdfkit";
+import { emptyFolderContainingFile } from "../utils/emptyTempFolder";
+import {
+  InsertPatient,
+  insertPatientSchema,
+} from "../../../../packages/db/types/patient-types";
+import { io } from "../socket";
+
+const router = Router();
+
+/** Job context stored in memory by sessionId */
+interface UnitedSCOJobContext {
+  userId: number;
+  insuranceEligibilityData: any; // parsed, enriched (includes username/password)
+  socketId?: string;
+}
+
+const unitedscoJobs: Record<string, UnitedSCOJobContext> = {};
+
+/** Utility: naive name splitter */
+function splitName(fullName?: string | null) {
+  if (!fullName) return { firstName: "", lastName: "" };
+  const parts = fullName.trim().split(/\s+/).filter(Boolean);
+  const firstName = parts.shift() ?? "";
+  const lastName = parts.join(" ") ?? "";
+  return { firstName, lastName };
+}
+
+async function imageToPdfBuffer(imagePath: string): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    try {
+      const doc = new PDFDocument({ autoFirstPage: false });
+      const chunks: Uint8Array[] = [];
+
+      doc.on("data", (chunk: any) => chunks.push(chunk));
+      doc.on("end", () => resolve(Buffer.concat(chunks)));
+      doc.on("error", (err: any) => reject(err));
+
+      const A4_WIDTH = 595.28; // points
+      const A4_HEIGHT = 841.89; // points
+
+      doc.addPage({ size: [A4_WIDTH, A4_HEIGHT] });
+
+      doc.image(imagePath, 0, 0, {
+        fit: [A4_WIDTH, A4_HEIGHT],
+        align: "center",
+        valign: "center",
+      });
+
+      doc.end();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+/**
+ * Ensure patient exists for given insuranceId.
+ */
+async function createOrUpdatePatientByInsuranceId(options: {
+  insuranceId: string;
+  firstName?: string | null;
+  lastName?: string | null;
+  dob?: string | Date | null;
+  userId: number;
+}) {
+  const { insuranceId, firstName, lastName, dob, userId } = options;
+  if (!insuranceId) throw new Error("Missing insuranceId");
+
+  const incomingFirst = (firstName || "").trim();
+  const incomingLast = (lastName || "").trim();
+
+  let patient = await storage.getPatientByInsuranceId(insuranceId);
+
+  if (patient && patient.id) {
+    const updates: any = {};
+    if (
+      incomingFirst &&
+      String(patient.firstName ?? "").trim() !== incomingFirst
+    ) {
+      updates.firstName = incomingFirst;
+    }
+    if (
+      incomingLast &&
+      String(patient.lastName ?? "").trim() !== incomingLast
+    ) {
+      updates.lastName = incomingLast;
+    }
+    if (Object.keys(updates).length > 0) {
+      await storage.updatePatient(patient.id, updates);
+    }
+    return;
+  } else {
+    const createPayload: any = {
+      firstName: incomingFirst,
+      lastName: incomingLast,
+      dateOfBirth: dob,
+      gender: "",
+      phone: "",
+      userId,
+      insuranceId,
+    };
+    let patientData: InsertPatient;
+    try {
+      patientData = insertPatientSchema.parse(createPayload);
+    } catch (err) {
+      const safePayload = { ...createPayload };
+      delete (safePayload as any).dateOfBirth;
+      patientData = insertPatientSchema.parse(safePayload);
+    }
+    await storage.createPatient(patientData);
+  }
+}
+
+/**
+ * When Selenium finishes for a given sessionId, run your patient + PDF pipeline,
+ * and return the final API response shape.
+ * 
+ * Note: For United SCO, we search by First Name + Last Name + DOB (not by Member ID).
+ * The Member ID is extracted from the page after search and returned in seleniumResult.memberId.
+ */
+async function handleUnitedSCOCompletedJob(
+  sessionId: string,
+  job: UnitedSCOJobContext,
+  seleniumResult: any
+) {
+  let createdPdfFileId: number | null = null;
+  const outputResult: any = {};
+
+  // We'll wrap the processing in try/catch/finally so cleanup always runs
+  try {
+    const insuranceEligibilityData = job.insuranceEligibilityData;
+    
+    // 1) Get Member ID - prefer the one extracted from the page by Selenium,
+    // since United SCO searches by name and the Member ID is found after search
+    let insuranceId = String(seleniumResult?.memberId ?? "").trim();
+    if (!insuranceId) {
+      // Fallback to the one provided in the request (if any)
+      insuranceId = String(insuranceEligibilityData.memberId ?? "").trim();
+    }
+    
+    if (!insuranceId) {
+      console.log("[unitedsco-eligibility] No Member ID found - will use name for patient lookup");
+    } else {
+      console.log(`[unitedsco-eligibility] Using Member ID: ${insuranceId}`);
+    }
+
+    // 2) Get patient name - prefer from selenium result, fallback to request data
+    const patientNameFromResult =
+      typeof seleniumResult?.patientName === "string"
+        ? seleniumResult.patientName.trim()
+        : null;
+
+    let firstName = insuranceEligibilityData.firstName || "";
+    let lastName = insuranceEligibilityData.lastName || "";
+    
+    if (patientNameFromResult) {
+      const parsedName = splitName(patientNameFromResult);
+      firstName = parsedName.firstName || firstName;
+      lastName = parsedName.lastName || lastName;
+    }
+
+    // 3) Create or update patient
+    if (insuranceId) {
+      await createOrUpdatePatientByInsuranceId({
+        insuranceId,
+        firstName,
+        lastName,
+        dob: insuranceEligibilityData.dateOfBirth,
+        userId: job.userId,
+      });
+    }
+
+    // 4) Get patient for status update and PDF upload
+    let patient = insuranceId 
+      ? await storage.getPatientByInsuranceId(insuranceId)
+      : null;
+    
+    if (!patient?.id) {
+      outputResult.patientUpdateStatus =
+        "Patient not found; no update performed";
+      return {
+        patientUpdateStatus: outputResult.patientUpdateStatus,
+        pdfUploadStatus: "none",
+        pdfFileId: null,
+      };
+    }
+
+    // Update patient status
+    const newStatus =
+      seleniumResult.eligibility === "active" ? "ACTIVE" : "INACTIVE";
+    await storage.updatePatient(patient.id, { status: newStatus });
+    outputResult.patientUpdateStatus = `Patient status updated to ${newStatus}`;
+
+    // Handle PDF or convert screenshot -> pdf if available
+    let pdfBuffer: Buffer | null = null;
+    let generatedPdfPath: string | null = null;
+
+    if (
+      seleniumResult &&
+      seleniumResult.ss_path &&
+      typeof seleniumResult.ss_path === "string"
+    ) {
+      try {
+        if (!fsSync.existsSync(seleniumResult.ss_path)) {
+          throw new Error(
+            `File not found: ${seleniumResult.ss_path}`
+          );
+        }
+
+        // Check if the file is already a PDF (from Page.printToPDF)
+        if (seleniumResult.ss_path.endsWith(".pdf")) {
+          // Read PDF directly
+          pdfBuffer = await fs.readFile(seleniumResult.ss_path);
+          generatedPdfPath = seleniumResult.ss_path;
+          seleniumResult.pdf_path = generatedPdfPath;
+          console.log(`[unitedsco-eligibility] Using PDF directly from Selenium: ${generatedPdfPath}`);
+        } else if (
+          seleniumResult.ss_path.endsWith(".png") ||
+          seleniumResult.ss_path.endsWith(".jpg") ||
+          seleniumResult.ss_path.endsWith(".jpeg")
+        ) {
+          // Convert image to PDF
+          pdfBuffer = await imageToPdfBuffer(seleniumResult.ss_path);
+
+          const pdfFileName = `unitedsco_eligibility_${insuranceEligibilityData.memberId}_${Date.now()}.pdf`;
+          generatedPdfPath = path.join(
+            path.dirname(seleniumResult.ss_path),
+            pdfFileName
+          );
+          await fs.writeFile(generatedPdfPath, pdfBuffer);
+          seleniumResult.pdf_path = generatedPdfPath;
+          console.log(`[unitedsco-eligibility] Converted screenshot to PDF: ${generatedPdfPath}`);
+        } else {
+          outputResult.pdfUploadStatus =
+            `Unsupported file format: ${seleniumResult.ss_path}`;
+        }
+      } catch (err: any) {
+        console.error("Failed to process PDF/screenshot:", err);
+        outputResult.pdfUploadStatus = `Failed to process file: ${String(err)}`;
+      }
+    } else {
+      outputResult.pdfUploadStatus =
+        "No valid file path (ss_path) provided by Selenium; nothing to upload.";
+    }
+
+    if (pdfBuffer && generatedPdfPath) {
+      const groupTitle = "Eligibility Status";
+      const groupTitleKey = "ELIGIBILITY_STATUS";
+
+      let group = await storage.findPdfGroupByPatientTitleKey(
+        patient.id,
+        groupTitleKey
+      );
+      if (!group) {
+        group = await storage.createPdfGroup(
+          patient.id,
+          groupTitle,
+          groupTitleKey
+        );
+      }
+      if (!group?.id) {
+        throw new Error("PDF group creation failed: missing group ID");
+      }
+
+      const created = await storage.createPdfFile(
+        group.id,
+        path.basename(generatedPdfPath),
+        pdfBuffer
+      );
+      if (created && typeof created === "object" && "id" in created) {
+        createdPdfFileId = Number(created.id);
+      }
+      outputResult.pdfUploadStatus = `PDF saved to group: ${group.title}`;
+    } else {
+      outputResult.pdfUploadStatus =
+        "No valid PDF path provided by Selenium, Couldn't upload pdf to server.";
+    }
+
+    return {
+      patientUpdateStatus: outputResult.patientUpdateStatus,
+      pdfUploadStatus: outputResult.pdfUploadStatus,
+      pdfFileId: createdPdfFileId,
+    };
+  } catch (err: any) {
+    return {
+      patientUpdateStatus: outputResult.patientUpdateStatus,
+      pdfUploadStatus:
+        outputResult.pdfUploadStatus ??
+        `Failed to process United SCO job: ${err?.message ?? String(err)}`,
+      pdfFileId: createdPdfFileId,
+      error: err?.message ?? String(err),
+    };
+  } finally {
+    // ALWAYS attempt cleanup of temp files
+    try {
+      if (seleniumResult && seleniumResult.pdf_path) {
+        await emptyFolderContainingFile(seleniumResult.pdf_path);
+      } else if (seleniumResult && seleniumResult.ss_path) {
+        await emptyFolderContainingFile(seleniumResult.ss_path);
+      } else {
+        console.log(
+          `[unitedsco-eligibility] no pdf_path or ss_path available to cleanup`
+        );
+      }
+    } catch (cleanupErr) {
+      console.error(
+        `[unitedsco-eligibility cleanup failed for ${seleniumResult?.pdf_path ?? seleniumResult?.ss_path}]`,
+        cleanupErr
+      );
+    }
+  }
+}
+
+// --- top of file, alongside unitedscoJobs ---
+let currentFinalSessionId: string | null = null;
+let currentFinalResult: any = null;
+
+function now() {
+  return new Date().toISOString();
+}
+function log(tag: string, msg: string, ctx?: any) {
+  console.log(`${now()} [${tag}] ${msg}`, ctx ?? "");
+}
+
+function emitSafe(socketId: string | undefined, event: string, payload: any) {
+  if (!socketId) {
+    log("socket", "no socketId for emit", { event });
+    return;
+  }
+  try {
+    const socket = io?.sockets.sockets.get(socketId);
+    if (!socket) {
+      log("socket", "socket not found (maybe disconnected)", {
+        socketId,
+        event,
+      });
+      return;
+    }
+    socket.emit(event, payload);
+    log("socket", "emitted", { socketId, event });
+  } catch (err: any) {
+    log("socket", "emit failed", { socketId, event, err: err?.message });
+  }
+}
+
+/**
+ * Polls Python agent for session status and emits socket events:
+ *  - 'selenium:otp_required' when waiting_for_otp
+ *  - 'selenium:session_update' when completed/error
+ *  - absolute timeout + transient error handling.
+ *  - pollTimeoutMs default = 2 minutes (adjust where invoked)
+ */
+async function pollAgentSessionAndProcess(
+  sessionId: string,
+  socketId?: string,
+  pollTimeoutMs = 2 * 60 * 1000
+) {
+  const maxAttempts = 300;
+  const baseDelayMs = 1000;
+  const maxTransientErrors = 12;
+
+  // NEW: give up if same non-terminal status repeats this many times
+  const noProgressLimit = 100;
+
+  const job = unitedscoJobs[sessionId];
+  let transientErrorCount = 0;
+  let consecutiveNoProgress = 0;
+  let lastStatus: string | null = null;
+  const deadline = Date.now() + pollTimeoutMs;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    // absolute deadline check
+    if (Date.now() > deadline) {
+      emitSafe(socketId, "selenium:session_update", {
+        session_id: sessionId,
+        status: "error",
+        message: `Polling timeout reached (${Math.round(pollTimeoutMs / 1000)}s).`,
+      });
+      delete unitedscoJobs[sessionId];
+      return;
+    }
+
+    log(
+      "poller",
+      `attempt=${attempt} session=${sessionId} transientErrCount=${transientErrorCount}`
+    );
+
+    try {
+      const st = await getSeleniumUnitedSCOSessionStatus(sessionId);
+      const status = st?.status ?? null;
+      log("poller", "got status", {
+        sessionId,
+        status,
+        message: st?.message,
+        resultKeys: st?.result ? Object.keys(st.result) : null,
+      });
+
+      // reset transient errors on success
+      transientErrorCount = 0;
+
+      // if status unchanged and non-terminal, increment no-progress counter
+      const isTerminalLike =
+        status === "completed" || status === "error" || status === "not_found";
+      if (status === lastStatus && !isTerminalLike) {
+        consecutiveNoProgress++;
+      } else {
+        consecutiveNoProgress = 0;
+      }
+      lastStatus = status;
+
+      // if no progress for too many consecutive polls -> abort
+      if (consecutiveNoProgress >= noProgressLimit) {
+        emitSafe(socketId, "selenium:session_update", {
+          session_id: sessionId,
+          status: "error",
+          message: `No progress from selenium agent (status="${status}") after ${consecutiveNoProgress} polls; aborting.`,
+        });
+        emitSafe(socketId, "selenium:session_error", {
+          session_id: sessionId,
+          status: "error",
+          message: "No progress from selenium agent",
+        });
+        delete unitedscoJobs[sessionId];
+        return;
+      }
+
+      // always emit debug to client if socket exists
+      emitSafe(socketId, "selenium:debug", {
+        session_id: sessionId,
+        attempt,
+        status,
+        serverTime: new Date().toISOString(),
+      });
+
+      // If agent is waiting for OTP, inform client but keep polling (do not return)
+      if (status === "waiting_for_otp") {
+        emitSafe(socketId, "selenium:otp_required", {
+          session_id: sessionId,
+          message: "OTP required. Please enter the OTP.",
+        });
+        // do not return — keep polling (allows same poller to pick up completion)
+        await new Promise((r) => setTimeout(r, baseDelayMs));
+        continue;
+      }
+
+      // Completed path
+      if (status === "completed") {
+        log("poller", "agent completed; processing result", {
+          sessionId,
+          resultKeys: st.result ? Object.keys(st.result) : null,
+        });
+
+        // Persist raw result so frontend can fetch if socket disconnects
+        currentFinalSessionId = sessionId;
+        currentFinalResult = {
+          rawSelenium: st.result,
+          processedAt: null,
+          final: null,
+        };
+
+        let finalResult: any = null;
+        if (job && st.result) {
+          try {
+            finalResult = await handleUnitedSCOCompletedJob(
+              sessionId,
+              job,
+              st.result
+            );
+            currentFinalResult.final = finalResult;
+            currentFinalResult.processedAt = Date.now();
+          } catch (err: any) {
+            currentFinalResult.final = {
+              error: "processing_failed",
+              detail: err?.message ?? String(err),
+            };
+            currentFinalResult.processedAt = Date.now();
+            log("poller", "handleUnitedSCOCompletedJob failed", {
+              sessionId,
+              err: err?.message ?? err,
+            });
+          }
+        } else {
+          currentFinalResult.final = {
+            error: "no_job_or_no_result",
+          };
+          currentFinalResult.processedAt = Date.now();
+        }
+
+        // Emit final update (if socket present)
+        emitSafe(socketId, "selenium:session_update", {
+          session_id: sessionId,
+          status: "completed",
+          rawSelenium: st.result,
+          final: currentFinalResult.final,
+        });
+
+        // cleanup job context
+        delete unitedscoJobs[sessionId];
+        return;
+      }
+
+      // Terminal error / not_found
+      if (status === "error" || status === "not_found") {
+        const emitPayload = {
+          session_id: sessionId,
+          status,
+          message: st?.message || "Selenium session error",
+        };
+        emitSafe(socketId, "selenium:session_update", emitPayload);
+        emitSafe(socketId, "selenium:session_error", emitPayload);
+        delete unitedscoJobs[sessionId];
+        return;
+      }
+    } catch (err: any) {
+      const axiosStatus =
+        err?.response?.status ?? (err?.status ? Number(err.status) : undefined);
+      const errCode = err?.code ?? err?.errno;
+      const errMsg = err?.message ?? String(err);
+      const errData = err?.response?.data ?? null;
+
+      // If agent explicitly returned 404 -> terminal (session gone)
+      if (
+        axiosStatus === 404 ||
+        (typeof errMsg === "string" && errMsg.includes("not_found"))
+      ) {
+        console.warn(
+          `${new Date().toISOString()} [poller] terminal 404/not_found for ${sessionId}: data=${JSON.stringify(errData)}`
+        );
+
+        // Emit not_found to client
+        const emitPayload = {
+          session_id: sessionId,
+          status: "not_found",
+          message:
+            errData?.detail || "Selenium session not found (agent cleaned up).",
+        };
+        emitSafe(socketId, "selenium:session_update", emitPayload);
+        emitSafe(socketId, "selenium:session_error", emitPayload);
+
+        // Remove job context and stop polling
+        delete unitedscoJobs[sessionId];
+        return;
+      }
+
+      // Detailed transient error logging
+      transientErrorCount++;
+      if (transientErrorCount > maxTransientErrors) {
+        const emitPayload = {
+          session_id: sessionId,
+          status: "error",
+          message:
+            "Repeated network errors while polling selenium agent; giving up.",
+        };
+        emitSafe(socketId, "selenium:session_update", emitPayload);
+        emitSafe(socketId, "selenium:session_error", emitPayload);
+        delete unitedscoJobs[sessionId];
+        return;
+      }
+
+      const backoffMs = Math.min(
+        30_000,
+        baseDelayMs * Math.pow(2, transientErrorCount - 1)
+      );
+      console.warn(
+        `${new Date().toISOString()} [poller] transient error (#${transientErrorCount}) for ${sessionId}: code=${errCode} status=${axiosStatus} msg=${errMsg} data=${JSON.stringify(errData)}`
+      );
+      console.warn(
+        `${new Date().toISOString()} [poller] backing off ${backoffMs}ms before next attempt`
+      );
+
+      await new Promise((r) => setTimeout(r, backoffMs));
+      continue;
+    }
+
+    // normal poll interval
+    await new Promise((r) => setTimeout(r, baseDelayMs));
+  }
+
+  // overall timeout fallback
+  emitSafe(socketId, "selenium:session_update", {
+    session_id: sessionId,
+    status: "error",
+    message: "Polling timeout while waiting for selenium session",
+  });
+  delete unitedscoJobs[sessionId];
+}
+
+/**
+ * POST /unitedsco-eligibility
+ * Starts United SCO eligibility Selenium job.
+ * Expects:
+ *  - req.body.data: stringified JSON like your existing /eligibility-check
+ *  - req.body.socketId: socket.io client id
+ */
+router.post(
+  "/unitedsco-eligibility",
+  async (req: Request, res: Response): Promise<any> => {
+    if (!req.body.data) {
+      return res
+        .status(400)
+        .json({ error: "Missing Insurance Eligibility data for selenium" });
+    }
+
+    if (!req.user || !req.user.id) {
+      return res.status(401).json({ error: "Unauthorized: user info missing" });
+    }
+
+    try {
+      const rawData =
+        typeof req.body.data === "string"
+          ? JSON.parse(req.body.data)
+          : req.body.data;
+
+      // United SCO uses its own credentials
+      const credentials = await storage.getInsuranceCredentialByUserAndSiteKey(
+        req.user.id,
+        "UNITEDSCO"
+      );
+      if (!credentials) {
+        return res.status(404).json({
+          error:
+            "No insurance credentials found for this provider, Kindly Update this at Settings Page.",
+        });
+      }
+
+      const enrichedData = {
+        ...rawData,
+        unitedscoUsername: credentials.username,
+        unitedscoPassword: credentials.password,
+      };
+
+      const socketId: string | undefined = req.body.socketId;
+
+      const agentResp =
+        await forwardToSeleniumUnitedSCOEligibilityAgent(enrichedData);
+
+      if (
+        !agentResp ||
+        agentResp.status !== "started" ||
+        !agentResp.session_id
+      ) {
+        return res.status(502).json({
+          error: "Selenium agent did not return a started session",
+          detail: agentResp,
+        });
+      }
+
+      const sessionId = agentResp.session_id as string;
+
+      // Save job context
+      unitedscoJobs[sessionId] = {
+        userId: req.user.id,
+        insuranceEligibilityData: enrichedData,
+        socketId,
+      };
+
+      // start polling in background to notify client via socket and process job
+      pollAgentSessionAndProcess(sessionId, socketId).catch((e) =>
+        console.warn("pollAgentSessionAndProcess failed", e)
+      );
+
+      // reply immediately with started status
+      return res.json({ status: "started", session_id: sessionId });
+    } catch (err: any) {
+      console.error(err);
+      return res.status(500).json({
+        error: err.message || "Failed to start United SCO selenium agent",
+      });
+    }
+  }
+);
+
+/**
+ * POST /selenium/submit-otp
+ * Body: { session_id, otp, socketId? }
+ * Forwards OTP to Python agent and optionally notifies client socket.
+ */
+router.post(
+  "/selenium/submit-otp",
+  async (req: Request, res: Response): Promise<any> => {
+    const { session_id: sessionId, otp, socketId } = req.body;
+    if (!sessionId || !otp) {
+      return res.status(400).json({ error: "session_id and otp are required" });
+    }
+
+    try {
+      const r = await forwardOtpToSeleniumUnitedSCOAgent(sessionId, otp);
+
+      // emit OTP accepted (if socket present)
+      emitSafe(socketId, "selenium:otp_submitted", {
+        session_id: sessionId,
+        result: r,
+      });
+
+      return res.json(r);
+    } catch (err: any) {
+      console.error(
+        "Failed to forward OTP:",
+        err?.response?.data || err?.message || err
+      );
+      return res.status(500).json({
+        error: "Failed to forward otp to selenium agent",
+        detail: err?.message || err,
+      });
+    }
+  }
+);
+
+// GET /selenium/session/:sid/final
+router.get(
+  "/selenium/session/:sid/final",
+  async (req: Request, res: Response) => {
+    const sid = req.params.sid;
+    if (!sid) return res.status(400).json({ error: "session id required" });
+
+    // Only the current in-memory result is available
+    if (currentFinalSessionId !== sid || !currentFinalResult) {
+      return res.status(404).json({ error: "final result not found" });
+    }
+
+    return res.json(currentFinalResult);
+  }
+);
+
+export default router;

apps/Backend/src/services/seleniumUnitedSCOInsuranceEligibilityClient.ts

@@ -0,0 +1,122 @@
+import axios from "axios";
+import http from "http";
+import https from "https";
+import dotenv from "dotenv";
+dotenv.config();
+
+export interface SeleniumPayload {
+  data: any;
+  url?: string;
+}
+
+const SELENIUM_AGENT_BASE = process.env.SELENIUM_AGENT_BASE_URL;
+
+const httpAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 60_000 });
+const httpsAgent = new https.Agent({ keepAlive: true, keepAliveMsecs: 60_000 });
+
+const client = axios.create({
+  baseURL: SELENIUM_AGENT_BASE,
+  timeout: 5 * 60 * 1000,
+  httpAgent,
+  httpsAgent,
+  validateStatus: (s) => s >= 200 && s < 600,
+});
+
+async function requestWithRetries(
+  config: any,
+  retries = 4,
+  baseBackoffMs = 300
+) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const r = await client.request(config);
+      if (![502, 503, 504].includes(r.status)) return r;
+      console.warn(
+        `[selenium-unitedsco-client] retryable HTTP status ${r.status} (attempt ${attempt})`
+      );
+    } catch (err: any) {
+      const code = err?.code;
+      const isTransient =
+        code === "ECONNRESET" ||
+        code === "ECONNREFUSED" ||
+        code === "EPIPE" ||
+        code === "ETIMEDOUT";
+      if (!isTransient) throw err;
+      console.warn(
+        `[selenium-unitedsco-client] transient network error ${code} (attempt ${attempt})`
+      );
+    }
+    await new Promise((r) => setTimeout(r, baseBackoffMs * attempt));
+  }
+  // final attempt (let exception bubble if it fails)
+  return client.request(config);
+}
+
+function now() {
+  return new Date().toISOString();
+}
+function log(tag: string, msg: string, ctx?: any) {
+  console.log(`${now()} [${tag}] ${msg}`, ctx ?? "");
+}
+
+export async function forwardToSeleniumUnitedSCOEligibilityAgent(
+  insuranceEligibilityData: any
+): Promise<any> {
+  const payload = { data: insuranceEligibilityData };
+  const url = `/unitedsco-eligibility`;
+  log("selenium-unitedsco-client", "POST unitedsco-eligibility", {
+    url: SELENIUM_AGENT_BASE + url,
+    keys: Object.keys(payload),
+  });
+  const r = await requestWithRetries({ url, method: "POST", data: payload }, 4);
+  log("selenium-unitedsco-client", "agent response", {
+    status: r.status,
+    dataKeys: r.data ? Object.keys(r.data) : null,
+  });
+  if (r.status >= 500)
+    throw new Error(`Selenium agent server error: ${r.status}`);
+  return r.data;
+}
+
+export async function forwardOtpToSeleniumUnitedSCOAgent(
+  sessionId: string,
+  otp: string
+): Promise<any> {
+  const url = `/unitedsco-submit-otp`;
+  log("selenium-unitedsco-client", "POST unitedsco-submit-otp", {
+    url: SELENIUM_AGENT_BASE + url,
+    sessionId,
+  });
+  const r = await requestWithRetries(
+    { url, method: "POST", data: { session_id: sessionId, otp } },
+    4
+  );
+  log("selenium-unitedsco-client", "submit-otp response", {
+    status: r.status,
+    data: r.data,
+  });
+  if (r.status >= 500)
+    throw new Error(`Selenium agent server error on submit-otp: ${r.status}`);
+  return r.data;
+}
+
+export async function getSeleniumUnitedSCOSessionStatus(
+  sessionId: string
+): Promise<any> {
+  const url = `/unitedsco-session/${sessionId}/status`;
+  log("selenium-unitedsco-client", "GET session status", {
+    url: SELENIUM_AGENT_BASE + url,
+    sessionId,
+  });
+  const r = await requestWithRetries({ url, method: "GET" }, 4);
+  log("selenium-unitedsco-client", "session status response", {
+    status: r.status,
+    dataKeys: r.data ? Object.keys(r.data) : null,
+  });
+  if (r.status === 404) {
+    const e: any = new Error("not_found");
+    e.response = { status: 404, data: r.data };
+    throw e;
+  }
+  return r.data;
+}

apps/Frontend/src/components/insurance-status/unitedsco-button-modal.tsx

@@ -0,0 +1,565 @@
+import { useEffect, useRef, useState } from "react";
+import { io as ioClient, Socket } from "socket.io-client";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { CheckCircle, LoaderCircleIcon, X } from "lucide-react";
+import { useToast } from "@/hooks/use-toast";
+import { apiRequest, queryClient } from "@/lib/queryClient";
+import { useAppDispatch } from "@/redux/hooks";
+import { setTaskStatus } from "@/redux/slices/seleniumEligibilityCheckTaskSlice";
+import { formatLocalDate } from "@/utils/dateUtils";
+import { QK_PATIENTS_BASE } from "@/components/patients/patient-table";
+
+const SOCKET_URL =
+  import.meta.env.VITE_API_BASE_URL_BACKEND ||
+  (typeof window !== "undefined" ? window.location.origin : "");
+
+// ---------- OTP Modal component ----------
+interface UnitedSCOOtpModalProps {
+  open: boolean;
+  onClose: () => void;
+  onSubmit: (otp: string) => Promise<void> | void;
+  isSubmitting: boolean;
+}
+
+function UnitedSCOOtpModal({
+  open,
+  onClose,
+  onSubmit,
+  isSubmitting,
+}: UnitedSCOOtpModalProps) {
+  const [otp, setOtp] = useState("");
+
+  useEffect(() => {
+    if (!open) setOtp("");
+  }, [open]);
+
+  if (!open) return null;
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!otp.trim()) return;
+    await onSubmit(otp.trim());
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40">
+      <div className="bg-white dark:bg-slate-900 rounded-xl shadow-lg w-full max-w-md p-6">
+        <div className="flex items-center justify-between mb-4">
+          <h2 className="text-lg font-semibold">Enter OTP</h2>
+          <button
+            type="button"
+            onClick={onClose}
+            className="text-slate-500 hover:text-slate-800"
+          >
+            <X className="w-4 h-4" />
+          </button>
+        </div>
+        <p className="text-sm text-slate-500 mb-4">
+          We need the one-time password (OTP) sent by the United SCO portal
+          to complete this eligibility check.
+        </p>
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div className="space-y-2">
+            <Label htmlFor="unitedsco-otp">OTP</Label>
+            <Input
+              id="unitedsco-otp"
+              placeholder="Enter OTP code"
+              value={otp}
+              onChange={(e) => setOtp(e.target.value)}
+              autoFocus
+            />
+          </div>
+          <div className="flex justify-end gap-3">
+            <Button
+              type="button"
+              variant="outline"
+              onClick={onClose}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button type="submit" disabled={isSubmitting || !otp.trim()}>
+              {isSubmitting ? (
+                <>
+                  <LoaderCircleIcon className="w-4 h-4 mr-2 animate-spin" />
+                  Submitting...
+                </>
+              ) : (
+                "Submit OTP"
+              )}
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
+
+// ---------- Main United SCO Eligibility button component ----------
+interface UnitedSCOEligibilityButtonProps {
+  memberId: string;
+  dateOfBirth: Date | null;
+  firstName?: string;
+  lastName?: string;
+  isFormIncomplete: boolean;
+  /** Called when backend has finished and PDF is ready */
+  onPdfReady: (pdfId: number, fallbackFilename: string | null) => void;
+}
+
+export function UnitedSCOEligibilityButton({
+  memberId,
+  dateOfBirth,
+  firstName,
+  lastName,
+  isFormIncomplete,
+  onPdfReady,
+}: UnitedSCOEligibilityButtonProps) {
+  const { toast } = useToast();
+  const dispatch = useAppDispatch();
+
+  const socketRef = useRef<Socket | null>(null);
+  const connectingRef = useRef<Promise<void> | null>(null);
+
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [otpModalOpen, setOtpModalOpen] = useState(false);
+  const [isStarting, setIsStarting] = useState(false);
+  const [isSubmittingOtp, setIsSubmittingOtp] = useState(false);
+
+  // Clean up socket on unmount
+  useEffect(() => {
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.removeAllListeners();
+        socketRef.current.disconnect();
+        socketRef.current = null;
+      }
+      connectingRef.current = null;
+    };
+  }, []);
+
+  const closeSocket = () => {
+    try {
+      socketRef.current?.removeAllListeners();
+      socketRef.current?.disconnect();
+    } catch (e) {
+      // ignore
+    } finally {
+      socketRef.current = null;
+    }
+  };
+
+  // Lazy socket setup: called only when we actually need it (first click)
+  const ensureSocketConnected = async () => {
+    // If already connected, nothing to do
+    if (socketRef.current && socketRef.current.connected) {
+      return;
+    }
+
+    // If a connection is in progress, reuse that promise
+    if (connectingRef.current) {
+      return connectingRef.current;
+    }
+
+    const promise = new Promise<void>((resolve, reject) => {
+      const socket = ioClient(SOCKET_URL, {
+        withCredentials: true,
+      });
+
+      socketRef.current = socket;
+
+      socket.on("connect", () => {
+        resolve();
+      });
+
+      // connection error when first connecting (or later)
+      socket.on("connect_error", (err: any) => {
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: "Connection failed",
+          })
+        );
+        toast({
+          title: "Realtime connection failed",
+          description:
+            "Could not connect to realtime server. Retrying automatically...",
+          variant: "destructive",
+        });
+        // do not reject here because socket.io will attempt reconnection
+      });
+
+      // socket.io will emit 'reconnect_attempt' for retries
+      socket.on("reconnect_attempt", (attempt: number) => {
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message: `Realtime reconnect attempt #${attempt}`,
+          })
+        );
+      });
+
+      // when reconnection failed after configured attempts
+      socket.on("reconnect_failed", () => {
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: "Reconnect failed",
+          })
+        );
+        toast({
+          title: "Realtime reconnect failed",
+          description:
+            "Connection to realtime server could not be re-established. Please try again later.",
+          variant: "destructive",
+        });
+        // terminal failure — cleanup and reject so caller can stop start flow
+        closeSocket();
+        reject(new Error("Realtime reconnect failed"));
+      });
+
+      socket.on("disconnect", (reason: any) => {
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: "Connection disconnected",
+          })
+        );
+        toast({
+          title: "Connection Disconnected",
+          description:
+            "Connection to the server was lost. If a United SCO job was running it may have failed.",
+          variant: "destructive",
+        });
+        // clear sessionId/OTP modal
+        setSessionId(null);
+        setOtpModalOpen(false);
+      });
+
+      // OTP required
+      socket.on("selenium:otp_required", (payload: any) => {
+        if (!payload?.session_id) return;
+        setSessionId(payload.session_id);
+        setOtpModalOpen(true);
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message: "OTP required for United SCO eligibility. Please enter the OTP.",
+          })
+        );
+      });
+
+      // OTP submitted (optional UX)
+      socket.on("selenium:otp_submitted", (payload: any) => {
+        if (!payload?.session_id) return;
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message: "OTP submitted. Finishing United SCO eligibility check...",
+          })
+        );
+      });
+
+      // Session update
+      socket.on("selenium:session_update", (payload: any) => {
+        const { session_id, status, final } = payload || {};
+        if (!session_id) return;
+
+        if (status === "completed") {
+          dispatch(
+            setTaskStatus({
+              status: "success",
+              message:
+                "United SCO eligibility updated and PDF attached to patient documents.",
+            })
+          );
+          toast({
+            title: "United SCO eligibility complete",
+            description:
+              "Patient status was updated and the eligibility PDF was saved.",
+            variant: "default",
+          });
+
+          const pdfId = final?.pdfFileId;
+          if (pdfId) {
+            const filename =
+              final?.pdfFilename ?? `eligibility_unitedsco_${memberId}.pdf`;
+            onPdfReady(Number(pdfId), filename);
+          }
+
+          setSessionId(null);
+          setOtpModalOpen(false);
+        } else if (status === "error") {
+          const msg =
+            payload?.message ||
+            final?.error ||
+            "United SCO eligibility session failed.";
+          dispatch(
+            setTaskStatus({
+              status: "error",
+              message: msg,
+            })
+          );
+          toast({
+            title: "United SCO selenium error",
+            description: msg,
+            variant: "destructive",
+          });
+
+          // Ensure socket is torn down for this session (stop receiving stale events)
+          try {
+            closeSocket();
+          } catch (e) {}
+          setSessionId(null);
+          setOtpModalOpen(false);
+        }
+
+        queryClient.invalidateQueries({ queryKey: QK_PATIENTS_BASE });
+      });
+
+      // explicit session error event (helpful)
+      socket.on("selenium:session_error", (payload: any) => {
+        const msg = payload?.message || "Selenium session error";
+
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: msg,
+          })
+        );
+
+        toast({
+          title: "Selenium session error",
+          description: msg,
+          variant: "destructive",
+        });
+
+        // tear down socket to avoid stale updates
+        try {
+          closeSocket();
+        } catch (e) {}
+        setSessionId(null);
+        setOtpModalOpen(false);
+      });
+
+      // If socket.io initial connection fails permanently (very rare: client-level)
+      // set a longer timeout to reject the first attempt to connect.
+      const initialConnectTimeout = setTimeout(() => {
+        if (!socket.connected) {
+          // if still not connected after 8s, treat as failure and reject so caller can handle it
+          closeSocket();
+          reject(new Error("Realtime initial connection timeout"));
+        }
+      }, 8000);
+
+      // When the connect resolves we should clear this timer
+      socket.once("connect", () => {
+        clearTimeout(initialConnectTimeout);
+      });
+    });
+
+    // store promise to prevent multiple concurrent connections
+    connectingRef.current = promise;
+
+    try {
+      await promise;
+    } finally {
+      connectingRef.current = null;
+    }
+  };
+
+  const startUnitedSCOEligibility = async () => {
+    if (!memberId || !dateOfBirth) {
+      toast({
+        title: "Missing fields",
+        description: "Member ID and Date of Birth are required.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    const formattedDob = dateOfBirth ? formatLocalDate(dateOfBirth) : "";
+
+    const payload = {
+      memberId,
+      dateOfBirth: formattedDob,
+      firstName,
+      lastName,
+      insuranceSiteKey: "UNITEDSCO", // for backend credential lookup (uses DENTAQUEST)
+    };
+
+    try {
+      setIsStarting(true);
+
+      // 1) Ensure socket is connected (lazy)
+      dispatch(
+        setTaskStatus({
+          status: "pending",
+          message: "Opening realtime channel for United SCO eligibility...",
+        })
+      );
+      await ensureSocketConnected();
+
+      const socket = socketRef.current;
+      if (!socket || !socket.connected) {
+        throw new Error("Socket connection failed");
+      }
+
+      const socketId = socket.id;
+
+      // 2) Start the selenium job via backend
+      dispatch(
+        setTaskStatus({
+          status: "pending",
+          message: "Starting United SCO eligibility check via selenium...",
+        })
+      );
+
+      const response = await apiRequest(
+        "POST",
+        "/api/insurance-status-unitedsco/unitedsco-eligibility",
+        {
+          data: JSON.stringify(payload),
+          socketId,
+        }
+      );
+
+      // If apiRequest threw, we would have caught above; but just in case it returns.
+      let result: any = null;
+      let backendError: string | null = null;
+
+      try {
+        // attempt JSON first
+        result = await response.clone().json();
+        backendError =
+          result?.error || result?.message || result?.detail || null;
+      } catch {
+        // fallback to text response
+        try {
+          const text = await response.clone().text();
+          backendError = text?.trim() || null;
+        } catch {
+          backendError = null;
+        }
+      }
+
+      if (!response.ok) {
+        throw new Error(
+          backendError ||
+            `United SCO selenium start failed (status ${response.status})`
+        );
+      }
+
+      // Normal success path: optional: if backend returns non-error shape still check for result.error
+      if (result?.error) {
+        throw new Error(result.error);
+      }
+
+      if (result.status === "started" && result.session_id) {
+        setSessionId(result.session_id as string);
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message:
+              "United SCO eligibility job started. Waiting for OTP or final result...",
+          })
+        );
+      } else {
+        // fallback if backend returns immediate result
+        dispatch(
+          setTaskStatus({
+            status: "success",
+            message: "United SCO eligibility completed.",
+          })
+        );
+      }
+    } catch (err: any) {
+      console.error("startUnitedSCOEligibility error:", err);
+      dispatch(
+        setTaskStatus({
+          status: "error",
+          message: err?.message || "Failed to start United SCO eligibility",
+        })
+      );
+      toast({
+        title: "United SCO selenium error",
+        description: err?.message || "Failed to start United SCO eligibility",
+        variant: "destructive",
+      });
+    } finally {
+      setIsStarting(false);
+    }
+  };
+
+  const handleSubmitOtp = async (otp: string) => {
+    if (!sessionId || !socketRef.current || !socketRef.current.connected) {
+      toast({
+        title: "Session not ready",
+        description:
+          "Could not submit OTP because the United SCO session or socket is not ready.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    try {
+      setIsSubmittingOtp(true);
+      const resp = await apiRequest(
+        "POST",
+        "/api/insurance-status-unitedsco/selenium/submit-otp",
+        {
+          session_id: sessionId,
+          otp,
+          socketId: socketRef.current.id,
+        }
+      );
+      const data = await resp.json();
+      if (!resp.ok || data.error) {
+        throw new Error(data.error || "Failed to submit OTP");
+      }
+
+      // from here we rely on websocket events (otp_submitted + session_update)
+      setOtpModalOpen(false);
+    } catch (err: any) {
+      console.error("handleSubmitOtp error:", err);
+      toast({
+        title: "Failed to submit OTP",
+        description: err?.message || "Error forwarding OTP to selenium agent",
+        variant: "destructive",
+      });
+    } finally {
+      setIsSubmittingOtp(false);
+    }
+  };
+
+  return (
+    <>
+      <Button
+        className="w-full"
+        variant="outline"
+        disabled={isFormIncomplete || isStarting}
+        onClick={startUnitedSCOEligibility}
+      >
+        {isStarting ? (
+          <>
+            <LoaderCircleIcon className="h-4 w-4 mr-2 animate-spin" />
+            Processing...
+          </>
+        ) : (
+          <>
+            <CheckCircle className="h-4 w-4 mr-2" />
+            United SCO
+          </>
+        )}
+      </Button>
+
+      <UnitedSCOOtpModal
+        open={otpModalOpen}
+        onClose={() => setOtpModalOpen(false)}
+        onSubmit={handleSubmitOtp}
+        isSubmitting={isSubmittingOtp}
+      />
+    </>
+  );
+}

apps/Frontend/src/pages/insurance-status-page.tsx

@@ -29,6 +29,7 @@ import { PdfPreviewModal } from "@/components/insurance-status/pdf-preview-modal
 import { useLocation } from "wouter";
 import { DdmaEligibilityButton } from "@/components/insurance-status/ddma-buton-modal";
 import { DentaQuestEligibilityButton } from "@/components/insurance-status/dentaquest-button-modal";
+import { UnitedSCOEligibilityButton } from "@/components/insurance-status/unitedsco-button-modal";
 
 export default function InsuranceStatusPage() {
   const { user } = useAuth();
@@ -632,14 +633,20 @@ export default function InsuranceStatusPage() {
                   }}
                 />
 
-                <Button
-                  className="w-full"
-                  variant="outline"
-                  disabled={isFormIncomplete}
-                >
-                  <CheckCircle className="h-4 w-4 mr-2" />
-                  United SCO
-                </Button>
+                <UnitedSCOEligibilityButton
+                  memberId={memberId}
+                  dateOfBirth={dateOfBirth}
+                  firstName={firstName}
+                  lastName={lastName}
+                  isFormIncomplete={isFormIncomplete}
+                  onPdfReady={(pdfId, fallbackFilename) => {
+                    setPreviewPdfId(pdfId);
+                    setPreviewFallbackFilename(
+                      fallbackFilename ?? `eligibility_unitedsco_${memberId}.pdf`
+                    );
+                    setPreviewOpen(true);
+                  }}
+                />
 
                 <Button
                   className="w-full"

apps/SeleniumService/agent.py

@@ -10,10 +10,12 @@ import os
 import time
 import helpers_ddma_eligibility as hddma
 import helpers_dentaquest_eligibility as hdentaquest
+import helpers_unitedsco_eligibility as hunitedsco
 
 # Import session clear functions for startup
 from ddma_browser_manager import clear_ddma_session_on_startup
 from dentaquest_browser_manager import clear_dentaquest_session_on_startup
+from unitedsco_browser_manager import clear_unitedsco_session_on_startup
 
 from dotenv import load_dotenv
 load_dotenv() 
@@ -25,6 +27,7 @@ print("SELENIUM AGENT STARTING - CLEARING ALL SESSIONS")
 print("=" * 50)
 clear_ddma_session_on_startup()
 clear_dentaquest_session_on_startup()
+clear_unitedsco_session_on_startup()
 print("=" * 50)
 print("SESSION CLEAR COMPLETE - FRESH LOGINS REQUIRED")
 print("=" * 50)
@@ -275,6 +278,79 @@ async def dentaquest_session_status(sid: str):
     return s
 
 
+# Endpoint:7 - United SCO eligibility (background, OTP)
+
+async def _unitedsco_worker_wrapper(sid: str, data: dict, url: str):
+    """
+    Background worker that:
+      - acquires semaphore (to keep 1 selenium at a time),
+      - updates active/queued counters,
+      - runs the United SCO flow via helpers.start_unitedsco_run.
+    """
+    global active_jobs, waiting_jobs
+    async with semaphore:
+        async with lock:
+            waiting_jobs -= 1
+            active_jobs += 1
+        try:
+            await hunitedsco.start_unitedsco_run(sid, data, url)
+        finally:
+            async with lock:
+                active_jobs -= 1
+
+
+@app.post("/unitedsco-eligibility")
+async def unitedsco_eligibility(request: Request):
+    """
+    Starts a United SCO eligibility session in the background.
+    Body: { "data": { ... }, "url"?: string }
+    Returns: { status: "started", session_id: "<uuid>" }
+    """
+    global waiting_jobs
+
+    body = await request.json()
+    data = body.get("data", {})
+
+    # create session
+    sid = hunitedsco.make_session_entry()
+    hunitedsco.sessions[sid]["type"] = "unitedsco_eligibility"
+    hunitedsco.sessions[sid]["last_activity"] = time.time()
+
+    async with lock:
+        waiting_jobs += 1
+
+    # run in background (queued under semaphore)
+    asyncio.create_task(_unitedsco_worker_wrapper(sid, data, url="https://app.dentalhub.com/app/login"))
+
+    return {"status": "started", "session_id": sid}
+
+
+@app.post("/unitedsco-submit-otp")
+async def unitedsco_submit_otp(request: Request):
+    """
+    Body: { "session_id": "<sid>", "otp": "123456" }
+    Node / frontend call this when user provides OTP for United SCO.
+    """
+    body = await request.json()
+    sid = body.get("session_id")
+    otp = body.get("otp")
+    if not sid or not otp:
+        raise HTTPException(status_code=400, detail="session_id and otp required")
+
+    res = hunitedsco.submit_otp(sid, otp)
+    if res.get("status") == "error":
+        raise HTTPException(status_code=400, detail=res.get("message"))
+    return res
+
+
+@app.get("/unitedsco-session/{sid}/status")
+async def unitedsco_session_status(sid: str):
+    s = hunitedsco.get_session_status(sid)
+    if s.get("status") == "not_found":
+        raise HTTPException(status_code=404, detail="session not found")
+    return s
+
+
 @app.post("/submit-otp")
 async def submit_otp(request: Request):
     """
@@ -311,6 +387,44 @@ async def get_status():
             "status": "busy" if active_jobs > 0 or waiting_jobs > 0 else "idle"
         }
 
+
+# ✅ Clear session endpoints - called when credentials are deleted
+@app.post("/clear-ddma-session")
+async def clear_ddma_session():
+    """
+    Clears the DDMA browser session. Called when DDMA credentials are deleted.
+    """
+    try:
+        clear_ddma_session_on_startup()
+        return {"status": "success", "message": "DDMA session cleared"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+@app.post("/clear-dentaquest-session")
+async def clear_dentaquest_session():
+    """
+    Clears the DentaQuest browser session. Called when DentaQuest credentials are deleted.
+    """
+    try:
+        clear_dentaquest_session_on_startup()
+        return {"status": "success", "message": "DentaQuest session cleared"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+@app.post("/clear-unitedsco-session")
+async def clear_unitedsco_session():
+    """
+    Clears the United SCO browser session. Called when United SCO credentials are deleted.
+    """
+    try:
+        clear_unitedsco_session_on_startup()
+        return {"status": "success", "message": "United SCO session cleared"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
 if __name__ == "__main__":
     host = os.getenv("HOST")
     port = int(os.getenv("PORT"))

apps/SeleniumService/helpers_unitedsco_eligibility.py

@@ -0,0 +1,323 @@
+import os
+import time
+import asyncio
+from typing import Dict, Any
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import WebDriverException, TimeoutException
+
+from selenium_UnitedSCO_eligibilityCheckWorker import AutomationUnitedSCOEligibilityCheck
+
+# In-memory session store
+sessions: Dict[str, Dict[str, Any]] = {}
+
+SESSION_OTP_TIMEOUT = int(os.getenv("SESSION_OTP_TIMEOUT", "120"))  # seconds
+
+
+def make_session_entry() -> str:
+    """Create a new session entry and return its ID."""
+    import uuid
+    sid = str(uuid.uuid4())
+    sessions[sid] = {
+        "status": "created",     # created -> running -> waiting_for_otp -> otp_submitted -> completed / error
+        "created_at": time.time(),
+        "last_activity": time.time(),
+        "bot": None,             # worker instance
+        "driver": None,          # selenium webdriver
+        "otp_event": asyncio.Event(),
+        "otp_value": None,
+        "result": None,
+        "message": None,
+        "type": None,
+    }
+    return sid
+
+
+async def cleanup_session(sid: str, message: str | None = None):
+    """
+    Close driver (if any), wake OTP waiter, set final state, and remove session entry.
+    Idempotent: safe to call multiple times.
+    """
+    s = sessions.get(sid)
+    if not s:
+        return
+    try:
+        # Ensure final state
+        try:
+            if s.get("status") not in ("completed", "error", "not_found"):
+                s["status"] = "error"
+            if message:
+                s["message"] = message
+        except Exception:
+            pass
+
+        # Wake any OTP waiter (so awaiting coroutines don't hang)
+        try:
+            ev = s.get("otp_event")
+            if ev and not ev.is_set():
+                ev.set()
+        except Exception:
+            pass
+
+        # NOTE: Do NOT quit driver - keep browser alive for next patient
+        # Browser manager handles the persistent browser instance
+
+    finally:
+        # Remove session entry from map
+        sessions.pop(sid, None)
+
+
+async def _remove_session_later(sid: str, delay: int = 20):
+    await asyncio.sleep(delay)
+    await cleanup_session(sid)
+
+
+async def start_unitedsco_run(sid: str, data: dict, url: str):
+    """
+    Run the United SCO workflow for a session (WITHOUT managing semaphore/counters).
+    Called by agent.py inside a wrapper that handles queue/counters.
+    """
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+
+    s["status"] = "running"
+    s["last_activity"] = time.time()
+
+    try:
+        bot = AutomationUnitedSCOEligibilityCheck({"data": data})
+        bot.config_driver()
+
+        s["bot"] = bot
+        s["driver"] = bot.driver
+        s["last_activity"] = time.time()
+
+        # Navigate to login URL
+        try:
+            if not url:
+                raise ValueError("URL not provided for United SCO run")
+            bot.driver.maximize_window()
+            bot.driver.get(url)
+            await asyncio.sleep(1)
+        except Exception as e:
+            s["status"] = "error"
+            s["message"] = f"Navigation failed: {e}"
+            await cleanup_session(sid)
+            return {"status": "error", "message": s["message"]}
+
+        # Login
+        try:
+            login_result = bot.login(url)
+        except WebDriverException as wde:
+            s["status"] = "error"
+            s["message"] = f"Selenium driver error during login: {wde}"
+            await cleanup_session(sid, s["message"])
+            return {"status": "error", "message": s["message"]}
+        except Exception as e:
+            s["status"] = "error"
+            s["message"] = f"Unexpected error during login: {e}"
+            await cleanup_session(sid, s["message"])
+            return {"status": "error", "message": s["message"]}
+
+        # Already logged in - session persisted from profile, skip to step1
+        if isinstance(login_result, str) and login_result == "ALREADY_LOGGED_IN":
+            s["status"] = "running"
+            s["message"] = "Session persisted"
+            print("[start_unitedsco_run] Session persisted - skipping OTP")
+            # Continue to step1 below
+
+        # OTP required path - POLL THE BROWSER to detect when user enters OTP
+        elif isinstance(login_result, str) and login_result == "OTP_REQUIRED":
+            s["status"] = "waiting_for_otp"
+            s["message"] = "OTP required for login - please enter OTP in browser"
+            s["last_activity"] = time.time()
+            
+            driver = s["driver"]
+            
+            # Poll the browser to detect when OTP is completed (user enters it directly)
+            # We check every 1 second for up to SESSION_OTP_TIMEOUT seconds (faster response)
+            max_polls = SESSION_OTP_TIMEOUT
+            login_success = False
+            
+            print(f"[UnitedSCO OTP] Waiting for user to enter OTP (polling browser for {SESSION_OTP_TIMEOUT}s)...")
+            
+            for poll in range(max_polls):
+                await asyncio.sleep(1)
+                s["last_activity"] = time.time()
+                
+                try:
+                    # Check if OTP was submitted via API (from app)
+                    otp_value = s.get("otp_value")
+                    if otp_value:
+                        print(f"[UnitedSCO OTP] OTP received from app: {otp_value}")
+                        try:
+                            otp_input = driver.find_element(By.XPATH, 
+                                "//input[contains(@name,'otp') or contains(@name,'code') or @type='tel' or contains(@aria-label,'Verification') or contains(@placeholder,'code')]"
+                            )
+                            otp_input.clear()
+                            otp_input.send_keys(otp_value)
+                            # Click verify button - use same pattern as Delta MA
+                            try:
+                                verify_btn = driver.find_element(By.XPATH, "//button[@type='button' and @aria-label='Verify']")
+                                verify_btn.click()
+                                print("[UnitedSCO OTP] Clicked verify button (aria-label)")
+                            except:
+                                try:
+                                    # Fallback: try other button patterns
+                                    verify_btn = driver.find_element(By.XPATH, "//button[contains(text(),'Verify') or contains(text(),'Submit') or @type='submit']")
+                                    verify_btn.click()
+                                    print("[UnitedSCO OTP] Clicked verify button (text/type)")
+                                except:
+                                    otp_input.send_keys("\n")  # Press Enter as fallback
+                                    print("[UnitedSCO OTP] Pressed Enter as fallback")
+                            print("[UnitedSCO OTP] OTP typed and submitted via app")
+                            s["otp_value"] = None  # Clear so we don't submit again
+                            await asyncio.sleep(3)  # Wait for verification
+                        except Exception as type_err:
+                            print(f"[UnitedSCO OTP] Failed to type OTP from app: {type_err}")
+                    
+                    # Check current URL - if we're on dashboard/member page, login succeeded
+                    current_url = driver.current_url.lower()
+                    print(f"[UnitedSCO OTP Poll {poll+1}/{max_polls}] URL: {current_url[:60]}...")
+                    
+                    # Check if we've navigated away from login/OTP pages
+                    if "member" in current_url or "dashboard" in current_url or "eligibility" in current_url or "home" in current_url:
+                        # Verify by checking for member search input or dashboard element
+                        try:
+                            # Try multiple selectors for logged-in state
+                            dashboard_elem = WebDriverWait(driver, 5).until(
+                                EC.presence_of_element_located((By.XPATH, 
+                                    '//input[@placeholder="Search by member ID"] | //input[contains(@placeholder,"Search")] | //*[contains(@class,"dashboard")]'
+                                ))
+                            )
+                            print("[UnitedSCO OTP] Dashboard/search element found - login successful!")
+                            login_success = True
+                            break
+                        except TimeoutException:
+                            print("[UnitedSCO OTP] On member page but search input not found, continuing to poll...")
+                    
+                    # Also check if OTP input is still visible
+                    try:
+                        otp_input = driver.find_element(By.XPATH, 
+                            "//input[contains(@name,'otp') or contains(@name,'code') or @type='tel' or contains(@aria-label,'Verification') or contains(@placeholder,'code') or contains(@placeholder,'Code')]"
+                        )
+                        # OTP input still visible - user hasn't entered OTP yet
+                        print(f"[UnitedSCO OTP Poll {poll+1}] OTP input still visible - waiting...")
+                    except:
+                        # OTP input not found - might mean login is in progress or succeeded
+                        # Try navigating to dashboard
+                        if "login" in current_url or "app/login" in current_url:
+                            print("[UnitedSCO OTP] OTP input gone, trying to navigate to dashboard...")
+                            try:
+                                driver.get("https://app.dentalhub.com/app/dashboard")
+                                await asyncio.sleep(2)
+                            except:
+                                pass
+                
+                except Exception as poll_err:
+                    print(f"[UnitedSCO OTP Poll {poll+1}] Error: {poll_err}")
+            
+            if not login_success:
+                # Final attempt - navigate to dashboard and check
+                try:
+                    print("[UnitedSCO OTP] Final attempt - navigating to dashboard...")
+                    driver.get("https://app.dentalhub.com/app/dashboard")
+                    await asyncio.sleep(3)
+                    
+                    dashboard_elem = WebDriverWait(driver, 10).until(
+                        EC.presence_of_element_located((By.XPATH, 
+                            '//input[@placeholder="Search by member ID"] | //input[contains(@placeholder,"Search")] | //*[contains(@class,"dashboard")]'
+                        ))
+                    )
+                    print("[UnitedSCO OTP] Dashboard element found - login successful!")
+                    login_success = True
+                except TimeoutException:
+                    s["status"] = "error"
+                    s["message"] = "OTP timeout - login not completed"
+                    await cleanup_session(sid)
+                    return {"status": "error", "message": "OTP not completed in time"}
+                except Exception as final_err:
+                    s["status"] = "error"
+                    s["message"] = f"OTP verification failed: {final_err}"
+                    await cleanup_session(sid)
+                    return {"status": "error", "message": s["message"]}
+            
+            if login_success:
+                s["status"] = "running"
+                s["message"] = "Login successful after OTP"
+                print("[UnitedSCO OTP] Proceeding to step1...")
+
+        elif isinstance(login_result, str) and login_result.startswith("ERROR"):
+            s["status"] = "error"
+            s["message"] = login_result
+            await cleanup_session(sid)
+            return {"status": "error", "message": login_result}
+
+        # Login succeeded without OTP (SUCCESS)
+        elif isinstance(login_result, str) and login_result == "SUCCESS":
+            print("[start_unitedsco_run] Login succeeded without OTP")
+            s["status"] = "running"
+            s["message"] = "Login succeeded"
+            # Continue to step1 below
+
+        # Step 1
+        step1_result = bot.step1()
+        if isinstance(step1_result, str) and step1_result.startswith("ERROR"):
+            s["status"] = "error"
+            s["message"] = step1_result
+            await cleanup_session(sid)
+            return {"status": "error", "message": step1_result}
+
+        # Step 2 (PDF)
+        step2_result = bot.step2()
+        if isinstance(step2_result, dict) and step2_result.get("status") == "success":
+            s["status"] = "completed"
+            s["result"] = step2_result
+            s["message"] = "completed"
+            asyncio.create_task(_remove_session_later(sid, 30))
+            return step2_result
+        else:
+            s["status"] = "error"
+            if isinstance(step2_result, dict):
+                s["message"] = step2_result.get("message", "unknown error")
+            else:
+                s["message"] = str(step2_result)
+            await cleanup_session(sid)
+            return {"status": "error", "message": s["message"]}
+
+    except Exception as e:
+        s["status"] = "error"
+        s["message"] = f"worker exception: {e}"
+        await cleanup_session(sid)
+        return {"status": "error", "message": s["message"]}
+
+
+def submit_otp(sid: str, otp: str) -> Dict[str, Any]:
+    """Set OTP for a session and wake waiting runner."""
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+    if s.get("status") != "waiting_for_otp":
+        return {"status": "error", "message": f"session not waiting for otp (state={s.get('status')})"}
+    s["otp_value"] = otp
+    s["last_activity"] = time.time()
+    try:
+        s["otp_event"].set()
+    except Exception:
+        pass
+    return {"status": "ok", "message": "otp accepted"}
+
+
+def get_session_status(sid: str) -> Dict[str, Any]:
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "not_found"}
+    return {
+        "session_id": sid,
+        "status": s.get("status"),
+        "message": s.get("message"),
+        "created_at": s.get("created_at"),
+        "last_activity": s.get("last_activity"),
+        "result": s.get("result") if s.get("status") == "completed" else None,
+    }

apps/SeleniumService/selenium_DDMA_eligibilityCheckWorker.py

@@ -391,8 +391,8 @@ class AutomationDeltaDentalMAEligibilityCheck:
                 except:
                     pass
 
-            # 2) Click on patient name to navigate to detailed patient page
-            print("[DDMA step2] Clicking on patient name to open detailed page...")
+            # 2) Extract patient name and click to navigate to detailed patient page
+            print("[DDMA step2] Extracting patient name and finding detail link...")
             patient_name_clicked = False
             patientName = ""
             
@@ -400,6 +400,29 @@ class AutomationDeltaDentalMAEligibilityCheck:
             current_url_before = self.driver.current_url
             print(f"[DDMA step2] Current URL before click: {current_url_before}")
             
+            # Try to extract patient name from the first row of search results
+            # This is more reliable than extracting from link text
+            name_extraction_selectors = [
+                "(//tbody//tr)[1]//td[1]",  # First column of first row (usually name)
+                "(//table//tbody//tr)[1]//td[1]",  # Alternative table structure
+                "//table//tr[2]//td[1]",  # Skip header row
+                "(//tbody//tr)[1]//td[contains(@class,'name')]",  # Name column by class
+                "(//tbody//tr)[1]//a",  # Link in first row (might contain name)
+            ]
+            
+            for selector in name_extraction_selectors:
+                try:
+                    elem = self.driver.find_element(By.XPATH, selector)
+                    text = elem.text.strip()
+                    # Filter out non-name text
+                    if text and len(text) > 1 and len(text) < 100:
+                        if not any(x in text.lower() for x in ['active', 'inactive', 'eligible', 'search', 'date', 'print', 'view', 'details', 'status']):
+                            patientName = text
+                            print(f"[DDMA step2] Extracted patient name from search results: '{patientName}'")
+                            break
+                except Exception:
+                    continue
+            
             # Try to find all links in the first row and print them for debugging
             try:
                 all_links = self.driver.find_elements(By.XPATH, "(//tbody//tr)[1]//a")
@@ -408,6 +431,11 @@ class AutomationDeltaDentalMAEligibilityCheck:
                     href = link.get_attribute("href") or "no-href"
                     text = link.text.strip() or "(empty text)"
                     print(f"  Link {i}: href={href[:80]}..., text={text}")
+                    # Also try to get name from link if we haven't found it yet
+                    if not patientName and text and len(text) > 1:
+                        if not any(x in text.lower() for x in ['active', 'inactive', 'eligible', 'search', 'view', 'details']):
+                            patientName = text
+                            print(f"[DDMA step2] Got patient name from link text: '{patientName}'")
             except Exception as e:
                 print(f"[DDMA step2] Error listing links: {e}")
             
@@ -424,9 +452,14 @@ class AutomationDeltaDentalMAEligibilityCheck:
                     patient_link = WebDriverWait(self.driver, 5).until(
                         EC.presence_of_element_located((By.XPATH, selector))
                     )
-                    patientName = patient_link.text.strip()
+                    link_text = patient_link.text.strip()
                     href = patient_link.get_attribute("href")
-                    print(f"[DDMA step2] Found patient link: text='{patientName}', href={href}")
+                    print(f"[DDMA step2] Found patient link: text='{link_text}', href={href}")
+                    
+                    # Use link text as name if we don't have one yet
+                    if not patientName and link_text and len(link_text) > 1:
+                        if not any(x in link_text.lower() for x in ['active', 'inactive', 'view', 'details']):
+                            patientName = link_text
                     
                     if href and "member-details" in href:
                         detail_url = href
@@ -507,30 +540,70 @@ class AutomationDeltaDentalMAEligibilityCheck:
                 # Try to extract patient name from detailed page if not already found
                 if not patientName:
                     detail_name_selectors = [
-                        "//h1",
-                        "//h2",
-                        "//*[contains(@class,'patient-name') or contains(@class,'member-name')]",
-                        "//div[contains(@class,'header')]//span",
+                        "//*[contains(@class,'member-name')]",
+                        "//*[contains(@class,'patient-name')]",
+                        "//h1[not(contains(@class,'page-title'))]",
+                        "//h2[not(contains(@class,'section-title'))]",
+                        "//div[contains(@class,'header')]//span[string-length(text()) > 2]",
+                        "//div[contains(@class,'member-info')]//span",
+                        "//div[contains(@class,'patient-info')]//span",
+                        "//span[contains(@class,'name')]",
                     ]
                     for selector in detail_name_selectors:
                         try:
                             name_elem = self.driver.find_element(By.XPATH, selector)
                             name_text = name_elem.text.strip()
-                            if name_text and len(name_text) > 1:
-                                if not any(x in name_text.lower() for x in ['active', 'inactive', 'eligible', 'search', 'date', 'print']):
+                            if name_text and len(name_text) > 2 and len(name_text) < 100:
+                                # Filter out common non-name text
+                                skip_words = ['active', 'inactive', 'eligible', 'search', 'date', 'print', 
+                                             'view', 'details', 'member', 'patient', 'status', 'eligibility',
+                                             'welcome', 'home', 'logout', 'menu', 'close', 'expand']
+                                if not any(x in name_text.lower() for x in skip_words):
                                     patientName = name_text
                                     print(f"[DDMA step2] Found patient name on detail page: {patientName}")
                                     break
                         except:
                             continue
+                
+                # As a last resort, try to find name in page text using patterns
+                if not patientName:
+                    try:
+                        # Look for text that looks like a name (First Last format)
+                        import re
+                        page_text = self.driver.find_element(By.TAG_NAME, "body").text
+                        # Look for "Member Name:" or "Patient Name:" followed by text
+                        name_patterns = [
+                            r'Member Name[:\s]+([A-Z][a-z]+\s+[A-Z][a-z]+)',
+                            r'Patient Name[:\s]+([A-Z][a-z]+\s+[A-Z][a-z]+)',
+                            r'Name[:\s]+([A-Z][a-z]+\s+[A-Z][a-z]+)',
+                        ]
+                        for pattern in name_patterns:
+                            match = re.search(pattern, page_text, re.IGNORECASE)
+                            if match:
+                                patientName = match.group(1).strip()
+                                print(f"[DDMA step2] Found patient name via pattern match: {patientName}")
+                                break
+                    except:
+                        pass
             else:
                 print("[DDMA step2] Warning: Could not click on patient, capturing search results page")
                 # Still try to get patient name from search results
-                try:
-                    name_elem = self.driver.find_element(By.XPATH, "(//tbody//tr)[1]//td[1]")
-                    patientName = name_elem.text.strip()
-                except:
-                    pass
+                if not patientName:
+                    name_selectors = [
+                        "(//tbody//tr)[1]//td[1]",  # First column of first row
+                        "(//table//tbody//tr)[1]//td[1]",
+                        "(//tbody//tr)[1]//a",  # Link in first row
+                    ]
+                    for selector in name_selectors:
+                        try:
+                            name_elem = self.driver.find_element(By.XPATH, selector)
+                            text = name_elem.text.strip()
+                            if text and len(text) > 1 and not any(x in text.lower() for x in ['active', 'inactive', 'view', 'details']):
+                                patientName = text
+                                print(f"[DDMA step2] Got patient name from search results: {patientName}")
+                                break
+                        except:
+                            continue
 
             if not patientName:
                 print("[DDMA step2] Could not extract patient name")

apps/SeleniumService/selenium_DentaQuest_eligibilityCheckWorker.py

@@ -285,16 +285,34 @@ class AutomationDentaQuestEligibilityCheck:
                     
                     def replace_with_sendkeys(el, value):
                         el.click()
-                        time.sleep(0.05)
+                        time.sleep(0.1)
+                        # Clear existing content
                         el.send_keys(Keys.CONTROL, "a")
+                        time.sleep(0.05)
                         el.send_keys(Keys.BACKSPACE)
+                        time.sleep(0.05)
+                        # Type new value
                         el.send_keys(value)
+                        time.sleep(0.1)
 
+                    # Fill month
                     replace_with_sendkeys(month_elem, month_val)
+                    # Tab to day field
+                    month_elem.send_keys(Keys.TAB)
                     time.sleep(0.1)
+                    
+                    # Fill day
                     replace_with_sendkeys(day_elem, day_val)
+                    # Tab to year field
+                    day_elem.send_keys(Keys.TAB)
                     time.sleep(0.1)
+                    
+                    # Fill year
                     replace_with_sendkeys(year_elem, year_val)
+                    # Tab out of the field to trigger validation
+                    year_elem.send_keys(Keys.TAB)
+                    time.sleep(0.2)
+                    
                     print(f"[DentaQuest step1] Filled {field_name}: {month_val}/{day_val}/{year_val}")
                     return True
                 except Exception as e:
@@ -303,11 +321,11 @@ class AutomationDentaQuestEligibilityCheck:
 
             # 1. Fill Date of Service with TODAY's date using specific data-testid
             fill_date_by_testid("member-search_date-of-service", service_month, service_day, service_year, "Date of Service")
-            time.sleep(0.3)
+            time.sleep(0.5)
 
             # 2. Fill Date of Birth with patient's DOB using specific data-testid
             fill_date_by_testid("member-search_date-of-birth", dob_month, dob_day, dob_year, "Date of Birth")
-            time.sleep(0.3)
+            time.sleep(0.5)
 
             # 3. Fill Member ID
             member_id_input = wait.until(EC.presence_of_element_located(
@@ -406,6 +424,25 @@ class AutomationDentaQuestEligibilityCheck:
             current_url_before = self.driver.current_url
             print(f"[DentaQuest step2] Current URL before: {current_url_before}")
             
+            # Try to extract patient name from search results first
+            name_extraction_selectors = [
+                "(//tbody//tr)[1]//td[1]",  # First column of first row
+                "(//table//tbody//tr)[1]//td[1]",
+                "//table//tr[2]//td[1]",  # Skip header row
+                "(//tbody//tr)[1]//a",  # Link in first row
+            ]
+            for selector in name_extraction_selectors:
+                try:
+                    elem = self.driver.find_element(By.XPATH, selector)
+                    text = elem.text.strip()
+                    if text and len(text) > 1 and len(text) < 100:
+                        if not any(x in text.lower() for x in ['active', 'inactive', 'eligible', 'search', 'view', 'details', 'status']):
+                            patientName = text
+                            print(f"[DentaQuest step2] Extracted patient name from search results: '{patientName}'")
+                            break
+                except:
+                    continue
+            
             # Find all links in first row and log them
             try:
                 all_links = self.driver.find_elements(By.XPATH, "(//tbody//tr)[1]//a")

apps/SeleniumService/selenium_UnitedSCO_eligibilityCheckWorker.py

@@ -0,0 +1,637 @@
+from selenium import webdriver
+from selenium.common.exceptions import WebDriverException, TimeoutException
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from webdriver_manager.chrome import ChromeDriverManager
+import time
+import os
+import base64
+
+from unitedsco_browser_manager import get_browser_manager
+
+class AutomationUnitedSCOEligibilityCheck:    
+    def __init__(self, data):
+        self.headless = False
+        self.driver = None
+
+        self.data = data.get("data", {}) if isinstance(data, dict) else {}
+
+        # Flatten values for convenience
+        self.memberId = self.data.get("memberId", "")
+        self.dateOfBirth = self.data.get("dateOfBirth", "")
+        self.firstName = self.data.get("firstName", "")
+        self.lastName = self.data.get("lastName", "")
+        self.unitedsco_username = self.data.get("unitedscoUsername", "")
+        self.unitedsco_password = self.data.get("unitedscoPassword", "")
+
+        # Use browser manager's download dir
+        self.download_dir = get_browser_manager().download_dir
+        os.makedirs(self.download_dir, exist_ok=True)
+
+    def config_driver(self):
+        # Use persistent browser from manager (keeps device trust tokens)
+        self.driver = get_browser_manager().get_driver(self.headless)
+
+    def _force_logout(self):
+        """Force logout by clearing cookies for United SCO domain."""
+        try:
+            print("[UnitedSCO login] Forcing logout due to credential change...")
+            browser_manager = get_browser_manager()
+            
+            # First try to click logout button if visible
+            try:
+                self.driver.get("https://app.dentalhub.com/app/dashboard")
+                time.sleep(2)
+                
+                logout_selectors = [
+                    "//button[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
+                    "//a[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
+                    "//button[@aria-label='Log out' or @aria-label='Logout' or @aria-label='Sign out']",
+                    "//*[contains(@class, 'logout') or contains(@class, 'signout')]"
+                ]
+                
+                for selector in logout_selectors:
+                    try:
+                        logout_btn = WebDriverWait(self.driver, 3).until(
+                            EC.element_to_be_clickable((By.XPATH, selector))
+                        )
+                        logout_btn.click()
+                        print("[UnitedSCO login] Clicked logout button")
+                        time.sleep(2)
+                        break
+                    except TimeoutException:
+                        continue
+            except Exception as e:
+                print(f"[UnitedSCO login] Could not click logout button: {e}")
+            
+            # Clear cookies as backup
+            try:
+                self.driver.delete_all_cookies()
+                print("[UnitedSCO login] Cleared all cookies")
+            except Exception as e:
+                print(f"[UnitedSCO login] Error clearing cookies: {e}")
+            
+            browser_manager.clear_credentials_hash()
+            print("[UnitedSCO login] Logout complete")
+            return True
+        except Exception as e:
+            print(f"[UnitedSCO login] Error during forced logout: {e}")
+            return False
+
+    def login(self, url):
+        wait = WebDriverWait(self.driver, 30)
+        browser_manager = get_browser_manager()
+        
+        try:
+            # Check if credentials have changed - if so, force logout first
+            if self.unitedsco_username and browser_manager.credentials_changed(self.unitedsco_username):
+                self._force_logout()
+                self.driver.get(url)
+                time.sleep(2)
+            
+            # First check if we're already on a logged-in page (from previous run)
+            try:
+                current_url = self.driver.current_url
+                print(f"[UnitedSCO login] Current URL: {current_url}")
+                
+                # Check if we're already on dentalhub dashboard (not the login page)
+                if "app.dentalhub.com" in current_url and "login" not in current_url.lower():
+                    try:
+                        # Look for dashboard element or member search
+                        dashboard_elem = WebDriverWait(self.driver, 3).until(
+                            EC.presence_of_element_located((By.XPATH, 
+                                '//input[contains(@placeholder,"Search")] | //*[contains(@class,"dashboard")] | '
+                                '//a[contains(@href,"member")] | //nav'))
+                        )
+                        print("[UnitedSCO login] Already logged in - on dashboard")
+                        return "ALREADY_LOGGED_IN"
+                    except TimeoutException:
+                        pass
+            except Exception as e:
+                print(f"[UnitedSCO login] Error checking current state: {e}")
+            
+            # Navigate to login URL
+            self.driver.get(url)
+            time.sleep(3)
+            
+            current_url = self.driver.current_url
+            print(f"[UnitedSCO login] After navigation URL: {current_url}")
+            
+            # If already on dentalhub dashboard (not login page), we're logged in
+            if "app.dentalhub.com" in current_url and "login" not in current_url.lower():
+                print("[UnitedSCO login] Already on dashboard")
+                return "ALREADY_LOGGED_IN"
+            
+            # Check for OTP input first (in case we're on B2C OTP page)
+            try:
+                otp_input = WebDriverWait(self.driver, 3).until(
+                    EC.presence_of_element_located((By.XPATH, 
+                        "//input[@type='tel' or contains(@placeholder,'code') or contains(@aria-label,'Verification')]"))
+                )
+                print("[UnitedSCO login] OTP input found")
+                return "OTP_REQUIRED"
+            except TimeoutException:
+                pass
+            
+            # Step 1: Click the LOGIN button on the initial dentalhub page
+            # This redirects to Azure B2C login
+            if "app.dentalhub.com" in current_url:
+                try:
+                    login_btn = WebDriverWait(self.driver, 5).until(
+                        EC.element_to_be_clickable((By.XPATH, 
+                            "//button[contains(text(),'LOGIN') or contains(text(),'Log In') or contains(text(),'Login')]"))
+                    )
+                    login_btn.click()
+                    print("[UnitedSCO login] Clicked LOGIN button on dentalhub.com")
+                    time.sleep(5)  # Wait for redirect to B2C login page
+                except TimeoutException:
+                    print("[UnitedSCO login] No LOGIN button found on dentalhub page, proceeding...")
+            
+            # Now we should be on the Azure B2C login page (dentalhubauth.b2clogin.com)
+            current_url = self.driver.current_url
+            print(f"[UnitedSCO login] After LOGIN click URL: {current_url}")
+            
+            # Step 2: Fill in credentials on B2C login page
+            if "b2clogin.com" in current_url or "login" in current_url.lower():
+                print("[UnitedSCO login] On B2C login page - filling credentials")
+                
+                try:
+                    # Find email field by id="signInName" (Azure B2C specific)
+                    email_field = WebDriverWait(self.driver, 10).until(
+                        EC.element_to_be_clickable((By.XPATH, 
+                            "//input[@id='signInName' or @name='signInName' or @name='Email address' or @type='email']"))
+                    )
+                    email_field.clear()
+                    email_field.send_keys(self.unitedsco_username)
+                    print(f"[UnitedSCO login] Entered username: {self.unitedsco_username}")
+                    
+                    # Find password field by id="password"
+                    password_field = WebDriverWait(self.driver, 10).until(
+                        EC.presence_of_element_located((By.XPATH, 
+                            "//input[@id='password' or @type='password']"))
+                    )
+                    password_field.clear()
+                    password_field.send_keys(self.unitedsco_password)
+                    print("[UnitedSCO login] Entered password")
+                    
+                    # Click "Sign in" button (id="next" on B2C page)
+                    signin_button = WebDriverWait(self.driver, 10).until(
+                        EC.element_to_be_clickable((By.XPATH, 
+                            "//button[@id='next'] | //button[@type='submit' and contains(text(),'Sign')]"))
+                    )
+                    signin_button.click()
+                    print("[UnitedSCO login] Clicked Sign in button")
+                    
+                    # Save credentials hash after login attempt
+                    if self.unitedsco_username:
+                        browser_manager.save_credentials_hash(self.unitedsco_username)
+                    
+                    time.sleep(5)  # Wait for login to process
+                    
+                    # Check for OTP input after login
+                    try:
+                        otp_input = WebDriverWait(self.driver, 15).until(
+                            EC.presence_of_element_located((By.XPATH, 
+                                "//input[@type='tel' or contains(@placeholder,'code') or contains(@placeholder,'Code') or "
+                                "contains(@aria-label,'Verification') or contains(@aria-label,'verification') or "
+                                "contains(@aria-label,'Code') or contains(@aria-label,'code') or "
+                                "contains(@placeholder,'verification') or contains(@placeholder,'Verification') or "
+                                "contains(@name,'otp') or contains(@name,'code') or contains(@id,'otp') or contains(@id,'code')]"
+                            ))
+                        )
+                        print("[UnitedSCO login] OTP input detected -> OTP_REQUIRED")
+                        return "OTP_REQUIRED"
+                    except TimeoutException:
+                        print("[UnitedSCO login] No OTP input detected")
+                    
+                    # Check if login succeeded (redirected back to dentalhub dashboard)
+                    current_url_after_login = self.driver.current_url.lower()
+                    print(f"[UnitedSCO login] After login URL: {current_url_after_login}")
+                    
+                    if "app.dentalhub.com" in current_url_after_login and "login" not in current_url_after_login:
+                        print("[UnitedSCO login] Login successful - redirected to dashboard")
+                        return "SUCCESS"
+                    
+                    # Check for error messages on B2C page
+                    try:
+                        error_elem = self.driver.find_element(By.XPATH, 
+                            "//*[contains(@class,'error') or contains(@class,'alert')]")
+                        error_text = error_elem.text
+                        if error_text:
+                            print(f"[UnitedSCO login] Error on page: {error_text}")
+                            return f"ERROR: {error_text}"
+                    except:
+                        pass
+                    
+                    # Still on B2C page - might need OTP or login failed
+                    if "b2clogin.com" in current_url_after_login:
+                        print("[UnitedSCO login] Still on B2C page - checking for OTP or error")
+                        # Give it more time for OTP
+                        try:
+                            otp_input = WebDriverWait(self.driver, 10).until(
+                                EC.presence_of_element_located((By.XPATH, 
+                                    "//input[@type='tel' or contains(@id,'code') or contains(@name,'code')]"))
+                            )
+                            print("[UnitedSCO login] OTP input found on second check")
+                            return "OTP_REQUIRED"
+                        except TimeoutException:
+                            return "ERROR: Login failed - still on B2C page"
+                    
+                except TimeoutException as te:
+                    print(f"[UnitedSCO login] Login form elements not found: {te}")
+                    return "ERROR: Login form not found"
+                except Exception as form_err:
+                    print(f"[UnitedSCO login] Error filling form: {form_err}")
+                    return f"ERROR: {form_err}"
+            
+            # If we got here without going through login, we're already logged in
+            return "SUCCESS"
+                
+        except Exception as e:
+            print(f"[UnitedSCO login] Exception: {e}")
+            return f"ERROR:LOGIN FAILED: {e}"
+
+    def _format_dob(self, dob_str):
+        """Convert DOB from YYYY-MM-DD to MM/DD/YYYY format"""
+        if dob_str and "-" in dob_str:
+            dob_parts = dob_str.split("-")
+            if len(dob_parts) == 3:
+                # YYYY-MM-DD -> MM/DD/YYYY
+                return f"{dob_parts[1]}/{dob_parts[2]}/{dob_parts[0]}"
+        return dob_str
+
+    def step1(self):
+        """
+        Navigate to Eligibility page and fill the Patient Information form.
+        
+        FLEXIBLE INPUT SUPPORT:
+        - If Member ID is provided: Fill Subscriber ID + DOB (+ optional First/Last Name)
+        - If no Member ID but First/Last Name provided: Fill First Name + Last Name + DOB
+        
+        Workflow:
+        1. Navigate directly to eligibility page
+        2. Fill available fields based on input
+        3. Select Payer: "UnitedHealthcare Massachusetts" from ng-select dropdown
+        4. Click Continue
+        5. Handle Practitioner & Location page - click paymentGroupId dropdown, select Summit Dental Care
+        6. Click Continue again
+        """
+        from selenium.webdriver.common.action_chains import ActionChains
+        
+        try:
+            # Determine which input mode to use
+            has_member_id = bool(self.memberId and self.memberId.strip())
+            has_name = bool(self.firstName and self.firstName.strip() and self.lastName and self.lastName.strip())
+            
+            if has_member_id:
+                print(f"[UnitedSCO step1] Using Member ID mode: ID={self.memberId}, DOB={self.dateOfBirth}")
+            elif has_name:
+                print(f"[UnitedSCO step1] Using Name mode: {self.firstName} {self.lastName}, DOB={self.dateOfBirth}")
+            else:
+                print("[UnitedSCO step1] ERROR: Need either Member ID or First Name + Last Name")
+                return "ERROR: Missing required input (Member ID or Name)"
+            
+            # Navigate directly to eligibility page
+            print("[UnitedSCO step1] Navigating to eligibility page...")
+            self.driver.get("https://app.dentalhub.com/app/patient/eligibility")
+            time.sleep(3)
+            
+            current_url = self.driver.current_url
+            print(f"[UnitedSCO step1] Current URL: {current_url}")
+            
+            # Step 1.1: Fill the Patient Information form
+            print("[UnitedSCO step1] Filling Patient Information form...")
+            
+            # Wait for form to load
+            try:
+                WebDriverWait(self.driver, 10).until(
+                    EC.presence_of_element_located((By.ID, "subscriberId_Front"))
+                )
+                print("[UnitedSCO step1] Patient Information form loaded")
+            except TimeoutException:
+                print("[UnitedSCO step1] Patient Information form not found")
+                return "ERROR: Patient Information form not found"
+            
+            # Fill Subscriber ID if provided (id='subscriberId_Front')
+            if has_member_id:
+                try:
+                    subscriber_id_input = self.driver.find_element(By.ID, "subscriberId_Front")
+                    subscriber_id_input.clear()
+                    subscriber_id_input.send_keys(self.memberId)
+                    print(f"[UnitedSCO step1] Entered Subscriber ID: {self.memberId}")
+                except Exception as e:
+                    print(f"[UnitedSCO step1] Error entering Subscriber ID: {e}")
+            
+            # Fill First Name if provided (id='firstName_Back')
+            if self.firstName and self.firstName.strip():
+                try:
+                    first_name_input = self.driver.find_element(By.ID, "firstName_Back")
+                    first_name_input.clear()
+                    first_name_input.send_keys(self.firstName)
+                    print(f"[UnitedSCO step1] Entered First Name: {self.firstName}")
+                except Exception as e:
+                    print(f"[UnitedSCO step1] Error entering First Name: {e}")
+                    if not has_member_id:  # Only fail if we're relying on name
+                        return "ERROR: Could not enter First Name"
+            
+            # Fill Last Name if provided (id='lastName_Back')
+            if self.lastName and self.lastName.strip():
+                try:
+                    last_name_input = self.driver.find_element(By.ID, "lastName_Back")
+                    last_name_input.clear()
+                    last_name_input.send_keys(self.lastName)
+                    print(f"[UnitedSCO step1] Entered Last Name: {self.lastName}")
+                except Exception as e:
+                    print(f"[UnitedSCO step1] Error entering Last Name: {e}")
+                    if not has_member_id:  # Only fail if we're relying on name
+                        return "ERROR: Could not enter Last Name"
+            
+            # Fill Date of Birth (id='dateOfBirth_Back', format: MM/DD/YYYY) - always required
+            try:
+                dob_input = self.driver.find_element(By.ID, "dateOfBirth_Back")
+                dob_input.clear()
+                dob_formatted = self._format_dob(self.dateOfBirth)
+                dob_input.send_keys(dob_formatted)
+                print(f"[UnitedSCO step1] Entered DOB: {dob_formatted}")
+            except Exception as e:
+                print(f"[UnitedSCO step1] Error entering DOB: {e}")
+                return "ERROR: Could not enter Date of Birth"
+            
+            time.sleep(1)
+            
+            # Step 1.2: Select Payer - UnitedHealthcare Massachusetts
+            print("[UnitedSCO step1] Selecting Payer...")
+            try:
+                # Click the Payer ng-select dropdown
+                payer_ng_select = self.driver.find_element(By.XPATH, 
+                    "//label[contains(text(),'Payer')]/following-sibling::ng-select"
+                )
+                payer_ng_select.click()
+                time.sleep(1)
+                
+                # Find and click "UnitedHealthcare Massachusetts" option
+                payer_options = self.driver.find_elements(By.XPATH, 
+                    "//ng-dropdown-panel//div[contains(@class,'ng-option')]"
+                )
+                for opt in payer_options:
+                    if "UnitedHealthcare Massachusetts" in opt.text:
+                        opt.click()
+                        print("[UnitedSCO step1] Selected Payer: UnitedHealthcare Massachusetts")
+                        break
+                
+                # Press Escape to close any dropdown
+                ActionChains(self.driver).send_keys(Keys.ESCAPE).perform()
+                time.sleep(1)
+                
+            except Exception as e:
+                print(f"[UnitedSCO step1] Error selecting Payer: {e}")
+                # Try to continue anyway - payer might be pre-selected
+                ActionChains(self.driver).send_keys(Keys.ESCAPE).perform()
+            
+            # Step 1.3: Click Continue button (Step 1 - Patient Info)
+            try:
+                continue_btn = WebDriverWait(self.driver, 10).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button[contains(text(),'Continue')]"))
+                )
+                continue_btn.click()
+                print("[UnitedSCO step1] Clicked Continue button (Patient Info)")
+                time.sleep(4)
+            except Exception as e:
+                print(f"[UnitedSCO step1] Error clicking Continue: {e}")
+                return "ERROR: Could not click Continue button"
+            
+            # Step 1.4: Handle Practitioner & Location page
+            print("[UnitedSCO step1] Handling Practitioner & Location page...")
+            try:
+                # Click Practitioner Taxonomy dropdown (id='paymentGroupId')
+                taxonomy_input = WebDriverWait(self.driver, 10).until(
+                    EC.element_to_be_clickable((By.ID, "paymentGroupId"))
+                )
+                taxonomy_input.click()
+                print("[UnitedSCO step1] Clicked Practitioner Taxonomy dropdown")
+                time.sleep(1)
+                
+                # Select "Summit Dental Care" option
+                summit_option = WebDriverWait(self.driver, 10).until(
+                    EC.element_to_be_clickable((By.XPATH, 
+                        "//ng-dropdown-panel//div[contains(@class,'ng-option') and contains(.,'Summit Dental Care')]"
+                    ))
+                )
+                summit_option.click()
+                print("[UnitedSCO step1] Selected: Summit Dental Care")
+                
+                # Press Escape to close dropdown
+                ActionChains(self.driver).send_keys(Keys.ESCAPE).perform()
+                time.sleep(1)
+                
+            except TimeoutException:
+                print("[UnitedSCO step1] Practitioner Taxonomy not found or already selected")
+            except Exception as e:
+                print(f"[UnitedSCO step1] Practitioner Taxonomy handling: {e}")
+            
+            # Step 1.5: Click Continue button (Step 2 - Practitioner)
+            try:
+                continue_btn2 = WebDriverWait(self.driver, 10).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button[contains(text(),'Continue')]"))
+                )
+                continue_btn2.click()
+                print("[UnitedSCO step1] Clicked Continue button (Practitioner)")
+                time.sleep(5)
+            except Exception as e:
+                print(f"[UnitedSCO step1] Error clicking Continue on Practitioner page: {e}")
+            
+            # Check for errors
+            try:
+                error_selectors = [
+                    "//*[contains(text(),'No results')]",
+                    "//*[contains(text(),'not found')]",
+                    "//*[contains(text(),'Invalid')]",
+                ]
+                for sel in error_selectors:
+                    try:
+                        error_elem = self.driver.find_element(By.XPATH, sel)
+                        if error_elem and error_elem.is_displayed():
+                            error_text = error_elem.text
+                            print(f"[UnitedSCO step1] Error found: {error_text}")
+                            return f"ERROR: {error_text}"
+                    except:
+                        continue
+            except:
+                pass
+            
+            print("[UnitedSCO step1] Patient search completed successfully")
+            return "Success"
+
+        except Exception as e: 
+            print(f"[UnitedSCO step1] Exception: {e}")
+            return f"ERROR:STEP1 - {e}"
+
+    
+    def step2(self):
+        """
+        Navigate to eligibility detail page and capture PDF.
+        
+        At this point we should be on the "Selected Patient" page after step1.
+        Workflow based on actual DOM testing:
+        1. Extract eligibility status and Member ID from the page
+        2. Click the "Eligibility" button (id='eligibility-link')
+        3. Generate PDF using Chrome DevTools Protocol (same as other insurances)
+        """
+        try:
+            print("[UnitedSCO step2] Starting eligibility capture")
+            
+            # Wait for page to load
+            time.sleep(3)
+            
+            current_url = self.driver.current_url
+            print(f"[UnitedSCO step2] Current URL: {current_url}")
+            
+            # 1) Extract eligibility status and Member ID from the Selected Patient page
+            eligibilityText = "unknown"
+            patientName = f"{self.firstName} {self.lastName}".strip()
+            foundMemberId = self.memberId  # Use provided memberId as default
+            
+            # Extract eligibility status
+            try:
+                status_elem = WebDriverWait(self.driver, 10).until(
+                    EC.presence_of_element_located((By.XPATH,
+                        "//*[contains(text(),'Member Eligible')]"
+                    ))
+                )
+                status_text = status_elem.text.strip().lower()
+                print(f"[UnitedSCO step2] Found status: {status_text}")
+                
+                if "eligible" in status_text:
+                    eligibilityText = "active"
+                elif "ineligible" in status_text or "not eligible" in status_text:
+                    eligibilityText = "inactive"
+                    
+            except TimeoutException:
+                print("[UnitedSCO step2] Eligibility status badge not found")
+            except Exception as e:
+                print(f"[UnitedSCO step2] Error extracting status: {e}")
+            
+            print(f"[UnitedSCO step2] Eligibility status: {eligibilityText}")
+            
+            # Extract Member ID from the page (for database storage)
+            try:
+                # Look for Member ID on the page
+                page_text = self.driver.find_element(By.TAG_NAME, "body").text
+                import re
+                # Look for "Member ID" followed by a number
+                member_id_match = re.search(r'Member ID\s*[\n:]\s*(\d+)', page_text)
+                if member_id_match:
+                    foundMemberId = member_id_match.group(1)
+                    print(f"[UnitedSCO step2] Extracted Member ID from page: {foundMemberId}")
+            except Exception as e:
+                print(f"[UnitedSCO step2] Could not extract Member ID: {e}")
+            
+            # 2) Click the "Eligibility" button (id='eligibility-link')
+            print("[UnitedSCO step2] Looking for 'Eligibility' button...")
+            
+            try:
+                eligibility_btn = WebDriverWait(self.driver, 10).until(
+                    EC.element_to_be_clickable((By.ID, "eligibility-link"))
+                )
+                eligibility_btn.click()
+                print("[UnitedSCO step2] Clicked 'Eligibility' button")
+                time.sleep(5)
+            except TimeoutException:
+                print("[UnitedSCO step2] Eligibility button not found, trying alternative selectors...")
+                try:
+                    # Alternative: find button with text "Eligibility"
+                    eligibility_btn = self.driver.find_element(By.XPATH,
+                        "//button[normalize-space(text())='Eligibility']"
+                    )
+                    eligibility_btn.click()
+                    print("[UnitedSCO step2] Clicked 'Eligibility' button (alternative)")
+                    time.sleep(5)
+                except Exception as e:
+                    print(f"[UnitedSCO step2] Could not click Eligibility button: {e}")
+            
+            # Wait for page to fully load
+            try:
+                WebDriverWait(self.driver, 30).until(
+                    lambda d: d.execute_script("return document.readyState") == "complete"
+                )
+            except Exception:
+                pass
+            
+            time.sleep(2)
+            
+            print(f"[UnitedSCO step2] Final URL: {self.driver.current_url}")
+
+            # 3) Generate PDF using Chrome DevTools Protocol (same as other insurances)
+            print("[UnitedSCO step2] Generating PDF...")
+            
+            pdf_options = {
+                "landscape": False,
+                "displayHeaderFooter": False,
+                "printBackground": True,
+                "preferCSSPageSize": True,
+                "paperWidth": 8.5,
+                "paperHeight": 11,
+                "marginTop": 0.4,
+                "marginBottom": 0.4,
+                "marginLeft": 0.4,
+                "marginRight": 0.4,
+                "scale": 0.9,
+            }
+            
+            # Use foundMemberId for filename
+            file_identifier = foundMemberId if foundMemberId else f"{self.firstName}_{self.lastName}"
+            
+            result = self.driver.execute_cdp_cmd("Page.printToPDF", pdf_options)
+            pdf_data = base64.b64decode(result.get('data', ''))
+            pdf_path = os.path.join(self.download_dir, f"unitedsco_eligibility_{file_identifier}_{int(time.time())}.pdf")
+            with open(pdf_path, "wb") as f:
+                f.write(pdf_data)
+            print(f"[UnitedSCO step2] PDF saved: {pdf_path}")
+
+            # Keep browser alive for next patient
+            print("[UnitedSCO step2] Eligibility capture complete - session preserved")
+
+            return {
+                "status": "success",
+                "eligibility": eligibilityText,
+                "ss_path": pdf_path,
+                "pdf_path": pdf_path,
+                "patientName": patientName,
+                "memberId": foundMemberId  # Return the Member ID found on the page
+            }
+            
+        except Exception as e:
+            print(f"[UnitedSCO step2] Exception: {e}")
+            return {"status": "error", "message": f"STEP2 FAILED: {str(e)}"}
+
+
+    def main_workflow(self, url):
+        """Main workflow that runs all steps."""
+        try:
+            self.config_driver()
+            
+            login_result = self.login(url)
+            print(f"[main_workflow] Login result: {login_result}")
+            
+            if login_result == "OTP_REQUIRED":
+                return {"status": "otp_required", "message": "OTP required after login"}
+            
+            if isinstance(login_result, str) and login_result.startswith("ERROR"):
+                return {"status": "error", "message": login_result}
+            
+            step1_result = self.step1()
+            print(f"[main_workflow] Step1 result: {step1_result}")
+            
+            if isinstance(step1_result, str) and step1_result.startswith("ERROR"):
+                return {"status": "error", "message": step1_result}
+            
+            step2_result = self.step2()
+            print(f"[main_workflow] Step2 result: {step2_result}")
+            
+            return step2_result
+            
+        except Exception as e:
+            return {"status": "error", "message": str(e)}

apps/SeleniumService/unitedsco_browser_manager.py

@@ -0,0 +1,277 @@
+"""
+Minimal browser manager for United SCO - only handles persistent profile and keeping browser alive.
+Clears session cookies on startup (after PC restart) to force fresh login.
+Tracks credentials to detect changes mid-session.
+"""
+import os
+import shutil
+import hashlib
+import threading
+import subprocess
+import time
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+# Ensure DISPLAY is set for Chrome to work (needed when running from SSH/background)
+if not os.environ.get("DISPLAY"):
+    os.environ["DISPLAY"] = ":0"
+
+
+class UnitedSCOBrowserManager:
+    """
+    Singleton that manages a persistent Chrome browser instance for United SCO.
+    - Uses --user-data-dir for persistent profile (device trust tokens)
+    - Clears session cookies on startup (after PC restart)
+    - Tracks credentials to detect changes mid-session
+    """
+    _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_unitedsco")
+                cls._instance.download_dir = os.path.abspath("seleniumDownloads")
+                cls._instance._credentials_file = os.path.join(cls._instance.profile_dir, ".last_credentials")
+                cls._instance._needs_session_clear = False  # Flag to clear session on next driver creation
+                os.makedirs(cls._instance.profile_dir, exist_ok=True)
+                os.makedirs(cls._instance.download_dir, exist_ok=True)
+        return cls._instance
+
+    def clear_session_on_startup(self):
+        """
+        Clear session cookies from Chrome profile on startup.
+        This forces a fresh login after PC restart.
+        Preserves device trust tokens (LocalStorage, IndexedDB) to avoid OTPs.
+        """
+        print("[UnitedSCO BrowserManager] Clearing session on startup...")
+        
+        try:
+            # Clear the credentials tracking file
+            if os.path.exists(self._credentials_file):
+                os.remove(self._credentials_file)
+                print("[UnitedSCO BrowserManager] Cleared credentials tracking file")
+            
+            # Clear session-related files from Chrome profile
+            # These are the files that store login session cookies
+            session_files = [
+                "Cookies",
+                "Cookies-journal",
+                "Login Data",
+                "Login Data-journal",
+                "Web Data",
+                "Web Data-journal",
+            ]
+            
+            for filename in session_files:
+                filepath = os.path.join(self.profile_dir, "Default", filename)
+                if os.path.exists(filepath):
+                    try:
+                        os.remove(filepath)
+                        print(f"[UnitedSCO BrowserManager] Removed {filename}")
+                    except Exception as e:
+                        print(f"[UnitedSCO BrowserManager] Could not remove {filename}: {e}")
+            
+            # Also try root level (some Chrome versions)
+            for filename in session_files:
+                filepath = os.path.join(self.profile_dir, filename)
+                if os.path.exists(filepath):
+                    try:
+                        os.remove(filepath)
+                        print(f"[UnitedSCO BrowserManager] Removed root {filename}")
+                    except Exception as e:
+                        print(f"[UnitedSCO BrowserManager] Could not remove root {filename}: {e}")
+            
+            # Clear Session Storage (contains login state)
+            session_storage_dir = os.path.join(self.profile_dir, "Default", "Session Storage")
+            if os.path.exists(session_storage_dir):
+                try:
+                    shutil.rmtree(session_storage_dir)
+                    print("[UnitedSCO BrowserManager] Cleared Session Storage")
+                except Exception as e:
+                    print(f"[UnitedSCO BrowserManager] Could not clear Session Storage: {e}")
+            
+            # Clear Local Storage (may contain auth tokens)
+            local_storage_dir = os.path.join(self.profile_dir, "Default", "Local Storage")
+            if os.path.exists(local_storage_dir):
+                try:
+                    shutil.rmtree(local_storage_dir)
+                    print("[UnitedSCO BrowserManager] Cleared Local Storage")
+                except Exception as e:
+                    print(f"[UnitedSCO BrowserManager] Could not clear Local Storage: {e}")
+            
+            # Clear IndexedDB (may contain auth tokens)
+            indexeddb_dir = os.path.join(self.profile_dir, "Default", "IndexedDB")
+            if os.path.exists(indexeddb_dir):
+                try:
+                    shutil.rmtree(indexeddb_dir)
+                    print("[UnitedSCO BrowserManager] Cleared IndexedDB")
+                except Exception as e:
+                    print(f"[UnitedSCO BrowserManager] Could not clear IndexedDB: {e}")
+            
+            # Set flag to clear session via JavaScript after browser opens
+            self._needs_session_clear = True
+            
+            print("[UnitedSCO BrowserManager] Session cleared - will require fresh login")
+            
+        except Exception as e:
+            print(f"[UnitedSCO BrowserManager] Error clearing session: {e}")
+
+    def _hash_credentials(self, username: str) -> str:
+        """Create a hash of the username to track credential changes."""
+        return hashlib.sha256(username.encode()).hexdigest()[:16]
+    
+    def get_last_credentials_hash(self) -> str | None:
+        """Get the hash of the last-used credentials."""
+        try:
+            if os.path.exists(self._credentials_file):
+                with open(self._credentials_file, 'r') as f:
+                    return f.read().strip()
+        except Exception:
+            pass
+        return None
+    
+    def save_credentials_hash(self, username: str):
+        """Save the hash of the current credentials."""
+        try:
+            cred_hash = self._hash_credentials(username)
+            with open(self._credentials_file, 'w') as f:
+                f.write(cred_hash)
+        except Exception as e:
+            print(f"[UnitedSCO BrowserManager] Failed to save credentials hash: {e}")
+    
+    def credentials_changed(self, username: str) -> bool:
+        """Check if the credentials have changed since last login."""
+        last_hash = self.get_last_credentials_hash()
+        if last_hash is None:
+            return False  # No previous credentials, not a change
+        current_hash = self._hash_credentials(username)
+        changed = last_hash != current_hash
+        if changed:
+            print(f"[UnitedSCO BrowserManager] Credentials changed - logout required")
+        return changed
+    
+    def clear_credentials_hash(self):
+        """Clear the saved credentials hash (used after logout)."""
+        try:
+            if os.path.exists(self._credentials_file):
+                os.remove(self._credentials_file)
+        except Exception as e:
+            print(f"[UnitedSCO BrowserManager] Failed to clear credentials hash: {e}")
+
+    def _kill_existing_chrome_for_profile(self):
+        """Kill any existing Chrome processes using this profile."""
+        try:
+            # Find and kill Chrome processes using this profile
+            result = subprocess.run(
+                ["pgrep", "-f", f"user-data-dir={self.profile_dir}"],
+                capture_output=True, text=True
+            )
+            if result.stdout.strip():
+                pids = result.stdout.strip().split('\n')
+                for pid in pids:
+                    try:
+                        subprocess.run(["kill", "-9", pid], check=False)
+                    except:
+                        pass
+                time.sleep(1)
+        except Exception as e:
+            pass
+        
+        # Remove SingletonLock if exists
+        lock_file = os.path.join(self.profile_dir, "SingletonLock")
+        try:
+            if os.path.islink(lock_file) or os.path.exists(lock_file):
+                os.remove(lock_file)
+        except:
+            pass
+
+    def get_driver(self, headless=False):
+        """Get or create the persistent browser instance."""
+        with self._lock:
+            if self._driver is None:
+                print("[UnitedSCO BrowserManager] Driver is None, creating new driver")
+                self._kill_existing_chrome_for_profile()
+                self._create_driver(headless)
+            elif not self._is_alive():
+                print("[UnitedSCO BrowserManager] Driver not alive, recreating")
+                self._kill_existing_chrome_for_profile()
+                self._create_driver(headless)
+            else:
+                print("[UnitedSCO BrowserManager] Reusing existing driver")
+            return self._driver
+
+    def _is_alive(self):
+        """Check if browser is still responsive."""
+        try:
+            if self._driver is None:
+                return False
+            url = self._driver.current_url
+            return True
+        except Exception as e:
+            return False
+
+    def _create_driver(self, headless=False):
+        """Create browser with persistent profile."""
+        if self._driver:
+            try:
+                self._driver.quit()
+            except:
+                pass
+            self._driver = None
+            time.sleep(1)
+
+        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()
+        
+        # Reset the session clear flag (file-based clearing is done on startup)
+        self._needs_session_clear = False
+
+    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
+            # Also clean up any orphaned processes
+            self._kill_existing_chrome_for_profile()
+
+
+# Singleton accessor
+_manager = None
+
+def get_browser_manager():
+    global _manager
+    if _manager is None:
+        _manager = UnitedSCOBrowserManager()
+    return _manager
+
+
+def clear_unitedsco_session_on_startup():
+    """Called by agent.py on startup to clear session."""
+    manager = get_browser_manager()
+    manager.clear_session_on_startup()