automate-google-login-scraper 0.1.9

package/dist/index.js

@@ -0,0 +1,455 @@
+import fs from "node:fs";
+import path from "node:path";
+import { s as summarizeStorageState, p as parseStorageState, r as redactStorageState, f as findExpiringCookies } from "./secret-B4HOopFT.js";
+import { A, I, S, a, b, c, e, d, i, g, n, h, t } from "./secret-B4HOopFT.js";
+const DEFAULT_AUTH_DIR = "playwright/.auth";
+const DEFAULT_AUTH_FILE = `${DEFAULT_AUTH_DIR}/google-test-user.json`;
+const STATE_PATH_ENV = "TEST_GOOGLE_LOGIN_STATE";
+const GITIGNORE_LINES = [
+  "playwright/.auth/",
+  ".env",
+  ".env.*",
+  "!.env.example"
+];
+function resolveAuthFile(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const file = options.file || env[STATE_PATH_ENV] || DEFAULT_AUTH_FILE;
+  return path.isAbsolute(file) ? file : path.resolve(cwd, file);
+}
+function ensureAuthDir(file) {
+  const dir = path.dirname(file);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+  return dir;
+}
+function writeAuthDirGitignore(file) {
+  const dir = ensureAuthDir(file);
+  const target = path.join(dir, ".gitignore");
+  fs.writeFileSync(
+    target,
+    [
+      "# Everything in this directory is a live browser session.",
+      "# Nothing here is ever committed — see test-google-login's README.",
+      "*",
+      ""
+    ].join("\n")
+  );
+  return target;
+}
+function isIgnored(gitignore, pattern) {
+  const normalize = (line) => line.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  const wanted = normalize(pattern);
+  if (!wanted) return true;
+  for (const raw of gitignore.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const candidate = normalize(line);
+    if (candidate === wanted) return true;
+    if (line.startsWith("!")) continue;
+    if (!candidate.includes("*") && wanted.startsWith(`${candidate}/`)) return true;
+  }
+  return false;
+}
+function ensureGitignored(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const patterns = options.patterns ?? GITIGNORE_LINES;
+  const file = path.join(cwd, ".gitignore");
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  const added = [];
+  const alreadyIgnored = [];
+  for (const pattern of patterns) {
+    const covered = pattern.startsWith("!") ? existing.split(/\r?\n/).some((line) => line.trim() === pattern) : isIgnored(existing, pattern);
+    (covered ? alreadyIgnored : added).push(pattern);
+  }
+  if (added.length > 0) {
+    const parts = [];
+    if (existing.length > 0) {
+      parts.push(existing.endsWith("\n") ? existing : `${existing}
+`);
+      parts.push("\n");
+    }
+    parts.push("# test-google-login: persisted browser sessions are credentials\n");
+    for (const pattern of added) parts.push(`${pattern}
+`);
+    fs.writeFileSync(file, parts.join(""));
+  }
+  return { file, added, alreadyIgnored };
+}
+function codegenCommand(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const absolute = resolveAuthFile({ cwd, file: options.file });
+  const relative = path.relative(cwd, absolute) || absolute;
+  const baseUrl = options.baseUrl || "http://localhost:3000";
+  return `npx playwright codegen --save-storage=${relative} ${baseUrl}`;
+}
+class MissingStorageStateError extends Error {
+  file;
+  constructor(file, hint) {
+    super(
+      [
+        `Missing persisted auth state: ${file}`,
+        "",
+        "Create it locally with:",
+        `  ${hint}`,
+        "",
+        "Then complete Google sign-in manually with the dedicated test account and",
+        "close the browser window — Playwright writes the state file on exit."
+      ].join("\n")
+    );
+    this.name = "MissingStorageStateError";
+    this.file = file;
+  }
+}
+function readStorageState(file, options = {}) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new MissingStorageStateError(file, codegenCommand({ file, ...options }));
+    }
+    throw error;
+  }
+  return parseStorageState(text);
+}
+function writeStorageState(file, state) {
+  ensureAuthDir(file);
+  fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+  try {
+    fs.chmodSync(file, 384);
+  } catch {
+  }
+  return path.resolve(file);
+}
+function hardenStorageStateFile(file) {
+  try {
+    fs.chmodSync(file, 384);
+  } catch {
+  }
+  return summarizeStorageState(parseStorageState(fs.readFileSync(file, "utf8")));
+}
+function assertStorageStateUsable(state, options = {}) {
+  const summary = summarizeStorageState(state, options);
+  if (summary.usable && !summary.expired) return summary;
+  const ago = summary.expiresInSeconds === null ? "it carries no usable cookie" : `it expired ${Math.abs(Math.round(summary.expiresInSeconds / 60))} minutes ago`;
+  throw new Error(
+    [
+      `The persisted session is no longer usable — ${ago}.`,
+      "",
+      "Re-capture it:",
+      `  ${codegenCommand(options)}`
+    ].join("\n")
+  );
+}
+const ALLOW_REAL_LOGIN_ENV = "TEST_GOOGLE_LOGIN_ALLOW_REAL";
+const BOOTSTRAP_HEADER = "x-e2e-auth-secret";
+function requireStoredSession(options = {}) {
+  const file = resolveAuthFile(options);
+  const state = readStorageState(file, options);
+  return assertStorageStateUsable(state, { ...options, file });
+}
+async function bootstrapAppSession(options) {
+  const {
+    request,
+    page,
+    context,
+    endpoint = "/api/test-auth/google-user",
+    secret,
+    landingPath = "/dashboard",
+    user,
+    indexedDB = true
+  } = options;
+  if (!secret) {
+    throw new Error(
+      "bootstrapAppSession() needs the shared secret for the test-only auth endpoint. Set E2E_TEST_AUTH_SECRET and pass it as `secret` — it is never defaulted, because an endpoint that mints sessions without one is a production incident waiting to happen."
+    );
+  }
+  const response = await request.post(endpoint, {
+    headers: { [BOOTSTRAP_HEADER]: secret },
+    data: user ?? {}
+  });
+  if (!response.ok()) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      [
+        `Test-auth endpoint ${endpoint} returned ${response.status()}.`,
+        body ? `Body: ${body.slice(0, 400)}` : "",
+        "",
+        "A 401 means the secret does not match; a 404 means the endpoint is disabled for this",
+        "environment — which is correct in production and a misconfiguration anywhere else."
+      ].filter(Boolean).join("\n")
+    );
+  }
+  await page.goto(landingPath);
+  const file = resolveAuthFile(options);
+  await context.storageState({ path: file, indexedDB });
+  hardenStorageStateFile(file);
+  return file;
+}
+function realGoogleLoginEnabled(env = process.env) {
+  const flag = env[ALLOW_REAL_LOGIN_ENV];
+  const optedIn = flag === "1" || flag?.toLowerCase() === "true";
+  return Boolean(optedIn && env.GOOGLE_TEST_EMAIL && env.GOOGLE_TEST_PASSWORD);
+}
+async function signInWithGoogle(options) {
+  const {
+    page,
+    context,
+    env = process.env,
+    loginPath = "/login",
+    signInButton = /continue with google|sign in with google/i,
+    expectUrl = /dashboard|app/,
+    indexedDB = true,
+    googleSelectors = {}
+  } = options;
+  if (!realGoogleLoginEnabled(env)) {
+    throw new Error(
+      [
+        "Real Google sign-in is not enabled.",
+        "",
+        `Set ${ALLOW_REAL_LOGIN_ENV}=1 together with GOOGLE_TEST_EMAIL and GOOGLE_TEST_PASSWORD,`,
+        "and only in a manually triggered workflow on a protected branch — never where a fork's",
+        "pull request can reach the secrets.",
+        "",
+        "For everything else, prefer a session captured once by hand:",
+        `  ${codegenCommand(options)}`
+      ].join("\n")
+    );
+  }
+  const email = env.GOOGLE_TEST_EMAIL;
+  const password = env.GOOGLE_TEST_PASSWORD;
+  const emailField = googleSelectors.email ?? /email or phone/i;
+  const passwordField = googleSelectors.password ?? /enter your password/i;
+  const next = googleSelectors.next ?? /^next$/i;
+  await page.goto(loginPath);
+  await page.getByRole("button", { name: signInButton }).click();
+  await page.getByLabel(emailField).fill(email);
+  await page.getByRole("button", { name: next }).click();
+  await page.getByLabel(passwordField).fill(password);
+  await page.getByRole("button", { name: next }).click();
+  await page.waitForURL(expectUrl);
+  const file = resolveAuthFile(options);
+  await context.storageState({ path: file, indexedDB });
+  hardenStorageStateFile(file);
+  return file;
+}
+function loadStorageStateFor(options = {}) {
+  return readStorageState(resolveAuthFile(options), options);
+}
+const HELP = `test-google-login — persist a Google test session for Playwright, safely
+
+Usage
+  test-google-login init [--file <path>] [--url <baseUrl>]
+      Create the auth directory (0700), add the gitignore rules, and print the
+      playwright codegen command that captures a session.
+
+  test-google-login check [--file <path>] [--within <minutes>]
+      Report what the stored session holds and whether it is still usable.
+      Exits 1 when it is missing or expired, so CI can fail early and clearly.
+
+  test-google-login redact [--file <path>]
+      Print the state with every cookie and localStorage value replaced by its
+      length. This is the only form that is safe to share.
+
+  test-google-login clear [--file <path>]
+      Delete the stored session.
+
+Options
+  --file <path>     State file. Default: ${DEFAULT_AUTH_FILE}
+                    (or $TEST_GOOGLE_LOGIN_STATE)
+  --url <baseUrl>   App URL used in the codegen command. Default: http://localhost:3000
+  --within <mins>   'check' warns about cookies expiring within this window. Default: 60
+  --json            Machine-readable output for 'check'.
+
+The state file contains live cookies and tokens. Treat it exactly like the
+password that produced it: dedicated Google test account only, never committed,
+never a public CI artifact, never pasted into a log.
+`;
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i2 = 0; i2 < argv.length; i2 += 1) {
+    const arg = argv[i2];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const [name, inline] = arg.slice(2).split("=", 2);
+    if (inline !== void 0) {
+      flags[name] = inline;
+      continue;
+    }
+    const next = argv[i2 + 1];
+    if (next && !next.startsWith("--")) {
+      flags[name] = next;
+      i2 += 1;
+    } else {
+      flags[name] = true;
+    }
+  }
+  return { command: positional[0] ?? "help", flags };
+}
+async function runCli(argv, io = {}) {
+  const out = io.out ?? ((line) => console.log(line));
+  const err = io.err ?? ((line) => console.error(line));
+  const cwd = io.cwd ?? process.cwd();
+  const { command, flags } = parseArgs(argv);
+  const file = resolveAuthFile({ cwd, file: typeof flags.file === "string" ? flags.file : void 0 });
+  const baseUrl = typeof flags.url === "string" ? flags.url : void 0;
+  switch (command) {
+    case "init":
+      return init({ cwd, file, baseUrl, out });
+    case "check":
+      return check({ cwd, file, baseUrl, flags, out, err });
+    case "redact":
+      return redact({ file, out, err });
+    case "clear":
+      return clear({ cwd, file, out });
+    case "help":
+    case "--help":
+    case "-h":
+      out(HELP);
+      return 0;
+    default:
+      err(`Unknown command: ${command}
+`);
+      err(HELP);
+      return 1;
+  }
+}
+function init(options) {
+  const { cwd, file, baseUrl, out } = options;
+  const dir = ensureAuthDir(file);
+  const nested = writeAuthDirGitignore(file);
+  const gitignore = ensureGitignored({ cwd });
+  out(`Created ${path.relative(cwd, dir) || dir}/ (mode 0700)`);
+  out(`Wrote   ${path.relative(cwd, nested)} — ignores everything in that directory`);
+  if (gitignore.added.length > 0) {
+    out(`Added to .gitignore: ${gitignore.added.join(", ")}`);
+  } else {
+    out(`.gitignore already covers: ${GITIGNORE_LINES.join(", ")}`);
+  }
+  out("");
+  out("Now capture a session by hand — this avoids automating Google's password form,");
+  out("which is what MFA, CAPTCHA and device checks all break:");
+  out("");
+  out(`  ${codegenCommand({ cwd, file, baseUrl })}`);
+  out("");
+  out("In the window that opens: click your app's 'Sign in with Google', sign in with");
+  out("the dedicated test account, finish the redirect back to your app, confirm you");
+  out("are on an authenticated page, then close the window. Playwright writes the");
+  out("state file on exit.");
+  return 0;
+}
+function check(options) {
+  const { cwd, file, baseUrl, flags, out, err } = options;
+  let state;
+  try {
+    state = readStorageState(file, { cwd, baseUrl });
+  } catch (error) {
+    err(error.message);
+    return error instanceof MissingStorageStateError ? 1 : 2;
+  }
+  const summary = summarizeStorageState(state);
+  const withinMinutes = Number.parseFloat(String(flags.within ?? "60"));
+  const expiring = findExpiringCookies(state, { withinMs: withinMinutes * 6e4 });
+  if (flags.json) {
+    out(JSON.stringify({ file, summary, expiringSoon: expiring.map((cookie) => cookie.name) }, null, 2));
+  } else {
+    out(`State file   ${path.relative(cwd, file) || file}`);
+    out(`Cookies      ${summary.cookieCount} (${summary.sessionCookies} session-only)`);
+    out(`Domains      ${summary.domains.join(", ") || "none"}`);
+    out(`Origins      ${summary.originCount}`);
+    out(`Google cookies present: ${summary.hasGoogleCookies ? "yes" : "no"}`);
+    if (summary.expiresInSeconds === null) {
+      out("Expiry       no cookie carries one — this session dies with the browser");
+    } else {
+      const minutes = Math.round(summary.expiresInSeconds / 60);
+      out(
+        summary.expiresInSeconds > 0 ? `Expiry       earliest in ${minutes} minutes` : `Expiry       lapsed ${Math.abs(minutes)} minutes ago`
+      );
+    }
+    if (expiring.length > 0 && summary.usable) {
+      out("");
+      out(
+        `⚠ ${expiring.length} cookie(s) expire within ${withinMinutes} minutes: ${expiring.map((cookie) => cookie.name).join(", ")}`
+      );
+      out(`  Re-capture before a long run: ${codegenCommand({ cwd, file, baseUrl })}`);
+    }
+  }
+  if (!summary.usable || summary.expired) {
+    err("");
+    err("This session is no longer usable. Re-capture it:");
+    err(`  ${codegenCommand({ cwd, file, baseUrl })}`);
+    return 1;
+  }
+  return 0;
+}
+function redact(options) {
+  try {
+    const state = readStorageState(options.file);
+    options.out(JSON.stringify(redactStorageState(state), null, 2));
+    return 0;
+  } catch (error) {
+    options.err(error.message);
+    return 1;
+  }
+}
+function clear(options) {
+  const { cwd, file, out } = options;
+  if (!fs.existsSync(file)) {
+    out(`Nothing to clear — ${path.relative(cwd, file) || file} does not exist.`);
+    return 0;
+  }
+  fs.rmSync(file);
+  out(`Deleted ${path.relative(cwd, file) || file}`);
+  return 0;
+}
+export {
+  ALLOW_REAL_LOGIN_ENV,
+  A as AUTH_HEADER,
+  BOOTSTRAP_HEADER,
+  DEFAULT_AUTH_DIR,
+  DEFAULT_AUTH_FILE,
+  GITIGNORE_LINES,
+  I as InvalidStorageStateError,
+  MissingStorageStateError,
+  S as SESSION_COOKIE_EXPIRES,
+  STATE_PATH_ENV,
+  a as applyLocalStorage,
+  b as applyStorageState,
+  assertStorageStateUsable,
+  bootstrapAppSession,
+  codegenCommand,
+  c as constantTimeEqual,
+  ensureAuthDir,
+  ensureGitignored,
+  e as extractStorageState,
+  findExpiringCookies,
+  d as fromPuppeteerCookies,
+  hardenStorageStateFile,
+  i as isAuthorized,
+  g as isGoogleDomain,
+  isIgnored,
+  loadStorageStateFor,
+  n as normalizeStorageState,
+  parseArgs,
+  parseStorageState,
+  readStorageState,
+  realGoogleLoginEnabled,
+  redactStorageState,
+  requireStoredSession,
+  resolveAuthFile,
+  runCli,
+  signInWithGoogle,
+  h as storageStateOrigins,
+  summarizeStorageState,
+  t as toPuppeteerCookies,
+  writeAuthDirGitignore,
+  writeStorageState
+};

