antigravity-claude-proxy 2.7.4 → 2.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",
@@ -63,7 +63,8 @@
     "better-sqlite3": "^12.5.0",
     "cors": "^2.8.5",
     "express": "^4.18.2",
-    "undici": "^7.20.0"
+    "undici": "^7.20.0",
+    "wreq-js": "^2.0.1"
   },
   "devDependencies": {
     "@tailwindcss/forms": "^0.5.7",

package/src/cloudcode/session-manager.js

@@ -8,46 +8,59 @@
 
 import crypto from 'crypto';
 
+
+// Runtime storage for session IDs (per account)
+// This mimics the behavior of the binary which generates a session ID at startup
+// and keeps it for the process lifetime.
+// Key: accountEmail, Value: sessionId
+const runtimeSessionStore = new Map();
+
 /**
- * Derive a stable session ID from the first user message in the conversation.
- * This ensures the same conversation uses the same session ID across turns,
- * enabling prompt caching (cache is scoped to session + organization).
+ * Get or create a session ID for the given account.
+ * 
+ * The binary generates a session ID once at startup: `p.sessionID = rs() + Date.now()`.
+ * Since our proxy is long-running, we simulate this "per-launch" behavior by storing
+ * a generated ID in memory for each account.
  *
- * @param {Object} anthropicRequest - The Anthropic-format request
- * @param {string} accountEmail - The account email to make session IDs unique per account
- * @returns {string} A stable session ID (32 hex characters) or random UUID if no user message
+ * - If the proxy restarts, the ID changes (matching binary/VS Code restart behavior).
+ * - Within a running proxy instance, the ID is stable for that account.
+ * - This enables prompt caching while using the EXACT random logic of the binary.
+ *
+ * @param {Object} anthropicRequest - The Anthropic-format request (unused for ID generation now)
+ * @param {string} accountEmail - The account email to scope the session ID
+ * @returns {string} A stable session ID string matching binary format
  */
 export function deriveSessionId(anthropicRequest, accountEmail) {
-    const messages = anthropicRequest.messages || [];
-
-    // Find the first user message
-    for (const msg of messages) {
-        if (msg.role === 'user') {
-            let content = '';
-
-            if (typeof msg.content === 'string') {
-                content = msg.content;
-            } else if (Array.isArray(msg.content)) {
-                // Extract text from content blocks
-                content = msg.content
-                    .filter(block => block.type === 'text' && block.text)
-                    .map(block => block.text)
-                    .join('\n');
-            }
-
-            if (content) {
-                // Include account email in the content to be hashed to ensure 
-                // unique session IDs per account for the same conversation.
-                // This prevents Google from correlating sessions across accounts.
-                const saltedContent = accountEmail ? `${accountEmail}:${content}` : content;
-
-                // Hash the content with SHA256, return first 32 hex chars
-                const hash = crypto.createHash('sha256').update(saltedContent).digest('hex');
-                return hash.substring(0, 32);
-            }
-        }
+    if (!accountEmail) {
+        // Fallback for requests without an account (should differ every time)
+        return generateBinaryStyleId();
+    }
+
+    // Check if we already have a session ID for this account in this process run
+    if (runtimeSessionStore.has(accountEmail)) {
+        return runtimeSessionStore.get(accountEmail);
     }
 
-    // Fallback to random UUID if no user message found
-    return crypto.randomUUID();
+    // Generate a new ID using the binary's exact logic
+    const newSessionId = generateBinaryStyleId();
+
+    // Store it for future requests from this account
+    runtimeSessionStore.set(accountEmail, newSessionId);
+
+    return newSessionId;
+}
+
+/**
+ * Generate a Session ID using the binary's exact logic.
+ * logic: `rs() + Date.now()` where `rs()` is randomUUID
+ */
+function generateBinaryStyleId() {
+    return crypto.randomUUID() + Date.now().toString();
+}
+
+/**
+ * Clears all session IDs (e.g. useful for testing or explicit reset)
+ */
+export function clearSessionStore() {
+    runtimeSessionStore.clear();
 }

package/src/constants.js

@@ -30,7 +30,7 @@ function getAntigravityDbPath() {
  * Generate platform-specific User-Agent string.
  * @returns {string} User-Agent in format "antigravity/version os/arch"
  */
-function getPlatformUserAgent() {
+export function getPlatformUserAgent() {
     const os = platform();
     const architecture = arch();
     return `antigravity/1.16.5 ${os}/${architecture}`;

package/src/index.js

@@ -12,6 +12,7 @@ import { logger } from './utils/logger.js';
 import { config } from './config.js';
 import { getStrategyLabel, STRATEGY_NAMES, DEFAULT_STRATEGY } from './account-manager/strategies/index.js';
 import { getPackageVersion } from './utils/helpers.js';
+import tlsClient from './utils/tls-client.js';
 import path from 'path';
 import os from 'os';
 
@@ -159,8 +160,15 @@ ${environmentSection}
 });
 
 // Graceful shutdown
-const shutdown = () => {
+const shutdown = async () => {
     logger.info('Shutting down server...');
+
+    try {
+        await tlsClient.exit();
+    } catch (err) {
+        logger.error('Error shutting down TLS client:', err);
+    }
+
     server.close(() => {
         logger.success('Server stopped');
         process.exit(0);

package/src/utils/helpers.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import path from 'path';
 import { config } from '../config.js';
+import tlsClient from './tls-client.js';
 
 /**
  * Shared Utility Functions
@@ -86,7 +87,7 @@ export async function throttledFetch(url, options) {
             await sleep(delayMs);
         }
     }
-    return fetch(url, options);
+    return tlsClient.fetch(url, options);
 }
 
 /**

package/src/utils/tls-client.js

@@ -0,0 +1,102 @@
+import { createRequire } from 'module';
+import { Readable } from 'stream';
+import { getPlatformUserAgent } from '../constants.js';
+
+const require = createRequire(import.meta.url);
+const { createSession } = require('wreq-js');
+
+class TlsClient {
+    constructor() {
+        this.userAgent = getPlatformUserAgent();
+        this.session = null;
+    }
+
+    async getSession() {
+        if (this.session) return this.session;
+        this.session = await createSession({
+            browser: 'chrome_124',
+            os: 'macos',
+            userAgent: this.userAgent
+        });
+        return this.session;
+    }
+
+    async fetch(url, options = {}) {
+        const session = await this.getSession();
+        const method = (options.method || 'GET').toUpperCase();
+
+        const wreqOptions = {
+            method,
+            headers: options.headers,
+            body: options.body,
+            redirect: options.redirect === 'manual' ? 'manual' : 'follow',
+        };
+
+        try {
+            const response = await session.fetch(url, wreqOptions);
+            return new ResponseWrapper(response);
+        } catch (error) {
+            console.error('wreq-js fetch failed:', error);
+            throw error;
+        }
+    }
+
+    async exit() {
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}
+
+class ResponseWrapper {
+    constructor(wreqResponse) {
+        this.status = wreqResponse.status;
+        this.statusText = wreqResponse.statusText || (this.status === 200 ? 'OK' : `Status ${this.status}`);
+        this.headers = new Headers(wreqResponse.headers);
+        this.url = wreqResponse.url;
+        this.ok = this.status >= 200 && this.status < 300;
+
+        if (wreqResponse.body) {
+            if (typeof wreqResponse.body.getReader === 'function') {
+                this.body = wreqResponse.body;
+            } else {
+                this.body = Readable.toWeb(wreqResponse.body);
+            }
+        } else {
+            this.body = null;
+        }
+    }
+
+    async text() {
+        if (!this.body) return '';
+        const reader = this.body.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            chunks.push(typeof value === 'string' ? Buffer.from(value) : value);
+        }
+        return Buffer.concat(chunks).toString('utf8');
+    }
+
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+}
+
+class Headers {
+    constructor(headersObj = {}) {
+        this.map = new Map();
+        for (const [key, value] of Object.entries(headersObj)) {
+            this.map.set(key.toLowerCase(), Array.isArray(value) ? value.join(', ') : value);
+        }
+    }
+
+    get(name) { return this.map.get(name.toLowerCase()) || null; }
+    has(name) { return this.map.has(name.toLowerCase()); }
+    forEach(callback) { this.map.forEach(callback); }
+}
+
+export default new TlsClient();