zevairouter 1.0.8 → 1.0.10

package/src/app/(dashboard)/dashboard/automation/page.js

@@ -340,6 +340,62 @@ function QoderAutomationPanel({ providerInfo, onRefresh }) {
   );
 }
 
+function AntigravityAutomationPanel({ providerInfo, onRefresh }) {
+  const [isBulkOpen, setIsBulkOpen] = useState(false);
+  const [isOAuthOpen, setIsOAuthOpen] = useState(false);
+
+  return (
+    <>
+      <div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
+        <button
+          type="button"
+          onClick={() => setIsBulkOpen(true)}
+          className="flex min-h-[112px] min-w-0 flex-col gap-2 rounded-lg border border-border bg-surface px-4 py-3 text-left transition-colors hover:border-primary/40 hover:bg-primary/5"
+        >
+          <span className="flex items-center gap-2 text-sm font-semibold text-text-main">
+            <span className="material-symbols-outlined text-[20px] text-primary">group_add</span>
+            Auto Login Bulk
+          </span>
+          <span className="text-xs leading-relaxed text-text-muted">
+            Run bulk gmail:password or gmail|password automation via Google OAuth (authorization code) for Antigravity.
+          </span>
+        </button>
+        <button
+          type="button"
+          onClick={() => setIsOAuthOpen(true)}
+          className="flex min-h-[112px] min-w-0 flex-col gap-2 rounded-lg border border-border bg-surface px-4 py-3 text-left transition-colors hover:border-primary/40 hover:bg-primary/5"
+        >
+          <span className="flex items-center gap-2 text-sm font-semibold text-text-main">
+            <span className="material-symbols-outlined text-[20px] text-primary">login</span>
+            OAuth Login
+          </span>
+          <span className="text-xs leading-relaxed text-text-muted">
+            Open Antigravity Google OAuth in browser and finish the consent manually.
+          </span>
+        </button>
+      </div>
+      <BulkAccountAutomationModal
+        isOpen={isBulkOpen}
+        provider="antigravity"
+        title="Antigravity Bulk GSuite Auto Login"
+        serviceName="Antigravity"
+        onSuccess={onRefresh}
+        onClose={() => setIsBulkOpen(false)}
+      />
+      <OAuthModal
+        isOpen={isOAuthOpen}
+        provider="antigravity"
+        providerInfo={providerInfo}
+        onSuccess={() => {
+          onRefresh?.();
+          setIsOAuthOpen(false);
+        }}
+        onClose={() => setIsOAuthOpen(false)}
+      />
+    </>
+  );
+}
+
 const AUTOMATION_PROVIDERS = [
   {
     id: "kiro",
@@ -365,6 +421,14 @@ const AUTOMATION_PROVIDERS = [
     supportedModes: ["bulk-account", "device-oauth"],
     component: QoderAutomationPanel,
   },
+  {
+    id: "antigravity",
+    label: "Antigravity",
+    icon: "rocket_launch",
+    description: "Bulk GSuite auto login via Google OAuth (authorization code).",
+    supportedModes: ["bulk-account", "oauth"],
+    component: AntigravityAutomationPanel,
+  },
 ];
 
 export default function AutomationPage() {

package/src/app/api/oauth/antigravity/bulk-import/[jobId]/cancel/route.js

@@ -0,0 +1,19 @@
+import { NextResponse } from "next/server";
+import { getAntigravityBulkImportManager } from "@/lib/oauth/services/antigravityBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const { jobId } = await params;
+  const manager = getAntigravityBulkImportManager();
+  const job = manager.cancelJob(jobId);
+
+  if (!job) {
+    return NextResponse.json({ error: "Bulk import job not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    success: true,
+    job,
+  });
+}

package/src/app/api/oauth/antigravity/bulk-import/[jobId]/manual/[workerId]/route.js

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { getAntigravityBulkImportManager } from "@/lib/oauth/services/antigravityBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const { jobId, workerId } = await params;
+  const manager = getAntigravityBulkImportManager();
+  const result = await manager.openManualSession(jobId, workerId);
+
+  if (!result) {
+    return NextResponse.json({ error: "Bulk import job not found" }, { status: 404 });
+  }
+
+  if (!result.ok) {
+    return NextResponse.json(
+      {
+        error: result.error || "Manual session not found for this worker",
+        job: result.job,
+      },
+      { status: 404 }
+    );
+  }
+
+  return NextResponse.json({
+    success: true,
+    job: result.job,
+    account: result.account,
+  });
+}

package/src/app/api/oauth/antigravity/bulk-import/[jobId]/route.js

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { getAntigravityBulkImportManager, buildLookupResponse } from "@/lib/oauth/services/antigravityBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(_request, { params }) {
+  const { jobId } = await params;
+  const manager = getAntigravityBulkImportManager();
+
+  const job = await manager.getJobWithPreview(jobId);
+
+  if (!job) {
+    return NextResponse.json({
+      success: true,
+      ...buildLookupResponse(null, { stale: true }),
+    });
+  }
+
+  return NextResponse.json({
+    success: true,
+    ...buildLookupResponse(job),
+  });
+}

