@sovovs/bycli 1.8.0 → 2.1.0

package/dist/src/browser/cdp-click-fixture.test.js

@@ -1,87 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { JSDOM } from 'jsdom';
-function installDom(html) {
-    const dom = new JSDOM(html, { pretendToBeVisual: true });
-    globalThis.window = dom.window;
-    globalThis.document = dom.window.document;
-    globalThis.Event = dom.window.Event;
-    globalThis.MouseEvent = dom.window.MouseEvent;
-    return dom.window.document;
-}
-function dispatchNativeMouseSequence(target) {
-    for (const type of ['mousemove', 'pointerdown', 'mousedown', 'mouseup', 'pointerup', 'click']) {
-        target.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
-    }
-}
-describe('CDP-primary click dropdown fixtures', () => {
-    afterEach(() => {
-        Reflect.deleteProperty(globalThis, 'window');
-        Reflect.deleteProperty(globalThis, 'document');
-    });
-    it('captures the Radix/shadcn class of dropdowns that open on pointerdown and select on pointerup', () => {
-        const document = installDom(`
-      <button id="trigger" role="combobox" aria-expanded="false">Category</button>
-      <div id="portal-root"></div>
-      <output id="value"></output>
-    `);
-        const trigger = document.querySelector('#trigger');
-        const portal = document.querySelector('#portal-root');
-        const value = document.querySelector('#value');
-        trigger.addEventListener('pointerdown', () => {
-            trigger.setAttribute('aria-expanded', 'true');
-            portal.innerHTML = `
-        <div role="listbox">
-          <div id="meals" role="option">Meals</div>
-        </div>
-      `;
-            portal.querySelector('#meals').addEventListener('pointerup', () => {
-                value.textContent = 'Meals';
-                trigger.textContent = 'Meals';
-                trigger.setAttribute('aria-expanded', 'false');
-            });
-        });
-        // Baseline: DOM el.click() dispatches click only. This is the old byCLI
-        // failure mode: the command reports success but the dropdown never opens.
-        trigger.click();
-        expect(trigger.getAttribute('aria-expanded')).toBe('false');
-        expect(portal.querySelector('[role="option"]')).toBeNull();
-        expect(value.textContent).toBe('');
-        // CDP-style mouse input opens the portal and can commit the option.
-        dispatchNativeMouseSequence(trigger);
-        const option = portal.querySelector('#meals');
-        expect(trigger.getAttribute('aria-expanded')).toBe('true');
-        dispatchNativeMouseSequence(option);
-        expect(value.textContent).toBe('Meals');
-        expect(trigger.textContent).toBe('Meals');
-    });
-    it('captures the MUI autocomplete class that opens on mousedown and commits on mousedown in a popper', () => {
-        const document = installDom(`
-      <label for="category">Category</label>
-      <input id="category" role="combobox" value="" />
-      <div id="mui-popper"></div>
-      <output id="value"></output>
-    `);
-        const input = document.querySelector('#category');
-        const popper = document.querySelector('#mui-popper');
-        const value = document.querySelector('#value');
-        input.addEventListener('mousedown', () => {
-            popper.innerHTML = `
-        <ul role="listbox">
-          <li id="travel" role="option">Travel</li>
-        </ul>
-      `;
-            popper.querySelector('#travel').addEventListener('mousedown', () => {
-                input.value = 'Travel';
-                value.textContent = 'Travel';
-            });
-        });
-        input.click();
-        expect(popper.querySelector('[role="option"]')).toBeNull();
-        expect(input.value).toBe('');
-        dispatchNativeMouseSequence(input);
-        const option = popper.querySelector('#travel');
-        dispatchNativeMouseSequence(option);
-        expect(input.value).toBe('Travel');
-        expect(value.textContent).toBe('Travel');
-    });
-});

package/dist/src/browser/cdp.test.js

