@sovovs/bycli 1.8.0 → 2.1.0

package/dist/src/browser.test.js

@@ -1,232 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { BrowserBridge, generateStealthJs } from './browser/index.js';
-import { extractTabEntries, diffTabIndexes, appendLimited } from './browser/tabs.js';
-import { withTimeoutMs } from './runtime.js';
-import { __test__ as cdpTest } from './browser/cdp.js';
-import { classifyBrowserError } from './browser/errors.js';
-import * as daemonClient from './browser/daemon-client.js';
-describe('browser helpers', () => {
-    it('extracts tab entries from string snapshots', () => {
-        const entries = extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
-        expect(entries).toEqual([
-            { index: 0, identity: 'https://example.com' },
-            { index: 1, identity: 'Chrome Extension' },
-        ]);
-    });
-    it('extracts tab entries from MCP markdown format', () => {
-        const entries = extractTabEntries('- 0: (current) [Playwright MCP extension](chrome-extension://abc/connect.html)\n- 1: [知乎 - 首页](https://www.zhihu.com/)');
-        expect(entries).toEqual([
-            { index: 0, identity: '(current) [Playwright MCP extension](chrome-extension://abc/connect.html)' },
-            { index: 1, identity: '[知乎 - 首页](https://www.zhihu.com/)' },
-        ]);
-    });
-    it('closes only tabs that were opened during the session', () => {
-        const tabsToClose = diffTabIndexes(['https://example.com', 'Chrome Extension'], [
-            { index: 0, identity: 'https://example.com' },
-            { index: 1, identity: 'Chrome Extension' },
-            { index: 2, identity: 'https://target.example/page' },
-            { index: 3, identity: 'chrome-extension://bridge' },
-        ]);
-        expect(tabsToClose).toEqual([3, 2]);
-    });
-    it('keeps only the tail of stderr buffers', () => {
-        expect(appendLimited('12345', '67890', 8)).toBe('34567890');
-    });
-    it('times out slow promises', async () => {
-        await expect(withTimeoutMs(new Promise(() => { }), 10, 'timeout')).rejects.toThrow('timeout');
-    });
-    it('classifies browser errors with correct kind and retry advice', () => {
-        // CDP target navigation — page-level settle retry
-        const nav = classifyBrowserError(new Error('{"code":-32000,"message":"Inspected target navigated or closed"}'));
-        expect(nav.kind).toBe('target-navigation');
-        expect(nav.delayMs).toBe(200);
-        // Extension transient — daemon-client retry only, NOT page-level
-        const ext = classifyBrowserError(new Error('Extension disconnected'));
-        expect(ext.kind).toBe('extension-transient');
-        expect(ext.delayMs).toBe(1500);
-        // Non-transient errors — not retryable
-        expect(classifyBrowserError(new Error('malformed exec payload')).kind).toBe('non-retryable');
-        expect(classifyBrowserError(new Error('Permission denied')).kind).toBe('non-retryable');
-    });
-    it('prefers the real Electron app target over DevTools and blank pages', () => {
-        const target = cdpTest.selectCDPTarget([
-            {
-                type: 'page',
-                title: 'DevTools - localhost:9224',
-                url: 'devtools://devtools/bundled/inspector.html',
-                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/devtools',
-            },
-            {
-                type: 'page',
-                title: '',
-                url: 'about:blank',
-                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/blank',
-            },
-            {
-                type: 'app',
-                title: 'Antigravity',
-                url: 'http://localhost:3000/',
-                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/app',
-            },
-        ]);
-        expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9224/app');
-    });
-    it('honors BYCLI_CDP_TARGET when multiple inspectable targets exist', () => {
-        vi.stubEnv('BYCLI_CDP_TARGET', 'codex');
-        const target = cdpTest.selectCDPTarget([
-            {
-                type: 'app',
-                title: 'Cursor',
-                url: 'http://localhost:3000/cursor',
-                webSocketDebuggerUrl: 'ws://127.0.0.1:9226/cursor',
-            },
-            {
-                type: 'app',
-                title: 'OpenAI Codex',
-                url: 'http://localhost:3000/codex',
-                webSocketDebuggerUrl: 'ws://127.0.0.1:9226/codex',
-            },
-        ]);
-        expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9226/codex');
-    });
-});
-describe('BrowserBridge state', () => {
-    it('transitions to closed after close()', async () => {
-        const bridge = new BrowserBridge();
-        expect(bridge.state).toBe('idle');
-        await bridge.close();
-        expect(bridge.state).toBe('closed');
-    });
-    it('rejects connect() after the session has been closed', async () => {
-        const bridge = new BrowserBridge();
-        await bridge.close();
-        await expect(bridge.connect()).rejects.toThrow('Session is closed');
-    });
-    it('rejects connect() while already connecting', async () => {
-        const bridge = new BrowserBridge();
-        bridge._state = 'connecting';
-        await expect(bridge.connect()).rejects.toThrow('Already connecting');
-    });
-    it('rejects connect() while closing', async () => {
-        const bridge = new BrowserBridge();
-        bridge._state = 'closing';
-        await expect(bridge.connect()).rejects.toThrow('Session is closing');
-    });
-    it('fails fast when daemon is running but extension is disconnected (same version)', async () => {
-        const { PKG_VERSION } = await import('./version.js');
-        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
-            state: 'no-extension',
-            status: {
-                ok: true,
-                pid: 1,
-                uptime: 0,
-                daemonVersion: PKG_VERSION,
-                extensionConnected: false,
-                pending: 0,
-                memoryMB: 0,
-                port: 0,
-            },
-        });
-        const bridge = new BrowserBridge();
-        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Bridge extension not connected');
-    });
-    it('attempts stale daemon replacement when daemonVersion is missing', async () => {
-        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
-            state: 'no-extension',
-            status: {
-                ok: true,
-                pid: 1,
-                uptime: 0,
-                extensionConnected: false,
-                pending: 0,
-                memoryMB: 0,
-                port: 0,
-            },
-        });
-        vi.spyOn(daemonClient, 'requestDaemonShutdown').mockResolvedValue(false);
-        const bridge = new BrowserBridge();
-        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
-    });
-    it('attempts stale daemon replacement when daemonVersion mismatches', async () => {
-        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
-            state: 'no-extension',
-            status: {
-                ok: true,
-                pid: 1,
-                uptime: 0,
-                daemonVersion: '0.0.1',
-                extensionConnected: false,
-                pending: 0,
-                memoryMB: 0,
-                port: 0,
-            },
-        });
-        vi.spyOn(daemonClient, 'requestDaemonShutdown').mockResolvedValue(false);
-        const bridge = new BrowserBridge();
-        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
-    });
-    it('attempts stale daemon replacement even when extension is connected', async () => {
-        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
-            state: 'ready',
-            status: {
-                ok: true,
-                pid: 1,
-                uptime: 0,
-                daemonVersion: '0.0.1',
-                extensionConnected: true,
-                pending: 0,
-                memoryMB: 0,
-                port: 0,
-            },
-        });
-        vi.spyOn(daemonClient, 'requestDaemonShutdown').mockResolvedValue(false);
-        const bridge = new BrowserBridge();
-        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
-    });
-});
-describe('stealth anti-detection', () => {
-    it('generates non-empty JS string', () => {
-        const js = generateStealthJs();
-        expect(typeof js).toBe('string');
-        expect(js.length).toBeGreaterThan(100);
-    });
-    it('contains all 7 anti-detection patches', () => {
-        const js = generateStealthJs();
-        // 1. webdriver
-        expect(js).toContain('navigator');
-        expect(js).toContain('webdriver');
-        // 2. chrome stub
-        expect(js).toContain('window.chrome');
-        // 3. plugins
-        expect(js).toContain('plugins');
-        expect(js).toContain('PDF Viewer');
-        // 4. languages
-        expect(js).toContain('languages');
-        // 5. permissions
-        expect(js).toContain('Permissions');
-        expect(js).toContain('notifications');
-        // 6. automation artifacts (dynamic cdc_ scan)
-        expect(js).toContain('__playwright');
-        expect(js).toContain('__puppeteer');
-        expect(js).toContain('getOwnPropertyNames');
-        expect(js).toContain('cdc_');
-        // 7. CDP stack trace cleanup
-        expect(js).toContain('Error.prototype');
-        expect(js).toContain('puppeteer_evaluation_script');
-        expect(js).toContain('getOwnPropertyDescriptor');
-    });
-    it('includes guard flag to prevent double-injection', () => {
-        const js = generateStealthJs();
-        // Guard uses a non-enumerable property on a built-in prototype
-        expect(js).toContain("EventTarget.prototype");
-        // Guard should check early and return 'skipped'
-        expect(js).toContain("return 'skipped'");
-        // Normal path returns 'applied'
-        expect(js).toContain("return 'applied'");
-    });
-    it('generates syntactically valid JS', () => {
-        const js = generateStealthJs();
-        // Should not throw when parsed
-        expect(() => new Function(js)).not.toThrow();
-    });
-});

