@sovovs/bycli 1.8.0 → 2.0.0

package/clis/chatgpt/image.test.js

@@ -1,188 +0,0 @@
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mocks = vi.hoisted(() => ({
-    getChatGPTVisibleImageUrls: vi.fn(),
-    clearChatGPTDraft: vi.fn(),
-    prepareChatGPTImagePaths: vi.fn(),
-    sendChatGPTMessage: vi.fn(),
-    uploadChatGPTImages: vi.fn(),
-    waitForChatGPTImages: vi.fn(),
-    getChatGPTImageAssets: vi.fn(),
-    saveBase64ToFile: vi.fn(),
-}));
-
-vi.mock('./utils.js', () => ({
-    clearChatGPTDraft: mocks.clearChatGPTDraft,
-    getChatGPTVisibleImageUrls: mocks.getChatGPTVisibleImageUrls,
-    normalizeBooleanFlag: (value, fallback = false) => {
-        if (typeof value === 'boolean') return value;
-        if (value == null || value === '') return fallback;
-        const normalized = String(value).trim().toLowerCase();
-        return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
-    },
-    prepareChatGPTImagePaths: mocks.prepareChatGPTImagePaths,
-    sendChatGPTMessage: mocks.sendChatGPTMessage,
-    unwrapEvaluateResult: (payload) => {
-        if (payload && !Array.isArray(payload) && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
-            return payload.data;
-        }
-        return payload;
-    },
-    uploadChatGPTImages: mocks.uploadChatGPTImages,
-    waitForChatGPTImages: mocks.waitForChatGPTImages,
-    getChatGPTImageAssets: mocks.getChatGPTImageAssets,
-}));
-
-vi.mock('@sovovs/bycli/utils', () => ({
-    saveBase64ToFile: mocks.saveBase64ToFile,
-}));
-
-const { imageCommand, nextAvailablePath, parseImagePaths, resolveOutputDir } = await import('./image.js');
-
-function createPage() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue('https://chatgpt.com/c/test-conversation'),
-    };
-}
-
-beforeEach(() => {
-    vi.restoreAllMocks();
-    mocks.clearChatGPTDraft.mockReset().mockResolvedValue(undefined);
-    mocks.prepareChatGPTImagePaths.mockReset().mockImplementation(async (paths) => ({ ok: true, paths }));
-    mocks.getChatGPTVisibleImageUrls.mockReset().mockResolvedValue([]);
-    mocks.sendChatGPTMessage.mockReset().mockResolvedValue(true);
-    mocks.uploadChatGPTImages.mockReset().mockResolvedValue({ ok: true });
-    mocks.waitForChatGPTImages.mockReset().mockResolvedValue(['https://images.example/generated.png']);
-    mocks.getChatGPTImageAssets.mockReset().mockResolvedValue([{
-        url: 'https://images.example/generated.png',
-        dataUrl: 'data:image/png;base64,aGVsbG8=',
-        mimeType: 'image/png',
-    }]);
-    mocks.saveBase64ToFile.mockReset().mockResolvedValue(undefined);
-});
-
-describe('chatgpt image output paths', () => {
-    it('expands the default and explicit home-relative output directories', () => {
-        expect(resolveOutputDir()).toBe(path.join(os.homedir(), 'Pictures', 'chatgpt'));
-        expect(resolveOutputDir('~/tmp/chatgpt-images')).toBe(path.join(os.homedir(), 'tmp', 'chatgpt-images'));
-        expect(resolveOutputDir('~')).toBe(os.homedir());
-    });
-
-    it('generates a non-overwriting file path when a timestamp collision exists', () => {
-        const dir = '/tmp/chatgpt';
-        const taken = new Set([
-            path.join(dir, 'chatgpt_123.png'),
-            path.join(dir, 'chatgpt_123_1.png'),
-        ]);
-
-        expect(nextAvailablePath(dir, 'chatgpt_123', '.png', (file) => taken.has(file))).toBe(path.join(dir, 'chatgpt_123_2.png'));
-    });
-
-    it('parses comma-separated image paths', () => {
-        expect(parseImagePaths('/tmp/a.png, /tmp/b.jpg')).toEqual(['/tmp/a.png', '/tmp/b.jpg']);
-        expect(parseImagePaths([' /tmp/a.png ', '/tmp/b.jpg,/tmp/c.webp'])).toEqual(['/tmp/a.png', '/tmp/b.jpg', '/tmp/c.webp']);
-    });
-});
-
-describe('chatgpt image upload flow', () => {
-    it('uploads local images before sending an edit prompt', async () => {
-        mocks.prepareChatGPTImagePaths.mockResolvedValue({ ok: true, paths: ['/abs/cat.png', '/abs/dog.jpg'] });
-        await imageCommand.func(createPage(), {
-            prompt: 'make the background blue',
-            image: '/tmp/cat.png,/tmp/dog.jpg',
-            op: '',
-            sd: true,
-            timeout: 240,
-        });
-
-        expect(mocks.clearChatGPTDraft).toHaveBeenCalled();
-        expect(mocks.uploadChatGPTImages).toHaveBeenCalledWith(expect.anything(), ['/abs/cat.png', '/abs/dog.jpg']);
-        expect(mocks.uploadChatGPTImages.mock.invocationCallOrder[0]).toBeLessThan(
-            mocks.getChatGPTVisibleImageUrls.mock.invocationCallOrder[0],
-        );
-        expect(mocks.sendChatGPTMessage).toHaveBeenCalledWith(expect.anything(), 'Edit the attached images: make the background blue');
-    });
-
-    it('rejects invalid local image paths before browser navigation', async () => {
-        mocks.prepareChatGPTImagePaths.mockResolvedValue({ ok: false, reason: 'Image not found: /tmp/missing.png' });
-        const page = createPage();
-
-        await expect(imageCommand.func(page, {
-            prompt: 'make the background blue',
-            image: '/tmp/missing.png',
-            op: '',
-            sd: false,
-            timeout: 240,
-        })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('Image not found'),
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(mocks.uploadChatGPTImages).not.toHaveBeenCalled();
-    });
-
-    it('surfaces upload failures as command execution errors', async () => {
-        mocks.uploadChatGPTImages.mockResolvedValue({ ok: false, reason: 'image upload preview did not appear' });
-
-        await expect(imageCommand.func(createPage(), {
-            prompt: 'make the background blue',
-            image: '/tmp/cat.png',
-            op: '',
-            sd: false,
-            timeout: 240,
-        })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('image upload preview did not appear'),
-        });
-    });
-});
-
-describe('chatgpt image failure contracts', () => {
-    it('fails fast when the image prompt cannot be sent', async () => {
-        mocks.sendChatGPTMessage.mockResolvedValue(false);
-
-        await expect(imageCommand.func(createPage(), {
-            prompt: 'cat',
-            op: '',
-            sd: false,
-            timeout: 240,
-        })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('Failed to send image prompt to ChatGPT'),
-        });
-        expect(mocks.waitForChatGPTImages).not.toHaveBeenCalled();
-    });
-
-    it('fails fast when image generation detection finds no new images', async () => {
-        mocks.waitForChatGPTImages.mockResolvedValue([]);
-
-        await expect(imageCommand.func(createPage(), {
-            prompt: 'cat',
-            op: '',
-            sd: false,
-            timeout: 240,
-        })).rejects.toMatchObject({
-            code: 'EMPTY_RESULT',
-            message: expect.stringContaining('chatgpt image returned no data'),
-            hint: expect.stringContaining('No generated images were detected'),
-        });
-    });
-
-    it('fails fast when generated image assets cannot be exported', async () => {
-        mocks.getChatGPTImageAssets.mockResolvedValue([]);
-
-        await expect(imageCommand.func(createPage(), {
-            prompt: 'cat',
-            op: '',
-            sd: false,
-            timeout: 240,
-        })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('Failed to export generated ChatGPT image assets'),
-        });
-    });
-});

