antigravity-claude-proxy 2.7.3 → 2.7.5

package/README.md

@@ -1,3 +1,5 @@
+# ⚠️ DO NOT USE THIS ANYMORE – GOOGLE IS ISSUING TOS VIOLATION BANS FOR THE ACCOUNTS CONNECTED
+
 # Antigravity Claude Proxy
 
 [![npm version](https://img.shields.io/npm/v/antigravity-claude-proxy.svg)](https://www.npmjs.com/package/antigravity-claude-proxy)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.7.3",
+  "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/account-manager/credentials.js

@@ -235,7 +235,7 @@ export async function discoverProject(token, projectId = undefined) {
                     'Content-Type': 'application/json',
                     ...LOAD_CODE_ASSIST_HEADERS
                 },
-                body: JSON.stringify({ metadata })
+                body: JSON.stringify({ metadata, mode: 1 })
             });
 
             if (!response.ok) {

package/src/cloudcode/message-handler.js

@@ -139,7 +139,7 @@ export async function sendMessage(anthropicRequest, accountManager, fallbackEnab
             // Get token and project for this account
             const token = await accountManager.getTokenForAccount(account);
             const project = await accountManager.getProjectForAccount(account, token);
-            const payload = buildCloudCodeRequest(anthropicRequest, project);
+            const payload = buildCloudCodeRequest(anthropicRequest, project, account.email);
 
             logger.debug(`[CloudCode] Sending request for model: ${model}`);
 

package/src/cloudcode/model-api.js

@@ -49,12 +49,12 @@ export async function listModels(token) {
     const modelList = Object.entries(data.models)
         .filter(([modelId]) => isSupportedModel(modelId))
         .map(([modelId, modelData]) => ({
-        id: modelId,
-        object: 'model',
-        created: Math.floor(Date.now() / 1000),
-        owned_by: 'anthropic',
-        description: modelData.displayName || modelId
-    }));
+            id: modelId,
+            object: 'model',
+            created: Math.floor(Date.now() / 1000),
+            owned_by: 'anthropic',
+            description: modelData.displayName || modelId
+        }));
 
     // Warm the model validation cache
     modelCache.validModels = new Set(modelList.map(m => m.id));
@@ -183,10 +183,8 @@ export async function getSubscriptionTier(token) {
                 method: 'POST',
                 headers,
                 body: JSON.stringify({
-                    metadata: {
-                        ...CLIENT_METADATA,
-                        duetProject: 'rising-fact-p41fc'
-                    }
+                    metadata: CLIENT_METADATA,
+                    mode: 1
                 })
             });
 

package/src/cloudcode/request-builder.js

@@ -19,14 +19,15 @@ import { deriveSessionId } from './session-manager.js';
  *
  * @param {Object} anthropicRequest - The Anthropic-format request
  * @param {string} projectId - The project ID to use
+ * @param {string} accountEmail - The account email for session ID derivation
  * @returns {Object} The Cloud Code API request payload
  */