package/dist/src/build-manifest.test.js

@@ -1,341 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { cli, getRegistry, Strategy } from './registry.js';
-import { ManifestImportError, diffRemovedEntries, findManifestMetadataIssues, loadManifestEntries, normalizeManifestPath, parseBuildManifestArgs, scanClisDir, serializeManifest, } from './build-manifest.js';
-describe('manifest helper rules', () => {
-    const tempDirs = [];
-    afterEach(() => {
-        for (const dir of tempDirs.splice(0)) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it('skips TS files that do not register a cli', () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-manifest-'));
-        tempDirs.push(dir);
-        const file = path.join(dir, 'utils.ts');
-        fs.writeFileSync(file, `export function helper() { return 'noop'; }`);
-        return expect(loadManifestEntries(file, 'demo', async () => ({}))).resolves.toEqual([]);
-    });
-    it('builds TS manifest entries from exported runtime commands', async () => {
-        const site = `manifest-hydrate-${Date.now()}`;
-        const key = `${site}/dynamic`;
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-manifest-'));
-        tempDirs.push(dir);
-        const file = path.join(dir, `${site}.ts`);
-        fs.writeFileSync(file, `export const command = cli({ site: '${site}', name: 'dynamic', access: 'read' });`);
-        const entries = await loadManifestEntries(file, site, async () => ({
-            command: cli({
-                site,
-                name: 'dynamic',
-                access: 'read',
-                description: 'dynamic command',
-                strategy: Strategy.PUBLIC,
-                browser: false,
-                aliases: ['metadata'],
-                args: [
-                    {
-                        name: 'model',
-                        required: true,
-                        positional: true,
-                        help: 'Choose a model',
-                        choices: ['auto', 'thinking'],
-                        default: '30',
-                    },
-                ],
-                domain: 'localhost',
-                navigateBefore: 'https://example.com/session',
-                defaultFormat: 'plain',
-            }),
-        }));
-        expect(entries).toMatchObject([
-            {
-                site,
-                name: 'dynamic',
-                access: 'read',
-                description: 'dynamic command',
-                domain: 'localhost',
-                strategy: 'public',
-                browser: false,
-                aliases: ['metadata'],
-                args: [
-                    expect.objectContaining({
-                        name: 'model',
-                        type: 'str',
-                        required: true,
-                        positional: true,
-                        help: 'Choose a model',
-                        choices: ['auto', 'thinking'],
-                        default: '30',
-                    }),
-                ],
-                type: 'js',
-                modulePath: `${site}/${site}.js`,
-                navigateBefore: 'https://example.com/session',
-                defaultFormat: 'plain',
-            },
-        ]);
-        // Verify sourceFile is included and stable for manifest consumers.
-        expect(entries[0].sourceFile).toBeDefined();
-        expect(entries[0].sourceFile).not.toContain('\\');
-        getRegistry().delete(key);
-    });
-    it('falls back to registry delta for side-effect-only cli modules', async () => {
-        const site = `manifest-side-effect-${Date.now()}`;
-        const key = `${site}/legacy`;
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-manifest-'));
-        tempDirs.push(dir);
-        const file = path.join(dir, `${site}.ts`);
-        fs.writeFileSync(file, `cli({ site: '${site}', name: 'legacy', access: 'read' });`);
-        const entries = await loadManifestEntries(file, site, async () => {
-            cli({
-                site,
-                name: 'legacy',
-                access: 'read',
-                description: 'legacy command',
-            });
-            return {};
-        });
-        expect(entries).toMatchObject([
-            {
-                site,
-                name: 'legacy',
-                access: 'read',
-                description: 'legacy command',
-                strategy: 'cookie',
-                browser: true,
-                args: [],
-                type: 'js',
-                modulePath: `${site}/${site}.js`,
-            },
-        ]);
-        // Verify sourceFile is included
-        expect(entries[0].sourceFile).toBeDefined();
-        getRegistry().delete(key);
-    });
-    it('keeps every command a module exports instead of guessing by site', async () => {
-        const site = `manifest-multi-${Date.now()}`;
-        const screenKey = `${site}/screen`;
-        const statusKey = `${site}/status`;
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-manifest-'));
-        tempDirs.push(dir);
-        const file = path.join(dir, `${site}.ts`);
-        fs.writeFileSync(file, `export const screen = cli({ site: '${site}', name: 'screen', access: 'read' });`);
-        const entries = await loadManifestEntries(file, site, async () => ({
-            screen: cli({
-                site,
-                name: 'screen',
-                access: 'read',
-                description: 'capture screen',
-            }),
-            status: cli({
-                site,
-                name: 'status',
-                access: 'read',
-                description: 'show status',
-            }),
-        }));
-        expect(entries.map(entry => entry.name)).toEqual(['screen', 'status']);
-        getRegistry().delete(screenKey);
-        getRegistry().delete(statusKey);
-    });
-    it('normalizes manifest paths to POSIX separators', () => {
-        expect(normalizeManifestPath('demo\\status.js')).toBe('demo/status.js');
-        expect(normalizeManifestPath('demo/status.js')).toBe('demo/status.js');
-    });
-    it('serializes manifest json with a trailing newline', () => {
-        const serialized = serializeManifest([{
-                site: 'demo',
-                name: 'status', access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [],
-                type: 'js',
-            }]);
-        expect(serialized.endsWith('\n')).toBe(true);
-        expect(serialized).toContain('\n]');
-    });
-    it('throws ManifestImportError when an adapter looks like a CLI module but fails to import', async () => {
-        // Reproduces the "stale dist drops adapters silently" incident: the file
-        // matches the cli() pattern (so it's not just a helper), but the importer
-        // throws — we want the failure surfaced, not swallowed.
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-manifest-fail-'));
-        tempDirs.push(dir);
-        const file = path.join(dir, 'broken.ts');
-        fs.writeFileSync(file, `export const command = cli({ site: 'demo', name: 'broken', access: 'read' });`);
-        const importer = async () => { throw new Error('boom: stale dist'); };
-        await expect(loadManifestEntries(file, 'demo', importer))
-            .rejects.toBeInstanceOf(ManifestImportError);
-        try {
-            await loadManifestEntries(file, 'demo', importer);
-        }
-        catch (err) {
-            expect(err).toBeInstanceOf(ManifestImportError);
-            const e = err;
-            expect(e.filePath).toBe(file);
-            expect(e.message).toContain('boom: stale dist');
-        }
-    });
-    it('still silently skips files that do not call cli() even if the importer would have thrown', async () => {
-        // The cli() pattern check happens before importing — we don't even ask
-        // the importer about helper modules, so a thrown import does not turn
-        // them into failures.
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-manifest-helper-'));
-        tempDirs.push(dir);
-        const file = path.join(dir, 'helper.ts');
-        fs.writeFileSync(file, `export const helper = () => 42;`);
-        const importer = async () => { throw new Error('should never be called'); };
-        await expect(loadManifestEntries(file, 'demo', importer)).resolves.toEqual([]);
-    });
-    it('scanClisDir aggregates per-adapter import failures instead of silently dropping them', async () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-clis-'));
-        tempDirs.push(root);
-        const siteDir = path.join(root, 'demo');
-        fs.mkdirSync(siteDir);
-        fs.writeFileSync(path.join(siteDir, 'good.js'), `export const cmd = cli({ site: 'demo', name: 'good', access: 'read' });`);
-        fs.writeFileSync(path.join(siteDir, 'broken.js'), `export const cmd = cli({ site: 'demo', name: 'broken', access: 'read' });`);
-        const importer = async (href) => {
-            if (href.endsWith('broken.js'))
-                throw new Error('stale dist drops broken');
-            return { cmd: cli({ site: 'demo', name: 'good', access: 'read', description: 'ok' }) };
-        };
-        const result = await scanClisDir(root, importer);
-        expect(result.failures).toHaveLength(1);
-        expect(result.failures[0]).toBeInstanceOf(ManifestImportError);
-        expect(result.failures[0].filePath).toMatch(/broken\.js$/);
-        expect(result.failures[0].message).toContain('stale dist drops broken');
-        expect(result.entries.map(e => e.name)).toEqual(['good']);
-        getRegistry().delete('demo/good');
-    });
-    it('diffRemovedEntries returns site/name keys present only in prev', () => {
-        const prev = [
-            { site: 'a', name: '1', access: 'read', description: '', strategy: 'public', browser: false, args: [], type: 'js' },
-            { site: 'a', name: '2', access: 'read', description: '', strategy: 'public', browser: false, args: [], type: 'js' },
-            { site: 'b', name: '3', access: 'read', description: '', strategy: 'public', browser: false, args: [], type: 'js' },
-        ];
-        const next = [
-            { site: 'a', name: '1', access: 'read', description: '', strategy: 'public', browser: false, args: [], type: 'js' },
-        ];
-        expect(diffRemovedEntries(prev, next)).toEqual(['a/2', 'b/3']);
-        expect(diffRemovedEntries(prev, prev)).toEqual([]);
-        expect(diffRemovedEntries([], next)).toEqual([]);
-    });
-    it('findManifestMetadataIssues flags positionals with empty/missing help', () => {
-        // The build-time hard gate. A positional with `help: ''` or no `help` at
-        // all renders `Arguments:\n  <name>` with a blank trailing column —
-        // unrecoverable for both humans and agents reading help. Failing closed
-        // here is the only way to keep help text trustworthy as adapters land.
-        //
-        // Semantic quality (e.g. what does an *optional* positional mean when
-        // omitted?) is intentionally NOT enforced — that belongs to the planned
-        // Arg metadata v2 advisory pass.
-        const entries = [
-            // Positional with usable help — clean.
-            {
-                site: 'demo',
-                name: 'ok',
-                access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [
-                    { name: 'q', positional: true, required: true, help: 'Search query' },
-                ],
-                type: 'js',
-                sourceFile: 'demo/ok.js',
-            },
-            // Positional with empty help string — must flag.
-            {
-                site: 'demo',
-                name: 'empty-help',
-                access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [
-                    { name: 'user', positional: true, required: false, help: '' },
-                ],
-                type: 'js',
-                sourceFile: 'demo/empty.js',
-            },
-            // Positional with whitespace-only help — must flag.
-            {
-                site: 'demo',
-                name: 'whitespace-help',
-                access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [
-                    { name: 'id', positional: true, required: true, help: '   ' },
-                ],
-                type: 'js',
-            },
-            // Positional with no help field at all — must flag.
-            {
-                site: 'demo',
-                name: 'missing-help',
-                access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [
-                    { name: 'name', positional: true, required: true },
-                ],
-                type: 'js',
-            },
-            // NON-positional flag with empty help — must NOT flag (gate is
-            // intentionally scoped to positionals; named flags carry the flag
-            // name itself in the help line).
-            {
-                site: 'demo',
-                name: 'flag-only',
-                access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [
-                    { name: 'limit', required: false, help: '' },
-                ],
-                type: 'js',
-            },
-        ];
-        const issues = findManifestMetadataIssues(entries);
-        expect(issues).toHaveLength(3);
-        expect(issues.map(i => `${i.site}/${i.command}/${i.arg}`).sort()).toEqual([
-            'demo/empty-help/user',
-            'demo/missing-help/name',
-            'demo/whitespace-help/id',
-        ]);
-        // sourceFile flows through when present so the build error points at the
-        // exact file to fix.
-        const emptyHelp = issues.find(i => i.command === 'empty-help');
-        expect(emptyHelp?.sourceFile).toBe('demo/empty.js');
-    });
-    it('findManifestMetadataIssues returns [] for fully-documented entries', () => {
-        expect(findManifestMetadataIssues([])).toEqual([]);
-        expect(findManifestMetadataIssues([
-            {
-                site: 'demo',
-                name: 'no-args',
-                access: 'read',
-                description: '',
-                strategy: 'public',
-                browser: false,
-                args: [],
-                type: 'js',
-            },
-        ])).toEqual([]);
-    });
-    it('parseBuildManifestArgs reads --allow-removals[=N]', () => {
-        expect(parseBuildManifestArgs([]).allowRemovals).toBe(0);
-        expect(parseBuildManifestArgs(['--allow-removals=5']).allowRemovals).toBe(5);
-        expect(parseBuildManifestArgs(['--allow-removals=0']).allowRemovals).toBe(0);
-        // Bare flag is the explicit "I know what I'm doing" escape hatch.
-        expect(parseBuildManifestArgs(['--allow-removals']).allowRemovals).toBe(Number.POSITIVE_INFINITY);
-        // Unknown flags are ignored.
-        expect(parseBuildManifestArgs(['--something-else']).allowRemovals).toBe(0);
-    });
-});

