squeezr-ai 1.17.1 → 1.17.5

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

@@ -200,6 +200,9 @@ 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 cursor           Start Cursor subscription MITM proxy (no BYOK needed)
+  squeezr cursor stop      Stop Cursor proxy and clean up system proxy settings
   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
@@ -1150,6 +1153,265 @@ 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) })
+}
+
+// ── squeezr cursor ───────────────────────────────────────────────────────────
+
+async function startCursorProxy() {
+  const port = getPort()
+  const mitmPort = getMitmPort(port)
+
+  // Verify main 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)
+  }
+
+  // Verify CA exists
+  const caDir = path.join(os.homedir(), '.squeezr', 'mitm-ca')
+  const caCertPath = path.join(caDir, 'ca.crt')
+  if (!fs.existsSync(caCertPath)) {
+    console.error('MITM CA certificate not found. Run `squeezr setup` first.')
+    process.exit(1)
+  }
+
+  console.log('Starting Cursor MITM proxy...')
+
+  const distPath = path.join(ROOT, 'dist', 'cursorMitm.js')
+  if (!fs.existsSync(distPath)) {
+    console.error(`Error: ${distPath} not found. Run 'npm run build' first.`)
+    process.exit(1)
+  }
+
+  const distUrl = process.platform === 'win32' ? 'file:///' + distPath.replace(/\\/g, '/') : distPath
+  const { startCursorMitm, getCursorMitmPort, getCursorStats } = await import(distUrl)
+
+  try {
+    await startCursorMitm()
+  } catch (err) {
+    console.error('Failed to start Cursor proxy:', err.message)
+    process.exit(1)
+  }
+
+  const actualPort = getCursorMitmPort()
+  const proxyConfigured = configureSystemProxy(actualPort)
+
+  console.log('')
+  console.log('╔══════════════════════════════════════════════════════════════════╗')
+  console.log(`║  Cursor MITM proxy active on port ${actualPort}                        ║`)
+  console.log('╠══════════════════════════════════════════════════════════════════╣')
+  console.log('║                                                                  ║')
+  console.log('║  Intercepting: api2.cursor.sh (chat, agent, composer)           ║')
+  console.log('║  Compressing:  conversation context via cursor-small            ║')
+  console.log('║  Everything else: transparent pass-through                       ║')
+  console.log('║                                                                  ║')
+  if (proxyConfigured) {
+    console.log('║  System proxy configured automatically.                         ║')
+    console.log('║  Cursor will route through Squeezr on next request.             ║')
+  } else {
+    console.log('║  ⚠ Could not set system proxy automatically.                   ║')
+    console.log('║  Set it manually:                                               ║')
+    if (process.platform === 'win32') {
+      console.log(`║    Settings > Network > Proxy > Manual: 127.0.0.1:${actualPort}     ║`)
+    } else if (process.platform === 'darwin') {
+      console.log(`║    networksetup -setsecurewebproxy Wi-Fi 127.0.0.1 ${actualPort}     ║`)
+    } else {
+      console.log(`║    export HTTPS_PROXY=http://127.0.0.1:${actualPort}                  ║`)
+    }
+  }
+  console.log('║                                                                  ║')
+  console.log('║  Press Ctrl+C to stop and clean up proxy settings               ║')
+  console.log('╚══════════════════════════════════════════════════════════════════╝')
+  console.log('')
+
+  const statsInterval = setInterval(() => {
+    const s = getCursorStats()
+    if (s.requests > 0) {
+      console.log(`[squeezr/cursor] Stats: ${s.requests} requests, ${s.compressed} compressed, -${s.charsSaved.toLocaleString()} chars saved`)
+    }
+  }, 30_000)
+
+  const cleanup = () => {
+    clearInterval(statsInterval)
+    console.log('\nStopping Cursor proxy...')
+    cleanSystemProxy()
+    const s = getCursorStats()
+    console.log(`Session: ${s.requests} requests, ${s.compressed} compressed, -${s.charsSaved.toLocaleString()} chars saved`)
+    process.exit(0)
+  }
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+}
+
+function configureSystemProxy(port) {
+  try {
+    if (process.platform === 'win32') {
+      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD /d 1 /f`, { stdio: 'pipe' })
+      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyServer /t REG_SZ /d "127.0.0.1:${port}" /f`, { stdio: 'pipe' })
+      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyOverride /t REG_SZ /d "<local>;localhost;127.0.0.1" /f`, { stdio: 'pipe' })
+      return true
+    } else if (process.platform === 'darwin') {
+      try {
+        const services = execSync('networksetup -listallnetworkservices', { encoding: 'utf-8' })
+          .split('\n')
+          .filter(s => s.trim() && !s.startsWith('*') && !s.startsWith('An asterisk'))
+        for (const svc of services) {
+          try {
+            execSync(`networksetup -setsecurewebproxy "${svc.trim()}" 127.0.0.1 ${port}`, { stdio: 'pipe' })
+          } catch {}
+        }
+        return true
+      } catch { return false }
+    } else {
+      try {
+        execSync(`gsettings set org.gnome.system.proxy mode 'manual'`, { stdio: 'pipe' })
+        execSync(`gsettings set org.gnome.system.proxy.https host '127.0.0.1'`, { stdio: 'pipe' })
+        execSync(`gsettings set org.gnome.system.proxy.https port ${port}`, { stdio: 'pipe' })
+        return true
+      } catch { return false }
+    }
+  } catch {
+    return false
+  }
+}
+
+function cleanSystemProxy() {
+  try {
+    if (process.platform === 'win32') {
+      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD /d 0 /f`, { stdio: 'pipe' })
+    } else if (process.platform === 'darwin') {
+      try {
+        const services = execSync('networksetup -listallnetworkservices', { encoding: 'utf-8' })
+          .split('\n')
+          .filter(s => s.trim() && !s.startsWith('*') && !s.startsWith('An asterisk'))
+        for (const svc of services) {
+          try {
+            execSync(`networksetup -setsecurewebproxystate "${svc.trim()}" off`, { stdio: 'pipe' })
+          } catch {}
+        }
+      } catch {}
+    } else {
+      try {
+        execSync(`gsettings set org.gnome.system.proxy mode 'none'`, { stdio: 'pipe' })
+      } catch {}
+    }
+    console.log('System proxy settings cleaned up.')
+  } catch {
+    console.warn('Could not clean system proxy settings. You may need to disable manually.')
+  }
+}
+
 // ── CLI router ────────────────────────────────────────────────────────────────
 
 switch (command) {
@@ -1262,6 +1524,19 @@ switch (command) {
   case 'ports':
     await configurePorts()
     break
+
+  case 'tunnel':
+    await startTunnel()
+    break
+
+  case 'cursor':
+    if (args[1] === 'stop') {
+      cleanSystemProxy()
+    } else {
+      await startCursorProxy()
+    }
+    break
+
   case 'uninstall':
     await uninstall()
     break

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

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

package/dist/__tests__/cursorMitm.test.js

@@ -0,0 +1,313 @@
+import { describe, it, expect } from 'vitest';
+// We test the exported utility functions and the ConnectRPC/proto layer.
+// Since cursorMitm.ts has many private functions, we use a test helper approach
+// by importing the module and testing the public API + running integration checks.
+// For testing the proto encoder/decoder, we replicate the minimal logic here
+// since the functions are module-private. We'll also test the full flow.
+// ── ConnectRPC frame tests ───────────────────────────────────────────────────
+function buildConnectFrame(payload, flag = 0) {
+    const header = Buffer.alloc(5);
+    header[0] = flag;
+    header.writeUInt32BE(payload.length, 1);
+    return Buffer.concat([header, payload]);
+}
+function parseConnectFrame(buf) {
+    if (buf.length < 5)
+        return null;
+    const flag = buf[0];
+    const length = buf.readUInt32BE(1);
+    if (buf.length < 5 + length)
+        return null;
+    return { flag, payload: buf.subarray(5, 5 + length), total: 5 + length };
+}
+describe('ConnectRPC frame encoding', () => {
+    it('should round-trip a simple payload', () => {
+        const payload = Buffer.from('hello world');
+        const frame = buildConnectFrame(payload);
+        expect(frame.length).toBe(5 + payload.length);
+        expect(frame[0]).toBe(0); // uncompressed flag
+        const parsed = parseConnectFrame(frame);
+        expect(parsed).not.toBeNull();
+        expect(parsed.flag).toBe(0);
+        expect(parsed.payload.toString()).toBe('hello world');
+        expect(parsed.total).toBe(frame.length);
+    });
+    it('should handle gzip flag', () => {
+        const payload = Buffer.from('compressed data');
+        const frame = buildConnectFrame(payload, 1);
+        const parsed = parseConnectFrame(frame);
+        expect(parsed.flag).toBe(1);
+        expect(parsed.payload.toString()).toBe('compressed data');
+    });
+    it('should return null for incomplete frames', () => {
+        expect(parseConnectFrame(Buffer.alloc(3))).toBeNull();
+        // Header says 100 bytes but only 10 present
+        const incomplete = Buffer.alloc(15);
+        incomplete.writeUInt32BE(100, 1);
+        expect(parseConnectFrame(incomplete)).toBeNull();
+    });
+    it('should handle empty payload', () => {
+        const frame = buildConnectFrame(Buffer.alloc(0));
+        expect(frame.length).toBe(5);
+        const parsed = parseConnectFrame(frame);
+        expect(parsed.payload.length).toBe(0);
+    });
+    it('should handle large payloads', () => {
+        const payload = Buffer.alloc(65536, 0x42);
+        const frame = buildConnectFrame(payload);
+        const parsed = parseConnectFrame(frame);
+        expect(parsed.payload.length).toBe(65536);
+        expect(parsed.payload[0]).toBe(0x42);
+    });
+});
+// ── Protobuf varint tests ────────────────────────────────────────────────────
+function encodeVarint(value) {
+    const bytes = [];
+    while (value > 0x7F) {
+        bytes.push((value & 0x7F) | 0x80);
+        value >>>= 7;
+    }
+    bytes.push(value & 0x7F);
+    return Buffer.from(bytes);
+}
+function decodeVarint(buf, offset) {
+    let value = 0;
+    let shift = 0;
+    let bytesRead = 0;
+    while (offset + bytesRead < buf.length) {
+        const byte = buf[offset + bytesRead];
+        value |= (byte & 0x7F) << shift;
+        bytesRead++;
+        if ((byte & 0x80) === 0)
+            break;
+        shift += 7;
+    }
+    return { value, bytesRead };
+}
+describe('Protobuf varint encoding', () => {
+    it('should encode small numbers', () => {
+        expect(encodeVarint(0)).toEqual(Buffer.from([0]));
+        expect(encodeVarint(1)).toEqual(Buffer.from([1]));
+        expect(encodeVarint(127)).toEqual(Buffer.from([127]));
+    });
+    it('should encode multi-byte varints', () => {
+        expect(encodeVarint(128)).toEqual(Buffer.from([0x80, 0x01]));
+        expect(encodeVarint(300)).toEqual(Buffer.from([0xAC, 0x02]));
+    });
+    it('should round-trip varints', () => {
+        for (const val of [0, 1, 127, 128, 300, 16383, 16384, 65535]) {
+            const buf = encodeVarint(val);
+            const { value } = decodeVarint(buf, 0);
+            expect(value).toBe(val);
+        }
+    });
+});
+// ── Protobuf message building/parsing ────────────────────────────────────────
+function encodeTag(fieldNumber, wireType) {
+    return encodeVarint((fieldNumber << 3) | wireType);
+}
+function encodeLengthDelimited(fieldNumber, data) {
+    const tag = encodeTag(fieldNumber, 2);
+    const len = encodeVarint(data.length);
+    return Buffer.concat([tag, len, data]);
+}
+function encodeString(fieldNumber, str) {
+    return encodeLengthDelimited(fieldNumber, Buffer.from(str, 'utf-8'));
+}
+function encodeVarintField(fieldNumber, value) {
+    const tag = encodeTag(fieldNumber, 0);
+    const val = encodeVarint(value);
+    return Buffer.concat([tag, val]);
+}
+function parseProtoFields(buf) {
+    const fields = [];
+    let offset = 0;
+    while (offset < buf.length) {
+        const tagStart = offset;
+        const { value: tag, bytesRead: tagBytes } = decodeVarint(buf, offset);
+        offset += tagBytes;
+        const fieldNumber = tag >>> 3;
+        const wireType = tag & 0x07;
+        let fieldEnd = offset;
+        switch (wireType) {
+            case 0: {
+                while (fieldEnd < buf.length && (buf[fieldEnd] & 0x80) !== 0)
+                    fieldEnd++;
+                fieldEnd++;
+                break;
+            }
+            case 1: {
+                fieldEnd += 8;
+                break;
+            }
+            case 2: {
+                const { value: len, bytesRead: lenBytes } = decodeVarint(buf, offset);
+                fieldEnd = offset + lenBytes + len;
+                break;
+            }
+            case 5: {
+                fieldEnd += 4;
+                break;
+            }
+            default: fieldEnd = buf.length;
+        }
+        fields.push({ fieldNumber, wireType, data: buf.subarray(tagStart, fieldEnd) });
+        offset = fieldEnd;
+    }
+    return fields;
+}
+function extractPayload(rawField) {
+    let offset = 0;
+    while (offset < rawField.length && (rawField[offset] & 0x80) !== 0)
+        offset++;
+    offset++;
+    const { value: len, bytesRead } = decodeVarint(rawField, offset);
+    offset += bytesRead;
+    return rawField.subarray(offset, offset + len);
+}
+describe('Protobuf field encoding/parsing', () => {
+    it('should encode and parse a string field', () => {
+        const encoded = encodeString(2, 'Hello, world!');
+        const fields = parseProtoFields(encoded);
+        expect(fields.length).toBe(1);
+        expect(fields[0].fieldNumber).toBe(2);
+        expect(fields[0].wireType).toBe(2);
+        const payload = extractPayload(fields[0].data);
+        expect(payload.toString('utf-8')).toBe('Hello, world!');
+    });
+    it('should encode and parse a varint field', () => {
+        const encoded = encodeVarintField(1, 42);
+        const fields = parseProtoFields(encoded);
+        expect(fields.length).toBe(1);
+        expect(fields[0].fieldNumber).toBe(1);
+        expect(fields[0].wireType).toBe(0);
+    });
+    it('should encode and parse a ConversationMessage-like structure', () => {
+        // ConversationMessage: field 1 = role (varint), field 2 = text (string)
+        const msgPayload = Buffer.concat([
+            encodeVarintField(1, 1), // role = HUMAN
+            encodeString(2, 'What is 2+2?'),
+        ]);
+        const conversationField = encodeLengthDelimited(2, msgPayload);
+        const outerFields = parseProtoFields(conversationField);
+        expect(outerFields.length).toBe(1);
+        expect(outerFields[0].fieldNumber).toBe(2);
+        const innerPayload = extractPayload(outerFields[0].data);
+        const innerFields = parseProtoFields(innerPayload);
+        expect(innerFields.length).toBe(2);
+        expect(innerFields[0].fieldNumber).toBe(1); // role
+        expect(innerFields[1].fieldNumber).toBe(2); // text
+        const text = extractPayload(innerFields[1].data).toString('utf-8');
+        expect(text).toBe('What is 2+2?');
+    });
+    it('should handle a full GetChatRequest with multiple conversation messages', () => {
+        // Build a fake GetChatRequest:
+        // field 2 (conversation) repeated, field 5 (workspace_root_path)
+        const msg1 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'Please review my code'),
+        ]));
+        const msg2 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 2),
+            encodeString(2, 'Sure, I see several issues with your implementation...'),
+        ]));
+        const msg3 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'Can you fix them?'),
+        ]));
+        const workspacePath = encodeString(5, '/home/user/project');
+        const request = Buffer.concat([msg1, msg2, msg3, workspacePath]);
+        const fields = parseProtoFields(request);
+        // Should have 4 fields: 3 conversation + 1 workspace
+        expect(fields.length).toBe(4);
+        const conversationFields = fields.filter(f => f.fieldNumber === 2);
+        expect(conversationFields.length).toBe(3);
+        const otherFields = fields.filter(f => f.fieldNumber !== 2);
+        expect(otherFields.length).toBe(1);
+        expect(otherFields[0].fieldNumber).toBe(5);
+    });
+    it('should preserve round-trip of unknown fields', () => {
+        // Fields we don't know should survive parse → concat(data) unchanged
+        const msg1 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'hello'),
+        ]));
+        const unknownField1 = encodeString(7, 'some-request-id');
+        const unknownField2 = encodeVarintField(27, 1); // is_composer
+        const unknownField3 = encodeString(15, 'conv-id-123');
+        const original = Buffer.concat([msg1, unknownField1, unknownField2, unknownField3]);
+        const fields = parseProtoFields(original);
+        // Reconstructing from raw data should give same bytes
+        const reconstructed = Buffer.concat(fields.map(f => f.data));
+        expect(reconstructed).toEqual(original);
+    });
+});
+// ── Integration: ConnectRPC + Protobuf ───────────────────────────────────────
+describe('ConnectRPC + Protobuf integration', () => {
+    it('should encode a full request frame and parse it back', () => {
+        const msg1 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 1),
+            encodeString(2, 'User question'),
+        ]));
+        const msg2 = encodeLengthDelimited(2, Buffer.concat([
+            encodeVarintField(1, 2),
+            encodeString(2, 'AI response with lots of context and details'),
+        ]));
+        const requestPayload = Buffer.concat([msg1, msg2]);
+        const frame = buildConnectFrame(requestPayload);
+        // Parse frame
+        const parsed = parseConnectFrame(frame);
+        expect(parsed).not.toBeNull();
+        // Parse proto
+        const fields = parseProtoFields(parsed.payload);
+        expect(fields.filter(f => f.fieldNumber === 2).length).toBe(2);
+    });
+});
+// ── Deterministic compression ────────────────────────────────────────────────
+function deterministicCompress(text) {
+    let out = text;
+    out = out.replace(/\n{3,}/g, '\n\n');
+    out = out.replace(/[ \t]+$/gm, '');
+    const lines = out.split('\n');
+    const result = [];
+    let lastLine = '';
+    let repeatCount = 0;
+    for (const line of lines) {
+        if (line === lastLine && line.trim().length > 0) {
+            repeatCount++;
+        }
+        else {
+            if (repeatCount > 0) {
+                result.push(`  ... (repeated ${repeatCount}x)`);
+                repeatCount = 0;
+            }
+            result.push(line);
+            lastLine = line;
+        }
+    }
+    if (repeatCount > 0)
+        result.push(`  ... (repeated ${repeatCount}x)`);
+    return result.join('\n');
+}
+describe('Deterministic compression', () => {
+    it('should collapse blank lines', () => {
+        const input = 'a\n\n\n\n\nb';
+        expect(deterministicCompress(input)).toBe('a\n\nb');
+    });
+    it('should strip trailing whitespace', () => {
+        const input = 'hello   \nworld\t\t';
+        expect(deterministicCompress(input)).toBe('hello\nworld');
+    });
+    it('should collapse repeated lines', () => {
+        const input = 'error: connection failed\nerror: connection failed\nerror: connection failed\nok';
+        const result = deterministicCompress(input);
+        expect(result).toContain('error: connection failed');
+        expect(result).toContain('repeated 2x');
+        expect(result).toContain('ok');
+    });
+    it('should not collapse empty repeated lines', () => {
+        const input = 'a\n\n\nb';
+        const result = deterministicCompress(input);
+        expect(result).not.toContain('repeated');
+    });
+});

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;