@sovovs/bycli 1.8.0 → 2.0.0

package/clis/boss/chatmsg.test.js

@@ -1,230 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './chatmsg.js';
-
-const BOSS_FRIEND = {
-    uid: 12345,
-    encryptUid: 'enc-boss-uid',
-    securityId: 'boss-sec-id',
-    name: '候选人甲',
-};
-const BOSS_MSGS = [
-    { type: 1, text: 'Hello', from: { uid: 99999, name: 'HR' }, time: 1704067200000 },
-    { type: 1, text: '感谢', from: { uid: 12345, name: '候选人甲' }, time: 1704067201000 },
-];
-
-const GEEK_FRIEND_LABEL = {
-    friendId: 11111,
-    encryptFriendId: 'enc-geek-uid',
-    name: 'Boss张',
-    brandName: '公司A',
-};
-const GEEK_FRIEND_ENRICHED = {
-    friendId: 11111,
-    uid: 67890,
-    encryptUid: 'enc-geek-uid',
-    securityId: 'geek-sec-id',
-    name: 'Boss张',
-};
-const GEEK_MSGS = [
-    { type: 1, text: '欢迎投递', received: true, time: 1704067200000, from: { uid: 67890, name: 'Boss张' } },
-    { type: 1, text: '谢谢', received: true, time: 1704067201000, from: { uid: 99999, name: '我' } },
-];
-
-function createPageMock(evaluateImpl) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockImplementation(evaluateImpl),
-    };
-}
-
-describe('boss chatmsg', () => {
-    const command = getRegistry().get('boss/chatmsg');
-
-    it('rejects empty uid before navigating', async () => {
-        const page = createPageMock(async () => ({}));
-        await expect(
-            command.func(page, { uid: ' ', page: 1, side: 'geek' })
-        ).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('rejects invalid --page before navigating', async () => {
-        const page = createPageMock(async () => ({}));
-        await expect(
-            command.func(page, { uid: 'enc-geek-uid', page: 0, side: 'geek' })
-        ).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('--side boss preserves existing behavior', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('getBossFriendListV2')) {
-                return { code: 0, zpData: { friendList: [BOSS_FRIEND] } };
-            }
-            if (script.includes('boss/historyMsg')) {
-                return { code: 0, zpData: { messages: BOSS_MSGS } };
-            }
-            return {};
-        });
-        const rows = await command.func(page, { uid: 'enc-boss-uid', page: 1, side: 'boss' });
-        expect(page.goto).toHaveBeenCalledWith(expect.stringContaining('/web/chat/index'));
-        expect(rows).toHaveLength(2);
-        expect(rows[0].from).toBe('我');
-        expect(rows[1].from).toBe('候选人甲');
-    });
-
-    it('--side geek calls historyMsg with bossId, securityId, page, c=20, src=0', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('document.cookie')) return 'test-enc-sys-id';
-            if (script.includes('geekFilterByLabel')) {
-                return { code: 0, zpData: { friendList: [GEEK_FRIEND_LABEL] } };
-            }
-            if (script.includes('getGeekFriendList.json')) {
-                return { code: 0, zpData: { result: [GEEK_FRIEND_ENRICHED] } };
-            }
-            if (script.includes('geek/historyMsg')) {
-                return { code: 0, zpData: { messages: GEEK_MSGS } };
-            }
-            return {};
-        });
-        await command.func(page, { uid: 'enc-geek-uid', page: 1, side: 'geek' });
-        const historyScript = page.evaluate.mock.calls.find((c) => c[0].includes('geek/historyMsg'))?.[0];
-        expect(historyScript).toBeDefined();
-        expect(historyScript).toContain('bossId=67890');
-        expect(historyScript).toContain('securityId=');
-        expect(historyScript).toContain('page=1');
-        expect(historyScript).toContain('c=20');
-        expect(historyScript).toContain('src=0');
-    });
-
-    it('--side geek uses from.uid to determine direction, not received flag', async () => {
-        // Both messages have received:true (mirrors real geek historyMsg API behaviour)
-        // Direction is determined by whether m.from.uid matches the boss's uid (67890)
-        const msgsAllReceived = [
-            { type: 1, text: '欢迎投递', received: true, time: 1704067200000, from: { uid: 67890, name: 'Boss张' } },
-            { type: 1, text: '谢谢', received: true, time: 1704067201000, from: { uid: 99999, name: '我' } },
-        ];
-        const page = createPageMock(async (script) => {
-            if (script.includes('document.cookie')) return 'test-enc-sys-id';
-            if (script.includes('geekFilterByLabel')) {
-                return { code: 0, zpData: { friendList: [GEEK_FRIEND_LABEL] } };
-            }
-            if (script.includes('getGeekFriendList.json')) {
-                return { code: 0, zpData: { result: [GEEK_FRIEND_ENRICHED] } };
-            }
-            if (script.includes('geek/historyMsg')) {
-                return { code: 0, zpData: { messages: msgsAllReceived } };
-            }
-            return {};
-        });
-        const rows = await command.func(page, { uid: 'enc-geek-uid', page: 1, side: 'geek' });
-        // from.uid=67890 matches friend.uid=67890 → boss sent it → '对方'
-        expect(rows[0].from).toBe('对方');
-        // from.uid=99999 does not match → geek sent it → '我'
-        expect(rows[1].from).toBe('我');
-    });
-
-    it('non-text message body does not crash and produces truncated JSON', async () => {
-        const nonTextMsg = { type: 99, received: true, time: 1704067200000, body: { action: 'resume_request', detail: 'X' } };
-        const page = createPageMock(async (script) => {
-            if (script.includes('document.cookie')) return 'test-enc-sys-id';
-            if (script.includes('geekFilterByLabel')) {
-                return { code: 0, zpData: { friendList: [GEEK_FRIEND_LABEL] } };
-            }
-            if (script.includes('getGeekFriendList.json')) {
-                return { code: 0, zpData: { result: [GEEK_FRIEND_ENRICHED] } };
-            }
-            if (script.includes('geek/historyMsg')) {
-                return { code: 0, zpData: { messages: [nonTextMsg] } };
-            }
-            return {};
-        });
-        const rows = await command.func(page, { uid: 'enc-geek-uid', page: 1, side: 'geek' });
-        expect(rows).toHaveLength(1);
-        expect(rows[0].text).toContain('resume_request');
-    });
-
-    it('--side auto falls back to geek when recruiter returns code 24', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('getBossFriendListV2')) {
-                return { code: 24, message: '请切换身份后再试' };
-            }
-            if (script.includes('document.cookie')) return 'test-enc-sys-id';
-            if (script.includes('geekFilterByLabel')) {
-                return { code: 0, zpData: { friendList: [GEEK_FRIEND_LABEL] } };
-            }
-            if (script.includes('getGeekFriendList.json')) {
-                return { code: 0, zpData: { result: [GEEK_FRIEND_ENRICHED] } };
-            }
-            if (script.includes('geek/historyMsg')) {
-                return { code: 0, zpData: { messages: GEEK_MSGS } };
-            }
-            return {};
-        });
-        const rows = await command.func(page, { uid: 'enc-geek-uid', page: 1, side: 'auto' });
-        expect(rows).toHaveLength(2);
-        expect(rows[0].from).toBe('对方');
-    });
-
-    it('--side geek throws when uid is not found in geek chat list', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('document.cookie')) return 'test-enc-sys-id';
-            if (script.includes('geekFilterByLabel')) {
-                return { code: 0, zpData: { friendList: [] } };
-            }
-            return {};
-        });
-        await expect(
-            command.func(page, { uid: 'unknown-uid', page: 1, side: 'geek' })
-        ).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('--side boss maps expired cookies to AuthRequiredError', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('getBossFriendListV2')) {
-                return { code: 7, message: 'Cookie 已过期' };
-            }
-            return {};
-        });
-        await expect(
-            command.func(page, { uid: 'enc-boss-uid', page: 1, side: 'boss' })
-        ).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('--side boss treats missing history list as parser drift', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('getBossFriendListV2')) {
-                return { code: 0, zpData: { friendList: [BOSS_FRIEND] } };
-            }
-            if (script.includes('boss/historyMsg')) {
-                return { code: 0, zpData: {} };
-            }
-            return {};
-        });
-        await expect(
-            command.func(page, { uid: 'enc-boss-uid', page: 1, side: 'boss' })
-        ).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('--side geek reports an empty history as EmptyResultError', async () => {
-        const page = createPageMock(async (script) => {
-            if (script.includes('document.cookie')) return 'test-enc-sys-id';
-            if (script.includes('geekFilterByLabel')) {
-                return { code: 0, zpData: { friendList: [GEEK_FRIEND_LABEL] } };
-            }
-            if (script.includes('getGeekFriendList.json')) {
-                return { code: 0, zpData: { result: [GEEK_FRIEND_ENRICHED] } };
-            }
-            if (script.includes('geek/historyMsg')) {
-                return { code: 0, zpData: { messages: [] } };
-            }
-            return {};
-        });
-        await expect(
-            command.func(page, { uid: 'enc-geek-uid', page: 1, side: 'geek' })
-        ).rejects.toBeInstanceOf(EmptyResultError);
-    });
-});

