@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/utils/cache.test.js

@@ -0,0 +1,93 @@
+import { promises as fs } from 'fs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+import { CacheManager } from '../../src/utils/cache.js';
+function createConfig(overrides) {
+    return {
+        enabled: true,
+        dir: '/tmp/jshookcp-cache',
+        ttl: 1,
+        ...overrides,
+    };
+}
+describe('CacheManager', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        loggerState.debug.mockReset();
+        loggerState.info.mockReset();
+        loggerState.warn.mockReset();
+        loggerState.error.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('initializes cache directory when enabled', async () => {
+        const mkdirSpy = vi.spyOn(fs, 'mkdir').mockResolvedValue(undefined);
+        const manager = new CacheManager(createConfig());
+        await manager.init();
+        expect(mkdirSpy).toHaveBeenCalledWith('/tmp/jshookcp-cache', { recursive: true });
+        expect(loggerState.debug).toHaveBeenCalledWith('Cache directory initialized: /tmp/jshookcp-cache');
+    });
+    it('returns null immediately when cache is disabled', async () => {
+        const readSpy = vi.spyOn(fs, 'readFile').mockResolvedValue('{}');
+        const manager = new CacheManager(createConfig({ enabled: false }));
+        const result = await manager.get('any-key');
+        expect(result).toBeNull();
+        expect(readSpy).not.toHaveBeenCalled();
+    });
+    it('returns cached value when entry is fresh', async () => {
+        const payload = { timestamp: Date.now(), value: { token: 'abc' } };
+        vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify(payload));
+        const manager = new CacheManager(createConfig({ ttl: 60 }));
+        const result = await manager.get('fresh-key');
+        expect(result).toEqual({ token: 'abc' });
+        expect(loggerState.debug).toHaveBeenCalledWith('Cache hit: fresh-key');
+    });
+    it('expires stale entries and removes cache file', async () => {
+        vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify({ timestamp: Date.now() - 5_000, value: { old: true } }));
+        const unlinkSpy = vi.spyOn(fs, 'unlink').mockResolvedValue(undefined);
+        const manager = new CacheManager(createConfig({ ttl: 1 }));
+        const result = await manager.get('stale-key');
+        expect(result).toBeNull();
+        expect(unlinkSpy).toHaveBeenCalledTimes(1);
+    });
+    it('persists structured data and timestamp on set', async () => {
+        const writeSpy = vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+        const manager = new CacheManager(createConfig());
+        await manager.set('store-key', { count: 7, nested: { ok: true } });
+        expect(writeSpy).toHaveBeenCalledTimes(1);
+        const [, raw] = writeSpy.mock.calls[0];
+        const parsed = JSON.parse(String(raw));
+        expect(parsed.value).toEqual({ count: 7, nested: { ok: true } });
+        expect(typeof parsed.timestamp).toBe('number');
+    });
+    it('ignores ENOENT during delete and warns on other unlink errors', async () => {
+        const manager = new CacheManager(createConfig());
+        const unlinkSpy = vi.spyOn(fs, 'unlink');
+        unlinkSpy.mockRejectedValueOnce(Object.assign(new Error('missing'), { code: 'ENOENT' }));
+        await expect(manager.delete('missing-key')).resolves.toBeUndefined();
+        expect(loggerState.warn).not.toHaveBeenCalled();
+        unlinkSpy.mockRejectedValueOnce(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
+        await expect(manager.delete('forbidden-key')).resolves.toBeUndefined();
+        expect(loggerState.warn).toHaveBeenCalledTimes(1);
+    });
+    it('clears all cached files and tolerates missing cache directory', async () => {
+        const manager = new CacheManager(createConfig());
+        const readdirSpy = vi.spyOn(fs, 'readdir');
+        const unlinkSpy = vi.spyOn(fs, 'unlink').mockResolvedValue(undefined);
+        readdirSpy.mockResolvedValueOnce(['a.json', 'b.json']);
+        await manager.clear();
+        expect(unlinkSpy).toHaveBeenCalledTimes(2);
+        readdirSpy.mockRejectedValueOnce(Object.assign(new Error('no dir'), { code: 'ENOENT' }));
+        await expect(manager.clear()).resolves.toBeUndefined();
+        expect(loggerState.error).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/utils/cliFastPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/cliFastPath.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { resolveCliFastPath } from '../../src/utils/cliFastPath.js';
+describe('resolveCliFastPath', () => {
+    const moduleUrl = new URL('../../src/index.ts', import.meta.url).href;
+    it('returns help text for --help', () => {
+        const result = resolveCliFastPath(['--help'], moduleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.exitCode).toBe(0);
+        expect(result.output).toContain('Usage:');
+        expect(result.output).toContain('jshook [--help] [--version]');
+    });
+    it('returns help text for subcommand-style help', () => {
+        const result = resolveCliFastPath(['debug', '--help'], moduleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.exitCode).toBe(0);
+        expect(result.output).toContain('@jshookmcp/jshook');
+    });
+    it('returns version text for --version', () => {
+        const result = resolveCliFastPath(['--version'], moduleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.exitCode).toBe(0);
+        expect(result.output?.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+    it('does not intercept normal startup args', () => {
+        const result = resolveCliFastPath([], moduleUrl);
+        expect(result.handled).toBe(false);
+        expect(result.exitCode).toBe(0);
+        expect(result.output).toBeUndefined();
+    });
+});

package/dist/tests/utils/concurrency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/concurrency.test.js

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const loadConcurrencyModule = async () => {
+    vi.resetModules();
+    return import('../../src/utils/concurrency.js');
+};
+describe('concurrency utilities', () => {
+    const originalEnv = { ...process.env };
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('ioLimit runs a task and returns its result', async () => {
+        process.env.jshook_IO_CONCURRENCY = '2';
+        const { ioLimit } = await loadConcurrencyModule();
+        await expect(ioLimit(async () => 123)).resolves.toBe(123);
+    });
+    it('ioLimit enforces configured max parallelism', async () => {
+        process.env.jshook_IO_CONCURRENCY = '2';
+        const { ioLimit } = await loadConcurrencyModule();
+        let running = 0;
+        let maxRunning = 0;
+        const tasks = Array.from({ length: 6 }, (_, idx) => ioLimit(async () => {
+            running++;
+            maxRunning = Math.max(maxRunning, running);
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            running--;
+            return idx;
+        }));
+        await Promise.all(tasks);
+        expect(maxRunning).toBeLessThanOrEqual(2);
+    });
+    it('cpuLimit can be forced to run sequentially', async () => {
+        process.env.jshook_CPU_CONCURRENCY = '1';
+        const { cpuLimit } = await loadConcurrencyModule();
+        const order = [];
+        const tasks = ['a', 'b', 'c'].map((id) => cpuLimit(async () => {
+            order.push(`start-${id}`);
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            order.push(`end-${id}`);
+            return id;
+        }));
+        await Promise.all(tasks);
+        expect(order).toEqual(['start-a', 'end-a', 'start-b', 'end-b', 'start-c', 'end-c']);
+    });
+    it('cdpLimit propagates task failures', async () => {
+        process.env.jshook_CDP_CONCURRENCY = '2';
+        const { cdpLimit } = await loadConcurrencyModule();
+        await expect(cdpLimit(async () => {
+            throw new Error('boom');
+        })).rejects.toThrow('boom');
+    });
+    it('throws during module load for invalid concurrency values', async () => {
+        process.env.jshook_IO_CONCURRENCY = '0';
+        await expect(loadConcurrencyModule()).rejects.toThrow('concurrency must be >= 1');
+    });
+});

package/dist/tests/utils/config.extended.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/config.extended.test.js

@@ -0,0 +1,46 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getConfig, validateConfig } from '../../src/utils/config.js';
+describe('config validation – extended checks', () => {
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        delete process.env.DEFAULT_LLM_PROVIDER;
+        delete process.env.PUPPETEER_TIMEOUT;
+        delete process.env.CACHE_TTL;
+        delete process.env.MAX_CONCURRENT_ANALYSIS;
+        delete process.env.MAX_CODE_SIZE_MB;
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('validates puppeteer timeout lower bound', () => {
+        const config = getConfig();
+        config.puppeteer.timeout = 100;
+        const result = validateConfig(config);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('puppeteer.timeout must be at least 1000ms');
+    });
+    it('validates cache ttl non-negative', () => {
+        const config = getConfig();
+        config.cache.ttl = -1;
+        const result = validateConfig(config);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('cache.ttl must be non-negative');
+    });
+    it('passes validation with correct defaults', () => {
+        const config = getConfig();
+        const result = validateConfig(config);
+        expect(result.valid).toBe(true);
+        expect(result.errors.length).toBe(0);
+    });
+    it('Zod schema provides fallback when env has invalid values', () => {
+        process.env.PUPPETEER_TIMEOUT = 'not-a-number';
+        const config = getConfig();
+        expect(typeof config.puppeteer.timeout).toBe('number');
+    });
+    it('reads custom MAX_CONCURRENT_ANALYSIS from env', () => {
+        process.env.MAX_CONCURRENT_ANALYSIS = '8';
+        const config = getConfig();
+        expect(config.performance.maxConcurrentAnalysis).toBe(8);
+    });
+});

package/dist/tests/utils/config.noise.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/config.noise.test.js

@@ -0,0 +1,21 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+describe('config env loading noise', () => {
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        vi.resetModules();
+        vi.restoreAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.DEBUG;
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('does not warn when .env is missing and config is loaded lazily', async () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const infoSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const { getConfig } = await import('../../src/utils/config.js');
+        getConfig();
+        expect(errorSpy).not.toHaveBeenCalled();
+        expect(infoSpy).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/utils/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/config.test.js

@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { join } from 'node:path';
+import { getConfig, validateConfig } from '../../src/utils/config.js';
+import { getProjectRoot } from '../../src/utils/outputPaths.js';
+function getSupportedProviders() {
+    return Object.keys(getConfig().llm).filter((key) => key !== 'provider');
+}
+describe('config utilities', () => {
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        delete process.env.DEFAULT_LLM_PROVIDER;
+        delete process.env.PUPPETEER_HEADLESS;
+        delete process.env.PUPPETEER_EXECUTABLE_PATH;
+        delete process.env.BROWSER_EXECUTABLE_PATH;
+        delete process.env.CACHE_DIR;
+        delete process.env.MAX_CONCURRENT_ANALYSIS;
+        delete process.env.MAX_CODE_SIZE_MB;
+        for (const provider of getSupportedProviders()) {
+            delete process.env[`${provider.toUpperCase()}_API_KEY`];
+            delete process.env[`${provider.toUpperCase()}_MODEL`];
+            delete process.env[`${provider.toUpperCase()}_BASE_URL`];
+        }
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('returns sane defaults when environment is empty', () => {
+        const config = getConfig();
+        expect(typeof config.llm.provider).toBe('string');
+        expect(config.llm.provider.length).toBeGreaterThan(0);
+        expect(config.puppeteer.timeout).toBe(30000);
+        expect(config.cache.ttl).toBe(3600);
+        expect(config.performance.maxConcurrentAnalysis).toBe(3);
+    });
+    it('reads provider and credentials from environment', () => {
+        const defaultProvider = getConfig().llm.provider;
+        const alternateProvider = getSupportedProviders().find((provider) => provider !== defaultProvider);
+        process.env.DEFAULT_LLM_PROVIDER = alternateProvider;
+        process.env[`${alternateProvider.toUpperCase()}_API_KEY`] = 'k-provider';
+        const config = getConfig();
+        expect(config.llm.provider).toBe(alternateProvider);
+        expect(config.llm[alternateProvider].apiKey).toBe('k-provider');
+    });
+    it('resolves executable path by priority order', () => {
+        process.env.BROWSER_EXECUTABLE_PATH = 'browser-path';
+        process.env.PUPPETEER_EXECUTABLE_PATH = 'puppeteer-path';
+        const config = getConfig();
+        expect(config.puppeteer.executablePath).toBe('puppeteer-path');
+    });
+    it('parses boolean headless flag correctly', () => {
+        process.env.PUPPETEER_HEADLESS = 'true';
+        expect(getConfig().puppeteer.headless).toBe(true);
+        process.env.PUPPETEER_HEADLESS = 'false';
+        expect(getConfig().puppeteer.headless).toBe(false);
+    });
+    it('resolves relative cache directory against project root', () => {
+        process.env.CACHE_DIR = '.cache/custom';
+        const config = getConfig();
+        expect(config.cache.dir).toBe(join(getProjectRoot(), '.cache/custom'));
+    });
+    it('validateConfig reports invalid performance settings', () => {
+        const config = getConfig();
+        config.performance.maxConcurrentAnalysis = 0;
+        config.performance.maxCodeSizeMB = 0;
+        const result = validateConfig(config);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('maxConcurrentAnalysis must be at least 1');
+        expect(result.errors).toContain('maxCodeSizeMB must be at least 1');
+    });
+});

package/dist/tests/utils/environmentDoctor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/environmentDoctor.test.js

@@ -0,0 +1,234 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const { probeAllMock, execFileMock, mockFetch } = vi.hoisted(() => ({
+    probeAllMock: vi.fn().mockResolvedValue({}),
+    execFileMock: vi.fn(),
+    mockFetch: vi.fn(),
+}));
+vi.mock('@modules/external/ToolRegistry', () => ({
+    ToolRegistry: class MockToolRegistry {
+        probeAll = probeAllMock;
+    },
+}));
+vi.mock('@utils/outputPaths', () => ({
+    getProjectRoot: vi.fn(() => '/mock/project/root'),
+}));
+vi.mock('@utils/artifactRetention', () => ({
+    getArtifactRetentionConfig: vi.fn(() => ({
+        enabled: false,
+        retentionDays: 0,
+        maxTotalBytes: 0,
+        cleanupIntervalMinutes: 0,
+        cleanupOnStart: false,
+    })),
+}));
+vi.mock('@src/constants', () => ({
+    GHIDRA_BRIDGE_ENDPOINT: 'http://127.0.0.1:18080',
+    IDA_BRIDGE_ENDPOINT: 'http://127.0.0.1:18081',
+}));
+vi.mock('node:child_process', () => ({ execFile: vi.fn() }));
+vi.mock('node:util', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, promisify: vi.fn(() => execFileMock) };
+});
+vi.stubGlobal('fetch', mockFetch);
+import { runEnvironmentDoctor, formatEnvironmentDoctorReport, } from '../../src/utils/environmentDoctor.js';
+function makeMinimalReport(overrides) {
+    return {
+        success: true,
+        generatedAt: '2026-01-01T00:00:00.000Z',
+        runtime: { platform: 'win32', arch: 'x64', node: 'v22.0.0', cwd: '/work', projectRoot: '/project' },
+        packages: [],
+        commands: [],
+        bridges: [],
+        config: {},
+        limitations: [],
+        recommendations: [],
+        ...overrides,
+    };
+}
+describe('runEnvironmentDoctor', () => {
+    beforeEach(() => {
+        probeAllMock.mockReset().mockResolvedValue({});
+        execFileMock.mockReset();
+        mockFetch.mockReset();
+        execFileMock.mockImplementation((cmd) => {
+            if (cmd === 'git')
+                return Promise.resolve({ stdout: 'git version 2.43.0', stderr: '' });
+            if (cmd === 'python')
+                return Promise.resolve({ stdout: 'Python 3.12.0', stderr: '' });
+            if (cmd === 'pnpm')
+                return Promise.resolve({ stdout: '10.28.2', stderr: '' });
+            return Promise.resolve({ stdout: 'available', stderr: '' });
+        });
+        mockFetch.mockRejectedValue(new Error('connect ECONNREFUSED'));
+    });
+    it('returns a report with runtime info', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        expect(report.runtime.platform).toBe(process.platform);
+        expect(report.runtime.arch).toBe(process.arch);
+        expect(report.runtime.node).toBe(process.version);
+        expect(report.generatedAt).toBeDefined();
+    });
+    it('reports installed packages', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        const mcpSdk = report.packages.find((p) => p.name === '@modelcontextprotocol/sdk');
+        expect(mcpSdk).toBeDefined();
+        expect(['ok', 'missing']).toContain(mcpSdk.status);
+    });
+    it('checks commands and reports status', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        const git = report.commands.find((c) => c.name === 'git');
+        expect(git).toBeDefined();
+        expect(git.status).toBe('ok');
+        expect(git.detail).toContain('git version');
+    });
+    it('reports missing commands with ENOENT as missing', async () => {
+        execFileMock.mockImplementation((cmd) => {
+            if (cmd === 'python')
+                return Promise.reject(new Error('ENOENT: python not found'));
+            return Promise.resolve({ stdout: 'ok', stderr: '' });
+        });
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        const python = report.commands.find((c) => c.name === 'python');
+        expect(python.status).toBe('missing');
+    });
+    it('reports warn for non-ENOENT command errors', async () => {
+        execFileMock.mockImplementation((cmd) => {
+            if (cmd === 'python')
+                return Promise.reject(new Error('permission denied'));
+            return Promise.resolve({ stdout: 'ok', stderr: '' });
+        });
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        const python = report.commands.find((c) => c.name === 'python');
+        expect(python.status).toBe('warn');
+    });
+    it('includes external tool registry results in commands', async () => {
+        probeAllMock.mockResolvedValue({
+            'wabt.wasm2wat': { available: true, path: '/usr/bin/wasm2wat', version: '1.0' },
+            'wabt.wasm-decompile': { available: false, reason: 'Not installed' },
+        });
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        const wasm2wat = report.commands.find((c) => c.name === 'wabt.wasm2wat');
+        expect(wasm2wat.status).toBe('ok');
+        const decompile = report.commands.find((c) => c.name === 'wabt.wasm-decompile');
+        expect(decompile.status).toBe('missing');
+    });
+    it('checks bridge health when includeBridgeHealth is true', async () => {
+        mockFetch.mockResolvedValue({ ok: true, status: 200 });
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: true });
+        expect(report.bridges.length).toBeGreaterThan(0);
+        const ghidra = report.bridges.find((b) => b.name === 'ghidra-bridge');
+        expect(ghidra.status).toBe('ok');
+    });
+    it('reports warn for bridge health failures', async () => {
+        mockFetch.mockRejectedValue(new Error('ECONNREFUSED'));
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: true });
+        const ghidra = report.bridges.find((b) => b.name === 'ghidra-bridge');
+        expect(ghidra.status).toBe('warn');
+        expect(ghidra.detail).toContain('ECONNREFUSED');
+    });
+    it('reports warn for non-ok HTTP status from bridge', async () => {
+        mockFetch.mockResolvedValue({ ok: false, status: 500 });
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: true });
+        const ghidra = report.bridges.find((b) => b.name === 'ghidra-bridge');
+        expect(ghidra.status).toBe('warn');
+        expect(ghidra.detail).toContain('500');
+    });
+    it('skips bridges when includeBridgeHealth is false', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        expect(report.bridges).toHaveLength(0);
+    });
+    it('defaults includeBridgeHealth to true', async () => {
+        mockFetch.mockRejectedValue(new Error('refused'));
+        const report = await runEnvironmentDoctor();
+        expect(report.bridges.length).toBeGreaterThan(0);
+    });
+    it('success is true when no checks have error status', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        expect(report.success).toBe(true);
+    });
+    it('includes config from environment', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        expect(report.config).toHaveProperty('transport');
+        expect(report.config).toHaveProperty('toolProfile');
+        expect(report.config).toHaveProperty('artifactRetention');
+    });
+    it('includes platform limitations', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        if (process.platform !== 'win32') {
+            expect(report.limitations.some((l) => l.includes('Windows-only'))).toBe(true);
+        }
+    });
+    it('recommends camoufox install when package is missing', async () => {
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        const camoufox = report.packages.find((p) => p.name === 'camoufox-js');
+        if (camoufox && camoufox.status !== 'ok') {
+            expect(report.recommendations.some((r) => r.includes('Camoufox'))).toBe(true);
+        }
+    });
+    it('recommends checking bridges when bridge health fails', async () => {
+        mockFetch.mockRejectedValue(new Error('refused'));
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: true });
+        expect(report.recommendations.some((r) => r.includes('bridge'))).toBe(true);
+    });
+    it('recommends wabt when wabt tools are missing', async () => {
+        probeAllMock.mockResolvedValue({
+            'wabt.wasm2wat': { available: false, reason: 'Not installed' },
+        });
+        const report = await runEnvironmentDoctor({ includeBridgeHealth: false });
+        expect(report.recommendations.some((r) => r.includes('wabt'))).toBe(true);
+    });
+});
+describe('formatEnvironmentDoctorReport', () => {
+    it('includes runtime info in output', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport());
+        expect(output).toContain('win32 x64');
+        expect(output).toContain('Node v22.0.0');
+    });
+    it('includes packages section', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ packages: [{ name: 'test-pkg', status: 'ok', detail: 'installed (1.0.0)' }] }));
+        expect(output).toContain('Packages:');
+        expect(output).toContain('[ok] test-pkg: installed (1.0.0)');
+    });
+    it('includes commands section', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ commands: [{ name: 'git', status: 'ok', detail: 'git version 2.43.0' }] }));
+        expect(output).toContain('Commands:');
+        expect(output).toContain('[ok] git');
+    });
+    it('includes bridge health section when bridges exist', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ bridges: [{ name: 'ghidra-bridge', status: 'warn', detail: 'refused' }] }));
+        expect(output).toContain('Bridge health:');
+        expect(output).toContain('[warn] ghidra-bridge');
+    });
+    it('omits bridge section when bridges are empty', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ bridges: [] }));
+        expect(output).not.toContain('Bridge health:');
+    });
+    it('includes config section with JSON for objects', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ config: { transport: 'stdio', nested: { key: 'value' } } }));
+        expect(output).toContain('transport: stdio');
+        expect(output).toContain('nested: {"key":"value"}');
+    });
+    it('includes limitations when present', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ limitations: ['Memory tools Windows-only'] }));
+        expect(output).toContain('Platform limitations:');
+        expect(output).toContain('Memory tools Windows-only');
+    });
+    it('omits limitations section when empty', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ limitations: [] }));
+        expect(output).not.toContain('Platform limitations:');
+    });
+    it('includes recommendations when present', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ recommendations: ['Install wabt for WASM support'] }));
+        expect(output).toContain('Recommendations:');
+        expect(output).toContain('Install wabt');
+    });
+    it('shows overall ok when success is true', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ success: true }));
+        expect(output).toContain('Overall: ok');
+    });
+    it('shows review message when success is false', () => {
+        const output = formatEnvironmentDoctorReport(makeMinimalReport({ success: false }));
+        expect(output).toContain('Overall: review warnings above');
+    });
+});

