@jackwener/opencli 1.7.12 → 1.7.13

package/clis/codex/sidebar.js

@@ -0,0 +1,356 @@
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function cleanText(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function normalizeMatch(value) {
+    return cleanText(value).toLowerCase();
+}
+
+function matchesProject(project, query) {
+    if (!query)
+        return true;
+    const label = normalizeMatch(project.project);
+    const projectPath = normalizeMatch(project.projectPath);
+    const needle = normalizeMatch(query);
+    if (!needle)
+        return true;
+    return label === needle
+        || label.includes(needle)
+        || projectPath === needle
+        || projectPath.endsWith(`/${needle}`);
+}
+
+export function hasConversationTarget(kwargs) {
+    return !!(kwargs?.project || kwargs?.conversation || kwargs?.index || kwargs?.['thread-id']);
+}
+
+export function parsePositiveIntegerOption(raw, label) {
+    const value = cleanText(raw);
+    if (!/^\d+$/.test(value)) {
+        throw new ArgumentError(`${label} must be a positive integer`);
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed) || parsed < 1) {
+        throw new ArgumentError(`${label} must be a positive integer`);
+    }
+    return parsed;
+}
+
+export function parseOptionalPositiveIntegerOption(raw, label) {
+    if (raw == null || cleanText(raw) === '') {
+        return null;
+    }
+    return parsePositiveIntegerOption(raw, label);
+}
+
+export function requireNonEmptyOption(raw, label) {
+    const value = cleanText(raw);
+    if (!value) {
+        throw new ArgumentError(`${label} cannot be empty`);
+    }
+    return value;
+}
+
+export function collectCodexProjectsFromDocument(doc = document) {
+    const projectRowSelector = '[data-app-action-sidebar-project-row]';
+    const threadRowSelector = '[data-app-action-sidebar-thread-row]';
+
+    function visibleText(el) {
+        return (el.innerText || el.textContent || '').replace(/\s+/g, ' ').trim();
+    }
+
+    function isRelativeTime(text) {
+        return /^(?:(?:\d+\s*)?(?:刚刚|秒|分钟|小时|天|周|个月|年|sec|min|hr|hour|day|week|month|year|s|m|h|d|w)|.*\bago)$/i.test(text.trim());
+    }
+
+    function getUpdatedText(row, title) {
+        const candidates = Array.from(row.querySelectorAll('.tabular-nums, [class*="tabular-nums"], [class*="description"]'))
+            .map(visibleText)
+            .filter(Boolean);
+        const direct = candidates.find(isRelativeTime);
+        if (direct)
+            return direct;
+        const fullText = visibleText(row);
+        const suffix = fullText.replace(title, '').trim();
+        return isRelativeTime(suffix) ? suffix : '';
+    }
+
+    return Array.from(doc.querySelectorAll(projectRowSelector)).map((projectRow, projectIndex) => {
+        const label = projectRow.getAttribute('data-app-action-sidebar-project-label')
+            || projectRow.getAttribute('aria-label')
+            || visibleText(projectRow);
+        const path = projectRow.getAttribute('data-app-action-sidebar-project-id') || '';
+        const projectItem = projectRow.closest('[role="listitem"][aria-label]') || projectRow.parentElement;
+        const threadRows = projectItem
+            ? Array.from(projectItem.querySelectorAll(threadRowSelector))
+            : [];
+        const conversations = threadRows.map((row, index) => {
+            const title = row.getAttribute('data-app-action-sidebar-thread-title') || visibleText(row);
+            return {
+                index: index + 1,
+                title,
+                updated: getUpdatedText(row, title),
+                active: row.getAttribute('data-app-action-sidebar-thread-active') === 'true',
+                pinned: row.getAttribute('data-app-action-sidebar-thread-pinned') === 'true',
+                threadId: row.getAttribute('data-app-action-sidebar-thread-id') || '',
+                hostId: row.getAttribute('data-app-action-sidebar-thread-host-id') || '',
+                kind: row.getAttribute('data-app-action-sidebar-thread-kind') || '',
+            };
+        });
+
+        return {
+            index: projectIndex + 1,
+            project: label,
+            projectPath: path,
+            collapsed: projectRow.getAttribute('data-app-action-sidebar-project-collapsed') === 'true'
+                || projectRow.getAttribute('aria-expanded') === 'false',
+            conversations,
+        };
+    });
+}
+
+export function selectCodexConversationInDocument(target, doc = document) {
+    const projectRowSelector = '[data-app-action-sidebar-project-row]';
+    const threadRowSelector = '[data-app-action-sidebar-thread-row]';
+
+    function clean(value) {
+        return String(value ?? '').replace(/\s+/g, ' ').trim();
+    }
+
+    function normalize(value) {
+        return clean(value).toLowerCase();
+    }
+
+    function matches(value, query) {
+        const haystack = normalize(value);
+        const needle = normalize(query);
+        return !!needle && (haystack === needle || haystack.includes(needle));
+    }
+
+    function projectLabel(row) {
+        return row.getAttribute('data-app-action-sidebar-project-label')
+            || row.getAttribute('aria-label')
+            || row.textContent
+            || '';
+    }
+
+    function projectPath(row) {
+        return row.getAttribute('data-app-action-sidebar-project-id') || '';
+    }
+
+    function threadTitle(row) {
+        return row.getAttribute('data-app-action-sidebar-thread-title')
+            || row.textContent
+            || '';
+    }
+
+    function centerPoint(row) {
+        const rect = row.getBoundingClientRect?.();
+        if (!rect || !Number.isFinite(rect.left) || !Number.isFinite(rect.top)) {
+            return {};
+        }
+        return {
+            x: rect.left + rect.width / 2,
+            y: rect.top + rect.height / 2,
+        };
+    }
+
+    const projectRows = Array.from(doc.querySelectorAll(projectRowSelector));
+    let projectRow = null;
+    if (target.project) {
+        projectRow = projectRows.find(row => matches(projectLabel(row), target.project))
+            || projectRows.find(row => matches(projectPath(row), target.project));
+        if (!projectRow) {
+            return {
+                ok: false,
+                error: `Project not found: ${target.project}`,
+                projects: projectRows.map(row => projectLabel(row)).filter(Boolean),
+            };
+        }
+    }
+
+    if (projectRow) {
+        const collapsed = projectRow.getAttribute('data-app-action-sidebar-project-collapsed') === 'true'
+            || projectRow.getAttribute('aria-expanded') === 'false';
+        if (collapsed) {
+            projectRow.scrollIntoView?.({ block: 'center' });
+            if (!target.preferNativeClick) {
+                projectRow.click();
+            }
+            return {
+                ok: true,
+                expanded: true,
+                selected: false,
+                project: projectLabel(projectRow),
+                projectPath: projectPath(projectRow),
+                ...centerPoint(projectRow),
+            };
+        }
+    }
+
+    const scope = projectRow
+        ? (projectRow.closest('[role="listitem"][aria-label]') || projectRow.parentElement || doc)
+        : doc;
+    const threadRows = Array.from(scope.querySelectorAll(threadRowSelector));
+    if (!threadRows.length) {
+        return {
+            ok: false,
+            error: projectRow
+                ? `No visible conversations under project: ${projectLabel(projectRow)}`
+                : 'No visible Codex conversations found',
+        };
+    }
+
+    let threadRow = null;
+    if (target.threadId) {
+        threadRow = threadRows.find(row => row.getAttribute('data-app-action-sidebar-thread-id') === target.threadId);
+    }
+    if (!threadRow && target.index != null) {
+        const index = Number(target.index);
+        if (!Number.isInteger(index) || index < 1) {
+            return { ok: false, error: `Invalid conversation index: ${target.index}` };
+        }
+        threadRow = threadRows[index - 1] || null;
+    }
+    if (!threadRow && target.conversation) {
+        const exact = threadRows.filter(row => normalize(threadTitle(row)) === normalize(target.conversation));
+        threadRow = exact[0] || threadRows.find(row => matches(threadTitle(row), target.conversation)) || null;
+        if (exact.length > 1 && !target.project) {
+            return {
+                ok: false,
+                error: `Multiple conversations matched "${target.conversation}". Pass --project to disambiguate.`,
+            };
+        }
+    }
+
+    if (!threadRow) {
+        return {
+            ok: false,
+            error: target.threadId
+                ? `Thread not found: ${target.threadId}`
+                : target.conversation
+                ? `Conversation not found: ${target.conversation}`
+                : 'Pass --conversation, --thread-id, or --index to select a Codex conversation',
+            conversations: threadRows.map((row, index) => ({ index: index + 1, title: threadTitle(row) })),
+        };
+    }
+
+    threadRow.scrollIntoView?.({ block: 'center' });
+    if (!target.preferNativeClick) {
+        threadRow.click();
+    }
+    return {
+        ok: true,
+        expanded: false,
+        selected: true,
+        project: projectRow ? projectLabel(projectRow) : '',
+        projectPath: projectRow ? projectPath(projectRow) : '',
+        conversation: threadTitle(threadRow),
+        threadId: threadRow.getAttribute('data-app-action-sidebar-thread-id') || '',
+        index: threadRows.indexOf(threadRow) + 1,
+        ...centerPoint(threadRow),
+    };
+}
+
+export function flattenCodexProjects(projects, opts = {}) {
+    const projectFilter = opts.project;
+    const limit = parseOptionalPositiveIntegerOption(opts.limit, 'codex --limit');
+    const rows = [];
+    for (const project of projects) {
+        if (!matchesProject(project, projectFilter)) {
+            continue;
+        }
+        const conversations = limit
+            ? project.conversations.slice(0, limit)
+            : project.conversations;
+        if (conversations.length === 0) {
+            rows.push({
+                Project: project.project,
+                Index: 0,
+                Title: project.collapsed ? '(collapsed)' : '(no visible conversations)',
+                Updated: '',
+                Active: '',
+                ProjectPath: project.projectPath,
+                ThreadId: '',
+            });
+            continue;
+        }
+        for (const conversation of conversations) {
+            rows.push({
+                Project: project.project,
+                Index: conversation.index,
+                Title: conversation.title,
+                Updated: conversation.updated,
+                Active: conversation.active ? 'yes' : '',
+                ProjectPath: project.projectPath,
+                ThreadId: conversation.threadId,
+            });
+        }
+    }
+    return rows;
+}
+
+export async function readCodexProjects(page) {
+    const projects = await page.evaluate(`(${collectCodexProjectsFromDocument.toString()})()`);
+    if (!Array.isArray(projects)) {
+        throw new CommandExecutionError('Codex sidebar project extraction returned an invalid payload');
+    }
+    return projects;
+}
+
+export async function openCodexConversation(page, kwargs) {
+    if (!hasConversationTarget(kwargs))
+        return null;
+    const index = parseOptionalPositiveIntegerOption(kwargs.index, 'codex conversation --index');
+    const threadId = kwargs['thread-id'] ? requireNonEmptyOption(kwargs['thread-id'], 'codex conversation --thread-id') : '';
+    const target = {
+        project: kwargs.project || '',
+        conversation: kwargs.conversation || '',
+        index: index == null ? '' : String(index),
+        threadId,
+        preferNativeClick: typeof page.nativeClick === 'function',
+    };
+    let result = await page.evaluate(`(${selectCodexConversationInDocument.toString()})(${JSON.stringify(target)})`);
+    if (result?.expanded) {
+        if (typeof page.nativeClick === 'function' && Number.isFinite(result.x) && Number.isFinite(result.y)) {
+            await page.nativeClick(result.x, result.y);
+        }
+        await page.wait(0.75);
+        result = await page.evaluate(`(${selectCodexConversationInDocument.toString()})(${JSON.stringify(target)})`);
+    }
+    if (!result?.ok || !result?.selected) {
+        const detail = result?.conversations
+            ? ` Available: ${result.conversations.map(item => `${item.index}. ${item.title}`).join('; ')}`
+            : result?.projects
+                ? ` Available projects: ${result.projects.join(', ')}`
+                : '';
+        const message = `${result?.error || 'Could not select Codex conversation'}${detail}`;
+        if (result?.error?.startsWith('Invalid conversation index:')) {
+            throw new ArgumentError(message);
+        }
+        if (result?.error?.startsWith('Multiple conversations matched')) {
+            throw new ArgumentError(message, 'Pass --project or --thread-id to disambiguate the target conversation.');
+        }
+        if (result?.error?.startsWith('Project not found:')
+            || result?.error?.startsWith('Conversation not found:')
+            || result?.error?.startsWith('Thread not found:')
+            || result?.error?.startsWith('No visible conversations under project:')) {
+            throw new EmptyResultError('codex conversation', message);
+        }
+        throw new CommandExecutionError(message, 'Open the Codex sidebar and verify project/conversation rows are visible.');
+    }
+    if (typeof page.nativeClick === 'function' && Number.isFinite(result.x) && Number.isFinite(result.y)) {
+        await page.nativeClick(result.x, result.y);
+    }
+    await page.wait(1);
+    return result;
+}
+
+export const conversationSelectionArgs = [
+    { name: 'project', required: false, help: 'Project label or path to select before running the command' },
+    { name: 'conversation', required: false, help: 'Conversation title to select within --project' },
+    { name: 'index', required: false, help: '1-based conversation index within --project' },
+    { name: 'thread-id', required: false, help: 'Exact Codex thread id to select' },
+];