package/clis/boss/search.test.js

@@ -1,78 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError } from '@sovovs/bycli/errors';
-import { __test__ } from './search.js';
-import './search.js';
-
-function createPageMock(response) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(response),
-    };
-}
-
-describe('boss search', () => {
-    const command = getRegistry().get('boss/search');
-
-    it('keeps legacy 在校/应届 experience input compatible', () => {
-        expect(__test__.resolveMap('在校/应届', __test__.EXP_MAP)).toBe('108');
-        expect(__test__.resolveMap('应届', __test__.EXP_MAP)).toBe('102');
-    });
-
-    it('fails fast on invalid jobType values', async () => {
-        expect(() => __test__.resolveJobType('外包')).toThrow(ArgumentError);
-    });
-
-    it('accepts supported jobType labels and raw codes', () => {
-        expect(__test__.resolveJobType('全职')).toBe('1901');
-        expect(__test__.resolveJobType('实习')).toBe('1902');
-        expect(__test__.resolveJobType('兼职')).toBe('1903');
-        expect(__test__.resolveJobType('1902')).toBe('1902');
-    });
-
-    it('keeps empty query empty and sends jobType filter to the API', async () => {
-        const page = createPageMock({
-            code: 0,
-            zpData: {
-                hasMore: false,
-                jobList: [
-                    {
-                        encryptJobId: 'abc',
-                        securityId: 'sec',
-                        jobName: '前端开发实习生',
-                        salaryDesc: '150-200/天',
-                        brandName: 'byCLI',
-                        cityName: '北京',
-                        areaDistrict: '海淀区',
-                        businessDistrict: '',
-                        jobExperience: '在校/应届',
-                        jobDegree: '本科',
-                        skills: ['JavaScript'],
-                        bossName: '张三',
-                        bossTitle: '技术负责人',
-                        bossOnline: false,
-                    },
-                ],
-            },
-        });
-
-        const rows = await command.func(page, {
-            query: undefined,
-            city: '北京',
-            jobType: '实习',
-            limit: 1,
-            page: 1,
-        });
-
-        expect(page.goto).toHaveBeenCalledWith('https://www.zhipin.com/web/geek/job?query=&city=101010100');
-        const fetchScript = page.evaluate.mock.calls.at(-1)[0];
-        expect(fetchScript).toContain('query=');
-        expect(fetchScript).not.toContain('query=undefined');
-        expect(fetchScript).toContain('jobType=1902');
-        expect(rows[0]).toMatchObject({
-            name: '前端开发实习生',
-            bossOnline: 'N',
-        });
-    });
-});