package/dist/tests/utils/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/logger.test.js

@@ -0,0 +1,66 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { logger } from '../../src/utils/logger.js';
+describe('logger', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        logger.setLevel('debug');
+    });
+    afterEach(() => {
+        logger.setLevel('info');
+        vi.restoreAllMocks();
+    });
+    it('emits debug logs when level is debug', () => {
+        logger.debug('debug message', { x: 1 });
+        expect(console.error).toHaveBeenCalledTimes(1);
+        const output = String(console.error.mock.calls[0][0]);
+        expect(output).toContain('[DEBUG]');
+        expect(output).toContain('debug message');
+    });
+    it('respects level filtering and suppresses lower-priority logs', () => {
+        logger.setLevel('warn');
+        logger.info('hidden info');
+        logger.warn('visible warn');
+        expect(console.error).toHaveBeenCalledTimes(1);
+        const output = String(console.error.mock.calls[0][0]);
+        expect(output).toContain('[WARN]');
+        expect(output).toContain('visible warn');
+    });
+    it('redacts sensitive keys from structured payloads', () => {
+        logger.info('auth payload', {
+            token: 'plain-token-value',
+            authorization: 'Bearer abcdef',
+            normalField: 'safe',
+        });
+        const output = String(console.error.mock.calls[0][0]);
+        expect(output).toContain('[REDACTED]');
+        expect(output).not.toContain('plain-token-value');
+        expect(output).not.toContain('Bearer abcdef');
+        expect(output).toContain('safe');
+    });
+    it('redacts secret-like values even when keys are not sensitive', () => {
+        logger.info('value redaction', {
+            harmless: 'Bearer very-secret-token',
+            another: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.payload.signature',
+        });
+        const output = String(console.error.mock.calls[0][0]);
+        expect(output).toContain('[REDACTED]');
+        expect(output).not.toContain('very-secret-token');
+        expect(output).not.toContain('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9');
+    });
+    it('falls back to [unserializable] for circular arguments', () => {
+        const circular = {};
+        circular.self = circular;
+        logger.info('circular', circular);
+        const output = String(console.error.mock.calls[0][0]);
+        expect(output).toContain('[unserializable]');
+    });
+    it('success logs use info-level threshold and include info prefix', () => {
+        logger.setLevel('info');
+        logger.success('operation completed');
+        expect(console.error).toHaveBeenCalledTimes(1);
+        const output = String(console.error.mock.calls[0][0]);
+        expect(output).toContain('[INFO]');
+        expect(output).toContain('operation completed');
+    });
+});

package/dist/tests/utils/outputPaths.test.d.ts

@@ -0,0 +1 @@
+export {};