@sovovs/bycli 1.8.0 → 2.0.0

package/dist/src/external.test.js

@@ -1,146 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import yaml from 'js-yaml';
-const { mockExecFileSync, mockPlatform, mockSpawnSync } = vi.hoisted(() => ({
-    mockExecFileSync: vi.fn(),
-    mockPlatform: vi.fn(() => 'darwin'),
-    mockSpawnSync: vi.fn(),
-}));
-vi.mock('node:child_process', () => ({
-    spawnSync: mockSpawnSync,
-    execFileSync: mockExecFileSync,
-}));
-vi.mock('node:os', async () => {
-    const actual = await vi.importActual('node:os');
-    return {
-        ...actual,
-        platform: mockPlatform,
-    };
-});
-import { executeExternalCli, formatExternalCliLabel, installExternalCli, parseCommand } from './external.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-describe('parseCommand', () => {
-    it('splits binaries and quoted arguments without invoking a shell', () => {
-        expect(parseCommand('npm install -g "@scope/tool name"')).toEqual({
-            binary: 'npm',
-            args: ['install', '-g', '@scope/tool name'],
-        });
-    });
-    it('rejects shell operators', () => {
-        expect(() => parseCommand('brew install gh && rm -rf /')).toThrow('Install command contains unsafe shell operators');
-    });
-    it('rejects command substitution and multiline input', () => {
-        expect(() => parseCommand('brew install $(whoami)')).toThrow('Install command contains unsafe shell operators');
-        expect(() => parseCommand('brew install gh\nrm -rf /')).toThrow('Install command contains unsafe shell operators');
-    });
-    it('keeps built-in install commands compatible with the shell-free parser', () => {
-        const raw = fs.readFileSync(path.join(__dirname, 'external-clis.yaml'), 'utf8');
-        const entries = (yaml.load(raw) || []);
-        for (const entry of entries) {
-            for (const command of Object.values(entry.install ?? {})) {
-                if (command)
-                    expect(() => parseCommand(command)).not.toThrow();
-            }
-        }
-    });
-    it('registers Longbridge with safe package-manager installers only', () => {
-        const raw = fs.readFileSync(path.join(__dirname, 'external-clis.yaml'), 'utf8');
-        const entries = (yaml.load(raw) || []);
-        const longbridge = entries.find((entry) => entry.name === 'longbridge');
-        expect(longbridge).toMatchObject({
-            binary: 'longbridge',
-            homepage: 'https://open.longbridge.com/zh-CN/docs/cli/',
-            install: {
-                mac: 'brew install --cask longbridge/tap/longbridge-terminal',
-                windows: 'scoop install https://open.longbridge.com/longbridge/longbridge-terminal/longbridge.json',
-            },
-        });
-        expect(longbridge?.install?.linux).toBeUndefined();
-        expect(longbridge?.install?.default).toBeUndefined();
-    });
-});
-describe('formatExternalCliLabel', () => {
-    it('shows the package name when the executable name differs', () => {
-        expect(formatExternalCliLabel({ name: 'wx', binary: 'wx', package: 'wx-cli' })).toBe('wx(wx-cli)');
-    });
-    it('keeps the label compact when package and name match', () => {
-        expect(formatExternalCliLabel({ name: 'docker', binary: 'docker', package: 'docker' })).toBe('docker');
-    });
-    it('renders a human-readable brand alias for ambiguous executable names', () => {
-        expect(formatExternalCliLabel({ name: 'ntn', binary: 'ntn', package: 'notion' })).toBe('ntn(notion)');
-        expect(formatExternalCliLabel({ name: 'wecom-cli', binary: 'wecom-cli', package: '企业微信' })).toBe('wecom-cli(企业微信)');
-    });
-});
-describe('installExternalCli', () => {
-    const cli = {
-        name: 'readwise',
-        binary: 'readwise',
-        install: {
-            default: 'npm install -g @readwiseio/readwise-cli',
-        },
-    };
-    beforeEach(() => {
-        mockExecFileSync.mockReset();
-        mockSpawnSync.mockReset();
-        mockPlatform.mockReturnValue('darwin');
-        process.exitCode = undefined;
-    });
-    it('retries with .cmd on Windows when the bare binary is unavailable', () => {
-        mockPlatform.mockReturnValue('win32');
-        mockExecFileSync
-            .mockImplementationOnce(() => {
-            const err = new Error('not found');
-            err.code = 'ENOENT';
-            throw err;
-        })
-            .mockReturnValueOnce(Buffer.from(''));
-        expect(installExternalCli(cli)).toBe(true);
-        expect(mockExecFileSync).toHaveBeenNthCalledWith(1, 'npm', ['install', '-g', '@readwiseio/readwise-cli'], { stdio: 'inherit' });
-        expect(mockExecFileSync).toHaveBeenNthCalledWith(2, 'npm.cmd', ['install', '-g', '@readwiseio/readwise-cli'], { stdio: 'inherit' });
-    });
-    it('does not mask non-ENOENT failures', () => {
-        mockPlatform.mockReturnValue('win32');
-        mockExecFileSync.mockImplementationOnce(() => {
-            const err = new Error('permission denied');
-            err.code = 'EACCES';
-            throw err;
-        });
-        expect(installExternalCli(cli)).toBe(false);
-        expect(mockExecFileSync).toHaveBeenCalledTimes(1);
-    });
-});
-describe('executeExternalCli', () => {
-    beforeEach(() => {
-        mockExecFileSync.mockReset();
-        mockSpawnSync.mockReset();
-        mockPlatform.mockReturnValue('darwin');
-        process.exitCode = undefined;
-    });
-    it('does not spawn a binary that is still unavailable after auto-install', () => {
-        const docker = {
-            name: 'docker',
-            binary: 'docker',
-            install: { mac: 'brew install --cask docker' },
-        };
-        mockExecFileSync
-            .mockImplementationOnce(() => {
-            const err = new Error('docker not found');
-            err.code = 'ENOENT';
-            throw err;
-        })
-            .mockReturnValueOnce(Buffer.from(''))
-            .mockImplementationOnce(() => {
-            const err = new Error('docker still not found');
-            err.code = 'ENOENT';
-            throw err;
-        });
-        executeExternalCli('docker', [], [docker]);
-        expect(mockExecFileSync).toHaveBeenNthCalledWith(1, 'which', ['docker'], { stdio: 'ignore' });
-        expect(mockExecFileSync).toHaveBeenNthCalledWith(2, 'brew', ['install', '--cask', 'docker'], { stdio: 'inherit' });
-        expect(mockExecFileSync).toHaveBeenNthCalledWith(3, 'which', ['docker'], { stdio: 'ignore' });
-        expect(mockSpawnSync).not.toHaveBeenCalled();
-        expect(process.exitCode).toBe(69);
-    });
-});

