@qartisan/playwright-loupe 0.1.0 → 0.1.2

package/dist/core/redact.d.ts

@@ -0,0 +1,101 @@
+import type { RedactMode } from '../config/types.js';
+/**
+ * Secret redaction, applied by the core before signatures and categories are
+ * computed and before anything is written. Three mechanisms (see "Secret
+ * redaction" in docs/config.md):
+ *
+ * - A, input steps: the value typed by `fill`, `type`, `pressSequentially`,
+ *   `keyboard.type` or `keyboard.insertText` is replaced when the target
+ *   (step subtitle, from Playwright 1.63) or the source line of the call has a
+ *   secret-looking name. The same value is then redacted in the attempt's
+ *   errors (Playwright repeats it in the call log: `fill("<value>")`).
+ * - C, HTTP headers and URL parameters: values of header lines with a
+ *   secret-looking name, as Playwright prints them in call logs
+ *   (`- cookie: <value>`), and of URL query or fragment parameters with a
+ *   secret-looking name (`?token=<value>`), wherever URLs appear.
+ * - B, environment values: the values of the variables listed in
+ *   `redact.env`, everywhere in the report except snippets and attachment paths.
+ *
+ * A and C share one list of secret-looking names. Attachment files (traces,
+ * screenshots, videos) are never altered.
+ */
+/** What replaces a secret. */
+export declare const REDACTED = "[redacted]";
+/** Values shorter than this are only redacted in quoted form (A), or not used at all (B): too many false matches. */
+export declare const MIN_SECRET_LENGTH = 6;
+/**
+ * Default secret-looking names, for A (locators, source lines) and C (header
+ * and URL parameter names). A string matches whole words, see `createNameMatcher`; a RegExp is
+ * tested as is.
+ */
+export declare const DEFAULT_SECRET_NAMES: ReadonlyArray<string | RegExp>;
+/**
+ * Lowercase words of a name or a line: split on anything but ASCII letters and
+ * digits, and on camelCase boundaries (`passwordInput` → password, input;
+ * `APIKey` → api, key).
+ */
+export declare function words(text: string): string[];
+/**
+ * Tells whether a text has a secret-looking name. A string pattern matches
+ * consecutive whole words, case-insensitively, each word allowing a trailing
+ * "s": `auth` matches `x-auth-token` and `authToken` but not `Author`; `pin`
+ * matches `PIN code` but not `spinner`; `api key` matches `x-api-key`, `apiKey`
+ * and `API_KEY`. A RegExp is tested on the text as is.
+ */
+export declare function createNameMatcher(patterns: ReadonlyArray<string | RegExp>): (text: string) => boolean;
+export interface InputStep {
+    /** The title with the value replaced by `[redacted]`. */
+    redacted: string;
+    value: string;
+    /** Target written in the title (Playwright 1.52), null otherwise. */
+    target: string | null;
+}
+export declare function parseInputStep(title: string): InputStep | null;
+/** The part of a Playwright step redaction reads. */
+export interface StepLike {
+    title: string;
+    category: string;
+    location?: {
+        file: string;
+        line: number;
+    } | undefined;
+    steps: readonly StepLike[];
+}
+export interface RedactOptions {
+    /** `extend`: `patterns` add to the default names. `replace`: only `patterns`; `[]` turns A and C off. */
+    mode: RedactMode;
+    patterns: ReadonlyArray<string | RegExp>;
+    /** Values of the `redact.env` variables, already filtered by `secretValues`. */
+    values: readonly string[];
+    /** Reads a source file; null when it cannot be read. Default: from disk. */
+    readSource?: (file: string) => string | null;
+}
+export declare const DEFAULT_REDACT: RedactOptions;
+/** Redaction for the steps and errors of one attempt. */
+export interface AttemptRedactor {
+    /** A step title: input value (A), values typed in this attempt, URL parameters (C), env values (B). */
+    title(step: StepLike): string;
+    /** An error message or stack, a subtitle: values typed in this attempt, header values and URL parameters (C), env values (B). */
+    text(text: string): string;
+}
+export interface Redactor {
+    /** Finds the secret input steps of an attempt (A) and returns the redaction for its steps and errors. */
+    attempt(steps: readonly StepLike[]): AttemptRedactor;
+    /** Text outside any attempt (run errors): header values and URL parameters (C), env values (B). */
+    text(text: string): string;
+    /** Env values only (B). */
+    values(text: string): string;
+    /** URL parameters (C) and env values (B), for every other string of the report: outputs, annotations, test titles... */
+    strings(text: string): string;
+    /** False when `strings` never changes anything (no names and no env values): the report needs no rewriting pass. */
+    rewritesStrings: boolean;
+}
+export declare function createRedactor(options?: RedactOptions): Redactor;
+/**
+ * Values of the `redact.env` variables. A variable that is unset or empty, or
+ * whose value is shorter than MIN_SECRET_LENGTH, is left out with a warning
+ * that names the variable, never its value.
+ */
+export declare function secretValues(names: readonly string[], env: Readonly<Record<string, string | undefined>>, warn: (message: string) => void): string[];
+/** Applies `replace` to every string of a JSON value, except under KEPT_KEYS. Returns a copy. */
+export declare function mapReportStrings<T>(value: T, replace: (text: string) => string): T;