package/clis/boss/utils.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { assertOk } from './utils.js';
-
-describe('assertOk', () => {
-    it('returns silently on code 0', () => {
-        expect(() => assertOk({ code: 0 })).not.toThrow();
-    });
-
-    it('maps expired cookie codes (7, 37) to AuthRequiredError', () => {
-        expect(() => assertOk({ code: 7, message: 'expired' })).toThrow(AuthRequiredError);
-        expect(() => assertOk({ code: 37, message: 'expired' })).toThrow(AuthRequiredError);
-    });
-
-    it('maps code 24 (identity mismatch) to AuthRequiredError with recruiter-only hint', () => {
-        try {
-            assertOk({ code: 24, message: '请切换身份后再试' });
-            throw new Error('assertOk should have thrown');
-        } catch (err) {
-            expect(err).toBeInstanceOf(AuthRequiredError);
-            expect(String(err.message)).toContain('招聘端');
-        }
-    });
-
-    it('falls through to CommandExecutionError for other non-zero codes', () => {
-        expect(() => assertOk({ code: 99, message: 'something else' }))
-            .toThrow(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError on malformed (non-object) response', () => {
-        expect(() => assertOk(null)).toThrow(CommandExecutionError);
-        expect(() => assertOk('not-an-object')).toThrow(CommandExecutionError);
-    });
-});

package/clis/brave/search.test.js

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-
-const { __test__ } = await import('./search.js');
-const command = __test__.command;
-
-function createPageMock(evaluateResult = []) {
-  return {
-    goto: vi.fn().mockResolvedValue(undefined),
-    wait: vi.fn().mockResolvedValue(undefined),
-    evaluate: vi.fn().mockResolvedValue(evaluateResult),
-  };
-}
-
-describe('brave search', () => {
-  it('should register as a valid command', () => {
-    expect(command).toBeDefined();
-    expect(command.site).toBe('brave');
-    expect(command.name).toBe('search');
-    expect(command.access).toBe('read');
-    expect(command.browser).toBe(true);
-    expect(command.strategy).toBe('public');
-    expect(command.domain).toBe('search.brave.com');
-  });
-
-  it('should define keyword positional arg', () => {
-    const kwArg = command.args.find(a => a.name === 'keyword');
-    expect(kwArg).toBeDefined();
-    expect(kwArg.positional).toBe(true);
-    expect(kwArg.required).toBe(true);
-  });
-
-  it('should define limit arg with default 10', () => {
-    const limitArg = command.args.find(a => a.name === 'limit');
-    expect(limitArg).toBeDefined();
-    expect(limitArg.type).toBe('int');
-    expect(limitArg.default).toBe(10);
-  });
-
-  it('should define output columns', () => {
-    expect(command.columns).toContain('rank');
-    expect(command.columns).toContain('title');
-    expect(command.columns).toContain('url');
-    expect(command.columns).toContain('snippet');
-  });
-
-  it('rejects empty query, invalid limit, and invalid offset before navigation', async () => {
-    const page = createPageMock();
-    await expect(command.func(page, { keyword: '', limit: 5 })).rejects.toMatchObject({ code: 'ARGUMENT' });
-    await expect(command.func(page, { keyword: 'bycli', limit: 19 })).rejects.toMatchObject({ code: 'ARGUMENT' });
-    await expect(command.func(page, { keyword: 'bycli', limit: 5, offset: -1 })).rejects.toMatchObject({ code: 'ARGUMENT' });
-    expect(page.goto).not.toHaveBeenCalled();
-  });
-
-  it('unwraps browser envelopes and returns ranked HTTPS rows', async () => {
-    const page = createPageMock({
-      session: 'site:brave',
-      data: [['byCLI', 'https://github.com/sovovs/byCLI', 'CLI browser tooling']],
-    });
-
-    await expect(command.func(page, { keyword: 'bycli', limit: 1, offset: 1 })).resolves.toEqual([{
-      rank: 19,
-      title: 'byCLI',
-      url: 'https://github.com/sovovs/byCLI',
-      snippet: 'CLI browser tooling',
-    }]);
-  });
-
-  it('fails typed instead of silently returning [] for malformed extraction payloads', async () => {
-    const page = createPageMock({ rows: [] });
-
-    await expect(command.func(page, { keyword: 'bycli', limit: 1 })).rejects.toMatchObject({
-      code: 'COMMAND_EXEC',
-      message: expect.stringContaining('payload shape'),
-    });
-  });
-});

package/clis/chaoxing/utils.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatTimestamp, workStatusLabel } from './utils.js';
-function localDatePrefixFromMillis(ts) {
-    const d = new Date(ts);
-    const yyyy = d.getFullYear();
-    const mm = String(d.getMonth() + 1).padStart(2, '0');
-    const dd = String(d.getDate()).padStart(2, '0');
-    return `${yyyy}-${mm}-${dd}`;
-}
-describe('formatTimestamp', () => {
-    it('formats millisecond timestamp', () => {
-        const ts = new Date('2026-01-15T00:30:00Z').getTime();
-        const result = formatTimestamp(ts);
-        expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(ts)}\\s`));
-    });
-    it('formats second timestamp', () => {
-        const millis = new Date('2026-06-01T12:00:00Z').getTime();
-        const ts = Math.floor(millis / 1000);
-        const result = formatTimestamp(ts);
-        expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(millis)}\\s`));
-    });
-    it('returns empty for null/undefined/0', () => {
-        expect(formatTimestamp(null)).toBe('');
-        expect(formatTimestamp(undefined)).toBe('');
-        expect(formatTimestamp(0)).toBe('');
-        expect(formatTimestamp('')).toBe('');
-    });
-    it('passes through readable date strings', () => {
-        expect(formatTimestamp('2026-03-20 23:59')).toBe('2026-03-20 23:59');
-    });
-});
-describe('workStatusLabel', () => {
-    it('maps numeric status codes', () => {
-        expect(workStatusLabel(0)).toBe('未交');
-        expect(workStatusLabel(1)).toBe('已交');
-        expect(workStatusLabel(2)).toBe('已批阅');
-    });
-    it('passes through string status', () => {
-        expect(workStatusLabel('已交')).toBe('已交');
-    });
-    it('returns 未知 for empty/null', () => {
-        expect(workStatusLabel(null)).toBe('未知');
-        expect(workStatusLabel('')).toBe('未知');
-    });
-});