package/dist/src/help.test.js

@@ -1,58 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { classifyAdapter, formatRootAdapterHelpText } from './help.js';
-describe('classifyAdapter', () => {
-    it('classifies DNS-style domains as site', () => {
-        expect(classifyAdapter('www.bilibili.com')).toBe('site');
-        expect(classifyAdapter('chatgpt.com')).toBe('site');
-        expect(classifyAdapter('claude.ai')).toBe('site');
-        expect(classifyAdapter('grok.com')).toBe('site');
-    });
-    it('classifies localhost as app (Electron / osascript desktop integrations)', () => {
-        expect(classifyAdapter('localhost')).toBe('app');
-    });
-    it('classifies non-DNS domain strings as app (e.g. literal "doubao-app")', () => {
-        expect(classifyAdapter('doubao-app')).toBe('app');
-    });
-    it('defaults missing domain to site (most adapters without explicit domain are public web scrapers)', () => {
-        expect(classifyAdapter(undefined)).toBe('site');
-    });
-});
-describe('formatRootAdapterHelpText', () => {
-    it('renders all three sections in External / App / Site order when populated', () => {
-        const text = formatRootAdapterHelpText({
-            external: [
-                { name: 'gh', label: 'gh' },
-                { name: 'wx', label: 'wx(wx-cli)' },
-            ],
-            apps: ['chatwise', 'codex'],
-            sites: ['bilibili'],
-        });
-        expect(text).toContain('External CLIs (2):');
-        expect(text).toContain('App adapters (2):');
-        expect(text).toContain('Site adapters (1):');
-        expect(text).toContain('wx(wx-cli)');
-        expect(text.indexOf('External CLIs')).toBeLessThan(text.indexOf('App adapters'));
-        expect(text.indexOf('App adapters')).toBeLessThan(text.indexOf('Site adapters'));
-    });
-    it('omits empty sections instead of rendering a (0) header', () => {
-        const text = formatRootAdapterHelpText({
-            external: [],
-            apps: [],
-            sites: ['bilibili'],
-        });
-        expect(text).not.toContain('External CLIs');
-        expect(text).not.toContain('App adapters');
-        expect(text).toContain('Site adapters (1):');
-    });
-    it('returns empty string when all groups are empty', () => {
-        expect(formatRootAdapterHelpText({ external: [], apps: [], sites: [] })).toBe('');
-    });
-    it('always renders the agent discovery hint when any section is populated', () => {
-        const text = formatRootAdapterHelpText({
-            external: [],
-            apps: [],
-            sites: ['bilibili'],
-        });
-        expect(text).toContain("'bycli <site> --help -f yaml'");
-    });
-});

