@nx/playwright 23.2.0-beta.10 → 23.2.0-beta.12

package/dist/src/executors/wait-for-webserver/proxy.d.ts

@@ -0,0 +1,28 @@
+export type ProxyResolution = {
+    kind: 'direct';
+} | {
+    kind: 'proxy';
+    proxy: URL;
+} | {
+    kind: 'unusable';
+    variable: string;
+    value: string;
+    reason: string;
+};
+export declare function resolveProxyForUrl(url: URL, env?: NodeJS.ProcessEnv, npmConfigProxy?: boolean): ProxyResolution;
+/**
+ * The proxy `env` configures for `protocol`, before any `no_proxy` exclusion:
+ * `<protocol>_proxy`, falling back to `all_proxy`, normalized as the probe
+ * would use it (a value with no scheme takes the target's protocol). With
+ * `npmConfigProxy`, `npm_config_<protocol>_proxy` comes first and
+ * `npm_config_proxy` sits between the two.
+ */
+export declare function resolveProxyForProtocol(protocol: string, env?: NodeJS.ProcessEnv, npmConfigProxy?: boolean): ProxyResolution;
+/**
+ * The `no_proxy` entries `env` configures (`npm_config_no_proxy` first with
+ * `npmConfigProxy`), lowercased and with the empty entries a separator run
+ * leaves dropped. Each entry excludes hosts on its own, so their order carries
+ * no meaning.
+ */
+export declare function noProxyEntries(env: NodeJS.ProcessEnv, npmConfigProxy?: boolean): string[];
+export declare function withoutCredentials(value: string): string;

package/dist/src/executors/wait-for-webserver/proxy.js

