vibecodingmachine-cli 2025.12.1-534 → 2025.12.22-2230

package/src/utils/antigravity-installer.js

@@ -0,0 +1,212 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const ora = require('ora');
+const chalk = require('chalk');
+
+async function installAntigravity() {
+  console.log(chalk.cyan('\n🚀 Initiating Google Antigravity IDE Installation...'));
+
+  const spinner = ora('Checking system requirements...').start();
+  await new Promise((r) => setTimeout(r, 800));
+
+  if (os.platform() !== 'darwin') {
+    spinner.fail('Automated Antigravity installation is only supported on macOS');
+    return false;
+  }
+
+  const arch = os.arch();
+  const isArm = arch === 'arm64';
+
+  // URLs from electron-app IDE installer
+  const downloadUrl = isArm
+    ? 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-arm/Antigravity.dmg'
+    : 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-x64/Antigravity.dmg';
+
+  spinner.succeed(`System OK (${isArm ? 'Apple Silicon' : 'Intel'})`);
+
+    try {
+    const cacheDir = path.join(os.homedir(), '.vibecodingmachine', 'cache');
+    await fs.ensureDir(cacheDir);
+    const cachedPath = path.join(cacheDir, 'Antigravity.dmg');
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'antigravity-'));
+    const dmgPath = path.join(tempDir, 'Antigravity.dmg');
+    const { downloadWithProgress } = require('./download-with-progress');
+
+    // Prefer cached DMG if it exists and matches upstream size (or exists at all)
+    let usedCache = false;
+    try {
+      if (await fs.pathExists(cachedPath)) {
+        // Try HEAD to compare sizes
+        try {
+          const fetch = require('node-fetch');
+          const head = await fetch(downloadUrl, { method: 'HEAD' });
+          const total = Number(head.headers.get('content-length')) || 0;
+          const stat = await fs.stat(cachedPath);
+          if (total && stat.size === total) {
+            await fs.copy(cachedPath, dmgPath);
+            usedCache = true;
+            console.log(chalk.gray('Using cached Antigravity DMG')); 
+          }
+        } catch (e) {
+          // If HEAD fails, still allow reuse of cache to avoid re-download
+          await fs.copy(cachedPath, dmgPath);
+          usedCache = true;
+          console.log(chalk.gray('Using cached Antigravity DMG (no HEAD)'));
+        }
+      }
+    } catch (e) {
+      // ignore cache errors
+      usedCache = false;
+    }
+
+    // Use download helper which displays progress and ETA if we didn't reuse cache
+    if (!usedCache) {
+      await downloadWithProgress(downloadUrl, dmgPath, { label: 'Downloading Antigravity...' });
+      // Save to cache for future runs
+      try { await fs.copy(dmgPath, cachedPath); } catch (e) { /* ignore cache write errors */ }
+    }
+
+    const installSpinner = ora('Installing Antigravity...').start();
+
+    try {
+      installSpinner.text = 'Mounting disk image...';
+      execSync(`hdiutil attach "${dmgPath}" -nobrowse -noverify -mountpoint "${tempDir}/mount"`);
+
+      installSpinner.text = 'Copying to /Applications...';
+      const files = await fs.readdir(path.join(tempDir, 'mount'));
+      const appName = files.find((f) => f.endsWith('.app'));
+      if (!appName) throw new Error('Could not find .app in DMG');
+
+      const src = path.join(tempDir, 'mount', appName);
+      const dest = path.join('/Applications', appName);
+
+      if (await fs.pathExists(dest)) {
+        installSpinner.text = 'Replacing existing application...';
+        await fs.remove(dest);
+      }
+
+        // Prefer rsync/ditto; fallback to node-stream copy with progress
+        try {
+          const { copyAppWithProgress } = require('./copy-with-progress');
+          installSpinner.stop();
+          const ok = await copyAppWithProgress(src, dest, { spinner: installSpinner });
+          if (!ok) {
+            installSpinner.text = 'Copying (fs fallback) to /Applications...';
+            await fs.copy(src, dest);
+          }
+        } catch (e) {
+          // final fallback
+          installSpinner.text = 'Copying (fs fallback) to /Applications...';
+          try {
+            execSync(`cp -R "${src}" "/Applications/"`, { stdio: 'inherit' });
+          } catch (err) {
+            await fs.copy(src, dest);
+          }
+        }
+
+      installSpinner.text = 'Cleaning up...';
+      execSync(`hdiutil detach "${tempDir}/mount" -force`);
+      await fs.remove(tempDir);
+
+      installSpinner.succeed('Antigravity installed');
+      console.log(chalk.green(`\n✅ Installed to ${dest}`));
+          // Attempt to automatically configure Antigravity's first-run settings
+          try {
+            await configureAntigravityDefaults(dest);
+          } catch (e) {
+            // Non-fatal: log and continue
+            console.log(chalk.yellow('Warning: could not auto-configure Antigravity:'), e.message || e);
+          }
+
+          return true;
+    } catch (err) {
+      installSpinner.fail('Installation failed');
+      try {
+        if (await fs.pathExists(path.join(tempDir, 'mount'))) {
+          execSync(`hdiutil detach "${tempDir}/mount" -force`);
+        }
+      try { await fs.remove(tempDir); } catch (e) { /* ignore */ }
+      console.log(chalk.red('\nInstallation error:'), err.message);
+      return false;
+    }
+  } catch (error) {
+    console.log(chalk.red('\nFailed to install Antigravity:'), error.message);
+    return false;
+  }
+}
+
+async function configureAntigravityDefaults() {
+  // Attempt to open Antigravity and set the onboarding defaults via AppleScript
+  // Desired selections:
+  // - Agent-driven development (instead of recommended Agent-assisted)
+  // - Terminal execution policy: Turbo
+  // - Review policy: Always Proceed
+  // - Use the default allowlist for the browser (checked)
+  try {
+    const script = `
+      tell application "Antigravity"
+        activate
+      end tell
+      delay 0.8
+      tell application "System Events"
+        tell process "Antigravity"
+          set frontmost to true
+          delay 0.5
+          -- Try to select Agent-driven development radio button
+          try
+            click radio button "Agent-driven development" of radio group 1 of window 1
+            delay 0.2
+          end try
+
+          -- Set Terminal execution policy to Turbo (attempt by label, then by index)
+          try
+            try
+              click pop up button "Terminal execution policy" of window 1
+              delay 0.2
+              click menu item "Turbo" of menu 1 of pop up button "Terminal execution policy" of window 1
+            on error
+              -- fallback: click first pop up button and choose Turbo
+              click pop up button 1 of window 1
+              delay 0.2
+              click menu item "Turbo" of menu 1 of pop up button 1 of window 1
+            end try
+            delay 0.2
+          end try
+
+          -- Set Review policy to Always Proceed
+          try
+            click pop up button "Review policy" of window 1
+            delay 0.2
+            click menu item "Always Proceed" of menu 1 of pop up button "Review policy" of window 1
+            delay 0.2
+          end try
+
+          -- Ensure default allowlist checkbox is checked
+          try
+            set cb to checkbox "Use the default allowlist for the browser" of window 1
+            if (value of cb as boolean) is false then click cb
+            delay 0.2
+          end try
+
+          -- Advance the onboarding if a Next/Done button exists
+          try
+            if exists button "Next" of window 1 then click button "Next" of window 1
+            delay 0.3
+          end try
+        end tell
+      end tell
+    `;
+
+    // Use osascript to run the UI automation. JSON-stringify ensures safe quoting.
+    const { execSync } = require('child_process');
+    execSync(`osascript -e ${JSON.stringify(script)}`, { stdio: 'ignore', timeout: 15000 });
+    console.log(chalk.gray('Auto-configured Antigravity first-run preferences'));
+    return true;
+  } catch (err) {
+    throw new Error(err.message || err);
+  }
+}
+
+module.exports = { installAntigravity };

