vibecodingmachine-cli 2025.12.6-1702 → 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

@@ -1,6 +1,5 @@
 const fs = require('fs-extra');
 const path = require('path');
-const chalk = require('chalk');
 
 /**
  * Scans the assets directory and removes 0-byte PNG files

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');
 
@@ -33,7 +32,11 @@ class CLIAuth {
   async isAuthenticated() {
     // First check if current token is valid
     const isValid = await sharedAuth.isAuthenticated();
-    if (isValid) return true;
+    if (isValid) {
+      // Update user activity in database
+      await this._updateUserActivity();
+      return true;
+    }
 
     // If not valid, try to refresh
     try {
@@ -47,6 +50,9 @@ class CLIAuth {
 
         // Save new tokens
         await sharedAuth.saveToken(newTokens);
+        
+        // Update user activity in database
+        await this._updateUserActivity();
         return true;
       }
     } catch (error) {
@@ -398,6 +404,9 @@ class CLIAuth {
               // Save token
               await sharedAuth.saveToken(tokens);
 
+              // Register/update user in enhanced database
+              await this._registerUserInDatabase(idToken);
+
               // Show success page
               res.writeHead(200, {
                 'Content-Type': 'text/html',
@@ -656,6 +665,9 @@ class CLIAuth {
       // Save token using shared storage (only if validation passed)
       await sharedAuth.saveToken(tokens);
 
+      // Register/update user in enhanced database
+      await this._registerUserInDatabase(idToken);
+
       console.log(chalk.green('\n✓ Authentication successful!'));
       return idToken;
     } catch (error) {
@@ -691,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

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

@@ -79,7 +79,7 @@ class AutoModeSimpleUI {
       { name: 'DONE', color: chalk.green }
     ];
 
-    const workflowLine = stages.map((stage, index) => {
+    const workflowLine = stages.map((stage, _index) => {
       const icon = this.getStepIcon(stage.name, this.step);
       const isCurrent = stage.name === this.step;
       const stageColor = isCurrent ? currentStepColor.bold : stage.color;

package/src/utils/compliance-check.js

@@ -0,0 +1,166 @@
+/**
+ * CLI Compliance Check Utility
+ * 
+ * Checks and prompts for compliance on CLI startup
+ */
+
+let CompliancePrompt
+try {
+  CompliancePrompt = require('vibecodingmachine-core/src/compliance/compliance-prompt')
+} catch (e) {
+  // If core package isn't installed (local dev), gracefully skip compliance by returning true
+  CompliancePrompt = null
+}
+const auth = require('./auth')
+
+async function checkCompliance() {
+  try {
+    // First check if user is authenticated
+    const isAuth = await auth.isAuthenticated()
+    if (!isAuth) {
+      // User not authenticated, skip compliance check (will be checked after login)
+      return true
+    }
+
+    // Get current user
+    const user = await auth.getCurrentUser()
+    
+    if (!user || !user.userId) {
+      // If we can't get user info but they're authenticated, something is wrong
+      // But don't block them - they can still use the app
+      console.warn('Warning: Unable to verify compliance status')
+      return true
+    }
+
+    // If CompliancePrompt is not available (dev environment), skip compliance checks
+    if (!CompliancePrompt) {
+      if (process.env.DEBUG) console.log('Compliance checks skipped: vibecodingmachine-core not available')
+      return true
+    }
+
+    // Check and prompt for compliance
+    const compliancePrompt = new CompliancePrompt()
+    const status = await compliancePrompt.complianceManager.checkComplianceStatus(user.userId)
+    
+    if (!status.needsAcknowledgment) {
+      return true
+    }
+
+    // Handle CLI prompting locally
+    const isCompliant = await promptCLI(user.userId, status, compliancePrompt)
+    return isCompliant
+  } catch (error) {
+    // Log error but don't block user
+    console.error('Error checking compliance:', error.message)
+    if (process.env.DEBUG) {
+      console.error(error.stack)
+    }
+    // Return true to not block the user if there's a system error
+    return true
+  }
+}
+
+/**
+ * CLI prompt for compliance
+ */
+async function promptCLI(userId, status, compliancePrompt) {
+  const chalk = require('chalk')
+  const inquirer = require('inquirer')
+
+  console.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))
+  console.log(chalk.cyan.bold('  📋 Terms & Privacy Acknowledgment Required'))
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'))
+
+  console.log(chalk.white('Before continuing, please review and accept:\n'))
+
+  const questions = []
+
+  if (status.requiredActions.includes('terms')) {
+    const terms = await compliancePrompt.complianceManager.getTermsOfService()
+    
+    console.log(chalk.yellow('📄 Terms of Service'))
+    console.log(chalk.gray('─'.repeat(70)))
+    console.log(formatForCLI(terms.content))
+    console.log(chalk.gray('─'.repeat(70)))
+    console.log(chalk.gray(`Version ${terms.version} | Effective: ${terms.effectiveDate}\n`))
+
+    questions.push({
+      type: 'confirm',
+      name: 'acceptTerms',
+      message: 'Do you accept the Terms of Service?',
+      default: false
+    })
+  }
+
+  if (status.requiredActions.includes('privacy')) {
+    const privacy = await compliancePrompt.complianceManager.getPrivacyPolicy()
+    
+    console.log(chalk.yellow('🔒 Privacy Policy'))
+    console.log(chalk.gray('─'.repeat(70)))
+    console.log(formatForCLI(privacy.content))
+    console.log(chalk.gray('─'.repeat(70)))
+    console.log(chalk.gray(`Version ${privacy.version} | Effective: ${privacy.effectiveDate}\n`))
+
+    questions.push({
+      type: 'confirm',
+      name: 'acceptPrivacy',
+      message: 'Do you accept the Privacy Policy?',
+      default: false
+    })
+  }
+
+  const answers = await inquirer.prompt(questions)
+
+  // Check if user accepted all required items
+  const allAccepted = 
+    (!status.requiredActions.includes('terms') || answers.acceptTerms) &&
+    (!status.requiredActions.includes('privacy') || answers.acceptPrivacy)
+
+  if (!allAccepted) {
+    console.log(chalk.red('\n❌ You must accept the Terms and Privacy Policy to use VibeCodingMachine.\n'))
+    return false
+  }
+
+  // Record acceptance
+  await compliancePrompt.complianceManager.recordAcknowledgment(userId, {
+    terms: answers.acceptTerms || undefined,
+    privacy: answers.acceptPrivacy || undefined
+  })
+
+  console.log(chalk.green('\n✅ Thank you! Your acceptance has been recorded.\n'))
+  return true
+}
+
+/**
+ * Format markdown content for CLI display
+ */
+function formatForCLI(content) {
+  // Simple markdown formatting for terminal
+  return content
+    .split('\n')
+    .map(line => {
+      // Headers
+      if (line.startsWith('# ')) {
+        return '  ' + line.substring(2).toUpperCase()
+      }
+      if (line.startsWith('## ')) {
+        return '  ' + line.substring(3)
+      }
+      // Bold
+      line = line.replace(/\*\*(.*?)\*\*/g, '$1')
+      // Lists
+      if (line.startsWith('- ')) {
+        return '  • ' + line.substring(2)
+      }
+      if (/^\d+\./.test(line)) {
+        return '  ' + line
+      }
+      // Regular text
+      return line ? '  ' + line : ''
+    })
+    .join('\n')
+}
+
+module.exports = {
+  checkCompliance
+}

package/src/utils/config.js

@@ -52,13 +52,39 @@ async function setAutoConfig(autoConfig) {
   await writeConfig(cfg);
 }
 
+const DEFAULT_STAGES = Object.freeze([
+  'PREPARE',
+  'REPRODUCE',
+  'CREATE UNIT TEST',
+  'ACT',
+  'CLEAN UP',
+  'VERIFY',
+  'RUN UNIT TESTS',
+  'DONE'
+]);
+
+async function getStages() {
+  const config = await getAutoConfig();
+  // Return a copy to prevent mutation of the internal array
+  return [...(config.stages || DEFAULT_STAGES)];
+}
+
+async function setStages(stages) {
+  const cfg = await readConfig();
+  cfg.auto = { ...(cfg.auto || {}), stages };
+  await writeConfig(cfg);
+}
+
 module.exports = {
   getRepoPath,
   setRepoPath,
   getAutoConfig,
   setAutoConfig,
   readConfig,
-  writeConfig
+  writeConfig,
+  getStages,
+  setStages,
+  DEFAULT_STAGES
 };