package/dist/src/hooks.test.js

@@ -1,92 +0,0 @@
-/**
- * Tests for the plugin lifecycle hooks system.
- */
-import { describe, it, expect, beforeEach } from 'vitest';
-import { onStartup, onBeforeExecute, onAfterExecute, emitHook, clearAllHooks, } from './hooks.js';
-beforeEach(() => {
-    clearAllHooks();
-});
-describe('hook registration and emission', () => {
-    it('onBeforeExecute hook is called with context', async () => {
-        const calls = [];
-        onBeforeExecute((ctx) => { calls.push({ ...ctx }); });
-        await emitHook('onBeforeExecute', { command: 'test/cmd', args: { limit: 5 }, startedAt: 100 });
-        expect(calls).toHaveLength(1);
-        expect(calls[0].command).toBe('test/cmd');
-        expect(calls[0].args).toEqual({ limit: 5 });
-        expect(calls[0].startedAt).toBe(100);
-    });
-    it('onAfterExecute hook receives result', async () => {
-        const results = [];
-        onAfterExecute((_ctx, result) => { results.push(result); });
-        const mockResult = [{ title: 'item1' }, { title: 'item2' }];
-        await emitHook('onAfterExecute', { command: 'test/cmd', args: {} }, mockResult);
-        expect(results).toHaveLength(1);
-        expect(results[0]).toEqual(mockResult);
-    });
-    it('onStartup hook fires', async () => {
-        let fired = false;
-        onStartup(() => { fired = true; });
-        await emitHook('onStartup', { command: '__startup__', args: {} });
-        expect(fired).toBe(true);
-    });
-    it('multiple hooks on the same event fire in order', async () => {
-        const order = [];
-        onBeforeExecute(() => { order.push(1); });
-        onBeforeExecute(() => { order.push(2); });
-        onBeforeExecute(() => { order.push(3); });
-        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
-        expect(order).toEqual([1, 2, 3]);
-    });
-    it('async hooks are awaited', async () => {
-        const order = [];
-        onBeforeExecute(async () => {
-            await new Promise((r) => setTimeout(r, 10));
-            order.push('async-done');
-        });
-        onBeforeExecute(() => { order.push('sync'); });
-        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
-        expect(order).toEqual(['async-done', 'sync']);
-    });
-});
-describe('hook error isolation', () => {
-    it('failing hook does not prevent other hooks from running', async () => {
-        const calls = [];
-        onBeforeExecute(() => { calls.push('first'); });
-        onBeforeExecute(() => { throw new Error('boom'); });
-        onBeforeExecute(() => { calls.push('third'); });
-        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
-        // First and third should still run despite the second throwing
-        expect(calls).toEqual(['first', 'third']);
-    });
-    it('async hook rejection does not prevent other hooks', async () => {
-        const calls = [];
-        onAfterExecute(() => { calls.push('before-reject'); });
-        onAfterExecute(async () => { throw new Error('async boom'); });
-        onAfterExecute(() => { calls.push('after-reject'); });
-        await emitHook('onAfterExecute', { command: 'test/cmd', args: {} }, null);
-        expect(calls).toEqual(['before-reject', 'after-reject']);
-    });
-});
-describe('no-op when no hooks registered', () => {
-    it('emitHook with no registered hooks does nothing', async () => {
-        // Should not throw
-        await emitHook('onBeforeExecute', { command: 'test/cmd', args: {} });
-        await emitHook('onAfterExecute', { command: 'test/cmd', args: {} }, []);
-        await emitHook('onStartup', { command: '__startup__', args: {} });
-    });
-});
-describe('clearAllHooks', () => {
-    it('removes all hooks', async () => {
-        let called = false;
-        onStartup(() => { called = true; });
-        clearAllHooks();
-        await emitHook('onStartup', { command: '__startup__', args: {} });
-        expect(called).toBe(false);
-    });
-});
-describe('globalThis singleton', () => {
-    it('uses globalThis.__bycli_hooks__ for shared state', () => {
-        expect(globalThis.__bycli_hooks__).toBeInstanceOf(Map);
-    });
-});