package/src/utils/antigravity-js-handler.js

@@ -0,0 +1,60 @@
+const chalk = require('chalk');
+const {
+  getProviderPreferences,
+  saveProviderPreferences
+} = require('./provider-registry');
+
+/**
+ * Check if Antigravity agent has hit a rate limit.
+ * @param {string} stderr - Standard error output from the agent.
+ * @returns {{isRateLimited: boolean, message: string|null}} - Rate limit status and message.
+ */
+function checkAntigravityRateLimit(stderr) {
+  const rateLimitPatterns = [
+    /quota limit/i,
+    /rate limit/i,
+    /too many requests/i,
+    /limit exceeded/i
+  ];
+
+  for (const pattern of rateLimitPatterns) {
+    if (pattern.test(stderr)) {
+      return {
+        isRateLimited: true,
+        message: 'Antigravity quota limit reached.'
+      };
+    }
+  }
+
+  return { isRateLimited: false, message: null };
+}
+
+/**
+ * Handle rate limit for Antigravity by disabling it and selecting the next available provider.
+ * @returns {Promise<{success: boolean, nextProvider: string|null, error: string|null}>}
+ */
+async function handleAntigravityRateLimit() {
+  console.log(chalk.yellow('Antigravity rate limit detected. Disabling for this session.'));
+
+  try {
+    const prefs = await getProviderPreferences();
+    prefs.enabled.antigravity = false;
+    await saveProviderPreferences(prefs);
+
+    const nextProvider = prefs.order.find(p => p !== 'antigravity' && prefs.enabled[p]);
+
+    if (nextProvider) {
+      console.log(chalk.cyan(`Switching to next available provider: ${nextProvider}`));
+      return { success: true, nextProvider, error: null };
+    } else {
+      return { success: false, nextProvider: null, error: 'No fallback providers available.' };
+    }
+  } catch (error) {
+    return { success: false, nextProvider: null, error: 'Failed to update provider preferences.' };
+  }
+}
+
+module.exports = {
+  checkAntigravityRateLimit,
+  handleAntigravityRateLimit
+};

