@sovovs/bycli 1.8.0 → 2.0.0

package/clis/flomo/memos.test.js

@@ -1,144 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  ArgumentError,
-  AuthRequiredError,
-  CommandExecutionError,
-  EmptyResultError,
-} from '@sovovs/bycli/errors';
-
-const { __test__ } = await import('./memos.js');
-const { command, normalizeMemo, parsePositiveIntArg, parseSinceArg, parseSlugArg } = __test__;
-
-function createPage(token = 'token-123') {
-  return {
-    wait: vi.fn().mockResolvedValue(undefined),
-    evaluate: vi.fn().mockResolvedValue({ session: 'browser:default', data: token }),
-  };
-}
-
-function mockFetchJson(body, status = 200) {
-  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-    ok: status >= 200 && status < 300,
-    status,
-    json: vi.fn().mockResolvedValue(body),
-  }));
-}
-
-describe('flomo memos registration', () => {
-  it('registers as a browser cookie read command with stable columns', () => {
-    expect(command.site).toBe('flomo');
-    expect(command.name).toBe('memos');
-    expect(command.access).toBe('read');
-    expect(command.browser).toBe(true);
-    expect(command.strategy).toBe('cookie');
-    expect(command.columns).toEqual(['id', 'url', 'content', 'slug', 'tags', 'images', 'created_at', 'updated_at']);
-  });
-});
-
-describe('flomo memos argument validation', () => {
-  it('rejects invalid limits instead of silently clamping', () => {
-    expect(() => parsePositiveIntArg('0', 'limit', 20, 200)).toThrow(ArgumentError);
-    expect(() => parsePositiveIntArg('201', 'limit', 20, 200)).toThrow(ArgumentError);
-    expect(() => parsePositiveIntArg('10.5', 'limit', 20, 200)).toThrow(ArgumentError);
-    expect(() => parsePositiveIntArg('abc', 'limit', 20, 200)).toThrow(ArgumentError);
-    expect(parsePositiveIntArg(undefined, 'limit', 20, 200)).toBe(20);
-    expect(parsePositiveIntArg('200', 'limit', 20, 200)).toBe(200);
-  });
-
-  it('rejects invalid since and slug arguments', () => {
-    expect(parseSinceArg(undefined)).toBe(0);
-    expect(parseSinceArg('1735689600')).toBe(1735689600);
-    expect(() => parseSinceArg('-1')).toThrow(ArgumentError);
-    expect(() => parseSinceArg('1.5')).toThrow(ArgumentError);
-    expect(parseSlugArg(undefined)).toBe('');
-    expect(parseSlugArg('abc_DEF-123')).toBe('abc_DEF-123');
-    expect(() => parseSlugArg('bad/slash')).toThrow(ArgumentError);
-    expect(() => parseSlugArg('bad space')).toThrow(ArgumentError);
-  });
-});
-
-describe('flomo memo normalization', () => {
-  it('emits string-safe id/url fields and normalizes tags/images', () => {
-    expect(normalizeMemo({
-      slug: 'memo_12345678901234567890',
-      content: ' <p>Hello</p> ',
-      tags: [{ name: 'work' }, 'idea'],
-      files: [{ thumbnail_url: 'https://img/thumb.jpg' }, { url: 'https://img/full.jpg' }],
-      created_at: '2026-01-01T00:00:00+08:00',
-      updated_at: '2026-01-02T00:00:00+08:00',
-    })).toEqual({
-      id: 'memo_12345678901234567890',
-      url: 'https://v.flomoapp.com/mine/?memo_id=memo_12345678901234567890',
-      content: '<p>Hello</p>',
-      slug: 'memo_12345678901234567890',
-      tags: 'work, idea',
-      images: 'https://img/thumb.jpg | https://img/full.jpg',
-      created_at: '2026-01-01T00:00:00+08:00',
-      updated_at: '2026-01-02T00:00:00+08:00',
-    });
-  });
-
-  it('fails typed on malformed memo entries', () => {
-    expect(() => normalizeMemo(null)).toThrow(CommandExecutionError);
-    expect(() => normalizeMemo({ content: 'missing slug' })).toThrow(CommandExecutionError);
-  });
-});
-
-describe('flomo memos command', () => {
-  beforeEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('reads token from Browser Bridge envelope and returns memo rows', async () => {
-    mockFetchJson({
-      code: 0,
-      data: [{
-        slug: 'memo_1',
-        content: 'hello',
-        tags: ['tag'],
-        files: [],
-        created_at: '2026-01-01',
-        updated_at: '2026-01-02',
-      }],
-    });
-
-    const rows = await command.func(createPage(), { limit: '1' });
-
-    expect(globalThis.fetch).toHaveBeenCalledWith(expect.stringContaining('limit=1'), expect.objectContaining({
-      headers: expect.objectContaining({ Authorization: 'Bearer token-123' }),
-    }));
-    expect(rows).toEqual([{
-      id: 'memo_1',
-      url: 'https://v.flomoapp.com/mine/?memo_id=memo_1',
-      content: 'hello',
-      slug: 'memo_1',
-      tags: 'tag',
-      images: '',
-      created_at: '2026-01-01',
-      updated_at: '2026-01-02',
-    }]);
-  });
-
-  it('throws AuthRequiredError when the browser session has no token', async () => {
-    await expect(command.func(createPage(null), {})).rejects.toBeInstanceOf(AuthRequiredError);
-  });
-
-  it('maps Flomo auth failures to AuthRequiredError', async () => {
-    mockFetchJson({ code: 401, message: 'unauthorized' });
-    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(AuthRequiredError);
-  });
-
-  it('maps HTTP, malformed JSON, malformed data, and empty results to typed errors', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 500, json: vi.fn() }));
-    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(CommandExecutionError);
-
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, status: 200, json: vi.fn().mockRejectedValue(new Error('bad json')) }));
-    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(CommandExecutionError);
-
-    mockFetchJson({ code: 0, data: {} });
-    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(CommandExecutionError);
-
-    mockFetchJson({ code: 0, data: [] });
-    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(EmptyResultError);
-  });
-});

