@sovovs/bycli 1.8.0 → 2.1.0

package/dist/src/convention-audit.test.js

@@ -1,247 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { renderConventionAuditText, runConventionAudit } from './convention-audit.js';
-describe('convention audit', () => {
-    const tempDirs = [];
-    afterEach(() => {
-        for (const dir of tempDirs.splice(0)) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    function makeProject(manifest, files) {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-convention-audit-'));
-        tempDirs.push(root);
-        fs.mkdirSync(path.join(root, 'clis'), { recursive: true });
-        fs.writeFileSync(path.join(root, 'cli-manifest.json'), JSON.stringify(manifest, null, 2));
-        for (const [relative, content] of Object.entries(files)) {
-            const file = path.join(root, 'clis', relative);
-            fs.mkdirSync(path.dirname(file), { recursive: true });
-            fs.writeFileSync(file, content);
-        }
-        return root;
-    }
-    it('reports column, metadata, typed-error, and write-pair violations', () => {
-        const root = makeProject([
-            {
-                site: 'demo',
-                name: 'search',
-                access: 'read',
-                columns: ['id', 'title', 'authorName'],
-                sourceFile: 'demo/search.js',
-            },
-            {
-                site: 'demo',
-                name: 'like',
-                access: 'write',
-                sourceFile: 'demo/like.js',
-            },
-            {
-                site: 'demo',
-                name: 'missing',
-                columns: [],
-                sourceFile: 'demo/missing.js',
-            },
-            {
-                site: 'clean',
-                name: 'search',
-                access: 'read',
-                columns: ['id', 'title'],
-                sourceFile: 'clean/search.js',
-            },
-        ], {
-            'demo/search.js': `
-        export async function run(kwargs) {
-          const limit = Math.min(kwargs.limit, 100);
-          try {
-            await fetch('/items');
-          } catch {
-            return [];
-          }
-          rows.push({
-            id: item.id,
-            title: item.title ?? 'unknown',
-            url: item.url,
-            authorName: item.authorName,
-          });
-          return limit;
-        }
-      `,
-            'demo/like.js': 'export async function run() { return { ok: true }; }',
-            'demo/missing.js': 'export async function run() { return { ok: true }; }',
-            'clean/search.js': 'export async function run() { rows.push({ id: item.id, title: item.title }); }',
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const category = (rule) => report.categories.find((item) => item.rule === rule);
-        expect(report.ok).toBe(false);
-        expect(category('silent-column-drop').violations[0]).toMatchObject({
-            command: 'demo/search',
-            details: expect.objectContaining({ missing: ['url'] }),
-        });
-        expect(category('camelCase-in-columns').violations[0]).toMatchObject({
-            command: 'demo/search',
-            details: { column: 'authorName' },
-        });
-        expect(category('missing-access-metadata').violations[0]).toMatchObject({ command: 'demo/missing' });
-        expect(category('silent-clamp').violations[0]).toMatchObject({ command: 'demo/search' });
-        expect(category('silent-empty-fallback').violations[0]).toMatchObject({ command: 'demo/search' });
-        expect(category('silent-sentinel').violations[0]).toMatchObject({ command: 'demo/search' });
-        expect(category('write-without-delete-pair').violations[0]).toMatchObject({
-            command: 'demo/like',
-            details: { expected_any_of: ['unlike'] },
-        });
-    });
-    it('supports site and command target filters', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'search', access: 'read', columns: ['id'], sourceFile: 'demo/search.js' },
-            { site: 'other', name: 'search', access: 'read', columns: ['id'], sourceFile: 'other/search.js' },
-        ], {
-            'demo/search.js': 'export async function run() { rows.push({ id: 1, hidden: true }); }',
-            'other/search.js': 'export async function run() { rows.push({ id: 1, hidden: true }); }',
-        });
-        expect(runConventionAudit({ projectRoot: root, site: 'demo' }).summary.commands).toBe(1);
-        expect(runConventionAudit({ projectRoot: root, target: 'other/search' }).summary.commands).toBe(1);
-        expect(runConventionAudit({ projectRoot: root, target: 'missing' }).summary.commands).toBe(0);
-    });
-    it('renders a compact text report', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'search', access: 'read', columns: ['id'], sourceFile: 'demo/search.js' },
-        ], {
-            'demo/search.js': 'export async function run() { rows.push({ id: 1 }); }',
-        });
-        const text = renderConventionAuditText(runConventionAudit({ projectRoot: root }));
-        expect(text).toContain('Convention Audit Report');
-        expect(text).toContain('OK - no convention violations found.');
-    });
-    it('scans pipeline map blocks for silent column drops', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'feed', access: 'read', columns: ['id', 'title'], sourceFile: 'demo/feed.js' },
-        ], {
-            'demo/feed.js': `
-        cli({
-          site: 'demo',
-          name: 'feed',
-          access: 'read',
-          columns: ['id', 'title'],
-          pipeline: [
-            { map: {
-              id: '\${{ item.id }}',
-              title: '\${{ item.title }}',
-              url: '\${{ item.url }}',
-            } },
-          ],
-        });
-      `,
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const violations = report.categories.find((item) => item.rule === 'silent-column-drop').violations;
-        expect(violations[0]).toMatchObject({
-            command: 'demo/feed',
-            details: expect.objectContaining({ missing: ['url'] }),
-        });
-    });
-    it('ignores ok:false diagnostic objects when checking emitted rows', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'search', access: 'read', columns: ['id', 'url'], sourceFile: 'demo/search.js' },
-        ], {
-            'demo/search.js': `
-        export async function run() {
-          if (!document.querySelector('.items')) {
-            return { ok: false, bodyLen: document.body.innerText.length, sample: document.body.innerText.slice(0, 800), url: location.href };
-          }
-          return rows.map((row) => ({ id: row.id, url: row.url }));
-        }
-      `,
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const violations = report.categories.find((item) => item.rule === 'silent-column-drop').violations;
-        expect(violations).toEqual([]);
-    });
-    it('ignores raw intermediate keys when a final mapper converts them into columns', () => {
-        const root = makeProject([
-            {
-                site: 'demo',
-                name: 'search',
-                access: 'read',
-                columns: ['id', 'rating', 'reviews', 'price'],
-                sourceFile: 'demo/search.js',
-            },
-        ], {
-            'demo/search.js': `
-        export async function run() {
-          rows.push({
-            id: item.id,
-            starClass: item.starClass,
-            reviewsRaw: item.reviewsRaw,
-            priceRaw: item.priceRaw,
-          });
-          return rows.map((r) => ({
-            id: r.id,
-            rating: r.starClass ? Number(r.starClass) / 10 : null,
-            reviews: parseReviewCount(r.reviewsRaw),
-            price: parsePrice(r.priceRaw),
-          }));
-        }
-      `,
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const violations = report.categories.find((item) => item.rule === 'silent-column-drop').violations;
-        expect(violations).toEqual([]);
-    });
-    it('still reports raw keys emitted directly without a final mapper', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'search', access: 'read', columns: ['id', 'title'], sourceFile: 'demo/search.js' },
-        ], {
-            'demo/search.js': `
-        export async function run() {
-          rows.push({
-            id: item.id,
-            title: titleRaw,
-            titleRaw,
-          });
-          return rows;
-        }
-      `,
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const violations = report.categories.find((item) => item.rule === 'silent-column-drop').violations;
-        expect(violations[0]).toMatchObject({
-            command: 'demo/search',
-            details: expect.objectContaining({ missing: ['titleRaw'] }),
-        });
-    });
-    it('only reports empty array fallbacks inside catch blocks', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'guard', access: 'read', columns: ['id'], sourceFile: 'demo/guard.js' },
-            { site: 'demo', name: 'catch', access: 'read', columns: ['id'], sourceFile: 'demo/catch.js' },
-        ], {
-            'demo/guard.js': 'export async function run() { if (!store) return []; rows.push({ id: 1 }); }',
-            'demo/catch.js': 'export async function run() { try { await fetch("/"); } catch (err) { return []; } rows.push({ id: 1 }); }',
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const violations = report.categories.find((item) => item.rule === 'silent-empty-fallback').violations;
-        expect(violations.map((violation) => violation.command)).toEqual(['demo/catch']);
-    });
-    it('does not report sentinel fallbacks inside thrown error messages', () => {
-        const root = makeProject([
-            { site: 'demo', name: 'error', access: 'read', columns: ['id'], sourceFile: 'demo/error.js' },
-            { site: 'demo', name: 'row', access: 'read', columns: ['id', 'title'], sourceFile: 'demo/row.js' },
-        ], {
-            'demo/error.js': `
-        export async function run(data) {
-          if (!data.ok) throw new Error(\`demo failed: \${data.message ?? 'unknown'}\`);
-          return [{ id: 1 }];
-        }
-      `,
-            'demo/row.js': `
-        export async function run(item) {
-          return [{ id: item.id, title: item.title ?? 'unknown' }];
-        }
-      `,
-        });
-        const report = runConventionAudit({ projectRoot: root });
-        const violations = report.categories.find((item) => item.rule === 'silent-sentinel').violations;
-        expect(violations.map((violation) => violation.command)).toEqual(['demo/row']);
-    });
-});

