squeezr-ai 1.17.12 → 1.18.0

package/dist/codexMitm.js

@@ -16,33 +16,35 @@ export const BUNDLE_PATH = join(CA_DIR, 'bundle.crt');
 export const MITM_PORT = config.mitmPort;
 // ── CA generation ─────────────────────────────────────────────────────────────
 function ensureCA() {
-    if (fs.existsSync(CA_KEY_PATH) && fs.existsSync(CA_CERT_PATH))
-        return;
-    fs.mkdirSync(CA_DIR, { recursive: true, mode: 0o700 });
-    const keys = forge.pki.rsa.generateKeyPair(2048);
-    const cert = forge.pki.createCertificate();
-    cert.publicKey = keys.publicKey;
-    cert.serialNumber = '01';
-    cert.validity.notBefore = new Date();
-    cert.validity.notAfter = new Date();
-    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 10);
-    const attrs = [{ name: 'commonName', value: 'Squeezr-MITM-CA' }];
-    cert.setSubject(attrs);
-    cert.setIssuer(attrs);
-    cert.setExtensions([
-        { name: 'basicConstraints', cA: true },
-        { name: 'keyUsage', keyCertSign: true, cRLSign: true },
-    ]);
-    cert.sign(keys.privateKey, forge.md.sha256.create());
-    fs.writeFileSync(CA_KEY_PATH, forge.pki.privateKeyToPem(keys.privateKey), { mode: 0o600 });
-    fs.writeFileSync(CA_CERT_PATH, forge.pki.certificateToPem(cert), { mode: 0o644 });
-    const systemCAs = [
-        '/etc/ssl/certs/ca-certificates.crt',
-        '/etc/ssl/cert.pem',
-    ].find(p => fs.existsSync(p));
-    const bundle = forge.pki.certificateToPem(cert) + (systemCAs ? fs.readFileSync(systemCAs, 'utf-8') : '');
-    fs.writeFileSync(BUNDLE_PATH, bundle, { mode: 0o644 });
-    console.log(`[squeezr/mitm] CA generated → ${CA_CERT_PATH}`);
+    const certsExist = fs.existsSync(CA_KEY_PATH) && fs.existsSync(CA_CERT_PATH);
+    if (!certsExist) {
+        fs.mkdirSync(CA_DIR, { recursive: true, mode: 0o700 });
+        const keys = forge.pki.rsa.generateKeyPair(2048);
+        const cert = forge.pki.createCertificate();
+        cert.publicKey = keys.publicKey;
+        cert.serialNumber = '01';
+        cert.validity.notBefore = new Date();
+        cert.validity.notAfter = new Date();
+        cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 10);
+        const attrs = [{ name: 'commonName', value: 'Squeezr-MITM-CA' }];
+        cert.setSubject(attrs);
+        cert.setIssuer(attrs);
+        cert.setExtensions([
+            { name: 'basicConstraints', cA: true },
+            { name: 'keyUsage', keyCertSign: true, cRLSign: true },
+        ]);
+        cert.sign(keys.privateKey, forge.md.sha256.create());
+        fs.writeFileSync(CA_KEY_PATH, forge.pki.privateKeyToPem(keys.privateKey), { mode: 0o600 });
+        fs.writeFileSync(CA_CERT_PATH, forge.pki.certificateToPem(cert), { mode: 0o644 });
+        console.log(`[squeezr/mitm] CA generated → ${CA_CERT_PATH}`);
+    }
+    // Always regenerate bundle.crt from the CA cert only.
+    // Avoid concatenating system CA bundles — they can contain certs that
+    // BoringSSL/Node.js rejects (e.g. on WSL), causing NODE_EXTRA_CA_CERTS to fail.
+    // Node.js already trusts its own built-in root CAs, so only the squeezr CA
+    // cert is needed here.
+    const caCertPem = fs.readFileSync(CA_CERT_PATH, 'utf-8');
+    fs.writeFileSync(BUNDLE_PATH, caCertPem, { mode: 0o644 });
 }
 // ── Per-host cert (cached) ────────────────────────────────────────────────────
 const certCache = new Map();

package/dist/compressor.d.ts