package/clis/gemini/ask.test.js

@@ -1,100 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const baseline = {
-    turns: [{ Role: 'Assistant', Text: '旧回答' }],
-    transcriptLines: ['baseline'],
-    composerHasText: true,
-    isGenerating: false,
-    structuredTurnsTrusted: true,
-};
-const submission = {
-    snapshot: {
-        turns: [
-            { Role: 'Assistant', Text: '旧回答' },
-            { Role: 'User', Text: '请只回复：OK' },
-        ],
-        transcriptLines: ['baseline', '请只回复：OK'],
-        composerHasText: false,
-        isGenerating: true,
-        structuredTurnsTrusted: true,
-    },
-    preSendAssistantCount: 1,
-    userAnchorTurn: { Role: 'User', Text: '请只回复：OK' },
-    reason: 'user_turn',
-};
-const mocks = vi.hoisted(() => ({
-    readGeminiSnapshot: vi.fn(),
-    sendGeminiMessage: vi.fn(),
-    startNewGeminiChat: vi.fn(),
-    waitForGeminiSubmission: vi.fn(),
-    waitForGeminiResponse: vi.fn(),
-}));
-vi.mock('./utils.js', async () => {
-    const actual = await vi.importActual('./utils.js');
-    return {
-        ...actual,
-        readGeminiSnapshot: mocks.readGeminiSnapshot,
-        sendGeminiMessage: mocks.sendGeminiMessage,
-        startNewGeminiChat: mocks.startNewGeminiChat,
-        waitForGeminiSubmission: mocks.waitForGeminiSubmission,
-        waitForGeminiResponse: mocks.waitForGeminiResponse,
-    };
-});
-import { askCommand } from './ask.js';
-function createPageMock() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn(),
-        getCookies: vi.fn().mockResolvedValue([]),
-        snapshot: vi.fn().mockResolvedValue(undefined),
-        click: vi.fn().mockResolvedValue(undefined),
-        typeText: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-        scrollTo: vi.fn().mockResolvedValue(undefined),
-        getFormState: vi.fn().mockResolvedValue({}),
-        wait: vi.fn().mockResolvedValue(undefined),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn().mockResolvedValue(undefined),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue([]),
-        scroll: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        installInterceptor: vi.fn().mockResolvedValue(undefined),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        screenshot: vi.fn().mockResolvedValue(''),
-        nativeType: vi.fn().mockResolvedValue(undefined),
-        nativeKeyPress: vi.fn().mockResolvedValue(undefined),
-    };
-}
-describe('gemini ask orchestration', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('captures baseline, sends, waits for confirmed submission, then waits with the remaining timeout', async () => {
-        vi.spyOn(Date, 'now')
-            .mockReturnValueOnce(0)
-            .mockReturnValueOnce(2000);
-        const page = createPageMock();
-        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
-        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
-        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
-        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
-        const result = await askCommand.func(page, { prompt: '请只回复：OK', timeout: 20, new: 'false' });
-        expect(mocks.readGeminiSnapshot).toHaveBeenCalledWith(page);
-        expect(mocks.waitForGeminiSubmission).toHaveBeenCalledWith(page, baseline, 20);
-        expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 18);
-        expect(result).toEqual([{ response: '💬 OK' }]);
-    });
-    it('does not spend extra response wait time after submission has already consumed the full timeout budget', async () => {
-        vi.spyOn(Date, 'now')
-            .mockReturnValueOnce(0)
-            .mockReturnValueOnce(20000);
-        const page = createPageMock();
-        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
-        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
-        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
-        mocks.waitForGeminiResponse.mockResolvedValueOnce('');
-        await askCommand.func(page, { prompt: '请只回复：OK', timeout: 20, new: 'false' });
-        expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 0);
-    });
-});