@@ -0,0 +1,158 @@
+"use strict";
+// Playwright routes its readiness poll through a proxy configured in the
+// environment, so a gate that always connected directly would be answering a
+// different question than the check it exists to satisfy. Selection mirrors the
+// `proxy-from-env` copy playwright-core 1.60.0 bundles (`getProxyForUrl`)
+// together with its own `normalizeProxyURL`; with `npmConfigProxy` it mirrors
+// the copy bundled before 1.59.0, which read npm's `npm_config_*` proxy
+// variables ahead of the standard ones. The transport is left to
+// `https-proxy-agent`, the agent Playwright itself hands to `https.request`
+// for a proxied https target.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProxyForUrl = resolveProxyForUrl;
+exports.resolveProxyForProtocol = resolveProxyForProtocol;
+exports.noProxyEntries = noProxyEntries;
+exports.withoutCredentials = withoutCredentials;
+const DEFAULT_PORTS = {
+    ftp: 21,
+    gopher: 70,
+    http: 80,
+    https: 443,
+    ws: 80,
+    wss: 443,
+};
+function resolveProxyForUrl(url, env = process.env, npmConfigProxy = false) {
+    const protocol = url.protocol.split(':')[0];
+    // Matched on the host with any port stripped, which keeps the brackets on an
+    // IPv6 literal.
+    const hostname = url.host.replace(/:\d*$/, '');
+    if (!hostname || !protocol) {
+        return { kind: 'direct' };
+    }
+    const port = parseInt(url.port) || DEFAULT_PORTS[protocol] || 0;
+    if (!shouldProxy(hostname, port, env, npmConfigProxy)) {
+        return { kind: 'direct' };
+    }
+    return resolveProxyForProtocol(protocol, env, npmConfigProxy);
+}
+/**
+ * The proxy `env` configures for `protocol`, before any `no_proxy` exclusion:
+ * `<protocol>_proxy`, falling back to `all_proxy`, normalized as the probe
+ * would use it (a value with no scheme takes the target's protocol). With
+ * `npmConfigProxy`, `npm_config_<protocol>_proxy` comes first and
+ * `npm_config_proxy` sits between the two.
+ */
+function resolveProxyForProtocol(protocol, env = process.env, npmConfigProxy = false) {
+    const source = readEnv(npmConfigProxy
+        ? [
+            `npm_config_${protocol}_proxy`,
+            `${protocol}_proxy`,
+            'npm_config_proxy',
+            'all_proxy',
+        ]
+        : [`${protocol}_proxy`, 'all_proxy'], env);
+    if (!source.value) {
+        return { kind: 'direct' };
+    }
+    // A value with no scheme takes the target's protocol, which is where this
+    // differs from `normalizeProxyURL` alone: that only defaults to http.
+    const scheme = source.value.includes('://') ? '' : `${protocol}://`;
+    const normalized = `${scheme}${source.value}`.trim();
+    // Playwright's own probe errors out on a proxy URL it cannot use instead of
+    // falling back to a direct request, so the gate must not clear here. Each
+    // cause is named, because the value alone often does not show it: redacting
+    // the credentials takes the offending character with them.
+    const unusable = (reason) => ({
+        kind: 'unusable',
+        variable: source.variable,
+        value: withoutCredentials(source.value),
+        reason,
+    });
+    let proxy;
+    try {
+        proxy = new URL(/^\w+:\/\//.test(normalized) ? normalized : `http://${normalized}`);
+    }
+    catch {
+        return unusable('is not a valid url');
+    }
+    // Anything else parses but cannot be dialled: an http target throws out of
+    // `http.request`, and an https one gets `CONNECT` spoken at a port that is
+    // not answering HTTP, which surfaces much later as a refused server.
+    if (proxy.protocol !== 'http:' && proxy.protocol !== 'https:') {
+        return unusable('is not an http or https url');
+    }
+    // Credentials are percent-decoded when the request is built, far from the
+    // configuration that produced them, so a value that cannot be decoded is
+    // rejected here where the failure can still name where it came from.
+    try {
+        decodeURIComponent(proxy.username);
+        decodeURIComponent(proxy.password);
+    }
+    catch {
+        return unusable('has credentials that are not valid percent-encoding');
+    }
+    return { kind: 'proxy', proxy };
+}
+// `no_proxy` governs where traffic may go. Sending the target URL to an
+// excluded proxy would disclose it even when the direct probe is the one that
+// succeeds.
+function shouldProxy(hostname, port, env, npmConfigProxy) {
+    const noProxy = readNoProxy(env, npmConfigProxy).toLowerCase();
+    if (!noProxy) {
+        return true;
+    }
+    if (noProxy === '*') {
+        return false;
+    }
+    return noProxyEntries(env, npmConfigProxy).every((entry) => {
+        const withPort = entry.match(/^(.+):(\d+)$/);
+        let host = withPort ? withPort[1] : entry;
+        const entryPort = withPort ? parseInt(withPort[2]) : 0;
+        if (entryPort && entryPort !== port) {
+            return true;
+        }
+        if (!/^[.*]/.test(host)) {
+            return hostname !== host;
+        }
+        if (host.charAt(0) === '*') {
+            host = host.slice(1);
+        }
+        return !hostname.endsWith(host);
+    });
+}
+/**
+ * The `no_proxy` entries `env` configures (`npm_config_no_proxy` first with
+ * `npmConfigProxy`), lowercased and with the empty entries a separator run
+ * leaves dropped. Each entry excludes hosts on its own, so their order carries
+ * no meaning.
+ */
+function noProxyEntries(env, npmConfigProxy = false) {
+    return readNoProxy(env, npmConfigProxy)
+        .toLowerCase()
+        .split(/[,\s]/)
+        .filter(Boolean);
+}
+function readNoProxy(env, npmConfigProxy) {
+    return readEnv(npmConfigProxy ? ['npm_config_no_proxy', 'no_proxy'] : ['no_proxy'], env).value;
+}
+// The executor runs in its own process, so a proxy variable the Playwright
+// config sets while loading (through `dotenv`, say) reaches Playwright's probe
+// and not this one. The name that was read is reported alongside the value so a
+// bad one can be found among the variables this looks at. The first name with
+// a value wins, in the lowercase spelling before the uppercase one.
+function readEnv(names, env) {
+    for (const name of names) {
+        for (const variable of [name.toLowerCase(), name.toUpperCase()]) {
+            if (env[variable]) {
+                return { variable, value: env[variable] };
+            }
+        }
+    }
+    return { variable: names[names.length - 1].toUpperCase(), value: '' };
+}
+// A rejected value is echoed back so it can be recognized in the environment,
+// and it reaches the task log, so the credentials come off first.
+function withoutCredentials(value) {
+    const at = value.lastIndexOf('@');
+    return at === -1 ? value : `***@${value.slice(at + 1)}`;
+}

package/dist/src/executors/wait-for-webserver/schema.d.ts

@@ -0,0 +1,9 @@
+export type Schema = {
+  servers: Array<{
+    port?: number;
+    url?: string;
+    ignoreHTTPSErrors?: boolean;
+    timeout?: number;
+  }>;
+  timeout?: number;
+};

package/dist/src/executors/wait-for-webserver/schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Schema for Playwright Wait For Web Server Executor",
+  "description": "Waits for the E2E web server(s) to be ready.",
+  "type": "object",
+  "properties": {
+    "servers": {
+      "type": "array",
+      "description": "The web servers to wait for.",
+      "items": {
+        "type": "object",
+        "properties": {
+          "port": {
+            "type": "number",
+            "description": "The port to wait for TCP connections on.",
+            "minimum": 1,
+            "maximum": 65535,
+            "multipleOf": 1
+          },
+          "url": {
+            "type": "string",
+            "description": "The URL to poll. Redirects are followed and the server is ready once the final response has a status from 200 to 403."
+          },
+          "ignoreHTTPSErrors": {
+            "type": "boolean",
+            "description": "Whether to ignore HTTPS errors (e.g. a self-signed certificate) when polling the URL.",
+            "default": false
+          },
+          "timeout": {
+            "type": "number",
+            "description": "The maximum time to wait for this server in milliseconds. A value of 0 means unset, as it does for Playwright's webServer.timeout. Defaults to 60000.",
+            "default": 60000
+          }
+        }
+      }
+    },
+    "timeout": {
+      "type": "number",
+      "description": "The maximum time to wait in milliseconds before failing. Overrides the timeout configured on every server. A value of 0 means unset, as it does for Playwright's webServer.timeout."
+    }
+  },
+  "required": ["servers"]
+}