@@ -1,79 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { MockWebSocket } = vi.hoisted(() => {
-    class MockWebSocket {
-        static OPEN = 1;
-        readyState = 1;
-        handlers = new Map();
-        constructor(_url) {
-            queueMicrotask(() => this.emit('open'));
-        }
-        on(event, handler) {
-            const handlers = this.handlers.get(event) ?? [];
-            handlers.push(handler);
-            this.handlers.set(event, handlers);
-        }
-        send(_message) { }
-        close() {
-            this.readyState = 3;
-        }
-        emit(event, ...args) {
-            for (const handler of this.handlers.get(event) ?? []) {
-                handler(...args);
-            }
-        }
-    }
-    return { MockWebSocket };
-});
-vi.mock('ws', () => ({
-    WebSocket: MockWebSocket,
-}));
-import { CDPBridge } from './cdp.js';
-describe('CDPBridge cookies', () => {
-    beforeEach(() => {
-        vi.unstubAllEnvs();
-    });
-    it('filters cookies by actual domain match instead of substring match', async () => {
-        vi.stubEnv('BYCLI_CDP_ENDPOINT', 'ws://127.0.0.1:9222/devtools/page/1');
-        const bridge = new CDPBridge();
-        vi.spyOn(bridge, 'send').mockResolvedValue({
-            cookies: [
-                { name: 'good', value: '1', domain: '.example.com' },
-                { name: 'exact', value: '2', domain: 'example.com' },
-                { name: 'bad', value: '3', domain: 'notexample.com' },
-            ],
-        });
-        const page = await bridge.connect();
-        const cookies = await page.getCookies({ domain: 'example.com' });
-        expect(cookies).toEqual([
-            { name: 'good', value: '1', domain: '.example.com' },
-            { name: 'exact', value: '2', domain: 'example.com' },
-        ]);
-    });
-    it('exposes native input helpers on direct CDP pages', async () => {
-        vi.stubEnv('BYCLI_CDP_ENDPOINT', 'ws://127.0.0.1:9222/devtools/page/1');
-        const bridge = new CDPBridge();
-        const send = vi.spyOn(bridge, 'send').mockResolvedValue({});
-        const page = await bridge.connect();
-        send.mockClear();
-        expect(page.nativeType).toBeTypeOf('function');
-        expect(page.nativeKeyPress).toBeTypeOf('function');
-        expect(page.nativeClick).toBeTypeOf('function');
-        expect(page.handleJavaScriptDialog).toBeTypeOf('function');
-        expect(page.cdp).toBeTypeOf('function');
-        await page.nativeType('hello');
-        await page.nativeKeyPress('a', ['Ctrl']);
-        await page.nativeClick(10, 20);
-        await page.handleJavaScriptDialog(true, 'ok');
-        await page.cdp('Page.getLayoutMetrics', {});
-        expect(send.mock.calls).toEqual([
-            ['Input.insertText', { text: 'hello' }],
-            ['Input.dispatchKeyEvent', { type: 'keyDown', key: 'a', modifiers: 2 }],
-            ['Input.dispatchKeyEvent', { type: 'keyUp', key: 'a', modifiers: 2 }],
-            ['Input.dispatchMouseEvent', { type: 'mouseMoved', x: 10, y: 20 }],
-            ['Input.dispatchMouseEvent', { type: 'mousePressed', x: 10, y: 20, button: 'left', clickCount: 1 }],
-            ['Input.dispatchMouseEvent', { type: 'mouseReleased', x: 10, y: 20, button: 'left', clickCount: 1 }],
-            ['Page.handleJavaScriptDialog', { accept: true, promptText: 'ok' }],
-            ['Page.getLayoutMetrics', {}],
-        ]);
-    });
-});

package/dist/src/browser/compound.test.js