package/dist/puppeteer-state.d.ts

@@ -0,0 +1,80 @@
+import { PageLike, PuppeteerCookie, StorageState, StorageStateCookie } from './types.js';
+/**
+ * Playwright cookies → Puppeteer/CDP cookies.
+ *
+ * The one transformation that matters: a session cookie loses its `expires` key
+ * entirely rather than carrying `-1`.
+ */
+export declare function toPuppeteerCookies(state: StorageState): PuppeteerCookie[];
+/**
+ * Puppeteer/CDP cookies → Playwright cookies.
+ *
+ * The inverse, plus the normalizations a CDP read needs: `session: true` or a
+ * missing expiry becomes `-1`, and `sameSite` is re-capitalised (CDP has been
+ * known to return `"unspecified"`, which is not one of the three).
+ */
+export declare function fromPuppeteerCookies(cookies: PuppeteerCookie[]): StorageStateCookie[];
+/** The origins a state file carries `localStorage` for, in file order. */
+export declare function storageStateOrigins(state: StorageState): string[];
+/**
+ * Write one origin's `localStorage` into a page that is already on that origin.
+ *
+ * Exported because it is the half that can fail for reasons worth surfacing: a
+ * page on `about:blank` or a cross-origin page throws `SecurityError`, and a
+ * browser with storage disabled throws `QuotaExceededError`. Both are far easier
+ * to read here than three steps later as a login screen.
+ */
+export declare function applyLocalStorage(page: PageLike, entries: {
+    name: string;
+    value: string;
+}[]): Promise<void>;
+export interface ApplyStorageStateOptions {
+    /**
+     * Only restore `localStorage` for these origins. Defaults to every origin in
+     * the state.
+     *
+     * Worth narrowing: the state captured during a real Google sign-in also holds
+     * `accounts.google.com` storage, and navigating a test browser to Google to
+     * restore it is both slow and a way to trip Google's own bot checks. Pass your
+     * app's origin and nothing else for the common case.
+     */
+    origins?: string[];
+    /** Passed through to `page.goto` for each origin navigation. */
+    gotoOptions?: Record<string, unknown>;
+}
+export interface ApplyStorageStateResult {
+    cookiesSet: number;
+    /** Origins whose `localStorage` was restored. */
+    originsRestored: string[];
+    /** Origins skipped, and why — a navigation that failed is not fatal on its own. */
+    skipped: {
+        origin: string;
+        reason: string;
+    }[];
+}
+/**
+ * Restore a whole captured session into a Puppeteer page.
+ *
+ * Cookies go in first and in one call — `setCookie` is variadic and a
+ * cookie-at-a-time loop is a round trip each. Then one navigation per origin to
+ * get a document that `localStorage` can be written through.
+ *
+ * A state file with no `origins` therefore costs no navigation at all, which is
+ * the case for most apps: if your session lives in a cookie, this is a single
+ * CDP call and you can `goto` wherever you actually wanted to go.
+ */
+export declare function applyStorageState(page: PageLike, state: StorageState, options?: ApplyStorageStateOptions): Promise<ApplyStorageStateResult>;
+/**
+ * Capture the current session out of a Puppeteer page, in Playwright's format.
+ *
+ * The mirror of {@link applyStorageState}: what a Worker produces here can be
+ * dropped into `playwright/.auth/` and used by the local suite, and vice versa.
+ *
+ * `origins` must be given explicitly — `localStorage` can only be read from the
+ * origin that owns it, so there is nothing to enumerate from. Defaults to the
+ * page's current origin, which is the common case.
+ */
+export declare function extractStorageState(page: PageLike, options?: {
+    origins?: string[];
+    gotoOptions?: Record<string, unknown>;
+}): Promise<StorageState>;