package/dist/core/redact.js

@@ -0,0 +1,254 @@
+import { readFileSync } from 'node:fs';
+/**
+ * Secret redaction, applied by the core before signatures and categories are
+ * computed and before anything is written. Three mechanisms (see "Secret
+ * redaction" in docs/config.md):
+ *
+ * - A, input steps: the value typed by `fill`, `type`, `pressSequentially`,
+ *   `keyboard.type` or `keyboard.insertText` is replaced when the target
+ *   (step subtitle, from Playwright 1.63) or the source line of the call has a
+ *   secret-looking name. The same value is then redacted in the attempt's
+ *   errors (Playwright repeats it in the call log: `fill("<value>")`).
+ * - C, HTTP headers and URL parameters: values of header lines with a
+ *   secret-looking name, as Playwright prints them in call logs
+ *   (`- cookie: <value>`), and of URL query or fragment parameters with a
+ *   secret-looking name (`?token=<value>`), wherever URLs appear.
+ * - B, environment values: the values of the variables listed in
+ *   `redact.env`, everywhere in the report except snippets and attachment paths.
+ *
+ * A and C share one list of secret-looking names. Attachment files (traces,
+ * screenshots, videos) are never altered.
+ */
+/** What replaces a secret. */
+export const REDACTED = '[redacted]';
+/** Values shorter than this are only redacted in quoted form (A), or not used at all (B): too many false matches. */
+export const MIN_SECRET_LENGTH = 6;
+/**
+ * Default secret-looking names, for A (locators, source lines) and C (header
+ * and URL parameter names). A string matches whole words, see `createNameMatcher`; a RegExp is
+ * tested as is.
+ */
+export const DEFAULT_SECRET_NAMES = [
+    // As a substring: newPassword, passwordConfirm, Passphrase, passwd.
+    /pass(?:word|wd|phrase)/i,
+    'pwd',
+    'passcode',
+    'secret',
+    'token',
+    'otp',
+    'totp',
+    'pin',
+    'api key',
+    'apikey',
+    'private key',
+    'credential',
+    'cookie',
+    'session',
+    'authorization',
+    'auth',
+    'bearer',
+    'jwt',
+    'csrf',
+    'xsrf',
+];
+/**
+ * Lowercase words of a name or a line: split on anything but ASCII letters and
+ * digits, and on camelCase boundaries (`passwordInput` → password, input;
+ * `APIKey` → api, key).
+ */
+export function words(text) {
+    return text
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((word) => word !== '');
+}
+/**
+ * Tells whether a text has a secret-looking name. A string pattern matches
+ * consecutive whole words, case-insensitively, each word allowing a trailing
+ * "s": `auth` matches `x-auth-token` and `authToken` but not `Author`; `pin`
+ * matches `PIN code` but not `spinner`; `api key` matches `x-api-key`, `apiKey`
+ * and `API_KEY`. A RegExp is tested on the text as is.
+ */
+export function createNameMatcher(patterns) {
+    const regexps = patterns.filter((pattern) => pattern instanceof RegExp);
+    const sequences = patterns.filter((pattern) => typeof pattern === 'string').map(words).filter((list) => list.length > 0);
+    if (regexps.length === 0 && sequences.length === 0)
+        return () => false;
+    return (text) => {
+        if (regexps.some((pattern) => pattern.test(text)))
+            return true;
+        if (sequences.length === 0)
+            return false;
+        const textWords = words(text);
+        return sequences.some((sequence) => textWords.some((_, start) => sequence.every((word, offset) => {
+            const candidate = textWords[start + offset];
+            return candidate === word || candidate === `${word}s`;
+        })));
+    };
+}
+/**
+ * Value input steps, as Playwright titles them:
+ * - 1.53+: `Fill "<value>"`, `Type "<value>"` (`type`, `pressSequentially`,
+ *   `keyboard.type`), `Insert "<value>"` (`keyboard.insertText`). Quotes in
+ *   the value are not escaped, so the value runs to the last quote; newlines
+ *   are written `\n`.
+ * - 1.52: `locator.fill(<value>)`, `locator.getByLabel('Password').type(<value>)`,
+ *   `locator.getByLabel('Password').pressSequentially(<value>)`,
+ *   `keyboard.type(<value>)`, `keyboard.insertText(<value>)`. The target is
+ *   part of the title for `type` and `pressSequentially` only.
+ */
+const INPUT_TITLE = /^(Fill|Type|Insert) "([\s\S]*)"$/;
+const LEGACY_INPUT_TITLE = /^((?:locator|page|frame|keyboard|elementHandle)\b.*?)\.(fill|type|pressSequentially|insertText)\(([\s\S]*)\)$/;
+export function parseInputStep(title) {
+    const current = INPUT_TITLE.exec(title);
+    if (current)
+        return { redacted: `${current[1]} "${REDACTED}"`, value: current[2], target: null };
+    const legacy = LEGACY_INPUT_TITLE.exec(title);
+    if (legacy) {
+        const [, target, action, value] = legacy;
+        return { redacted: `${target}.${action}(${REDACTED})`, value, target };
+    }
+    return null;
+}
+/**
+ * A header line as Playwright prints it in a call log (`  - cookie: <value>`),
+ * or a bare `Name: value` line. Header names are tokens: no spaces.
+ */
+const HEADER_LINE = /^([ \t]*(?:-[ \t]+)?)([A-Za-z0-9!#$%&'*+.^_`|~-]+):[ \t]+\S.*$/gm;
+/**
+ * A URL query or fragment parameter: `?token=<value>`, `&access_token=<value>`,
+ * `#access_token=<value>` (OAuth implicit flow). Only after `?`, `&` or `#`, so
+ * a bare `token=abc` in prose is left alone. The value stops at the next
+ * parameter, the fragment, whitespace, a quote, a bracket or a parenthesis.
+ */
+const URL_PARAM = /([?&#])([A-Za-z0-9_.~%-]+)=(\[redacted\]|[^&#\s"'`<>()[\]]+)/g;
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Replaces every occurrence of `values` with `[redacted]`, longest first. An
+ * existing `[redacted]` is left alone, so applying it twice changes nothing
+ * even when a value is part of the word "redacted".
+ */
+function valueReplacer(values) {
+    const unique = [...new Set(values)].filter((value) => value !== '').sort((a, b) => b.length - a.length);
+    if (unique.length === 0)
+        return (text) => text;
+    const pattern = new RegExp([escapeRegExp(REDACTED), ...unique.map(escapeRegExp)].join('|'), 'g');
+    return (text) => text.replace(pattern, REDACTED);
+}
+export const DEFAULT_REDACT = { mode: 'extend', patterns: [], values: [] };
+function readFromDisk(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function createRedactor(options = DEFAULT_REDACT) {
+    const namePatterns = options.mode === 'extend' ? [...DEFAULT_SECRET_NAMES, ...options.patterns] : options.patterns;
+    const names = createNameMatcher(namePatterns);
+    const envValues = valueReplacer(options.values);
+    const readSource = options.readSource ?? readFromDisk;
+    const sources = new Map();
+    /** The source line of a step, from disk; null when the file cannot be read (merge-reports without the code). */
+    const sourceLine = (location) => {
+        if (!location)
+            return null;
+        if (!sources.has(location.file))
+            sources.set(location.file, readSource(location.file)?.split(/\r?\n/) ?? null);
+        return sources.get(location.file)?.[location.line - 1] ?? null;
+    };
+    const headers = (text) => text.replace(HEADER_LINE, (line, indent, name) => (names(name) ? `${indent}${name}: ${REDACTED}` : line));
+    const urlParams = (text) => text.replace(URL_PARAM, (param, separator, name) => (names(name) ? `${separator}${name}=${REDACTED}` : param));
+    /** A: the target (subtitle from 1.63, title on 1.52), else the source line of the call, has a secret-looking name. */
+    const isSecret = (step, input) => {
+        const subtitle = step.subtitle;
+        if (typeof subtitle === 'string' && names(subtitle))
+            return true;
+        if (input.target !== null && names(input.target))
+            return true;
+        const line = sourceLine(step.location);
+        return line !== null && names(line);
+    };
+    return {
+        rewritesStrings: namePatterns.length > 0 || options.values.length > 0,
+        text: (text) => envValues(urlParams(headers(text))),
+        values: envValues,
+        strings: (text) => envValues(urlParams(text)),
+        attempt(steps) {
+            const titles = new Map();
+            const typed = new Set();
+            const visit = (list) => {
+                for (const step of list) {
+                    const input = step.category === 'pw:api' ? parseInputStep(step.title) : null;
+                    if (input && isSecret(step, input)) {
+                        titles.set(step, input.redacted);
+                        typed.add(input.value);
+                        // Titles from 1.53 write newlines as `\n`; call logs keep the real ones.
+                        typed.add(input.value.replaceAll('\\n', '\n'));
+                    }
+                    visit(step.steps);
+                }
+            };
+            visit(steps);
+            // A short value (a PIN) would also match line numbers and other text: only its quoted form is redacted.
+            const long = [...typed].filter((value) => value.length >= MIN_SECRET_LENGTH);
+            const short = [...typed].filter((value) => value !== '' && value.length < MIN_SECRET_LENGTH).map((value) => `"${value}"`);
+            const replaceLong = valueReplacer(long);
+            const shortPattern = short.length > 0 ? new RegExp(short.map(escapeRegExp).join('|'), 'g') : null;
+            const typedValues = (text) => {
+                const replaced = replaceLong(text);
+                return shortPattern ? replaced.replace(shortPattern, `"${REDACTED}"`) : replaced;
+            };
+            return {
+                title: (step) => envValues(urlParams(titles.get(step) ?? typedValues(step.title))),
+                text: (text) => envValues(urlParams(headers(typedValues(text)))),
+            };
+        },
+    };
+}
+/**
+ * Values of the `redact.env` variables. A variable that is unset or empty, or
+ * whose value is shorter than MIN_SECRET_LENGTH, is left out with a warning
+ * that names the variable, never its value.
+ */
+export function secretValues(names, env, warn) {
+    const values = [];
+    for (const name of names) {
+        const value = env[name];
+        if (value === undefined || value === '') {
+            warn(`Loupe: redact.env: ${name} is not set or empty; nothing to redact for it.`);
+        }
+        else if (value.length < MIN_SECRET_LENGTH) {
+            warn(`Loupe: redact.env: the value of ${name} is shorter than ${MIN_SECRET_LENGTH} characters and is not redacted (too many false matches).`);
+        }
+        else {
+            values.push(value);
+        }
+    }
+    return values;
+}
+/**
+ * Keys whose strings B never rewrites: identifiers and signatures (hex that a
+ * short value could match), snippets (source code, already in the
+ * repository) and attachment paths (the files keep their names).
+ */
+const KEPT_KEYS = new Set(['id', 'signature', 'errorSignature', 'snippet', 'path']);
+/** Applies `replace` to every string of a JSON value, except under KEPT_KEYS. Returns a copy. */
+export function mapReportStrings(value, replace) {
+    const visit = (node) => {
+        if (typeof node === 'string')
+            return replace(node);
+        if (Array.isArray(node))
+            return node.map(visit);
+        if (node !== null && typeof node === 'object') {
+            return Object.fromEntries(Object.entries(node).map(([key, child]) => [key, KEPT_KEYS.has(key) ? child : visit(child)]));
+        }
+        return node;
+    };
+    return visit(value);
+}

package/dist/core/reporter.d.ts

@@ -11,6 +11,8 @@ interface ErrorWorkerInfo {
 }
 export declare class LoupeReporter implements Reporter {
     private readonly loupeConfig;
+    /** Values of the `redact.env` variables, read once at startup. */
+    private readonly secretValues;
     private readonly scopeOverride;
     private readonly runErrors;
     private config;

package/dist/core/reporter.js

@@ -4,12 +4,15 @@ import path from 'node:path';
 import { loadConfig } from '../config/index.js';
 import { buildReport } from './build.js';
 import { injectData, injectSettings } from './inject.js';
+import { secretValues } from './redact.js';
 import { SCOPE_ENV, parseScopeOverride } from './scope.js';
 import { generatorVersion } from './version.js';
 /** Built renderer template, shipped next to the compiled core (`dist/renderer/index.html`). */
 const TEMPLATE_URL = new URL('../renderer/index.html', import.meta.url);
 export class LoupeReporter {
     loupeConfig;
+    /** Values of the `redact.env` variables, read once at startup. */
+    secretValues;
     scopeOverride;
     runErrors = [];
     config;
@@ -20,6 +23,8 @@ export class LoupeReporter {
         // run with its message, which no later reporter hook can do.
         this.scopeOverride = parseScopeOverride(process.env[SCOPE_ENV]);
         this.loupeConfig = loadConfig(options);
+        // After the config is loaded; warnings name a variable, never its value.
+        this.secretValues = secretValues(this.loupeConfig.redact.env, process.env, (message) => console.warn(message));
     }
     printsToStdio() {
         return false;
@@ -47,6 +52,7 @@ export class LoupeReporter {
             categories: this.loupeConfig.categories,
             dimensions: this.loupeConfig.dimensions,
             runErrors: this.runErrors,
+            redact: { mode: this.loupeConfig.redact.mode, patterns: this.loupeConfig.redact.patterns, values: this.secretValues },
         });
         const settings = {
             title: this.loupeConfig.title,

package/dist/core/signature.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { STATUS_CODE, httpStatusSource } from './http.js';
 // Same pattern as the `ansi-regex` package (CSI and OSC sequences).
 const ANSI_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~]))/g;
 export function stripAnsi(text) {
@@ -78,8 +79,14 @@ const REPLACEMENTS = [
     [/\b\d+(?:\.\d+)?\s?(?:ms|milliseconds?|s|secs?|seconds?|m|mins?|minutes?|h|hours?)\b/gi, '<duration>'],
     // 8+ hex chars with at least one letter (pure digit runs fall through to <n>).
     [/(?<![0-9A-Za-z])(?=[0-9a-f]*[a-f])[0-9a-f]{8,}(?![0-9A-Za-z])/gi, '<hex>'],
-    [/\d+(?:\.\d+)?/g, '<n>'],
 ];
+/**
+ * Last replacement: remaining numbers become `<n>`, except HTTP status codes
+ * (100–599) in an HTTP context, kept with their context so `error 401` and
+ * `error 500` stay apart. Same context as the "Rate limited" and "Server
+ * error" categories (src/core/http.ts).
+ */
+const STATUS_OR_NUMBER = new RegExp(`(${httpStatusSource(STATUS_CODE)})|\\d+(?:\\.\\d+)?`, 'gi');
 /**
  * Normalizes an error message so the same failure produces the same text
  * across tests, retries and runs: ANSI codes and the call log are removed,
@@ -97,6 +104,7 @@ export function normalizeErrorMessage(message, options = {}) {
     for (const [pattern, placeholder] of REPLACEMENTS) {
         text = text.replace(pattern, placeholder);
     }
+    text = text.replace(STATUS_OR_NUMBER, (_match, status) => status ?? '<n>');
     return text.replace(/\s+/g, ' ').trim();
 }
 /** First 12 hex chars of sha256 of the normalized message. Independent of the test. */