@@ -1,175 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { COMPOUND_INFO_JS, COMPOUND_LABEL_CAP, COMPOUND_SELECT_OPTIONS_CAP, } from './compound.js';
-/**
- * Tests run the JS source in a sandbox via `new Function`, feeding it
- * minimal mock elements shaped like the DOM elements the real code sees
- * at runtime. Avoids a full jsdom setup while still exercising the logic
- * end-to-end instead of only snapshotting string markers.
- */
-function runCompound(mockEl) {
-    const fn = new Function('el', `${COMPOUND_INFO_JS}\nreturn compoundInfoOf(el);`);
-    return fn(mockEl);
-}
-function mockInput(attrs, extras = {}) {
-    return {
-        tagName: 'INPUT',
-        value: extras.value,
-        multiple: extras.multiple,
-        files: extras.files,
-        getAttribute(name) {
-            return attrs[name] ?? null;
-        },
-    };
-}
-function mockSelect(options, multiple = false) {
-    const opts = options.map(o => ({ ...o, selected: !!o.selected }));
-    return {
-        tagName: 'SELECT',
-        multiple,
-        options: opts,
-        getAttribute: () => null,
-    };
-}
-describe('compoundInfoOf — date-like inputs', () => {
-    it('returns { control, format, current } for <input type=date>', () => {
-        const info = runCompound(mockInput({ type: 'date' }, { value: '2026-04-21' }));
-        expect(info).toEqual({ control: 'date', format: 'YYYY-MM-DD', current: '2026-04-21' });
-    });
-    it('surfaces min + max when present', () => {
-        const info = runCompound(mockInput({ type: 'date', min: '2026-01-01', max: '2026-12-31' }, { value: '2026-04-21' }));
-        expect(info).toMatchObject({ min: '2026-01-01', max: '2026-12-31' });
-    });
-    it('handles time / datetime-local / month / week with correct format strings', () => {
-        const formats = {
-            time: 'HH:MM',
-            'datetime-local': 'YYYY-MM-DDTHH:MM',
-            month: 'YYYY-MM',
-            week: 'YYYY-W##',
-        };
-        for (const [type, fmt] of Object.entries(formats)) {
-            const info = runCompound(mockInput({ type }, { value: '' }));
-            expect(info.format).toBe(fmt);
-        }
-    });
-    it('coerces null value into empty string instead of crashing', () => {
-        const info = runCompound(mockInput({ type: 'date' }));
-        expect(info).toMatchObject({ control: 'date', current: '' });
-    });
-});
-describe('compoundInfoOf — file inputs', () => {
-    it('returns { control: file, multiple, current[] }', () => {
-        const info = runCompound(mockInput({ type: 'file' }, {
-            multiple: true,
-            files: [{ name: 'a.png' }, { name: 'b.jpg' }],
-        }));
-        expect(info).toEqual({ control: 'file', multiple: true, current: ['a.png', 'b.jpg'] });
-    });
-    it('includes accept when present', () => {
-        const info = runCompound(mockInput({ type: 'file', accept: 'image/*' }, { multiple: false }));
-        expect(info).toMatchObject({ control: 'file', accept: 'image/*' });
-    });
-    it('returns empty current[] when nothing uploaded', () => {
-        const info = runCompound(mockInput({ type: 'file' }, { multiple: false }));
-        expect(info).toEqual({ control: 'file', multiple: false, current: [] });
-    });
-    it('caps file name at COMPOUND_LABEL_CAP', () => {
-        const longName = 'x'.repeat(COMPOUND_LABEL_CAP + 50);
-        const info = runCompound(mockInput({ type: 'file' }, { multiple: false, files: [{ name: longName }] }));
-        expect(info.current[0].length).toBe(COMPOUND_LABEL_CAP);
-    });
-});
-describe('compoundInfoOf — select', () => {
-    it('returns full options list with labels, values, selected flag', () => {
-        const info = runCompound(mockSelect([
-            { value: 'us', label: 'United States', selected: true },
-            { value: 'ca', label: 'Canada' },
-            { value: 'fr', label: 'France' },
-        ]));
-        expect(info.options).toHaveLength(3);
-        expect(info.options[0]).toEqual({ label: 'United States', value: 'us', selected: true });
-        expect(info.options[2]).toEqual({ label: 'France', value: 'fr', selected: false });
-    });
-    it('sets current to the selected label (single-select)', () => {
-        const info = runCompound(mockSelect([
-            { value: 'a', label: 'Alpha' },
-            { value: 'b', label: 'Bravo', selected: true },
-        ]));
-        expect(info).toMatchObject({ control: 'select', multiple: false, current: 'Bravo' });
-    });
-    it('sets current to an array of labels when multiple=true', () => {
-        const info = runCompound(mockSelect([
-            { value: 'a', label: 'Alpha', selected: true },
-            { value: 'b', label: 'Bravo' },
-            { value: 'c', label: 'Charlie', selected: true },
-        ], true));
-        expect(info).toMatchObject({ control: 'select', multiple: true, current: ['Alpha', 'Charlie'] });
-    });
-    it('falls back from option.label to option.text', () => {
-        const info = runCompound(mockSelect([
-            { value: 'a', text: 'FromText' },
-            { value: 'b', label: '', text: 'EmptyLabelFallback' },
-        ]));
-        expect(info.options[0].label).toBe('FromText');
-        expect(info.options[1].label).toBe('EmptyLabelFallback');
-    });
-    it('marks disabled options', () => {
-        const info = runCompound(mockSelect([
-            { value: 'a', label: 'A' },
-            { value: 'b', label: 'B', disabled: true },
-        ]));
-        expect(info.options[0].disabled).toBeUndefined();
-        expect(info.options[1].disabled).toBe(true);
-    });
-    it('caps options[] at COMPOUND_SELECT_OPTIONS_CAP but keeps true options_total', () => {
-        const big = Array.from({ length: COMPOUND_SELECT_OPTIONS_CAP + 25 }, (_, i) => ({
-            value: 'v' + i,
-            label: 'L' + i,
-        }));
-        const info = runCompound(mockSelect(big));
-        expect(info.options.length).toBe(COMPOUND_SELECT_OPTIONS_CAP);
-        expect(info.options_total).toBe(COMPOUND_SELECT_OPTIONS_CAP + 25);
-    });
-    it('returns "" for current on single-select with no selected option', () => {
-        const info = runCompound(mockSelect([
-            { value: 'a', label: 'A' },
-            { value: 'b', label: 'B' },
-        ]));
-        expect(info).toMatchObject({ current: '' });
-    });
-    // Regression: the previous loop stopped walking options once it hit
-    // COMPOUND_SELECT_OPTIONS_CAP, so a long country dropdown with the
-    // selected country sitting at index 80 would be reported with current="".
-    // Agents then thought nothing was selected and picked another country.
-    it('populates current even when the selected option sits past the serialization cap', () => {
-        const big = Array.from({ length: COMPOUND_SELECT_OPTIONS_CAP + 25 }, (_, i) => ({
-            value: 'v' + i,
-            label: 'L' + i,
-            selected: i === COMPOUND_SELECT_OPTIONS_CAP + 10,
-        }));
-        const info = runCompound(mockSelect(big));
-        expect(info.current).toBe('L' + (COMPOUND_SELECT_OPTIONS_CAP + 10));
-        expect(info.options.length).toBe(COMPOUND_SELECT_OPTIONS_CAP);
-        expect(info.options_total).toBe(COMPOUND_SELECT_OPTIONS_CAP + 25);
-    });
-    it('multi-select: current[] includes labels for selected options beyond the cap', () => {
-        const big = Array.from({ length: COMPOUND_SELECT_OPTIONS_CAP + 10 }, (_, i) => ({
-            value: 'v' + i,
-            label: 'L' + i,
-            selected: i === 3 || i === COMPOUND_SELECT_OPTIONS_CAP + 5,
-        }));
-        const info = runCompound(mockSelect(big, true));
-        expect(info.current).toEqual(['L3', 'L' + (COMPOUND_SELECT_OPTIONS_CAP + 5)]);
-    });
-});
-describe('compoundInfoOf — unsupported shapes', () => {
-    it('returns null for plain text input', () => {
-        expect(runCompound(mockInput({ type: 'text' }, { value: 'hi' }))).toBeNull();
-    });
-    it('returns null for non-form tags', () => {
-        expect(runCompound({ tagName: 'DIV', getAttribute: () => null })).toBeNull();
-    });
-    it('returns null for null / missing element', () => {
-        expect(runCompound(null)).toBeNull();
-        expect(runCompound({})).toBeNull();
-    });
-});