package/dist/src/interceptor.test.js

@@ -1,81 +0,0 @@
-/**
- * Tests for interceptor.ts: JavaScript code generators for XHR/Fetch interception.
- */
-import { describe, it, expect } from 'vitest';
-import { generateInterceptorJs, generateReadInterceptedJs, generateTapInterceptorJs } from './interceptor.js';
-describe('generateInterceptorJs', () => {
-    it('generates valid JavaScript function source', () => {
-        const js = generateInterceptorJs('"api/search"');
-        expect(js).toContain('window.fetch');
-        expect(js).toContain('XMLHttpRequest');
-        expect(js).toContain('"api/search"');
-        // Should be a function expression wrapping
-        expect(js.trim()).toMatch(/^\(\)\s*=>/);
-    });
-    it('uses default array name and patch guard', () => {
-        const js = generateInterceptorJs('"test"');
-        expect(js).toContain('__bycli_intercepted');
-        expect(js).toContain('__bycli_interceptor_patched');
-    });
-    it('uses custom array name and patch guard', () => {
-        const js = generateInterceptorJs('"test"', {
-            arrayName: '__my_data',
-            patchGuard: '__my_guard',
-        });
-        expect(js).toContain('__my_data');
-        expect(js).toContain('__my_guard');
-        expect(js).not.toContain('__bycli_intercepted');
-    });
-    it('includes fetch clone and json parsing', () => {
-        const js = generateInterceptorJs('"api"');
-        expect(js).toContain('response.clone()');
-        expect(js).toContain('clone.json()');
-    });
-    it('includes XHR open and send patching', () => {
-        const js = generateInterceptorJs('"api"');
-        expect(js).toContain('XMLHttpRequest.prototype');
-        expect(js).toContain('__origOpen');
-        expect(js).toContain('__origSend');
-    });
-});
-describe('generateReadInterceptedJs', () => {
-    it('generates valid JavaScript to read and clear data', () => {
-        const js = generateReadInterceptedJs();
-        expect(js).toContain('__bycli_intercepted');
-        // Should clear the array after reading
-        expect(js).toContain('= []');
-    });
-    it('uses custom array name', () => {
-        const js = generateReadInterceptedJs('__custom_arr');
-        expect(js).toContain('__custom_arr');
-        expect(js).not.toContain('__bycli_intercepted');
-    });
-});
-describe('generateTapInterceptorJs', () => {
-    it('returns all required fields', () => {
-        const tap = generateTapInterceptorJs('"api/data"');
-        expect(tap.setupVar).toBeDefined();
-        expect(tap.capturedVar).toBe('captured');
-        expect(tap.promiseVar).toBe('capturePromise');
-        expect(tap.resolveVar).toBe('captureResolve');
-        expect(tap.fetchPatch).toBeDefined();
-        expect(tap.xhrPatch).toBeDefined();
-        expect(tap.restorePatch).toBeDefined();
-    });
-    it('contains the capture pattern in setup', () => {
-        const tap = generateTapInterceptorJs('"my-pattern"');
-        expect(tap.setupVar).toContain('"my-pattern"');
-    });
-    it('restores original fetch and XHR in restorePatch', () => {
-        const tap = generateTapInterceptorJs('"test"');
-        expect(tap.restorePatch).toContain('origFetch');
-        expect(tap.restorePatch).toContain('origXhrOpen');
-        expect(tap.restorePatch).toContain('origXhrSend');
-    });
-    it('uses first-match capture (only first response)', () => {
-        const tap = generateTapInterceptorJs('"test"');
-        // Both fetch and xhr patches should check !captured before storing
-        expect(tap.fetchPatch).toContain('!captured');
-        expect(tap.xhrPatch).toContain('!captured');
-    });
-});

package/dist/src/launcher.test.js

