feat: Implement intelligent Antigravity version detection and dynamic User-Agent generation with platform-specific logic and tests.

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.
@@ -31,9 +32,7 @@ function getAntigravityDbPath() {
  * @returns {string} User-Agent in format "antigravity/version os/arch"
  */
 export function getPlatformUserAgent() {
-    const os = platform();
-    const architecture = arch();
-    return `antigravity/1.16.5 ${os}/${architecture}`;
+    return generateSmartUserAgent();
 }
 
 // IDE Type enum (numeric values as expected by Cloud Code API)

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;
+}
+

tests/run-all.cjs

@@ -23,7 +23,8 @@ const tests = [
     { name: 'Schema Sanitizer', file: 'test-schema-sanitizer.cjs' },
     { name: 'Streaming Whitespace', file: 'test-streaming-whitespace.cjs' },
     { name: '403 Account Rotation (Unit)', file: 'test-403-account-rotation.cjs' },
-    { name: '403 Account Rotation (Integration)', file: 'test-403-integration.cjs' }
+    { name: '403 Account Rotation (Integration)', file: 'test-403-integration.cjs' },
+    { name: 'Version Detection', file: 'test-version-detection.js' }
 ];
 
 async function runTest(test) {

tests/test-version-detection.js

@@ -0,0 +1,27 @@
+import { generateSmartUserAgent } from '../src/utils/version-detector.js';
+import { getPlatformUserAgent } from '../src/constants.js';
+import assert from 'assert';
+
+async function testVersionDetection() {
+    console.log('--- Testing Version Detection ---');
+
+    // 1. Check User-Agent generation
+    const ua = generateSmartUserAgent();
+    console.log('Generated User-Agent:', ua);
+
+    assert.ok(ua.startsWith('antigravity/'), 'UA should start with antigravity/');
+    assert.ok(/\d+\.\d+\.\d+/.test(ua), 'UA should contain a version number');
+
+    // 2. Check integration in constants.js
+    const constantsUA = getPlatformUserAgent();
+    console.log('Constants User-Agent:', constantsUA);
+    assert.strictEqual(ua, constantsUA, 'Constants UA should match generated UA');
+
+    console.log('\n✓ Version detection tests passed!');
+}
+
+testVersionDetection().catch(err => {
+    console.error('\n✗ Version detection tests failed:');
+    console.error(err);
+    process.exit(1);
+});