package/src/utils/asset-cleanup.js

@@ -0,0 +1,60 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Scans the assets directory and removes 0-byte PNG files
+ * This is a mitigation for an issue where empty PNG files are mysteriously created
+ */
+async function cleanupBrokenAssets() {
+    try {
+        // Find assets directory - assuming we are in packages/cli/src/utils
+        // and assets is at root of repo, but simpler to look relative to where VCM runs
+        // effectively, we look for 'assets' in the current working directory as CWD is usually the repo root or where the CLI is run
+        // Better: define path relative to the project root if possible, or CWD if that's how it's structured.
+        // Based on previous search, assets/ is at the root of the repo.
+        // However, when installed, strict paths matters.
+        // But for the user's workspace context, iterating 'assets/' in CWD (repo root) is correct for their dev environment.
+        // Let's try to be smart about finding specific 'assets' dir if we can, but CWD is a safe start for the CLI tool which is often run from root.
+
+        // Actually, looking at previous grep, `assets/` was checked specifically. 
+        // Let's just check `assets` in process.cwd() as a primary target.
+
+        const assetsDir = path.join(process.cwd(), 'assets');
+
+        if (!await fs.pathExists(assetsDir)) {
+            return; // No assets dir, nothing to clean
+        }
+
+        const files = await fs.readdir(assetsDir);
+        let removedCount = 0;
+
+        for (const file of files) {
+            if (file.toLowerCase().endsWith('.png')) {
+                const filePath = path.join(assetsDir, file);
+                try {
+                    const stats = await fs.stat(filePath);
+                    if (stats.size === 0) {
+                        await fs.remove(filePath);
+                        removedCount++;
+                    }
+                } catch (err) {
+                    // Ignore errors accessing specific files
+                }
+            }
+        }
+
+        if (removedCount > 0) {
+            // Only log if we actually did something, to keep noise down
+            // But maybe we want to know? The plan said "verification: verify removed".
+            // We can use a debug flag or just log.
+            // Let's log to console for now as it's a CLI tool.
+            // console.log(chalk.gray(`Cleaned up ${removedCount} broken (0-byte) asset files.`));
+        }
+
+    } catch (error) {
+        // Silently fail to avoid disrupting startup
+        // console.error('Asset cleanup failed:', error);
+    }
+}
+
+module.exports = { cleanupBrokenAssets };

package/src/utils/auth.js

@@ -2,7 +2,6 @@ const chalk = require('chalk');
 const http = require('http');
 const crypto = require('crypto');
 const fs = require('fs');
-const path = require('path');
 const net = require('net');
 const sharedAuth = require('vibecodingmachine-core/src/auth/shared-auth-storage');
 
