vibecodingmachine-core 2025.12.1-534 → 2025.12.22-2230

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-core",
-  "version": "2025.12.01-0534",
+  "version": "2025.12.22-2230",
   "description": "Shared core logic for Vibe Coding Machine IDE integration",
   "main": "src/index.cjs",
   "module": "src/index.js",
@@ -13,6 +13,9 @@
   },
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.932.0",
+    "@aws-sdk/client-dynamodb": "^3.600.0",
+    "@aws-sdk/lib-dynamodb": "^3.600.0",
+    "@aws-sdk/client-cognito-identity-provider": "^3.600.0",
     "chrome-remote-interface": "^0.33.0",
     "fs-extra": "^11.1.1",
     "jsonwebtoken": "^9.0.2",

package/scripts/setup-database.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * Database Setup Script for VibeCodingMachine Enhanced User Tracking
+ * 
+ * This script creates the necessary DynamoDB tables for the enhanced
+ * user tracking system.
+ */
+
+const DatabaseMigrations = require('../src/database/migrations')
+
+async function main() {
+  console.log('🚀 VibeCodingMachine Database Setup')
+  console.log('=====================================\n')
+
+  const migrations = new DatabaseMigrations()
+
+  try {
+    // Check current table status
+    console.log('📊 Checking current database status...')
+    const tableStatuses = await migrations.getAllTableStatus()
+    
+    console.log('\nCurrent Table Status:')
+    tableStatuses.forEach(status => {
+      const statusIcon = status.status === 'ACTIVE' ? '✅' : 
+                        status.status === 'NOT_FOUND' ? '❌' : '⏳'
+      console.log(`  ${statusIcon} ${status.name}: ${status.status}`)
+      if (status.itemCount !== undefined) {
+        console.log(`     Items: ${status.itemCount}, Size: ${Math.round(status.sizeBytes / 1024)} KB`)
+      }
+    })
+
+    console.log('\n🔄 Running database migrations...')
+    await migrations.runMigrations()
+
+    // Check final status
+    console.log('\n📊 Final database status...')
+    const finalStatuses = await migrations.getAllTableStatus()
+    
+    console.log('\nFinal Table Status:')
+    finalStatuses.forEach(status => {
+      const statusIcon = status.status === 'ACTIVE' ? '✅' : 
+                        status.status === 'CREATING' ? '⏳' : '❌'
+      console.log(`  ${statusIcon} ${status.name}: ${status.status}`)
+    })
+
+    console.log('\n🎉 Database setup completed successfully!')
+    console.log('\nNext steps:')
+    console.log('1. Update your application environment variables with AWS credentials')
+    console.log('2. Test the user registration flow')
+    console.log('3. Deploy the admin dashboard')
+    console.log('4. Configure compliance policies')
+
+  } catch (error) {
+    console.error('\n❌ Database setup failed:', error.message)
+    console.error('\nTroubleshooting:')
+    console.error('1. Check your AWS credentials and permissions')
+    console.error('2. Ensure you have DynamoDB access in your AWS region')
+    console.error('3. Verify your AWS region is set correctly')
+    console.error('4. Check for any existing tables with the same names')
+    process.exit(1)
+  }
+}
+
+// Handle command line arguments
+const args = process.argv.slice(2)
+if (args.includes('--help') || args.includes('-h')) {
+  console.log('VibeCodingMachine Database Setup')
+  console.log('')
+  console.log('Usage: node setup-database.js [options]')
+  console.log('')
+  console.log('Options:')
+  console.log('  --help, -h     Show this help message')
+  console.log('  --status       Show current table status only')
+  console.log('')
+  console.log('Environment Variables:')
+  console.log('  AWS_REGION              AWS region (default: us-east-1)')
+  console.log('  AWS_ACCESS_KEY_ID       AWS access key')
+  console.log('  AWS_SECRET_ACCESS_KEY   AWS secret key')
+  console.log('')
+  console.log('Required AWS Permissions:')
+  console.log('  - dynamodb:CreateTable')
+  console.log('  - dynamodb:DescribeTable')
+  console.log('  - dynamodb:ListTables')
+  process.exit(0)
+}
+
+if (args.includes('--status')) {
+  // Just show status, don't run migrations
+  const migrations = new DatabaseMigrations()
+  migrations.getAllTableStatus().then(statuses => {
+    console.log('Current Table Status:')
+    statuses.forEach(status => {
+      const statusIcon = status.status === 'ACTIVE' ? '✅' : 
+                        status.status === 'NOT_FOUND' ? '❌' : '⏳'
+      console.log(`  ${statusIcon} ${status.name}: ${status.status}`)
+      if (status.itemCount !== undefined) {
+        console.log(`     Items: ${status.itemCount}, Size: ${Math.round(status.sizeBytes / 1024)} KB`)
+      }
+    })
+  }).catch(error => {
+    console.error('Error checking table status:', error.message)
+    process.exit(1)
+  })
+} else {
+  // Run full setup
+  main()
+}

