vibecodingmachine-cli 2025.12.6-1702 → 2025.12.24-2348

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

package/src/utils/copy-with-progress.js

@@ -0,0 +1,167 @@
+const { spawn, execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+
+function progressBar(percent, width) {
+  const fill = Math.round((percent / 100) * width);
+  return '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+}
+
+function formatEta(sec) {
+  if (!isFinite(sec) || sec === null) return '--:--';
+  const s = Math.max(0, Math.round(sec));
+  const m = Math.floor(s / 60);
+  const ss = s % 60;
+  return `${m}:${ss.toString().padStart(2, '0')}`;
+}
+
+async function tryRsync(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
+  try {
+    execSync('which rsync', { stdio: 'ignore' });
+  } catch (e) {
+    return false;
+  }
+  // choose progress option based on rsync version
+  let rsyncArgs = ['-a'];
+  try {
+    const verOut = execSync('rsync --version', { encoding: 'utf8', timeout: 2000 });
+    const m = verOut.match(/version\s+(\d+)\.(\d+)/i);
+    if (m) {
+      const major = Number(m[1]);
+      const minor = Number(m[2] || 0);
+      if (major > 3 || (major === 3 && minor >= 1)) {
+        rsyncArgs.push('--info=progress2');
+      } else {
+        rsyncArgs.push('--progress');
+      }
+    } else {
+      rsyncArgs.push('--progress');
+    }
+  } catch (e) {
+    rsyncArgs.push('--progress');
+  }
+
+  return await new Promise((resolve) => {
+    const rsync = spawn('rsync', rsyncArgs.concat([src + '/', dest]), { stdio: 'inherit' });
+    let finished = false;
+    const to = setTimeout(() => {
+      if (!finished) {
+        try { rsync.kill('SIGINT'); } catch (e) { /* ignore */ }
+        resolve(false);
+      }
+    }, timeoutMs);
+    rsync.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
+    rsync.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
+  });
+}
+
+async function tryDitto(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
+  try {
+    await fs.ensureDir(path.dirname(dest));
+    return await new Promise((resolve) => {
+      const ditto = spawn('ditto', ['-v', src, dest], { stdio: 'inherit' });
+      let finished = false;
+      const to = setTimeout(() => {
+        if (!finished) {
+          try { ditto.kill('SIGINT'); } catch (e) { /* ignore */ }
+          resolve(false);
+        }
+      }, timeoutMs);
+      ditto.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
+      ditto.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
+    });
+  } catch (e) {
+    return false;
+  }
+}
+
+async function nodeStreamCopy(src, dest, _spinner) {
+  // Determine total size (attempt du -sk fallback to recursive stat)
+  let total = 0;
+  try {
+    const out = execSync(`du -sk "${src}" | cut -f1`, { encoding: 'utf8' }).trim();
+    total = Number(out) * 1024;
+  } catch (e) {
+    // fallback: sum file sizes via traversal
+    await (async function walk(p) {
+      const entries = await fs.readdir(p);
+      for (const e of entries) {
+        const full = path.join(p, e);
+        const stat = await fs.stat(full);
+        if (stat.isDirectory()) await walk(full);
+        else total += stat.size;
+      }
+    })(src);
+  }
+
+  let copied = 0;
+  const start = Date.now();
+  const width = 30;
+
+  async function copyEntry(srcPath, dstPath) {
+    const stat = await fs.stat(srcPath);
+    if (stat.isDirectory()) {
+      await fs.ensureDir(dstPath);
+      const entries = await fs.readdir(srcPath);
+      for (const e of entries) {
+        await copyEntry(path.join(srcPath, e), path.join(dstPath, e));
+      }
+    } else {
+      await fs.ensureDir(path.dirname(dstPath));
+      await new Promise((resolve, reject) => {
+        const rs = fs.createReadStream(srcPath);
+        const ws = fs.createWriteStream(dstPath);
+        rs.on('data', (chunk) => {
+          copied += chunk.length;
+          if (total) {
+            const percent = Math.round((copied / total) * 100);
+            const mbCopied = (copied / (1024 * 1024)).toFixed(1);
+            const mbTotal = (total / (1024 * 1024)).toFixed(1);
+            const elapsed = Math.max(0.001, (Date.now() - start) / 1000);
+            const speed = copied / elapsed;
+            const eta = formatEta((total - copied) / (speed || 1));
+            const bar = progressBar(percent, width);
+            process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbCopied}MB / ${mbTotal}MB ETA: ${eta}`);
+          } else {
+            process.stdout.write(`\r\x1b[2KCopying ${ (copied/(1024*1024)).toFixed(1) } MB`);
+          }
+        });
+        rs.on('error', reject);
+        ws.on('error', reject);
+        ws.on('close', resolve);
+        rs.pipe(ws);
+      });
+    }
+  }
+
+  await copyEntry(src, dest);
+  process.stdout.write('\n');
+  return true;
+}
+
+async function copyAppWithProgress(src, dest, opts = {}) {
+  const spinner = (opts && opts.spinner) || { start: () => {}, stop: () => {}, fail: () => {}, succeed: () => {} };
+
+  // Try rsync first
+  spinner.stop && spinner.stop();
+  console.log(`Copying ${path.basename(src)} -> ${dest} (attempting rsync...)`);
+  const okRsync = await tryRsync(src, dest, spinner);
+  if (okRsync) return true;
+
+  // Try ditto (macOS)
+  console.log('rsync failed or not available — trying ditto...');
+  const okDitto = await tryDitto(src, dest, spinner);
+  if (okDitto) return true;
+
+  // Fallback to Node streaming copy with progress
+  console.log('Falling back to node-stream copy with progress...');
+  try {
+    await nodeStreamCopy(src, dest, spinner);
+    return true;
+  } catch (e) {
+    console.error('node-stream copy failed:', e.message || e);
+    return false;
+  }
+}
+
+module.exports = { copyAppWithProgress };

package/src/utils/download-with-progress.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const ora = require('ora');
+
+async function downloadWithProgress(url, dest, opts = {}) {
+  const fetch = require('node-fetch');
+  const spinner = opts.spinner || ora();
+  const label = opts.label || 'Downloading...';
+
+  spinner.start(label);
+
+  const res = await fetch(url);
+  if (!res.ok) {
+    spinner.fail(`Download failed: ${res.status} ${res.statusText}`);
+    throw new Error(`Failed to download ${url}: ${res.status}`);
+  }
+  // Stop the ora spinner so we can write an in-place progress line without conflicts
+  try { spinner.stop(); } catch (e) { /* ignore */ }
+  // Print initial progress line so user sees immediate feedback
+  try { process.stdout.write('\r\x1b[2KDownloading: 0.0 MB'); } catch (e) { /* ignore */ }
+
+  const total = Number(res.headers.get('content-length')) || 0;
+  const fileStream = fs.createWriteStream(dest);
+
+  return await new Promise((resolve, reject) => {
+    let downloaded = 0;
+    const start = Date.now();
+    let lastPercent = -1;
+
+    res.body.on('data', (chunk) => {
+      downloaded += chunk.length;
+      if (total) {
+        const percent = Math.round((downloaded / total) * 100);
+        if (percent !== lastPercent) {
+          lastPercent = percent;
+          const mbDownloaded = (downloaded / (1024 * 1024)).toFixed(1);
+          const mbTotal = (total / (1024 * 1024)).toFixed(1);
+          const elapsed = Math.max(0.001, (Date.now() - start) / 1000);
+          const speed = downloaded / elapsed; // bytes/sec
+          const etaSec = (total - downloaded) / (speed || 1);
+          const eta = formatEta(etaSec);
+          const bar = progressBar(percent, 30);
+          process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbDownloaded}MB / ${mbTotal}MB ETA: ${eta}`);
+        }
+      } else {
+        const mbDownloaded = (downloaded / (1024 * 1024)).toFixed(1);
+        process.stdout.write(`\r\x1b[2K${label} ${mbDownloaded} MB`);
+      }
+    });
+
+    res.body.on('error', (err) => {
+      spinner.fail('Download error');
+      reject(err);
+    });
+
+    fileStream.on('error', (err) => {
+      spinner.fail('File write error');
+      reject(err);
+    });
+
+    fileStream.on('finish', () => {
+      process.stdout.write('\n');
+      spinner.succeed('Download complete');
+      resolve();
+    });
+
+    // Pipe the response body to file
+    res.body.pipe(fileStream);
+  });
+}
+
+function progressBar(percent, width) {
+  const fill = Math.round((percent / 100) * width);
+  return '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+}
+
+function formatEta(sec) {
+  if (!isFinite(sec) || sec === null) return '--:--';
+  const s = Math.max(0, Math.round(sec));
+  const m = Math.floor(s / 60);
+  const ss = s % 60;
+  return `${m}:${ss.toString().padStart(2, '0')}`;
+}
+
+module.exports = { downloadWithProgress };