zevairouter 1.0.84 → 1.0.86

package/src/lib/oauth/services/kiroGoogleAutomation.js

@@ -412,7 +412,7 @@ async function getFirstVisibleLocator(page, selector) {
   return null;
 }
 
-async function waitForFirstVisibleLocator(page, selector, { timeout = 15_000, pollInterval = 500 } = {}) {
+async function waitForFirstVisibleLocator(page, selector, { timeout = 15_000, pollInterval = 150 } = {}) {
   const deadline = Date.now() + timeout;
   while (Date.now() < deadline) {
     const found = await getFirstVisibleLocator(page, selector);
@@ -424,6 +424,62 @@ async function waitForFirstVisibleLocator(page, selector, { timeout = 15_000, po
   return null;
 }
 
+/** Tiny yield only — never use multi-second sleeps for “maybe page will load”. */
+function yieldMs(ms = 50) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Wait until a condition is true, polling fast. Replaces fixed sleep after clicks.
+ * @returns {Promise<boolean>} true if condition met before timeout
+ */
+async function waitUntil(checkFn, { timeout = 8_000, interval = 100 } = {}) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    try {
+      if (await checkFn()) return true;
+    } catch {
+      /* retry */
+    }
+    await yieldMs(interval);
+  }
+  return false;
+}
+
+function isGoogleHostname(url) {
+  try {
+    const host = new URL(url).hostname;
+    return host === "accounts.google.com"
+      || host.endsWith(".accounts.google.com")
+      || /^accounts\.google\./i.test(host);
+  } catch {
+    return false;
+  }
+}
+
+/** After navigation/click: wait for URL change or next UI, not a fixed sleep. */
+async function waitForPageAdvance(page, {
+  fromUrl = "",
+  urlMatch = null,
+  selector = null,
+  timeout = 8_000,
+} = {}) {
+  const startUrl = fromUrl || page.url?.() || "";
+  return waitUntil(async () => {
+    const url = page.url?.() || "";
+    if (urlMatch) {
+      if (typeof urlMatch === "function" && urlMatch(url)) return true;
+      if (urlMatch instanceof RegExp && urlMatch.test(url)) return true;
+    }
+    if (url && url !== startUrl && !url.startsWith("about:")) return true;
+    if (selector) {
+      const found = await getFirstVisibleLocator(page, selector);
+      if (found) return true;
+    }
+    return false;
+  }, { timeout, interval: 80 });
+}
+
 async function fillInputResilient(locator, value, { timeout = 15_000 } = {}) {
   if (!locator || value == null) return false;
 
@@ -496,12 +552,18 @@ function includesAny(text, markers) {
 function isGoogleAuthPage(page) {
   try {
     const url = new URL(page.url());
-    return url.hostname === "accounts.google.com" || url.hostname.endsWith(".accounts.google.com");
+    return url.hostname === "accounts.google.com"
+      || url.hostname.endsWith(".accounts.google.com")
+      || /^accounts\.google\./i.test(url.hostname);
   } catch {
     return false;
   }
 }
 
+function isGrokish(serviceLabel) {
+  return /grok/i.test(String(serviceLabel || ""));
+}
+
 // Google bounces flagged (headless) browsers:
 // - myaccount.google.com/not-supported
 // - accounts.google.com/v3/signin/rejected ("This browser or app may not be secure")
@@ -601,14 +663,15 @@ async function waitThroughGoogleInterstitials(page, reportStep, { maxWaitMs = 20
       ]);
       if (clicked) {
         reportStep?.("selecting_google_account", "Selected account from Google AccountChooser");
-        await page.waitForTimeout(1200);
+        await waitForPageAdvance(page, { timeout: 5_000 });
         continue;
       }
     }
 
     const waiters = [
-      page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 4_000 }).catch(() => null),
-      page.waitForTimeout(1_200),
+      page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 3_000 }).catch(() => null),
+      // Cap idle wait low — exit as soon as URL/body changes or success settles.
+      yieldMs(400),
     ];
     if (successPromise && !isSuccessSettled(successPromise)) {
       waiters.push(successPromise.then(() => null).catch(() => null));
@@ -1328,28 +1391,39 @@ async function handleXaiDeviceCodeConfirm(page, reportStep, { alreadyAuthed = fa
     || (/sign in to grok/i.test(text) && /continue/i.test(text) && !/login with/i.test(text));
   if (!isCodeConfirm) return false;
 
+  const fromUrl = page.url?.() || "";
+  let clicked = false;
   try {
     const btn = page.getByRole("button", { name: /^Continue$/i }).first();
-    if (await btn.isVisible({ timeout: 600 }).catch(() => false)) {
+    if (await btn.isVisible({ timeout: 300 }).catch(() => false)) {
       await btn.click({ timeout: 5_000 });
-      reportStep?.("confirming_device_code", "Confirmed device user code on xAI");
-      await page.waitForTimeout(1_200);
-      return true;
+      clicked = true;
     }
   } catch {
     /* fall through */
   }
-
-  const clicked = await clickFirstActionable(page, [
-    'button[type="submit"]:has-text("Continue")',
-    'button:has-text("Continue")',
-  ]);
-  if (clicked) {
-    reportStep?.("confirming_device_code", "Confirmed device user code on xAI");
-    await page.waitForTimeout(1_200);
-    return true;
+  if (!clicked) {
+    clicked = await clickFirstActionable(page, [
+      'button[type="submit"]:has-text("Continue")',
+      'button:has-text("Continue")',
+    ]);
   }
-  return false;
+  if (!clicked) return false;
+
+  reportStep?.("confirming_device_code", "Confirmed device user code on xAI");
+  // Event-driven: next screen is Login with Google or URL change — no fixed 1.2s sleep.
+  // GOOGLE_LOGIN_BUTTON_SELECTORS is a string[] — never .split() it.
+  await waitForPageAdvance(page, {
+    fromUrl,
+    urlMatch: (u) => /sign-in|login|oauth/i.test(u) && u !== fromUrl,
+    selector: [
+      ...GOOGLE_LOGIN_BUTTON_SELECTORS.slice(0, 8),
+      'button:has-text("Login with Google")',
+      'button:has-text("Login with email")',
+    ].join(", "),
+    timeout: 10_000,
+  });
+  return true;
 }
 
 async function clickGoogleLoginRole(page) {
@@ -1404,8 +1478,19 @@ async function ensureProviderTermsChecked(page, reportStep) {
           || await locator.click({ force: true, timeout: 3_000 }).then(() => true).catch(() => false);
         if (did) {
           reportStep?.("accepting_provider_terms", "Accepted provider terms for Google login");
-          // xAI enables Google SSO only after the checkbox settles.
-          await page.waitForTimeout(500);
+          // Wait until Google button enables — not a blind sleep.
+          await waitUntil(
+            async () => {
+              try {
+                const btn = page.getByRole("button", { name: /google/i }).first();
+                return (await btn.isVisible().catch(() => false))
+                  && (await btn.isEnabled().catch(() => true));
+              } catch {
+                return true;
+              }
+            },
+            { timeout: 2_000, interval: 80 },
+          );
           return true;
         }
       } catch {
@@ -1422,7 +1507,6 @@ async function handleProviderLoginGate(page, reportStep, { allowGoogleClick = tr
   const confirmedExistingDialog = await clickFirstActionable(page, PRIVACY_CONFIRM_BUTTON_SELECTORS);
   if (confirmedExistingDialog) {
     reportStep("accepting_provider_privacy_dialog", "Confirmed provider privacy agreement dialog");
-    await page.waitForTimeout(500);
     return true;
   }
 
@@ -1441,39 +1525,29 @@ async function handleProviderLoginGate(page, reportStep, { allowGoogleClick = tr
   const clickedGoogle = clickedGoogleRole || await clickFirstActionable(page, GOOGLE_LOGIN_BUTTON_SELECTORS);
   if (clickedGoogle) {
     reportStep("selecting_google_login", "Selecting Google login");
-    await page.waitForTimeout(500);
 
     const confirmedDialog = await clickFirstActionable(page, PRIVACY_CONFIRM_BUTTON_SELECTORS);
     if (confirmedDialog) {
       reportStep("accepting_provider_privacy_dialog", "Confirmed provider privacy agreement dialog");
-      await page.waitForTimeout(500);
     }
 
-    // Wait for OAuth redirect to Google (or popup) — short timeout; loop retries.
-    try {
-      await page.waitForURL(
-        (url) => {
-          try {
-            const host = new URL(url).hostname;
-            return host === "accounts.google.com"
-              || host.endsWith(".accounts.google.com")
-              || /^accounts\.google\./i.test(host);
-          } catch {
-            return false;
-          }
-        },
-        { timeout: 8_000 },
-      );
+    // Wait for OAuth redirect to Google (or email field) — event-driven.
+    const reached = await waitForPageAdvance(page, {
+      urlMatch: (u) => isGoogleHostname(u),
+      selector: EMAIL_INPUT_SELECTOR,
+      timeout: 12_000,
+    });
+    if (reached || isGoogleAuthPage(page)) {
       reportStep("google_login_page", "Reached Google sign-in after provider SSO");
-    } catch {
-      // Popup-based Google SSO: try the newest page
+    } else {
+      // Popup-based Google SSO
       try {
         const ctx = page.context?.();
         const pages = ctx?.pages?.() || [];
         for (let i = pages.length - 1; i >= 0; i -= 1) {
           const p = pages[i];
           const u = p.url?.() || "";
-          if (/accounts\.google\.com/i.test(u)) {
+          if (isGoogleHostname(u)) {
             reportStep("google_login_popup", "Google sign-in opened in a popup");
             break;
           }
@@ -1504,12 +1578,11 @@ async function clickXaiDeviceAuthorize(page, reportStep) {
   for (const re of roles) {
     try {
       const btn = page.getByRole("button", { name: re }).first();
-      if (await btn.isVisible({ timeout: 250 }).catch(() => false)) {
+      if (await btn.isVisible({ timeout: 200 }).catch(() => false)) {
         const label = (await btn.innerText().catch(() => "")) || "";
         if (/google/i.test(label)) continue;
         await btn.click({ timeout: 3_000 });
         reportStep?.("approving_consent", "Approving xAI device authorization");
-        await page.waitForTimeout(600);
         return true;
       }
     } catch {
@@ -1818,30 +1891,38 @@ export async function runGoogleAccountAutomation({
   let deviceApproveAt = 0;
   let deviceInvalidReopenAt = 0;
   let deviceInvalidReopenCount = 0;
-  const PASSWORD_RESUBMIT_COOLDOWN_MS = 18_000;
-  const EMAIL_RESUBMIT_COOLDOWN_MS = 8_000;
-  // Short cooldown: long values blocked re-click after a no-op first SSO attempt.
-  const GOOGLE_SSO_COOLDOWN_MS = 8_000;
-  // Don't hammer Allow — xAI returns rate_limited after rapid device posts.
-  const DEVICE_APPROVE_COOLDOWN_MS = 8_000;
-  const DEVICE_INVALID_REOPEN_COOLDOWN_MS = 8_000;
+  // Cooldowns prevent double-submit only — not artificial pacing.
+  const PASSWORD_RESUBMIT_COOLDOWN_MS = isGrokish(serviceLabel) ? 6_000 : 18_000;
+  const EMAIL_RESUBMIT_COOLDOWN_MS = isGrokish(serviceLabel) ? 3_000 : 8_000;
+  const GOOGLE_SSO_COOLDOWN_MS = isGrokish(serviceLabel) ? 3_000 : 8_000;
+  // Don't hammer Allow — xAI rate_limits rapid device posts.
+  const DEVICE_APPROVE_COOLDOWN_MS = 3_000;
+  const DEVICE_INVALID_REOPEN_COOLDOWN_MS = 4_000;
   const DEVICE_INVALID_REOPEN_MAX = 3;
-  const isGrokFlow = /grok/i.test(String(serviceLabel || ""));
+  const isGrokFlow = isGrokish(serviceLabel);
   // Grok does not need the long Kiro SetSID / kiro:// interstitial window.
-  const postPasswordInterstitialMs = isGrokFlow ? 10_000 : 25_000;
-  const loopTickMs = isGrokFlow ? 400 : 800;
+  const postPasswordInterstitialMs = isGrokFlow ? 4_000 : 25_000;
+  // Loop poll: race successPromise — keep tiny so fast networks aren't stalled.
+  const loopTickMs = isGrokFlow ? 120 : 500;
 
   reportStep(openingStep, openingMessage);
   await page.goto(authUrl, { waitUntil: "domcontentloaded", timeout: 60_000 });
-  await page.waitForTimeout(isGrokFlow ? 700 : 2_000);
-  await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(isGrokFlow ? 4_000 : 12_000));
+  // Wait for interactive UI (Continue / Google / email), not a fixed sleep.
+  await waitUntil(
+    async () =>
+      isGoogleAuthPage(page)
+      || (await getFirstVisibleLocator(page, 'button:has-text("Continue"), button:has-text("Login with Google"), button:has-text("Google")'))
+      || (await getFirstVisibleLocator(page, EMAIL_INPUT_SELECTOR)),
+    { timeout: isGrokFlow ? 6_000 : 12_000, interval: 80 },
+  );
+  if (!isGrokFlow) {
+    await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(8_000));
+  }
 
   // Provider shells (xAI device, CodeBuddy, …) must pick Google SSO first.
-  // Never type credentials into provider user_code / email fields — that
-  // produced email_fill_failed + invalid_code on accounts.x.ai/oauth2/device.
-  // xAI: confirm device user_code first, then Google SSO.
-  // Retry briefly while SPA mounts Login with Google.
-  for (let attempt = 0; attempt < (isGrokFlow ? 8 : 2); attempt += 1) {
+  // Never type credentials into provider user_code / email fields.
+  // xAI: confirm device user_code first, then Google SSO — event-driven retries.
+  for (let attempt = 0; attempt < (isGrokFlow ? 6 : 2); attempt += 1) {
     if (isGoogleAuthPage(page)) break;
     if (await handleXaiDeviceCodeConfirm(page, reportStep)) {
       continue;
@@ -1849,15 +1930,27 @@ export async function runGoogleAccountAutomation({
     if (await handleProviderLoginGate(page, reportStep)) {
       googleLoginSelectedAt = Date.now();
       if (isGoogleAuthPage(page)) break;
+      // Gate already waited for Google URL; only brief yield if still on provider.
+      await yieldMs(50);
+      continue;
     }
-    await page.waitForTimeout(600);
+    // SPA not ready — poll for buttons, don't sleep 600ms blindly.
+    const ready = await waitUntil(
+      async () =>
+        (await providerHasGoogleLogin(page))
+        || /enter the code|login with google|continue/i.test(await readPageText(page).catch(() => "")),
+      { timeout: 800, interval: 80 },
+    );
+    if (!ready) await yieldMs(100);
+  }
+  if (!isGrokFlow) {
+    await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(6_000));
   }
-  await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(isGrokFlow ? 4_000 : 8_000));
 
   // Only fill Google email once we are actually on accounts.google.com.
   if (isGoogleAuthPage(page)) {
     seenGoogleAuth = true;
-    const emailInput = await waitForFirstVisibleLocator(page, EMAIL_INPUT_SELECTOR, { timeout: 12_000 });
+    const emailInput = await waitForFirstVisibleLocator(page, EMAIL_INPUT_SELECTOR, { timeout: 10_000 });
     if (emailInput) {
       reportStep("entering_email", "Entering Google email");
       const filled = await fillInputResilient(emailInput, email);
@@ -1867,11 +1960,14 @@ export async function runGoogleAccountAutomation({
         reportStep("submitting_email", "Submitting email");
         await clickFirstVisible(page, NEXT_BUTTON_SELECTORS);
         emailSubmittedAt = Date.now();
-        // Wait for the page to transition away from the email step so the
-        // polling loop doesn't immediately re-detect the disappearing email
-        // field and type the email value into the password input.
-        await page.waitForTimeout(isGrokFlow ? 700 : 1_500);
-        await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(isGrokFlow ? 5_000 : 12_000));
+        // Wait for password field (or leave email step) — not fixed sleep.
+        await waitForPageAdvance(page, {
+          selector: PASSWORD_INPUT_SELECTOR,
+          timeout: isGrokFlow ? 8_000 : 12_000,
+        });
+        if (!isGrokFlow) {
+          await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(8_000));
+        }
       }
     }
   } else if (isProviderPage(page)) {
@@ -1907,7 +2003,7 @@ export async function runGoogleAccountAutomation({
     const waited = await waitThroughGoogleInterstitials(
       page,
       reportStep,
-      interstitialOpts(isGrokFlow ? 4_000 : 8_000),
+      interstitialOpts(isGrokFlow ? 2_500 : 8_000),
     );
     if (waited) {
       continue;
@@ -1915,11 +2011,11 @@ export async function runGoogleAccountAutomation({
 
     const handledGoogleConsent = await handleGoogleConsent(page, reportStep);
     if (handledGoogleConsent) {
-      await waitThroughGoogleInterstitials(
-        page,
-        reportStep,
-        interstitialOpts(isGrokFlow ? 5_000 : 12_000),
-      );
+      if (!isGrokFlow) {
+        await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(12_000));
+      } else {
+        await waitForPageAdvance(page, { timeout: 4_000 });
+      }
       continue;
     }
 
@@ -2009,7 +2105,12 @@ export async function runGoogleAccountAutomation({
         `Device page error — reopening auth URL (${deviceInvalidReopenCount}/${DEVICE_INVALID_REOPEN_MAX})`,
       );
       await page.goto(authUrl, { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => null);
-      await page.waitForTimeout(1_800);
+      await waitUntil(
+        async () =>
+          (await getFirstVisibleLocator(page, 'button:has-text("Continue"), button:has-text("Allow"), button:has-text("Authorize")'))
+          || (await providerHasGoogleLogin(page)),
+        { timeout: 4_000, interval: 80 },
+      );
       continue;
     }
 
@@ -2063,8 +2164,11 @@ export async function runGoogleAccountAutomation({
             "waiting_after_password",
             `Password already submitted ${Math.round(sincePw / 1000)}s ago — waiting for Google redirect`,
           );
-          await waitThroughGoogleInterstitials(page, reportStep, interstitialOpts(8_000));
-          await page.waitForTimeout(500);
+          await waitThroughGoogleInterstitials(
+            page,
+            reportStep,
+            interstitialOpts(isGrokFlow ? 2_000 : 6_000),
+          );
           continue;
         }
 
@@ -2072,17 +2176,15 @@ export async function runGoogleAccountAutomation({
         const filled = await fillInputResilient(passwordInput, password);
         if (filled) {
           reportStep("submitting_password", "Submitting password");
+          const prePwUrl = page.url?.() || "";
           await clickFirstVisible(page, NEXT_BUTTON_SELECTORS);
           passwordSubmittedAt = Date.now();
-          // Give Google time to leave the password challenge before the next
-          // loop iteration can re-detect the still-mounted password field.
+          // Leave password challenge via navigation / URL change / success — no 2.5s sleep.
           await Promise.race([
-            page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 8_000 }).catch(() => null),
-            page.waitForTimeout(2_500),
+            page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: isGrokFlow ? 6_000 : 10_000 }).catch(() => null),
+            waitForPageAdvance(page, { fromUrl: prePwUrl, timeout: isGrokFlow ? 6_000 : 10_000 }),
+            successPromise.then(() => null).catch(() => null),
           ]);
-          // Password submit often lands on empty SetSID while network completes
-          // consent→idpresponse→kiro://. Callback monitor (CDP) settles successPromise.
-          // Grok device poll settles faster — shorter interstitial wait.
           await waitThroughGoogleInterstitials(
             page,
             reportStep,
@@ -2090,7 +2192,7 @@ export async function runGoogleAccountAutomation({
           );
         } else {
           reportStep("password_fill_failed", "Could not fill the Google password field; retrying loop");
-          await page.waitForTimeout(500);
+          await yieldMs(100);
         }
         continue;
       }
@@ -2103,7 +2205,10 @@ export async function runGoogleAccountAutomation({
             "waiting_after_email",
             `Email already submitted ${Math.round(sinceEmail / 1000)}s ago — waiting for password/next screen`,
           );
-          await page.waitForTimeout(500);
+          await waitForPageAdvance(page, {
+            selector: PASSWORD_INPUT_SELECTOR,
+            timeout: Math.max(200, EMAIL_RESUBMIT_COOLDOWN_MS - sinceEmail),
+          });
           continue;
         }
 
@@ -2113,11 +2218,14 @@ export async function runGoogleAccountAutomation({
           reportStep("submitting_email", "Submitting email");
           await clickFirstVisible(page, NEXT_BUTTON_SELECTORS);
           emailSubmittedAt = Date.now();
-          await page.waitForTimeout(isGrokFlow ? 600 : 1_500);
+          await waitForPageAdvance(page, {
+            selector: PASSWORD_INPUT_SELECTOR,
+            timeout: isGrokFlow ? 6_000 : 10_000,
+          });
         } else {
           reportStep("email_fill_failed", "Could not fill the Google email field; retrying loop");
+          await yieldMs(80);
         }
-        await page.waitForTimeout(400);
         continue;
       }
     }
@@ -2132,7 +2240,7 @@ export async function runGoogleAccountAutomation({
       if (clickedApprove) {
         reportStep("approving_consent", `Approving Google or ${serviceLabel} consent`);
         deviceApproveAt = Date.now();
-        await page.waitForTimeout(isGrokFlow ? 500 : 700);
+        await waitForPageAdvance(page, { timeout: isGrokFlow ? 2_000 : 4_000 });
         continue;
       }
     }
@@ -2148,7 +2256,8 @@ export async function runGoogleAccountAutomation({
     } else {
       reportStep("waiting_for_next_screen", `Waiting for the next Google or ${serviceLabel} screen`);
     }
-    await page.waitForTimeout(loopTickMs);
+    // Only yield — next loop races successPromise + handlers. Fast net = fast exit.
+    await yieldMs(loopTickMs);
   }
 
   // Final blocked check before generic needs_manual
@@ -2213,4 +2322,9 @@ export const __test__ = {
   fillInputResilient,
   parseSelectorList,
   getFirstVisibleLocator,
+  waitForPageAdvance,
+  waitUntil,
+  handleXaiDeviceCodeConfirm,
+  GOOGLE_LOGIN_BUTTON_SELECTORS,
+  isGrokish,
 };