package/dist/src/daemon.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { COMMAND_RESULT_UNKNOWN_CODE, COMMAND_RESULT_UNKNOWN_HINT, buildCommandDispatchFailure, buildExtensionDisconnectFailure, commandResultUnknownMessage, getResponseCorsHeaders, } from './daemon-utils.js';
-describe('getResponseCorsHeaders', () => {
-    it('allows the Browser Bridge extension origin to read /ping', () => {
-        expect(getResponseCorsHeaders('/ping', 'chrome-extension://abc123')).toEqual({
-            'Access-Control-Allow-Origin': 'chrome-extension://abc123',
-            Vary: 'Origin',
-        });
-    });
-    it('does not add CORS headers for ordinary web origins', () => {
-        expect(getResponseCorsHeaders('/ping', 'https://example.com')).toBeUndefined();
-    });
-    it('does not add CORS headers when origin is absent', () => {
-        expect(getResponseCorsHeaders('/ping')).toBeUndefined();
-    });
-    it('does not add CORS headers for command endpoints even from the extension origin', () => {
-        expect(getResponseCorsHeaders('/command', 'chrome-extension://abc123')).toBeUndefined();
-    });
-});
-describe('daemon command dispatch', () => {
-    it('uses a distinct command_result_unknown contract for ambiguous dispatched commands', () => {
-        expect(COMMAND_RESULT_UNKNOWN_CODE).toBe('command_result_unknown');
-        expect(commandResultUnknownMessage('navigate')).toContain('navigate command was dispatched');
-        expect(COMMAND_RESULT_UNKNOWN_HINT).toContain('Inspect the browser/session state');
-        expect(COMMAND_RESULT_UNKNOWN_HINT).toContain('Do not blindly retry write commands');
-    });
-    it('classifies dispatched extension disconnects as command_result_unknown', () => {
-        expect(buildExtensionDisconnectFailure({
-            contextId: 'work',
-            action: 'navigate',
-            dispatched: true,
-        })).toEqual({
-            message: 'Browser connection dropped after the navigate command was dispatched; it may have completed.',
-            errorCode: 'command_result_unknown',
-            errorHint: COMMAND_RESULT_UNKNOWN_HINT,
-            status: 503,
-            countAsCommandResultUnknown: true,
-        });
-    });
-    it('classifies pre-dispatch extension disconnects as profile_disconnected', () => {
-        expect(buildExtensionDisconnectFailure({
-            contextId: 'work',
-            action: 'navigate',
-            dispatched: false,
-        })).toMatchObject({
-            message: 'Browser profile "work" disconnected before command dispatch',
-            errorCode: 'profile_disconnected',
-            status: 503,
-            countAsCommandResultUnknown: false,
-        });
-    });
-    it('classifies ws.send dispatch failures as profile_disconnected', () => {
-        expect(buildCommandDispatchFailure('work')).toMatchObject({
-            message: 'Browser profile "work" disconnected before command dispatch',
-            errorCode: 'profile_disconnected',
-            status: 503,
-            countAsCommandResultUnknown: false,
-        });
-    });
-});