package/clis/chatgpt/commands.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './ask.js';
-import './send.js';
-import './read.js';
-import './history.js';
-import './detail.js';
-import './new.js';
-import './status.js';
-import './image.js';
-
-describe('chatgpt browser command registration', () => {
-    it('registers the baseline web chat commands with persistent site sessions', () => {
-        const expectedAccess = {
-            ask: 'write',
-            send: 'write',
-            read: 'read',
-            history: 'read',
-            detail: 'read',
-            new: 'read',
-            status: 'read',
-            image: 'write',
-        };
-
-        for (const [name, access] of Object.entries(expectedAccess)) {
-            const cmd = getRegistry().get(`chatgpt/${name}`);
-            expect(cmd, `chatgpt/${name}`).toBeDefined();
-            expect(cmd.site).toBe('chatgpt');
-            expect(cmd.domain).toBe('chatgpt.com');
-            expect(cmd.strategy).toBe('cookie');
-            expect(cmd.browser).toBe(true);
-            expect(cmd.siteSession).toBe('persistent');
-            expect(cmd.navigateBefore).toBe(false);
-            expect(cmd.access).toBe(access);
-        }
-    });
-
-    it('keeps ask timeout as the runtime-visible integer timeout arg', () => {
-        const ask = getRegistry().get('chatgpt/ask');
-        expect(ask.args).toEqual(expect.arrayContaining([
-            expect.objectContaining({ name: 'timeout', type: 'int', default: 120 }),
-            expect.objectContaining({ name: 'new', type: 'boolean', default: false }),
-        ]));
-    });
-});

