@cspeach/cli 0.6.4 → 0.7.0

package/dist/tools/__tests__/web_fetch.test.js

@@ -1,329 +0,0 @@
-// cspeach-cli/src/tools/__tests__/web_fetch.test.ts
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { EventEmitter } from 'node:events';
-/**
- * `node:https`'s exported `request` function is a non-configurable own
- * property of the module namespace (Object.getOwnPropertyDescriptor
- * shows `configurable: false`), so `vi.spyOn(https, 'request')` throws
- * "Cannot redefine property". We use `vi.mock('node:https', ...)` —
- * hoisted by vitest before module resolution — so the implementation's
- * `import * as https from 'node:https'` resolves to a controllable
- * mock instead. Each test resets `mockRequest`'s impl via the
- * `setupHttpsMock(responder)` helper.
- */
-const { mockRequest } = vi.hoisted(() => ({ mockRequest: vi.fn() }));
-vi.mock('node:https', () => ({
-    default: { request: mockRequest },
-    request: mockRequest,
-}));
-import { webFetchHandler, USER_AGENT } from '../web/web_fetch.js';
-import { makeCtx } from './_helpers.js';
-function setupHttpsMock(responder) {
-    const recorded = [];
-    let callIndex = 0;
-    mockRequest.mockImplementation((...rawArgs) => {
-        // https.request can be called as (opts, cb) OR (url, opts, cb) OR (url, cb).
-        let opts;
-        let cb;
-        if (rawArgs.length === 1) {
-            opts = rawArgs[0];
-        }
-        else if (rawArgs.length === 2) {
-            if (typeof rawArgs[1] === 'function') {
-                opts = rawArgs[0];
-                cb = rawArgs[1];
-            }
-            else {
-                opts = { ...rawArgs[0], ...rawArgs[1] };
-            }
-        }
-        else {
-            opts = { ...rawArgs[0], ...rawArgs[1] };
-            cb = rawArgs[2];
-        }
-        const spec = responder(opts, callIndex);
-        callIndex++;
-        recorded.push({ options: opts, spec });
-        const req = new EventEmitter();
-        req.setTimeout = (ms, fn) => {
-            if (spec.kind === 'timeout' && fn)
-                setTimeout(fn, 0);
-        };
-        req.destroy = (err) => { req.emit('close'); if (err)
-            req.emit('error', err); };
-        req.end = () => {
-            if (spec.kind === 'response' && cb) {
-                const res = new EventEmitter();
-                res.statusCode = spec.statusCode;
-                res.headers = spec.headers;
-                // Real Node streams' destroy() emits 'close' but NOT 'end'.
-                // The mock must mirror that contract: once destroy() has been
-                // called, no further 'data' or 'end' events fire. Otherwise the
-                // mock papers over production code that relies on 'end' firing
-                // after destroy() — which it doesn't, in real Node.
-                let destroyed = false;
-                res.destroy = () => { destroyed = true; };
-                setImmediate(() => {
-                    cb(res);
-                    setImmediate(() => {
-                        if (spec.bodyChunks) {
-                            for (const chunk of spec.bodyChunks) {
-                                if (destroyed)
-                                    break;
-                                res.emit('data', chunk);
-                            }
-                        }
-                        else {
-                            if (!destroyed)
-                                res.emit('data', Buffer.isBuffer(spec.body) ? spec.body : Buffer.from(spec.body, 'utf-8'));
-                        }
-                        if (!destroyed)
-                            res.emit('end');
-                    });
-                });
-            }
-            else if (spec.kind === 'error') {
-                setImmediate(() => req.emit('error', spec.error));
-            }
-            // 'timeout' kind: setTimeout fired via req.setTimeout above
-        };
-        return req;
-    });
-    return { recorded };
-}
-const fakeDeps = (addresses) => ({
-    resolveAll: async () => addresses,
-});
-const ctx = () => makeCtx(process.cwd());
-beforeEach(() => {
-    delete process.env.CSPEACH_WEB_ALLOW_PRIVATE;
-    mockRequest.mockReset();
-});
-afterEach(() => {
-    delete process.env.CSPEACH_WEB_ALLOW_PRIVATE;
-    mockRequest.mockReset();
-});
-describe('web_fetch — happy path', () => {
-    it('fetches a public HTTPS URL and returns its body + status + headers', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'text/plain; charset=utf-8' },
-            body: 'hello world',
-        }));
-        const r = await webFetchHandler({ url: 'https://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('status: 200');
-        expect(r.content).toContain('hello world');
-    });
-    it('sends our User-Agent header on every request', async () => {
-        const { recorded } = setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'text/plain' },
-            body: 'ok',
-        }));
-        await webFetchHandler({ url: 'https://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        const sentUa = recorded[0].options.headers?.['User-Agent'] ?? recorded[0].options.headers?.['user-agent'];
-        expect(sentUa).toBe(USER_AGENT);
-        expect(USER_AGENT).toMatch(/^cspeach\/\d+\.\d+ \(\+https:\/\/cspeach\.dev\)$/);
-    });
-});
-describe('web_fetch — URL / protocol / IP guards', () => {
-    it('refuses http:// (HTTPS-only)', async () => {
-        const r = await webFetchHandler({ url: 'http://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/protocol|https/i);
-    });
-    it('refuses literal localhost hostname', async () => {
-        const r = await webFetchHandler({ url: 'https://localhost/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/blocked|localhost/i);
-    });
-    it('refuses a 10.x.x.x literal IP', async () => {
-        const r = await webFetchHandler({ url: 'https://10.0.0.1/' }, ctx(), { _deps: fakeDeps([]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/private|reserved/i);
-    });
-    it('refuses a public hostname that resolves to 169.254.169.254 (cloud metadata)', async () => {
-        const r = await webFetchHandler({ url: 'https://attacker.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '169.254.169.254', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/private|metadata/i);
-    });
-    it('refuses a public hostname that resolves to 127.0.0.1 (DNS-rebinding)', async () => {
-        const r = await webFetchHandler({ url: 'https://innocent.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '127.0.0.1', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/private|loopback/i);
-    });
-    it('allows a private IP when CSPEACH_WEB_ALLOW_PRIVATE=on', async () => {
-        process.env.CSPEACH_WEB_ALLOW_PRIVATE = 'on';
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'text/plain' },
-            body: 'dev server',
-        }));
-        const r = await webFetchHandler({ url: 'https://dev.local.test/' }, ctx(), { _deps: fakeDeps([{ address: '127.0.0.1', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('dev server');
-    });
-    it('passes a pinnedLookup that returns the validated address, not a fresh DNS query', async () => {
-        const { recorded } = setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'text/plain' },
-            body: 'ok',
-        }));
-        await webFetchHandler({ url: 'https://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        const lookup = recorded[0].options.lookup;
-        expect(typeof lookup).toBe('function');
-        const result = await new Promise((resolve, reject) => {
-            lookup('example.com', {}, (err, address, family) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve({ addr: address, fam: family });
-            });
-        });
-        expect(result.addr).toBe('93.184.216.34');
-        expect(result.fam).toBe(4);
-    });
-});
-describe('web_fetch — redirects', () => {
-    it('follows a single 302 redirect to a different public host', async () => {
-        let call = 0;
-        setupHttpsMock((opts) => {
-            call++;
-            if (call === 1) {
-                return {
-                    kind: 'response',
-                    statusCode: 302,
-                    headers: { 'content-type': 'text/plain', location: 'https://target.example.com/final' },
-                    body: '',
-                };
-            }
-            return {
-                kind: 'response',
-                statusCode: 200,
-                headers: { 'content-type': 'text/plain' },
-                body: 'final page',
-            };
-        });
-        const r = await webFetchHandler({ url: 'https://start.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('final page');
-        expect(r.content).toMatch(/redirects: 1/i);
-    });
-    it('refuses a redirect that points at a private IP', async () => {
-        let call = 0;
-        setupHttpsMock(() => {
-            call++;
-            if (call === 1) {
-                return {
-                    kind: 'response',
-                    statusCode: 302,
-                    headers: { 'content-type': 'text/plain', location: 'https://10.0.0.1/admin' },
-                    body: '',
-                };
-            }
-            return { kind: 'response', statusCode: 200, headers: { 'content-type': 'text/plain' }, body: 'should never reach' };
-        });
-        const r = await webFetchHandler({ url: 'https://start.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/private|redirect/i);
-        expect(call).toBe(1); // we never made the second request
-    });
-    it('refuses a redirect that downgrades to http://', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 302,
-            headers: { 'content-type': 'text/plain', location: 'http://example.com/insecure' },
-            body: '',
-        }));
-        const r = await webFetchHandler({ url: 'https://start.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/protocol|https/i);
-    });
-    it('aborts after 5 hops with a structured error', async () => {
-        let call = 0;
-        setupHttpsMock(() => {
-            call++;
-            return {
-                kind: 'response',
-                statusCode: 302,
-                headers: { 'content-type': 'text/plain', location: `https://hop${call}.example.com/` },
-                body: '',
-            };
-        });
-        const r = await webFetchHandler({ url: 'https://start.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/redirect.*limit|too many redirects/i);
-        // 1 initial + 5 redirect hops attempted, then refused — exact-count
-        // is the invariant; loosening to <=6 would mask a regression that
-        // aborts at hop 3.
-        expect(call).toBe(6);
-    });
-});
-describe('web_fetch — response handling', () => {
-    it('refuses application/octet-stream and other non-allowlisted content-types', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'application/octet-stream' },
-            body: Buffer.from([0x00, 0x01, 0x02]),
-        }));
-        const r = await webFetchHandler({ url: 'https://example.com/data.bin' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/content.?type|allowed/i);
-    });
-    it('accepts text/html, application/json, application/xml', async () => {
-        for (const ct of ['text/html; charset=utf-8', 'application/json', 'application/xml']) {
-            setupHttpsMock(() => ({ kind: 'response', statusCode: 200, headers: { 'content-type': ct }, body: 'ok' }));
-            const r = await webFetchHandler({ url: 'https://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-            expect(r.is_error).toBeFalsy();
-        }
-    });
-    it('truncates a response that exceeds 1 MB and appends a marker', async () => {
-        const giant = 'A'.repeat(2_000_000);
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'text/plain' },
-            bodyChunks: [Buffer.from(giant.slice(0, 500_000)), Buffer.from(giant.slice(500_000, 1_000_000)), Buffer.from(giant.slice(1_000_000))],
-            body: '',
-        }));
-        const r = await webFetchHandler({ url: 'https://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/\[truncated/i);
-        expect(r.content.length).toBeLessThan(1_200_000);
-    });
-    it('reports a 10s timeout as a structured error', async () => {
-        setupHttpsMock(() => ({ kind: 'timeout' }));
-        const r = await webFetchHandler({ url: 'https://slow.example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]), _timeoutMs: 50 });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/timeout|timed out/i);
-    });
-    it('rejects responses with Content-Encoding other than identity', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'text/html', 'content-encoding': 'gzip' },
-            body: Buffer.from([0x1f, 0x8b, 0x08]), // gzip magic header, just to be realistic
-        }));
-        const r = await webFetchHandler({ url: 'https://example.com/' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/content.?encoding|gzip|identity/i);
-    });
-    it('surfaces non-2xx status + body WITHOUT marking is_error (the agent sees the 404)', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 404,
-            headers: { 'content-type': 'text/html' },
-            body: '<h1>Not Found</h1>',
-        }));
-        const r = await webFetchHandler({ url: 'https://example.com/missing' }, ctx(), { _deps: fakeDeps([{ address: '93.184.216.34', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/status:\s*404/);
-        expect(r.content).toContain('Not Found');
-    });
-});

package/dist/tools/__tests__/web_search.test.js

@@ -1,215 +0,0 @@
-// cspeach-cli/src/tools/__tests__/web_search.test.ts
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { EventEmitter } from 'node:events';
-import { webSearchHandler } from '../web/web_search.js';
-import { makeCtx } from './_helpers.js';
-const { mockRequest } = vi.hoisted(() => ({ mockRequest: vi.fn() }));
-vi.mock('node:https', () => ({
-    default: { request: mockRequest },
-    request: mockRequest,
-}));
-function setupHttpsMock(responder) {
-    const recorded = [];
-    let callIndex = 0;
-    mockRequest.mockImplementation((...rawArgs) => {
-        let opts;
-        let cb;
-        if (rawArgs.length === 1)
-            opts = rawArgs[0];
-        else if (rawArgs.length === 2) {
-            if (typeof rawArgs[1] === 'function') {
-                opts = rawArgs[0];
-                cb = rawArgs[1];
-            }
-            else {
-                opts = { ...rawArgs[0], ...rawArgs[1] };
-            }
-        }
-        else {
-            opts = { ...rawArgs[0], ...rawArgs[1] };
-            cb = rawArgs[2];
-        }
-        const spec = responder(opts, callIndex);
-        callIndex++;
-        recorded.push({ options: opts, spec });
-        const req = new EventEmitter();
-        let destroyed = false;
-        req.setTimeout = (_ms, fn) => {
-            if (spec.kind === 'timeout' && fn)
-                setTimeout(fn, 0);
-        };
-        req.destroy = () => { destroyed = true; req.emit('close'); };
-        req.end = () => {
-            if (spec.kind === 'response' && cb) {
-                const res = new EventEmitter();
-                res.statusCode = spec.statusCode;
-                res.headers = spec.headers;
-                let resDestroyed = false;
-                res.destroy = () => { resDestroyed = true; };
-                setImmediate(() => {
-                    cb(res);
-                    setImmediate(() => {
-                        if (spec.bodyChunks) {
-                            for (const chunk of spec.bodyChunks) {
-                                if (resDestroyed)
-                                    break;
-                                res.emit('data', chunk);
-                            }
-                        }
-                        else {
-                            if (!resDestroyed) {
-                                res.emit('data', Buffer.isBuffer(spec.body) ? spec.body : Buffer.from(spec.body, 'utf-8'));
-                            }
-                        }
-                        if (!resDestroyed)
-                            res.emit('end');
-                    });
-                });
-            }
-            else if (spec.kind === 'error') {
-                setImmediate(() => req.emit('error', spec.error));
-            }
-        };
-        return req;
-    });
-    return { recorded };
-}
-const fakeDeps = (addresses) => ({
-    resolveAll: async () => addresses,
-});
-const ctx = () => makeCtx(process.cwd());
-const VALID_API_KEY = 'BSA-test-key-1234567890';
-let origKey;
-beforeEach(() => {
-    origKey = process.env.CSPEACH_BRAVE_SEARCH_KEY;
-    process.env.CSPEACH_BRAVE_SEARCH_KEY = VALID_API_KEY;
-    vi.clearAllMocks();
-});
-afterEach(() => {
-    if (origKey === undefined)
-        delete process.env.CSPEACH_BRAVE_SEARCH_KEY;
-    else
-        process.env.CSPEACH_BRAVE_SEARCH_KEY = origKey;
-    vi.clearAllMocks();
-});
-describe('web_search — happy path', () => {
-    it('issues a request to BRAVE_ENDPOINT with API key header and parses results', async () => {
-        const fakeResponse = {
-            web: {
-                results: [
-                    { title: 'SAP RAP Tutorial', url: 'https://help.sap.com/rap', description: 'Restful Application Programming' },
-                    { title: 'CDS Views', url: 'https://help.sap.com/cds', description: 'Core Data Services overview' },
-                ],
-            },
-        };
-        const { recorded } = setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(fakeResponse),
-        }));
-        const r = await webSearchHandler({ query: 'sap rap tutorial' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('SAP RAP Tutorial');
-        expect(r.content).toContain('https://help.sap.com/rap');
-        expect(r.content).toContain('Restful Application Programming');
-        expect(r.content).toContain('CDS Views');
-        expect(recorded[0].options.headers?.['X-Subscription-Token']).toBe(VALID_API_KEY);
-        expect(recorded[0].options.hostname).toBe('api.search.brave.com');
-    });
-    it('respects count parameter and caps it at 20', async () => {
-        const results = Array.from({ length: 25 }, (_, i) => ({
-            title: `Result ${i}`,
-            url: `https://example.com/${i}`,
-            description: `Description ${i}`,
-        }));
-        const { recorded } = setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ web: { results } }),
-        }));
-        await webSearchHandler({ query: 'test', count: 99 }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        // The URL the handler builds for Brave must include count=20 (clamped)
-        const sentPath = recorded[0].options.path;
-        expect(sentPath).toMatch(/count=20/);
-    });
-    it('returns empty-results envelope cleanly when Brave returns 0 results', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ web: { results: [] } }),
-        }));
-        const r = await webSearchHandler({ query: 'asdfqwerzxcv-zero-results-expected' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/0 results|no results/i);
-    });
-});
-describe('web_search — input validation + API key handling', () => {
-    it('returns a structured error when CSPEACH_BRAVE_SEARCH_KEY is unset', async () => {
-        delete process.env.CSPEACH_BRAVE_SEARCH_KEY;
-        const r = await webSearchHandler({ query: 'test' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/CSPEACH_BRAVE_SEARCH_KEY/);
-        expect(r.content).not.toContain(VALID_API_KEY); // sanity — no leak when key IS set but elsewhere referenced
-    });
-    it('does NOT include the API key value in any error envelope', async () => {
-        // Embed the key in the 401 body so the scrub is what makes the assertion
-        // pass. Without scrub the key would land in the returned content and
-        // the not.toContain would fail. Simulates a misbehaving proxy that
-        // echoes the X-Subscription-Token header into its error response body.
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 401,
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ error: 'invalid api key', debug: VALID_API_KEY }),
-        }));
-        const r = await webSearchHandler({ query: 'test' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).not.toContain(VALID_API_KEY);
-        // Positive assertion that the scrub fired — the masked marker MUST appear
-        // in the returned content (since the mock body contained the key).
-        expect(r.content).toContain('***');
-    });
-    it('rejects empty query with structured error', async () => {
-        const r = await webSearchHandler({ query: '' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/query.*required|empty/i);
-    });
-    it('rejects whitespace-only query', async () => {
-        const r = await webSearchHandler({ query: '   \t\n   ' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/query.*required|empty/i);
-    });
-});
-describe('web_search — error handling', () => {
-    it('surfaces a 429 rate-limit response as structured error', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 429,
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ error: 'rate limit exceeded' }),
-        }));
-        const r = await webSearchHandler({ query: 'test' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        // The handler emits `status 429` (no colon); match the actual format.
-        expect(r.content).toMatch(/status 429|rate limit/i);
-    });
-    it('returns structured error for malformed JSON response', async () => {
-        setupHttpsMock(() => ({
-            kind: 'response',
-            statusCode: 200,
-            headers: { 'content-type': 'application/json' },
-            body: '{ not valid json',
-        }));
-        const r = await webSearchHandler({ query: 'test' }, ctx(), { _deps: fakeDeps([{ address: '23.21.34.5', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/json|parse|malformed/i);
-    });
-    it('rejects when api.search.brave.com resolves to a private IP (DNS-hijack defense)', async () => {
-        const r = await webSearchHandler({ query: 'test' }, ctx(), { _deps: fakeDeps([{ address: '127.0.0.1', family: 4 }]) });
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/blocked|private|loopback/i);
-    });
-});

package/dist/tools/__tests__/write-mode.test.js

@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isWriteTool, WRITE_TOOLS } from '../write-mode.js';
-describe('isWriteTool', () => {
-    it('returns true for mutating SAP tools', () => {
-        expect(isWriteTool('sap_create_object')).toBe(true);
-        expect(isWriteTool('sap_set_source')).toBe(true);
-        expect(isWriteTool('sap_update_method')).toBe(true);
-        expect(isWriteTool('sap_delete_object')).toBe(true);
-        expect(isWriteTool('sap_activate')).toBe(true);
-        expect(isWriteTool('sap_message_maintain')).toBe(true);
-        expect(isWriteTool('sap_service_binding_publish')).toBe(true);
-        expect(isWriteTool('sap_transport_release')).toBe(true);
-    });
-    it('returns false for read-only SAP tools', () => {
-        expect(isWriteTool('sap_get_source')).toBe(false);
-        expect(isWriteTool('sap_search_object')).toBe(false);
-        expect(isWriteTool('sap_atc_run')).toBe(false);
-        expect(isWriteTool('sap_syntax_check')).toBe(false);
-    });
-    it('returns false for control tools (lock/unlock/snapshot)', () => {
-        expect(isWriteTool('sap_lock')).toBe(false);
-        expect(isWriteTool('sap_unlock')).toBe(false);
-        expect(isWriteTool('sap_snapshot')).toBe(false);
-    });
-    it('returns false for unknown tool names', () => {
-        expect(isWriteTool('unknown_tool')).toBe(false);
-        expect(isWriteTool('')).toBe(false);
-    });
-    it('WRITE_TOOLS is non-empty and contains the canonical eight', () => {
-        expect(WRITE_TOOLS.size).toBe(8);
-    });
-});