package/clis/gemini/deep-research-result.test.js

@@ -1,155 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockClickGeminiConversationByTitle, mockExportGeminiDeepResearchReport, mockGetGeminiConversationList, mockGetGeminiPageState, mockGetLatestGeminiAssistantResponse, mockReadGeminiSnapshot, mockResolveGeminiConversationForQuery, mockWaitForGeminiTranscript, } = vi.hoisted(() => ({
-    mockClickGeminiConversationByTitle: vi.fn(),
-    mockExportGeminiDeepResearchReport: vi.fn(),
-    mockGetGeminiConversationList: vi.fn(),
-    mockGetGeminiPageState: vi.fn(),
-    mockGetLatestGeminiAssistantResponse: vi.fn(),
-    mockReadGeminiSnapshot: vi.fn(),
-    mockResolveGeminiConversationForQuery: vi.fn(),
-    mockWaitForGeminiTranscript: vi.fn(),
-}));
-vi.mock('./utils.js', () => ({
-    GEMINI_DOMAIN: 'gemini.google.com',
-    clickGeminiConversationByTitle: mockClickGeminiConversationByTitle,
-    exportGeminiDeepResearchReport: mockExportGeminiDeepResearchReport,
-    getGeminiConversationList: mockGetGeminiConversationList,
-    getGeminiPageState: mockGetGeminiPageState,
-    getLatestGeminiAssistantResponse: mockGetLatestGeminiAssistantResponse,
-    readGeminiSnapshot: mockReadGeminiSnapshot,
-    parseGeminiConversationUrl: (value) => {
-        const raw = String(value ?? '').trim();
-        return raw.startsWith('https://gemini.google.com/app/') ? raw : null;
-    },
-    parseGeminiTitleMatchMode: (value) => {
-        const raw = String(value ?? 'contains').trim().toLowerCase();
-        if (raw === 'contains' || raw === 'exact')
-            return raw;
-        return null;
-    },
-    resolveGeminiConversationForQuery: mockResolveGeminiConversationForQuery,
-    waitForGeminiTranscript: mockWaitForGeminiTranscript,
-}));
-import { deepResearchResultCommand } from './deep-research-result.js';
-describe('gemini/deep-research-result', () => {
-    const page = {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-    };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockGetGeminiPageState.mockResolvedValue({ isSignedIn: true });
-        mockGetGeminiConversationList.mockResolvedValue([{ Title: 'A title', Url: 'https://gemini.google.com/app/abc' }]);
-        mockResolveGeminiConversationForQuery.mockReturnValue({ Title: 'A title', Url: 'https://gemini.google.com/app/abc' });
-        mockClickGeminiConversationByTitle.mockResolvedValue(true);
-        mockWaitForGeminiTranscript.mockResolvedValue(['line']);
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: 'https://files.example.com/report.md', source: 'network' });
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('Final answer');
-        mockReadGeminiSnapshot.mockResolvedValue({
-            turns: [],
-            transcriptLines: [],
-            composerHasText: false,
-            isGenerating: false,
-            structuredTurnsTrusted: true,
-        });
-    });
-    const runCommand = (kwargs) => deepResearchResultCommand.func(page, { timeout: 120, ...kwargs });
-    it('uses latest conversation when query is empty', async () => {
-        const result = await runCommand({ query: '   ' });
-        expect(page.goto).toHaveBeenCalledWith('https://gemini.google.com/app/abc', { waitUntil: 'load', settleMs: 2500 });
-        expect(result).toEqual([{ response: 'https://files.example.com/report.md' }]);
-    });
-    it('falls back to current page response when query is empty and sidebar has no conversations', async () => {
-        mockGetGeminiConversationList.mockResolvedValue([]);
-        mockResolveGeminiConversationForQuery.mockReturnValue(null);
-        const result = await runCommand({ query: '' });
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(result).toEqual([{ response: 'https://files.example.com/report.md' }]);
-    });
-    it('returns a validation message when match mode is invalid', async () => {
-        const result = await runCommand({ query: 'A', match: 'prefix' });
-        expect(result).toEqual([{ response: 'Invalid match mode. Use contains or exact.' }]);
-    });
-    it('returns a signed-out message when Gemini page state indicates logged out', async () => {
-        mockGetGeminiPageState.mockResolvedValue({ isSignedIn: false });
-        const result = await runCommand({ query: 'A' });
-        expect(result).toEqual([{ response: 'Not signed in to Gemini.' }]);
-    });
-    it('opens matched conversation by URL and returns exported report url', async () => {
-        const result = await runCommand({ query: 'A title', match: 'exact' });
-        expect(page.goto).toHaveBeenCalledWith('https://gemini.google.com/app/abc', { waitUntil: 'load', settleMs: 2500 });
-        expect(result).toEqual([{ response: 'https://files.example.com/report.md' }]);
-    });
-    it('accepts a direct conversation URL and reads response from that page', async () => {
-        const url = 'https://gemini.google.com/app/direct-id';
-        const result = await runCommand({ query: url, match: 'contains' });
-        expect(page.goto).toHaveBeenCalledWith(url, { waitUntil: 'load', settleMs: 2500 });
-        expect(result).toEqual([{ response: 'https://files.example.com/report.md' }]);
-    });
-    it('passes query and mode into resolveGeminiConversationForQuery', async () => {
-        const result = await runCommand({ query: 'title', match: 'contains' });
-        expect(mockResolveGeminiConversationForQuery).toHaveBeenCalledWith([{ Title: 'A title', Url: 'https://gemini.google.com/app/abc' }], 'title', 'contains');
-        expect(result).toEqual([{ response: 'https://files.example.com/report.md' }]);
-    });
-    it('falls back to click-by-title and returns not-found when click fails', async () => {
-        mockResolveGeminiConversationForQuery.mockReturnValue(null);
-        mockClickGeminiConversationByTitle.mockResolvedValue(false);
-        const result = await runCommand({ query: 'missing', match: 'contains' });
-        expect(result).toEqual([{ response: 'No conversation matched: missing' }]);
-    });
-    it('returns pending message when export url is unavailable and completion is not confirmed', async () => {
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: '', source: 'none' });
-        const result = await runCommand({ query: 'A title' });
-        expect(result).toEqual([{ response: 'Deep Research may still be running or preparing export. Please wait and retry later.' }]);
-    });
-    it('returns waiting message when deep research is still generating', async () => {
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: '', source: 'none' });
-        mockReadGeminiSnapshot.mockResolvedValue({
-            turns: [],
-            transcriptLines: [],
-            composerHasText: false,
-            isGenerating: true,
-            structuredTurnsTrusted: true,
-        });
-        const result = await runCommand({ query: 'A title' });
-        expect(result).toEqual([{ response: 'Deep Research is still running. Please wait and retry later.' }]);
-    });
-    it('returns waiting message when assistant response indicates research in progress', async () => {
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: '', source: 'none' });
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('正在研究中，请稍候。');
-        const result = await runCommand({ query: 'A title' });
-        expect(result).toEqual([{ response: 'Deep Research is still running. Please wait and retry later.' }]);
-    });
-    it('returns waiting message when transcript indicates in-progress status', async () => {
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: '', source: 'none' });
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('');
-        mockReadGeminiSnapshot.mockResolvedValue({
-            turns: [],
-            transcriptLines: ['生成研究计划中，请稍候。'],
-            composerHasText: false,
-            isGenerating: false,
-            structuredTurnsTrusted: true,
-        });
-        const result = await runCommand({ query: 'A title' });
-        expect(result).toEqual([{ response: 'Deep Research is still running. Please wait and retry later.' }]);
-    });
-    it('returns no-docs message when text indicates completed state', async () => {
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: '', source: 'none' });
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('Researching websites... Completed');
-        mockReadGeminiSnapshot.mockResolvedValue({
-            turns: [],
-            transcriptLines: [],
-            composerHasText: false,
-            isGenerating: false,
-            structuredTurnsTrusted: true,
-        });
-        const result = await runCommand({ query: 'A title' });
-        expect(result).toEqual([{ response: 'No Docs URL found. Please check Share & Export -> Export to Docs in Gemini UI.' }]);
-    });
-    it('returns pending message when assistant response is empty', async () => {
-        mockExportGeminiDeepResearchReport.mockResolvedValue({ url: '', source: 'none' });
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('');
-        const result = await runCommand({ query: 'A title' });
-        expect(result).toEqual([{ response: 'Deep Research may still be running or preparing export. Please wait and retry later.' }]);
-    });
-});

