@cspeach/cli 0.6.2 → 0.6.4

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

@@ -0,0 +1,329 @@
+// 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

@@ -0,0 +1,215 @@
+// 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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,69 @@
+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);
+    });
+});