@@ -31,7 +30,37 @@ class CLIAuth {
    * Check if authenticated (uses shared storage)
    */
   async isAuthenticated() {
-    return await sharedAuth.isAuthenticated();
+    // First check if current token is valid
+    const isValid = await sharedAuth.isAuthenticated();
+    if (isValid) {
+      // Update user activity in database
+      await this._updateUserActivity();
+      return true;
+    }
+
+    // If not valid, try to refresh
+    try {
+      const refreshToken = await sharedAuth.getRefreshToken();
+      if (refreshToken) {
+        // console.log(chalk.gray('Refreshing session...'));
+        const newTokens = await this._refreshTokens(refreshToken);
+
+        // Validate new ID token
+        await this._validateToken(newTokens.id_token);
+
+        // Save new tokens
+        await sharedAuth.saveToken(newTokens);
+        
+        // Update user activity in database
+        await this._updateUserActivity();
+        return true;
+      }
+    } catch (error) {
+      // Refresh failed (token expired or revoked), user needs to login again
+      // console.log(chalk.gray('Session refresh failed, please login again.'));
+    }
+
+    return false;
   }
 
   /**
@@ -82,7 +111,7 @@ class CLIAuth {
         res.on('end', () => {
           if (res.statusCode === 200) {
             const tokens = JSON.parse(data);
-            resolve(tokens.id_token); // Return the ID token
+            resolve(tokens); // Return full tokens object
           } else {
             reject(new Error(`Token exchange failed: ${res.statusCode} - ${data}`));
           }
@@ -97,7 +126,53 @@ class CLIAuth {
       req.end();
     });
   }
+  /**
+   * Refresh tokens using refresh_token
+   */
+  async _refreshTokens(refreshToken) {
+    const https = require('https');
+
+    const tokenEndpoint = `https://${COGNITO_DOMAIN}/oauth2/token`;
+    const postData = new URLSearchParams({
+      grant_type: 'refresh_token',
+      client_id: CLIENT_ID,
+      refresh_token: refreshToken
+    }).toString();
 
+    return new Promise((resolve, reject) => {
+      const options = {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'Content-Length': postData.length
+        }
+      };
+
+      const req = https.request(tokenEndpoint, options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          if (res.statusCode === 200) {
+            const tokens = JSON.parse(data);
+            // Cognito might not return a new refresh token, so we keep the old one if not provided
+            if (!tokens.refresh_token) {
+              tokens.refresh_token = refreshToken;
+            }
+            resolve(tokens);
+          } else {
+            reject(new Error(`Token refresh failed: ${res.statusCode} - ${data}`));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(new Error(`Token refresh request failed: ${error.message}`));
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
   /**
    * Validate JWT token with signature verification
    * @param {string} idToken - JWT token to validate
@@ -312,18 +387,25 @@ class CLIAuth {
             try {
               // Exchange code for tokens
               console.log(chalk.gray('Exchanging authorization code for tokens...'));
-              const idToken = await this._exchangeCodeForTokens(
+              // Exchange code for tokens
+              console.log(chalk.gray('Exchanging authorization code for tokens...'));
+              const tokens = await this._exchangeCodeForTokens(
                 code,
                 codeVerifier,
                 `http://localhost:${PORT}/callback`
               );
 
+              const idToken = tokens.id_token;
+
               // Validate token (signature + claims)
               console.log(chalk.gray('Validating token...'));
               await this._validateToken(idToken);
 
               // Save token
-              await sharedAuth.saveToken(idToken);
+              await sharedAuth.saveToken(tokens);
+
+              // Register/update user in enhanced database
+              await this._registerUserInDatabase(idToken);
 
               // Show success page
               res.writeHead(200, {
@@ -428,7 +510,7 @@ class CLIAuth {
                 serverClosed = true;
                 server.close();
                 console.log(chalk.green('✓ Authentication successful!\n'));
-                resolve(idToken);
+                resolve(tokens.id_token);
               }
             } catch (error) {
               // Token exchange or validation failed
@@ -560,12 +642,16 @@ class CLIAuth {
 
       // Exchange code for tokens
       console.log(chalk.gray('Exchanging authorization code for tokens...'));
-      const idToken = await this._exchangeCodeForTokens(
+      // Exchange code for tokens
+      console.log(chalk.gray('Exchanging authorization code for tokens...'));
+      const tokens = await this._exchangeCodeForTokens(
         code,
         codeVerifier,
         'http://localhost:3000/callback'
       );
 
+      const idToken = tokens.id_token;
+
       // Validate JWT token
       console.log(chalk.gray('Validating token...'));
       try {
@@ -577,7 +663,10 @@ class CLIAuth {
       }
 
       // Save token using shared storage (only if validation passed)
-      await sharedAuth.saveToken(idToken);
+      await sharedAuth.saveToken(tokens);
+
+      // Register/update user in enhanced database
+      await this._registerUserInDatabase(idToken);
 
       console.log(chalk.green('\n✓ Authentication successful!'));
       return idToken;
@@ -614,6 +703,141 @@ class CLIAuth {
   async activateLicense(licenseKey) {
     return await sharedAuth.activateLicense(licenseKey);
   }
+
+  /**
+   * Register or update user in enhanced database system
+   */
+  async _registerUserInDatabase(idToken) {
+    try {
+      // Decode JWT to get user info (without verification since we already validated)
+      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+      
+      const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
+      const userDb = new UserDatabase();
+      
+      const userInfo = {
+        email: payload.email,
+        name: payload.name || payload.email.split('@')[0],
+        cognitoId: payload.sub
+      };
+
+      // Register/update user
+      const user = await userDb.registerUser(userInfo);
+      
+      // Register computer
+      await userDb.registerComputer(user.userId, {
+        interface: 'cli'
+      });
+
+      // Track login activity
+      await userDb.trackActivity(user.userId, {
+        interface: 'cli',
+        action: 'login',
+        duration: 0,
+        metadata: {
+          authMethod: 'cognito',
+          timestamp: Date.now()
+        }
+      });
+
+    } catch (error) {
+      // Don't fail authentication if database registration fails
+      console.error('Warning: Failed to register user in database:', error.message);
+    }
+  }
+
+  /**
+   * Update user activity in database
+   */
+  async _updateUserActivity() {
+    try {
+      const token = await sharedAuth.getToken();
+      if (!token || !token.id_token) return;
+
+      // Decode JWT to get user info
+      const payload = JSON.parse(Buffer.from(token.id_token.split('.')[1], 'base64').toString());
+      
+      const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
+      const userDb = new UserDatabase();
+      
+      const userId = userDb.generateUserId(payload.email);
+      
+      // Update last activity
+      await userDb.updateUserActivity(userId, {
+        lastActivity: Date.now()
+      });
+
+    } catch (error) {
+      // Silently fail - don't disrupt user experience
+      console.error('Warning: Failed to update user activity:', error.message);
+    }
+  }
+
+  /**
+   * Track CLI usage activity
+   */
+  async trackCLIActivity(action, metadata = {}) {
+    try {
+      const token = await sharedAuth.getToken();
+      if (!token) return;
+
+      // Handle both string tokens and object tokens with id_token property
+      const idToken = typeof token === 'string' ? token : token.id_token;
+      if (!idToken) return;
+
+      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+      
+      const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
+      const userDb = new UserDatabase();
+      
+      const userId = userDb.generateUserId(payload.email);
+      
+      await userDb.trackActivity(userId, {
+        interface: 'cli',
+        action,
+        duration: metadata.duration || 0,
+        metadata: {
+          ...metadata,
+          timestamp: Date.now()
+        }
+      });
+
+    } catch (error) {
+      // Silently fail - don't disrupt user experience
+      console.error('Warning: Failed to track CLI activity:', error.message);
+    }
+  }
+
+  /**
+   * Get current user information
+   */
+  async getCurrentUser() {
+    try {
+      const token = await sharedAuth.getToken();
+      if (!token) return null;
+
+      // Handle both string token and object with id_token
+      const idToken = typeof token === 'string' ? token : token.id_token;
+      if (!idToken) return null;
+
+      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+      
+      const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
+      const userDb = new UserDatabase();
+      
+      const userId = userDb.generateUserId(payload.email);
+      
+      return {
+        userId,
+        email: payload.email,
+        name: payload.name || payload.email.split('@')[0],
+        cognitoId: payload.sub
+      };
+    } catch (error) {
+      console.error('Error getting current user:', error.message);
+      return null;
+    }
+  }
 }
 
 module.exports = new CLIAuth();

package/src/utils/auto-mode-ansi-ui.js

@@ -1,6 +1,5 @@
 const chalk = require('chalk');
 const ansiEscapes = require('ansi-escapes');
-const stripAnsi = require('strip-ansi');
 
 /**
  * ANSI-based UI for Auto Mode