squeezr-ai 1.17.0 → 1.17.4

package/README.md

@@ -2,7 +2,7 @@
 
 **Token compression proxy for AI coding CLIs.** Sits between your CLI and the API, compresses context on the fly, saves thousands of tokens per session.
 
-[![npm](https://img.shields.io/npm/v/squeezr-ai)](https://www.npmjs.com/package/squeezr-ai) [![license](https://img.shields.io/npm/l/squeezr-ai)](LICENSE) [![tests](https://img.shields.io/badge/tests-219%20passing-brightgreen)]()
+[![npm](https://img.shields.io/npm/v/squeezr-ai)](https://www.npmjs.com/package/squeezr-ai) [![license](https://img.shields.io/npm/l/squeezr-ai)](LICENSE) [![tests](https://img.shields.io/badge/tests-237%20passing-brightgreen)]()
 
 ## Supported CLIs
 
@@ -14,6 +14,8 @@
 | Gemini CLI | HTTP to Gemini API | `GEMINI_API_BASE_URL=http://localhost:8080` |
 | Ollama | HTTP (local) | Transparent via dummy API key detection |
 | **Codex** | **WebSocket to chatgpt.com** | **TLS-terminating MITM proxy on :8081** |
+| **Cursor IDE** | **ConnectRPC/HTTP2 to api2.cursor.sh** | **`squeezr cursor` — MITM proxy on :8082** |
+| Continue (VS Code) | HTTP to OpenAI-compat | `apiBase: http://localhost:8080/v1` |
 
 ## Quick start
 
@@ -109,8 +111,9 @@ threshold = 800          # min chars to trigger compression
 keep_recent = 3          # last N results left uncompressed
 compress_system_prompt = true
 compress_conversation = false  # aggressive: compress assistant messages too
-# skip_tools = ["Read"]       # never compress these tools
+# skip_tools = ["Read"]       # skip ALL compression for these tools (deterministic + AI)
 # only_tools = ["Bash"]       # only compress these tools
+ai_skip_tools = ["Read"]      # skip AI compression only (default); deterministic still runs
 
 [cache]
 enabled = true

package/bin/squeezr.js

@@ -100,7 +100,6 @@ function installShellWrapper() {
 
 function installBashWrapper() {
   const port = getPort()
-  const mitmPort = getMitmPort(port)
   const bundlePath = path.join(os.homedir(), '.squeezr', 'mitm-ca', 'bundle.crt')
   const marker = '# squeezr shell wrapper'
   const endMarker = '# end squeezr shell wrapper'
@@ -111,11 +110,7 @@ squeezr() {
     start|setup|update)
       export ANTHROPIC_BASE_URL=http://localhost:${port}
       export GEMINI_API_BASE_URL=http://localhost:${port}
-      export HTTPS_PROXY=http://localhost:${mitmPort}
-      export SSL_CERT_FILE=${bundlePath}
-      ;;
-    stop)
-      unset HTTPS_PROXY
+      export NODE_EXTRA_CA_CERTS=${bundlePath}
       ;;
   esac
 }
@@ -205,6 +200,7 @@ Usage:
   squeezr status           Check if proxy is running
   squeezr config           Print config file path and current settings
   squeezr ports            Change HTTP and MITM proxy ports
+  squeezr tunnel           Expose proxy via Cloudflare Tunnel for Cursor IDE
   squeezr update           Kill old processes, install latest from npm, restart
   squeezr uninstall        Remove Squeezr completely (env vars, CA, auto-start, logs)
   squeezr version          Print version
@@ -469,7 +465,6 @@ async function configurePorts() {
       `export SQUEEZR_MITM_PORT=${finalMitm}`,
       `export ANTHROPIC_BASE_URL=http://localhost:${finalPort}`,
       `export GEMINI_API_BASE_URL=http://localhost:${finalPort}`,
-      `export HTTPS_PROXY=http://localhost:${finalMitm}`,
     ].join('\n')
     for (const p of profiles) {
       try {
@@ -494,7 +489,6 @@ async function configurePorts() {
         try { execSync(`"${setx}" SQUEEZR_MITM_PORT "${finalMitm}"`, { stdio: 'pipe' }) } catch {}
         try { execSync(`"${setx}" ANTHROPIC_BASE_URL "http://localhost:${finalPort}"`, { stdio: 'pipe' }) } catch {}
         try { execSync(`"${setx}" GEMINI_API_BASE_URL "http://localhost:${finalPort}"`, { stdio: 'pipe' }) } catch {}
-        try { execSync(`"${setx}" HTTPS_PROXY "http://localhost:${finalMitm}"`, { stdio: 'pipe' }) } catch {}
       }
     } catch {}
   }
@@ -503,7 +497,6 @@ async function configurePorts() {
   process.env.SQUEEZR_PORT = String(finalPort)
   process.env.SQUEEZR_MITM_PORT = String(finalMitm)
   process.env.ANTHROPIC_BASE_URL = `http://localhost:${finalPort}`
-  process.env.HTTPS_PROXY = `http://localhost:${finalMitm}`
 
   // Auto stop + start
   console.log('')
@@ -822,9 +815,10 @@ function setupUnix() {
     `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
     `export openai_base_url=http://localhost:${port}`,
     `export GEMINI_API_BASE_URL=http://localhost:${port}`,
-    `# squeezr MITM proxy for Codex (TLS interception)`,
-    `export HTTPS_PROXY=http://localhost:${mitmPort}`,
-    `export SSL_CERT_FILE=${bundlePath}`,
+    `export NODE_EXTRA_CA_CERTS=${bundlePath}`,
+    `# NOTE: HTTPS_PROXY is intentionally NOT set globally — it would route ALL HTTPS`,
+    `# (including Claude Code) through the MITM proxy and cause 502 errors.`,
+    `# For Codex, set it per-session only: HTTPS_PROXY=http://localhost:${mitmPort} codex`,
     `# squeezr auto-heal: start proxy if not running`,
     `if ! curl -sf http://localhost:${port}/squeezr/health >/dev/null 2>&1; then`,
     `  nohup ${nodeExe} ${distIndex} >> "${os.homedir()}/.squeezr/squeezr.log" 2>&1 &`,
@@ -840,8 +834,7 @@ function setupUnix() {
     `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
     `export openai_base_url=http://localhost:${port}`,
     `export GEMINI_API_BASE_URL=http://localhost:${port}`,
-    `export HTTPS_PROXY=http://localhost:${mitmPort}`,
-    `export SSL_CERT_FILE=${bundlePath}`,
+    `export NODE_EXTRA_CA_CERTS=${bundlePath}`,
   ].join('\n')
 
   // Write env vars to ~/.profile (login shell — always loaded)
@@ -905,6 +898,28 @@ function setupUnix() {
       spawn(nodeExe, [squeezrBin], { detached: true, stdio: 'ignore' }).unref()
     }
 
+    // Trust MITM CA in macOS Keychain (for Codex TLS interception)
+    // CA is generated on first proxy start — wait briefly for it to appear
+    const caPath = path.join(os.homedir(), '.squeezr', 'mitm-ca', 'ca.crt')
+    const waitForCa = (retries = 10, interval = 500) => new Promise(resolve => {
+      const check = (n) => {
+        if (fs.existsSync(caPath)) return resolve(true)
+        if (n <= 0) return resolve(false)
+        setTimeout(() => check(n - 1), interval)
+      }
+      check(retries)
+    })
+    waitForCa().then(found => {
+      if (found) {
+        try {
+          execSync(`security add-trusted-cert -d -r trustRoot -k ~/Library/Keychains/login.keychain-db "${caPath}" 2>/dev/null`, { stdio: 'pipe' })
+          console.log(`  [ok] MITM CA trusted in macOS Keychain`)
+        } catch {
+          console.log(`  [info] To trust MITM CA for Codex: security add-trusted-cert -d -r trustRoot -k ~/Library/Keychains/login.keychain-db "${caPath}"`)
+        }
+      }
+    })
+
   // 2b. Linux — systemd
   } else {
     const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user')
@@ -978,8 +993,9 @@ function setupWSL() {
     `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
     `export openai_base_url=http://localhost:${port}`,
     `export GEMINI_API_BASE_URL=http://localhost:${port}`,
-    `export HTTPS_PROXY=http://localhost:${mitmPort}`,
-    `export SSL_CERT_FILE=${bundlePath}`,
+    `export NODE_EXTRA_CA_CERTS=${bundlePath}`,
+    `# NOTE: HTTPS_PROXY is intentionally NOT set globally — set per-session for Codex only:`,
+    `# HTTPS_PROXY=http://localhost:${mitmPort} codex`,
     `# squeezr auto-heal: start proxy if not running`,
     `if ! curl -sf http://localhost:${port}/squeezr/health >/dev/null 2>&1; then`,
     `  nohup ${nodeExe} ${distIndex} >> "${os.homedir()}/.squeezr/squeezr.log" 2>&1 &`,
@@ -994,8 +1010,7 @@ function setupWSL() {
     `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
     `export openai_base_url=http://localhost:${port}`,
     `export GEMINI_API_BASE_URL=http://localhost:${port}`,
-    `export HTTPS_PROXY=http://localhost:${mitmPort}`,
-    `export SSL_CERT_FILE=${bundlePath}`,
+    `export NODE_EXTRA_CA_CERTS=${bundlePath}`,
   ].join('\n')
 
   const profilePath = path.join(os.homedir(), '.profile')
@@ -1136,6 +1151,109 @@ Done!
   installShellWrapper()
 }
 
+// ── squeezr tunnel ────────────────────────────────────────────────────────────
+// Exposes the local proxy via a Cloudflare Quick Tunnel (free, no account needed).
+// Cursor IDE requires a public HTTPS URL because its servers call the endpoint
+// from Cloudflare's infrastructure — localhost is unreachable from there.
+
+async function startTunnel() {
+  const port = getPort()
+
+  // Verify proxy is running first
+  const running = await new Promise(resolve => {
+    const req = http.get(`http://localhost:${port}/squeezr/health`, res => {
+      resolve(res.statusCode === 200)
+    })
+    req.on('error', () => resolve(false))
+    req.setTimeout(2000, () => { req.destroy(); resolve(false) })
+  })
+
+  if (!running) {
+    console.error(`Squeezr proxy is not running on port ${port}.`)
+    console.error(`Start it first: squeezr start`)
+    process.exit(1)
+  }
+
+  console.log(`Starting Cloudflare Quick Tunnel for http://localhost:${port}...`)
+  console.log(`(free, no account needed — powered by trycloudflare.com)\n`)
+
+  // Try cloudflared binary, fall back to npx
+  let tunnelCmd, tunnelArgs
+  try {
+    execSync('cloudflared --version', { stdio: 'pipe' })
+    tunnelCmd = 'cloudflared'
+    tunnelArgs = ['tunnel', '--url', `http://localhost:${port}`]
+  } catch {
+    tunnelCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx'
+    tunnelArgs = ['cloudflared@latest', 'tunnel', '--url', `http://localhost:${port}`]
+    console.log(`cloudflared not installed — using npx cloudflared (may take a moment to download)\n`)
+  }
+
+  let tunnelUrl = null
+  const child = spawn(tunnelCmd, tunnelArgs, { stdio: ['ignore', 'pipe', 'pipe'] })
+
+  const printInstructions = (url) => {
+    console.log(`\n  ╔══════════════════════════════════════════════════════════════════╗`)
+    console.log(`  ║  Tunnel active:  ${url.padEnd(49)}║`)
+    console.log(`  ╠══════════════════════════════════════════════════════════════════╣`)
+    console.log(`  ║  CURSOR SETUP                                                    ║`)
+    console.log(`  ║                                                                  ║`)
+    console.log(`  ║  1. Cursor → Settings → Models                                   ║`)
+    console.log(`  ║  2. Add your OpenAI or Anthropic API key                         ║`)
+    console.log(`  ║  3. Enable "Override OpenAI Base URL"                            ║`)
+    console.log(`  ║  4. Set URL to: ${(url + '/v1').padEnd(49)}║`)
+    console.log(`  ║  5. Disable all built-in Cursor models                           ║`)
+    console.log(`  ║  6. Add a custom model pointing to the same URL                  ║`)
+    console.log(`  ║                                                                  ║`)
+    console.log(`  ║  CONTINUE EXTENSION (VS Code / JetBrains)                        ║`)
+    console.log(`  ║  No tunnel needed — use http://localhost:${port} directly         ${' '.repeat(Math.max(0, 17 - String(port).length))}║`)
+    console.log(`  ║                                                                  ║`)
+    console.log(`  ║  Press Ctrl+C to stop the tunnel                                 ║`)
+    console.log(`  ╚══════════════════════════════════════════════════════════════════╝\n`)
+  }
+
+  const parseUrl = (line) => {
+    const m = line.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/)
+    return m ? m[0] : null
+  }
+
+  child.stdout.on('data', (chunk) => {
+    const text = chunk.toString()
+    if (!tunnelUrl) {
+      const found = parseUrl(text)
+      if (found) { tunnelUrl = found; printInstructions(tunnelUrl) }
+    }
+    process.stdout.write(text)
+  })
+
+  child.stderr.on('data', (chunk) => {
+    const text = chunk.toString()
+    if (!tunnelUrl) {
+      const found = parseUrl(text)
+      if (found) { tunnelUrl = found; printInstructions(tunnelUrl) }
+    }
+    // Only show cloudflared logs if no URL yet (suppress verbose after)
+    if (!tunnelUrl) process.stderr.write(text)
+  })
+
+  child.on('error', (err) => {
+    if (err.code === 'ENOENT') {
+      console.error(`Could not start tunnel. Install cloudflared: https://developers.cloudflare.com/cloudflared/downloads`)
+    } else {
+      console.error(`Tunnel error: ${err.message}`)
+    }
+    process.exit(1)
+  })
+
+  child.on('exit', (code) => {
+    if (code !== 0) console.log(`\nTunnel stopped (exit ${code})`)
+    process.exit(0)
+  })
+
+  process.on('SIGINT', () => { child.kill(); process.exit(0) })
+  process.on('SIGTERM', () => { child.kill(); process.exit(0) })
+}
+
 // ── CLI router ────────────────────────────────────────────────────────────────
 
 switch (command) {
@@ -1248,6 +1366,11 @@ switch (command) {
   case 'ports':
     await configurePorts()
     break
+
+  case 'tunnel':
+    await startTunnel()
+    break
+
   case 'uninstall':
     await uninstall()
     break

package/dist/compressor.d.ts

@@ -21,7 +21,7 @@ interface AnthropicMessage {
         content?: unknown;
     }>;
 }
-export declare function compressAnthropicMessages(messages: AnthropicMessage[], apiKey: string, config: Config): Promise<[AnthropicMessage[], Savings]>;
+export declare function compressAnthropicMessages(messages: AnthropicMessage[], apiKey: string, config: Config, systemExtraChars?: number): Promise<[AnthropicMessage[], Savings]>;
 interface OpenAIMessage {
     role: string;
     content?: string | null;

package/dist/compressor.js

@@ -15,8 +15,8 @@ export function getCache(config) {
         _cache = new CompressionCache(config.cacheMaxEntries);
     return _cache;
 }
-function estimatePressure(messages) {
-    const chars = JSON.stringify(messages).length;
+function estimatePressure(messages, extraChars = 0) {
+    const chars = JSON.stringify(messages).length + extraChars;
     return Math.min(chars / 800_000, 1.0);
 }
 // ── Compression backends ──────────────────────────────────────────────────────
@@ -134,10 +134,10 @@ function buildAnthropicToolIdMap(messages) {
     }
     return { nameMap, skipIds };
 }
-export async function compressAnthropicMessages(messages, apiKey, config) {
+export async function compressAnthropicMessages(messages, apiKey, config, systemExtraChars = 0) {
     if (config.disabled)
         return [messages, emptySavings()];
-    const pressure = estimatePressure(messages);
+    const pressure = estimatePressure(messages, systemExtraChars);
     const threshold = config.thresholdForPressure(pressure);
     const { nameMap: toolIdMap, skipIds } = buildAnthropicToolIdMap(messages);
     const allResults = extractAnthropicToolResults(messages, toolIdMap)
@@ -211,12 +211,17 @@ export async function compressAnthropicMessages(messages, apiKey, config) {
     // Differential: split session cache hits from uncached
     const sessionHits = [];
     const toCompress = [];
+    const lastMsgIdx = messages.length - 1;
     for (const c of toProcess) {
         const cached = getBlock(hashText(c.text));
-        if (cached)
+        if (cached) {
             sessionHits.push({ index: c.index, subIndex: c.subIndex, tool: c.tool, block: cached });
-        else
+        }
+        else if (c.index === lastMsgIdx && !config.aiSkipTools.has(c.tool.toLowerCase())) {
+            // Only AI-compress genuinely new blocks (from the last user message).
+            // Historical uncached blocks skip AI compression → prevents burst on first activation.
             toCompress.push(c);
+        }
     }
     const freshlyCompressed = toCompress.length > 0
         ? await runCompression(toCompress, t => compressWithHaiku(t, apiKey), config)
@@ -339,12 +344,18 @@ export async function compressOpenAIMessages(messages, apiKey, config, isLocal =
     }
     const sessionHits = [];
     const toCompress = [];
+    const lastOAIMsgIdx = messages.length - 1;
+    const lastAssistantIdx = messages.reduce((best, m, i) => (m.role === 'assistant' ? i : best), -1);
+    const newStartIdx = lastAssistantIdx >= 0 ? lastAssistantIdx : lastOAIMsgIdx;
     for (const c of toProcess) {
         const cached = getBlock(hashText(c.text));
-        if (cached)
+        if (cached) {
             sessionHits.push({ index: c.index, tool: c.tool, block: cached });
-        else
+        }
+        else if (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);
+        }
     }
     const compressFn = isLocal
         ? t => compressWithOllama(t, config.localUpstreamUrl, config.localCompressionModel)

package/dist/config.d.ts

@@ -9,6 +9,7 @@ export declare class Config {
     readonly dryRun: boolean;
     readonly skipTools: Set<string>;
     readonly onlyTools: Set<string>;
+    readonly aiSkipTools: Set<string>;
     readonly cacheEnabled: boolean;
     readonly cacheMaxEntries: number;
     readonly adaptiveEnabled: boolean;

package/dist/config.js

@@ -49,6 +49,7 @@ export class Config {
     dryRun;
     skipTools;
     onlyTools;
+    aiSkipTools;
     cacheEnabled;
     cacheMaxEntries;
     adaptiveEnabled;
@@ -77,6 +78,7 @@ export class Config {
         this.dryRun = env('SQUEEZR_DRY_RUN', '') === '1';
         this.skipTools = new Set((c.skip_tools ?? []).map(t => t.toLowerCase()));
         this.onlyTools = new Set((c.only_tools ?? []).map(t => t.toLowerCase()));
+        this.aiSkipTools = new Set((c.ai_skip_tools ?? ['read']).map(t => t.toLowerCase()));
         this.cacheEnabled = ca.enabled ?? true;
         this.cacheMaxEntries = ca.max_entries ?? 1000;
         this.adaptiveEnabled = ad.enabled ?? true;

package/dist/expand.d.ts

@@ -2,6 +2,8 @@ export declare function storeOriginal(original: string): string;
 export declare function retrieveOriginal(id: string): string | undefined;
 export declare function expandStoreSize(): number;
 export declare function clearExpandStore(): void;
+export declare function loadExpandStore(): void;
+export declare function persistExpandStore(): void;
 export declare const EXPAND_TOOL_ANTHROPIC: {
     name: string;
     description: string;

package/dist/expand.js

@@ -1,4 +1,8 @@
 import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const EXPAND_STORE_PATH = join(homedir(), '.squeezr', 'expand_store.json');
 /**
  * Expand store — keeps original tool results so the model can retrieve
  * them if it needs more detail than the compressed summary provides.
@@ -33,6 +37,28 @@ export function expandStoreSize() {
 export function clearExpandStore() {
     store.clear();
 }
+export function loadExpandStore() {
+    try {
+        if (existsSync(EXPAND_STORE_PATH)) {
+            const raw = JSON.parse(readFileSync(EXPAND_STORE_PATH, 'utf-8'));
+            for (const [k, v] of Object.entries(raw)) {
+                store.set(k, v);
+            }
+            if (store.size > 0)
+                console.log(`[squeezr] Loaded ${store.size} expand store entries from disk`);
+        }
+    }
+    catch { /* ignore */ }
+}
+export function persistExpandStore() {
+    try {
+        const dir = join(homedir(), '.squeezr');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(EXPAND_STORE_PATH, JSON.stringify(Object.fromEntries(store)));
+    }
+    catch { /* ignore */ }
+}
 // ── Tool definitions ──────────────────────────────────────────────────────────
 export const EXPAND_TOOL_ANTHROPIC = {
     name: 'squeezr_expand',

package/dist/index.js

@@ -3,8 +3,15 @@ import { app, stats } from './server.js';
 import { config } from './config.js';
 import { VERSION } from './version.js';
 import { startMitmProxy } from './codexMitm.js';
+import { loadSessionCache, persistSessionCache } from './sessionCache.js';
+import { loadExpandStore, persistExpandStore } from './expand.js';
+// Load persisted caches before accepting requests
+loadSessionCache();
+loadExpandStore();
 const PORT = config.port;
 const httpServer = createAdaptorServer({ fetch: app.fetch });
+// Persist caches every 60s so a crash doesn't lose more than a minute of work
+setInterval(() => { persistSessionCache(); persistExpandStore(); }, 60_000).unref();
 httpServer.listen(PORT, () => {
     console.log(`Squeezr v${VERSION} listening on http://localhost:${PORT}`);
     console.log(`Mode: ${config.dryRun ? 'dry-run' : 'active'}`);
@@ -16,15 +23,20 @@ httpServer.listen(PORT, () => {
 // Start MITM proxy for Codex OAuth (chatgpt.com/backend-api)
 startMitmProxy();
 const isDaemon = !!process.env.SQUEEZR_DAEMON;
+function persistAndExit(code = 0) {
+    persistSessionCache();
+    persistExpandStore();
+    process.exit(code);
+}
 if (isDaemon) {
-    process.on('SIGINT', () => { });
-    process.on('SIGHUP', () => { });
+    process.on('SIGINT', () => { persistAndExit(0); });
+    process.on('SIGHUP', () => { persistAndExit(0); });
 }
 else {
     process.on('SIGINT', () => {
         const s = stats.summary();
         console.log(`\n[squeezr] Session summary: ${s.requests} requests | -${s.total_saved_chars.toLocaleString()} chars (~${s.total_saved_tokens.toLocaleString()} tokens, ${s.savings_pct}% saved)`);
-        process.exit(0);
+        persistAndExit(0);
     });
 }
-process.on('SIGTERM', () => process.exit(0));
+process.on('SIGTERM', () => { persistAndExit(0); });

package/dist/server.js

@@ -62,6 +62,23 @@ async function proxyStream(upstream, body, headers, params) {
     });
 }
 export const app = new Hono();
+// ── CORS middleware (required for Cursor IDE and browser-based tools) ─────────
+// Cursor's Electron renderer sends OPTIONS preflight before every POST.
+// Without this the request is blocked and Cursor shows a network error.
+app.use('*', async (c, next) => {
+    if (c.req.method === 'OPTIONS') {
+        return c.body(null, 204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
+            'Access-Control-Allow-Headers': '*',
+            'Access-Control-Max-Age': '86400',
+        });
+    }
+    await next();
+    c.res.headers.set('Access-Control-Allow-Origin', '*');
+    c.res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+    c.res.headers.set('Access-Control-Allow-Headers', '*');
+});
 // ── Anthropic / Claude Code ───────────────────────────────────────────────────
 app.post('/v1/messages', async (c) => {
     const body = await c.req.json();
@@ -71,13 +88,27 @@ app.post('/v1/messages', async (c) => {
         ?? c.req.header('authorization')?.replace(/^bearer\s+/i, '').trim()
         ?? process.env.ANTHROPIC_API_KEY
         ?? '';
-    // System prompt compression
-    if (config.compressSystemPrompt && !config.dryRun && typeof body.system === 'string') {
-        body.system = await compressSystemPrompt(body.system, apiKey, 'haiku');
+    // System prompt compression (handles both string and array formats — Claude Code sends array)
+    if (config.compressSystemPrompt && !config.dryRun) {
+        if (typeof body.system === 'string') {
+            body.system = await compressSystemPrompt(body.system, apiKey, 'haiku');
+        }
+        else if (Array.isArray(body.system)) {
+            for (const block of body.system) {
+                if (block.type === 'text' && typeof block.text === 'string') {
+                    block.text = await compressSystemPrompt(block.text, apiKey, 'haiku');
+                }
+            }
+        }
     }
     const messages = (body.messages ?? []);
     const originalChars = estimateChars(messages);
-    const [compressedMsgs, savings] = await compressAnthropicMessages(messages, apiKey, config);
+    const systemExtraChars = typeof body.system === 'string'
+        ? body.system.length
+        : Array.isArray(body.system)
+            ? body.system.reduce((s, b) => s + (b.text?.length ?? 0), 0)
+            : 0;
+    const [compressedMsgs, savings] = await compressAnthropicMessages(messages, apiKey, config, systemExtraChars);
     body.messages = compressedMsgs;
     // Inject expand tool
     injectExpandToolAnthropic(body);

package/dist/sessionCache.d.ts

@@ -28,3 +28,5 @@ export declare function getBlock(hash: string): SessionBlock | undefined;
 export declare function setBlock(hash: string, block: SessionBlock): void;
 export declare function sessionCacheSize(): number;
 export declare function clearSessionCache(): void;
+export declare function loadSessionCache(): void;
+export declare function persistSessionCache(): void;

package/dist/sessionCache.js

@@ -1,4 +1,8 @@
 import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const SESSION_CACHE_PATH = join(homedir(), '.squeezr', 'session_cache.json');
 const cache = new Map();
 export function hashText(text) {
     return createHash('md5').update(text).digest('hex');
@@ -15,3 +19,25 @@ export function sessionCacheSize() {
 export function clearSessionCache() {
     cache.clear();
 }
+export function loadSessionCache() {
+    try {
+        if (existsSync(SESSION_CACHE_PATH)) {
+            const raw = JSON.parse(readFileSync(SESSION_CACHE_PATH, 'utf-8'));
+            for (const [k, v] of Object.entries(raw)) {
+                cache.set(k, v);
+            }
+            if (cache.size > 0)
+                console.log(`[squeezr] Loaded ${cache.size} session cache entries from disk`);
+        }
+    }
+    catch { /* ignore */ }
+}
+export function persistSessionCache() {
+    try {
+        const dir = join(homedir(), '.squeezr');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(SESSION_CACHE_PATH, JSON.stringify(Object.fromEntries(cache)));
+    }
+    catch { /* ignore */ }
+}

package/package.json

@@ -1,61 +1,62 @@
-{
-  "name": "squeezr-ai",
-  "version": "1.17.0",
-  "description": "AI proxy that compresses Claude Code, Codex, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
-  "keywords": [
-    "claude",
-    "claude-code",
-    "codex",
-    "ollama",
-    "aider",
-    "gemini",
-    "token",
-    "compression",
-    "proxy",
-    "llm",
-    "ai"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sergioramosv/Squeezr.git"
-  },
-  "homepage": "https://github.com/sergioramosv/Squeezr#readme",
-  "type": "module",
-  "bin": {
-    "squeezr": "bin/squeezr.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/index.ts",
-    "start": "node dist/index.js",
-    "gain": "node dist/gain.js",
-    "discover": "node dist/discover.js",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "files": [
-    "bin/",
-    "dist/",
-    "squeezr.toml"
-  ],
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "@hono/node-server": "^1.13.7",
-    "hono": "^4.7.5",
-    "node-forge": "^1.4.0",
-    "openai": "^4.93.0",
-    "smol-toml": "^1.3.1"
-  },
-  "devDependencies": {
-    "@types/node": "^22.14.0",
-    "@types/node-forge": "^1.3.14",
-    "@vitest/coverage-v8": "^4.1.2",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "squeezr-ai",
+  "version": "1.17.4",
+  "description": "AI proxy that compresses Claude Code, Codex, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "ollama",
+    "aider",
+    "gemini",
+    "token",
+    "compression",
+    "proxy",
+    "llm",
+    "ai"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sergioramosv/Squeezr.git"
+  },
+  "homepage": "https://github.com/sergioramosv/Squeezr#readme",
+  "type": "module",
+  "bin": {
+    "squeezr": "bin/squeezr.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "gain": "node dist/gain.js",
+    "discover": "node dist/discover.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "squeezr.toml"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@bufbuild/protobuf": "^2.11.0",
+    "@hono/node-server": "^1.13.7",
+    "hono": "^4.7.5",
+    "node-forge": "^1.4.0",
+    "openai": "^4.93.0",
+    "smol-toml": "^1.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "@types/node-forge": "^1.3.14",
+    "@vitest/coverage-v8": "^4.1.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}