@sovovs/bycli 1.8.0 → 2.1.0

package/dist/src/commanderAdapter.test.js

@@ -1,352 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { Command } from 'commander';
-import { attachTraceReceipt, EmptyResultError, selectorError } from './errors.js';
-const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
-    mockExecuteCommand: vi.fn(),
-    mockRenderOutput: vi.fn(),
-}));
-vi.mock('./execution.js', async () => {
-    const actual = await vi.importActual('./execution.js');
-    return {
-        ...actual,
-        executeCommand: mockExecuteCommand,
-    };
-});
-vi.mock('./output.js', () => ({
-    render: mockRenderOutput,
-}));
-import { registerCommandToProgram } from './commanderAdapter.js';
-describe('commanderAdapter arg passing', () => {
-    const cmd = {
-        site: 'paperreview',
-        name: 'submit', access: 'read',
-        description: 'Submit a PDF',
-        browser: false,
-        args: [
-            { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
-            { name: 'dry-run', type: 'bool', default: false, help: 'Validate only' },
-            { name: 'prepare-only', type: 'bool', default: false, help: 'Prepare only' },
-        ],
-        func: vi.fn(),
-    };
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockExecuteCommand.mockResolvedValue([]);
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('passes bool flag values through to executeCommand for coercion', async () => {
-        const program = new Command();
-        const siteCmd = program.command('paperreview');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'false']);
-        expect(mockExecuteCommand).toHaveBeenCalled();
-        const kwargs = mockExecuteCommand.mock.calls[0][1];
-        expect(kwargs.pdf).toBe('./paper.pdf');
-        expect(kwargs).toHaveProperty('dry-run');
-    });
-    it('passes valueless bool flags as true to executeCommand', async () => {
-        const program = new Command();
-        const siteCmd = program.command('paperreview');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
-        expect(mockExecuteCommand).toHaveBeenCalled();
-        const kwargs = mockExecuteCommand.mock.calls[0][1];
-        expect(kwargs.pdf).toBe('./paper.pdf');
-        expect(kwargs['prepare-only']).toBe(true);
-    });
-    it('passes option value sources through for adapters that need explicit-vs-default semantics', async () => {
-        const program = new Command();
-        const siteCmd = program.command('paperreview');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
-        expect(mockExecuteCommand).toHaveBeenCalled();
-        const kwargs = mockExecuteCommand.mock.calls[0][1];
-        expect(kwargs.__bycliOptionSources).toMatchObject({
-            'prepare-only': 'cli',
-        });
-    });
-    it('passes explicit trace mode to executeCommand', async () => {
-        const program = new Command();
-        const siteCmd = program.command('paperreview');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'paperreview', 'submit', './paper.pdf', '--trace', 'retain-on-failure']);
-        expect(mockExecuteCommand).toHaveBeenCalledWith(expect.objectContaining({ site: 'paperreview', name: 'submit' }), expect.objectContaining({ pdf: './paper.pdf' }), false, { prepared: true, trace: 'retain-on-failure' });
-    });
-    it('rejects invalid bool values before calling executeCommand', async () => {
-        const program = new Command();
-        const siteCmd = program.command('paperreview');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
-        // prepareCommandArgs validates bools before dispatch; executeCommand should not be reached
-        expect(mockExecuteCommand).not.toHaveBeenCalled();
-    });
-});
-describe('commanderAdapter boolean alias support', () => {
-    const cmd = {
-        site: 'reddit',
-        name: 'save', access: 'read',
-        description: 'Save a post',
-        browser: false,
-        args: [
-            { name: 'post-id', positional: true, required: true, help: 'Post ID' },
-            { name: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },
-        ],
-        func: vi.fn(),
-    };
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockExecuteCommand.mockResolvedValue([]);
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('coerces default false for boolean args to a real boolean', async () => {
-        const program = new Command();
-        const siteCmd = program.command('reddit');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'reddit', 'save', 't3_abc123']);
-        expect(mockExecuteCommand).toHaveBeenCalled();
-        const kwargs = mockExecuteCommand.mock.calls[0][1];
-        expect(kwargs['post-id']).toBe('t3_abc123');
-        expect(kwargs.undo).toBe(false);
-    });
-    it('coerces explicit false for boolean args to a real boolean', async () => {
-        const program = new Command();
-        const siteCmd = program.command('reddit');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'reddit', 'save', 't3_abc123', '--undo', 'false']);
-        expect(mockExecuteCommand).toHaveBeenCalled();
-        const kwargs = mockExecuteCommand.mock.calls[0][1];
-        expect(kwargs.undo).toBe(false);
-    });
-});
-describe('commanderAdapter value-required optional options', () => {
-    const cmd = {
-        site: 'instagram',
-        name: 'post', access: 'read',
-        description: 'Post to Instagram',
-        browser: true,
-        args: [
-            { name: 'image', valueRequired: true, help: 'Single image path' },
-            { name: 'images', valueRequired: true, help: 'Comma-separated image paths' },
-            { name: 'content', positional: true, required: false, help: 'Caption text' },
-        ],
-        validateArgs: (kwargs) => {
-            if (!kwargs.image && !kwargs.images) {
-                throw new Error('media required');
-            }
-        },
-        func: vi.fn(),
-    };
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockExecuteCommand.mockResolvedValue([]);
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('requires a value when --image is present', async () => {
-        const program = new Command();
-        program.exitOverride();
-        const siteCmd = program.command('instagram');
-        registerCommandToProgram(siteCmd, cmd);
-        await expect(program.parseAsync(['node', 'bycli', 'instagram', 'post', '--image'])).rejects.toMatchObject({ code: 'commander.optionMissingArgument' });
-        expect(mockExecuteCommand).not.toHaveBeenCalled();
-    });
-    it('runs validateArgs before executeCommand so missing media does not dispatch the browser command', async () => {
-        const program = new Command();
-        const siteCmd = program.command('instagram');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'instagram', 'post', 'caption only']);
-        expect(mockExecuteCommand).not.toHaveBeenCalled();
-        expect(process.exitCode).toBeDefined();
-    });
-});
-describe('commanderAdapter command aliases', () => {
-    const cmd = {
-        site: 'notebooklm',
-        name: 'get',
-        access: 'read',
-        aliases: ['metadata'],
-        description: 'Get notebook metadata',
-        browser: false,
-        args: [],
-        func: vi.fn(),
-    };
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockExecuteCommand.mockResolvedValue([]);
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('registers aliases with Commander so compatibility names execute the same command', async () => {
-        const program = new Command();
-        const siteCmd = program.command('notebooklm');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'notebooklm', 'metadata']);
-        expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false, { prepared: true });
-    });
-});
-describe('commanderAdapter validation preparation', () => {
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockExecuteCommand.mockResolvedValue([]);
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('prepares args once before dispatching to executeCommand', async () => {
-        const validateArgs = vi.fn();
-        const program = new Command();
-        const siteCmd = program.command('test');
-        registerCommandToProgram(siteCmd, {
-            site: 'test',
-            name: 'run', access: 'read',
-            description: 'Run test command',
-            browser: false,
-            args: [{ name: 'count', default: '1', help: 'Count' }],
-            validateArgs,
-            func: vi.fn(),
-        });
-        await program.parseAsync(['node', 'bycli', 'test', 'run']);
-        expect(validateArgs).toHaveBeenCalledTimes(1);
-        expect(mockExecuteCommand).toHaveBeenCalledWith(expect.objectContaining({ site: 'test', name: 'run' }), { count: '1' }, false, { prepared: true });
-    });
-});
-describe('commanderAdapter default formats', () => {
-    const cmd = {
-        site: 'gemini',
-        name: 'ask', access: 'read',
-        description: 'Ask Gemini',
-        browser: false,
-        args: [],
-        columns: ['response'],
-        defaultFormat: 'plain',
-        func: vi.fn(),
-    };
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockExecuteCommand.mockResolvedValue([{ response: 'hello' }]);
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('uses the command defaultFormat when the user keeps the default table format', async () => {
-        const program = new Command();
-        const siteCmd = program.command('gemini');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'gemini', 'ask']);
-        expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'plain' }));
-    });
-    it('respects an explicit user format over the command defaultFormat', async () => {
-        const program = new Command();
-        const siteCmd = program.command('gemini');
-        registerCommandToProgram(siteCmd, cmd);
-        await program.parseAsync(['node', 'bycli', 'gemini', 'ask', '--format', 'json']);
-        expect(mockRenderOutput).toHaveBeenCalledWith([{ response: 'hello' }], expect.objectContaining({ fmt: 'json' }));
-    });
-});
-describe('commanderAdapter error envelope output', () => {
-    const cmd = {
-        site: 'xiaohongshu',
-        name: 'note', access: 'read',
-        description: 'Read one note',
-        browser: false,
-        args: [
-            { name: 'note-id', positional: true, required: true, help: 'Note ID' },
-        ],
-        func: vi.fn(),
-    };
-    beforeEach(() => {
-        mockExecuteCommand.mockReset();
-        mockRenderOutput.mockReset();
-        delete process.env.BYCLI_VERBOSE;
-        process.exitCode = undefined;
-    });
-    it('outputs YAML error envelope with adapter hint to stderr', async () => {
-        const program = new Command();
-        const siteCmd = program.command('xiaohongshu');
-        registerCommandToProgram(siteCmd, cmd);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        mockExecuteCommand.mockRejectedValueOnce(new EmptyResultError('xiaohongshu/note', 'Pass the full search_result URL with xsec_token instead of a bare note ID.'));
-        await program.parseAsync(['node', 'bycli', 'xiaohongshu', 'note', '69ca3927000000001a020fd5']);
-        const output = stderrSpy.mock.calls.map(c => String(c[0])).join('');
-        expect(output).toContain('ok: false');
-        expect(output).toContain('code: EMPTY_RESULT');
-        expect(output).toContain('xsec_token');
-        expect(output).toContain('--trace=retain-on-failure');
-        expect(output).toContain('bycli xiaohongshu note --trace retain-on-failure');
-        stderrSpy.mockRestore();
-    });
-    it('outputs YAML error envelope for selector errors', async () => {
-        const program = new Command();
-        const siteCmd = program.command('xiaohongshu');
-        registerCommandToProgram(siteCmd, cmd);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        mockExecuteCommand.mockRejectedValueOnce(selectorError('.note-title', 'The note title selector no longer matches the current page.'));
-        await program.parseAsync(['node', 'bycli', 'xiaohongshu', 'note', '69ca3927000000001a020fd5']);
-        const output = stderrSpy.mock.calls.map(c => String(c[0])).join('');
-        expect(output).toContain('ok: false');
-        expect(output).toContain('code: SELECTOR');
-        expect(output).toContain('selector no longer matches');
-        expect(output).toContain('--trace=retain-on-failure');
-        stderrSpy.mockRestore();
-    });
-    it('does not add an AutoFix rerun hint when trace is already enabled', async () => {
-        const program = new Command();
-        const siteCmd = program.command('xiaohongshu');
-        registerCommandToProgram(siteCmd, cmd);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        mockExecuteCommand.mockRejectedValueOnce(selectorError('.note-title'));
-        await program.parseAsync([
-            'node',
-            'bycli',
-            'xiaohongshu',
-            'note',
-            '69ca3927000000001a020fd5',
-            '--trace',
-            'retain-on-failure',
-        ]);
-        const output = stderrSpy.mock.calls.map(c => String(c[0])).join('');
-        expect(output).toContain('code: SELECTOR');
-        expect(output).not.toContain('AutoFix: re-run');
-        stderrSpy.mockRestore();
-    });
-    it('includes trace metadata from the error envelope when execution attached it', async () => {
-        const program = new Command();
-        const siteCmd = program.command('xiaohongshu');
-        registerCommandToProgram(siteCmd, cmd);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const err = selectorError('.note-title');
-        attachTraceReceipt(err, {
-            schemaVersion: 1,
-            bycliVersion: '1.7.8',
-            traceId: 'trace-1',
-            traceDir: '/tmp/bycli/profiles/default/traces/trace-1',
-            summaryPath: '/tmp/bycli/profiles/default/traces/trace-1/summary.md',
-            receiptPath: '/tmp/bycli/profiles/default/traces/trace-1/receipt.json',
-            status: 'failure',
-            createdAt: '2026-05-03T00:00:00.000Z',
-            error: { code: 'SELECTOR', message: 'Could not find element: .note-title' },
-        });
-        mockExecuteCommand.mockRejectedValueOnce(err);
-        await program.parseAsync([
-            'node',
-            'bycli',
-            'xiaohongshu',
-            'note',
-            '69ca3927000000001a020fd5',
-            '--trace',
-            'retain-on-failure',
-        ]);
-        const output = stderrSpy.mock.calls.map(c => String(c[0])).join('');
-        expect(output).toContain('trace:');
-        expect(output).toContain('dir: /tmp/bycli/profiles/default/traces/trace-1');
-        expect(output).toContain('summaryPath: /tmp/bycli/profiles/default/traces/trace-1/summary.md');
-        expect(output).toContain('receiptPath: /tmp/bycli/profiles/default/traces/trace-1/receipt.json');
-        stderrSpy.mockRestore();
-    });
-});