package/src/app/api/oauth/antigravity/bulk-import/latest/route.js

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { getAntigravityBulkImportManager, buildLookupResponse } from "@/lib/oauth/services/antigravityBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  const manager = getAntigravityBulkImportManager();
+  const searchParams = new URL(request.url).searchParams;
+  const scope = searchParams.get("scope");
+  const includeRecentTerminal = scope === "recent" || scope === "recoverable" || scope === "all";
+  const job = await manager.getLatestJobWithPreview({ includeRecentTerminal });
+
+  if (!job) {
+    return NextResponse.json({
+      success: true,
+      ...buildLookupResponse(null),
+    });
+  }
+
+  return NextResponse.json({
+    success: true,
+    ...buildLookupResponse(job),
+  });
+}

package/src/app/api/oauth/antigravity/bulk-import/route.js

@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import { getAntigravityBulkImportManager, parseKiroBulkAccounts } from "@/lib/oauth/services/antigravityBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const accounts = Array.isArray(body?.accounts) ? body.accounts : [];
+    const { parsed, invalidLines } = parseKiroBulkAccounts(accounts);
+
+    if (!parsed.length) {
+      return NextResponse.json(
+        { error: "At least one account entry is required" },
+        { status: 400 }
+      );
+    }
+
+    if (invalidLines.length > 0) {
+      return NextResponse.json(
+        {
+          error: "Invalid account format. Use one account per line: email@gmail.com:password or email@gmail.com|password",
+          invalidLines,
+        },
+        { status: 400 }
+      );
+    }
+
+    const manager = getAntigravityBulkImportManager();
+    const job = await manager.startJob({
+      accounts,
+      concurrency: body?.concurrency,
+      engine: body?.engine,
+    });
+
+    return NextResponse.json({
+      success: true,
+      job,
+    });
+  } catch (error) {
+    const status = Array.isArray(error?.invalidLines) ? 400 : 500;
+    return NextResponse.json(
+      {
+        error: error?.error || error?.message || "Failed to start Antigravity bulk import",
+        ...(Array.isArray(error?.invalidLines) ? { invalidLines: error.invalidLines } : {}),
+      },
+      { status }
+    );
+  }
+}

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

