patchrome 0.1.0

package/dist/challenges.js

@@ -0,0 +1,97 @@
+import { CommandError } from "./protocol.js";
+export const challengeVendors = [
+    "turnstile",
+    "recaptcha",
+    "hcaptcha",
+    "datadome",
+    "mtcaptcha",
+    "cloudflare-interstitial",
+    "unknown",
+];
+// Widgets write their pass token into a form field of the host page; a filled field means the check passed.
+const tokenFieldSelector = [
+    '[name="cf-turnstile-response"]',
+    '[name="g-recaptcha-response"]',
+    '[name="h-captcha-response"]',
+    '[name="mtcaptcha-verifiedtoken"]',
+].join(", ");
+const handoffPollMs = 500;
+export function vendorOfFrameUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+    const host = parsed.hostname;
+    if (host === "challenges.cloudflare.com")
+        return "turnstile";
+    if ((host === "www.google.com" || host === "www.recaptcha.net") && parsed.pathname.startsWith("/recaptcha/"))
+        return "recaptcha";
+    if (host === "hcaptcha.com" || host.endsWith(".hcaptcha.com"))
+        return "hcaptcha";
+    if (host.endsWith(".captcha-delivery.com"))
+        return "datadome";
+    if (host === "service.mtcaptcha.com")
+        return "mtcaptcha";
+    return undefined;
+}
+// Cloudflare's full-page check shows this title until it lets the visitor through.
+export function isInterstitialTitle(title) {
+    return /^just a moment\.*$/i.test(title.trim());
+}
+export async function inspectChallenges(page) {
+    const widgets = [];
+    // The main frame is the site itself, even on a vendor's own demo page.
+    for (const frame of page.frames().filter((candidate) => candidate !== page.mainFrame())) {
+        const vendor = vendorOfFrameUrl(frame.url());
+        if (vendor === undefined)
+            continue;
+        widgets.push({ vendor, url: frame.url(), box: await frameBox(frame) });
+    }
+    const title = await page.title().catch(() => "");
+    if (isInterstitialTitle(title))
+        widgets.push({ vendor: "cloudflare-interstitial", url: page.url(), box: undefined });
+    const tokens = await tokenValues(page);
+    if (widgets.length === 0 && tokens.length > 0)
+        widgets.push({ vendor: "unknown", url: page.url(), box: undefined });
+    const isSolved = tokens.some((token) => token !== "");
+    const state = widgets.length === 0 ? "none" : isSolved ? "solved" : "pending";
+    return { state, widgets };
+}
+// Raises the tab for a person to solve, then returns once the widget passes, the page moves past it, or the
+// person closes the tab.
+export async function waitForPersonToSolve(page, timeoutMs) {
+    await page.bringToFront();
+    const deadlineMs = Date.now() + timeoutMs;
+    for (;;) {
+        if (page.isClosed())
+            throw new CommandError("tab_gone", "the tab closed before the challenge was solved", "run `patchrome open <url>`");
+        const report = await inspectChallenges(page).catch(() => undefined);
+        if (report !== undefined && report.state !== "pending")
+            return report;
+        if (Date.now() >= deadlineMs)
+            throw new CommandError("timeout", `the challenge was not solved within ${timeoutMs} ms`, "raise --timeout-ms, or check the tab with screenshot");
+        await new Promise((resolve) => setTimeout(resolve, handoffPollMs));
+    }
+}
+async function frameBox(frame) {
+    const element = await frame.frameElement().catch(() => undefined);
+    const box = await element?.boundingBox().catch(() => null);
+    return box ?? undefined;
+}
+async function tokenValues(page) {
+    const values = [];
+    for (const frame of page.frames()) {
+        const fields = frame.locator(tokenFieldSelector);
+        const count = await fields.count().catch(() => 0);
+        for (let index = 0; index < count; index++) {
+            values.push(await fields
+                .nth(index)
+                .inputValue({ timeout: 1000 })
+                .catch(() => ""));
+        }
+    }
+    return values;
+}

package/dist/chrome-profiles.d.ts