package/clis/chatgpt/envelope.test.js

@@ -1,108 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CommandExecutionError } from '@sovovs/bycli/errors';
-import {
-    requireArrayEvaluateResult,
-    requireBooleanEvaluateResult,
-    requireObjectEvaluateResult,
-    unwrapEvaluateResult,
-} from './utils.js';
-
-describe('chatgpt page.evaluate envelope helpers', () => {
-    describe('unwrapEvaluateResult', () => {
-        it('unwraps a { session, data } envelope produced by the browser bridge', () => {
-            const envelope = { session: 'site:chatgpt:abc', data: [{ id: 'msg-1' }] };
-            expect(unwrapEvaluateResult(envelope)).toEqual([{ id: 'msg-1' }]);
-        });
-
-        it('passes raw arrays through unchanged (back-compat with older bridge versions)', () => {
-            const raw = [1, 2, 3];
-            expect(unwrapEvaluateResult(raw)).toBe(raw);
-        });
-
-        it('passes primitive return values (URL strings, booleans) through unchanged', () => {
-            expect(unwrapEvaluateResult('https://chatgpt.com/c/abc')).toBe('https://chatgpt.com/c/abc');
-            expect(unwrapEvaluateResult(true)).toBe(true);
-            expect(unwrapEvaluateResult(0)).toBe(0);
-        });
-
-        it('passes plain non-envelope objects through unchanged', () => {
-            const obj = { ok: true, reason: 'all good' };
-            expect(unwrapEvaluateResult(obj)).toBe(obj);
-        });
-
-        it('handles null and undefined defensively', () => {
-            expect(unwrapEvaluateResult(null)).toBe(null);
-            expect(unwrapEvaluateResult(undefined)).toBe(undefined);
-        });
-    });
-
-    describe('requireArrayEvaluateResult', () => {
-        it('returns the payload when it is an array', () => {
-            const rows = [{ id: 1 }, { id: 2 }];
-            expect(requireArrayEvaluateResult(rows, 'chatgpt test')).toBe(rows);
-        });
-
-        it('throws a typed CommandExecutionError when the payload is the raw envelope (caller forgot to unwrap)', () => {
-            const envelope = { session: 'site:chatgpt:abc', data: [{ id: 1 }] };
-            expect(() => requireArrayEvaluateResult(envelope, 'chatgpt visible image url extraction'))
-                .toThrowError(CommandExecutionError);
-            expect(() => requireArrayEvaluateResult(envelope, 'chatgpt visible image url extraction'))
-                .toThrow(/malformed extraction payload/);
-        });
-
-        it('surfaces the inner error message when the payload carries an `error` field', () => {
-            const errPayload = { error: 'image generator returned 500' };
-            expect(() => requireArrayEvaluateResult(errPayload, 'chatgpt image asset export'))
-                .toThrow(/chatgpt image asset export: image generator returned 500/);
-        });
-
-        it('throws when the payload is null or a primitive', () => {
-            expect(() => requireArrayEvaluateResult(null, 'chatgpt test')).toThrowError(CommandExecutionError);
-            expect(() => requireArrayEvaluateResult('a string', 'chatgpt test')).toThrowError(CommandExecutionError);
-        });
-    });
-
-    describe('requireObjectEvaluateResult', () => {
-        it('returns the payload when it is a plain object', () => {
-            const obj = { url: 'https://chatgpt.com', isLoggedIn: true };
-            expect(requireObjectEvaluateResult(obj, 'chatgpt page state')).toBe(obj);
-        });
-
-        it('throws when the payload is an array or a primitive', () => {
-            expect(() => requireObjectEvaluateResult([], 'chatgpt page state')).toThrowError(CommandExecutionError);
-            expect(() => requireObjectEvaluateResult('string', 'chatgpt page state')).toThrowError(CommandExecutionError);
-            expect(() => requireObjectEvaluateResult(null, 'chatgpt page state')).toThrowError(CommandExecutionError);
-        });
-    });
-
-    describe('requireBooleanEvaluateResult', () => {
-        it('returns booleans and rejects wrong-shape values', () => {
-            expect(requireBooleanEvaluateResult(true, 'chatgpt generation state')).toBe(true);
-            expect(requireBooleanEvaluateResult(false, 'chatgpt generation state')).toBe(false);
-            expect(() => requireBooleanEvaluateResult({ ok: true }, 'chatgpt generation state'))
-                .toThrowError(CommandExecutionError);
-        });
-    });
-
-    describe('end-to-end envelope sweep', () => {
-        // The bridge envelope is shaped like { session, data } where `session` is
-        // any string and `data` is the actual return value. Verify the helpers
-        // chain correctly: unwrap → require* yields the inner shape.
-        it('unwrap + requireArray pipes an envelope through to the underlying array', () => {
-            const envelope = {
-                session: 'site:chatgpt:img-export',
-                data: [
-                    { url: 'https://a.example/1.png', dataUrl: 'data:image/png;base64,xxx', mimeType: 'image/png' },
-                ],
-            };
-            expect(requireArrayEvaluateResult(unwrapEvaluateResult(envelope), 'chatgpt image asset export'))
-                .toEqual(envelope.data);
-        });
-
-        it('unwrap + requireObject pipes an envelope through to the underlying object', () => {
-            const envelope = { session: 'site:chatgpt:state', data: { url: 'https://chatgpt.com', isLoggedIn: true } };
-            expect(requireObjectEvaluateResult(unwrapEvaluateResult(envelope), 'chatgpt page state'))
-                .toEqual(envelope.data);
-        });
-    });
-});