package/dist/src/doctor.test.js

@@ -1,263 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockGetDaemonHealth, mockConnect, mockClose, mockFindShadowedUserAdapters } = vi.hoisted(() => ({
-    mockGetDaemonHealth: vi.fn(),
-    mockConnect: vi.fn(),
-    mockClose: vi.fn(),
-    mockFindShadowedUserAdapters: vi.fn(),
-}));
-vi.mock('./browser/daemon-client.js', () => ({
-    getDaemonHealth: mockGetDaemonHealth,
-}));
-vi.mock('./browser/index.js', () => ({
-    BrowserBridge: class {
-        connect = mockConnect;
-        close = mockClose;
-    },
-}));
-vi.mock('./adapter-shadow.js', async () => {
-    const actual = await vi.importActual('./adapter-shadow.js');
-    return {
-        ...actual,
-        findShadowedUserAdapters: mockFindShadowedUserAdapters,
-    };
-});
-import { renderBrowserDoctorReport, runBrowserDoctor } from './doctor.js';
-describe('doctor report rendering', () => {
-    const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockFindShadowedUserAdapters.mockReturnValue([]);
-        // Doctor always runs live connectivity. Tests that want connect to fail override.
-        mockConnect.mockResolvedValue({
-            evaluate: vi.fn().mockResolvedValue(2),
-            closeWindow: vi.fn().mockResolvedValue(undefined),
-        });
-        mockClose.mockResolvedValue(undefined);
-    });
-    it('renders OK-style report when daemon and extension connected', () => {
-        const text = strip(renderBrowserDoctorReport({
-            cliVersion: '1.7.9',
-            daemonRunning: true,
-            daemonVersion: '1.7.9',
-            extensionConnected: true,
-            extensionVersion: '1.6.8',
-            issues: [],
-        }));
-        expect(text).toContain('[OK] Daemon: running on port 19825');
-        expect(text).toContain('(v1.7.9)');
-        expect(text).toContain('[OK] Extension: connected (v1.6.8)');
-        expect(text).toContain('Everything looks good!');
-        expect(text).not.toContain('bycli browser analyze <url>');
-    });
-    it('renders a warning when daemon version is stale', () => {
-        const text = strip(renderBrowserDoctorReport({
-            cliVersion: '1.7.9',
-            daemonRunning: true,
-            daemonVersion: '1.7.6',
-            daemonStale: true,
-            extensionConnected: true,
-            extensionVersion: '1.0.3',
-            issues: ['Stale daemon detected: daemon v1.7.6 != CLI v1.7.9.\n  Run: bycli daemon restart'],
-        }));
-        expect(text).toContain('[WARN] Daemon: running on port 19825 (v1.7.6, stale; CLI v1.7.9)');
-        expect(text).toContain('Run: bycli daemon restart');
-        expect(text).not.toContain('Everything looks good!');
-    });
-    it('renders MISSING when daemon not running', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: false,
-            extensionConnected: false,
-            issues: ['Daemon is not running.'],
-        }));
-        expect(text).toContain('[MISSING] Daemon: not running');
-        expect(text).toContain('[MISSING] Extension: not connected');
-        expect(text).toContain('Daemon is not running.');
-    });
-    it('renders extension not connected when daemon is running', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: true,
-            extensionConnected: false,
-            issues: ['Daemon is running but the Chrome extension is not connected.'],
-        }));
-        expect(text).toContain('[OK] Daemon: running on port 19825');
-        expect(text).toContain('[MISSING] Extension: not connected');
-    });
-    it('renders a warning when the extension version is unknown', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: true,
-            extensionConnected: true,
-            issues: ['Extension is connected but did not report a version.'],
-        }));
-        expect(text).toContain('[WARN] Extension: connected (version unknown)');
-        expect(text).toContain('Extension is connected but did not report a version.');
-        expect(text).not.toContain('Everything looks good!');
-    });
-    it('renders connectivity OK when live test succeeds', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: true,
-            extensionConnected: true,
-            connectivity: { ok: true, durationMs: 1234 },
-            issues: [],
-        }));
-        expect(text).toContain('[OK] Connectivity: connected in 1.2s');
-    });
-    it('renders connected profiles when multiple are present', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: true,
-            extensionConnected: false,
-            profiles: [
-                { contextId: 'work', extensionConnected: true, extensionVersion: '1.2.3', pending: 0 },
-                { contextId: 'personal', extensionConnected: true, extensionVersion: '1.2.3', pending: 0 },
-            ],
-            issues: [],
-        }));
-        expect(text).toContain('Profiles:');
-        expect(text).toContain('work: connected v1.2.3');
-        expect(text).toContain('personal: connected v1.2.3');
-    });
-    it('renders unstable extension state when live connectivity and status disagree', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: true,
-            extensionConnected: true,
-            extensionFlaky: true,
-            connectivity: { ok: true, durationMs: 1234 },
-            issues: ['Extension connection is unstable.'],
-        }));
-        expect(text).toContain('[WARN] Extension: unstable');
-        expect(text).toContain('Extension connection is unstable.');
-    });
-    it('renders unstable daemon state when live connectivity and status disagree', () => {
-        const text = strip(renderBrowserDoctorReport({
-            daemonRunning: false,
-            daemonFlaky: true,
-            extensionConnected: false,
-            connectivity: { ok: true, durationMs: 1234 },
-            issues: ['Daemon connectivity is unstable.'],
-        }));
-        expect(text).toContain('[WARN] Daemon: unstable');
-        expect(text).toContain('Daemon connectivity is unstable.');
-    });
-    it('reports daemon not running when connectivity fails and daemon stays stopped', async () => {
-        mockConnect.mockRejectedValueOnce(new Error('Could not start daemon'));
-        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
-        const report = await runBrowserDoctor();
-        expect(report.daemonRunning).toBe(false);
-        expect(report.extensionConnected).toBe(false);
-        expect(report.connectivity?.ok).toBe(false);
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('Daemon is not running'),
-        ]));
-    });
-    it('reports flapping when live check succeeds but final status shows extension disconnected', async () => {
-        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
-        const report = await runBrowserDoctor();
-        expect(report.daemonRunning).toBe(true);
-        expect(report.extensionConnected).toBe(false);
-        expect(report.extensionFlaky).toBe(true);
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('Extension connection is unstable'),
-        ]));
-    });
-    it('reports daemon flapping when live check succeeds but daemon disappears afterward', async () => {
-        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
-        const report = await runBrowserDoctor();
-        expect(report.daemonRunning).toBe(false);
-        expect(report.daemonFlaky).toBe(true);
-        expect(report.extensionConnected).toBe(false);
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('Daemon connectivity is unstable'),
-        ]));
-    });
-    it('uses the fast default timeout for live connectivity checks', async () => {
-        let timeoutSeen;
-        const closeWindow = vi.fn().mockResolvedValue(undefined);
-        mockConnect.mockImplementationOnce(async (opts) => {
-            timeoutSeen = opts?.timeout;
-            expect(opts?.session).toBe('__doctor__');
-            expect(opts?.surface).toBe('browser');
-            return {
-                evaluate: vi.fn().mockResolvedValue(2),
-                closeWindow,
-            };
-        });
-        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'ready', status: { extensionConnected: true } });
-        await runBrowserDoctor();
-        expect(timeoutSeen).toBe(8);
-        expect(closeWindow).toHaveBeenCalledTimes(1);
-    });
-    it('reports an issue when the extension is connected but does not report a version', async () => {
-        const status = {
-            state: 'ready',
-            status: {
-                extensionConnected: true,
-                extensionVersion: undefined,
-            },
-        };
-        mockGetDaemonHealth.mockResolvedValue(status);
-        const report = await runBrowserDoctor();
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('did not report a version'),
-        ]));
-    });
-    it('reports an issue when daemon version differs from CLI version', async () => {
-        const status = {
-            state: 'ready',
-            status: {
-                daemonVersion: '1.7.6',
-                extensionConnected: true,
-                extensionVersion: '1.0.3',
-            },
-        };
-        mockGetDaemonHealth.mockResolvedValue(status);
-        const report = await runBrowserDoctor({ cliVersion: '1.7.9' });
-        expect(report.daemonStale).toBe(true);
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('Stale daemon detected: daemon v1.7.6 != CLI v1.7.9'),
-        ]));
-    });
-    it('reports local adapter shadows as a warning issue', async () => {
-        const status = {
-            state: 'ready',
-            status: {
-                daemonVersion: '1.7.9',
-                extensionConnected: true,
-                extensionVersion: '1.0.3',
-            },
-        };
-        mockGetDaemonHealth.mockResolvedValue(status);
-        mockFindShadowedUserAdapters.mockReturnValueOnce([
-            {
-                name: 'instagram/saved',
-                userPath: '/home/me/.bycli/clis/instagram/saved.js',
-                builtinPath: '/pkg/clis/instagram/saved.js',
-            },
-        ]);
-        const report = await runBrowserDoctor({ cliVersion: '1.7.9' });
-        expect(report.adapterShadows).toHaveLength(1);
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('Local adapter overrides shadow packaged adapters'),
-        ]));
-    });
-    it('reports profile-required when multiple profiles are connected without a selection', async () => {
-        const status = {
-            state: 'profile-required',
-            status: {
-                extensionConnected: false,
-                profileRequired: true,
-                profiles: [
-                    { contextId: 'work', extensionConnected: true, pending: 0 },
-                    { contextId: 'personal', extensionConnected: true, pending: 0 },
-                ],
-            },
-        };
-        mockGetDaemonHealth.mockResolvedValue(status);
-        // Real connectivity would fail in profile-required state; force it here so
-        // the test exercises the profile-required issue path, not the flaky path.
-        mockConnect.mockRejectedValueOnce(new Error('profile required'));
-        const report = await runBrowserDoctor();
-        expect(report.profiles).toHaveLength(2);
-        expect(report.issues).toEqual(expect.arrayContaining([
-            expect.stringContaining('Multiple Chrome profiles are connected'),
-        ]));
-    });
-});