package/dist/src/browser/daemon-client.test.js

@@ -1,199 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown, sendCommand, } from './daemon-client.js';
-describe('daemon-client', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-        vi.unstubAllEnvs();
-    });
-    it('fetchDaemonStatus sends the shared status request and returns parsed data', async () => {
-        const status = {
-            ok: true,
-            pid: 123,
-            uptime: 10,
-            extensionConnected: true,
-            extensionVersion: '1.2.3',
-            pending: 0,
-            memoryMB: 32,
-            port: 19825,
-        };
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(status),
-        });
-        await expect(fetchDaemonStatus()).resolves.toEqual(status);
-        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/status$/), expect.objectContaining({
-            headers: expect.objectContaining({ 'X-byCLI': '1' }),
-        }));
-    });
-    it('fetchDaemonStatus returns null on network failure', async () => {
-        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
-        await expect(fetchDaemonStatus()).resolves.toBeNull();
-    });
-    it('requestDaemonShutdown POSTs to the shared shutdown endpoint', async () => {
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({ ok: true });
-        await expect(requestDaemonShutdown()).resolves.toBe(true);
-        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/shutdown$/), expect.objectContaining({
-            method: 'POST',
-            headers: expect.objectContaining({ 'X-byCLI': '1' }),
-        }));
-    });
-    it('getDaemonHealth returns stopped when daemon is not reachable', async () => {
-        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
-        await expect(getDaemonHealth()).resolves.toEqual({ state: 'stopped', status: null });
-    });
-    it('getDaemonHealth returns no-extension when daemon is running but extension disconnected', async () => {
-        const status = {
-            ok: true,
-            pid: 123,
-            uptime: 10,
-            extensionConnected: false,
-            pending: 0,
-            memoryMB: 16,
-            port: 19825,
-        };
-        vi.mocked(fetch).mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(status),
-        });
-        await expect(getDaemonHealth()).resolves.toEqual({ state: 'no-extension', status });
-    });
-    it('getDaemonHealth returns ready when daemon and extension are both connected', async () => {
-        const status = {
-            ok: true,
-            pid: 123,
-            uptime: 10,
-            extensionConnected: true,
-            extensionVersion: '1.2.3',
-            pending: 0,
-            memoryMB: 32,
-            port: 19825,
-        };
-        vi.mocked(fetch).mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(status),
-        });
-        await expect(getDaemonHealth()).resolves.toEqual({ state: 'ready', status });
-    });
-    it('getDaemonHealth returns profile-required when multiple profiles are connected without a selection', async () => {
-        const status = {
-            ok: true,
-            pid: 123,
-            uptime: 10,
-            extensionConnected: false,
-            profileRequired: true,
-            profiles: [
-                { contextId: 'work', extensionConnected: true, pending: 0 },
-                { contextId: 'personal', extensionConnected: true, pending: 0 },
-            ],
-            pending: 0,
-            memoryMB: 32,
-            port: 19825,
-        };
-        vi.mocked(fetch).mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(status),
-        });
-        await expect(getDaemonHealth()).resolves.toEqual({ state: 'profile-required', status });
-    });
-    it('fetchDaemonStatus includes contextId in the status query', async () => {
-        vi.mocked(fetch).mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({
-                ok: true,
-                pid: 1,
-                uptime: 0,
-                extensionConnected: true,
-                pending: 0,
-                memoryMB: 1,
-                port: 19825,
-            }),
-        });
-        await fetchDaemonStatus({ contextId: 'work' });
-        expect(vi.mocked(fetch).mock.calls[0][0]).toMatch(/\/status\?contextId=work$/);
-    });
-    it('sendCommand includes the current pid in generated command ids', async () => {
-        vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_000);
-        vi.mocked(fetch).mockResolvedValue({
-            status: 200,
-            json: () => Promise.resolve({ id: 'server', ok: true, data: 'ok' }),
-        });
-        await expect(sendCommand('exec', { code: '1 + 1' })).resolves.toBe('ok');
-        await expect(sendCommand('exec', { code: '2 + 2' })).resolves.toBe('ok');
-        const ids = vi.mocked(fetch).mock.calls.map(([, init]) => {
-            const body = JSON.parse(String(init?.body));
-            return body.id;
-        });
-        expect(ids).toHaveLength(2);
-        expect(ids[0]).toMatch(new RegExp(`^cmd_${process.pid}_1763000000000_\\d+$`));
-        expect(ids[1]).toMatch(new RegExp(`^cmd_${process.pid}_1763000000000_\\d+$`));
-        expect(ids[0]).not.toBe(ids[1]);
-    });
-    it('sendCommand forwards BYCLI_PROFILE as command contextId', async () => {
-        vi.stubEnv('BYCLI_PROFILE', 'work');
-        vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_000);
-        vi.mocked(fetch).mockResolvedValue({
-            status: 200,
-            json: () => Promise.resolve({ id: 'server', ok: true, data: 'ok' }),
-        });
-        await sendCommand('exec', { code: '1 + 1' });
-        const body = JSON.parse(String(vi.mocked(fetch).mock.calls[0][1]?.body));
-        expect(body.contextId).toBe('work');
-    });
-    it('sendCommand uses explicit windowMode before BYCLI_WINDOW env fallback', async () => {
-        vi.stubEnv('BYCLI_WINDOW', 'foreground');
-        vi.mocked(fetch).mockResolvedValue({
-            status: 200,
-            json: () => Promise.resolve({ id: 'server', ok: true, data: 'ok' }),
-        });
-        await sendCommand('exec', { code: '1 + 1', windowMode: 'background' });
-        const body = JSON.parse(String(vi.mocked(fetch).mock.calls[0][1]?.body));
-        expect(body.windowMode).toBe('background');
-    });
-    it('sendCommand retries with a new id when daemon reports a duplicate pending id', async () => {
-        vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_123);
-        const fetchMock = vi.mocked(fetch);
-        fetchMock
-            .mockResolvedValueOnce({
-            ok: false,
-            status: 409,
-            json: () => Promise.resolve({ ok: false, error: 'Duplicate command id already pending; retry' }),
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: () => Promise.resolve({ id: 'server', ok: true, data: 42 }),
-        });
-        await expect(sendCommand('exec', { code: '6 * 7' })).resolves.toBe(42);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        const ids = fetchMock.mock.calls.map(([, init]) => {
-            const body = JSON.parse(String(init?.body));
-            return body.id;
-        });
-        expect(ids[0]).not.toBe(ids[1]);
-    });
-    it('sendCommand does not retry command_result_unknown even when the message looks transient', async () => {
-        const fetchMock = vi.mocked(fetch);
-        fetchMock.mockResolvedValue({
-            ok: false,
-            status: 503,
-            json: () => Promise.resolve({
-                id: 'server',
-                ok: false,
-                errorCode: 'command_result_unknown',
-                error: 'Extension disconnected after command timeout',
-                errorHint: 'Inspect state before retrying.',
-            }),
-        });
-        await expect(sendCommand('exec', { code: 'window.__mutate = true' })).rejects.toMatchObject({
-            name: 'BrowserCommandError',
-            code: 'command_result_unknown',
-            hint: 'Inspect state before retrying.',
-        });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/src/browser/dom-helpers.test.js

@@ -1,106 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { autoScrollJs, waitForCaptureJs, waitForSelectorJs } from './dom-helpers.js';
-describe('autoScrollJs', () => {
-    it('returns early without error when document.body is null', async () => {
-        const g = globalThis;
-        const origDoc = g.document;
-        g.document = { body: null, documentElement: {} };
-        g.window = g;
-        const code = autoScrollJs(3, 500);
-        // Should resolve without throwing
-        await expect(eval(code)).resolves.not.toThrow();
-        g.document = origDoc;
-        delete g.window;
-    });
-});
-describe('waitForCaptureJs', () => {
-    it('returns a non-empty string', () => {
-        const code = waitForCaptureJs(1000);
-        expect(typeof code).toBe('string');
-        expect(code.length).toBeGreaterThan(0);
-        expect(code).toContain('__bycli_xhr');
-        expect(code).toContain('resolve');
-        expect(code).toContain('reject');
-    });
-    it('resolves "captured" when __bycli_xhr is populated before deadline', async () => {
-        const g = globalThis;
-        const captured = [];
-        g.__bycli_xhr = captured;
-        g.window = g; // stub window for Node eval
-        const code = waitForCaptureJs(1000);
-        const promise = eval(code);
-        captured.push({ data: 'test' });
-        await expect(promise).resolves.toBe('captured');
-        delete g.__bycli_xhr;
-        delete g.window;
-    });
-    it('rejects when __bycli_xhr stays empty past deadline', async () => {
-        const g = globalThis;
-        g.__bycli_xhr = [];
-        g.window = g;
-        const code = waitForCaptureJs(50); // 50ms timeout
-        const promise = eval(code);
-        await expect(promise).rejects.toThrow('No network capture within 0.05s');
-        delete g.__bycli_xhr;
-        delete g.window;
-    });
-    it('resolves immediately when __bycli_xhr already has data', async () => {
-        const g = globalThis;
-        g.__bycli_xhr = [{ data: 'already here' }];
-        g.window = g;
-        const code = waitForCaptureJs(1000);
-        await expect(eval(code)).resolves.toBe('captured');
-        delete g.__bycli_xhr;
-        delete g.window;
-    });
-});
-describe('waitForSelectorJs', () => {
-    it('returns a non-empty string', () => {
-        const code = waitForSelectorJs('#app', 1000);
-        expect(typeof code).toBe('string');
-        expect(code).toContain('#app');
-        expect(code).toContain('querySelector');
-        expect(code).toContain('MutationObserver');
-    });
-    it('resolves "found" immediately when selector already present', async () => {
-        const g = globalThis;
-        const fakeEl = { tagName: 'DIV' };
-        g.document = { querySelector: (_) => fakeEl };
-        const code = waitForSelectorJs('[data-testid="primaryColumn"]', 1000);
-        await expect(eval(code)).resolves.toBe('found');
-        delete g.document;
-    });
-    it('resolves "found" when selector appears after DOM mutation', async () => {
-        const g = globalThis;
-        let mutationCallback;
-        g.MutationObserver = class {
-            constructor(cb) { mutationCallback = cb; }
-            observe() { }
-            disconnect() { }
-        };
-        let calls = 0;
-        g.document = {
-            querySelector: (_) => (calls++ > 0 ? { tagName: 'DIV' } : null),
-            body: {},
-        };
-        const code = waitForSelectorJs('#app', 1000);
-        const promise = eval(code);
-        mutationCallback(); // simulate DOM mutation
-        await expect(promise).resolves.toBe('found');
-        delete g.document;
-        delete g.MutationObserver;
-    });
-    it('rejects when selector never appears within timeout', async () => {
-        const g = globalThis;
-        g.MutationObserver = class {
-            constructor(_cb) { }
-            observe() { }
-            disconnect() { }
-        };
-        g.document = { querySelector: (_) => null, body: {} };
-        const code = waitForSelectorJs('#missing', 50);
-        await expect(eval(code)).rejects.toThrow('Selector not found: #missing');
-        delete g.document;
-        delete g.MutationObserver;
-    });
-});