@glubean/browser 0.8.1 → 0.9.0

package/dist/evidence.d.ts

@@ -0,0 +1,470 @@
+/**
+ * Shared evidence CDP session — the foundation for browser evidence capture.
+ *
+ * A single self-opened `createCDPSession` hosts **all** CDP-backed capabilities
+ * at once, instead of opening one session per capability:
+ *
+ * - **Network trace** (`Network` domain) — every in-page request as a Glubean
+ *   trace event (see {@link ./network.ts}).
+ * - **Request mock** (`Fetch` domain) — fulfill matching requests with a canned
+ *   response; non-matching requests are continued untouched.
+ * - **Emulation** (`Emulation` domain) — timezone / geolocation / viewport / user agent.
+ * - **Storage state** — restore cookies / localStorage before the page's
+ *   first script runs, and capture them back out on demand (a thin "login
+ *   once, reuse the session" primitive). Cookies go through this session's
+ *   `Network.setCookies` (browser-context scoped, session-agnostic in CDP).
+ *   localStorage does **not** — see guardrail ③.
+ *
+ * The keystone spike disproved the "Fetch is near-exclusive" hypothesis: a
+ * self-opened session running `Fetch.enable`/`fulfillRequest` is stable **as
+ * long as the user has not enabled Puppeteer's own request interception**.
+ * Three coexistence hazards exist, each handled below:
+ *
+ * **Guardrail ① — viewport ownership.** Our `Emulation.setDeviceMetricsOverride`
+ * and Puppeteer's `page.setViewport()` both drive device metrics and clobber
+ * each other last-wins. When `emulate.viewport` is configured, Glubean is the
+ * sole owner: it applies the viewport last and blocks `page.setViewport()` with
+ * a clear error so the two never race.
+ *
+ * **Guardrail ② — Fetch double-open.** If the user turns on Puppeteer request
+ * interception (`page.setRequestInterception(true)`) while our `Fetch` mock is
+ * active, both stacks try to handle the same paused request and fulfillment
+ * conflicts. When mocks are enabled, Glubean owns `Fetch` and blocks
+ * `page.setRequestInterception(true)` with a clear error. When no mocks are
+ * configured we never enable `Fetch`, so the user's own interception is free.
+ *
+ * **Guardrail ③ — new-document scripts need Puppeteer's OWN session.**
+ * Verified empirically: sending `Page.addScriptToEvaluateOnNewDocument` on
+ * our *auxiliary* `page.createCDPSession()` session registers without error
+ * (a real `identifier` comes back) but the script never actually fires on
+ * subsequent navigations — only the session Puppeteer itself uses for the
+ * page's frame-lifecycle bookkeeping gets its new-document scripts run.
+ * `storageState.localStorage` therefore seeds via Puppeteer's own
+ * `page.evaluateOnNewDocument()`, not a raw CDP call on this session.
+ *
+ * **Downloads** (`Browser` domain, BT1-M5) — `Browser.setDownloadBehavior`
+ * with `eventsEnabled: true`, called on this same auxiliary session, both
+ * configures the save directory AND (unlike guardrail ③'s Page-domain
+ * finding) reliably delivers `Browser.downloadWillBegin` /
+ * `Browser.downloadProgress` back on THIS session — verified empirically
+ * (spike script) against puppeteer-core ^24; `Browser.*` is genuinely
+ * session-agnostic where `Page.addScriptToEvaluateOnNewDocument` was not.
+ * The deprecated `Page.setDownloadBehavior` / `Page.downloadWillBegin` also
+ * work on the same spike but `Browser.*` is the protocol's forward path, so
+ * that's what's wired here. One caveat verified in the same spike: the file
+ * on disk is saved as `suggestedFilename`, not `guid` (despite some CDP docs
+ * implying the latter) — `DownloadEntry.path` is built from that name, which
+ * is only exact when Chrome didn't have to de-duplicate a collision.
+ * Always wired when a page is created (like dialog/popup) — a download IS
+ * evidence the moment it happens, not an opt-in capability.
+ *
+ * **Guardrail ④ — download events are browser-context-global.** Unlike the
+ * page-scoped `Network`/`Fetch` domains, `Browser.setDownloadBehavior` sets a
+ * single context-wide save path (last caller wins) and its `downloadWillBegin`/
+ * `downloadProgress` events fire on *every* session that turned events on, for
+ * *every* download in the context. So two instrumented pages in one Chrome
+ * would otherwise cross-observe and cross-repoint each other's downloads. Two
+ * mitigations: (a) the page layer uses ONE browser-wide download dir (not
+ * per-test) so the last-wins path is a no-op; (b) this session enables the
+ * `Page` domain, tracks its target's frame ids (`Page.getFrameTree` +
+ * `frameAttached`/`frameDetached`), and only records downloads whose
+ * originating `frameId` it owns — so a page never resolves another page's
+ * download. Both degrade safely: an unreadable frame tree falls back to
+ * accepting all events (single-page runs are unaffected).
+ *
+ * @module evidence
+ */
+import type { CDPSession, Page } from "puppeteer-core";
+import { type NetworkTracerOptions, type TraceFn } from "./network.js";
+/**
+ * When screenshots are automatically captured into the evidence stream.
+ *
+ * - `"off"` — no automatic screenshots
+ * - `"on-failure"` — capture when a step or test fails (default)
+ * - `"every-step"` — capture after every action AND on failure
+ */
+export type ScreenshotMode = "off" | "on-failure" | "every-step";
+/**
+ * What triggered a screenshot capture.
+ *
+ * - `"step"` — post-action capture in every-step mode
+ * - `"failure"` — automatic capture on action or assertion failure
+ * - `"manual"` — explicit call to `page.captureScreenshot()`
+ */
+export type ScreenshotTrigger = "step" | "failure" | "manual";
+/** A screenshot captured into the evidence stream. */
+export interface ScreenshotEntry {
+    /** Sequential number within this evidence session (1-based). */
+    seq: number;
+    /** Wall-clock ISO timestamp at capture time. */
+    ts: string;
+    /** Human-readable label (the action or assertion that triggered the capture). */
+    label: string;
+    /** What triggered this capture. */
+    trigger: ScreenshotTrigger;
+    /** Artifact ID when `ctx.saveArtifact` is available (SDK ≥ 0.13). */
+    artifactId?: string;
+    /** File path when falling back to direct file write. */
+    path?: string;
+}
+/**
+ * Screenshot capture options for the shared evidence session.
+ *
+ * The `shoot` delegate performs the actual I/O (screenshot + artifact save +
+ * `ctx.event()` emission); {@link EvidenceSession.captureShot} handles the
+ * mode / trigger policy, sequencing, and accumulation of entries.
+ */
+export interface EvidenceScreenshotOptions {
+    /** Policy: which triggers result in a capture. */
+    mode: ScreenshotMode;
+    /**
+     * I/O delegate — takes the screenshot, saves the artifact, and emits
+     * the `browser:screenshot` evidence event. Returns an artifact reference
+     * for {@link ScreenshotEntry}. Called only when the mode/trigger policy allows.
+     *
+     * @param filename — suggested filename: `[FAIL-]NNN-label-ts.png`
+     * @param label — human label for the action/assertion
+     * @param trigger — what triggered this capture
+     */
+    shoot: (filename: string, label: string, trigger: ScreenshotTrigger) => Promise<{
+        artifactId?: string;
+        path?: string;
+    }>;
+}
+/** A single header as CDP's `Fetch.fulfillRequest` expects it. */
+interface HeaderEntry {
+    name: string;
+    value: string;
+}
+/**
+ * A request-mock rule. Matching requests are fulfilled with a canned response;
+ * everything else is continued untouched.
+ */
+export interface MockRule {
+    /**
+     * Match the request URL. A string matches by substring (`url.includes(...)`);
+     * a `RegExp` matches by `test(url)`.
+     */
+    url: string | RegExp;
+    /** Restrict to a single HTTP method (case-insensitive). Omit to match any. */
+    method?: string;
+    /** Response status code. @default 200 */
+    status?: number;
+    /** Extra response headers. */
+    headers?: Record<string, string>;
+    /**
+     * Response body. A string is sent verbatim; any other value is
+     * `JSON.stringify`-ed. The `content-type` is inferred (JSON vs plain text)
+     * unless `contentType` is set.
+     */
+    body?: unknown;
+    /** Explicit `content-type` header. Overrides the inferred value. */
+    contentType?: string;
+}
+/** Geolocation override. */
+export interface GeolocationOverride {
+    latitude: number;
+    longitude: number;
+    /** Accuracy in meters. @default 0 (mirrors Puppeteer's `setGeolocation`). */
+    accuracy?: number;
+}
+/** Viewport / device-metrics override (owned solely by Glubean — see guardrail ①). */
+export interface ViewportOverride {
+    width: number;
+    height: number;
+    /** @default 1 */
+    deviceScaleFactor?: number;
+    /** @default false */
+    mobile?: boolean;
+}
+/**
+ * Environment emulation applied on the shared evidence session.
+ *
+ * Timezone, geolocation, and user agent are pure overrides with no Puppeteer
+ * conflict. Viewport is special: see guardrail ① — do **not** also call
+ * `page.setViewport()`, it will race with this override.
+ */
+export interface EmulationOptions {
+    /** IANA timezone id, e.g. `"America/New_York"`. */
+    timezone?: string;
+    /** Geolocation override. */
+    geolocation?: GeolocationOverride;
+    /** Viewport / device metrics. Glubean becomes the sole viewport owner. */
+    viewport?: ViewportOverride;
+    /** User-agent string override (`Emulation.setUserAgentOverride`). */
+    userAgent?: string;
+}
+/**
+ * A cookie as accepted by {@link EvidenceSession.attach}'s `storageState.cookies`
+ * and returned by {@link EvidenceSession.captureStorageState}. Mirrors the CDP
+ * `Network.CookieParam` / `Network.Cookie` shapes closely enough to round-trip:
+ * a captured cookie can be fed straight back in as an applied one.
+ */
+export interface StorageCookie {
+    name: string;
+    value: string;
+    /** Either `domain` or `url` must be resolvable for CDP to place the cookie. */
+    domain?: string;
+    path?: string;
+    url?: string;
+    /** Unix time in seconds, or `-1` for a session cookie. */
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+/**
+ * Cookies + localStorage for one page — a thin "login once, reuse the
+ * session" primitive (à la Playwright's `storageState`). Cookies apply via
+ * CDP `Network.setCookies`; localStorage applies via Puppeteer's own
+ * `page.evaluateOnNewDocument()` (see guardrail ③) so it is present before
+ * the page's own scripts run on every navigation of this page.
+ */
+export interface StorageState {
+    cookies?: StorageCookie[];
+    /** Key/value pairs seeded into `localStorage` on every new document. */
+    localStorage?: Record<string, string>;
+}
+/** Lifecycle state of a browser download (mirrors CDP `Browser.downloadProgress.state`). */
+export type DownloadState = "inProgress" | "completed" | "canceled";
+/**
+ * A browser download captured via CDP `Browser.downloadWillBegin` /
+ * `Browser.downloadProgress`.
+ */
+export interface DownloadEntry {
+    /** CDP-assigned globally-unique download id. */
+    guid: string;
+    /** URL the download was initiated from (may be `data:`/`blob:`). */
+    url: string;
+    /** Filename suggested by the server/anchor at download start. */
+    suggestedFilename: string;
+    /**
+     * Best-effort on-disk path: `${dir}/${suggestedFilename}`. Exact only when
+     * Chrome didn't have to de-duplicate a filename collision in `dir` — see
+     * the module doc's Downloads note.
+     */
+    path: string;
+}
+/** Options wiring the shared session's download capture. */
+export interface DownloadOptions {
+    /** Directory downloads are saved to. Must already exist — the caller creates it. */
+    dir: string;
+    /**
+     * Called on every state transition (`inProgress` fires once per progress
+     * tick — usually more than once per download; `completed`/`canceled` fire
+     * exactly once). Mainly for evidence emission; {@link EvidenceSession.waitForDownload}
+     * is the ergonomic way to correlate a triggering action with its result.
+     */
+    onDownload?: (entry: DownloadEntry, state: DownloadState) => void;
+}
+/** Options for {@link EvidenceSession.attach}. */
+export interface EvidenceSessionOptions {
+    /**
+     * Network-trace callback (`ctx.trace`). When omitted, the `Network` domain
+     * tracer is not attached.
+     */
+    trace?: TraceFn;
+    /** Network-trace filter configuration. Ignored when `trace` is omitted. */
+    network?: Pick<NetworkTracerOptions, "include" | "excludePaths" | "filter">;
+    /** Request-mock rules. When non-empty, the `Fetch` domain is enabled (guardrail ②). */
+    mocks?: MockRule[];
+    /** Environment emulation (timezone / geolocation / viewport / user agent). */
+    emulate?: EmulationOptions;
+    /**
+     * Cookies / localStorage to restore before the page's first script runs
+     * (`storageState.cookies` via `Network.setCookies`, `storageState.localStorage`
+     * via Puppeteer's `page.evaluateOnNewDocument()` — see guardrail ③).
+     * Capture the current state with {@link EvidenceSession.captureStorageState}.
+     */
+    storageState?: StorageState;
+    /**
+     * Screenshot capture policy and I/O delegate.
+     *
+     * When provided, {@link EvidenceSession.captureShot} becomes active and will
+     * call `screenshots.shoot` based on the configured mode and trigger.
+     * Omit (or set `mode: "off"`) to disable all automatic screenshot capture.
+     */
+    screenshots?: EvidenceScreenshotOptions;
+    /**
+     * Download capture (`Browser.setDownloadBehavior` + `downloadWillBegin`/
+     * `downloadProgress`). When provided, every download on this page is
+     * allowed (not blocked) and reported via `onDownload` / {@link EvidenceSession.waitForDownload}.
+     */
+    downloads?: DownloadOptions;
+}
+/** A single CDP call: `{ method, params }`. Kept pure for testing. */
+export interface CdpCall {
+    method: string;
+    params?: Record<string, unknown>;
+}
+/** @internal Does `rule` match the given request? */
+export declare function matchMock(rule: MockRule, req: {
+    url: string;
+    method: string;
+}): boolean;
+/** @internal Find the first matching mock rule, or `undefined`. */
+export declare function findMock(mocks: readonly MockRule[], req: {
+    url: string;
+    method: string;
+}): MockRule | undefined;
+/**
+ * @internal Build `Fetch.fulfillRequest` params from a rule.
+ *
+ * The body is always base64-encoded (as CDP requires). Content-type is inferred
+ * from the body kind unless `rule.contentType` is set. User headers win over the
+ * inferred content-type.
+ */
+export declare function buildFulfillParams(rule: MockRule, requestId: string): {
+    requestId: string;
+    responseCode: number;
+    responseHeaders: HeaderEntry[];
+    body: string;
+};
+/**
+ * @internal Build the ordered list of `Emulation.*` CDP calls.
+ *
+ * Timezone, geolocation, and user agent come first (order-independent among
+ * themselves); the viewport override is applied **last** (guardrail ①) so it
+ * is the final word on device metrics at setup time.
+ */
+export declare function buildEmulationCalls(emulate: EmulationOptions): CdpCall[];
+/**
+ * @internal Build `Network.setCookies` params from `storageState.cookies`.
+ * Returns `undefined` when there is nothing to set (caller skips the call).
+ */
+export declare function buildSetCookiesParams(cookies: StorageCookie[] | undefined): {
+    cookies: StorageCookie[];
+} | undefined;
+/**
+ * @internal Replace `page[method]` with a guard, returning a restore function.
+ *
+ * `shouldBlock` decides, per call arguments, whether to throw the guard error.
+ * Blocked calls throw synchronously; allowed calls fall through to the original
+ * method (or resolve to `undefined` if there was none). Used to enforce
+ * guardrails ① (viewport) and ② (Fetch interception).
+ */
+export declare function guardPageMethod(page: any, method: string, message: string, shouldBlock: (args: unknown[]) => boolean): () => void;
+/**
+ * A single self-opened CDP session that hosts every CDP-backed evidence
+ * capability for one page. Create with {@link EvidenceSession.attach}; release
+ * with {@link EvidenceSession.detach}.
+ */
+export declare class EvidenceSession {
+    private readonly _cdp;
+    private readonly _cleanups;
+    private _detached;
+    private _screenshotOpts;
+    private _screenshotSeq;
+    private _screenshotLog;
+    private _downloadsEnabled;
+    private _downloadDir;
+    private _onDownload;
+    /**
+     * Frame ids owned by THIS page's target. `Browser.setDownloadBehavior`'s
+     * events are browser-context-global — every session that turned events on
+     * receives every download in the context. We only record downloads whose
+     * originating `frameId` belongs to this page, so two instrumented pages
+     * sharing one Chrome never cross-observe each other's downloads.
+     */
+    private _ownedFrames;
+    /**
+     * True only once the initial `Page.getFrameTree` seeded {@link _ownedFrames}.
+     * The frame filter engages ONLY when this is set — otherwise we accept all
+     * download events (fallback mode). Without this flag, a later
+     * `Page.frameAttached` would grow `_ownedFrames` from empty to non-empty and
+     * silently flip fallback mode into a PARTIAL filter that drops the page's own
+     * top-frame downloads (codex R2 P2).
+     */
+    private _frameTreeSeeded;
+    private _pendingDownloads;
+    private _downloadWaiters;
+    private constructor();
+    /** The underlying CDP session, for advanced/raw use. */
+    get cdp(): CDPSession;
+    /**
+     * All screenshots captured into this evidence session, in order.
+     *
+     * Each entry carries `seq`, `ts`, `label`, `trigger`, and an artifact
+     * reference (`artifactId` or `path`). The list is empty when no screenshot
+     * has been captured yet or when `screenshots.mode` is `"off"`.
+     */
+    get screenshots(): readonly ScreenshotEntry[];
+    /**
+     * Capture a screenshot into the evidence stream, subject to the configured
+     * {@link ScreenshotMode} and the `trigger` argument.
+     *
+     * | mode          | "step" trigger | "failure" trigger | "manual" trigger |
+     * |---------------|----------------|-------------------|------------------|
+     * | "off"         | skip           | skip              | skip             |
+     * | "on-failure"  | skip           | capture           | capture          |
+     * | "every-step"  | capture        | capture           | capture          |
+     *
+     * Always best-effort: errors from the I/O delegate are silently swallowed
+     * so a broken page state never masks the real test error.
+     *
+     * Does nothing when no `screenshots` option was passed to {@link attach}.
+     */
+    captureShot(label: string, trigger: ScreenshotTrigger): Promise<void>;
+    /**
+     * Open one CDP session on `page` and wire up the requested capabilities:
+     * Network trace, Fetch mock (guardrail ②), Emulation (guardrail ① for
+     * viewport), and storage state (cookies + localStorage). Capabilities are
+     * only enabled when their config is present, so a page with no mocks never
+     * enables `Fetch` and leaves the user's own request interception untouched.
+     */
+    static attach(page: Page, options: EvidenceSessionOptions): Promise<EvidenceSession>;
+    private _installMocks;
+    private _applyStorageState;
+    /**
+     * @internal Wire `Browser.setDownloadBehavior` (`eventsEnabled: true`) plus
+     * the `downloadWillBegin` / `downloadProgress` listeners on this session.
+     * See the module doc's Downloads note for why `Browser.*` (not the
+     * deprecated `Page.*` pair) and why it works on an auxiliary session.
+     *
+     * `Browser.*` download events are browser-context-global, so we also enable
+     * the `Page` domain and track this target's frame ids, then only record
+     * downloads originating from a frame we own — two instrumented pages in one
+     * Chrome must not cross-observe each other's downloads.
+     */
+    private _enableDownloads;
+    /** @internal Best-effort onDownload callback — never let it wedge the waiter machine. */
+    private _notifyDownload;
+    /**
+     * Wait for the NEXT download (one that completes after this call) to finish,
+     * and resolve with its metadata. Register the wait *before* triggering the
+     * action that starts the download — `GlubeanPage.waitForDownload(action)` in
+     * `page.ts` does exactly this and is the ergonomic wrapper most callers
+     * should use instead of this lower-level method.
+     *
+     * Rejects if the next download is canceled, after `timeoutMs`, if `signal`
+     * aborts (e.g. the triggering action threw), or if the session has detached.
+     * Does **not** resolve from downloads that already completed before the call —
+     * each wait is scoped to a fresh, future download.
+     */
+    waitForDownload(timeoutMs: number, signal?: AbortSignal): Promise<DownloadEntry>;
+    /**
+     * Capture the current page's cookies + localStorage as a {@link StorageState}
+     * snapshot — the counterpart to {@link EvidenceSessionOptions.storageState}.
+     * Cookies are scoped to the page's current URL (`Network.getCookies`), not
+     * every cookie the browser holds, so unrelated tabs/origins never leak in.
+     *
+     * @example
+     * ```ts
+     * await page.goto("/login");
+     * // ... perform login ...
+     * const state = await page.getStorageState();
+     * // Reuse on a fresh page to skip the login flow:
+     * const chrome2 = browser({ launch: true, storageState: state });
+     * ```
+     */
+    captureStorageState(page: Page): Promise<StorageState>;
+    private _guardViewport;
+    /**
+     * Remove all listeners/overrides, restore guarded page methods, and detach
+     * the CDP session. Idempotent and best-effort — safe to call after the page
+     * has closed.
+     */
+    detach(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"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"}