@@ -11,6 +11,10 @@ export interface Savings {
     }>;
     dryRun: boolean;
     sessionCacheHits: number;
+    detSavedChars?: number;
+    dedupSavedChars?: number;
+    aiSavedChars?: number;
+    overheadChars?: number;
 }
 export declare function getCache(config: Config): CompressionCache;
 interface AnthropicMessage {

package/dist/compressor.js

@@ -92,9 +92,11 @@ function buildAndCache(original, result) {
     const ratio = Math.round((1 - result.length / Math.max(original.length, 1)) * 100);
     const id = storeOriginal(original);
     const fullString = `[squeezr:${id} -${ratio}%] ${result}`;
-    const savedChars = original.length - result.length;
+    const overheadChars = fullString.length - result.length; // tag overhead
+    // Real savings: original minus what's actually sent (fullString, including tag)
+    const savedChars = original.length - fullString.length;
     setBlock(hashText(original), { fullString, savedChars, originalChars: original.length });
-    return { fullString, savedChars };
+    return { fullString, savedChars, overheadChars };
 }
 function extractAnthropicToolResults(messages, toolIdMap) {
     const results = [];
@@ -152,10 +154,10 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     // keep the most recent occurrence at full fidelity and replace earlier ones
     // with a short reference (saves tokens, model still has access via expand).
     const dedupedSet = new Set(); // "index:subIndex" keys — skip in later steps
+    let readDedupSaved = 0;
     {
         const readHashToId = new Map(); // hash → expand id of most recent
         const seenMostRecent = new Set();
-        let readDedupSaved = 0;
         let readDedupCount = 0;
         // Scan newest → oldest: first encounter of each hash = most recent
         for (let i = allResults.length - 1; i >= 0; i--) {
@@ -203,11 +205,11 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)));
     const toProcess = candidates.filter(c => c.text.length >= threshold && !dedupedSet.has(`${c.index}:${c.subIndex}`));
     if (toProcess.length === 0)
-        return [msgs, emptySavings()];
+        return [msgs, emptySavings(false, detSaved, readDedupSaved)];
     if (config.dryRun) {
         const potential = toProcess.reduce((sum, c) => sum + c.text.length, 0);
         console.log(`[squeezr dry-run] Would AI-compress ${toProcess.length} block(s) | potential -${potential.toLocaleString()} chars | pressure=${Math.round(pressure * 100)}%`);
-        return [msgs, emptySavings(true)];
+        return [msgs, emptySavings(true, detSaved, readDedupSaved)];
     }
     // Differential: split session cache hits from uncached
     const sessionHits = [];
@@ -229,19 +231,24 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
         : [];
     let totalOriginal = 0;
     let totalCompressed = 0;
+    let totalOverhead = 0;
+    let totalAiSaved = 0;
     const byTool = [];
     for (const { index, subIndex, tool, block } of sessionHits) {
         ;
         msgs[index].content[subIndex].content = block.fullString;
         totalOriginal += block.originalChars;
         totalCompressed += block.originalChars - block.savedChars;
+        totalAiSaved += block.savedChars;
         byTool.push({ tool, savedChars: block.savedChars, originalChars: block.originalChars });
     }
     for (const { index, subIndex, original, result, tool } of freshlyCompressed) {
-        const { fullString, savedChars } = buildAndCache(original, result);
+        const { fullString, savedChars, overheadChars } = buildAndCache(original, result);
         msgs[index].content[subIndex].content = fullString;
         totalOriginal += original.length;
         totalCompressed += original.length - savedChars;
+        totalOverhead += overheadChars;
+        totalAiSaved += savedChars;
         byTool.push({ tool, savedChars, originalChars: original.length });
     }
     if (pressure >= 0.5)
@@ -255,6 +262,10 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
             byTool,
             dryRun: false,
             sessionCacheHits: sessionHits.length,
+            detSavedChars: detSaved,
+            dedupSavedChars: readDedupSaved,
+            aiSavedChars: totalAiSaved,
+            overheadChars: totalOverhead,
         }];
 }
 function extractOpenAIToolResults(messages) {
@@ -293,10 +304,11 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     const msgs = structuredClone(messages);
     // Step 0: Cross-turn Read dedup
     const dedupedIndices = new Set();
+    let readDedupSaved = 0;
     {
         const readHashToId = new Map();
         const seenMostRecent = new Set();
-        let readDedupSaved = 0, readDedupCount = 0;
+        let readDedupCount = 0;
         for (let i = allResults.length - 1; i >= 0; i--) {
             const { index, text, tool } = allResults[i];
             if (tool.toLowerCase() !== 'read')
@@ -337,11 +349,11 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)));
     const toProcess = candidates.filter(c => c.text.length >= threshold && !dedupedIndices.has(c.index));
     if (toProcess.length === 0)
