@sovovs/bycli 1.8.0 → 2.0.0

package/dist/src/engine.test.js

@@ -1,312 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { discoverClis, discoverPlugins, ensureUserCliCompatShims, ensureUserAdapters, PLUGINS_DIR } from './discovery.js';
-import { executeCommand } from './execution.js';
-import { getRegistry, cli, Strategy } from './registry.js';
-import { clearAllHooks, onAfterExecute } from './hooks.js';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { pathToFileURL } from 'node:url';
-describe('discoverClis', () => {
-    it('handles non-existent directories gracefully', async () => {
-        // Should not throw for missing directories
-        await expect(discoverClis(path.join(os.tmpdir(), 'nonexistent-bycli-test-dir'))).resolves.not.toThrow();
-    });
-    it('imports only CLI command modules during filesystem discovery', async () => {
-        const tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bycli-discovery-'));
-        const siteDir = path.join(tempRoot, 'temp-site');
-        const helperPath = path.join(siteDir, 'helper.js');
-        const commandPath = path.join(siteDir, 'hello.js');
-        try {
-            await fs.promises.mkdir(siteDir, { recursive: true });
-            await fs.promises.writeFile(helperPath, `
-globalThis.__bycli_helper_loaded__ = true;
-export const helper = true;
-`);
-            await fs.promises.writeFile(commandPath, `
-import { cli, Strategy } from '${pathToFileURL(path.join(process.cwd(), 'src', 'registry.ts')).href}';
-cli({
-  site: 'temp-site',
-  name: 'hello', access: 'read',
-  description: 'hello command',
-  strategy: Strategy.PUBLIC,
-  browser: false,
-  func: async () => [{ ok: true }],
-});
-`);
-            delete globalThis.__bycli_helper_loaded__;
-            await discoverClis(tempRoot);
-            expect(globalThis.__bycli_helper_loaded__).toBeUndefined();
-            expect(getRegistry().get('temp-site/hello')).toBeDefined();
-        }
-        finally {
-            delete globalThis.__bycli_helper_loaded__;
-            await fs.promises.rm(tempRoot, { recursive: true, force: true });
-        }
-    });
-    it('falls back to filesystem discovery when the manifest is invalid', async () => {
-        const tempBuildRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bycli-manifest-fallback-'));
-        const distDir = path.join(tempBuildRoot, 'dist');
-        const siteDir = path.join(distDir, 'fallback-site');
-        const commandPath = path.join(siteDir, 'hello.js');
-        const manifestPath = path.join(tempBuildRoot, 'cli-manifest.json');
-        try {
-            await fs.promises.mkdir(siteDir, { recursive: true });
-            await fs.promises.writeFile(manifestPath, '{ invalid json');
-            await fs.promises.writeFile(commandPath, `
-import { cli, Strategy } from '${pathToFileURL(path.join(process.cwd(), 'src', 'registry.ts')).href}';
-cli({
-  site: 'fallback-site',
-  name: 'hello', access: 'read',
-  description: 'hello command',
-  strategy: Strategy.PUBLIC,
-  browser: false,
-  func: async () => [{ ok: true }],
-});
-`);
-            await discoverClis(distDir);
-            expect(getRegistry().get('fallback-site/hello')).toBeDefined();
-        }
-        finally {
-            await fs.promises.rm(tempBuildRoot, { recursive: true, force: true });
-        }
-    });
-    it('loads user CLI modules via package exports symlink', async () => {
-        const tempBycliRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bycli-user-clis-'));
-        const userClisDir = path.join(tempBycliRoot, 'clis');
-        const siteDir = path.join(userClisDir, 'legacy-site');
-        const commandPath = path.join(siteDir, 'hello.js');
-        try {
-            await ensureUserCliCompatShims(tempBycliRoot);
-            await fs.promises.mkdir(siteDir, { recursive: true });
-            await fs.promises.writeFile(commandPath, `
-import { cli, Strategy } from '@sovovs/bycli/registry';
-import { CommandExecutionError } from '@sovovs/bycli/errors';
-import { htmlToMarkdown } from '@sovovs/bycli/utils';
-
-cli({
-  site: 'legacy-site',
-  name: 'hello', access: 'read',
-  description: 'hello command',
-  strategy: Strategy.PUBLIC,
-  browser: false,
-  func: async () => [{ ok: true, errorName: new CommandExecutionError('boom').name, markdown: htmlToMarkdown('<p>hello</p>') }],
-});
-`);
-            await discoverClis(userClisDir);
-            const cmd = getRegistry().get('legacy-site/hello');
-            expect(cmd).toBeDefined();
-            await expect(executeCommand(cmd, {})).resolves.toEqual([{ ok: true, errorName: 'CommandExecutionError', markdown: 'hello' }]);
-        }
-        finally {
-            await fs.promises.rm(tempBycliRoot, { recursive: true, force: true });
-        }
-    });
-});
-describe('ensureUserAdapters', () => {
-    it('creates user clis directory without triggering full copy', async () => {
-        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bycli-ensure-'));
-        const clisDir = path.join(tempDir, 'clis');
-        try {
-            // Patch USER_CLIS_DIR is not easy, so we test the function behavior indirectly:
-            // ensureUserAdapters should not throw and should be very fast (no fetch script)
-            const start = Date.now();
-            await ensureUserAdapters();
-            const elapsed = Date.now() - start;
-            // Should complete quickly (< 1s) since it only creates a directory
-            expect(elapsed).toBeLessThan(1000);
-        }
-        finally {
-            await fs.promises.rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('discoverClis handles empty user directory gracefully', async () => {
-        const emptyDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bycli-empty-'));
-        try {
-            // Should not throw for an empty directory (no adapters to discover)
-            await expect(discoverClis(emptyDir)).resolves.not.toThrow();
-        }
-        finally {
-            await fs.promises.rm(emptyDir, { recursive: true, force: true });
-        }
-    });
-});
-describe('discoverPlugins', () => {
-    const testPluginDir = path.join(PLUGINS_DIR, '__test-plugin__');
-    const yamlPath = path.join(testPluginDir, 'greeting.yaml');
-    const symlinkTargetDir = path.join(os.tmpdir(), '__test-plugin-symlink-target__');
-    const symlinkPluginDir = path.join(PLUGINS_DIR, '__test-plugin-symlink__');
-    const brokenSymlinkDir = path.join(PLUGINS_DIR, '__test-plugin-broken__');
-    const dirSymlinkType = process.platform === 'win32' ? 'junction' : 'dir';
-    afterEach(async () => {
-        try {
-            await fs.promises.rm(testPluginDir, { recursive: true });
-        }
-        catch { }
-        try {
-            await fs.promises.rm(symlinkPluginDir, { recursive: true, force: true });
-        }
-        catch { }
-        try {
-            await fs.promises.rm(symlinkTargetDir, { recursive: true, force: true });
-        }
-        catch { }
-        try {
-            await fs.promises.rm(brokenSymlinkDir, { recursive: true, force: true });
-        }
-        catch { }
-    });
-    it('ignores YAML files in plugin directories (YAML format removed)', async () => {
-        await fs.promises.mkdir(testPluginDir, { recursive: true });
-        await fs.promises.writeFile(yamlPath, `
-site: __test-plugin__
-name: greeting
-description: Test plugin greeting
-strategy: public
-browser: false
-`);
-        await discoverPlugins();
-        const registry = getRegistry();
-        const cmd = registry.get('__test-plugin__/greeting');
-        expect(cmd).toBeUndefined();
-    });
-    it('handles non-existent plugins directory gracefully', async () => {
-        // discoverPlugins should not throw if ~/.bycli/plugins/ does not exist
-        await expect(discoverPlugins()).resolves.not.toThrow();
-    });
-    it('ignores YAML files in symlinked plugin directories (YAML format removed)', async () => {
-        await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
-        await fs.promises.mkdir(symlinkTargetDir, { recursive: true });
-        await fs.promises.writeFile(path.join(symlinkTargetDir, 'hello.yaml'), `
-site: __test-plugin-symlink__
-name: hello
-description: Test plugin greeting via symlink
-strategy: public
-browser: false
-`);
-        await fs.promises.symlink(symlinkTargetDir, symlinkPluginDir, dirSymlinkType);
-        await discoverPlugins();
-        const cmd = getRegistry().get('__test-plugin-symlink__/hello');
-        expect(cmd).toBeUndefined();
-    });
-    it('skips broken plugin symlinks without throwing', async () => {
-        await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
-        await fs.promises.symlink(path.join(os.tmpdir(), '__missing-plugin-target__'), brokenSymlinkDir, dirSymlinkType);
-        await expect(discoverPlugins()).resolves.not.toThrow();
-        expect(getRegistry().get('__test-plugin-broken__/hello')).toBeUndefined();
-    });
-});
-describe('executeCommand', () => {
-    beforeEach(() => {
-        clearAllHooks();
-        vi.unstubAllEnvs();
-    });
-    it('accepts kebab-case option names after Commander camelCases them', async () => {
-        const cmd = cli({
-            site: 'test-engine',
-            name: 'kebab-arg-test', access: 'read',
-            description: 'test command with kebab-case arg',
-            browser: false,
-            strategy: Strategy.PUBLIC,
-            args: [
-                { name: 'note-id', required: true, help: 'Note ID' },
-            ],
-            func: async (kwargs) => [{ noteId: kwargs['note-id'] }],
-        });
-        const result = await executeCommand(cmd, { 'note-id': 'abc123' });
-        expect(result).toEqual([{ noteId: 'abc123' }]);
-    });
-    it('executes a command with func', async () => {
-        const cmd = cli({
-            site: 'test-engine',
-            name: 'func-test', access: 'read',
-            description: 'test command with func',
-            browser: false,
-            strategy: Strategy.PUBLIC,
-            func: async (kwargs) => {
-                return [{ title: kwargs.query ?? 'default' }];
-            },
-        });
-        const result = await executeCommand(cmd, { query: 'hello' });
-        expect(result).toEqual([{ title: 'hello' }]);
-    });
-    it('executes a command with pipeline', async () => {
-        const cmd = cli({
-            site: 'test-engine',
-            name: 'pipe-test', access: 'read',
-            description: 'test command with pipeline',
-            browser: false,
-            strategy: Strategy.PUBLIC,
-            pipeline: [
-                { evaluate: '() => [{ n: 1 }, { n: 2 }, { n: 3 }]' },
-                { limit: '2' },
-            ],
-        });
-        // Pipeline commands require page for evaluate step, so we'll test the error path
-        await expect(executeCommand(cmd, {})).rejects.toThrow();
-    });
-    it('throws for command with no func or pipeline', async () => {
-        const cmd = cli({
-            site: 'test-engine',
-            name: 'empty-test', access: 'read',
-            description: 'empty command',
-            browser: false,
-        });
-        await expect(executeCommand(cmd, {})).rejects.toThrow('has no func or pipeline');
-    });
-    it('passes debug flag to func', async () => {
-        let receivedDebug = false;
-        const cmd = cli({
-            site: 'test-engine',
-            name: 'debug-test', access: 'read',
-            description: 'debug test',
-            browser: false,
-            func: async (_kwargs, debug) => {
-                receivedDebug = debug ?? false;
-                return [];
-            },
-        });
-        await executeCommand(cmd, {}, true);
-        expect(receivedDebug).toBe(true);
-    });
-    it('fires onAfterExecute even when command execution throws', async () => {
-        const seen = [];
-        onAfterExecute((ctx) => {
-            seen.push({ error: ctx.error, finishedAt: ctx.finishedAt });
-        });
-        const cmd = cli({
-            site: 'test-engine',
-            name: 'failing-test', access: 'read',
-            description: 'failing command',
-            browser: false,
-            strategy: Strategy.PUBLIC,
-            func: async () => {
-                throw new Error('boom');
-            },
-        });
-        await expect(executeCommand(cmd, {})).rejects.toThrow('boom');
-        expect(seen).toHaveLength(1);
-        expect(seen[0].error).toBeInstanceOf(Error);
-        expect(seen[0].error.message).toBe('boom');
-        expect(typeof seen[0].finishedAt).toBe('number');
-    });
-    it('uses launcher for registered Electron apps (chatwise)', async () => {
-        // Mock the launcher to return a fake endpoint (avoids real HTTP/process calls)
-        const launcher = await import('./launcher.js');
-        const spy = vi.spyOn(launcher, 'resolveElectronEndpoint')
-            .mockResolvedValue('http://127.0.0.1:9228');
-        const cmd = cli({
-            site: 'chatwise',
-            name: 'status', access: 'read',
-            description: 'chatwise status',
-            browser: true,
-            strategy: Strategy.PUBLIC,
-            func: async () => [{ ok: true }],
-        });
-        // CDPBridge.connect() will fail (no actual CDP server), but the launcher
-        // should have been called with 'chatwise'.
-        await expect(executeCommand(cmd, {})).rejects.toThrow();
-        expect(spy).toHaveBeenCalledWith('chatwise');
-        spy.mockRestore();
-    });
-});

package/dist/src/errors.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CliError, BrowserConnectError, adapterLoadError, CommandExecutionError, ConfigError, AuthRequiredError, TimeoutError, ArgumentError, EmptyResultError, selectorError, toEnvelope, } from './errors.js';
-describe('Error type hierarchy', () => {
-    it('all error types extend CliError', () => {
-        const errors = [
-            new BrowserConnectError('test'),
-            adapterLoadError('test'),
-            new CommandExecutionError('test'),
-            new ConfigError('test'),
-            new AuthRequiredError('example.com'),
-            new TimeoutError('test', 30),
-            new ArgumentError('test'),
-            new EmptyResultError('test/cmd'),
-            selectorError('.btn'),
-        ];
-        for (const err of errors) {
-            expect(err).toBeInstanceOf(CliError);
-            expect(err).toBeInstanceOf(Error);
-        }
-    });
-    it('AuthRequiredError has correct code, domain, and auto-generated hint', () => {
-        const err = new AuthRequiredError('bilibili.com');
-        expect(err.code).toBe('AUTH_REQUIRED');
-        expect(err.domain).toBe('bilibili.com');
-        expect(err.message).toBe('Not logged in to bilibili.com');
-        expect(err.hint).toContain('https://bilibili.com');
-    });
-    it('AuthRequiredError accepts custom message', () => {
-        const err = new AuthRequiredError('x.com', 'No ct0 cookie found');
-        expect(err.message).toBe('No ct0 cookie found');
-        expect(err.hint).toContain('https://x.com');
-    });
-    it('TimeoutError has correct code and hint', () => {
-        const err = new TimeoutError('bilibili/hot', 60);
-        expect(err.code).toBe('TIMEOUT');
-        expect(err.message).toBe('bilibili/hot timed out after 60s');
-        expect(err.hint).toContain('timeout');
-    });
-    it('ArgumentError has correct code', () => {
-        const err = new ArgumentError('Argument "limit" must be a valid number');
-        expect(err.code).toBe('ARGUMENT');
-    });
-    it('EmptyResultError has default hint', () => {
-        const err = new EmptyResultError('hackernews/top');
-        expect(err.code).toBe('EMPTY_RESULT');
-        expect(err.message).toBe('hackernews/top returned no data');
-        expect(err.hint).toBeTruthy();
-    });
-    it('selectorError has default hint about page changes', () => {
-        const err = selectorError('.submit-btn');
-        expect(err.code).toBe('SELECTOR');
-        expect(err.message).toContain('.submit-btn');
-        expect(err.hint).toContain('report');
-    });
-    it('BrowserConnectError has correct code', () => {
-        const err = new BrowserConnectError('Cannot connect');
-        expect(err.code).toBe('BROWSER_CONNECT');
-    });
-});
-describe('toEnvelope', () => {
-    it('converts CliError to structured envelope', () => {
-        const err = new AuthRequiredError('bilibili.com');
-        const envelope = toEnvelope(err);
-        expect(envelope).toEqual({
-            ok: false,
-            error: {
-                code: 'AUTH_REQUIRED',
-                message: 'Not logged in to bilibili.com',
-                help: expect.stringContaining('https://bilibili.com'),
-                exitCode: 77,
-            },
-        });
-    });
-    it('converts CliError without hint (omits help field)', () => {
-        const err = new CommandExecutionError('Something broke');
-        const envelope = toEnvelope(err);
-        expect(envelope.error.code).toBe('COMMAND_EXEC');
-        expect(envelope.error).not.toHaveProperty('help');
-    });
-    it('converts unknown Error to UNKNOWN envelope', () => {
-        const envelope = toEnvelope(new Error('random failure'));
-        expect(envelope).toEqual({
-            ok: false,
-            error: {
-                code: 'UNKNOWN',
-                message: 'random failure',
-                exitCode: 1,
-            },
-        });
-    });
-    it('converts non-Error values to UNKNOWN envelope', () => {
-        const envelope = toEnvelope('string error');
-        expect(envelope.error.code).toBe('UNKNOWN');
-        expect(envelope.error.message).toBe('string error');
-    });
-    it('serializes deep cause chains without stack overflow', () => {
-        // Build a 20-level deep cause chain — should truncate at depth 10
-        let deepErr = new Error('root');
-        for (let i = 0; i < 20; i++) {
-            deepErr = new Error(`level-${i}`, { cause: deepErr });
-        }
-        const topErr = new CommandExecutionError('top');
-        topErr.cause = deepErr;
-        const envelope = toEnvelope(topErr);
-        const causeStr = envelope.error.cause ?? '';
-        expect(causeStr).toContain('(cause chain truncated)');
-        expect(causeStr).not.toContain('root'); // root is beyond depth 10
-    });
-});