-export function buildCloudCodeRequest(anthropicRequest, projectId) {
+export function buildCloudCodeRequest(anthropicRequest, projectId, accountEmail) {
     const model = anthropicRequest.model;
     const googleRequest = convertAnthropicToGoogle(anthropicRequest);
 
     // Use stable session ID derived from first user message for cache continuity
-    googleRequest.sessionId = deriveSessionId(anthropicRequest);
+    googleRequest.sessionId = deriveSessionId(anthropicRequest, accountEmail);
 
     // Build system instruction parts array with [ignore] tags to prevent model from
     // identifying as "Antigravity" (fixes GitHub issue #76)

package/src/cloudcode/session-manager.js

@@ -8,40 +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
- * @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) {
-    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) {
-                // Hash the content with SHA256, return first 32 hex chars
-                const hash = crypto.createHash('sha256').update(content).digest('hex');
-                return hash.substring(0, 32);
-            }
-        }
+export function deriveSessionId(anthropicRequest, accountEmail) {
+    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

@@ -139,7 +139,7 @@ export async function* sendMessageStream(anthropicRequest, accountManager, fallb
             // Get token and project for this account
             const token = await accountManager.getTokenForAccount(account);
             const project = await accountManager.getProjectForAccount(account, token);
-            const payload = buildCloudCodeRequest(anthropicRequest, project);
+            const payload = buildCloudCodeRequest(anthropicRequest, project, account.email);
 
             logger.debug(`[CloudCode] Starting stream for model: ${model}`);
 

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}`;
@@ -40,24 +40,25 @@ function getPlatformUserAgent() {
 // Reference: Antigravity binary analysis - google.internal.cloud.code.v1internal.ClientMetadata.IdeType
 export const IDE_TYPE = {
     UNSPECIFIED: 0,
-    JETSKI: 5,         // Internal codename for Gemini CLI
-    ANTIGRAVITY: 6,
+    JETSKI: 10,        // Internal codename for Gemini CLI
+    ANTIGRAVITY: 9,
     PLUGINS: 7
 };
 
-// Platform enum
-// Reference: Antigravity binary analysis - google.internal.cloud.code.v1internal.ClientMetadata.Platform
+// Platform enum (as specified in Antigravity binary)
 export const PLATFORM = {
     UNSPECIFIED: 0,
-    WINDOWS: 1,
-    LINUX: 2,
-    MACOS: 3
+    DARWIN_AMD64: 1,
+    DARWIN_ARM64: 2,
+    LINUX_AMD64: 3,
+    LINUX_ARM64: 4,
+    WINDOWS_AMD64: 5
 };
 
-// Plugin type enum
+// Plugin type enum (as specified in Antigravity binary)
 export const PLUGIN_TYPE = {
     UNSPECIFIED: 0,
-    DUET_AI: 1,
+    CLOUD_CODE: 1,
     GEMINI: 2
 };
 
@@ -66,12 +67,17 @@ export const PLUGIN_TYPE = {
  * @returns {number} Platform enum value
  */
 function getPlatformEnum() {
-    switch (platform()) {
-        case 'darwin': return PLATFORM.MACOS;
-        case 'win32': return PLATFORM.WINDOWS;
-        case 'linux': return PLATFORM.LINUX;
-        default: return PLATFORM.UNSPECIFIED;
+    const os = platform();
+    const architecture = arch();
+
+    if (os === 'darwin') {
+        return architecture === 'arm64' ? PLATFORM.DARWIN_ARM64 : PLATFORM.DARWIN_AMD64;
+    } else if (os === 'linux') {
+        return architecture === 'arm64' ? PLATFORM.LINUX_ARM64 : PLATFORM.LINUX_AMD64;
+    } else if (os === 'win32') {
+        return PLATFORM.WINDOWS_AMD64;
     }
+    return PLATFORM.UNSPECIFIED;
 }
 
 // Centralized client metadata (used in request bodies for loadCodeAssist, onboardUser, etc.)
@@ -93,10 +99,11 @@ export const ANTIGRAVITY_ENDPOINT_FALLBACKS = [
 ];
 
 // Required headers for Antigravity API requests
+// Headers for general Antigravity API requests
+// Strictly matches the generic 'u' method in main.js
 export const ANTIGRAVITY_HEADERS = {
     'User-Agent': getPlatformUserAgent(),
-    'X-Goog-Api-Client': 'google-cloud-sdk vscode_cloudshelleditor/0.1',
-    'Client-Metadata': JSON.stringify(CLIENT_METADATA)
+    'Content-Type': 'application/json'
 };
 
 // Endpoint order for loadCodeAssist (prod first)
@@ -110,6 +117,7 @@ export const LOAD_CODE_ASSIST_ENDPOINTS = [
 export const ONBOARD_USER_ENDPOINTS = ANTIGRAVITY_ENDPOINT_FALLBACKS;
 
 // Headers for loadCodeAssist API
+// Matches the minimal headers seen in the binary's u() method
 export const LOAD_CODE_ASSIST_HEADERS = ANTIGRAVITY_HEADERS;
 
 // Default project ID if none can be discovered

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