package/clis/codex/sidebar.test.js

@@ -0,0 +1,329 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { askCommand } from './ask.js';
+import { historyCommand } from './history.js';
+import { projectsCommand } from './projects.js';
+import {
+    collectCodexProjectsFromDocument,
+    flattenCodexProjects,
+    openCodexConversation,
+    selectCodexConversationInDocument,
+} from './sidebar.js';
+
+class FakeElement {
+    constructor(tagName = 'div', attrs = {}, children = [], text = '') {
+        this.tagName = tagName.toUpperCase();
+        this.attrs = attrs;
+        this.children = children;
+        this.parentElement = null;
+        this.textContent = text;
+        this.innerText = text;
+        this.className = attrs.class || '';
+        this.listeners = new Map();
+        for (const child of children) {
+            child.parentElement = this;
+        }
+    }
+
+    getAttribute(name) {
+        return this.attrs[name] ?? null;
+    }
+
+    addEventListener(name, fn) {
+        const listeners = this.listeners.get(name) || [];
+        listeners.push(fn);
+        this.listeners.set(name, listeners);
+    }
+
+    click() {
+        for (const listener of this.listeners.get('click') || []) {
+            listener();
+        }
+    }
+
+    scrollIntoView() {
+    }
+
+    closest(selector) {
+        let current = this;
+        while (current) {
+            if (matchesSelector(current, selector))
+                return current;
+            current = current.parentElement;
+        }
+        return null;
+    }
+
+    querySelectorAll(selector) {
+        const selectors = selector.split(',').map(part => part.trim());
+        const results = [];
+        const visit = (node) => {
+            if (selectors.some(part => matchesSelector(node, part))) {
+                results.push(node);
+            }
+            for (const child of node.children) {
+                visit(child);
+            }
+        };
+        for (const child of this.children) {
+            visit(child);
+        }
+        return results;
+    }
+}
+
+function matchesSelector(node, selector) {
+    if (selector === '[data-app-action-sidebar-project-row]') {
+        return node.getAttribute('data-app-action-sidebar-project-row') !== null;
+    }
+    if (selector === '[data-app-action-sidebar-thread-row]') {
+        return node.getAttribute('data-app-action-sidebar-thread-row') !== null;
+    }
+    if (selector === '[role="listitem"][aria-label]') {
+        return node.getAttribute('role') === 'listitem' && node.getAttribute('aria-label') !== null;
+    }
+    if (selector === '.tabular-nums') {
+        return String(node.className || '').split(/\s+/).includes('tabular-nums');
+    }
+    if (selector === '[class*="tabular-nums"]') {
+        return String(node.className || '').includes('tabular-nums');
+    }
+    if (selector === '[class*="description"]') {
+        return String(node.className || '').includes('description');
+    }
+    return false;
+}
+
+function el(tagName, attrs, children = [], text = '') {
+    return new FakeElement(tagName, attrs, children, text);
+}
+
+function thread(attrs, title, updated) {
+    return el('div', {
+        role: 'button',
+        'data-app-action-sidebar-thread-row': '',
+        'data-app-action-sidebar-thread-title': title,
+        'data-app-action-sidebar-thread-id': attrs.threadId,
+        'data-app-action-sidebar-thread-host-id': attrs.hostId || '',
+        'data-app-action-sidebar-thread-kind': attrs.kind || '',
+        'data-app-action-sidebar-thread-active': attrs.active ? 'true' : 'false',
+        'data-app-action-sidebar-thread-pinned': attrs.pinned ? 'true' : 'false',
+    }, [
+        el('span', { 'data-thread-title': '' }, [], title),
+        el('span', { class: 'tabular-nums' }, [], updated),
+    ], `${title} ${updated}`);
+}
+
+function project(label, projectPath, children) {
+    return el('div', { role: 'listitem', 'aria-label': label }, [
+        el('div', {
+            role: 'button',
+            'aria-expanded': 'true',
+            'data-app-action-sidebar-project-row': '',
+            'data-app-action-sidebar-project-label': label,
+            'data-app-action-sidebar-project-id': projectPath,
+        }, [], label),
+        ...children,
+    ]);
+}
+
+function fixtureDocument() {
+    return el('document', {}, [
+        project('stock', '/Users/youngcan/stock', [
+            thread({ threadId: 'local:stock-sync', hostId: 'local', kind: 'local', active: true }, '同步各仓库最新代码', '4 小时'),
+            thread({ threadId: 'local:trading-agents' }, '借鉴 TradingAgents', '2 小时'),
+        ]),
+        project('opencli', '/Users/youngcan/opencli', [
+            thread({ threadId: 'local:opencli-groups' }, '统一 opencli 二级命令分组', '1 天'),
+        ]),
+    ]);
+}
+
+describe('codex sidebar helpers', () => {
+    it('collects projects and visible conversations from Codex data attributes', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+
+        expect(projects).toHaveLength(2);
+        expect(projects[0]).toMatchObject({
+            project: 'stock',
+            projectPath: '/Users/youngcan/stock',
+            collapsed: false,
+        });
+        expect(projects[0].conversations[0]).toMatchObject({
+            index: 1,
+            title: '同步各仓库最新代码',
+            updated: '4 小时',
+            active: true,
+            threadId: 'local:stock-sync',
+        });
+    });
+
+    it('flattens project rows with project filters', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+        const rows = flattenCodexProjects(projects, { project: 'opencli' });
+
+        expect(rows).toEqual([
+            expect.objectContaining({
+                Project: 'opencli',
+                Index: 1,
+                Title: '统一 opencli 二级命令分组',
+                Updated: '1 天',
+            }),
+        ]);
+    });
+
+    it('rejects invalid project/history limits instead of silently ignoring them', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+
+        expect(() => flattenCodexProjects(projects, { limit: '0' })).toThrowError(ArgumentError);
+        expect(() => flattenCodexProjects(projects, { limit: '1.5' })).toThrowError(ArgumentError);
+        expect(() => flattenCodexProjects(projects, { limit: 'abc' })).toThrowError(ArgumentError);
+    });
+
+    it('does not match nested project paths when filtering by a parent label', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+        projects.push({
+            index: 3,
+            project: 'nested',
+            projectPath: '/Users/youngcan/opencli/nested',
+            collapsed: false,
+            conversations: [
+                { index: 1, title: 'Nested thread', updated: '', active: false, threadId: 'local:nested' },
+            ],
+        });
+
+        const rows = flattenCodexProjects(projects, { project: 'opencli' });
+
+        expect(rows.map(row => row.Project)).toEqual(['opencli']);
+    });
+
+    it('selects a conversation by project and title', () => {
+        const doc = fixtureDocument();
+        const selected = [];
+        for (const row of doc.querySelectorAll('[data-app-action-sidebar-thread-row]')) {
+            row.addEventListener('click', () => selected.push(row.getAttribute('data-app-action-sidebar-thread-id')));
+        }
+
+        const result = selectCodexConversationInDocument({
+            project: 'stock',
+            conversation: 'TradingAgents',
+        }, doc);
+
+        expect(result).toMatchObject({
+            ok: true,
+            selected: true,
+            project: 'stock',
+            conversation: '借鉴 TradingAgents',
+            threadId: 'local:trading-agents',
+            index: 2,
+        });
+        expect(selected).toEqual(['local:trading-agents']);
+    });
+
+    it('does not dispatch DOM click when native click is preferred', () => {
+        const doc = fixtureDocument();
+        const selected = [];
+        for (const row of doc.querySelectorAll('[data-app-action-sidebar-thread-row]')) {
+            row.addEventListener('click', () => selected.push(row.getAttribute('data-app-action-sidebar-thread-id')));
+        }
+
+        const result = selectCodexConversationInDocument({
+            project: 'stock',
+            conversation: 'TradingAgents',
+            preferNativeClick: true,
+        }, doc);
+
+        expect(result).toMatchObject({
+            ok: true,
+            selected: true,
+            threadId: 'local:trading-agents',
+        });
+        expect(selected).toEqual([]);
+    });
+
+    it('selects a conversation by index within a project', () => {
+        const result = selectCodexConversationInDocument({
+            project: '/Users/youngcan/opencli',
+            index: '1',
+        }, fixtureDocument());
+
+        expect(result).toMatchObject({
+            ok: true,
+            project: 'opencli',
+            conversation: '统一 opencli 二级命令分组',
+            threadId: 'local:opencli-groups',
+        });
+    });
+
+    it('reports exact thread-id misses as not found', () => {
+        const result = selectCodexConversationInDocument({
+            project: 'stock',
+            threadId: 'local:missing',
+        }, fixtureDocument());
+
+        expect(result).toMatchObject({
+            ok: false,
+            error: 'Thread not found: local:missing',
+        });
+    });
+
+    it('maps project/conversation misses to EmptyResultError in command selection', async () => {
+        const page = {
+            evaluate: async () => selectCodexConversationInDocument({ project: 'missing' }, fixtureDocument()),
+        };
+
+        await expect(openCodexConversation(page, { project: 'missing' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('maps missing sidebar DOM to CommandExecutionError instead of empty success', async () => {
+        const page = {
+            evaluate: async () => selectCodexConversationInDocument({ conversation: 'anything' }, el('document', {}, [])),
+        };
+
+        await expect(openCodexConversation(page, { conversation: 'anything' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('maps ambiguous conversation selection to ArgumentError', async () => {
+        const duplicateDoc = el('document', {}, [
+            project('alpha', '/tmp/alpha', [
+                thread({ threadId: 'local:one' }, 'Shared title', '1 小时'),
+            ]),
+            project('beta', '/tmp/beta', [
+                thread({ threadId: 'local:two' }, 'Shared title', '2 小时'),
+            ]),
+        ]);
+        const page = {
+            evaluate: async () => selectCodexConversationInDocument({ conversation: 'Shared title' }, duplicateDoc),
+        };
+
+        await expect(openCodexConversation(page, { conversation: 'Shared title' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+});
+
+describe('codex sidebar commands', () => {
+    it('projects fails empty result instead of returning a sentinel row', async () => {
+        const page = {
+            evaluate: async () => [],
+        };
+
+        await expect(projectsCommand.func(page, {})).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('history fails empty result instead of returning a sentinel row', async () => {
+        const page = {
+            evaluate: async () => [],
+        };
+
+        await expect(historyCommand.func(page, {})).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('ask rejects invalid timeout instead of falling back to the default', async () => {
+        const page = {
+            evaluate: async () => 0,
+        };
+
+        await expect(askCommand.func(page, { text: 'hello', timeout: 'bogus' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(askCommand.func(page, { text: 'hello', timeout: '0' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(askCommand.func(page, { text: 'hello', timeout: '1.5' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+});