antigravity-claude-proxy 1.2.7 → 1.2.8

package/README.md

@@ -400,4 +400,4 @@ MIT
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=badri-s2001/antigravity-claude-proxy&type=date&legend=top-left&cache-control=no-cache)](https://www.star-history.com/#badri-s2001/antigravity-claude-proxy&type=date&legend=top-left)
+[![Star History Chart](https://api.star-history.com/svg?repos=badrisnarayanan/antigravity-claude-proxy&type=date&legend=top-left&cache-control=no-cache)](https://www.star-history.com/#badrisnarayanan/antigravity-claude-proxy&type=date&legend=top-left)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",

package/src/auth/database.js

@@ -6,10 +6,80 @@
  * - Windows compatibility (no CLI dependency)
  * - Native performance
  * - Synchronous API (simple error handling)
+ *
+ * Includes auto-rebuild capability for handling Node.js version updates
+ * that cause native module incompatibility.
  */
 
-import Database from 'better-sqlite3';
+import { createRequire } from 'module';
 import { ANTIGRAVITY_DB_PATH } from '../constants.js';
+import { isModuleVersionError, attemptAutoRebuild, clearRequireCache } from '../utils/native-module-helper.js';
+import { logger } from '../utils/logger.js';
+import { NativeModuleError } from '../errors.js';
+
+const require = createRequire(import.meta.url);
+
+// Lazy-loaded Database constructor
+let Database = null;
+let moduleLoadError = null;
+
+/**
+ * Load the better-sqlite3 module with auto-rebuild on version mismatch
+ * Uses synchronous require to maintain API compatibility
+ * @returns {Function} The Database constructor
+ * @throws {Error} If module cannot be loaded even after rebuild
+ */
+function loadDatabaseModule() {
+    // Return cached module if already loaded
+    if (Database) return Database;
+
+    // Re-throw cached error if previous load failed permanently
+    if (moduleLoadError) throw moduleLoadError;
+
+    try {
+        Database = require('better-sqlite3');
+        return Database;
+    } catch (error) {
+        if (isModuleVersionError(error)) {
+            logger.warn('[Database] Native module version mismatch detected');
+
+            if (attemptAutoRebuild(error)) {
+                // Clear require cache and retry
+                try {
+                    const resolvedPath = require.resolve('better-sqlite3');
+                    // Clear the module and all its dependencies from cache
+                    clearRequireCache(resolvedPath, require.cache);
+
+                    Database = require('better-sqlite3');
+                    logger.success('[Database] Module reloaded successfully after rebuild');
+                    return Database;
+                } catch (retryError) {
+                    // Rebuild succeeded but reload failed - user needs to restart
+                    moduleLoadError = new NativeModuleError(
+                        'Native module rebuild completed. Please restart the server to apply the fix.',
+                        true,  // rebuildSucceeded
+                        true   // restartRequired
+                    );
+                    logger.info('[Database] Rebuild succeeded - server restart required');
+                    throw moduleLoadError;
+                }
+            } else {
+                moduleLoadError = new NativeModuleError(
+                    'Failed to auto-rebuild native module. Please run manually:\n' +
+                    '  npm rebuild better-sqlite3\n' +
+                    'Or if using npx, find the package location in the error and run:\n' +
+                    '  cd /path/to/better-sqlite3 && npm rebuild',
+                    false,  // rebuildSucceeded
+                    false   // restartRequired
+                );
+                throw moduleLoadError;
+            }
+        }
+
+        // Non-version-mismatch error, just throw it
+        throw error;
+    }
+}
 
 /**
  * Query Antigravity database for authentication status
@@ -18,10 +88,11 @@ import { ANTIGRAVITY_DB_PATH } from '../constants.js';
  * @throws {Error} If database doesn't exist, query fails, or no auth status found
  */
 export function getAuthStatus(dbPath = ANTIGRAVITY_DB_PATH) {
+    const Db = loadDatabaseModule();
     let db;
     try {
         // Open database in read-only mode
-        db = new Database(dbPath, {
+        db = new Db(dbPath, {
             readonly: true,
             fileMustExist: true
         });
@@ -56,6 +127,10 @@ export function getAuthStatus(dbPath = ANTIGRAVITY_DB_PATH) {
         if (error.message.includes('No auth status') || error.message.includes('missing apiKey')) {
             throw error;
         }
+        // Re-throw native module errors from loadDatabaseModule without wrapping
+        if (error instanceof NativeModuleError) {
+            throw error;
+        }
         throw new Error(`Failed to read Antigravity database: ${error.message}`);
     } finally {
         // Always close database connection
@@ -73,7 +148,8 @@ export function getAuthStatus(dbPath = ANTIGRAVITY_DB_PATH) {
 export function isDatabaseAccessible(dbPath = ANTIGRAVITY_DB_PATH) {
     let db;
     try {
-        db = new Database(dbPath, {
+        const Db = loadDatabaseModule();
+        db = new Db(dbPath, {
             readonly: true,
             fileMustExist: true
         });

package/src/auth/oauth.js

@@ -131,10 +131,10 @@ export function startCallbackServer(expectedState, timeoutMs = 120000) {
             const error = url.searchParams.get('error');
 
             if (error) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
                 res.end(`
                     <html>
-                    <head><title>Authentication Failed</title></head>
+                    <head><meta charset="UTF-8"><title>Authentication Failed</title></head>
                     <body style="font-family: system-ui; padding: 40px; text-align: center;">
                         <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
                         <p>Error: ${error}</p>
@@ -148,10 +148,10 @@ export function startCallbackServer(expectedState, timeoutMs = 120000) {
             }
 
             if (state !== expectedState) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
                 res.end(`
                     <html>
-                    <head><title>Authentication Failed</title></head>
+                    <head><meta charset="UTF-8"><title>Authentication Failed</title></head>
                     <body style="font-family: system-ui; padding: 40px; text-align: center;">
                         <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
                         <p>State mismatch - possible CSRF attack.</p>
@@ -165,10 +165,10 @@ export function startCallbackServer(expectedState, timeoutMs = 120000) {
             }
 
             if (!code) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
                 res.end(`
                     <html>
-                    <head><title>Authentication Failed</title></head>
+                    <head><meta charset="UTF-8"><title>Authentication Failed</title></head>
                     <body style="font-family: system-ui; padding: 40px; text-align: center;">
                         <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
                         <p>No authorization code received.</p>
@@ -182,10 +182,10 @@ export function startCallbackServer(expectedState, timeoutMs = 120000) {
             }
 
             // Success!
-            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
             res.end(`
                 <html>
-                <head><title>Authentication Successful</title></head>
+                <head><meta charset="UTF-8"><title>Authentication Successful</title></head>
                 <body style="font-family: system-ui; padding: 40px; text-align: center;">
                     <h1 style="color: #28a745;">✅ Authentication Successful!</h1>
                     <p>You can close this window and return to the terminal.</p>

package/src/constants.js

@@ -74,7 +74,7 @@ export const ACCOUNT_CONFIG_PATH = join(
 // Uses platform-specific path detection
 export const ANTIGRAVITY_DB_PATH = getAntigravityDbPath();
 
-export const DEFAULT_COOLDOWN_MS = 60 * 1000; // 1 minute default cooldown
+export const DEFAULT_COOLDOWN_MS = 10 * 1000; // 10 second default cooldown
 export const MAX_RETRIES = 5; // Max retry attempts across accounts
 export const MAX_ACCOUNTS = 10; // Maximum number of accounts allowed
 

package/src/errors.js

@@ -118,6 +118,23 @@ export class ApiError extends AntigravityError {
     }
 }
 
+/**
+ * Native module error (version mismatch, rebuild required)
+ */
+export class NativeModuleError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {boolean} rebuildSucceeded - Whether auto-rebuild succeeded
+     * @param {boolean} restartRequired - Whether server restart is needed
+     */
+    constructor(message, rebuildSucceeded = false, restartRequired = false) {
+        super(message, 'NATIVE_MODULE_ERROR', false, { rebuildSucceeded, restartRequired });
+        this.name = 'NativeModuleError';
+        this.rebuildSucceeded = rebuildSucceeded;
+        this.restartRequired = restartRequired;
+    }
+}
+
 /**
  * Check if an error is a rate limit error
  * Works with both custom error classes and legacy string-based errors
@@ -154,6 +171,7 @@ export default {
     NoAccountsError,
     MaxRetriesError,
     ApiError,
+    NativeModuleError,
     isRateLimitError,
     isAuthError
 };

package/src/utils/native-module-helper.js

@@ -0,0 +1,162 @@
+/**
+ * Native Module Helper
+ * Detects and auto-rebuilds native Node.js modules when they become
+ * incompatible after a Node.js version update.
+ */
+
+import { execSync } from 'child_process';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { logger } from './logger.js';
+
+/**
+ * Check if an error is a NODE_MODULE_VERSION mismatch error
+ * @param {Error} error - The error to check
+ * @returns {boolean} True if it's a version mismatch error
+ */
+export function isModuleVersionError(error) {
+    const message = error?.message || '';
+    return message.includes('NODE_MODULE_VERSION') &&
+           message.includes('was compiled against a different Node.js version');
+}
+
+/**
+ * Extract the module path from a NODE_MODULE_VERSION error message
+ * @param {Error} error - The error containing the module path
+ * @returns {string|null} The path to the .node file, or null if not found
+ */
+export function extractModulePath(error) {
+    const message = error?.message || '';
+    // Match pattern like: "The module '/path/to/module.node'"
+    const match = message.match(/The module '([^']+\.node)'/);
+    return match ? match[1] : null;
+}
+
+/**
+ * Find the package root directory from a .node file path
+ * @param {string} nodeFilePath - Path to the .node file
+ * @returns {string|null} Path to the package root, or null if not found
+ */
+export function findPackageRoot(nodeFilePath) {
+    // Walk up from the .node file to find package.json
+    let dir = dirname(nodeFilePath);
+    while (dir) {
+        const packageJsonPath = join(dir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            return dir;
+        }
+        const parentDir = dirname(dir);
+        // Stop when we've reached the filesystem root (dirname returns same path)
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
+    }
+    return null;
+}
+
+/**
+ * Attempt to rebuild a native module
+ * @param {string} packagePath - Path to the package root directory
+ * @returns {boolean} True if rebuild succeeded, false otherwise
+ */
+export function rebuildModule(packagePath) {
+    try {
+        logger.info(`[NativeModule] Rebuilding native module at: ${packagePath}`);
+
+        // Run npm rebuild in the package directory
+        const output = execSync('npm rebuild', {
+            cwd: packagePath,
+            stdio: 'pipe', // Capture output instead of printing
+            timeout: 120000 // 2 minute timeout
+        });
+
+        // Log rebuild output for debugging
+        const outputStr = output?.toString().trim();
+        if (outputStr) {
+            logger.debug(`[NativeModule] Rebuild output:\n${outputStr}`);
+        }
+
+        logger.success('[NativeModule] Rebuild completed successfully');
+        return true;
+    } catch (error) {
+        // Include stdout/stderr from the failed command for troubleshooting
+        const stdout = error.stdout?.toString().trim();
+        const stderr = error.stderr?.toString().trim();
+        let errorDetails = `[NativeModule] Rebuild failed: ${error.message}`;
+        if (stdout) {
+            errorDetails += `\n[NativeModule] stdout: ${stdout}`;
+        }
+        if (stderr) {
+            errorDetails += `\n[NativeModule] stderr: ${stderr}`;
+        }
+        logger.error(errorDetails);
+        return false;
+    }
+}
+
+/**
+ * Attempt to auto-rebuild a native module from an error
+ * @param {Error} error - The NODE_MODULE_VERSION error
+ * @returns {boolean} True if rebuild succeeded, false otherwise
+ */
+export function attemptAutoRebuild(error) {
+    const nodePath = extractModulePath(error);
+    if (!nodePath) {
+        logger.error('[NativeModule] Could not extract module path from error');
+        return false;
+    }
+
+    const packagePath = findPackageRoot(nodePath);
+    if (!packagePath) {
+        logger.error('[NativeModule] Could not find package root');
+        return false;
+    }
+
+    logger.warn('[NativeModule] Native module version mismatch detected');
+    logger.info('[NativeModule] Attempting automatic rebuild...');
+
+    return rebuildModule(packagePath);
+}
+
+/**
+ * Recursively clear a module and its dependencies from the require cache
+ * This is needed after rebuilding a native module to force re-import
+ * @param {string} modulePath - Resolved path to the module
+ * @param {object} cache - The require.cache object
+ * @param {Set} [visited] - Set of already-visited paths to prevent cycles
+ */
+export function clearRequireCache(modulePath, cache, visited = new Set()) {
+    if (visited.has(modulePath)) return;
+    visited.add(modulePath);
+
+    const mod = cache[modulePath];
+    if (!mod) return;
+
+    // Recursively clear children first
+    if (mod.children) {
+        for (const child of mod.children) {
+            clearRequireCache(child.id, cache, visited);
+        }
+    }
+
+    // Remove from parent's children array
+    if (mod.parent && mod.parent.children) {
+        const idx = mod.parent.children.indexOf(mod);
+        if (idx !== -1) {
+            mod.parent.children.splice(idx, 1);
+        }
+    }
+
+    // Delete from cache
+    delete cache[modulePath];
+}
+
+export default {
+    isModuleVersionError,
+    extractModulePath,
+    findPackageRoot,
+    rebuildModule,
+    attemptAutoRebuild,
+    clearRequireCache
+};