@@ -1,138 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { detectProcess, discoverAppPath, launchDetachedApp, launchElectronApp, probeCDP, resolveExecutableCandidates } from './launcher.js';
-function createMockChildProcess() {
-    const listeners = new Map();
-    return {
-        once: vi.fn((event, handler) => {
-            listeners.set(event, [...(listeners.get(event) ?? []), handler]);
-        }),
-        off: vi.fn((event, handler) => {
-            listeners.set(event, (listeners.get(event) ?? []).filter((listener) => listener !== handler));
-        }),
-        unref: vi.fn(),
-        emit: (event, value) => {
-            for (const listener of listeners.get(event) ?? [])
-                listener(value);
-        },
-    };
-}
-vi.mock('node:child_process', () => ({
-    execFileSync: vi.fn(),
-    spawn: vi.fn(),
-}));
-const cp = vi.mocked(await import('node:child_process'));
-describe('probeCDP', () => {
-    it('returns false when CDP endpoint is unreachable', async () => {
-        const result = await probeCDP(59999, 500);
-        expect(result).toBe(false);
-    });
-});
-describe('detectProcess', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('returns false when pgrep finds no process', () => {
-        cp.execFileSync.mockImplementation(() => {
-            const err = new Error('exit 1');
-            err.status = 1;
-            throw err;
-        });
-        const result = detectProcess('NonExistentApp');
-        expect(result).toBe(false);
-    });
-    it.skipIf(process.platform === 'win32')('returns true when pgrep finds a process', () => {
-        cp.execFileSync.mockReturnValue('12345\n');
-        const result = detectProcess('Cursor');
-        expect(result).toBe(true);
-    });
-});
-describe('discoverAppPath', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it.skipIf(process.platform !== 'darwin')('returns path when osascript succeeds', () => {
-        cp.execFileSync.mockReturnValue('/Applications/Cursor.app/\n');
-        const result = discoverAppPath('Cursor');
-        expect(result).toBe('/Applications/Cursor.app');
-    });
-    it.skipIf(process.platform !== 'darwin')('returns null when osascript fails', () => {
-        cp.execFileSync.mockImplementation(() => {
-            throw new Error('app not found');
-        });
-        const result = discoverAppPath('NonExistent');
-        expect(result).toBeNull();
-    });
-    it.skipIf(process.platform === 'darwin')('returns null on non-darwin platform', () => {
-        const result = discoverAppPath('Cursor');
-        expect(result).toBeNull();
-    });
-});
-describe('launchDetachedApp', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        cp.spawn.mockReset();
-    });
-    it('unrefs the process after spawn succeeds', async () => {
-        const child = createMockChildProcess();
-        cp.spawn.mockImplementation(() => {
-            queueMicrotask(() => child.emit('spawn'));
-            return child;
-        });
-        await expect(launchDetachedApp('/Applications/Antigravity.app/Contents/MacOS/Antigravity', ['--remote-debugging-port=9234'], 'Antigravity'))
-            .resolves
-            .toBeUndefined();
-        expect(child.unref).toHaveBeenCalledTimes(1);
-    });
-    it('converts ENOENT into a controlled launch error', async () => {
-        const child = createMockChildProcess();
-        cp.spawn.mockImplementation(() => {
-            queueMicrotask(() => child.emit('error', Object.assign(new Error('missing binary'), { code: 'ENOENT' })));
-            return child;
-        });
-        await expect(launchDetachedApp('/Applications/Antigravity.app/Contents/MacOS/Antigravity', ['--remote-debugging-port=9234'], 'Antigravity'))
-            .rejects
-            .toThrow('Could not launch Antigravity');
-        expect(child.unref).not.toHaveBeenCalled();
-    });
-});
-describe('resolveExecutableCandidates', () => {
-    it('prefers explicit executable candidates over processName', () => {
-        const app = {
-            port: 9234,
-            processName: 'Antigravity',
-            executableNames: ['Electron', 'Antigravity'],
-        };
-        expect(resolveExecutableCandidates('/Applications/Antigravity.app', app)).toEqual([
-            '/Applications/Antigravity.app/Contents/MacOS/Electron',
-            '/Applications/Antigravity.app/Contents/MacOS/Antigravity',
-        ]);
-    });
-});
-describe('launchElectronApp', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        cp.spawn.mockReset();
-    });
-    it('falls back to the next executable candidate when the first is missing', async () => {
-        const firstChild = createMockChildProcess();
-        const secondChild = createMockChildProcess();
-        const app = {
-            port: 9234,
-            processName: 'Antigravity',
-            executableNames: ['Electron', 'Antigravity'],
-        };
-        cp.spawn
-            .mockImplementationOnce(() => {
-            queueMicrotask(() => firstChild.emit('error', Object.assign(new Error('missing binary'), { code: 'ENOENT' })));
-            return firstChild;
-        })
-            .mockImplementationOnce(() => {
-            queueMicrotask(() => secondChild.emit('spawn'));
-            return secondChild;
-        });
-        await expect(launchElectronApp('/Applications/Antigravity.app', app, ['--remote-debugging-port=9234'], 'Antigravity')).resolves.toBeUndefined();
-        expect(cp.spawn).toHaveBeenNthCalledWith(1, '/Applications/Antigravity.app/Contents/MacOS/Electron', ['--remote-debugging-port=9234'], { detached: true, stdio: 'ignore' });
-        expect(cp.spawn).toHaveBeenNthCalledWith(2, '/Applications/Antigravity.app/Contents/MacOS/Antigravity', ['--remote-debugging-port=9234'], { detached: true, stdio: 'ignore' });
-        expect(secondChild.unref).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/src/node-network.test.js

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { decideProxy, hasProxyEnv } from './node-network.js';
-describe('node network proxy decisions', () => {
-    it('detects common proxy env variables', () => {
-        expect(hasProxyEnv({ https_proxy: 'http://127.0.0.1:7897' })).toBe(true);
-        expect(hasProxyEnv({ HTTP_PROXY: 'http://proxy.example:8080' })).toBe(true);
-        expect(hasProxyEnv({})).toBe(false);
-    });
-    it('routes external https traffic through https_proxy', () => {
-        const decision = decideProxy(new URL('https://www.v2ex.com/api/topics/latest.json'), { https_proxy: 'http://127.0.0.1:7897' });
-        expect(decision).toEqual({
-            mode: 'proxy',
-            proxyUrl: 'http://127.0.0.1:7897',
-        });
-    });
-    it('falls back to HTTP_PROXY for https traffic when HTTPS_PROXY is absent', () => {
-        const decision = decideProxy(new URL('https://www.v2ex.com/api/topics/latest.json'), { HTTP_PROXY: 'http://127.0.0.1:7897' });
-        expect(decision).toEqual({
-            mode: 'proxy',
-            proxyUrl: 'http://127.0.0.1:7897',
-        });
-    });
-    it('bypasses proxies for loopback addresses', () => {
-        const env = { https_proxy: 'http://127.0.0.1:7897', http_proxy: 'http://127.0.0.1:7897' };
-        expect(decideProxy(new URL('http://127.0.0.1:19825/status'), env)).toEqual({ mode: 'direct' });
-        expect(decideProxy(new URL('http://localhost:19825/status'), env)).toEqual({ mode: 'direct' });
-        expect(decideProxy(new URL('http://[::1]:19825/status'), env)).toEqual({ mode: 'direct' });
-    });
-    it('honors NO_PROXY domain matches', () => {
-        const decision = decideProxy(new URL('https://api.example.com/v1/items'), {
-            https_proxy: 'http://127.0.0.1:7897',
-            no_proxy: '.example.com',
-        });
-        expect(decision).toEqual({ mode: 'direct' });
-    });
-    it('supports wildcard-style NO_PROXY subdomain entries', () => {
-        const decision = decideProxy(new URL('https://api.example.com/v1/items'), {
-            https_proxy: 'http://127.0.0.1:7897',
-            no_proxy: '*.example.com',
-        });
-        expect(decision).toEqual({ mode: 'direct' });
-    });
-    it('matches NO_PROXY entries that rely on the default URL port', () => {
-        const env = { https_proxy: 'http://127.0.0.1:7897', http_proxy: 'http://127.0.0.1:7897' };
-        expect(decideProxy(new URL('https://example.com/'), { ...env, NO_PROXY: 'example.com:443' })).toEqual({ mode: 'direct' });
-        expect(decideProxy(new URL('http://example.com/health'), { ...env, NO_PROXY: 'example.com:80' })).toEqual({ mode: 'direct' });
-    });
-    it('falls back to ALL_PROXY when protocol-specific settings are absent', () => {
-        const decision = decideProxy(new URL('http://example.net/data'), { ALL_PROXY: 'socks5://127.0.0.1:1080' });
-        expect(decision).toEqual({
-            mode: 'proxy',
-            proxyUrl: 'socks5://127.0.0.1:1080',
-        });
-    });
-});