squeezr-ai 1.17.6 → 1.17.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squeezr-ai",
-  "version": "1.17.6",
+  "version": "1.17.7",
   "description": "AI proxy that compresses Claude Code, Codex, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
   "keywords": [
     "claude",
@@ -28,6 +28,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "prepack": "node -e \"['dist/cursorMitm.js','dist/cursorMitm.d.ts','dist/__tests__/cursorMitm.test.js','dist/__tests__/cursorMitm.test.d.ts'].forEach(f=>{try{require('fs').unlinkSync(f)}catch{}})\"",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "gain": "node dist/gain.js",

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

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

package/dist/__tests__/cursorMitm.test.js

@@ -1,313 +0,0 @@
-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/cursorMitm.d.ts

@@ -1,18 +0,0 @@
-/**
- * Cursor Subscription MITM Proxy
- *
- * Intercepts Cursor IDE (Electron/Chromium) traffic to api2.cursor.sh,
- * compresses the conversation context using Cursor's own models (cursor-small),
- * and forwards the compressed request transparently.
- *
- * Protocol: ConnectRPC over HTTP/2 with binary Protobuf
- * Target:   api2.cursor.sh/aiserver.v1.ChatService/StreamUnifiedChatWithTools
- */
-export declare function getCursorStats(): {
-    requests: number;
-    compressed: number;
-    charsSaved: number;
-};
-export declare function getCursorMitmPort(): number;
-export declare function startCursorMitm(): Promise<void>;
-export declare function stopCursorMitm(): void;

package/dist/cursorMitm.js

@@ -1,846 +0,0 @@
-/**
- * Cursor Subscription MITM Proxy
- *
- * Intercepts Cursor IDE (Electron/Chromium) traffic to api2.cursor.sh,
- * compresses the conversation context using Cursor's own models (cursor-small),
- * and forwards the compressed request transparently.
- *
- * Protocol: ConnectRPC over HTTP/2 with binary Protobuf
- * Target:   api2.cursor.sh/aiserver.v1.ChatService/StreamUnifiedChatWithTools
- */
-import net from 'node:net';
-import tls from 'node:tls';
-import http from 'node:http';
-import http2 from 'node:http2';
-import fs from 'node:fs';
-import crypto from 'node:crypto';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import forge from 'node-forge';
-import { config } from './config.js';
-// ── Constants ────────────────────────────────────────────────────────────────
-const CURSOR_API_HOST = 'api2.cursor.sh';
-const CURSOR_CHAT_PATH = '/aiserver.v1.ChatService/StreamUnifiedChatWithTools';
-const CURSOR_COMPOSER_PATH = '/aiserver.v1.AiService/StreamComposer';
-const CURSOR_CHAT_HARD_PATH = '/aiserver.v1.AiService/StreamChatTryReallyHard';
-const INTERCEPTED_PATHS = new Set([CURSOR_CHAT_PATH, CURSOR_COMPOSER_PATH, CURSOR_CHAT_HARD_PATH]);
-// Minimal Protobuf field numbers for GetChatRequest (from cursor-rpc protos)
-// We decode only the fields we need to compress, pass-through everything else at binary level
-const PROTO_FIELD_CONVERSATION = 2; // repeated ConversationMessage
-const PROTO_FIELD_ROLE = 1; // MessageType enum in ConversationMessage
-const PROTO_FIELD_TEXT = 2; // string text in ConversationMessage
-// Protobuf wire types
-const WIRE_VARINT = 0;
-const WIRE_LENGTH_DELIMITED = 2;
-const COMPRESS_THRESHOLD = config.threshold ?? 800;
-const KEEP_RECENT = config.keepRecent ?? 3;
-// ── CA paths (shared with codexMitm) ─────────────────────────────────────────
-const CA_DIR = join(homedir(), '.squeezr', 'mitm-ca');
-const CA_KEY_PATH = join(CA_DIR, 'ca.key');
-const CA_CERT_PATH = join(CA_DIR, 'ca.crt');
-// ── Per-host cert (cached) ───────────────────────────────────────────────────
-const certCache = new Map();
-function getCert(hostname) {
-    if (certCache.has(hostname))
-        return certCache.get(hostname);
-    const caKey = forge.pki.privateKeyFromPem(fs.readFileSync(CA_KEY_PATH, 'utf-8'));
-    const caCert = forge.pki.certificateFromPem(fs.readFileSync(CA_CERT_PATH, 'utf-8'));
-    const keys = forge.pki.rsa.generateKeyPair(2048);
-    const cert = forge.pki.createCertificate();
-    cert.publicKey = keys.publicKey;
-    cert.serialNumber = crypto.randomBytes(8).toString('hex');
-    cert.validity.notBefore = new Date();
-    cert.validity.notAfter = new Date();
-    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
-    cert.setSubject([{ name: 'commonName', value: hostname }]);
-    cert.setIssuer(caCert.subject.attributes);
-    cert.setExtensions([{ name: 'subjectAltName', altNames: [{ type: 2, value: hostname }] }]);
-    cert.sign(caKey, forge.md.sha256.create());
-    const result = {
-        key: forge.pki.privateKeyToPem(keys.privateKey),
-        cert: forge.pki.certificateToPem(cert),
-    };
-    certCache.set(hostname, result);
-    return result;
-}
-// ── ConnectRPC envelope framing ──────────────────────────────────────────────
-// Wire format: [flag: 1 byte][length: 4 bytes big-endian][payload: N bytes]
-// flag 0x00 = uncompressed, 0x01 = gzip (we only handle uncompressed)
-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 };
-}
-function buildConnectFrame(payload, flag = 0) {
-    const header = Buffer.alloc(5);
-    header[0] = flag;
-    header.writeUInt32BE(payload.length, 1);
-    return Buffer.concat([header, payload]);
-}
-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 };
-}
-function encodeVarint(value) {
-    const bytes = [];
-    while (value > 0x7F) {
-        bytes.push((value & 0x7F) | 0x80);
-        value >>>= 7;
-    }
-    bytes.push(value & 0x7F);
-    return Buffer.from(bytes);
-}
-function encodeTag(fieldNumber, wireType) {
-    return encodeVarint((fieldNumber << 3) | wireType);
-}
-function encodeLengthDelimited(fieldNumber, data) {
-    const tag = encodeTag(fieldNumber, WIRE_LENGTH_DELIMITED);
-    const len = encodeVarint(data.length);
-    return Buffer.concat([tag, len, data]);
-}
-function encodeString(fieldNumber, str) {
-    const data = Buffer.from(str, 'utf-8');
-    return encodeLengthDelimited(fieldNumber, data);
-}
-function encodeVarintField(fieldNumber, value) {
-    const tag = encodeTag(fieldNumber, WIRE_VARINT);
-    const val = encodeVarint(value);
-    return Buffer.concat([tag, val]);
-}
-/** Parse a protobuf message into raw fields, preserving byte-level data for round-trip */
-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: { // varint
-                while (fieldEnd < buf.length && (buf[fieldEnd] & 0x80) !== 0)
-                    fieldEnd++;
-                fieldEnd++; // last byte
-                break;
-            }
-            case 1: { // 64-bit
-                fieldEnd += 8;
-                break;
-            }
-            case 2: { // length-delimited
-                const { value: len, bytesRead: lenBytes } = decodeVarint(buf, offset);
-                fieldEnd = offset + lenBytes + len;
-                break;
-            }
-            case 5: { // 32-bit
-                fieldEnd += 4;
-                break;
-            }
-            default:
-                // Unknown wire type — skip to end to avoid infinite loop
-                fieldEnd = buf.length;
-        }
-        fields.push({
-            fieldNumber,
-            wireType,
-            data: buf.subarray(tagStart, fieldEnd),
-        });
-        offset = fieldEnd;
-    }
-    return fields;
-}
-/** Extract the payload of a length-delimited field (skipping tag + length prefix) */
-function extractLengthDelimitedPayload(rawField) {
-    let offset = 0;
-    // skip tag varint
-    while (offset < rawField.length && (rawField[offset] & 0x80) !== 0)
-        offset++;
-    offset++; // last tag byte
-    // read length varint
-    const { value: len, bytesRead } = decodeVarint(rawField, offset);
-    offset += bytesRead;
-    return rawField.subarray(offset, offset + len);
-}
-/** Read a varint field value */
-function readVarintValue(rawField) {
-    let offset = 0;
-    while (offset < rawField.length && (rawField[offset] & 0x80) !== 0)
-        offset++;
-    offset++;
-    return decodeVarint(rawField, offset).value;
-}
-function extractConversation(requestPayload) {
-    const fields = parseProtoFields(requestPayload);
-    const messages = [];
-    const otherFields = [];
-    for (const field of fields) {
-        if (field.fieldNumber === PROTO_FIELD_CONVERSATION && field.wireType === WIRE_LENGTH_DELIMITED) {
-            const msgPayload = extractLengthDelimitedPayload(field.data);
-            const msgFields = parseProtoFields(msgPayload);
-            let role = 0;
-            let text = '';
-            for (const mf of msgFields) {
-                if (mf.fieldNumber === PROTO_FIELD_ROLE && mf.wireType === WIRE_VARINT) {
-                    role = readVarintValue(mf.data);
-                }
-                else if (mf.fieldNumber === PROTO_FIELD_TEXT && mf.wireType === WIRE_LENGTH_DELIMITED) {
-                    text = extractLengthDelimitedPayload(mf.data).toString('utf-8');
-                }
-            }
-            messages.push({ role, text, originalBytes: field.data });
-        }
-        else {
-            otherFields.push(field.data);
-        }
-    }
-    return { messages, otherFields };
-}
-function rebuildRequest(messages, otherFields, compressed) {
-    const parts = [];
-    // Re-add non-conversation fields in original order
-    // We need to interleave them, but proto doesn't care about field order
-    for (const raw of otherFields) {
-        parts.push(raw);
-    }
-    // Re-add conversation messages
-    for (let i = 0; i < messages.length; i++) {
-        if (compressed.has(i)) {
-            // Build new ConversationMessage proto
-            const msgPayload = Buffer.concat([
-                encodeVarintField(PROTO_FIELD_ROLE, messages[i].role),
-                encodeString(PROTO_FIELD_TEXT, compressed.get(i)),
-            ]);
-            parts.push(encodeLengthDelimited(PROTO_FIELD_CONVERSATION, msgPayload));
-        }
-        else {
-            // Keep original bytes
-            parts.push(messages[i].originalBytes);
-        }
-    }
-    return Buffer.concat(parts);
-}
-// ── Compression via Cursor's own API ─────────────────────────────────────────
-let cursorStats = { requests: 0, compressed: 0, charsSaved: 0 };
-export function getCursorStats() {
-    return { ...cursorStats };
-}
-async function compressViaCursor(texts, bearerToken, headers) {
-    // Build a compression request using the same Cursor API
-    // We ask cursor-small to summarize multiple conversation turns
-    const combinedText = texts.map((t, i) => `[Turn ${i + 1}]:\n${t}`).join('\n\n');
-    const prompt = `Compress this conversation history into a concise summary preserving: file paths, function names, error messages, decisions made, and key technical context. Be very concise, under ${Math.max(150, Math.floor(combinedText.length / 6))} chars.\n\n${combinedText}`;
-    try {
-        // Build a minimal GetChatRequest protobuf
-        const conversationMsg = Buffer.concat([
-            encodeVarintField(PROTO_FIELD_ROLE, 1), // HUMAN
-            encodeString(PROTO_FIELD_TEXT, prompt),
-        ]);
-        const requestPayload = encodeLengthDelimited(PROTO_FIELD_CONVERSATION, conversationMsg);
-        const frame = buildConnectFrame(requestPayload);
-        // Make HTTP/2 request to api2.cursor.sh
-        return await new Promise((resolve) => {
-            const timeout = setTimeout(() => resolve(texts), 15_000);
-            const session = http2.connect(`https://${CURSOR_API_HOST}`, {
-                // Trust system CAs + our MITM CA
-                rejectUnauthorized: true,
-            });
-            session.on('error', () => {
-                clearTimeout(timeout);
-                resolve(texts);
-            });
-            const reqHeaders = {
-                ':method': 'POST',
-                ':path': CURSOR_CHAT_PATH,
-                ':authority': CURSOR_API_HOST,
-                'content-type': 'application/connect+proto',
-                'connect-protocol-version': '1',
-                'authorization': bearerToken,
-            };
-            // Forward Cursor-specific headers
-            for (const [k, v] of Object.entries(headers)) {
-                const lk = k.toLowerCase();
-                if (lk.startsWith('x-cursor-') || lk === 'x-ghost-mode' || lk === 'x-session-id' || lk === 'x-client-key') {
-                    reqHeaders[lk] = v;
-                }
-            }
-            const req = session.request(reqHeaders);
-            req.write(frame);
-            req.end();
-            let responseBuf = Buffer.alloc(0);
-            req.on('data', (chunk) => {
-                responseBuf = Buffer.concat([responseBuf, chunk]);
-            });
-            req.on('end', () => {
-                clearTimeout(timeout);
-                try {
-                    // Parse response ConnectRPC frame(s)
-                    const responseFrame = parseConnectFrame(responseBuf);
-                    if (responseFrame && responseFrame.flag === 0) {
-                        // Parse the response protobuf — look for text field
-                        const respFields = parseProtoFields(responseFrame.payload);
-                        for (const f of respFields) {
-                            if (f.wireType === WIRE_LENGTH_DELIMITED) {
-                                const inner = extractLengthDelimitedPayload(f.data);
-                                const innerFields = parseProtoFields(inner);
-                                for (const inf of innerFields) {
-                                    if (inf.wireType === WIRE_LENGTH_DELIMITED) {
-                                        const text = extractLengthDelimitedPayload(inf.data).toString('utf-8');
-                                        if (text.length > 20 && text.length < combinedText.length) {
-                                            session.close();
-                                            resolve([text]);
-                                            return;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    session.close();
-                    resolve(texts); // fallback: return originals
-                }
-                catch {
-                    session.close();
-                    resolve(texts);
-                }
-            });
-            req.on('error', () => {
-                clearTimeout(timeout);
-                session.close();
-                resolve(texts);
-            });
-        });
-    }
-    catch {
-        return texts;
-    }
-}
-// ── Deterministic compression (no LLM, pattern-based) ────────────────────────
-function deterministicCompress(text) {
-    let out = text;
-    // Remove duplicate blank lines
-    out = out.replace(/\n{3,}/g, '\n\n');
-    // Remove trailing whitespace per line
-    out = out.replace(/[ \t]+$/gm, '');
-    // Collapse repeated log-like lines (keep first + count)
-    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');
-}
-// ── HTTP/1.1 → HTTP/2 bridge for api2.cursor.sh ─────────────────────────────
-// When Cursor runs with --disable-http2, it sends HTTP/1.1 but api2.cursor.sh
-// requires HTTP/2. We accept HTTP/1.1, parse the request, optionally compress,
-// and forward it over HTTP/2.
-function handleCursorH1Bridge(clientSocket, hostname) {
-    // Persistent H2 session to upstream — reused across keep-alive requests
-    let upstreamH2 = null;
-    function getUpstream() {
-        if (upstreamH2 && !upstreamH2.closed && !upstreamH2.destroyed)
-            return upstreamH2;
-        upstreamH2 = http2.connect(`https://${hostname}`, { rejectUnauthorized: true });
-        upstreamH2.on('error', () => { upstreamH2 = null; });
-        return upstreamH2;
-    }
-    const fakeServer = new http.Server({ keepAlive: true, keepAliveTimeout: 30000 });
-    // IMPORTANT: attach listener BEFORE emitting connection to avoid race condition
-    fakeServer.on('request', async (clientReq, clientRes) => {
-        const reqPath = clientReq.url ?? '/';
-        const method = clientReq.method ?? 'POST';
-        const shouldIntercept = INTERCEPTED_PATHS.has(reqPath);
-        console.log(`[squeezr/cursor] H1→H2: ${method} ${reqPath}${shouldIntercept ? ' [CHAT]' : ''}`);
-        // Collect request body
-        const chunks = [];
-        clientReq.on('data', (chunk) => chunks.push(chunk));
-        clientReq.on('end', async () => {
-            let body = Buffer.concat(chunks);
-            // Compress if this is a chat endpoint
-            if (shouldIntercept && method === 'POST' && body.length > 0) {
-                cursorStats.requests++;
-                try {
-                    const frame = parseConnectFrame(body);
-                    if (frame && frame.flag === 0) {
-                        const { messages, otherFields } = extractConversation(frame.payload);
-                        if (messages.length > KEEP_RECENT + 1) {
-                            const compressibleCount = messages.length - KEEP_RECENT;
-                            const compressibleMsgs = messages.slice(0, compressibleCount);
-                            const totalChars = compressibleMsgs.reduce((sum, m) => sum + m.text.length, 0);
-                            if (totalChars >= COMPRESS_THRESHOLD) {
-                                const textsToCompress = compressibleMsgs.map(m => m.text);
-                                let compressedTexts = textsToCompress.map(deterministicCompress);
-                                const compressed = new Map();
-                                for (let i = 0; i < compressedTexts.length; i++) {
-                                    if (compressedTexts[i] !== textsToCompress[i]) {
-                                        compressed.set(i, compressedTexts[i]);
-                                    }
-                                }
-                                if (compressed.size > 0) {
-                                    const filteredMessages = messages.filter((_, i) => !compressed.has(i) || compressed.get(i) !== '');
-                                    const newPayload = rebuildRequest(filteredMessages, otherFields, compressed);
-                                    const newFrame = buildConnectFrame(newPayload);
-                                    const charsSaved = totalChars - compressedTexts.join('').length;
-                                    if (charsSaved > 0) {
-                                        cursorStats.compressed++;
-                                        cursorStats.charsSaved += charsSaved;
-                                        console.log(`[squeezr/cursor] Compressed: -${charsSaved} chars (${messages.length} msgs → ${filteredMessages.length})`);
-                                    }
-                                    body = newFrame;
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    console.error(`[squeezr/cursor] H1 compression error: ${e.message}`);
-                }
-            }
-            // Forward to api2.cursor.sh over HTTP/2 (reusable session)
-            const upSession = getUpstream();
-            const upHeaders = {
-                ':method': method,
-                ':path': reqPath,
-                ':authority': hostname,
-                ':scheme': 'https',
-            };
-            for (const [k, v] of Object.entries(clientReq.headers)) {
-                if (['host', 'connection', 'transfer-encoding', 'upgrade', 'proxy-connection'].includes(k))
-                    continue;
-                upHeaders[k] = Array.isArray(v) ? v.join(', ') : (v ?? '');
-            }
-            upHeaders['content-length'] = String(body.length);
-            const upStream = upSession.request(upHeaders);
-            upStream.write(body);
-            upStream.end();
-            // Buffer response to get content-length for proper HTTP/1.1 keep-alive
-            const respChunks = [];
-            let respStatus = 200;
-            let respHeaders = {};
-            upStream.on('response', (upRespHeaders) => {
-                respStatus = upRespHeaders[':status'] ?? 200;
-                for (const [k, v] of Object.entries(upRespHeaders)) {
-                    if (k.startsWith(':'))
-                        continue;
-                    respHeaders[k] = v;
-                }
-            });
-            upStream.on('data', (chunk) => {
-                respChunks.push(chunk);
-            });
-            upStream.on('end', () => {
-                const respBody = Buffer.concat(respChunks);
-                respHeaders['content-length'] = String(respBody.length);
-                respHeaders['connection'] = 'keep-alive';
-                clientRes.writeHead(respStatus, respHeaders);
-                clientRes.end(respBody);
-            });
-            upStream.on('error', () => {
-                if (!clientRes.headersSent)
-                    clientRes.writeHead(502, { 'connection': 'keep-alive' });
-                clientRes.end();
-            });
-        });
-    });
-    fakeServer.on('error', () => { try {
-        clientSocket.destroy();
-    }
-    catch { } });
-    // Emit connection AFTER all listeners are attached
-    fakeServer.emit('connection', clientSocket);
-}
-// ── HTTP/2 MITM handler for api2.cursor.sh ───────────────────────────────────
-function handleCursorH2(clientSocket, _hostname) {
-    // Use performServerHandshake to create an HTTP/2 session on the existing TLS socket
-    let serverSession;
-    try {
-        serverSession = http2.performServerHandshake(clientSocket);
-    }
-    catch (e) {
-        console.log(`[squeezr/cursor] H2 handshake failed: ${e.message}`);
-        clientSocket.destroy();
-        return;
-    }
-    serverSession.on('error', (e) => {
-        // Expected when client doesn't speak h2 — just close silently
-        if (!e.message.includes('ECONNRESET')) {
-            console.log(`[squeezr/cursor] H2 session error: ${e.message}`);
-        }
-    });
-    serverSession.on('stream', (clientStream, clientHeaders) => {
-        const path = clientHeaders[':path'] || '';
-        const method = clientHeaders[':method'] || 'POST';
-        const authority = clientHeaders[':authority'] || CURSOR_API_HOST;
-        console.log(`[squeezr/cursor] H2 stream: ${method} ${path}`);
-        const shouldIntercept = INTERCEPTED_PATHS.has(path);
-        // Open upstream HTTP/2 connection to real api2.cursor.sh
-        const upstreamSession = http2.connect(`https://${CURSOR_API_HOST}`, {
-            rejectUnauthorized: true,
-        });
-        upstreamSession.on('error', (err) => {
-            console.error(`[squeezr/cursor] upstream error: ${err.message}`);
-            try {
-                clientStream.close(http2.constants.NGHTTP2_INTERNAL_ERROR);
-            }
-            catch { }
-        });
-        // Forward headers (strip pseudo-headers, rebuild for upstream)
-        const upHeaders = {
-            ':method': method,
-            ':path': path,
-            ':authority': CURSOR_API_HOST,
-            ':scheme': 'https',
-        };
-        for (const [k, v] of Object.entries(clientHeaders)) {
-            if (k.startsWith(':'))
-                continue;
-            upHeaders[k] = v;
-        }
-        if (!shouldIntercept) {
-            // Non-chat path: transparent proxy
-            const upStream = upstreamSession.request(upHeaders);
-            clientStream.on('data', (chunk) => {
-                try {
-                    upStream.write(chunk);
-                }
-                catch { }
-            });
-            clientStream.on('end', () => {
-                try {
-                    upStream.end();
-                }
-                catch { }
-            });
-            upStream.on('response', (upRespHeaders) => {
-                const respHeaders = {};
-                for (const [k, v] of Object.entries(upRespHeaders)) {
-                    if (k === ':status')
-                        continue;
-                    respHeaders[k] = v;
-                }
-                clientStream.respond({
-                    ':status': upRespHeaders[':status'] ?? 200,
-                    ...respHeaders,
-                });
-            });
-            upStream.on('data', (chunk) => {
-                try {
-                    clientStream.write(chunk);
-                }
-                catch { }
-            });
-            upStream.on('end', () => {
-                try {
-                    clientStream.end();
-                }
-                catch { }
-            });
-            clientStream.on('error', () => { try {
-                upstreamSession.close();
-            }
-            catch { } });
-            upStream.on('error', () => { try {
-                clientStream.close();
-            }
-            catch { } });
-            return;
-        }
-        // ── Intercepted chat path: buffer request, compress, forward ────────────
-        let requestBuf = Buffer.alloc(0);
-        clientStream.on('data', (chunk) => {
-            requestBuf = Buffer.concat([requestBuf, chunk]);
-        });
-        clientStream.on('end', async () => {
-            cursorStats.requests++;
-            try {
-                // Parse ConnectRPC frame
-                const frame = parseConnectFrame(requestBuf);
-                if (!frame || frame.flag !== 0) {
-                    // Can't parse or gzip-compressed — pass through as-is
-                    forwardRaw(requestBuf, upHeaders, upstreamSession, clientStream);
-                    return;
-                }
-                // Extract conversation from protobuf
-                const { messages, otherFields } = extractConversation(frame.payload);
-                if (messages.length <= KEEP_RECENT + 1) {
-                    // Not enough messages to compress — pass through
-                    forwardRaw(requestBuf, upHeaders, upstreamSession, clientStream);
-                    return;
-                }
-                // Find messages to compress (all except the last KEEP_RECENT)
-                const compressibleCount = messages.length - KEEP_RECENT;
-                const compressibleMsgs = messages.slice(0, compressibleCount);
-                const totalChars = compressibleMsgs.reduce((sum, m) => sum + m.text.length, 0);
-                if (totalChars < COMPRESS_THRESHOLD) {
-                    forwardRaw(requestBuf, upHeaders, upstreamSession, clientStream);
-                    return;
-                }
-                // Extract bearer token and headers for compression call
-                const bearerToken = clientHeaders['authorization'] || '';
-                const fwdHeaders = {};
-                for (const [k, v] of Object.entries(clientHeaders)) {
-                    if (!k.startsWith(':'))
-                        fwdHeaders[k] = v;
-                }
-                // Try LLM compression first, fallback to deterministic
-                const textsToCompress = compressibleMsgs.map(m => m.text);
-                let compressedTexts;
-                if (bearerToken) {
-                    compressedTexts = await compressViaCursor(textsToCompress, bearerToken, fwdHeaders);
-                    // If LLM returned originals unchanged, fallback to deterministic
-                    const llmChanged = compressedTexts.length !== textsToCompress.length ||
-                        compressedTexts.some((t, i) => t !== textsToCompress[i]);
-                    if (!llmChanged) {
-                        compressedTexts = textsToCompress.map(deterministicCompress);
-                    }
-                }
-                else {
-                    compressedTexts = textsToCompress.map(deterministicCompress);
-                }
-                // Build map of compressed messages
-                const compressed = new Map();
-                if (compressedTexts.length === 1 && textsToCompress.length > 1) {
-                    // LLM returned a single summary — replace all compressible turns with one
-                    compressed.set(0, compressedTexts[0]);
-                    // Mark rest for removal by setting empty text
-                    for (let i = 1; i < compressibleCount; i++) {
-                        compressed.set(i, '');
-                    }
-                }
-                else {
-                    // Per-message compression (deterministic fallback)
-                    for (let i = 0; i < compressedTexts.length; i++) {
-                        if (compressedTexts[i] !== textsToCompress[i]) {
-                            compressed.set(i, compressedTexts[i]);
-                        }
-                    }
-                }
-                // Filter out empty messages
-                const filteredMessages = messages.filter((_, i) => !compressed.has(i) || compressed.get(i) !== '');
-                // Rebuild the protobuf
-                const newPayload = rebuildRequest(filteredMessages, otherFields, compressed);
-                const newFrame = buildConnectFrame(newPayload);
-                const charsSaved = totalChars - compressedTexts.join('').length;
-                if (charsSaved > 0) {
-                    cursorStats.compressed++;
-                    cursorStats.charsSaved += charsSaved;
-                    console.log(`[squeezr/cursor] Compressed: -${charsSaved} chars (${messages.length} msgs → ${filteredMessages.length})`);
-                }
-                // Forward compressed request
-                forwardRaw(newFrame, upHeaders, upstreamSession, clientStream);
-            }
-            catch (err) {
-                console.error(`[squeezr/cursor] compression error:`, err);
-                // Fallback: forward original
-                forwardRaw(requestBuf, upHeaders, upstreamSession, clientStream);
-            }
-        });
-    });
-    serverSession.on('error', () => { });
-}
-function forwardRaw(body, headers, upstreamSession, clientStream) {
-    // Update content-length
-    const upHeaders = { ...headers, 'content-length': String(body.length) };
-    const upStream = upstreamSession.request(upHeaders);
-    upStream.write(body);
-    upStream.end();
-    upStream.on('response', (upRespHeaders) => {
-        const respHeaders = {};
-        for (const [k, v] of Object.entries(upRespHeaders)) {
-            if (k === ':status')
-                continue;
-            respHeaders[k] = v;
-        }
-        try {
-            clientStream.respond({
-                ':status': upRespHeaders[':status'] ?? 200,
-                ...respHeaders,
-            });
-        }
-        catch { }
-    });
-    upStream.on('data', (chunk) => {
-        try {
-            clientStream.write(chunk);
-        }
-        catch { }
-    });
-    upStream.on('end', () => {
-        try {
-            clientStream.end();
-        }
-        catch { }
-    });
-    upStream.on('error', () => { try {
-        clientStream.close();
-    }
-    catch { } });
-    clientStream.on('error', () => { try {
-        upstreamSession.close();
-    }
-    catch { } });
-}
-// ── Local TLS server for MITM ────────────────────────────────────────────────
-const tlsServerCache = new Map();
-function getOrCreateTlsServer(hostname) {
-    const cached = tlsServerCache.get(hostname);
-    if (cached)
-        return Promise.resolve(cached.port);
-    return new Promise((resolve, reject) => {
-        const { key, cert } = getCert(hostname);
-        let tcpCount = 0;
-        let tlsCount = 0;
-        const server = tls.createServer({
-            key,
-            cert,
-            ALPNProtocols: ['h2', 'http/1.1'],
-        }, (socket) => {
-            tlsCount++;
-            const protocol = socket.alpnProtocol;
-            console.log(`[squeezr/cursor] TLS #${tlsCount} ALPN=${protocol} (${tcpCount} tcp total)`);
-            if (protocol === 'h2') {
-                handleCursorH2(socket, hostname);
-            }
-            else {
-                // HTTP/1.1 or no ALPN — transparent tunnel to real api2.cursor.sh (no MITM)
-                const upstream = tls.connect(443, hostname, { servername: hostname }, () => {
-                    socket.pipe(upstream);
-                    upstream.pipe(socket);
-                });
-                upstream.on('error', () => { try {
-                    socket.destroy();
-                }
-                catch { } });
-                socket.on('error', () => { try {
-                    upstream.destroy();
-                }
-                catch { } });
-            }
-        });
-        server.on('connection', () => { tcpCount++; });
-        server.on('tlsClientError', () => { }); // suppress idle connection errors
-        server.on('error', reject);
-        server.listen(0, '127.0.0.1', () => {
-            const addr = server.address();
-            tlsServerCache.set(hostname, { port: addr.port, server });
-            resolve(addr.port);
-        });
-    });
-}
-// ── CONNECT handler ──────────────────────────────────────────────────────────
-function handleConnect(req, clientSocket, _head) {
-    const [hostname, portStr] = (req.url ?? '').split(':');
-    const port = parseInt(portStr) || 443;
-    console.log(`[squeezr/cursor] CONNECT ${hostname}:${port}`);
-    // Only MITM api2.cursor.sh — everything else transparent tunnel
-    if (hostname !== CURSOR_API_HOST) {
-        const upstream = net.connect(port, hostname, () => {
-            clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
-            upstream.pipe(clientSocket);
-            clientSocket.pipe(upstream);
-        });
-        upstream.on('error', (e) => { console.log(`[squeezr/cursor] tunnel error ${hostname}: ${e.message}`); try {
-            clientSocket.destroy();
-        }
-        catch { } });
-        clientSocket.on('error', () => { try {
-            upstream.destroy();
-        }
-        catch { } });
-        return;
-    }
-    // MITM api2.cursor.sh — route through local TLS server
-    getOrCreateTlsServer(hostname).then((localPort) => {
-        clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
-        const local = net.connect(localPort, '127.0.0.1', () => {
-            clientSocket.pipe(local);
-            local.pipe(clientSocket);
-        });
-        local.on('error', () => { try {
-            clientSocket.destroy();
-        }
-        catch { } });
-        clientSocket.on('error', () => { try {
-            local.destroy();
-        }
-        catch { } });
-    }).catch(() => {
-        clientSocket.write('HTTP/1.1 502 Bad Gateway\r\n\r\n');
-        clientSocket.destroy();
-    });
-}
-// ── Plain HTTP handler ───────────────────────────────────────────────────────
-function handleHttp(req, res) {
-    res.writeHead(200, { 'content-type': 'application/json' });
-    res.end(JSON.stringify({ status: 'ok', type: 'cursor-mitm-proxy', stats: getCursorStats() }));
-}
-// ── Server lifecycle ─────────────────────────────────────────────────────────
-let cursorServer = null;
-const CURSOR_MITM_PORT = config.mitmPort + 1; // default: 8082
-export function getCursorMitmPort() { return CURSOR_MITM_PORT; }
-export function startCursorMitm() {
-    return new Promise((resolve, reject) => {
-        // Verify CA exists (codexMitm should have created it already)
-        if (!fs.existsSync(CA_KEY_PATH) || !fs.existsSync(CA_CERT_PATH)) {
-            console.error('[squeezr/cursor] CA not found. Run `squeezr setup` first.');
-            reject(new Error('CA not found'));
-            return;
-        }
-        cursorServer = http.createServer(handleHttp);
-        cursorServer.on('connect', handleConnect);
-        cursorServer.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                console.error(`[squeezr/cursor] Port ${CURSOR_MITM_PORT} in use`);
-                reject(err);
-            }
-            else {
-                console.error('[squeezr/cursor] error:', err.message);
-            }
-        });
-        cursorServer.listen(CURSOR_MITM_PORT, () => {
-            console.log(`[squeezr/cursor] MITM proxy on http://localhost:${CURSOR_MITM_PORT}`);
-            console.log(`[squeezr/cursor] Intercepting: ${CURSOR_API_HOST} (chat, composer, agent)`);
-            resolve();
-        });
-    });
-}
-export function stopCursorMitm() {
-    cursorServer?.close();
-    cursorServer = null;
-    for (const [, entry] of tlsServerCache) {
-        try {
-            entry.server.close();
-        }
-        catch { }
-    }
-    tlsServerCache.clear();
-}