package/clis/chatgpt/utils.test.js

@@ -1,330 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { JSDOM } from 'jsdom';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { __test__, getChatGPTImageAssets, getChatGPTVisibleImageUrls, prepareChatGPTImagePaths, sendChatGPTMessage, uploadChatGPTImages, waitForChatGPTImages } from './utils.js';
-
-const tempDirs = [];
-
-afterEach(() => {
-    vi.restoreAllMocks();
-    while (tempDirs.length) {
-        fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
-    }
-});
-
-function createPageMock({ location = '', generating = [], imageUrls = [] } = {}) {
-    let generatingIndex = 0;
-    let imageIndex = 0;
-    return {
-        wait: vi.fn().mockResolvedValue(undefined),
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn((script) => {
-            if (script === 'window.location.href') return Promise.resolve(location);
-            if (script.includes('Stop generating') || script.includes('Thinking')) {
-                const value = generating[Math.min(generatingIndex, generating.length - 1)] ?? false;
-                generatingIndex += 1;
-                return Promise.resolve(value);
-            }
-            if (script.includes("document.querySelectorAll('img')")) {
-                const value = imageUrls[Math.min(imageIndex, imageUrls.length - 1)] ?? [];
-                imageIndex += 1;
-                return Promise.resolve(value);
-            }
-            return Promise.resolve(undefined);
-        }),
-    };
-}
-
-describe('chatgpt image wait contract', () => {
-    it('does not periodically reload the conversation while generation is still active', async () => {
-        const convUrl = 'https://chatgpt.com/c/demo';
-        const page = createPageMock({
-            location: convUrl,
-            generating: [true, true, true, true, true, true],
-        });
-
-        await expect(waitForChatGPTImages(page, [], 18, convUrl)).resolves.toEqual([]);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('jumps back to the captured conversation when the page drifts away', async () => {
-        const convUrl = 'https://chatgpt.com/c/demo';
-        const page = createPageMock({
-            location: 'https://chatgpt.com/',
-            generating: [false],
-            imageUrls: [['https://cdn.openai.com/generated/demo.png']],
-        });
-
-        await expect(waitForChatGPTImages(page, [], 3, convUrl)).resolves.toEqual([
-            'https://cdn.openai.com/generated/demo.png',
-        ]);
-        expect(page.goto).toHaveBeenCalledWith(convUrl);
-    });
-
-    it('treats query and hash variants as the same conversation', () => {
-        expect(__test__.isSameChatGPTConversation(
-            'https://chatgpt.com/c/demo?model=gpt-image-1',
-            'https://chatgpt.com/c/demo',
-        )).toBe(true);
-        expect(__test__.isSameChatGPTConversation(
-            'https://chatgpt.com/c/other',
-            'https://chatgpt.com/c/demo',
-        )).toBe(false);
-    });
-});
-
-describe('chatgpt conversation id parsing', () => {
-    it('accepts ids and chatgpt conversation URLs', () => {
-        expect(__test__.parseChatGPTConversationId('abc_123-def')).toBe('abc_123-def');
-        expect(__test__.parseChatGPTConversationId('https://chatgpt.com/c/abc_123-def?model=gpt-5')).toBe('abc_123-def');
-        expect(__test__.parseChatGPTConversationId('/c/abc_123-def')).toBe('abc_123-def');
-    });
-
-    it('rejects invalid detail ids', () => {
-        expect(() => __test__.parseChatGPTConversationId('')).toThrow(/conversation id/);
-        expect(() => __test__.parseChatGPTConversationId('https://chatgpt.com/')).toThrow(/conversation id/);
-    });
-});
-
-describe('chatgpt send selectors', () => {
-    it('inlines the composer locator without returning before caller code runs', () => {
-        const dom = new JSDOM('<!doctype html><div id="prompt-textarea" contenteditable="true"></div>', {
-            url: 'https://chatgpt.com/',
-            runScripts: 'outside-only',
-        });
-        const composer = dom.window.document.querySelector('#prompt-textarea');
-        composer.getBoundingClientRect = () => ({ width: 320, height: 48 });
-
-        const result = dom.window.eval(`
-            (() => {
-                ${__test__.buildComposerLocatorScript()}
-                const composer = findComposer();
-                return !!composer && composer.getAttribute(markerAttr) === '1';
-            })()
-        `);
-
-        expect(result).toBe(true);
-    });
-
-    it('keeps locale-independent send-button selector before aria-label fallbacks', async () => {
-        const page = {
-            wait: vi.fn().mockResolvedValue(undefined),
-            nativeType: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn((script) => {
-                if (script.includes('findComposer')) return Promise.resolve(true);
-                if (script.includes('sendBtnFound')) {
-                    expect(script).toContain('data-testid=\\\"send-button\\\"');
-                    return Promise.resolve({ sendBtnFound: true });
-                }
-                if (script.includes('if (sendBtn) sendBtn.click')) {
-                    expect(script).toContain('data-testid=\\\"send-button\\\"');
-                }
-                return Promise.resolve(undefined);
-            }),
-        };
-
-        await expect(sendChatGPTMessage(page, 'hello')).resolves.toBe(true);
-    });
-
-    it('uses the composer submit fallback consistently for readiness and click', async () => {
-        const page = {
-            wait: vi.fn().mockResolvedValue(undefined),
-            nativeType: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn((script) => {
-                if (script.includes('findComposer')) return Promise.resolve(true);
-                if (script.includes('sendBtnFound')) {
-                    expect(script).toContain('#composer-submit-button:not([disabled])');
-                    return Promise.resolve({ sendBtnFound: true });
-                }
-                if (script.includes('if (sendBtn) sendBtn.click')) {
-                    expect(script).toContain('#composer-submit-button:not([disabled])');
-                }
-                return Promise.resolve(undefined);
-            }),
-        };
-
-        await expect(sendChatGPTMessage(page, 'hello')).resolves.toBe(true);
-    });
-
-    it('keeps zh-CN aria and placeholder fallbacks without replacing English selectors', () => {
-        expect(__test__.COMPOSER_SELECTORS).toEqual(expect.arrayContaining([
-            '[aria-label="Chat with ChatGPT"]',
-            '[aria-label="与 ChatGPT 聊天"]',
-            '[placeholder="Ask anything"]',
-            '[placeholder="有问题，尽管问"]',
-            '[data-testid="prompt-textarea"]',
-        ]));
-        expect(__test__.SEND_BUTTON_SELECTOR).toBe('button[data-testid="send-button"]:not([disabled])');
-        expect(__test__.SEND_BUTTON_FALLBACK_SELECTORS).toContain('#composer-submit-button:not([disabled])');
-        expect(__test__.SEND_BUTTON_LABELS).toEqual(expect.arrayContaining(['Send prompt', 'Send message', 'Send', '发送提示']));
-        expect(__test__.CLOSE_SIDEBAR_LABELS).toEqual(expect.arrayContaining(['Close sidebar', '关闭边栏']));
-    });
-});
-
-describe('chatgpt generated image detection', () => {
-    function createDomPage(html, setup = () => {}) {
-        const dom = new JSDOM(html, {
-            url: 'https://chatgpt.com/c/demo',
-            runScripts: 'outside-only',
-        });
-        setup(dom.window);
-        return {
-            evaluate: vi.fn((script) => Promise.resolve(dom.window.eval(String(script)))),
-        };
-    }
-
-    it('detects visible CSS background images when ChatGPT does not render a plain img', async () => {
-        const page = createDomPage(`
-            <!doctype html>
-            <main>
-              <div class="avatar" style="background-image: url('https://chatgpt.com/avatar.png')"></div>
-              <button data-testid="generated-image" style="background-image: url('/backend-api/generated/foo.webp')"></button>
-            </main>
-        `, (window) => {
-            for (const el of window.document.querySelectorAll('div, button')) {
-                el.getBoundingClientRect = () => ({ width: 512, height: 512 });
-            }
-        });
-
-        await expect(getChatGPTVisibleImageUrls(page)).resolves.toEqual([
-            'https://chatgpt.com/backend-api/generated/foo.webp',
-        ]);
-    });
-
-    it('detects visible generated canvases as data URLs', async () => {
-        const page = createDomPage('<!doctype html><canvas width="512" height="512"></canvas>', (window) => {
-            const canvas = window.document.querySelector('canvas');
-            canvas.getBoundingClientRect = () => ({ width: 512, height: 512 });
-            canvas.toDataURL = () => 'data:image/png;base64,ZmFrZQ==';
-        });
-
-        await expect(getChatGPTVisibleImageUrls(page)).resolves.toEqual([
-            'data:image/png;base64,ZmFrZQ==',
-        ]);
-    });
-
-    it('exports assets for generated CSS background images', async () => {
-        const imageUrl = 'https://chatgpt.com/backend-api/generated/foo.webp';
-        const page = createDomPage(`
-            <!doctype html>
-            <button style="background-image: url('/backend-api/generated/foo.webp')"></button>
-        `, (window) => {
-            const button = window.document.querySelector('button');
-            button.getBoundingClientRect = () => ({ width: 512, height: 512 });
-            window.fetch = vi.fn().mockResolvedValue({
-                ok: true,
-                blob: async () => new window.Blob(['fake-image'], { type: 'image/webp' }),
-            });
-        });
-
-        await expect(getChatGPTImageAssets(page, [imageUrl])).resolves.toEqual([
-            expect.objectContaining({
-                url: imageUrl,
-                mimeType: 'image/webp',
-                width: 512,
-                height: 512,
-            }),
-        ]);
-    });
-});
-
-describe('chatgpt image upload helper', () => {
-    it('validates local images without a browser page', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-chatgpt-'));
-        tempDirs.push(dir);
-        const filePath = path.join(dir, 'cat.png');
-        fs.writeFileSync(filePath, 'fake-png');
-
-        await expect(prepareChatGPTImagePaths([filePath])).resolves.toEqual({ ok: true, paths: [filePath] });
-        await expect(prepareChatGPTImagePaths([path.join(dir, 'missing.png')])).resolves.toMatchObject({
-            ok: false,
-            reason: expect.stringContaining('Image not found'),
-        });
-    });
-
-    it('prefers Browser Bridge file input upload and waits for a preview', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-chatgpt-'));
-        tempDirs.push(dir);
-        const filePath = path.join(dir, 'cat.png');
-        fs.writeFileSync(filePath, 'fake-png');
-
-        const page = {
-            setFileInput: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue(true),
-        };
-
-        const result = await uploadChatGPTImages(page, [filePath]);
-
-        expect(result).toEqual({ ok: true, files: [filePath] });
-        expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[type="file"]');
-    });
-
-    it('rejects missing files before touching the page', async () => {
-        const page = {
-            setFileInput: vi.fn(),
-            wait: vi.fn(),
-            evaluate: vi.fn(),
-        };
-
-        const result = await uploadChatGPTImages(page, ['/no/such/cat.png']);
-
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('Image not found');
-        expect(page.setFileInput).not.toHaveBeenCalled();
-    });
-
-    it('rejects non-image extensions', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-chatgpt-'));
-        tempDirs.push(dir);
-        const filePath = path.join(dir, 'report.pdf');
-        fs.writeFileSync(filePath, 'fake');
-
-        const page = {
-            setFileInput: vi.fn(),
-            wait: vi.fn(),
-            evaluate: vi.fn(),
-        };
-
-        const result = await uploadChatGPTImages(page, [filePath]);
-
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('Unsupported image type');
-        expect(page.setFileInput).not.toHaveBeenCalled();
-    });
-
-    it('passes a React-compatible change event in fallback upload', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-chatgpt-'));
-        tempDirs.push(dir);
-        const filePath = path.join(dir, 'cat.png');
-        fs.writeFileSync(filePath, 'fake-png');
-
-        const page = {
-            setFileInput: vi.fn().mockRejectedValue(new Error('No element found')),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn((script) => {
-                if (String(script).includes('new DataTransfer()')) {
-                    return Promise.resolve({ ok: true });
-                }
-                return Promise.resolve(true);
-            }),
-        };
-
-        const result = await uploadChatGPTImages(page, [filePath]);
-
-        expect(result).toEqual({ ok: true, files: [filePath] });
-        const fallbackScript = page.evaluate.mock.calls
-            .map(([script]) => String(script))
-            .find(script => script.includes('new DataTransfer()'));
-        expect(fallbackScript).toContain('preventDefault()');
-        expect(fallbackScript).toContain('stopPropagation()');
-    });
-
-    it('exposes image MIME inference for fallback upload', () => {
-        expect(__test__.imageMimeFromPath('/tmp/a.png')).toBe('image/png');
-        expect(__test__.imageMimeFromPath('/tmp/a.webp')).toBe('image/webp');
-        expect(__test__.imageMimeFromPath('/tmp/a.jpg')).toBe('image/jpeg');
-    });
-});