package/dist/src/executors/wait-for-webserver/wait-for-webserver.impl.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function waitForWebserverExecutor(options: Schema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export default waitForWebserverExecutor;

package/dist/src/executors/wait-for-webserver/wait-for-webserver.impl.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForWebserverExecutor = waitForWebserverExecutor;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const http = tslib_1.__importStar(require("node:http"));
+const https = tslib_1.__importStar(require("node:https"));
+const node_net_1 = require("node:net");
+const node_path_1 = require("node:path");
+const installed_playwright_1 = require("../../utils/installed-playwright");
+const npm_config_proxy_1 = require("../../utils/npm-config-proxy");
+const proxied_tls_verification_1 = require("../../utils/proxied-tls-verification");
+const proxy_1 = require("./proxy");
+const DEFAULT_TIMEOUT = 60_000;
+// Retry cadence mirrors Playwright's web server readiness loop: a short ramp
+// up front, then a steady interval.
+const RETRY_SCHEDULE = [100, 250, 500];
+const FALLBACK_RETRY_DELAY = 1_000;
+// A probe the deadline cut short before it could learn anything observed
+// nothing, so it must not replace what the previous probe saw.
+const NO_OBSERVATION = 'the deadline passed before the server responded';
+async function waitForWebserverExecutor(options, context) {
+    const servers = options.servers ?? [];
+    if (servers.length === 0) {
+        devkit_1.logger.error('@nx/playwright:wait-for-webserver requires at least one server to wait for.');
+        return { success: false };
+    }
+    const playwright = (0, installed_playwright_1.installedPlaywrightVersion)(playwrightRequirePaths(context));
+    const skipProxiedTls = (0, proxied_tls_verification_1.installedPlaywrightSkipsProxiedTls)(playwright);
+    const npmConfigProxy = (0, npm_config_proxy_1.installedPlaywrightReadsNpmConfigProxy)(playwright);
+    const problem = servers
+        .map((server) => findServerProblem(server, npmConfigProxy))
+        .find(Boolean);
+    if (problem) {
+        devkit_1.logger.error(`@nx/playwright:wait-for-webserver ${problem}`);
+        return { success: false };
+    }
+    try {
+        await Promise.all(servers.map((server) => 
+        // A zero timeout means "unset" rather than "give up immediately", which
+        // is how Playwright reads it (`this._options.timeout || 60 * 1e3`).
+        waitForServer(server, options.timeout || server.timeout || DEFAULT_TIMEOUT, skipProxiedTls, npmConfigProxy)));
+        return { success: true };
+    }
+    catch (e) {
+        devkit_1.logger.error(`@nx/playwright:wait-for-webserver ${e instanceof Error ? e.message : String(e)}`);
+        return { success: false };
+    }
+}
+exports.default = waitForWebserverExecutor;
+// A malformed URL, an out-of-range port and a proxy that cannot be used are all
+// inputs that can never become valid, so they are rejected up front instead of
+// being retried until the timeout and reported as a slow server. An unusable
+// port is also the only input that makes `connect` throw synchronously, which
+// no probe could turn into a failure.
+function findServerProblem(server, npmConfigProxy) {
+    if (server.port == null && !server.url) {
+        return 'requires each server to define a "port" or a "url".';
+    }
+    if (server.port != null && !isValidPort(server.port)) {
+        return `received an invalid "port": ${server.port}.`;
+    }
+    if (server.url) {
+        let url;
+        try {
+            url = new URL(server.url);
+        }
+        catch {
+            return `received an invalid "url": ${(0, proxy_1.withoutCredentials)(server.url)}.`;
+        }
+        // Only the address the wait starts from is checked here. A redirect can
+        // cross to a protocol with its own proxy variable, which the probe reports
+        // when it gets there.
+        const resolution = (0, proxy_1.resolveProxyForUrl)(url, process.env, npmConfigProxy);
+        if (resolution.kind === 'unusable') {
+            return `${unusableProxyProblem(resolution)}.`;
+        }
+    }
+}
+// Left unpunctuated because a probe failure is also quoted mid-sentence when
+// the wait times out.
+function unusableProxyProblem(resolution) {
+    return `cannot use the proxy configured in ${resolution.variable}: ${resolution.value} ${resolution.reason}`;
+}
+// 0 is not a connectable port, so it is rejected rather than probed.
+function isValidPort(port) {
+    return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+// The directories the task's Playwright install resolves from: the project
+// root, where `playwright test` runs, then the workspace root.
+function playwrightRequirePaths(context) {
+    if (context.root == null) {
+        return [];
+    }
+    const projectRoot = context.projectName != null
+        ? context.projectsConfigurations?.projects?.[context.projectName]?.root
+        : undefined;
+    return projectRoot != null
+        ? [(0, node_path_1.join)(context.root, projectRoot), context.root]
+        : [context.root];
+}
+async function waitForServer(server, timeout, skipProxiedTls, npmConfigProxy) {
+    // Named the way it is probed: a port wins over a url when both are set.
+    const label = server.port != null ? `port ${server.port}` : redactedHref(server.url);
+    const deadline = Date.now() + timeout;
+    const schedule = [...RETRY_SCHEDULE];
+    let lastObserved;
+    while (true) {
+        const failure = await probeServer(server, deadline, skipProxiedTls, npmConfigProxy);
+        if (failure === null) {
+            return;
+        }
+        if (failure !== NO_OBSERVATION) {
+            lastObserved = failure;
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out after ${timeout}ms waiting for the E2E web server at ${label} to be ready. Last observation: ${lastObserved ?? failure}. If the server now listens at a different address, run "nx reset" so the gate is re-inferred from the Playwright config. If a configuration-scoped env file (".env.<target>.<configuration>") sets the address, the gate is inferred without it; set "waitForWebServer" to false on @nx/playwright/plugin instead.`);
+        }
+        const delay = schedule.shift() ?? FALLBACK_RETRY_DELAY;
+        await sleep(Math.min(delay, Math.max(0, deadline - Date.now())));
+    }
+}
+// Probe the way Playwright does: connect to the port on both loopback
+// addresses, or poll the URL for a status from 200 to 403, through whatever
+// proxy the environment configures for it. A port is always probed directly,
+// because Playwright checks one with a raw socket too.
+function probeServer(server, deadline, skipProxiedTls, npmConfigProxy) {
+    return server.port != null
+        ? probePort(server.port, deadline)
+        : probeUrl(server.url, server.ignoreHTTPSErrors ?? false, deadline, skipProxiedTls, npmConfigProxy);
+}
+function probePort(port, deadline) {
+    // Silence for the retry-delay window is the probe's observation; clamp it so
+    // a connect that hangs (e.g. a firewalled port) cannot run past the
+    // readiness deadline. Floored at 1ms because setTimeout(0) disables the
+    // socket's idle timeout instead.
+    const timeout = Math.max(1, Math.min(FALLBACK_RETRY_DELAY, deadline - Date.now()));
+    const canConnect = (host) => new Promise((resolve) => {
+        const address = host.includes(':')
+            ? `[${host}]:${port}`
+            : `${host}:${port}`;
+        const socket = (0, node_net_1.connect)({ port, host });
+        const settle = (failure) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(failure);
+        };
+        socket.setTimeout(timeout);
+        socket.once('connect', () => settle(null));
+        socket.once('timeout', () => settle(`${address} timed out`));
+        socket.once('error', (error) => settle(`${address} ${error.code ?? error.message}`));
+    });
+    return new Promise((resolve) => {
+        const failures = [];
+        let pending = 2;
+        const onResult = (failure) => {
+            if (failure === null) {
+                resolve(null);
+            }
+            else {
+                failures.push(failure);
+                if (--pending === 0) {
+                    resolve(failures.join('; '));
+                }
+            }
+        };
+        void canConnect('127.0.0.1').then(onResult);
+        void canConnect('::1').then(onResult);
+    });
+}
+async function probeUrl(url, ignoreHTTPSErrors, deadline, skipProxiedTls, npmConfigProxy) {
+    // Validated before any server is probed, so this cannot throw.
+    const parsedUrl = new URL(url);
+    let response = await requestStatus(parsedUrl, ignoreHTTPSErrors, deadline, skipProxiedTls, npmConfigProxy);
+    if (response.status === 404 && parsedUrl.pathname === '/') {
+        const indexUrl = new URL(parsedUrl);
+        indexUrl.pathname = '/index.html';
+        response = await requestStatus(indexUrl, ignoreHTTPSErrors, deadline, skipProxiedTls, npmConfigProxy);
+    }
+    if (response.status >= 200 && response.status < 404) {
+        return null;
+    }
+    return (response.failure ??
+        `${redactedHref(response.href)} responded with status ${response.status}${viaProxy(response.via)}`);
+}
+// The one place the phrase is written, so a failure the probe words and one the
+// request words cannot drift apart.
+function viaProxy(via) {
+    return via ? ` via the proxy at ${via}` : '';
+}
+// Probe failures reach the task log, so a URL's credentials come off before it
+// enters one. Callers only pass URLs that already round-tripped through `URL`.
+function redactedHref(href) {
+    const url = new URL(href);
+    if (!url.username && !url.password) {
+        return href;
+    }
+    url.username = '***';
+    url.password = '';
+    return url.href;
+}
+function requestStatus(url, ignoreHTTPSErrors, deadline, skipProxiedTls, npmConfigProxy, redirects = 0) {
+    // A chain that ran out of budget still told us the server is answering, so it
+    // is a real observation rather than silence, whether the budget ran out
+    // between hops or inside the last one.
+    const redirectFailure = redirects > 0
+        ? `${redactedHref(url.href)} redirected ${redirects} times without resolving`
+        : undefined;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+        return Promise.resolve({
+            href: url.href,
+            status: 0,
+            failure: redirectFailure ?? NO_OBSERVATION,
+        });
+    }
+    // Resolved per URL rather than once per probe so a redirect that changes
+    // protocol re-selects the way Playwright's own recursion does.
+    const resolution = (0, proxy_1.resolveProxyForUrl)(url, process.env, npmConfigProxy);
+    if (resolution.kind === 'unusable') {
+        return Promise.resolve({
+            href: url.href,
+            status: 0,
+            failure: `${redactedHref(url.href)} ${unusableProxyProblem(resolution)}`,
+        });
+    }
+    const via = resolution.kind === 'proxy' ? resolution.proxy.host : undefined;
+    const describe = (detail) => `${redactedHref(url.href)} ${detail}${viaProxy(via)}`;
+    return new Promise((resolve) => {
+        const requestOptions = {
+            method: 'GET',
+            headers: { Accept: '*/*' },
+            rejectUnauthorized: !ignoreHTTPSErrors,
+        };
+        let request;
+        let settled = false;
+        // Until the agent finishes `CONNECT` the request holds no socket, so
+        // destroying it cannot reach the connection to the proxy. Aborting is what
+        // closes that leg; without it a proxy that never answers leaves a live
+        // socket nothing else can reach.
+        const connecting = new AbortController();
+        // Declared ahead of the settle it is cleared by, which the timer's own
+        // callback in turn calls.
+        let budget;
+        const settle = (response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(budget);
+            request?.destroy();
+            connecting.abort();
+            resolve(response);
+        };
+        // The rest of the readiness budget bounds the request in wall-clock time. A
+        // request arms its own idle timeout only once it holds a socket, and one
+        // waiting on a proxy that accepted the connection but never answered
+        // `CONNECT` never gets that far. Unreferenced because it is a bound rather
+        // than work of its own: it still fires while a request is in flight, and
+        // cannot hold the process open once nothing else does.
+        budget = setTimeout(() => {
+            // Silence for the window the port probe allows is an observation of the
+            // server. A request cut off with less budget than that only means the
+            // deadline arrived mid-flight, and must not displace what an earlier
+            // probe saw.
+            settle({
+                href: url.href,
+                status: 0,
+                failure: redirectFailure ??
+                    (remaining >= FALLBACK_RETRY_DELAY
+                        ? describe('did not respond')
+                        : NO_OBSERVATION),
+            });
+        }, remaining).unref();
+        const onResponse = (response) => {
+            const status = response.statusCode ?? 0;
+            const location = response.headers.location;
+            response.resume();
+            // Follow redirects like Playwright and evaluate the final
+            // destination, so a redirect to an unavailable page is not read as
+            // ready. The readiness deadline bounds the chain instead of a hop
+            // count, which would fail a long chain Playwright follows to a
+            // ready server. Treat a malformed chain as not ready.
+            if (status >= 300 && status < 400 && location) {
+                let redirectUrl;
+                try {
+                    redirectUrl = new URL(location, url);
+                }
+                catch {
+                    settle({
+                        href: url.href,
+                        status: 0,
+                        // Node's header parser passes tab and the C1 controls through, and
+                        // the value reaches a terminal from here. Unparseable for URL, so
+                        // credentials come off with the string-based treatment.
+                        failure: describe(`redirected to an invalid location "${(0, proxy_1.withoutCredentials)(location.replace(/[\x00-\x1f\x7f-\x9f]/g, ''))}"`),
+                    });
+                    return;
+                }
+                if (redirectUrl.protocol !== 'http:' &&
+                    redirectUrl.protocol !== 'https:') {
+                    // Classified like an unparseable location rather than followed into
+                    // `http.request`, which would throw synchronously and fail the wait
+                    // outright. A boot-time redirect can still settle into a ready
+                    // server within the budget.
+                    settle({
+                        href: url.href,
+                        status: 0,
+                        failure: describe(`redirected to "${redactedHref(redirectUrl.href)}", which is not an http or https url`),
+                    });
+                    return;
+                }
+                settle(requestStatus(redirectUrl, ignoreHTTPSErrors, deadline, skipProxiedTls, npmConfigProxy, redirects + 1));
+                return;
+            }
+            settle({ href: url.href, via, status });
+        };
+        switch (resolution.kind) {
+            case 'direct':
+                // `localhost` can resolve to ::1 first while the server listens on
+                // 127.0.0.1 only; Happy Eyeballs tries both families the way
+                // Playwright's probe agent does, on every Node line regardless of the
+                // process-wide default.
+                // The cast is needed because @types/node's RequestOptions omits the
+                // option; Node forwards request options to socket.connect, which
+                // honors it.
+                request = (url.protocol === 'https:' ? https : http).request(url, {
+                    ...requestOptions,
+                    autoSelectFamily: true,
+                }, onResponse);
+                break;
+            case 'proxy':
+                request = proxiedRequest(url, resolution.proxy, requestOptions, skipProxiedTls, connecting.signal, onResponse);
+                break;
+            default: {
+                // Both kinds that reach here route the request somewhere; a new one has
+                // to say where.
+                const unhandled = resolution;
+                throw new Error(`Unhandled proxy resolution ${JSON.stringify(unhandled)}`);
+            }
+        }
+        // Not `once`: aborting the connection raises a second error on a request
+        // that has already been settled, and an emitter left without a listener
+        // would throw it at the process.
+        request.on('error', (error) => {
+            const detail = error.code ?? error.message;
+            settle({
+                href: url.href,
+                status: 0,
+                failure: describe(redirects > 0 ? `${detail} after ${redirects} redirects` : detail),
+            });
+        });
+        request.end();
+    });
+}
+// An http target is named in the request line and the request itself goes to
+// the proxy, which is what Playwright does. An https target cannot be named
+// that way, so the agent opens a tunnel with `CONNECT` and TLS runs over it.
+// Proxy credentials travel differently on the two routes, on the URL for the
+// first and as `Proxy-Authorization` for the second, and both match Playwright.
+function proxiedRequest(url, proxy, options, skipProxiedTls, signal, onResponse) {
+    if (url.protocol === 'https:') {
+        const agent = new https_proxy_agent_1.HttpsProxyAgent(proxy);
+        // The agent dials the proxy itself, so this is the only handle on that
+        // connection. A signal in the request options does not reach it.
+        agent.connectOpts.signal = signal;
+        return https.request(url, {
+            ...options,
+            // Playwright before 1.59.0 never verifies the origin certificate on
+            // this route, whatever the caller asked for.
+            // TODO(v25): drop once minSupportedPlaywrightVersion reaches 1.59.0.
+            ...(skipProxiedTls ? { rejectUnauthorized: false } : {}),
+            agent,
+        }, onResponse);
+    }
+    // Playwright's Happy Eyeballs agent also dials the proxy on this route (its
+    // CONNECT route above drops it, so that one stays default). Same cast as the
+    // direct probe: @types/node's RequestOptions omits the option.
+    return (proxy.protocol === 'https:' ? https : http).request(proxy, {
+        ...options,
+        path: url.href,
+        autoSelectFamily: true,
+    }, onResponse);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/generators/configuration/schema.d.ts

@@ -30,8 +30,7 @@ export interface ConfigurationGeneratorSchema {
   addPlugin?: boolean;
 }
 
-export interface NormalizedGeneratorOptions
-  extends ConfigurationGeneratorSchema {
+export interface NormalizedGeneratorOptions extends ConfigurationGeneratorSchema {
   addPlugin: boolean;
   directory: string;
   linter: LinterType;

package/dist/src/plugins/plugin.d.ts

@@ -2,6 +2,21 @@ import { type CreateNodes } from '@nx/devkit';
 export interface PlaywrightPluginOptions {
     targetName?: string;
     ciTargetName?: string;
+    /**
+     * Maximum time in milliseconds the inferred web server readiness task waits
+     * for a server to be ready before failing. Overrides the `timeout` each
+     * Playwright `webServer` configures. Defaults to that configured timeout,
+     * or 60000 when neither is set.
+     */
+    webServerTimeout?: number;
+    /**
+     * Whether to infer a task that waits for the web server to be ready before the
+     * Playwright test tasks run. When false, no readiness task is inferred and the
+     * tests fall back to Playwright's own `reuseExistingServer` probe. Defaults to
+     * true.
+     */
+    waitForWebServer?: boolean;
 }
 export declare const createNodes: CreateNodes<PlaywrightPluginOptions>;
 export declare const createNodesV2: CreateNodes<PlaywrightPluginOptions>;
+export declare function _clearWarnedUnparseableCommands(): void;