package/dist/src/capabilityRouting.test.js

@@ -1,63 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Strategy } from './registry.js';
-import { BROWSER_ONLY_STEPS, _validateBrowserOnlyStepsAgainstRegistry, shouldUseBrowserSession } from './capabilityRouting.js';
-import { getRegisteredStepNames } from './pipeline/registry.js';
-function makeCmd(partial) {
-    return {
-        site: 'test',
-        name: 'command', access: 'read',
-        description: '',
-        args: [],
-        ...partial,
-    };
-}
-describe('shouldUseBrowserSession', () => {
-    it('skips browser session for public fetch-only pipelines', () => {
-        expect(shouldUseBrowserSession(makeCmd({
-            browser: true,
-            strategy: Strategy.PUBLIC,
-            pipeline: [{ fetch: 'https://example.com/api' }, { select: 'items' }],
-        }))).toBe(false);
-    });
-    it('keeps browser session for public pipelines with browser-only steps', () => {
-        expect(shouldUseBrowserSession(makeCmd({
-            browser: true,
-            strategy: Strategy.PUBLIC,
-            pipeline: [{ navigate: 'https://example.com' }, { evaluate: '() => []' }],
-        }))).toBe(true);
-    });
-    it('keeps browser session for non-public strategies (via normalized navigateBefore)', () => {
-        // After normalizeCommand, COOKIE strategy without domain sets navigateBefore: true
-        // (signals "needs authenticated browser context" without a specific pre-nav URL).
-        expect(shouldUseBrowserSession(makeCmd({
-            browser: true,
-            strategy: Strategy.COOKIE,
-            navigateBefore: true,
-            pipeline: [{ fetch: 'https://example.com/api' }],
-        }))).toBe(true);
-    });
-    it('keeps browser session for function adapters', () => {
-        expect(shouldUseBrowserSession(makeCmd({
-            browser: true,
-            strategy: Strategy.PUBLIC,
-            func: async () => [],
-        }))).toBe(true);
-    });
-    it('routes pipelines containing the fill step into a browser session', () => {
-        expect(shouldUseBrowserSession(makeCmd({
-            browser: true,
-            strategy: Strategy.PUBLIC,
-            pipeline: [{ navigate: 'https://example.com' }, { fill: { ref: '#q', text: 'hello' } }],
-        }))).toBe(true);
-    });
-});
-describe('BROWSER_ONLY_STEPS / pipeline registry alignment', () => {
-    it('is a subset of registered pipeline step names', () => {
-        const { extras } = _validateBrowserOnlyStepsAgainstRegistry();
-        expect(extras).toEqual([]);
-    });
-    it('includes fill (DOM-touching step added in PR #1222)', () => {
-        expect(BROWSER_ONLY_STEPS.has('fill')).toBe(true);
-        expect(getRegisteredStepNames()).toContain('fill');
-    });
-});