package/clis/gemini/deep-research.test.js

@@ -1,181 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockGetCurrentGeminiUrl, mockReadGeminiSnapshot, mockSelectGeminiTool, mockSendGeminiMessage, mockStartNewGeminiChat, mockWaitForGeminiSubmission, mockWaitForGeminiConfirmButton, mockGetLatestGeminiAssistantResponse, } = vi.hoisted(() => ({
-    mockGetCurrentGeminiUrl: vi.fn(),
-    mockReadGeminiSnapshot: vi.fn(),
-    mockSelectGeminiTool: vi.fn(),
-    mockSendGeminiMessage: vi.fn(),
-    mockStartNewGeminiChat: vi.fn(),
-    mockWaitForGeminiSubmission: vi.fn(),
-    mockWaitForGeminiConfirmButton: vi.fn(),
-    mockGetLatestGeminiAssistantResponse: vi.fn(),
-}));
-vi.mock('./utils.js', () => ({
-    GEMINI_DOMAIN: 'gemini.google.com',
-    GEMINI_APP_URL: 'https://gemini.google.com/app',
-    GEMINI_DEEP_RESEARCH_DEFAULT_TOOL_LABELS: ['Deep Research', 'Deep research', '\u6df1\u5ea6\u7814\u7a76'],
-    GEMINI_DEEP_RESEARCH_DEFAULT_CONFIRM_LABELS: [
-        'Start research',
-        'Start Research',
-        'Start deep research',
-        'Start Deep Research',
-        'Generate research plan',
-        'Generate Research Plan',
-        'Generate deep research plan',
-        'Generate Deep Research Plan',
-        '\u5f00\u59cb\u7814\u7a76',
-        '\u5f00\u59cb\u6df1\u5ea6\u7814\u7a76',
-        '\u5f00\u59cb\u8c03\u7814',
-        '\u751f\u6210\u7814\u7a76\u8ba1\u5212',
-        '\u751f\u6210\u8c03\u7814\u8ba1\u5212',
-    ],
-    resolveGeminiLabels: (value, fallback) => {
-        const label = String(value ?? '').trim();
-        return label ? [label] : fallback;
-    },
-    getCurrentGeminiUrl: mockGetCurrentGeminiUrl,
-    getLatestGeminiAssistantResponse: mockGetLatestGeminiAssistantResponse,
-    readGeminiSnapshot: mockReadGeminiSnapshot,
-    selectGeminiTool: mockSelectGeminiTool,
-    sendGeminiMessage: mockSendGeminiMessage,
-    startNewGeminiChat: mockStartNewGeminiChat,
-    waitForGeminiSubmission: mockWaitForGeminiSubmission,
-    waitForGeminiConfirmButton: mockWaitForGeminiConfirmButton,
-}));
-import { deepResearchCommand } from './deep-research.js';
-describe('gemini/deep-research', () => {
-    const page = {};
-    const runCommand = (kwargs) => deepResearchCommand.func(page, { timeout: 180, ...kwargs });
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockGetCurrentGeminiUrl.mockResolvedValue('https://gemini.google.com/app/chat');
-        mockReadGeminiSnapshot.mockResolvedValue({
-            turns: [],
-            transcriptLines: [],
-            composerHasText: false,
-            isGenerating: false,
-            structuredTurnsTrusted: true,
-        });
-        mockSelectGeminiTool.mockResolvedValue('Deep Research');
-        mockSendGeminiMessage.mockResolvedValue();
-        mockStartNewGeminiChat.mockResolvedValue();
-        mockWaitForGeminiSubmission.mockResolvedValue({
-            snapshot: { turns: [], transcriptLines: [], composerHasText: false, isGenerating: false, structuredTurnsTrusted: true },
-            preSendAssistantCount: 0,
-            userAnchorTurn: null,
-            reason: 'user_turn',
-        });
-        mockWaitForGeminiConfirmButton.mockResolvedValue('Start research');
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('');
-    });
-    it('starts a new chat by default, then sends prompt and confirms deep research', async () => {
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(mockStartNewGeminiChat).toHaveBeenCalledTimes(1);
-        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(1);
-        expect(mockSendGeminiMessage).toHaveBeenCalledWith(page, 'research this topic');
-        expect(mockWaitForGeminiSubmission).toHaveBeenCalledTimes(1);
-        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledWith(page, expect.arrayContaining(['Start research', 'Start deep research', 'Generate research plan', '\u751f\u6210\u7814\u7a76\u8ba1\u5212']), 180);
-        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/chat' }]);
-    });
-    it('returns tool-not-found when the tool cannot be selected', async () => {
-        mockSelectGeminiTool.mockResolvedValue('');
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(result).toEqual([{ status: 'tool-not-found', url: 'https://gemini.google.com/app/chat' }]);
-        expect(mockSendGeminiMessage).not.toHaveBeenCalled();
-        expect(mockWaitForGeminiSubmission).not.toHaveBeenCalled();
-        expect(mockWaitForGeminiConfirmButton).not.toHaveBeenCalled();
-    });
-    it('retries send once when first submission cannot be confirmed', async () => {
-        mockWaitForGeminiSubmission.mockResolvedValueOnce(null).mockResolvedValueOnce({
-            snapshot: { turns: [], transcriptLines: [], composerHasText: false, isGenerating: false, structuredTurnsTrusted: true },
-            preSendAssistantCount: 0,
-            userAnchorTurn: null,
-            reason: 'user_turn',
-        });
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
-        expect(mockReadGeminiSnapshot).toHaveBeenCalledTimes(2);
-        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(2);
-        expect(mockWaitForGeminiSubmission).toHaveBeenCalledTimes(2);
-        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/chat' }]);
-    });
-    it('returns submit-not-found when submission cannot be confirmed after retry', async () => {
-        mockWaitForGeminiSubmission.mockResolvedValue(null);
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
-        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(2);
-        expect(mockWaitForGeminiConfirmButton).not.toHaveBeenCalled();
-        expect(result).toEqual([{ status: 'submit-not-found', url: 'https://gemini.google.com/app/chat' }]);
-    });
-    it('returns confirm-not-found when no confirm button is found', async () => {
-        mockWaitForGeminiConfirmButton.mockResolvedValue('');
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(result).toEqual([{ status: 'confirm-not-found', url: 'https://gemini.google.com/app/chat' }]);
-    });
-    it('returns started when confirm is missing but research appears to be running', async () => {
-        mockWaitForGeminiConfirmButton.mockResolvedValue('');
-        mockGetCurrentGeminiUrl.mockResolvedValue('https://gemini.google.com/app/abc123');
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('Researching websites now');
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/abc123' }]);
-    });
-    it('does not treat conversation url alone as started when confirm is missing', async () => {
-        mockWaitForGeminiConfirmButton.mockResolvedValue('');
-        mockGetCurrentGeminiUrl.mockResolvedValue('https://gemini.google.com/app/abc999');
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('I drafted a plan. Start research');
-        const result = await runCommand({ prompt: 'research this topic' });
-        expect(result).toEqual([{ status: 'confirm-not-found', url: 'https://gemini.google.com/app/abc999' }]);
-    });
-    it('retries once when stuck on root app URL and starts successfully on second confirm', async () => {
-        mockWaitForGeminiConfirmButton.mockResolvedValueOnce('').mockResolvedValueOnce('Start research');
-        mockGetCurrentGeminiUrl.mockResolvedValueOnce('https://gemini.google.com/app').mockResolvedValueOnce('https://gemini.google.com/app/retry123');
-        const result = await runCommand({ prompt: 'research this topic', timeout: 20 });
-        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
-        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
-        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledTimes(2);
-        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/retry123' }]);
-    });
-    it('treats root-url confirm as false-positive and retries', async () => {
-        mockWaitForGeminiConfirmButton.mockResolvedValueOnce('Start research').mockResolvedValueOnce('Start research');
-        mockGetCurrentGeminiUrl.mockResolvedValueOnce('https://gemini.google.com/app').mockResolvedValueOnce('https://gemini.google.com/app/retry456');
-        const result = await runCommand({ prompt: 'research this topic', timeout: 20 });
-        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
-        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/retry456' }]);
-    });
-    it('does not resend prompt during root-url retry to avoid duplicate chats', async () => {
-        mockWaitForGeminiConfirmButton.mockResolvedValueOnce('Start research').mockResolvedValueOnce('');
-        mockGetCurrentGeminiUrl.mockResolvedValueOnce('https://gemini.google.com/app').mockResolvedValueOnce('https://gemini.google.com/app');
-        mockGetLatestGeminiAssistantResponse.mockResolvedValue('');
-        const result = await runCommand({ prompt: 'research this topic', timeout: 20 });
-        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
-        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
-        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledTimes(2);
-        expect(result).toEqual([{ status: 'confirm-not-found', url: 'https://gemini.google.com/app' }]);
-    });
-    it('attempts one more confirm click when still waiting for start research', async () => {
-        mockWaitForGeminiConfirmButton
-            .mockResolvedValueOnce('')
-            .mockResolvedValueOnce('Start research');
-        mockGetCurrentGeminiUrl
-            .mockResolvedValueOnce('https://gemini.google.com/app/xyz123')
-            .mockResolvedValueOnce('https://gemini.google.com/app/xyz123');
-        mockGetLatestGeminiAssistantResponse
-            .mockResolvedValueOnce('I drafted a plan. Start research')
-            .mockResolvedValueOnce('Researching websites now');
-        const result = await runCommand({ prompt: 'research this topic', timeout: 20 });
-        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledTimes(2);
-        expect(mockWaitForGeminiConfirmButton).toHaveBeenNthCalledWith(2, page, expect.arrayContaining(['Start research', 'Start deep research', '开始研究', '开始深度研究']), 8);
-        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/xyz123' }]);
-    });
-    it('uses custom tool/confirm labels when provided', async () => {
-        await runCommand({
-            prompt: 'research this topic',
-            tool: 'Custom Tool',
-            confirm: 'Custom Confirm',
-            timeout: 42,
-        });
-        expect(mockSelectGeminiTool).toHaveBeenCalledWith(page, ['Custom Tool']);
-        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledWith(page, ['Custom Confirm'], 42);
-    });
-});