package/clis/chatgpt-app/ax.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { __test__ } from './ax.js';
-
-describe('chatgpt-app AX send script', () => {
-    it('prefers the focused composer before falling back to the last editable input', () => {
-        expect(__test__.AX_SEND_SCRIPT).toContain('kAXFocusedUIElementAttribute');
-    });
-
-    it('fails fast when the AX set does not round-trip into the composer value', () => {
-        expect(__test__.AX_SEND_SCRIPT).toContain('Failed to verify input value after AX set');
-    });
-
-    it('does not report success until the prompt leaves the composer after send', () => {
-        expect(__test__.AX_SEND_SCRIPT).toContain('Prompt did not leave input after pressing send');
-    });
-
-    it('supports english, zh-CN, and zh-TW send button labels', () => {
-        expect(__test__.AX_SEND_SCRIPT).toContain('["发送", "傳送", "Send"]');
-    });
-});
-
-describe('chatgpt-app AX model script', () => {
-    it('supports english, zh-CN, and zh-TW options button labels', () => {
-        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "Options")');
-        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "选项")');
-        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "選項")');
-    });
-});
-
-describe('chatgpt-app generating detection', () => {
-    it('supports both english and zh-CN stop-generating labels', () => {
-        expect(__test__.AX_GENERATING_SCRIPT).toContain('Stop generating');
-        expect(__test__.AX_GENERATING_SCRIPT).toContain('停止生成');
-    });
-});