@@ -0,0 +1,17 @@
+export interface ChromeProfile {
+    folder: string;
+    name: string;
+    email: string | undefined;
+}
+export declare function chromeUserDataDirFrom(env: NodeJS.ProcessEnv, platform?: NodeJS.Platform, home?: string): string;
+export declare function listChromeProfiles(userDataDir: string): Promise<{
+    profiles: ChromeProfile[];
+    lastUsedFolder: string | undefined;
+}>;
+export declare function resolveChromeProfile(profiles: ChromeProfile[], from: string | undefined, lastUsedFolder: string | undefined): ChromeProfile;
+export declare function describeChromeProfile(profile: ChromeProfile): string;
+export declare function siteFromInput(input: string): string;
+export declare function hostBelongsToSite(host: string, site: string): boolean;
+export declare function copySiteLoginStorage(profileDir: string, site: string, copyUserDataDir: string): Promise<string[]>;
+export declare function localStorageOrigins(leveldbDir: string): Promise<string[]>;
+export declare function originOfIndexedDbFolder(folder: string): string | undefined;

package/dist/chrome-profiles.js

@@ -0,0 +1,141 @@
+import { cp, mkdir, readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { CommandError } from "./protocol.js";
+// Where the everyday Google Chrome keeps its profiles. PATCHROME_CHROME_USER_DATA_DIR points elsewhere,
+// for Chrome Beta or a test profile.
+export function chromeUserDataDirFrom(env, platform = process.platform, home = homedir()) {
+    if (env.PATCHROME_CHROME_USER_DATA_DIR !== undefined)
+        return env.PATCHROME_CHROME_USER_DATA_DIR;
+    if (platform === "darwin")
+        return join(home, "Library", "Application Support", "Google", "Chrome");
+    if (platform === "win32")
+        return join(env.LOCALAPPDATA ?? join(home, "AppData", "Local"), "Google", "Chrome", "User Data");
+    return join(home, ".config", "google-chrome");
+}
+export async function listChromeProfiles(userDataDir) {
+    const raw = await readFile(join(userDataDir, "Local State"), "utf8").catch(() => {
+        throw new CommandError("bad_args", `no Chrome profiles found in ${userDataDir}`, "set PATCHROME_CHROME_USER_DATA_DIR to the Chrome user data dir");
+    });
+    const profileState = (JSON.parse(raw).profile ?? {});
+    const profiles = Object.entries(profileState.info_cache ?? {}).map(([folder, info]) => ({
+        folder,
+        name: info.name ?? folder,
+        email: info.user_name === undefined || info.user_name === "" ? undefined : info.user_name,
+    }));
+    return { profiles, lastUsedFolder: profileState.last_used };
+}
+// Accepts what a person sees or knows: the menu name, the folder, or the signed-in email.
+export function resolveChromeProfile(profiles, from, lastUsedFolder) {
+    const wanted = (from ?? lastUsedFolder ?? "Default").toLowerCase();
+    const matches = profiles.filter((profile) => [profile.folder, profile.name, profile.email].some((candidate) => candidate?.toLowerCase() === wanted));
+    const choices = profiles.map(describeChromeProfile).join(", ");
+    if (matches.length === 1 && matches[0] !== undefined)
+        return matches[0];
+    if (matches.length > 1)
+        throw new CommandError("bad_args", `${from} names more than one Chrome profile: ${choices}`, "pass the folder name with --from");
+    throw new CommandError("bad_args", `no Chrome profile named ${from ?? wanted}`, `pass --from with one of: ${choices}`);
+}
+export function describeChromeProfile(profile) {
+    return `"${profile.name}" (${profile.folder}${profile.email === undefined ? "" : `, ${profile.email}`})`;
+}
+// A site is a host name; a pasted URL keeps only its host.
+export function siteFromInput(input) {
+    const trimmed = input.trim().toLowerCase();
+    const host = /^[a-z][a-z0-9+.-]*:\/\//.test(trimmed)
+        ? new URL(trimmed).hostname
+        : (trimmed.replace(/^\./, "").split("/")[0] ?? "");
+    if (!/^[a-z0-9][a-z0-9.-]*$/.test(host))
+        throw new CommandError("bad_args", `${input} is not a site`, "pass a host such as github.com");
+    return host;
+}
+export function hostBelongsToSite(host, site) {
+    const bare = host.replace(/^\./, "").toLowerCase();
+    return bare === site || bare.endsWith(`.${site}`);
+}
+// Copies only what a login lives in: the cookie jar, localStorage, and the site's own IndexedDB. The copy is
+// what Chrome opens, so the everyday profile is never locked or written. Returns the site's origins that hold
+// localStorage or IndexedDB.
+export async function copySiteLoginStorage(profileDir, site, copyUserDataDir) {
+    const source = (name) => join(profileDir, name);
+    const target = join(copyUserDataDir, "Default");
+    await mkdir(target, { recursive: true });
+    // Chrome holds LOCK while it runs; the copy gets its own.
+    const skipLock = (path) => basename(path) !== "LOCK";
+    const origins = new Set();
+    for (const name of ["Cookies", "Cookies-journal"])
+        await cp(source(name), join(target, name)).catch(ignoreMissing);
+    await cp(source("Local Storage"), join(target, "Local Storage"), { recursive: true, filter: skipLock }).catch(ignoreMissing);
+    for (const origin of await localStorageOrigins(join(target, "Local Storage", "leveldb"))) {
+        if (hostBelongsToSite(new URL(origin).hostname, site))
+            origins.add(origin);
+    }
+    for (const folder of await readdir(source("IndexedDB")).catch(() => [])) {
+        const origin = originOfIndexedDbFolder(folder);
+        if (origin === undefined || !hostBelongsToSite(new URL(origin).hostname, site))
+            continue;
+        origins.add(origin);
+        await cp(join(source("IndexedDB"), folder), join(target, "IndexedDB", folder), {
+            recursive: true,
+            filter: skipLock,
+        });
+    }
+    // Newer Chrome files IndexedDB under numbered storage buckets, listed in the QuotaManager database.
+    await mkdir(join(target, "WebStorage"), { recursive: true });
+    const hasQuotaManager = await cp(source("WebStorage/QuotaManager"), join(target, "WebStorage", "QuotaManager")).then(() => true, () => false);
+    if (hasQuotaManager) {
+        await cp(source("WebStorage/QuotaManager-journal"), join(target, "WebStorage", "QuotaManager-journal")).catch(ignoreMissing);
+        for (const { bucketId, origin } of await bucketOrigins(join(target, "WebStorage", "QuotaManager"))) {
+            if (!hostBelongsToSite(new URL(origin).hostname, site))
+                continue;
+            origins.add(origin);
+            await cp(source(`WebStorage/${bucketId}`), join(target, "WebStorage", String(bucketId)), {
+                recursive: true,
+                filter: skipLock,
+            }).catch(ignoreMissing);
+        }
+    }
+    return [...origins].toSorted();
+}
+function ignoreMissing(err) {
+    if (err.code !== "ENOENT")
+        throw err;
+}
+// LevelDB compresses table files, but Chrome writes a META:<origin> key per origin whose text stays readable.
+export async function localStorageOrigins(leveldbDir) {
+    const origins = new Set();
+    for (const file of await readdir(leveldbDir).catch(() => [])) {
+        if (!/\.(log|ldb)$/.test(file))
+            continue;
+        const text = (await readFile(join(leveldbDir, file))).toString("latin1");
+        for (const match of text.matchAll(/META:(https?:\/\/[a-z0-9.-]+(?::\d+)?)/g)) {
+            if (match[1] !== undefined)
+                origins.add(match[1]);
+        }
+    }
+    return [...origins];
+}
+// Folders read like https_app.example.com_0.indexeddb.leveldb, where port 0 is the scheme's default.
+export function originOfIndexedDbFolder(folder) {
+    const match = folder.match(/^(https?)_([a-z0-9.-]+)_(\d+)\.indexeddb\.leveldb$/);
+    if (!match)
+        return undefined;
+    const [, scheme, host, port] = match;
+    return port === "0" ? `${scheme}://${host}` : `${scheme}://${host}:${port}`;
+}
+// Partitioned keys (a site embedded in another) carry ^ markers and are left out: they are not the site's login.
+// node:sqlite loads here, not at the top, because it prints an experimental warning into every CLI run.
+async function bucketOrigins(quotaManagerPath) {
+    const { DatabaseSync } = await import("node:sqlite");
+    const db = new DatabaseSync(quotaManagerPath, { readOnly: true });
+    try {
+        const rows = db.prepare("select id, storage_key from buckets").all();
+        return rows.flatMap((row) => {
+            const match = row.storage_key.match(/^(https?:\/\/[a-z0-9.-]+(?::\d+)?)\/$/);
+            return match?.[1] === undefined ? [] : [{ bucketId: row.id, origin: match[1] }];
+        });
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli-options.d.ts

@@ -0,0 +1,131 @@
+export declare const cliOptions: {
+    readonly profile: {
+        readonly type: "string";
+    };
+    readonly session: {
+        readonly type: "string";
+    };
+    readonly json: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "timeout-ms": {
+        readonly type: "string";
+    };
+    readonly wait: {
+        readonly type: "string";
+    };
+    readonly all: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly inline: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly full: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly ref: {
+        readonly type: "string";
+    };
+    readonly "main-world": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly url: {
+        readonly type: "string";
+    };
+    readonly type: {
+        readonly type: "string";
+    };
+    readonly status: {
+        readonly type: "string";
+    };
+    readonly body: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly until: {
+        readonly type: "string";
+    };
+    readonly domain: {
+        readonly type: "string";
+    };
+    readonly level: {
+        readonly type: "string";
+    };
+    readonly follow: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly mode: {
+        readonly type: "string";
+    };
+    readonly isolated: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly from: {
+        readonly type: "string";
+    };
+    readonly selector: {
+        readonly type: "string";
+    };
+    readonly text: {
+        readonly type: "string";
+    };
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly load: {
+        readonly type: "string";
+    };
+    readonly gone: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly events: {
+        readonly type: "string";
+    };
+    readonly count: {
+        readonly type: "string";
+    };
+    readonly frame: {
+        readonly type: "string";
+    };
+    readonly at: {
+        readonly type: "string";
+    };
+    readonly handoff: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly role: {
+        readonly type: "string";
+    };
+    readonly name: {
+        readonly type: "string";
+    };
+    readonly exact: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly nth: {
+        readonly type: "string";
+    };
+    readonly label: {
+        readonly type: "string";
+    };
+    readonly out: {
+        readonly type: "string";
+    };
+    readonly format: {
+        readonly type: "string";
+    };
+    readonly bail: {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+};

package/dist/cli-options.js

@@ -0,0 +1,43 @@
+// Every flag the CLI knows. History reads recorded words with the same table, so `--ref e5` parses the
+// way the CLI parsed it.
+export const cliOptions = {
+    profile: { type: "string" },
+    session: { type: "string" },
+    json: { type: "boolean", default: false },
+    "timeout-ms": { type: "string" },
+    wait: { type: "string" },
+    all: { type: "boolean", default: false },
+    inline: { type: "boolean", default: false },
+    full: { type: "boolean", default: false },
+    ref: { type: "string" },
+    "main-world": { type: "boolean", default: false },
+    url: { type: "string" },
+    type: { type: "string" },
+    status: { type: "string" },
+    body: { type: "boolean", default: false },
+    until: { type: "string" },
+    domain: { type: "string" },
+    level: { type: "string" },
+    follow: { type: "boolean", default: false },
+    mode: { type: "string" },
+    isolated: { type: "boolean", default: false },
+    from: { type: "string" },
+    selector: { type: "string" },
+    text: { type: "string" },
+    title: { type: "string" },
+    load: { type: "string" },
+    gone: { type: "boolean", default: false },
+    events: { type: "string" },
+    count: { type: "string" },
+    frame: { type: "string" },
+    at: { type: "string" },
+    handoff: { type: "boolean", default: false },
+    role: { type: "string" },
+    name: { type: "string" },
+    exact: { type: "boolean", default: false },
+    nth: { type: "string" },
+    label: { type: "string" },
+    out: { type: "string" },
+    format: { type: "string" },
+    bail: { type: "boolean", default: false },
+};

package/dist/cli.d.ts

@@ -0,0 +1,48 @@
+import { type CommandArgs, type CommandData, type CommandName } from "./protocol.ts";
+import { type HistoryFormat } from "./history.ts";
+interface ParsedCli {
+    profile: string;
+    session: string;
+    isJson: boolean;
+    timeoutMs: number;
+    command: CommandName;
+    args: CommandArgs;
+    shouldStartDaemon: boolean;
+}
+export type LocalAction = {
+    kind: "logs";
+    profile: string;
+    isJson: boolean;
+} | {
+    kind: "audit";
+    count: number;
+    isJson: boolean;
+} | {
+    kind: "create-profile";
+    profile: string;
+    mode: string;
+    isJson: boolean;
+} | {
+    kind: "completions";
+    shell: "zsh";
+} | {
+    kind: "history";
+    profile: string;
+    session: string;
+    format: HistoryFormat;
+    out: string | undefined;
+    isClear: boolean;
+    isJson: boolean;
+} | {
+    kind: "pipe";
+    profile: string;
+    session: string;
+    isBail: boolean;
+};
+export declare function parseCli(argv: string[], env: NodeJS.ProcessEnv, sessionFallback: () => string): ParsedCli | LocalAction;
+export declare function localActionData(action: Exclude<LocalAction, {
+    kind: "completions" | "pipe";
+}>): Promise<CommandData>;
+declare function main(argv: string[]): Promise<number>;
+export declare const runCli: typeof main;
+export {};