-        return [msgs, emptySavings()];
+        return [msgs, emptySavings(false, detSaved, readDedupSaved)];
     if (config.dryRun) {
         const tag = isLocal ? 'ollama' : 'codex';
         console.log(`[squeezr dry-run/${tag}] Would AI-compress ${toProcess.length} block(s) | potential -${toProcess.reduce((s, c) => s + c.text.length, 0).toLocaleString()} chars`);
-        return [msgs, emptySavings(true)];
+        return [msgs, emptySavings(true, detSaved, readDedupSaved)];
     }
     const sessionHits = [];
     const toCompress = [];
@@ -354,7 +366,6 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
             sessionHits.push({ index: c.index, tool: c.tool, block: cached });
         }
         else if (aiEnabled() && c.index > newStartIdx && !config.aiSkipTools.has(c.tool.toLowerCase())) {
-            // Only AI-compress new tool results (after last assistant turn) — prevents burst on first activation.
             toCompress.push(c);
         }
     }
@@ -364,19 +375,22 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     const freshlyCompressed = toCompress.length > 0
         ? await runCompression(toCompress, compressFn, config)
         : [];
-    let totalOriginal = 0, totalCompressed = 0;
+    let totalOriginal = 0, totalCompressed = 0, totalOverhead = 0, totalAiSaved = 0;
     const byTool = [];
     for (const { index, tool, block } of sessionHits) {
         msgs[index].content = block.fullString;
         totalOriginal += block.originalChars;
         totalCompressed += block.originalChars - block.savedChars;
+        totalAiSaved += block.savedChars;
         byTool.push({ tool, savedChars: block.savedChars, originalChars: block.originalChars });
     }
     for (const { index, original, result, tool } of freshlyCompressed) {
-        const { fullString, savedChars } = buildAndCache(original, result);
+        const { fullString, savedChars, overheadChars } = buildAndCache(original, result);
         msgs[index].content = fullString;
         totalOriginal += original.length;
         totalCompressed += original.length - savedChars;
+        totalOverhead += overheadChars;
+        totalAiSaved += savedChars;
         byTool.push({ tool, savedChars, originalChars: original.length });
     }
     if (pressure >= 0.5) {
@@ -385,7 +399,7 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     }
     if (sessionHits.length > 0)
         console.log(`[squeezr] Session cache: ${sessionHits.length} block(s) reused`);