@@ -0,0 +1,308 @@
+import { randomUUID } from "crypto";
+import {
+  KiroBulkImportManager,
+  buildLookupResponse,
+  createFreshContext,
+  parseKiroBulkAccounts,
+  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
+  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
+  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
+} from "./kiroBulkImportManager.js";
+import {
+  runGoogleAccountAutomation,
+  createGenericCallbackMonitor,
+} from "./kiroGoogleAutomation.js";
+import { generateAuthData, exchangeTokens } from "../providers.js";
+
+const ANTIGRAVITY_PROVIDER_ID = "antigravity";
+const ANTIGRAVITY_LABEL = "Antigravity";
+const ANTIGRAVITY_CALLBACK_TIMEOUT_MS = 3 * 60_000;
+
+// Antigravity uses a Google loopback redirect on the app's own port (same as
+// the single-OAuth flow in antigravity.js). Google desktop clients accept any
+// localhost port, but authUrl and token exchange MUST use the same value.
+function getRedirectUri() {
+  const port = process.env.PORT || "1997";
+  return `http://localhost:${port}/callback`;
+}
+
+async function defaultSaveAntigravityConnection({ tokens, email }) {
+  const { createProviderConnection } = await import("../../../models/index.js");
+  const providerSpecificData = {
+    authMethod: "oauth",
+    projectId: tokens.projectId || "",
+    loginEmail: email,
+    automation: "gsuite-bulk",
+  };
+
+  const connectionData = {
+    provider: ANTIGRAVITY_PROVIDER_ID,
+    authType: "oauth",
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken || "",
+    email,
+    displayName: tokens.displayName || email.split("@")[0],
+    providerSpecificData,
+    expiresAt: tokens.expiresIn
+      ? new Date(Date.now() + tokens.expiresIn * 1000).toISOString()
+      : null,
+    testStatus: "active",
+  };
+
+  const connection = await createProviderConnection(connectionData);
+  return { connection };
+}
+
+async function defaultBrowserLauncher(job) {
+  const { launchBulkImportBrowser } = await import("./bulkImportBrowserEngine.js");
+  return launchBulkImportBrowser({ engine: job?.engine || "chromium" });
+}
+
+class AntigravityBulkImportManager extends KiroBulkImportManager {
+  constructor({
+    saveConnection = defaultSaveAntigravityConnection,
+    browserLauncher = defaultBrowserLauncher,
+    storageName = "antigravity-bulk-import",
+  } = {}) {
+    super({
+      browserLauncher,
+      storageName,
+    });
+    this.saveConnection = saveConnection;
+  }
+
+  async processAccount(job, account, workerId) {
+    if (job.cancelRequested || !job.browser) {
+      this.finalizeAccount(account, "cancelled", { error: "Job cancelled" });
+      return;
+    }
+
+    const { context, page } = await createFreshContext(job.browser);
+    account.runtimeSession = { context, page };
+
+    const redirectUri = getRedirectUri();
+    const state = randomUUID();
+    let authData;
+    try {
+      authData = await generateAuthData(ANTIGRAVITY_PROVIDER_ID, redirectUri);
+    } catch (error) {
+      this.finalizeAccount(account, "failed", {
+        error: `Failed to build Antigravity auth URL: ${error.message}`,
+        step: "failed",
+        message: error.message,
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+      return;
+    }
+
+    // authData.state from generateAuthData drives the auth URL; reuse it for exchange.
+    const authState = authData.state || state;
+    const callbackPromise = createGenericCallbackMonitor(context, page, {
+      prefix: redirectUri,
+      timeoutMs: ANTIGRAVITY_CALLBACK_TIMEOUT_MS,
+    });
+
+    try {
+      this.setAccountStep(account, "preparing_worker", `Worker ${workerId} preparing Antigravity Google OAuth`);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+
+      const automationResult = await runGoogleAccountAutomation({
+        page,
+        authUrl: authData.authUrl,
+        email: account.email,
+        password: account.password,
+        successPromise: callbackPromise,
+        shortTimeoutMs: ANTIGRAVITY_CALLBACK_TIMEOUT_MS,
+        serviceLabel: ANTIGRAVITY_LABEL,
+        openingStep: "opening_antigravity_login",
+        openingMessage: "Opening Antigravity Google OAuth page",
+        successStep: "antigravity_callback_received",
+        successMessage: "Antigravity OAuth callback received",
+        onStep: (step, message) => {
+          this.setAccountStep(account, step, message);
+          void this.persistJobSnapshot(job, { forcePreview: false });
+        },
+      });
+
+      if (automationResult.status === "success") {
+        const code = automationResult.code;
+        if (!code) {
+          throw new Error("OAuth callback captured but no authorization code present");
+        }
+
+        this.setAccountStep(account, "exchanging_token", "Exchanging authorization code for tokens");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        const tokens = await exchangeTokens(
+          ANTIGRAVITY_PROVIDER_ID,
+          code,
+          redirectUri,
+          authData.codeVerifier || null,
+          automationResult.state || authState,
+        );
+
+        this.setAccountStep(account, "saving_connection", "Saving Antigravity connection to database");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+
+        const { connection } = await this.saveConnection({
+          tokens: {
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken || "",
+            projectId: tokens.projectId || "",
+            expiresIn: tokens.expiresIn || null,
+            displayName: tokens.email || "",
+          },
+          email: tokens.email || account.email,
+        });
+
+        const projectLabel = tokens.projectId ? ` (project ${tokens.projectId})` : "";
+        this.finalizeAccount(account, "success", {
+          connectionId: connection.id,
+          step: "connection_saved",
+          message: `Antigravity connection saved successfully${projectLabel}`,
+        });
+        account.runtimeSession = null;
+        await context.close().catch(() => null);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        return;
+      }
+
+      if (automationResult.status === "needs_manual") {
+        account.manualSession = { context, page, opened: false, openedAt: null };
+        this.setAccountStep(account, "awaiting_manual", "Waiting for manual completion");
+        this.finalizeAccount(account, "needs_manual", {
+          error: automationResult.error,
+          step: "awaiting_manual",
+          message: automationResult.error,
+        });
+        await this.persistJobSnapshot(job, { forcePreview: true });
+
+        await this.runAntigravityManualFollowup(job, account, workerId, context, callbackPromise, redirectUri, authData, authState);
+        return;
+      }
+
+      const terminalStatus = automationResult.status?.startsWith("failed") ? automationResult.status : "failed";
+      this.finalizeAccount(account, terminalStatus, {
+        error: automationResult.error || "Antigravity Google automation failed.",
+        step: terminalStatus,
+        message: automationResult.error || "Antigravity Google automation failed.",
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    } catch (error) {
+      this.finalizeAccount(account, "failed", {
+        error: error.message || "Unexpected Antigravity bulk import failure.",
+        step: "failed",
+        message: error.message || "Unexpected Antigravity bulk import failure.",
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    }
+  }
+
+  async runAntigravityManualFollowup(job, account, workerId, context, callbackPromise, redirectUri, authData, authState) {
+    const followupPromise = (async () => {
+      const closeManualResources = async () => {
+        const ms = account.manualSession;
+        const ctx = ms?.context || context;
+        const headed = ms?.headedBrowser || null;
+        if (ctx) await ctx.close().catch(() => null);
+        if (headed) await headed.close().catch(() => null);
+      };
+      try {
+        const result = await callbackPromise;
+        if (job.cancelRequested) {
+          this.finalizeAccount(account, "cancelled", {
+            error: "Job cancelled",
+            step: "cancelled",
+            message: "Job cancelled while waiting for manual completion",
+          });
+          await this.persistJobSnapshot(job, { forcePreview: true });
+          return;
+        }
+
+        const code = result?.code;
+        if (!code) throw new Error("Manual flow finished but no authorization code captured");
+
+        this.setAccountStep(account, "exchanging_token", "Exchanging authorization code for tokens");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        const tokens = await exchangeTokens(
+          ANTIGRAVITY_PROVIDER_ID,
+          code,
+          redirectUri,
+          authData.codeVerifier || null,
+          result.state || authState,
+        );
+
+        this.setAccountStep(account, "saving_connection", "Saving Antigravity connection");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+
+        const { connection } = await this.saveConnection({
+          tokens: {
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken || "",
+            projectId: tokens.projectId || "",
+            expiresIn: tokens.expiresIn || null,
+            displayName: tokens.email || "",
+          },
+          email: tokens.email || account.email,
+        });
+
+        this.finalizeAccount(account, "success", {
+          connectionId: connection.id,
+          step: "connection_saved",
+          message: "Antigravity connection saved successfully",
+        });
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      } catch (error) {
+        if (job.cancelRequested) {
+          this.finalizeAccount(account, "cancelled", {
+            error: "Job cancelled",
+            step: "cancelled",
+            message: "Job cancelled while waiting for manual completion",
+          });
+        } else {
+          this.finalizeAccount(account, "failed", {
+            error: error.message || "Manual assist flow failed.",
+            step: "failed",
+            message: error.message || "Manual assist flow failed.",
+          });
+        }
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      } finally {
+        await closeManualResources();
+        account.manualSession = null;
+        account.runtimeSession = null;
+        job.manualFollowups.delete(followupPromise);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      }
+    })();
+
+    job.manualFollowups.add(followupPromise);
+  }
+}
+
+function getSingletonStore() {
+  if (!globalThis.__antigravityBulkImportSingleton) {
+    globalThis.__antigravityBulkImportSingleton = {
+      manager: new AntigravityBulkImportManager(),
+    };
+  }
+  return globalThis.__antigravityBulkImportSingleton;
+}
+
+export function getAntigravityBulkImportManager() {
+  return getSingletonStore().manager;
+}
+
+export {
+  AntigravityBulkImportManager,
+  buildLookupResponse,
+  parseKiroBulkAccounts,
+  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
+  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
+  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
+};

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

@@ -475,6 +475,18 @@ function isGoogleAuthPage(page) {
   }
 }
 
+// Google bounces flagged (headless) browsers to myaccount.google.com/not-supported
+// at the OAuth consent step; from there the page often drifts to about.google.
+function isBlockedBrowserPage(page) {
+  try {
+    const url = new URL(page.url());
+    if (url.pathname.startsWith("/not-supported")) return true;
+    return url.hostname === "about.google" || url.hostname.endsWith(".about.google");
+  } catch {
+    return false;
+  }
+}
+
 function isProviderPage(page) {
   try {
     const url = new URL(page.url());
@@ -1230,6 +1242,100 @@ export function createKiroCallbackMonitor(context, page, timeoutMs = DEFAULT_MAN
   return promise;
 }
 
+// Parse any OAuth redirect callback URL (e.g. http://localhost:8080/callback?code=...)
+// against a configurable prefix. Returns { callbackUrl, code, state } or null.
+function parseCallbackUrlWithPrefix(rawUrl, prefix) {
+  if (!rawUrl || !prefix || !rawUrl.startsWith(prefix)) return null;
+  const queryIndex = rawUrl.indexOf("?");
+  const params = new URLSearchParams(queryIndex >= 0 ? rawUrl.slice(queryIndex + 1) : "");
+  const code = params.get("code");
+  const state = params.get("state");
+  if (!code) return null;
+  return { callbackUrl: rawUrl, code, state };
+}
+
+// Generic version of createKiroCallbackMonitor for authorization_code providers
+// whose redirect_uri is an http(s) loopback (e.g. Antigravity → http://localhost:8080/callback).
+// The browser may fail to actually load the loopback (connection refused), but the
+// request/framenavigated/requestfailed events still fire with the URL+code, which we capture.
+export function createGenericCallbackMonitor(context, page, { prefix, timeoutMs = DEFAULT_MANUAL_TIMEOUT_MS } = {}) {
+  let resolveOuter;
+  let rejectOuter;
+  const promise = new Promise((resolve, reject) => {
+    resolveOuter = resolve;
+    rejectOuter = reject;
+  });
+
+  let settled = false;
+  const trackedPages = new Set();
+  const contextCleanups = new Map();
+  const timeoutHandle = setTimeout(() => {
+    settle(null, new Error("Timed out waiting for OAuth callback"));
+  }, timeoutMs);
+
+  function settle(result, error = null) {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeoutHandle);
+    for (const fns of contextCleanups.values()) {
+      for (const fn of fns) {
+        try { fn(); } catch {}
+      }
+    }
+    contextCleanups.clear();
+    if (error) rejectOuter(error);
+    else resolveOuter(result);
+  }
+
+  function registerPage(trackedPage, ownerCleanups) {
+    if (!trackedPage || trackedPages.has(trackedPage)) return;
+    trackedPages.add(trackedPage);
+
+    const check = (url) => {
+      const parsed = parseCallbackUrlWithPrefix(url || "", prefix);
+      if (parsed) settle(parsed);
+    };
+    const onFrame = (frame) => check(frame?.url?.() || "");
+    const onRequest = (request) => check(request?.url?.() || "");
+    const onRequestFailed = (request) => check(request?.url?.() || "");
+    const onLoadState = () => check(trackedPage.url?.() || "");
+
+    trackedPage.on("framenavigated", onFrame);
+    trackedPage.on("request", onRequest);
+    trackedPage.on("requestfailed", onRequestFailed);
+    trackedPage.on("domcontentloaded", onLoadState);
+    trackedPage.on("load", onLoadState);
+
+    ownerCleanups.push(() => {
+      trackedPage.off("framenavigated", onFrame);
+      trackedPage.off("request", onRequest);
+      trackedPage.off("requestfailed", onRequestFailed);
+      trackedPage.off("domcontentloaded", onLoadState);
+      trackedPage.off("load", onLoadState);
+    });
+
+    check(trackedPage.url?.() || "");
+  }
+
+  function bind(ctx, pg) {
+    if (settled) return;
+    if (contextCleanups.has(ctx)) return;
+    const cleanups = [];
+    contextCleanups.set(ctx, cleanups);
+    const onPage = (newPage) => registerPage(newPage, cleanups);
+    ctx.on("page", onPage);
+    cleanups.push(() => ctx.off("page", onPage));
+    if (pg) registerPage(pg, cleanups);
+  }
+
+  bind(context, page);
+  promise.rebind = ({ context: newContext, page: newPage } = {}) => {
+    if (newContext) bind(newContext, newPage);
+  };
+
+  return promise;
+}
+
 export async function runGoogleAccountAutomation({
   page,
   authUrl,
@@ -1294,6 +1400,18 @@ export async function runGoogleAccountAutomation({
       continue;
     }
 
+    // Headless Chromium gets bounced to myaccount.google.com/not-supported at the
+    // OAuth consent step. From there the broad Google-button selectors wander onto
+    // about.google and loop until timeout. Detect the dead-end and bail to manual
+    // (the Camoufox engine avoids this by not being flagged as headless).
+    if (isBlockedBrowserPage(page)) {
+      reportStep("manual_assist_required", "Google blocked the automated browser (not-supported). Use the Camoufox engine or complete manually.");
+      return {
+        status: "needs_manual",
+        error: "Google blocked the automated browser at the OAuth consent step (not-supported page). Switch to the Camoufox engine or finish this account manually.",
+      };
+    }
+
     const text = await readPageText(page);
     if (includesAny(text, INVALID_CREDENTIAL_MARKERS)) {
       reportStep("invalid_credentials", "Google rejected the supplied email or password");