e2e 0.16.0 → 0.18.0

package/dist/cache/trace.js

@@ -34,10 +34,11 @@ export function bound(text, maxChars) {
     return text.length <= maxChars ? text : `${text.slice(0, maxChars - 1)}…`;
 }
 /**
- * Cap on recorded end anchors. Anchors are the step's own delta — what
- * appeared on screen between the first observation and the passing one — so
- * a same-screen mutation rarely has more than a handful; a step that changes
- * the whole screen keeps the first few in document order.
+ * Cap on recorded anchors, per side of the delta. Anchors are the step's own
+ * delta, what appeared on screen between the first observation and the
+ * passing one and what vanished, so a same-screen mutation rarely has more
+ * than a handful; a step that changes the whole screen keeps the first few,
+ * announcements first (`cache/anchors.ts`).
  */
 export const MAX_TRACE_ANCHORS = 8;
 /** Longest a replay waits for the recorded end state to return. */
@@ -66,6 +67,9 @@ function each(items, read) {
 const SHA256_HEX = /^[a-f0-9]{64}$/u;
 /** Most twins a positional recording distinguishes between; beyond it a list is data, not a control set. */
 const MAX_TRACE_POSITION_OF = 1000;
+/** The node states an anchor records: the ones a step sets on a control it leaves on screen. */
+export const TRACE_ANCHOR_STATES = ['checked', 'expanded', 'pressed', 'selected'];
+const isTraceAnchorState = oneOf(TRACE_ANCHOR_STATES);
 /** The verbs that act on one node and carry no input: tap and its variants, hover, scroll into view. */
 const NODE_ACTION_NAMES = ['tap', 'doubleTap', 'longPress', 'secondaryTap', 'hover', 'scrollTo'];
 const isNodeActionName = oneOf(NODE_ACTION_NAMES);
@@ -131,18 +135,13 @@ function readActionTrace(document) {
     const summary = readBoundedText(raw['summary'], MAX_TRACE_SUMMARY_CHARS);
     if (summary === undefined)
         return undefined;
-    const startPath = raw['startPath'];
-    if (startPath !== undefined) {
-        if (typeof startPath !== 'string' || startPath === '' || startPath.length > MAX_TRACE_DESCRIPTOR_CHARS) {
-            return undefined;
-        }
-    }
-    const endPath = raw['endPath'];
-    if (endPath !== undefined) {
-        if (typeof endPath !== 'string' || endPath === '' || endPath.length > MAX_TRACE_DESCRIPTOR_CHARS) {
-            return undefined;
-        }
-    }
+    // A location is a replay precondition, kept whole like a typed value.
+    const startPath = raw['startPath'] === undefined ? undefined : readInputText(raw['startPath']);
+    if (raw['startPath'] !== undefined && startPath === undefined)
+        return undefined;
+    const endPath = raw['endPath'] === undefined ? undefined : readInputText(raw['endPath']);
+    if (raw['endPath'] !== undefined && endPath === undefined)
+        return undefined;
     const truncated = raw['truncated'];
     if (truncated !== undefined && typeof truncated !== 'boolean')
         return undefined;
@@ -151,15 +150,12 @@ function readActionTrace(document) {
         (typeof endWaitMs !== 'number' || !Number.isInteger(endWaitMs) || endWaitMs < 0 || endWaitMs > MAX_TRACE_END_WAIT_MS)) {
         return undefined;
     }
-    const anchorsRaw = raw['endAnchors'];
-    let endAnchors;
-    if (anchorsRaw !== undefined) {
-        if (!Array.isArray(anchorsRaw) || anchorsRaw.length > MAX_TRACE_ANCHORS)
-            return undefined;
-        endAnchors = each(anchorsRaw, readDescriptor);
-        if (endAnchors === undefined)
-            return undefined;
-    }
+    const endAnchors = readAnchors(raw['endAnchors']);
+    if (endAnchors === undefined)
+        return undefined;
+    const goneAnchors = readAnchors(raw['goneAnchors']);
+    if (goneAnchors === undefined)
+        return undefined;
     const actionsRaw = raw['actions'];
     if (!Array.isArray(actionsRaw) || actionsRaw.length === 0 || actionsRaw.length > MAX_TRACE_ACTIONS) {
         return undefined;
@@ -177,11 +173,20 @@ function readActionTrace(document) {
         summary,
         ...(startPath === undefined ? {} : { startPath }),
         ...(endPath === undefined ? {} : { endPath }),
-        ...(endAnchors === undefined || endAnchors.length === 0 ? {} : { endAnchors }),
+        ...(endAnchors.length === 0 ? {} : { endAnchors }),
+        ...(goneAnchors.length === 0 ? {} : { goneAnchors }),
         ...(endWaitMs === undefined ? {} : { endWaitMs }),
         ...(truncated === undefined ? {} : { truncated }),
     };
 }
+/** One side of the recorded delta: absent reads as empty, anything malformed or over the cap as undefined. */
+function readAnchors(document) {
+    if (document === undefined)
+        return [];
+    if (!Array.isArray(document) || document.length > MAX_TRACE_ANCHORS)
+        return undefined;
+    return each(document, readDescriptor);
+}
 function readRecordedAction(document) {
     if (typeof document !== 'object' || document === null || Array.isArray(document)) {
         return undefined;
@@ -198,7 +203,7 @@ function readRecordedAction(document) {
     switch (name) {
         case 'type': {
             const target = readDescriptor(raw['target']);
-            const value = readInputText(raw['value']);
+            const value = readTypedValue(raw['value']);
             if (target === undefined || value === undefined)
                 return undefined;
             return { name: 'type', summary, target, value };
@@ -305,7 +310,7 @@ function readRecordedAction(document) {
         case 'back':
             return { name: 'back', summary };
         case 'typeText': {
-            const value = readInputText(raw['value']);
+            const value = readTypedValue(raw['value']);
             if (value === undefined || typeof raw['replace'] !== 'boolean')
                 return undefined;
             return { name: 'typeText', summary, value, replace: raw['replace'] };
@@ -370,13 +375,14 @@ export const DESCRIPTOR_FIELDS = [
     'selector',
     'inputPurpose',
     'within',
+    'value',
 ];
 /**
  * The descriptor fields that carry text read off the screen, where a value
  * a test supplied can reappear. `role`, `selector`, and `inputPurpose` are
  * vocabulary, never screen text.
  */
-const DESCRIPTOR_TEXT_FIELDS = ['name', 'text', 'testId', 'placeholder', 'within'];
+const DESCRIPTOR_TEXT_FIELDS = ['name', 'text', 'testId', 'placeholder', 'within', 'value'];
 function mapDescriptorText(descriptor, map) {
     const changes = {};
     for (const field of DESCRIPTOR_TEXT_FIELDS) {
@@ -486,6 +492,9 @@ export function mapTraceText(trace, map) {
     const endAnchors = trace.endAnchors === undefined ? undefined : mapDescriptors(trace.endAnchors, map);
     if (trace.endAnchors !== undefined && endAnchors === undefined)
         return undefined;
+    const goneAnchors = trace.goneAnchors === undefined ? undefined : mapDescriptors(trace.goneAnchors, map);
+    if (trace.goneAnchors !== undefined && goneAnchors === undefined)
+        return undefined;
     return {
         ...trace,
         actions,
@@ -493,6 +502,7 @@ export function mapTraceText(trace, map) {
         ...(startPath === undefined ? {} : { startPath }),
         ...(endPath === undefined ? {} : { endPath }),
         ...(endAnchors === undefined ? {} : { endAnchors }),
+        ...(goneAnchors === undefined ? {} : { goneAnchors }),
     };
 }
 function mapDescriptors(descriptors, map) {
@@ -521,8 +531,23 @@ function readDescriptor(document) {
             return undefined;
         descriptor['position'] = position;
     }
+    if (raw['states'] !== undefined) {
+        const states = readStates(raw['states']);
+        if (states === undefined)
+            return undefined;
+        descriptor['states'] = states;
+    }
     return descriptor;
 }
+/** Known anchor states, each once, in sorted order, as `anchors.ts` writes them; an empty list is never written. */
+function readStates(document) {
+    if (!Array.isArray(document) || document.length === 0)
+        return undefined;
+    const states = each(document, (state) => (isTraceAnchorState(state) ? state : undefined));
+    if (states === undefined)
+        return undefined;
+    return states.every((state, index) => index === 0 || states[index - 1] < state) ? states : undefined;
+}
 /** A well-formed position: two safe integers with the index inside the count. */
 function readPosition(document) {
     if (typeof document !== 'object' || document === null || Array.isArray(document))
@@ -549,7 +574,24 @@ function readProvenance(document) {
         return undefined;
     if (typeof instructionDigest !== 'string' || !SHA256_HEX.test(instructionDigest))
         return undefined;
-    return { testId, targetId, instructionDigest };
+    const paramsDigest = raw['paramsDigest'];
+    if (paramsDigest !== undefined && (typeof paramsDigest !== 'string' || !SHA256_HEX.test(paramsDigest)))
+        return undefined;
+    const callIndex = raw['callIndex'];
+    if (callIndex !== undefined && (typeof callIndex !== 'number' || !Number.isSafeInteger(callIndex) || callIndex < 0)) {
+        return undefined;
+    }
+    const agent = raw['agent'] === undefined ? undefined : readBoundedText(raw['agent'], MAX_TRACE_DESCRIPTOR_CHARS);
+    if (raw['agent'] !== undefined && agent === undefined)
+        return undefined;
+    return {
+        testId,
+        targetId,
+        instructionDigest,
+        ...(paramsDigest === undefined ? {} : { paramsDigest }),
+        ...(callIndex === undefined ? {} : { callIndex }),
+        ...(agent === undefined ? {} : { agent }),
+    };
 }
 function readBoundedText(value, maxChars) {
     if (typeof value !== 'string' || value.trim() === '' || value.length > maxChars) {
@@ -570,3 +612,7 @@ function readInputText(value) {
     }
     return value;
 }
+/** A typed value: `readInputText`, except that `''` is valid, since typing it clears a field. */
+function readTypedValue(value) {
+    return value === '' ? value : readInputText(value);
+}

package/dist/cli/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { unsupportedNodeMessage } from '../internal/node-version.js';
+import { unsupportedRuntimeMessage } from '../internal/node-version.js';
 // Checked before the CLI module loads: that module and its dependencies are
 // what an old runtime would fail on, with a stack trace instead of a sentence.
-const unsupported = unsupportedNodeMessage(process.versions.node);
+const unsupported = unsupportedRuntimeMessage();
 if (unsupported !== undefined) {
     process.stderr.write(`${unsupported}\n`);
     process.exit(2);

package/dist/cli/index.js

@@ -7,6 +7,7 @@ import { detectPackageManager, execCommand, runScriptCommand } from '../internal
 import { packageVersion } from '../internal/package-version.js';
 import { classifyError, exitCodeForCategory } from '../internal/errors.js';
 import { list, run } from '../run/runner.js';
+import { claimRunnerOutput } from './run-output.js';
 import { explore, STEP_BOUNDS, TIMEOUT_BOUNDS } from '../explore/index.js';
 import { BUILTIN_REPORTERS, isBuiltinReporter } from '../report/builtin.js';
 import { bounded } from '../report/format.js';
@@ -357,22 +358,22 @@ function createProgram(version, telemetry) {
     });
     program
         .command('login')
-        .summary('sign in to a ChatGPT, GitHub Copilot, or SuperGrok subscription for agent steps')
-        .description('Sign in once to a personal subscription and store the login for the e2e/oauth models: openai (ChatGPT Plus/Pro, the Codex sign-in), github-copilot (GitHub Copilot; reuses the GitHub CLI login or runs a device flow for your OAuth App), spacexai (SuperGrok or X Premium+, device code). The config then constructs the model with chatgpt(), copilot(), or grok() from e2e/oauth/<provider>.')
-        .addArgument(new Argument('[provider]', 'openai, github-copilot, or spacexai; omitted, a picker').choices(PROVIDER_IDS))
+        .summary('sign in to a ChatGPT, GitHub Copilot, OpenCode Console, or SuperGrok subscription for agent steps')
+        .description('Sign in once to a personal subscription and store the login for the e2e/oauth models: openai (ChatGPT Plus/Pro, the Codex sign-in), github-copilot (GitHub Copilot; reuses the GitHub CLI login or runs a device flow for your OAuth App), opencode-console (OpenCode Console, device code), spacexai (SuperGrok or X Premium+, device code). The config then constructs the model with chatgpt(), copilot(), opencodeConsole(), or grok() from e2e/oauth/<provider>.')
+        .addArgument(new Argument('[provider]', 'openai, github-copilot, opencode-console, or spacexai; omitted, a picker').choices(PROVIDER_IDS))
         .option('--device', 'ChatGPT: show a code to enter on another device instead of opening a browser')
         .option('--client-id <id>', 'GitHub Copilot: the client id of your GitHub OAuth App with the device flow enabled')
         .option('--from-gh', 'GitHub Copilot: reuse the token of the signed-in GitHub CLI')
         .option('--enterprise-url <host>', 'GitHub Copilot: the GitHub Enterprise host')
-        .addHelpText('after', ['', examples(['e2e login openai', 'e2e login github-copilot --from-gh', 'e2e login spacexai', 'e2e login']), '', docsLine('/subscriptions')].join('\n'))
+        .addHelpText('after', ['', examples(['e2e login openai', 'e2e login github-copilot --from-gh', 'e2e login opencode-console', 'e2e login spacexai', 'e2e login']), '', docsLine('/subscriptions')].join('\n'))
         .action(async (provider, options) => {
         process.exitCode = await runLogin(provider, options);
     });
     program
         .command('logout')
         .summary('forget a stored subscription login')
-        .description('Remove the stored login of one provider (openai, github-copilot, spacexai). Without a provider, a picker over the stored logins.')
-        .addArgument(new Argument('[provider]', 'openai, github-copilot, or spacexai; omitted, a picker').choices(PROVIDER_IDS))
+        .description('Remove the stored login of one provider (openai, github-copilot, opencode-console, spacexai). Without a provider, a picker over the stored logins.')
+        .addArgument(new Argument('[provider]', 'openai, github-copilot, opencode-console, or spacexai; omitted, a picker').choices(PROVIDER_IDS))
         .addHelpText('after', ['', examples(['e2e logout', 'e2e logout openai']), '', docsLine('/subscriptions')].join('\n'))
         .action(async (provider) => {
         process.exitCode = await runLogout(provider);
@@ -380,8 +381,8 @@ function createProgram(version, telemetry) {
     program
         .command('models')
         .summary('list the models a stored subscription login serves')
-        .description('Ask the vendor which models the stored login serves and print their ids, the ones chatgpt(), copilot(), and grok() take. Without a provider, every stored login in turn.')
-        .addArgument(new Argument('[provider]', 'openai, github-copilot, or spacexai; omitted, every stored login').choices(PROVIDER_IDS))
+        .description('Ask the vendor which models the stored login serves and print their ids, the ones chatgpt(), copilot(), opencodeConsole(), and grok() take. Without a provider, every stored login in turn.')
+        .addArgument(new Argument('[provider]', 'openai, github-copilot, opencode-console, or spacexai; omitted, every stored login').choices(PROVIDER_IDS))
         .addHelpText('after', ['', examples(['e2e models', 'e2e models openai']), '', docsLine('/subscriptions#pick-a-model')].join('\n'))
         .action(async (provider) => {
         process.exitCode = await runModels(provider);
@@ -401,11 +402,14 @@ function createProgram(version, telemetry) {
         .description('Serve an MCP server over stdio for a coding agent such as Claude Code or Cursor: open_session opens a live session on one target of any config the agent names, call runs the session\'s tools (observe, tap, type, press, select, scroll, navigate, type_secret, locate, screenshot, and the project\'s own), tools describes them, close_session ends it. The agent explores the real app before writing a test. Register it with the client, e.g. claude mcp add e2e -- npx e2e mcp.')
         .option('--config <path>', 'config file (default: the nearest e2e.config.ts)')
         .option('--target <name>', 'target every session opens on (default: the only target, or the one open_session names)')
-        .option('--headless', 'hide the UI during live sessions (default: headed outside CI)')
+        .option('--headed', 'show the UI in sessions whose open_session does not set headed, when the engine supports it')
+        // Sessions were headed by default before 0.18 and took --headless; a client config that still passes it
+        // asks for the default now, and a refused flag would surface as nothing but a failed connection.
+        .addOption(new Option('--headless').hideHelp())
         .option('--max-sessions <n>', `sessions open at once, each with its own browser or device, ${SESSION_BOUNDS.min} through ${SESSION_BOUNDS.max} (default: ${SESSION_BOUNDS.default})`, parseBoundedInt(SESSION_BOUNDS))
         .addHelpText('after', [
         '',
-        examples(['e2e mcp', 'e2e mcp --target web --headless', 'e2e mcp --max-sessions 8', 'claude mcp add e2e -- npx e2e mcp']),
+        examples(['e2e mcp', 'e2e mcp --target web --headed', 'e2e mcp --max-sessions 8', 'claude mcp add e2e -- npx e2e mcp']),
         '',
         docsLine('/reference/mcp'),
     ].join('\n'))
@@ -466,28 +470,35 @@ function createProgram(version, telemetry) {
     // Each value is what its parser returned, so a bad one never reaches here.
     options, command) => {
         rejectForwardedFlags(command, files);
-        return runToOutcome(telemetry, command, (signals) => run({
-            files,
-            configPath: options.config,
-            targetIds: options.target,
-            ...selectionRunOptions(options),
-            headed: options.headed,
-            agent: options.agent,
-            retries: options.retries,
-            workers: options.workers,
-            maxFailures: options.maxFailures,
-            repeatEach: options.repeatEach,
-            reporters: options.reporter,
-            output: options.output,
-            noCache: options.cache === false,
-            strictCache: options.strictCache,
-            debug: options.debug,
-            aiTrace: options.aiTrace,
-            trace: recordingOption(options.trace),
-            video: recordingOption(options.video),
-            interruptSignal: signals.interruptSignal,
-            forceSignal: signals.forceSignal,
-        }));
+        const output = claimRunnerOutput();
+        try {
+            await runToOutcome(telemetry, command, (signals) => run({
+                files,
+                configPath: options.config,
+                targetIds: options.target,
+                ...selectionRunOptions(options),
+                headed: options.headed,
+                agent: options.agent,
+                retries: options.retries,
+                workers: options.workers,
+                maxFailures: options.maxFailures,
+                repeatEach: options.repeatEach,
+                reporters: options.reporter,
+                output: options.output,
+                noCache: options.cache === false,
+                strictCache: options.strictCache,
+                debug: options.debug,
+                aiTrace: options.aiTrace,
+                trace: recordingOption(options.trace),
+                video: recordingOption(options.video),
+                interruptSignal: signals.interruptSignal,
+                forceSignal: signals.forceSignal,
+                processOutput: output,
+            }));
+        }
+        finally {
+            output.end();
+        }
     });
     program
         .command('explore')

package/dist/cli/init/engines.d.ts

@@ -16,9 +16,7 @@ export declare function getEnginePresets(): readonly [{
     readonly id: 'web';
     readonly label: 'Web';
     readonly hint: 'Playwright';
-    readonly dependencies: {
-        readonly playwright: string;
-    };
+    readonly dependencies: Readonly<Record<string, string>>;
     readonly imports: readonly ["import { web } from '@e2e-dev/web';"];
     readonly config: `  targets: [{
     engine: web(),

package/dist/cli/init/engines.js

@@ -1,6 +1,6 @@
 /** CLI scaffold presets. Engine packages are referenced as generated source, never imported. */
 import os from 'node:os';
-import { playwrightRange, siblingDependency, SIBLING_VERSIONS } from './versions.js';
+import { siblingDependency } from './versions.js';
 /** Builds prompt choices and scaffolds with defaults for the machine running init. */
 export function getEnginePresets() {
     const ios = os.platform() === 'darwin';
@@ -9,7 +9,7 @@ export function getEnginePresets() {
             id: 'web',
             label: 'Web',
             hint: 'Playwright',
-            dependencies: { ...siblingDependency('@e2e-dev/web'), playwright: playwrightRange(SIBLING_VERSIONS?.['playwright']) },
+            dependencies: siblingDependency('@e2e-dev/web'),
             imports: ["import { web } from '@e2e-dev/web';"],
             config: `  targets: [{
     engine: web(),

package/dist/cli/init/gateways.d.ts

@@ -4,7 +4,7 @@
  * of them and takes the constructed instance. Adding a gateway is adding an
  * entry here.
  */
-export type GatewayId = 'vercel' | 'openrouter' | 'openai-compatible' | 'chatgpt' | 'copilot' | 'grok';
+export type GatewayId = 'vercel' | 'openrouter' | 'openai-compatible' | 'chatgpt' | 'copilot' | 'opencode-console' | 'grok';
 export interface GatewayPreset {
     readonly id: GatewayId;
     readonly label: string;

package/dist/cli/init/gateways.js

@@ -50,12 +50,22 @@ export const GATEWAYS = [
         id: 'copilot',
         label: 'GitHub Copilot subscription',
         hint: 'your Copilot plan: OpenAI, Anthropic, Google, and SpaceXAI models',
-        dependencies: { '@ai-sdk/openai-compatible': '^3.0.0' },
+        dependencies: { '@ai-sdk/openai-compatible': '^3.0.0', '@ai-sdk/openai': '^4.0.0' },
         import: "import { copilot } from 'e2e/oauth/copilot';",
         comment: 'Your GitHub Copilot subscription serves the model; sign in once with `e2e login github-copilot`, `e2e models github-copilot` lists the ids.',
         login: 'github-copilot',
         model: () => "copilot('claude-sonnet-5')",
     },
+    {
+        id: 'opencode-console',
+        label: 'OpenCode Console',
+        hint: 'the models your OpenCode Console workspace serves',
+        dependencies: { '@ai-sdk/openai-compatible': '^3.0.0', '@ai-sdk/openai': '^4.0.0', '@ai-sdk/anthropic': '^4.0.0', '@ai-sdk/google': '^4.0.0' },
+        import: "import { opencodeConsole } from 'e2e/oauth/opencode-console';",
+        comment: 'Your OpenCode Console workspace serves the model; sign in once with `e2e login opencode-console`, `e2e models opencode-console` lists the ids.',
+        login: 'opencode-console',
+        model: () => "opencodeConsole('deepseek-v4.1-flash')",
+    },
     {
         id: 'grok',
         label: 'SuperGrok subscription',

package/dist/cli/init/mcp-config.d.ts

@@ -25,6 +25,7 @@ export declare function findRegisteredMcpFiles(cwd: string): string[];
 /**
  * Plans the writes for the given files. A file without the entry gets it
  * merged in; one whose entry already matches needs nothing and is left out.
- * Other servers, other keys, and the file's indentation are preserved.
+ * Extra settings on the e2e entry, other servers, other keys, and the file's
+ * indentation are preserved.
  */
 export declare function planMcpRegistration(cwd: string, files: readonly string[]): McpRegistration[];

package/dist/cli/init/mcp-config.js

@@ -45,7 +45,8 @@ export function findRegisteredMcpFiles(cwd) {
 /**
  * Plans the writes for the given files. A file without the entry gets it
  * merged in; one whose entry already matches needs nothing and is left out.
- * Other servers, other keys, and the file's indentation are preserved.
+ * Extra settings on the e2e entry, other servers, other keys, and the file's
+ * indentation are preserved.
  */
 export function planMcpRegistration(cwd, files) {
     const registrations = [];
@@ -55,9 +56,13 @@ export function planMcpRegistration(cwd, files) {
         const servers = typeof document.mcpServers === 'object' && document.mcpServers !== null && !Array.isArray(document.mcpServers)
             ? document.mcpServers
             : {};
-        if (JSON.stringify(servers[MCP_SERVER_NAME]) === JSON.stringify(SERVER_ENTRY))
+        const existing = servers[MCP_SERVER_NAME];
+        const entry = typeof existing === 'object' && existing !== null && !Array.isArray(existing)
+            ? { ...existing, ...SERVER_ENTRY }
+            : SERVER_ENTRY;
+        if (JSON.stringify(existing) === JSON.stringify(entry))
             continue;
-        const merged = { ...document, mcpServers: { ...servers, [MCP_SERVER_NAME]: SERVER_ENTRY } };
+        const merged = { ...document, mcpServers: { ...servers, [MCP_SERVER_NAME]: entry } };
         const original = existsSync(absolute) ? readFileSync(absolute, 'utf8') : undefined;
         const indent = original?.match(/\n([\t ]+)"/)?.[1] ?? '  ';
         registrations.push({

package/dist/cli/init/sibling-versions.json

@@ -1 +1 @@
-{"@e2e-dev/web":"0.11.2","@e2e-dev/mobile":"0.9.1","playwright":"1.63.0"}
+{"@e2e-dev/web":"0.13.0","@e2e-dev/mobile":"0.10.0"}

package/dist/cli/init/versions.d.ts

@@ -3,7 +3,6 @@
  * build in `sibling-versions.json` next to this module from their manifests.
  * Absent when running from source. Both preset tables read from here.
  */
-export declare const SIBLING_VERSIONS: Readonly<Record<string, string>> | undefined;
 /**
  * The range init writes for the runner and for an engine. Engines version
  * independently of the runner and pin it through their own peer range, so init
@@ -20,10 +19,3 @@ export declare const SIBLING_VERSIONS: Readonly<Record<string, string>> | undefi
 export declare function dependencyRange(version: string | undefined): string;
 /** The range init writes for a sibling `@e2e-dev/*` package released alongside this runner. */
 export declare function siblingDependency(name: string): Readonly<Record<string, string>>;
-/**
- * The range init writes for `playwright`, which `@e2e-dev/web` peers on
- * rather than installs, so an app that already ships Playwright keeps one copy
- * and one browser cache. The build records the version the engine was built
- * and tested against; from source, where nothing is recorded, any 1.x will do.
- */
-export declare function playwrightRange(version: string | undefined): string;

package/dist/cli/init/versions.js

@@ -4,7 +4,7 @@
  * Absent when running from source. Both preset tables read from here.
  */
 import { readJson } from '../../internal/package-version.js';
-export const SIBLING_VERSIONS = readJson(import.meta.url, './sibling-versions.json');
+const SIBLING_VERSIONS = readJson(import.meta.url, './sibling-versions.json');
 /**
  * The range init writes for the runner and for an engine. Engines version
  * independently of the runner and pin it through their own peer range, so init
@@ -27,12 +27,3 @@ export function dependencyRange(version) {
 export function siblingDependency(name) {
     return { [name]: dependencyRange(SIBLING_VERSIONS?.[name]) };
 }
-/**
- * The range init writes for `playwright`, which `@e2e-dev/web` peers on
- * rather than installs, so an app that already ships Playwright keeps one copy
- * and one browser cache. The build records the version the engine was built
- * and tested against; from source, where nothing is recorded, any 1.x will do.
- */
-export function playwrightRange(version) {
-    return version === undefined ? '^1' : `^${version}`;
-}

package/dist/cli/mcp.d.ts

@@ -3,14 +3,15 @@
  * stdio, stdout is the JSON-RPC stream, so anything else that writes there
  * (a stray console.log, a library banner) would corrupt the handshake. The
  * transport keeps the process's own stdout writer, and everything else that
- * reaches process.stdout is redirected to stderr for the whole process.
+ * reaches process.stdout or process.stderr goes to stderr, redacted, for the
+ * whole process: user code runs here and may print a secret.
  */
 import { type ServeOptions } from '../mcp/server.ts';
 import type { Telemetry } from '../telemetry/telemetry.ts';
 export interface McpCommandOptions {
     config?: string | undefined;
     target?: string | undefined;
-    headless?: boolean | undefined;
+    headed?: boolean | undefined;
     maxSessions?: number | undefined;
 }
 /**

package/dist/cli/mcp.js

@@ -3,30 +3,48 @@
  * stdio, stdout is the JSON-RPC stream, so anything else that writes there
  * (a stray console.log, a library banner) would corrupt the handshake. The
  * transport keeps the process's own stdout writer, and everything else that
- * reaches process.stdout is redirected to stderr for the whole process.
+ * reaches process.stdout or process.stderr goes to stderr, redacted, for the
+ * whole process: user code runs here and may print a secret.
  */
 import { Writable } from 'node:stream';
-import { isCiMode } from '../config/resolve.js';
 import { errorMessage, exitCodeForCategory, classifyError } from '../internal/errors.js';
+import { McpOutput } from '../mcp/output.js';
 import { serveMcp } from '../mcp/server.js';
+import { processSecrets } from '../run/secrecy.js';
 import { mcpSessionEvent } from '../telemetry/events.js';
 /**
- * Diverts every later `process.stdout` write to stderr and returns a stream
- * that still reaches the real stdout. The protocol stream wraps the original
- * writer rather than opening file descriptor 1 again: once Node has set up
+ * Takes over the process's stdout and stderr: the returned protocol stream
+ * still reaches the real stdout, and every other write to either stream goes
+ * through `output` to stderr. The protocol stream wraps the original writer
+ * rather than opening file descriptor 1 again: once Node has set up
  * `process.stdout` on a pipe, the descriptor is non-blocking, and a plain
  * `fs` write to it fails with EAGAIN as soon as the client reads slower than
  * the server writes (a screenshot result), killing the server. The socket
  * writer queues and retries instead.
  */
-function claimStdout() {
+function claimStdio() {
     const stdout = process.stdout;
     const stderr = process.stderr;
-    const write = stdout.write.bind(stdout);
-    stdout.write = ((chunk, encoding, callback) => stderr.write(chunk, encoding, callback));
+    const writeStdout = stdout.write.bind(stdout);
+    const writeStderr = stderr.write.bind(stderr);
+    const output = new McpOutput(writeStderr, processSecrets);
+    for (const [stream, name] of [
+        [stdout, 'stdout'],
+        [stderr, 'stderr'],
+    ]) {
+        stream.write = ((chunk, encoding, callback) => {
+            const done = typeof encoding === 'function' ? encoding : callback;
+            const text = typeof chunk === 'string' && typeof encoding === 'string' ? Buffer.from(chunk, encoding) : chunk;
+            const accepted = output.write(name, text, done);
+            // stderr drains on its own; a writer waiting on stdout is told when stderr has.
+            if (!accepted && stream === stdout)
+                stderr.once('drain', () => stdout.emit('drain'));
+            return accepted;
+        });
+    }
     const protocol = new Writable({
         write(chunk, _encoding, callback) {
-            write(chunk, callback);
+            writeStdout(chunk, callback);
         },
     });
     // A client that went away fails the pipe with EPIPE; the protocol stream
@@ -36,7 +54,7 @@ function claimStdout() {
     // before its app processes stop.
     stdout.on('error', (error) => protocol.destroy(error));
     stderr.on('error', () => undefined);
-    return protocol;
+    return { protocol, output };
 }
 /**
  * Records each MCP session as it ends and sends it at once: a server lives
@@ -51,34 +69,52 @@ export function sessionTelemetry(telemetry) {
 }
 /** Runs the server until the client disconnects or a signal arrives; returns the exit code. */
 export async function mcp(version, options, telemetry) {
-    const stdout = claimStdout();
+    const { protocol, output } = claimStdio();
     const stop = new AbortController();
     const onSignal = () => stop.abort();
+    // Node would print an error nobody caught (a project tool's unawaited
+    // promise) straight to the stderr descriptor, past the redaction, and
+    // exit with every session's app still running. It is logged redacted, and
+    // held like user output while a config loads, and the server shuts down as
+    // on a signal.
+    let crashed = false;
+    const onUncaught = (cause) => {
+        crashed = true;
+        const text = cause instanceof Error ? (cause.stack ?? errorMessage(cause)) : errorMessage(cause);
+        output.report(`e2e mcp: [error] uncaught: ${text}`);
+        stop.abort();
+    };
     process.once('SIGINT', onSignal);
     process.once('SIGTERM', onSignal);
+    // A rejection nobody handled arrives here too: with no `unhandledRejection` listener, Node raises it as uncaught.
+    process.on('uncaughtException', onUncaught);
     try {
-        return await serveMcp({
+        const code = await serveMcp({
             cwd: process.cwd(),
             configPath: options.config,
             target: options.target,
-            headed: options.headless !== true && !isCiMode(process.env),
+            headed: options.headed === true,
             maxSessions: options.maxSessions,
             env: process.env,
             version,
             stdin: process.stdin,
-            stdout,
-            log: (line) => process.stderr.write(`e2e mcp: ${line}\n`),
+            stdout: protocol,
+            log: (line) => output.log(`e2e mcp: ${line}`),
+            output,
             signal: stop.signal,
             onSessionEnd: sessionTelemetry(telemetry),
         });
+        return crashed ? 1 : code;
     }
     catch (cause) {
         const error = classifyError(cause);
-        process.stderr.write(`e2e mcp: ${error.code}: ${errorMessage(cause)}\n`);
+        output.log(`e2e mcp: ${error.code}: ${processSecrets.redact(errorMessage(cause))}`);
         return exitCodeForCategory(error.category);
     }
     finally {
+        output.end();
         process.off('SIGINT', onSignal);
         process.off('SIGTERM', onSignal);
+        process.off('uncaughtException', onUncaught);
     }
 }