-    return [msgs, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length }];
+    return [msgs, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length, detSavedChars: detSaved, dedupSavedChars: readDedupSaved, aiSavedChars: totalAiSaved, overheadChars: totalOverhead }];
 }
 export async function compressGeminiContents(contents, apiKey, config) {
     if (config.disabled)
@@ -415,10 +429,11 @@ export async function compressGeminiContents(contents, apiKey, config) {
     const cts = structuredClone(contents);
     // Step 0: Cross-turn Read dedup
     const geminiDedupedSet = new Set();
+    let geminiReadDedupSaved = 0;
     {
         const readHashToId = new Map();
         const seenMostRecent = new Set();
-        let readDedupSaved = 0, readDedupCount = 0;
+        let readDedupCount = 0;
         for (let i = allResults.length - 1; i >= 0; i--) {
             const { index, subIndex, text, tool } = allResults[i];
             if (tool.toLowerCase() !== 'read')
@@ -432,11 +447,11 @@ export async function compressGeminiContents(contents, apiKey, config) {
                 cts[index].parts[subIndex].functionResponse.response = { output: `[same file content as a later read — squeezr_expand(${readHashToId.get(hash)}) to retrieve]` };
                 geminiDedupedSet.add(`${index}:${subIndex}`);
                 readDedupCount++;
-                readDedupSaved += text.length;
+                geminiReadDedupSaved += text.length;
             }
         }
-        if (readDedupSaved > 0) {
-            console.log(`[squeezr/read-dedup/gemini] ${readDedupCount} duplicate file read(s) collapsed: -${readDedupSaved.toLocaleString()} chars`);
+        if (geminiReadDedupSaved > 0) {
+            console.log(`[squeezr/read-dedup/gemini] ${readDedupCount} duplicate file read(s) collapsed: -${geminiReadDedupSaved.toLocaleString()} chars`);
             hitPattern('readDedup', readDedupCount);
         }
     }
@@ -457,10 +472,10 @@ export async function compressGeminiContents(contents, apiKey, config) {
     const candidates = allResults.slice(0, Math.max(0, allResults.length - effectiveKeepRecent(config)))
         .filter(c => c.text.length >= threshold && !geminiDedupedSet.has(`${c.index}:${c.subIndex}`));
     if (candidates.length === 0)
-        return [cts, emptySavings()];
+        return [cts, emptySavings(false, detSaved, geminiReadDedupSaved)];
     if (config.dryRun) {
         console.log(`[squeezr dry-run/gemini] Would AI-compress ${candidates.length} block(s) | potential -${candidates.reduce((s, c) => s + c.text.length, 0).toLocaleString()} chars`);
-        return [cts, emptySavings(true)];
+        return [cts, emptySavings(true, detSaved, geminiReadDedupSaved)];
     }
     const sessionHits = [];
     const toCompress = [];
@@ -474,25 +489,28 @@ export async function compressGeminiContents(contents, apiKey, config) {
     const freshlyCompressed = toCompress.length > 0
         ? await runCompression(toCompress, t => compressWithGeminiFlash(t, apiKey), config)
         : [];
-    let totalOriginal = 0, totalCompressed = 0;
+    let totalOriginal = 0, totalCompressed = 0, totalOverhead = 0, totalAiSaved = 0;
     const byTool = [];
     for (const { index, subIndex, tool, block } of sessionHits) {
         cts[index].parts[subIndex].functionResponse.response = { output: block.fullString };
         totalOriginal += block.originalChars;
         totalCompressed += block.originalChars - block.savedChars;
+        totalAiSaved += block.savedChars;
         byTool.push({ tool, savedChars: block.savedChars, originalChars: block.originalChars });
     }
     for (const { index, subIndex, original, result, tool } of freshlyCompressed) {
-        const { fullString, savedChars } = buildAndCache(original, result);
+        const { fullString, savedChars, overheadChars } = buildAndCache(original, result);
         cts[index].parts[subIndex].functionResponse.response = { output: fullString };
         totalOriginal += original.length;
         totalCompressed += original.length - savedChars;
+        totalOverhead += overheadChars;
+        totalAiSaved += savedChars;
         byTool.push({ tool, savedChars, originalChars: original.length });
     }
     if (sessionHits.length > 0)
         console.log(`[squeezr/gemini] Session cache: ${sessionHits.length} block(s) reused`);
-    return [cts, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length }];
+    return [cts, { compressed: freshlyCompressed.length, savedChars: totalOriginal - totalCompressed, originalChars: totalOriginal, byTool, dryRun: false, sessionCacheHits: sessionHits.length, detSavedChars: detSaved, dedupSavedChars: geminiReadDedupSaved, aiSavedChars: totalAiSaved, overheadChars: totalOverhead }];
 }
-function emptySavings(dryRun = false) {
-    return { compressed: 0, savedChars: 0, originalChars: 0, byTool: [], dryRun, sessionCacheHits: 0 };
+function emptySavings(dryRun = false, detSavedChars = 0, dedupSavedChars = 0) {
+    return { compressed: 0, savedChars: 0, originalChars: 0, byTool: [], dryRun, sessionCacheHits: 0, detSavedChars, dedupSavedChars, aiSavedChars: 0, overheadChars: 0 };
 }