package/src/auth/shared-auth-storage.js

@@ -46,13 +46,15 @@ class SharedAuthStorage {
   }
 
   /**
-   * Get stored token
+   * Get stored token (returns id_token for backward compatibility)
    */
   async getToken() {
     try {
       if (await fs.pathExists(TOKEN_FILE)) {
         const data = await fs.readJson(TOKEN_FILE);
-        return data.token;
+        // If data.token exists (old format), return it
+        // If data.id_token exists (new format), return it
+        return data.id_token || data.token;
       }
     } catch (error) {
       console.error('Failed to read token:', error);
@@ -61,15 +63,50 @@ class SharedAuthStorage {
   }
 
   /**
-   * Save token
+   * Get stored refresh token
    */
-  async saveToken(token) {
+  async getRefreshToken() {
+    try {
+      if (await fs.pathExists(TOKEN_FILE)) {
+        const data = await fs.readJson(TOKEN_FILE);
+        return data.refresh_token;
+      }
+    } catch (error) {
+      console.error('Failed to read refresh token:', error);
+    }
+    return null;
+  }
+
+  /**
+   * Save token (supports both string token and object with tokens)
+   */
+  async saveToken(tokenOrTokens) {
     await fs.ensureDir(CONFIG_DIR);
-    await fs.writeJson(TOKEN_FILE, { token }, { spaces: 2 });
+
+    let tokenData = {};
+    let idToken = '';
+
+    if (typeof tokenOrTokens === 'string') {
+      // Legacy format: just the ID token
+      tokenData = { token: tokenOrTokens, id_token: tokenOrTokens };
+      idToken = tokenOrTokens;
+    } else {
+      // New format: object with id_token, access_token, refresh_token
+      tokenData = {
+        id_token: tokenOrTokens.id_token,
+        access_token: tokenOrTokens.access_token,
+        refresh_token: tokenOrTokens.refresh_token,
+        // Keep legacy field for backward compatibility
+        token: tokenOrTokens.id_token
+      };
+      idToken = tokenOrTokens.id_token;
+    }
+
+    await fs.writeJson(TOKEN_FILE, tokenData, { spaces: 2 });
 
     // Also save user profile from token
     try {
-      const payload = this.decodeJWT(token);
+      const payload = this.decodeJWT(idToken);
       const email = payload.email;
 
       // Note: Beta access control is handled server-side by Cognito Pre-Auth Lambda

package/src/compliance/compliance-manager.js

@@ -0,0 +1,249 @@
+/**
+ * Compliance Manager for Terms of Service and Privacy Policy
+ * 
+ * This module handles checking and managing user compliance with
+ * terms of service and privacy policy requirements.
+ */
+
+const UserDatabase = require('../database/user-schema')
+const fs = require('fs').promises
+const path = require('path')
+
+class ComplianceManager {
+  constructor() {
+    this.userDb = new UserDatabase()
+  }
+
+  /**
+   * Check if user needs to acknowledge terms/privacy
+   * Returns what needs to be acknowledged
+   */
+  async checkComplianceStatus(userId) {
+    const user = await this.userDb.getUser(userId)
+    
+    if (!user) {
+      throw new Error('User not found')
+    }
+
+    const status = {
+      termsAccepted: user.termsAccepted || false,
+      privacyAccepted: user.privacyAccepted || false,
+      termsAcceptedDate: user.termsAcceptedDate,
+      privacyAcceptedDate: user.privacyAcceptedDate,
+      needsAcknowledgment: false,
+      requiredActions: []
+    }
+
+    // Check if terms need to be acknowledged
+    if (!status.termsAccepted) {
+      status.needsAcknowledgment = true
+      status.requiredActions.push('terms')
+    }
+
+    // Check if privacy policy needs to be acknowledged
+    if (!status.privacyAccepted) {
+      status.needsAcknowledgment = true
+      status.requiredActions.push('privacy')
+    }
+
+    return status
+  }
+
+  /**
+   * Record user's acknowledgment of terms and/or privacy policy
+   */
+  async recordAcknowledgment(userId, acknowledgments) {
+    const { terms, privacy } = acknowledgments
+    
+    const updateData = {}
+    
+    if (terms !== undefined) {
+      updateData.termsAccepted = terms
+    }
+    
+    if (privacy !== undefined) {
+      updateData.privacyAccepted = privacy
+    }
+
+    await this.userDb.updateComplianceStatus(userId, updateData)
+
+    // Log the acknowledgment activity
+    await this.userDb.trackActivity(userId, {
+      action: 'compliance_acknowledgment',
+      interface: 'system',
+      duration: 0,
+      metadata: {
+        termsAccepted: terms,
+        privacyAccepted: privacy,
+        timestamp: Date.now()
+      }
+    })
+
+    return await this.checkComplianceStatus(userId)
+  }
+
+  /**
+   * Get terms of service content
+   */
+  async getTermsOfService() {
+    try {
+      const termsPath = path.join(__dirname, '../../admin/src/content/terms-of-service.md')
+      const content = await fs.readFile(termsPath, 'utf8')
+      
+      return {
+        content,
+        version: '1.0',
+        effectiveDate: '2025-12-09',
+        lastUpdated: '2025-12-09'
+      }
+    } catch (error) {
+      // Fallback content if file not found
+      return {
+        content: this.getFallbackTerms(),
+        version: '1.0',
+        effectiveDate: '2025-12-09',
+        lastUpdated: '2025-12-09'
+      }
+    }
+  }
+
+  /**
+   * Get privacy policy content
+   */
+  async getPrivacyPolicy() {
+    try {
+      const privacyPath = path.join(__dirname, '../../admin/src/content/privacy-policy.md')
+      const content = await fs.readFile(privacyPath, 'utf8')
+      
+      return {
+        content,
+        version: '1.0',
+        effectiveDate: '2025-12-09',
+        lastUpdated: '2025-12-09'
+      }
+    } catch (error) {
+      // Fallback content if file not found
+      return {
+        content: this.getFallbackPrivacy(),
+        version: '1.0',
+        effectiveDate: '2025-12-09',
+        lastUpdated: '2025-12-09'
+      }
+    }
+  }
+
+  /**
+   * Get compliance summary for all users (admin function)
+   */
+  async getComplianceSummary() {
+    // This would typically scan all users, but for now return mock data
+    // In a real implementation, you'd scan the users table
+    
+    return {
+      totalUsers: 0,
+      compliantUsers: 0,
+      termsAcceptanceRate: 0,
+      privacyAcceptanceRate: 0,
+      recentAcknowledgments: [],
+      nonCompliantUsers: []
+    }
+  }
+
+  /**
+   * Generate compliance report for admin dashboard
+   */
+  async generateComplianceReport(options = {}) {
+    const { startDate, endDate, format = 'json' } = options
+    
+    // This would generate a detailed compliance report
+    // For now, return a basic structure
+    
+    const report = {
+      generatedAt: new Date().toISOString(),
+      period: {
+        start: startDate || new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+        end: endDate || new Date().toISOString()
+      },
+      summary: await this.getComplianceSummary(),
+      details: {
+        termsAcceptances: [],
+        privacyAcceptances: [],
+        pendingUsers: []
+      }
+    }
+
+    if (format === 'csv') {
+      return this.convertReportToCSV(report)
+    }
+
+    return report
+  }
+
+  /**
+   * Fallback terms of service content
+   */
+  getFallbackTerms() {
+    return `# Terms of Service
+
+By using VibeCodingMachine, you agree to these terms:
+
+1. Use the service responsibly and legally
+2. Respect intellectual property rights
+3. Do not attempt to harm or disrupt the service
+4. We may collect usage data to improve the service
+5. We reserve the right to modify these terms
+
+For full terms, visit: https://vibecodingmachine.com/terms
+
+Effective Date: December 9, 2025`
+  }
+
+  /**
+   * Fallback privacy policy content
+   */
+  getFallbackPrivacy() {
+    return `# Privacy Policy
+
+VibeCodingMachine collects and uses your information to provide our service:
+
+**Information We Collect:**
+- Account information (email, name)
+- Computer and system information
+- Usage statistics and activity logs
+- Project information you provide
+
+**How We Use Information:**
+- To provide and improve our service
+- For authentication and security
+- To track usage and performance
+- For customer support
+
+**Data Protection:**
+- We use industry-standard security measures
+- We do not sell your personal information
+- You can request data deletion
+
+For full privacy policy, visit: https://vibecodingmachine.com/privacy
+
+Effective Date: December 9, 2025`
+  }
+
+  /**
+   * Convert compliance report to CSV format
+   */
+  convertReportToCSV(report) {
+    // Basic CSV conversion - would be more detailed in real implementation
+    const headers = ['User ID', 'Email', 'Terms Accepted', 'Privacy Accepted', 'Date']
+    const rows = report.details.termsAcceptances.map(item => [
+      item.userId,
+      item.email,
+      item.termsAccepted,
+      item.privacyAccepted,
+      item.date
+    ])
+
+    return [headers, ...rows].map(row => row.join(',')).join('\n')
+  }
+}
+
+module.exports = ComplianceManager

package/src/compliance/compliance-prompt.js

@@ -0,0 +1,183 @@
+/**
+ * Compliance Prompt Utility
+ * 
+ * Handles prompting users for terms and privacy acceptance
+ * across CLI and Electron interfaces
+ */
+
+const ComplianceManager = require('./compliance-manager')
+
+class CompliancePrompt {
+  constructor() {
+    this.complianceManager = new ComplianceManager()
+  }
+
+  /**
+   * Check and prompt for compliance if needed
+   * Returns true if compliant, false if user declined
+   */
+  async checkAndPrompt(userId, interfaceType = 'cli') {
+    try {
+      const status = await this.complianceManager.checkComplianceStatus(userId)
+      
+      if (!status.needsAcknowledgment) {
+        return true
+      }
+
+      // Prompt based on interface
+      if (interfaceType === 'cli') {
+        return await this.promptCLI(userId, status)
+      } else if (interfaceType === 'electron') {
+        return await this.promptElectron(userId, status)
+      }
+
+      return false
+    } catch (error) {
+      console.error('Error checking compliance:', error)
+      return false
+    }
+  }
+
+  /**
+   * CLI prompt for compliance
+   */
+  async promptCLI(userId, status) {
+    const chalk = require('chalk')
+    
+    // Dynamically require inquirer (only available in CLI context)
+    let inquirer
+    try {
+      inquirer = require('inquirer')
+    } catch (error) {
+      throw new Error('inquirer module not available - CLI prompting not supported in this context')
+    }
+
+    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 this.complianceManager.getTermsOfService()
+      
+      console.log(chalk.yellow('📄 Terms of Service'))
+      console.log(chalk.gray('─'.repeat(70)))
+      console.log(this.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 this.complianceManager.getPrivacyPolicy()
+      
+      console.log(chalk.yellow('🔒 Privacy Policy'))
+      console.log(chalk.gray('─'.repeat(70)))
+      console.log(this.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 this.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
+  }
+
+  /**
+   * Electron prompt for compliance (returns HTML dialog)
+   */
+  async promptElectron(userId, status) {
+    // For Electron, we'll return the data needed to show a dialog
+    // The actual dialog will be handled by the Electron renderer
+    const data = {
+      needsTerms: status.requiredActions.includes('terms'),
+      needsPrivacy: status.requiredActions.includes('privacy')
+    }
+
+    if (data.needsTerms) {
+      data.terms = await this.complianceManager.getTermsOfService()
+    }
+
+    if (data.needsPrivacy) {
+      data.privacy = await this.complianceManager.getPrivacyPolicy()
+    }
+
+    return data
+  }
+
+  /**
+   * Record acceptance from Electron
+   */
+  async recordElectronAcceptance(userId, acceptTerms, acceptPrivacy) {
+    await this.complianceManager.recordAcknowledgment(userId, {
+      terms: acceptTerms,
+      privacy: acceptPrivacy
+    })
+    return true
+  }
+
+  /**
+   * Format markdown content for CLI display
+   */
+  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 = CompliancePrompt