package/dist/ui/__tests__/login-banner.test.js

@@ -1,69 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { formatLoginBanner } from '../login-banner.js';
-const base = {
-    email: 'a@b.com', company: null, plan: 'solo',
-    trial_mode: null, trial_ends_at: null,
-    trial_token_cap_input: null, trial_token_cap_output: null,
-    usage_input_tokens: 0, usage_output_tokens: 0,
-    entitlements: { enabled_skills: [], agent_mode: 'skill', enabled_features: [] },
-};
-describe('formatLoginBanner', () => {
-    it('non-trial: just shows email + plan', () => {
-        const { line, warningLine } = formatLoginBanner({ ...base, plan: 'solo' });
-        expect(line).toMatch(/Signed in as a@b\.com/);
-        expect(line).toMatch(/solo/);
-        expect(warningLine).toBeNull();
-    });
-    it('managed-capped trial: shows days left + token progress', () => {
-        // +1 h buffer so floor division stays at 6 even if a few ms elapse between
-        // test setup and banner render.
-        const ends = new Date(Date.now() + 6 * 86400_000 + 3600_000).toISOString();
-        const { line } = formatLoginBanner({
-            ...base, plan: 'trial-managed', trial_mode: 'managed-capped',
-            trial_ends_at: ends, trial_token_cap_input: 200_000, trial_token_cap_output: 50_000,
-            usage_input_tokens: 47_000, usage_output_tokens: 8_000,
-        });
-        expect(line).toMatch(/trial/i);
-        expect(line).toMatch(/6\s*days?/i);
-        expect(line).toMatch(/47/);
-        expect(line).toMatch(/200/);
-    });
-    it('byok trial: omits token budget (customer pays Anthropic directly)', () => {
-        const ends = new Date(Date.now() + 6 * 86400_000).toISOString();
-        const { line } = formatLoginBanner({
-            ...base, plan: 'trial-byok', trial_mode: 'byok',
-            trial_ends_at: ends,
-        });
-        expect(line).toMatch(/byok/i);
-        expect(line).toMatch(/6\s*days?/i);
-        expect(line).not.toMatch(/\/200/);
-    });
-    it('warning fires when token usage ≥ 80% of input cap', () => {
-        const ends = new Date(Date.now() + 6 * 86400_000).toISOString();
-        const { warningLine } = formatLoginBanner({
-            ...base, plan: 'trial-managed', trial_mode: 'managed-capped',
-            trial_ends_at: ends, trial_token_cap_input: 100_000, trial_token_cap_output: 25_000,
-            usage_input_tokens: 82_000, usage_output_tokens: 5_000,
-        });
-        expect(warningLine).not.toBeNull();
-        expect(warningLine).toMatch(/80%|budget|cap/i);
-    });
-    it('warning fires when trial expiry < 24 hours away', () => {
-        const ends = new Date(Date.now() + 12 * 3600_000).toISOString();
-        const { warningLine } = formatLoginBanner({
-            ...base, plan: 'trial-managed', trial_mode: 'managed-capped',
-            trial_ends_at: ends, trial_token_cap_input: 200_000, trial_token_cap_output: 50_000,
-        });
-        expect(warningLine).not.toBeNull();
-        expect(warningLine).toMatch(/expires|24 hours|hours? left/i);
-    });
-    it('expired trial: warning says expired', () => {
-        const ends = new Date(Date.now() - 86400_000).toISOString();
-        const { warningLine } = formatLoginBanner({
-            ...base, plan: 'trial-managed', trial_mode: 'managed-capped',
-            trial_ends_at: ends, trial_token_cap_input: 200_000, trial_token_cap_output: 50_000,
-        });
-        expect(warningLine).not.toBeNull();
-        expect(warningLine).toMatch(/expired/i);
-    });
-});