package/dist/src/commands/daemon.test.js

@@ -1,219 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const { fetchDaemonStatusMock, requestDaemonShutdownMock, restartDaemonMock, } = vi.hoisted(() => ({
-    fetchDaemonStatusMock: vi.fn(),
-    requestDaemonShutdownMock: vi.fn(),
-    restartDaemonMock: vi.fn(),
-}));
-vi.mock('../browser/daemon-client.js', () => ({
-    fetchDaemonStatus: fetchDaemonStatusMock,
-    requestDaemonShutdown: requestDaemonShutdownMock,
-}));
-vi.mock('../browser/daemon-lifecycle.js', () => ({
-    restartDaemon: restartDaemonMock,
-}));
-import { daemonRestart, daemonStatus, daemonStop } from './daemon.js';
-import { PKG_VERSION } from '../version.js';
-describe('daemonStatus', () => {
-    let stdoutSpy;
-    beforeEach(() => {
-        stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-        fetchDaemonStatusMock.mockReset();
-        requestDaemonShutdownMock.mockReset();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('reports "not running" when daemon is unreachable', async () => {
-        fetchDaemonStatusMock.mockResolvedValue(null);
-        await daemonStatus();
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    });
-    it('shows daemon info when running', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 12345,
-            uptime: 3661,
-            daemonVersion: PKG_VERSION,
-            extensionConnected: true,
-            extensionVersion: '1.6.8',
-            pending: 0,
-            memoryMB: 64,
-            port: 19825,
-        });
-        await daemonStatus();
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining(`v${PKG_VERSION}`));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
-    });
-    it('shows disconnected when extension is not connected', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 99,
-            uptime: 120,
-            daemonVersion: PKG_VERSION,
-            extensionConnected: false,
-            pending: 0,
-            memoryMB: 32,
-            port: 19825,
-        });
-        await daemonStatus();
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
-    });
-    it('shows version unknown when the connected extension does not report one', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 99,
-            uptime: 120,
-            daemonVersion: PKG_VERSION,
-            extensionConnected: true,
-            extensionVersion: undefined,
-            pending: 0,
-            memoryMB: 32,
-            port: 19825,
-        });
-        await daemonStatus();
-        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('version unknown'));
-    });
-});
-describe('daemonStop', () => {
-    let stderrSpy;
-    beforeEach(() => {
-        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        fetchDaemonStatusMock.mockReset();
-        requestDaemonShutdownMock.mockReset();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('reports "not running" when daemon is unreachable', async () => {
-        fetchDaemonStatusMock.mockResolvedValue(null);
-        await daemonStop();
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    });
-    it('sends shutdown and reports success', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 12345,
-            uptime: 100,
-            daemonVersion: PKG_VERSION,
-            extensionConnected: true,
-            pending: 0,
-            memoryMB: 50,
-            port: 19825,
-        });
-        requestDaemonShutdownMock.mockResolvedValue(true);
-        await daemonStop();
-        expect(requestDaemonShutdownMock).toHaveBeenCalledTimes(1);
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon stopped'));
-    });
-    it('reports failure when shutdown request fails', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 12345,
-            uptime: 100,
-            daemonVersion: PKG_VERSION,
-            extensionConnected: true,
-            pending: 0,
-            memoryMB: 50,
-            port: 19825,
-        });
-        requestDaemonShutdownMock.mockResolvedValue(false);
-        await daemonStop();
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
-    });
-});
-describe('daemonRestart', () => {
-    let stderrSpy;
-    beforeEach(() => {
-        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        fetchDaemonStatusMock.mockReset();
-        requestDaemonShutdownMock.mockReset();
-        restartDaemonMock.mockReset();
-        process.exitCode = undefined;
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-        process.exitCode = undefined;
-    });
-    it('restarts a running daemon and reports the new version', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 12345,
-            uptime: 100,
-            daemonVersion: '1.7.6',
-            extensionConnected: true,
-            profiles: [{ contextId: 'work', extensionConnected: true, pending: 0 }],
-            pending: 0,
-            memoryMB: 50,
-            port: 19825,
-        });
-        restartDaemonMock.mockResolvedValue({
-            previousStatus: { daemonVersion: '1.7.6' },
-            stopped: true,
-            spawned: true,
-            status: {
-                ok: true,
-                pid: 12346,
-                uptime: 1,
-                daemonVersion: PKG_VERSION,
-                extensionConnected: true,
-                profiles: [{ contextId: 'work', extensionConnected: true, pending: 0 }],
-                pending: 0,
-                memoryMB: 51,
-                port: 19825,
-            },
-        });
-        await daemonRestart();
-        expect(restartDaemonMock).toHaveBeenCalledTimes(1);
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('will disconnect 1 browser profile'));
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon restarted on port 19825 (v${PKG_VERSION})`));
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Extension connected; profiles connected: 1'));
-    });
-    it('starts a new daemon when none was running', async () => {
-        fetchDaemonStatusMock.mockResolvedValue(null);
-        restartDaemonMock.mockResolvedValue({
-            previousStatus: null,
-            stopped: true,
-            spawned: true,
-            status: {
-                ok: true,
-                pid: 12346,
-                uptime: 1,
-                daemonVersion: PKG_VERSION,
-                extensionConnected: false,
-                pending: 0,
-                memoryMB: 51,
-                port: 19825,
-            },
-        });
-        await daemonRestart();
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon started on port 19825 (v${PKG_VERSION})`));
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('extension has not connected yet'));
-    });
-    it('reports failure when the daemon cannot stop', async () => {
-        fetchDaemonStatusMock.mockResolvedValue({
-            ok: true,
-            pid: 12345,
-            uptime: 100,
-            daemonVersion: '1.7.6',
-            extensionConnected: true,
-            pending: 0,
-            memoryMB: 50,
-            port: 19825,
-        });
-        restartDaemonMock.mockResolvedValue({
-            previousStatus: { daemonVersion: '1.7.6' },
-            status: { daemonVersion: '1.7.6' },
-            stopped: false,
-            spawned: false,
-        });
-        await daemonRestart();
-        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon before restart'));
-        expect(process.exitCode).toBe(1);
-    });
-});

package/dist/src/completion.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-const { mockGetRegistry } = vi.hoisted(() => ({
-    mockGetRegistry: vi.fn(() => new Map([
-        ['github/issues', { site: 'github', name: 'issues' }],
-    ])),
-}));
-vi.mock('./registry.js', () => ({
-    getRegistry: mockGetRegistry,
-}));
-import { getCompletions } from './completion.js';
-describe('getCompletions', () => {
-    it('includes top-level built-ins that are registered outside the site registry', () => {
-        const completions = getCompletions([], 1);
-        expect(completions).toContain('plugin');
-        expect(completions).toContain('external');
-        expect(completions).not.toContain('install');
-        expect(completions).not.toContain('register');
-        expect(completions).not.toContain('setup');
-    });
-    it('still includes discovered site names', () => {
-        const completions = getCompletions([], 1);
-        expect(completions).toContain('github');
-    });
-});