squeezr-ai 1.90.0 → 1.99.2

package/dist/__tests__/compressor.test.js

@@ -296,7 +296,11 @@ describe('compressGeminiContents', () => {
         const cts = makeContents(['g'.repeat(200), 'h'.repeat(200)]);
         await compressGeminiContents(cts, 'my-google-key', baseConfig);
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('generativelanguage.googleapis.com'), expect.any(Object));
-        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('my-google-key'), expect.any(Object));
+        // Security: the key travels in the x-goog-api-key header, never in the URL.
+        const [calledUrl, calledOpts] = mockFetch.mock.calls.at(-1);
+        expect(calledUrl).not.toContain('my-google-key');
+        expect(calledUrl).not.toContain('key=');
+        expect(calledOpts.headers['x-goog-api-key']).toBe('my-google-key');
     });
     it('returns dry-run without modifications', async () => {
         const oldText = 'g'.repeat(200);

package/dist/__tests__/contentRouter.test.d.ts

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

package/dist/__tests__/contentRouter.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { findObjectArraySpans, crushEmbeddedJson, TABLE_MARKER_RE } from '../contentRouter.js';
+import { retrieveOriginal } from '../expand.js';
+function bigArray(prefix = '', suffix = '') {
+    const rows = Array.from({ length: 20 }, (_, i) => ({ id: i, name: `svc-${i}`, status: 'ok', region: 'us-east-1' }));
+    return `${prefix}${JSON.stringify(rows)}${suffix}`;
+}
+describe('findObjectArraySpans', () => {
+    it('finds a whole-text array of objects', () => {
+        const t = JSON.stringify([{ a: 1 }, { a: 2 }]);
+        const spans = findObjectArraySpans(t);
+        expect(spans.length).toBe(1);
+        expect(t.slice(spans[0].start, spans[0].end)).toBe(t);
+    });
+    it('finds an array embedded between prose', () => {
+        const t = bigArray('Here are the pods:\n', '\nDone.');
+        const spans = findObjectArraySpans(t);
+        expect(spans.length).toBe(1);
+        const sub = t.slice(spans[0].start, spans[0].end);
+        expect(sub.startsWith('[{')).toBe(true);
+        expect(sub.endsWith('}]')).toBe(true);
+    });
+    it('handles brackets inside string values without breaking', () => {
+        const t = 'x ' + JSON.stringify([{ note: 'has ] and } inside' }, { note: 'more [ [ {' }]) + ' y';
+        const spans = findObjectArraySpans(t);
+        expect(spans.length).toBe(1);
+        expect(() => JSON.parse(t.slice(spans[0].start, spans[0].end))).not.toThrow();
+    });
+    it('finds two separate embedded arrays', () => {
+        const t = `first ${JSON.stringify([{ a: 1 }, { a: 2 }])} middle ${JSON.stringify([{ b: 3 }, { b: 4 }])} end`;
+        expect(findObjectArraySpans(t).length).toBe(2);
+    });
+    it('ignores arrays of scalars (not object arrays)', () => {
+        expect(findObjectArraySpans('[1, 2, 3, 4, 5]').length).toBe(0);
+    });
+});
+describe('crushEmbeddedJson', () => {
+    it('crushes an array embedded in prose, preserving the surrounding text', () => {
+        const t = bigArray('POD STATUS REPORT\n', '\n(end of report)');
+        const res = crushEmbeddedJson(t);
+        expect(res.savedChars).toBeGreaterThan(0);
+        expect(res.text.startsWith('POD STATUS REPORT')).toBe(true);
+        expect(res.text.includes('(end of report)')).toBe(true);
+        expect(TABLE_MARKER_RE.test(res.text)).toBe(true);
+    });
+    it('keeps the embedded original recoverable via expand', () => {
+        const t = bigArray('label: ', '');
+        const res = crushEmbeddedJson(t);
+        const m = res.text.match(TABLE_MARKER_RE);
+        expect(m).not.toBeNull();
+        const original = retrieveOriginal(m[1]);
+        expect(original).not.toBeUndefined();
+        expect(() => JSON.parse(original)).not.toThrow();
+    });
+    it('crushes the whole-text case too (parity with jsonCrush)', () => {
+        const res = crushEmbeddedJson(bigArray());
+        expect(res.savedChars).toBeGreaterThan(0);
+        expect(TABLE_MARKER_RE.test(res.text)).toBe(true);
+    });
+    it('leaves text with no crushable arrays unchanged', () => {
+        const t = 'just a normal log line\nwith no json at all';
+        const res = crushEmbeddedJson(t);
+        expect(res.savedChars).toBe(0);
+        expect(res.text).toBe(t);
+    });
+    it('leaves a small (non-crushable) embedded array untouched, surroundings intact', () => {
+        const t = 'before [{"a":1},{"a":2}] after';
+        const res = crushEmbeddedJson(t);
+        expect(res.text).toBe(t);
+        expect(res.savedChars).toBe(0);
+    });
+    it('is deterministic', () => {
+        const t = bigArray('p ', ' s');
+        expect(crushEmbeddedJson(t).text).toBe(crushEmbeddedJson(t).text);
+    });
+});

package/dist/__tests__/controlEndpointGuard.test.d.ts

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

package/dist/__tests__/controlEndpointGuard.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { app } from '../server.js';
+// Security regression: control endpoints (/squeezr/*) must not be usable from a
+// cross-origin browser context. A malicious page open in the user's browser must
+// not be able to change state or read control responses on http://localhost:<port>.
+// We hit *non-existent* control paths so the guard runs but no real handler fires
+// (403 = guard blocked; 404 = guard allowed and routing missed) — no side effects.
+describe('control-endpoint CSRF/CORS guard', () => {
+    it('rejects a cross-origin mutation to a control endpoint with 403', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', {
+            method: 'POST',
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.status).toBe(403);
+    });
+    it('rejects a file:// (null) origin mutation to a control endpoint', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', {
+            method: 'POST',
+            headers: { origin: 'null' },
+        });
+        expect(res.status).toBe(403);
+    });
+    it('allows a mutation with no Origin (curl / MCP / native over loopback)', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', { method: 'POST' });
+        expect(res.status).toBe(404); // guard passed; route simply does not exist
+    });
+    it('allows a mutation from a loopback browser origin', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', {
+            method: 'POST',
+            headers: { origin: 'http://localhost:8899' },
+        });
+        expect(res.status).toBe(404); // guard passed; route simply does not exist
+    });
+    it('does not guard the proxy endpoints (Cursor needs cross-origin)', async () => {
+        const res = await app.request('/v1/__proxy_probe__', {
+            method: 'POST',
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.status).not.toBe(403);
+    });
+    it('never reflects a wildcard ACAO on control endpoints', async () => {
+        const res = await app.request('/squeezr/health', {
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.headers.get('access-control-allow-origin')).not.toBe('*');
+    });
+    it('reflects the loopback origin (not wildcard) on control endpoints', async () => {
+        const res = await app.request('/squeezr/health', {
+            headers: { origin: 'http://127.0.0.1:1234' },
+        });
+        expect(res.headers.get('access-control-allow-origin')).toBe('http://127.0.0.1:1234');
+        expect(res.headers.get('vary')).toBe('Origin');
+    });
+    it('keeps wildcard ACAO on proxy endpoints for browser tooling', async () => {
+        const res = await app.request('/v1/__proxy_probe__', {
+            method: 'OPTIONS',
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.headers.get('access-control-allow-origin')).toBe('*');
+    });
+});

package/dist/__tests__/doctor.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { checkProxy, checkVersion, checkEnv, checkBypass, computeExitCode, formatDoctor, } from '../doctor.js';
+import { checkProxy, checkVersion, checkEnv, checkBypass, checkSavings, computeExitCode, formatDoctor, } from '../doctor.js';
 describe('checkProxy', () => {
     it('passes when health is present', () => {
         expect(checkProxy({ identity: 'squeezr', version: '1.89.0' }).status).toBe('pass');
@@ -46,6 +46,22 @@ describe('checkBypass', () => {
         expect(checkBypass(undefined).status).toBe('skip');
     });
 });
+describe('checkSavings', () => {
+    it('skips when the proxy is down (requests unknown)', () => {
+        expect(checkSavings(undefined, undefined).status).toBe('skip');
+    });
+    it('skips when there is no traffic yet', () => {
+        expect(checkSavings(0, 0).status).toBe('skip');
+    });
+    it('warns when traffic is flowing but nothing is being saved', () => {
+        expect(checkSavings(120, 0).status).toBe('warn');
+    });
+    it('passes when savings are flowing', () => {
+        const r = checkSavings(120, 34);
+        expect(r.status).toBe('pass');
+        expect(r.detail.includes('34')).toBe(true);
+    });
+});
 describe('computeExitCode', () => {
     it('0 when all pass/skip', () => {
         expect(computeExitCode([{ name: 'a', status: 'pass', detail: '' }, { name: 'b', status: 'skip', detail: '' }])).toBe(0);

package/dist/__tests__/jsonCrush.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { crushJsonArrays, TABLE_MARKER_RE } from '../jsonCrush.js';
+import { crushJsonArrays, TABLE_MARKER_RE, simhash32, hammingDistance } from '../jsonCrush.js';
 import { retrieveOriginal } from '../expand.js';
 function makeRows(n) {
     const rows = [];
@@ -101,6 +101,49 @@ describe('crushJsonArrays', () => {
         const b = crushJsonArrays(input).text;
         expect(a).toBe(b);
     });
+    // ── Lossy row-drop (SimHash near-dup collapse) for large arrays ──────────────
+    function manyRows(n) {
+        return Array.from({ length: n }, (_, i) => ({
+            id: i,
+            name: `svc-${i}`,
+            status: i % 2 === 0 ? 'running' : 'stopped',
+            region: 'us-east-1',
+        }));
+    }
+    it('drops near-duplicate rows in a large array but keeps the original recoverable', () => {
+        const rows = manyRows(120);
+        const input = JSON.stringify(rows);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBeGreaterThan(0);
+        // the inline table shows far fewer than 120 rows
+        const bodyLines = text.split('\n').filter(l => l.includes('\t'));
+        expect(bodyLines.length).toBeLessThan(120);
+        // an omitted-rows note is present
+        expect(/of 120 rows|rows omitted|near-duplicate/i.test(text)).toBe(true);
+        // ALL 120 rows still recoverable via expand
+        const m = text.match(TABLE_MARKER_RE);
+        expect(JSON.parse(retrieveOriginal(m[1])).length).toBe(120);
+    });
+    it('ALWAYS keeps an anomalous/error row inline even amid near-duplicates', () => {
+        const rows = manyRows(120);
+        rows[63] = { id: 63, name: 'svc-63', status: 'CrashLoopBackOff', region: 'us-east-1', error: 'OOMKilled' };
+        const input = JSON.stringify(rows);
+        const { text } = crushJsonArrays(input);
+        expect(text.includes('CrashLoopBackOff')).toBe(true);
+        expect(text.includes('OOMKilled')).toBe(true);
+    });
+    it('keeps ALL rows for arrays below the lossy threshold (no row-drop)', () => {
+        const input = JSON.stringify(manyRows(30));
+        const { text } = crushJsonArrays(input);
+        expect(/rows omitted|near-duplicate/i.test(text)).toBe(false);
+        // lines after the marker (0) and header (1) are the data rows
+        const dataRows = text.split('\n').slice(2);
+        expect(dataRows.length).toBe(30);
+    });
+    it('row-drop is deterministic', () => {
+        const input = JSON.stringify(manyRows(150));
+        expect(crushJsonArrays(input).text).toBe(crushJsonArrays(input).text);
+    });
     it('crushes a pretty-printed (indented) JSON array too', () => {
         const input = JSON.stringify(Array.from({ length: 8 }, (_, i) => ({ id: i, name: `x${i}`, status: 'ok', region: 'us' })), null, 2);
         const { text, savedChars } = crushJsonArrays(input);
@@ -108,3 +151,18 @@ describe('crushJsonArrays', () => {
         expect(TABLE_MARKER_RE.test(text)).toBe(true);
     });
 });
+describe('simhash32 / hammingDistance', () => {
+    it('identical text → identical fingerprint (distance 0)', () => {
+        expect(hammingDistance(simhash32('the quick brown fox'), simhash32('the quick brown fox'))).toBe(0);
+    });
+    it('near-identical rows are closer than unrelated ones (the property that matters)', () => {
+        // Realistic row strings (many shared tokens) — SimHash's signal is strongest here.
+        const base = simhash32('id 1 name svc-1 status running region us-east-1 node ip-10-0-1-5');
+        const near = simhash32('id 2 name svc-2 status running region us-east-1 node ip-10-0-1-5');
+        const far = simhash32('completely unrelated payload about quarterly revenue and marketing spend');
+        expect(hammingDistance(base, near)).toBeLessThan(hammingDistance(base, far));
+    });
+    it('is deterministic', () => {
+        expect(simhash32('same input here')).toBe(simhash32('same input here'));
+    });
+});

package/dist/__tests__/outputSavings.test.d.ts

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

package/dist/__tests__/outputSavings.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { wordNgrams, echoRatio, extractAssistantTextFromSse } from '../outputSavings.js';
+describe('wordNgrams', () => {
+    it('builds word n-grams', () => {
+        expect(wordNgrams('a b c d', 3).has('a b c')).toBe(true);
+        expect(wordNgrams('a b c d', 3).has('b c d')).toBe(true);
+    });
+    it('empty for text shorter than n', () => {
+        expect(wordNgrams('a b', 3).size).toBe(0);
+    });
+});
+describe('echoRatio', () => {
+    it('~1 when the output only restates context', () => {
+        const context = 'the authentication middleware refreshes the token on every request cycle';
+        const output = 'the authentication middleware refreshes the token on every request cycle';
+        expect(echoRatio(output, context)).toBeGreaterThan(0.9);
+    });
+    it('~0 when the output is entirely novel', () => {
+        const context = 'the authentication middleware refreshes the token';
+        const output = 'completely different sentence about unrelated banana harvest logistics today';
+        expect(echoRatio(output, context)).toBeLessThan(0.1);
+    });
+    it('is 0 for empty output', () => {
+        expect(echoRatio('', 'some context here at all')).toBe(0);
+    });
+    it('is between 0 and 1 for partial restating', () => {
+        const context = 'shared preamble tokens appear here in the context block';
+        const output = 'shared preamble tokens appear here plus a brand new original tail clause';
+        const r = echoRatio(output, context);
+        expect(r).toBeGreaterThan(0);
+        expect(r).toBeLessThan(1);
+    });
+    it('is deterministic', () => {
+        expect(echoRatio('a b c d e', 'a b c d e f')).toBe(echoRatio('a b c d e', 'a b c d e f'));
+    });
+});
+describe('extractAssistantTextFromSse', () => {
+    it('concatenates text_delta events, unescaping', () => {
+        const sse = [
+            'event: content_block_delta',
+            'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello "}}',
+            'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"world\\n"}}',
+        ].join('\n');
+        expect(extractAssistantTextFromSse(sse)).toBe('Hello world\n');
+    });
+    it('returns empty string when there are no text deltas', () => {
+        expect(extractAssistantTextFromSse('data: {"type":"message_start"}')).toBe('');
+    });
+});

package/dist/__tests__/relevance.test.d.ts

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

package/dist/__tests__/relevance.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { tokenize, bm25Scores, rankByRelevance } from '../relevance.js';
+describe('tokenize', () => {
+    it('lowercases and splits on non-alphanumerics', () => {
+        expect(tokenize('Foo.Bar(baz)')).toEqual(['foo', 'bar', 'baz']);
+    });
+    it('drops 1-char noise tokens but keeps numbers/identifiers', () => {
+        expect(tokenize('a in the db_pool 42')).toEqual(['in', 'the', 'db_pool', '42']);
+    });
+    it('returns [] for empty/symbol-only input', () => {
+        expect(tokenize('   %%$$  ')).toEqual([]);
+    });
+});
+describe('bm25Scores', () => {
+    it('scores a matching doc above a non-matching one', () => {
+        const docs = ['the database connection failed', 'the cat sat on the mat'];
+        const s = bm25Scores('database connection', docs);
+        expect(s[0]).toBeGreaterThan(s[1]);
+    });
+    it('weights a RARE query term more than a common one (idf)', () => {
+        // "apple" appears in 1 doc (rare), "banana" in 3 (common). A doc matching the
+        // rare term should outscore a doc matching only the common one.
+        const docs = ['apple', 'banana', 'banana', 'banana'];
+        const s = bm25Scores('apple banana', docs);
+        expect(s[0]).toBeGreaterThan(s[1]);
+    });
+    it('returns all-zero scores when the query has no usable terms', () => {
+        const docs = ['anything here', 'and here'];
+        expect(bm25Scores('', docs)).toEqual([0, 0]);
+        expect(bm25Scores('%%%', docs)).toEqual([0, 0]);
+    });
+    it('gives a non-matching doc a score of 0', () => {
+        const docs = ['relevant match here', 'totally unrelated'];
+        const s = bm25Scores('relevant', docs);
+        expect(s[1]).toBe(0);
+        expect(s[0]).toBeGreaterThan(0);
+    });
+    it('does not let a long repetitive doc dominate unboundedly (length normalization)', () => {
+        const short = 'error';
+        const long = ('error ' + 'filler '.repeat(200)).trim();
+        const s = bm25Scores('error', [short, long]);
+        // the concise doc that is mostly the query term should score at least as high
+        expect(s[0]).toBeGreaterThanOrEqual(s[1]);
+    });
+    it('is deterministic', () => {
+        const docs = ['alpha beta', 'beta gamma', 'gamma delta'];
+        expect(bm25Scores('beta gamma', docs)).toEqual(bm25Scores('beta gamma', docs));
+    });
+    it('produces one score per doc', () => {
+        const docs = ['a b c', 'd e f', 'g h i'];
+        expect(bm25Scores('a', docs).length).toBe(3);
+    });
+});
+describe('rankByRelevance', () => {
+    it('returns document indices sorted by descending relevance', () => {
+        const docs = ['no match', 'strong error error match', 'weak error'];
+        const order = rankByRelevance('error', docs);
+        expect(order[0]).toBe(1); // most "error" hits
+        expect(order[order.length - 1]).toBe(0); // no match last
+    });
+    it('is a stable permutation of all indices', () => {
+        const docs = ['a', 'b', 'c', 'd'];
+        const order = rankByRelevance('a b', docs);
+        expect([...order].sort((x, y) => x - y)).toEqual([0, 1, 2, 3]);
+    });
+});

package/dist/__tests__/secureKeyFile.test.d.ts

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

package/dist/__tests__/secureKeyFile.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { secureKeyFile } from '../codexMitm.js';
+// Security regression: the CA private key must be locked to the current user.
+// 0o600 is a no-op on Windows, so secureKeyFile applies a per-OS restriction
+// (icacls on Windows, chmod on POSIX). It must never throw — a key we cannot
+// secure is warned about, not fatal — and must leave the file readable by us.
+describe('secureKeyFile', () => {
+    it('secures a key file without throwing and keeps it owner-readable', () => {
+        const dir = mkdtempSync(join(tmpdir(), 'squeezr-key-'));
+        const keyPath = join(dir, 'ca.key');
+        writeFileSync(keyPath, 'PRIVATE-KEY-MATERIAL', { mode: 0o600 });
+        try {
+            expect(() => secureKeyFile(keyPath)).not.toThrow();
+            expect(readFileSync(keyPath, 'utf-8')).toBe('PRIVATE-KEY-MATERIAL');
+            if (process.platform !== 'win32') {
+                // On POSIX the mode must be owner-only (no group/other bits).
+                expect(statSync(keyPath).mode & 0o077).toBe(0);
+            }
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/__tests__/serverBinding.test.d.ts

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

package/dist/__tests__/serverBinding.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+// Security regression: the main proxy holds the user's API keys and exposes
+// state-changing control endpoints, so it MUST bind to loopback only and never
+// be reachable from the LAN. This guards against silently reverting that fix.
+describe('main proxy loopback binding', () => {
+    const src = readFileSync(fileURLToPath(new URL('../index.ts', import.meta.url)), 'utf-8');
+    it('binds httpServer.listen to 127.0.0.1', () => {
+        expect(src).toMatch(/httpServer\.listen\(\s*PORT\s*,\s*['"]127\.0\.0\.1['"]/);
+    });
+    it('never binds the main proxy to all interfaces', () => {
+        expect(src).not.toMatch(/httpServer\.listen\(\s*PORT\s*,\s*['"]0\.0\.0\.0['"]/);
+        expect(src).not.toMatch(/httpServer\.listen\(\s*PORT\s*,\s*['"]::['"]/);
+        // A two-arg listen(PORT, cb) would bind all interfaces by default — forbid it.
+        expect(src).not.toMatch(/httpServer\.listen\(\s*PORT\s*,\s*\(/);
+    });
+});

package/dist/__tests__/statsOutput.test.d.ts

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

package/dist/__tests__/statsOutput.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { Stats } from '../stats.js';
+// recordEcho / recordShaping only mutate in-memory counters (persistence happens on the
+// main record() path), so these tests never touch ~/.squeezr. We assert relative deltas
+// so a pre-existing stats.json baseline doesn't matter.
+describe('Stats output metrics', () => {
+    it('recordEcho updates sample count and average echo', () => {
+        const s = new Stats();
+        const before = s.summary().output;
+        s.recordEcho(0.2);
+        s.recordEcho(0.4);
+        const after = s.summary().output;
+        expect(after.echo_samples).toBe(before.echo_samples + 2);
+        expect(after.avg_echo_pct).toBeGreaterThanOrEqual(0);
+        expect(after.avg_echo_pct).toBeLessThanOrEqual(100);
+    });
+    it('recordShaping counts only the true flags', () => {
+        const s = new Stats();
+        const before = s.summary().output;
+        s.recordShaping(true, false); // steered only
+        s.recordShaping(true, true); // steered + effort
+        s.recordShaping(false, false); // neither
+        const after = s.summary().output;
+        expect(after.steered).toBe(before.steered + 2);
+        expect(after.effort_lowered).toBe(before.effort_lowered + 1);
+    });
+    it('avg echo reflects the mean of the samples added', () => {
+        const s = new Stats();
+        // add a large batch so any baseline is diluted toward our known mean
+        for (let i = 0; i < 200; i++)
+            s.recordEcho(0.3);
+        expect(Math.abs(s.summary().output.avg_echo_pct - 30)).toBeLessThan(10);
+    });
+    it('recordBypassed counts separately and never touches processed/saved totals', () => {
+        const s = new Stats();
+        const before = s.summary();
+        s.recordBypassed();
+        s.recordBypassed();
+        const after = s.summary();
+        expect(after.bypassed_requests).toBe(before.bypassed_requests + 2);
+        // bypassed traffic must NOT inflate processed or saved
+        expect(after.total_original_chars).toBe(before.total_original_chars);
+        expect(after.total_saved_chars).toBe(before.total_saved_chars);
+        expect(after.requests).toBe(before.requests);
+    });
+});

package/dist/__tests__/textCrusher.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { crushText, normalizeLineKey } from '../textCrusher.js';
+import { crushText, normalizeLineKey, wordShingles, jaccard } from '../textCrusher.js';
 describe('normalizeLineKey', () => {
     it('collapses numbers, hex and timestamps so near-duplicates share a key', () => {
         const a = normalizeLineKey('2026-07-21T10:00:01Z downloaded chunk 12 (0x1a2b)');
@@ -68,4 +68,66 @@ describe('crushText', () => {
         const res = crushText(repetitiveLog(300));
         expect(/\[\d+ lines omitted/.test(res.text)).toBe(true);
     });
+    it('with a query, keeps task-relevant lines that a blind pass would drop', () => {
+        // 120 noise lines + one line mentioning the task keyword, positioned in the middle
+        // (not an anchor) so only relevance can save it.
+        const lines = [];
+        for (let i = 0; i < 60; i++)
+            lines.push(`background chore ${i} finished`);
+        lines.push('updated the authentication middleware token refresh logic');
+        for (let i = 0; i < 60; i++)
+            lines.push(`background chore ${i + 60} finished`);
+        const input = lines.join('\n');
+        const withQuery = crushText(input, { maxLines: 20, headKeep: 3, tailKeep: 3, query: 'authentication middleware token' });
+        expect(withQuery.text.includes('authentication middleware token refresh')).toBe(true);
+    });
+    it('stays deterministic for a fixed query', () => {
+        const input = repetitiveLog(300);
+        const a = crushText(input, { query: 'record ms' }).text;
+        const b = crushText(input, { query: 'record ms' }).text;
+        expect(a).toBe(b);
+    });
+    it('collapses REWORDED near-duplicate lines (not just number-varied)', () => {
+        // Two wordings of the same idea, no numbers, no signal keywords → exact-key dedup
+        // would keep both; shingle near-dup should collapse them.
+        const a = 'the worker finished processing the batch quickly and moved on';
+        const b = 'the worker completed processing the batch quickly and moved on';
+        // Unique anchor lines at head/tail (no "worker") so the variants live in the MIDDLE,
+        // where the budget-fill + shingle collapse applies.
+        const lines = ['ALPHA HEADER ONE', 'ALPHA HEADER TWO', 'ALPHA HEADER THREE'];
+        for (let i = 0; i < 100; i++)
+            lines.push(i % 2 === 0 ? a : b);
+        lines.push('OMEGA FOOTER ONE', 'OMEGA FOOTER TWO', 'OMEGA FOOTER THREE');
+        const res = crushText(lines.join('\n'), { maxLines: 30, headKeep: 3, tailKeep: 3 });
+        const distinct = new Set(res.text.split('\n').filter(l => l.includes('worker')));
+        // both wordings collapse to (at most) one representative
+        expect(distinct.size).toBeLessThanOrEqual(1);
+    });
+    it('does NOT collapse genuinely different lines', () => {
+        const lines = ['UNIQUE HEADER'];
+        for (let i = 0; i < 30; i++) {
+            lines.push('alpha subsystem initialised the primary cache layer');
+            lines.push('gamma module rejected the inbound websocket handshake');
+        }
+        lines.push('UNIQUE FOOTER');
+        const res = crushText(lines.join('\n'), { maxLines: 40, headKeep: 2, tailKeep: 2 });
+        expect(res.text.includes('alpha subsystem')).toBe(true);
+        expect(res.text.includes('gamma module')).toBe(true);
+    });
+});
+describe('wordShingles / jaccard', () => {
+    it('reworded lines share most shingles (high jaccard)', () => {
+        const a = wordShingles('the worker finished processing the batch quickly');
+        const b = wordShingles('the worker completed processing the batch quickly');
+        expect(jaccard(a, b)).toBeGreaterThan(0.4);
+    });
+    it('unrelated lines share few shingles (low jaccard)', () => {
+        const a = wordShingles('database connection pool exhausted');
+        const b = wordShingles('the cat sat on the warm mat');
+        expect(jaccard(a, b)).toBeLessThan(0.1);
+    });
+    it('identical lines have jaccard 1', () => {
+        const a = wordShingles('exactly the same words here now');
+        expect(jaccard(a, a)).toBe(1);
+    });
 });

package/dist/codexMitm.d.ts

@@ -1,4 +1,5 @@
 export declare const BUNDLE_PATH: string;
 export declare const MITM_PORT: number;
+export declare function secureKeyFile(path: string): void;
 export declare function startMitmProxy(): void;
 export declare function stopMitmProxy(): void;

package/dist/codexMitm.js

@@ -4,7 +4,8 @@ import http from 'node:http';
 import https from 'node:https';
 import fs from 'node:fs';
 import crypto from 'node:crypto';
-import { homedir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { homedir, userInfo } from 'node:os';
 import { join } from 'node:path';
 import forge from 'node-forge';
 import { config } from './config.js';
@@ -15,6 +16,26 @@ const CA_CERT_PATH = join(CA_DIR, 'ca.crt');
 export const BUNDLE_PATH = join(CA_DIR, 'bundle.crt');
 export const MITM_PORT = config.mitmPort;
 // ── CA generation ─────────────────────────────────────────────────────────────
+// POSIX permission bits (0o600) are ignored on Windows, so the CA private key
+// would be left readable by other accounts. Lock it down per-OS: an ACL that
+// grants only the current user on Windows, chmod 0o600 on POSIX. A private key
+// we cannot secure is a real risk, so failure is surfaced loudly, never silent.
+export function secureKeyFile(path) {
+    if (process.platform === 'win32') {
+        const user = process.env.USERNAME || userInfo().username;
+        try {
+            // /inheritance:r drops inherited ACEs; /grant:r sets the current user as
+            // the only principal with Full control.
+            execFileSync('icacls', [path, '/inheritance:r', '/grant:r', `${user}:F`], { stdio: 'ignore' });
+        }
+        catch (err) {
+            console.warn(`[squeezr/mitm] WARNING: could not restrict permissions on ${path} — ` +
+                `${err.message}. Secure this private key manually.`);
+        }
+        return;
+    }
+    fs.chmodSync(path, 0o600);
+}
 function ensureCA() {
     const certsExist = fs.existsSync(CA_KEY_PATH) && fs.existsSync(CA_CERT_PATH);
     if (!certsExist) {
@@ -35,6 +56,7 @@ function ensureCA() {
         ]);
         cert.sign(keys.privateKey, forge.md.sha256.create());
         fs.writeFileSync(CA_KEY_PATH, forge.pki.privateKeyToPem(keys.privateKey), { mode: 0o600 });
+        secureKeyFile(CA_KEY_PATH);
         fs.writeFileSync(CA_CERT_PATH, forge.pki.certificateToPem(cert), { mode: 0o644 });
         console.log(`[squeezr/mitm] CA generated → ${CA_CERT_PATH}`);
     }
@@ -438,7 +460,9 @@ export function startMitmProxy() {
         if (err.code !== 'EADDRINUSE')
             console.error('[squeezr/mitm] error:', err.message);
     });
-    mitmServer.listen(MITM_PORT, () => {
+    // Loopback only: the MITM proxy terminates TLS for the user's traffic and must
+    // never be reachable from the LAN (matches the other listeners).
+    mitmServer.listen(MITM_PORT, '127.0.0.1', () => {
         console.log(`[squeezr/mitm] HTTPS proxy on http://localhost:${MITM_PORT}`);
     });
 }