antigravity-claude-proxy 2.7.4 → 2.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.7.4",
+  "version": "2.7.6",
   "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/message-handler.js

@@ -157,7 +157,7 @@ export async function sendMessage(anthropicRequest, accountManager, fallbackEnab
 
                     const response = await throttledFetch(url, {
                         method: 'POST',
-                        headers: buildHeaders(token, model, isThinking ? 'text/event-stream' : 'application/json'),
+                        headers: buildHeaders(token, model, isThinking ? 'text/event-stream' : 'application/json', payload.request.sessionId),
                         body: JSON.stringify(payload)
                     });
 

package/src/cloudcode/request-builder.js

@@ -70,15 +70,21 @@ export function buildCloudCodeRequest(anthropicRequest, projectId, accountEmail)
  * @param {string} token - OAuth access token
  * @param {string} model - Model name
  * @param {string} accept - Accept header value (default: 'application/json')
+ * @param {string} [sessionId] - Optional session ID for X-Machine-Session-Id header
  * @returns {Object} Headers object
  */
-export function buildHeaders(token, model, accept = 'application/json') {
+export function buildHeaders(token, model, accept = 'application/json', sessionId) {
     const headers = {
         'Authorization': `Bearer ${token}`,
         'Content-Type': 'application/json',
         ...ANTIGRAVITY_HEADERS
     };
 
+    // Add session ID header if provided (matches Antigravity binary behavior)
+    if (sessionId) {
+        headers['X-Machine-Session-Id'] = sessionId;
+    }
+
     const modelFamily = getModelFamily(model);
 
     // Add interleaved thinking header only for Claude thinking models

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/cloudcode/streaming-handler.js

@@ -155,7 +155,7 @@ export async function* sendMessageStream(anthropicRequest, accountManager, fallb
 
                     const response = await throttledFetch(url, {
                         method: 'POST',
-                        headers: buildHeaders(token, model, 'text/event-stream'),
+                        headers: buildHeaders(token, model, 'text/event-stream', payload.request.sessionId),
                         body: JSON.stringify(payload)
                     });
 
@@ -336,7 +336,7 @@ export async function* sendMessageStream(anthropicRequest, accountManager, fallb
                             // Refetch the response
                             currentResponse = await throttledFetch(url, {
                                 method: 'POST',
-                                headers: buildHeaders(token, model, 'text/event-stream'),
+                                headers: buildHeaders(token, model, 'text/event-stream', payload.request.sessionId),
                                 body: JSON.stringify(payload)
                             });
 

package/src/constants.js

@@ -6,6 +6,7 @@
 import { homedir, platform, arch } from 'os';
 import { join } from 'path';
 import { config } from './config.js';
+import { generateSmartUserAgent } from './utils/version-detector.js';
 
 /**
  * Get the Antigravity database path based on the current platform.
@@ -30,10 +31,8 @@ function getAntigravityDbPath() {
  * Generate platform-specific User-Agent string.
  * @returns {string} User-Agent in format "antigravity/version os/arch"
  */
-function getPlatformUserAgent() {
-    const os = platform();
-    const architecture = arch();
-    return `antigravity/1.16.5 ${os}/${architecture}`;
+export function getPlatformUserAgent() {
+    return generateSmartUserAgent();
 }
 
 // IDE Type enum (numeric values as expected by Cloud Code API)
@@ -103,7 +102,10 @@ export const ANTIGRAVITY_ENDPOINT_FALLBACKS = [
 // Strictly matches the generic 'u' method in main.js
 export const ANTIGRAVITY_HEADERS = {
     'User-Agent': getPlatformUserAgent(),
-    'Content-Type': 'application/json'
+    'Content-Type': 'application/json',
+    'X-Client-Name': 'antigravity',
+    'X-Client-Version': '1.107.0', // Match product.json version
+    'x-goog-api-client': 'gl-node/18.18.2 fire/0.8.6 grpc/1.10.x' // Simulate Google Node.js client environment
 };
 
 // Endpoint order for loadCodeAssist (prod first)

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();

package/src/utils/version-detector.js

@@ -0,0 +1,134 @@
+import { execSync } from 'child_process';
+import { platform, homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * Intelligent Version Detection for Antigravity
+ * Attempts to find the local installation and extract its version.
+ * Falls back to hard-coded stable versions if detection fails.
+ */
+
+// Fallback constant
+const FALLBACK_ANTIGRAVITY_VERSION = '1.16.5';
+
+// Cache for the generated User-Agent string
+let cachedUserAgent = null;
+
+/**
+ * Compares two semver-ish version strings (X.Y.Z).
+ * @param {string} v1 - Version string 1
+ * @param {string} v2 - Version string 2
+ * @returns {boolean} True if v1 > v2
+ */
+function isVersionHigher(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 > p2) return true;
+        if (p1 < p2) return false;
+    }
+    return false;
+}
+
+/**
+ * Gets the version config (version, source)
+ * @returns {{ version: string, source: string }}
+ */
+function getVersionConfig() {
+    const os = platform();
+    let detectedVersion = null;
+    let finalVersion = FALLBACK_ANTIGRAVITY_VERSION;
+    let source = 'fallback';
+
+    try {
+        if (os === 'darwin') {
+            detectedVersion = getVersionMacos();
+        } else if (os === 'win32') {
+            detectedVersion = getVersionWindows();
+        }
+    } catch (error) {
+        // Silently fail and use fallback
+    }
+
+    // Only use detected version if it's higher than the fallback version
+    if (detectedVersion && isVersionHigher(detectedVersion, FALLBACK_ANTIGRAVITY_VERSION)) {
+        finalVersion = detectedVersion;
+        source = 'local';
+    }
+
+    return {
+        version: finalVersion,
+        source
+    };
+}
+
+/**
+ * Generate a simplified User-Agent string used by the Antigravity binary.
+ * Format: "antigravity/version os/arch"
+ * @returns {string} The User-Agent string
+ */
+export function generateSmartUserAgent() {
+    if (cachedUserAgent) return cachedUserAgent;
+
+    const { version } = getVersionConfig();
+    const os = platform();
+    const architecture = process.arch;
+
+    // Map Node.js platform names to binary-friendly names
+    const osName = os === 'darwin' ? 'darwin' : (os === 'win32' ? 'win32' : 'linux');
+
+    cachedUserAgent = `antigravity/${version} ${osName}/${architecture}`;
+    return cachedUserAgent;
+}
+
+/**
+ * MacOS-specific version detection using plutil
+ */
+function getVersionMacos() {
+    const appPath = '/Applications/Antigravity.app';
+    const plistPath = join(appPath, 'Contents/Info.plist');
+
+    if (!existsSync(plistPath)) return null;
+
+    try {
+        const version = execSync(`plutil -extract CFBundleShortVersionString raw "${plistPath}"`, { encoding: 'utf8' }).trim();
+        if (/^\d+\.\d+\.\d+/.test(version)) {
+            return version;
+        }
+    } catch (e) {
+        // plutil failed or file not found
+    }
+    return null;
+}
+
+/**
+ * Windows-specific version detection using PowerShell
+ */
+function getVersionWindows() {
+    try {
+        const localAppData = process.env.LOCALAPPDATA;
+        const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+
+        const possiblePaths = [
+            join(localAppData, 'Programs', 'Antigravity', 'Antigravity.exe'),
+            join(programFiles, 'Antigravity', 'Antigravity.exe')
+        ];
+
+        for (const exePath of possiblePaths) {
+            if (existsSync(exePath)) {
+                const cmd = `powershell -Command "(Get-Item '${exePath}').VersionInfo.FileVersion"`;
+                const version = execSync(cmd, { encoding: 'utf8' }).trim();
+                const match = version.match(/^(\d+\.\d+\.\d+)/);
+                if (match) return match[1];
+            }
+        }
+    } catch (e) {
+        // PowerShell or path issues
+    }
+    return null;
+}
+