vibecodingmachine-core 2025.12.6-1702 → 2025.12.24-2348

package/src/database/migrations.js

@@ -0,0 +1,289 @@
+/**
+ * Database Migration Scripts for Enhanced User Tracking
+ * 
+ * This module handles creating and updating DynamoDB tables for the
+ * enhanced user tracking system.
+ */
+
+const { DynamoDBClient } = require('@aws-sdk/client-dynamodb')
+const { 
+  CreateTableCommand, 
+  DescribeTableCommand, 
+  UpdateTableCommand,
+  ListTablesCommand 
+} = require('@aws-sdk/client-dynamodb')
+
+class DatabaseMigrations {
+  constructor() {
+    this.client = new DynamoDBClient({
+      region: process.env.AWS_REGION || 'us-east-1'
+    })
+  }
+
+  /**
+   * Run all migrations to set up the enhanced user tracking system
+   */
+  async runMigrations() {
+    console.log('🔄 Running database migrations...')
+    
+    try {
+      await this.createUsersTable()
+      await this.createComputersTable()
+      await this.createProjectsTable()
+      await this.createActivityTable()
+      
+      console.log('✅ All migrations completed successfully')
+    } catch (error) {
+      console.error('❌ Migration failed:', error)
+      throw error
+    }
+  }
+
+  /**
+   * Create users table with enhanced schema
+   */
+  async createUsersTable() {
+    const tableName = 'vibecodingmachine-users'
+    
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'userId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'userId', AttributeType: 'S' },
+        { AttributeName: 'email', AttributeType: 'S' },
+        { AttributeName: 'registrationDate', AttributeType: 'N' }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: 'EmailIndex',
+          KeySchema: [
+            { AttributeName: 'email', KeyType: 'HASH' }
+          ],
+          Projection: { ProjectionType: 'ALL' },
+          BillingMode: 'PAY_PER_REQUEST'
+        },
+        {
+          IndexName: 'RegistrationDateIndex',
+          KeySchema: [
+            { AttributeName: 'registrationDate', KeyType: 'HASH' }
+          ],
+          Projection: { ProjectionType: 'ALL' },
+          BillingMode: 'PAY_PER_REQUEST'
+        }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Create computers table for tracking user devices
+   */
+  async createComputersTable() {
+    const tableName = 'vibecodingmachine-computers'
+    
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'computerId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'computerId', AttributeType: 'S' },
+        { AttributeName: 'userId', AttributeType: 'S' },
+        { AttributeName: 'lastSeen', AttributeType: 'N' }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: 'UserIdIndex',
+          KeySchema: [
+            { AttributeName: 'userId', KeyType: 'HASH' },
+            { AttributeName: 'lastSeen', KeyType: 'RANGE' }
+          ],
+          Projection: { ProjectionType: 'ALL' },
+          BillingMode: 'PAY_PER_REQUEST'
+        }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Create projects table for tracking user projects
+   */
+  async createProjectsTable() {
+    const tableName = 'vibecodingmachine-projects'
+    
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'projectId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'projectId', AttributeType: 'S' },
+        { AttributeName: 'userId', AttributeType: 'S' },
+        { AttributeName: 'createdAt', AttributeType: 'N' }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: 'UserIdIndex',
+          KeySchema: [
+            { AttributeName: 'userId', KeyType: 'HASH' },
+            { AttributeName: 'createdAt', KeyType: 'RANGE' }
+          ],
+          Projection: { ProjectionType: 'ALL' },
+          BillingMode: 'PAY_PER_REQUEST'
+        }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Create activity table for detailed usage tracking
+   */
+  async createActivityTable() {
+    const tableName = 'vibecodingmachine-activity'
+    
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'activityId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'activityId', AttributeType: 'S' },
+        { AttributeName: 'userId', AttributeType: 'S' },
+        { AttributeName: 'createdAt', AttributeType: 'N' }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: 'UserIdIndex',
+          KeySchema: [
+            { AttributeName: 'userId', KeyType: 'HASH' },
+            { AttributeName: 'createdAt', KeyType: 'RANGE' }
+          ],
+          Projection: { ProjectionType: 'ALL' },
+          BillingMode: 'PAY_PER_REQUEST'
+        }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      TimeToLiveSpecification: {
+        AttributeName: 'ttl',
+        Enabled: true
+      },
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Check if a table exists
+   */
+  async tableExists(tableName) {
+    try {
+      await this.client.send(new DescribeTableCommand({ TableName: tableName }))
+      return true
+    } catch (error) {
+      if (error.name === 'ResourceNotFoundException') {
+        return false
+      }
+      throw error
+    }
+  }
+
+  /**
+   * List all VibeCodingMachine tables
+   */
+  async listTables() {
+    const response = await this.client.send(new ListTablesCommand({}))
+    return response.TableNames.filter(name => name.startsWith('vibecodingmachine-'))
+  }
+
+  /**
+   * Get table status
+   */
+  async getTableStatus(tableName) {
+    try {
+      const response = await this.client.send(new DescribeTableCommand({ TableName: tableName }))
+      return {
+        name: tableName,
+        status: response.Table.TableStatus,
+        itemCount: response.Table.ItemCount,
+        sizeBytes: response.Table.TableSizeBytes,
+        created: response.Table.CreationDateTime
+      }
+    } catch (error) {
+      return {
+        name: tableName,
+        status: 'NOT_FOUND',
+        error: error.message
+      }
+    }
+  }
+
+  /**
+   * Get status of all tables
+   */
+  async getAllTableStatus() {
+    const tableNames = [
+      'vibecodingmachine-users',
+      'vibecodingmachine-computers',
+      'vibecodingmachine-projects',
+      'vibecodingmachine-activity'
+    ]
+
+    const statuses = await Promise.all(
+      tableNames.map(name => this.getTableStatus(name))
+    )
+
+    return statuses
+  }
+}
+
+module.exports = DatabaseMigrations

package/src/database/user-database-client.js

@@ -0,0 +1,266 @@
+/**
+ * Client-side User Database for VibeCodingMachine
+ * 
+ * This version makes HTTP requests to the API server instead of
+ * directly accessing AWS DynamoDB.
+ */
+
+const os = require('os');
+const crypto = require('crypto');
+
+// Use node-fetch for older Node.js versions that don't have fetch built-in
+let fetch;
+try {
+  fetch = globalThis.fetch || require('node-fetch');
+} catch (err) {
+  console.warn('UserDatabaseClient: fetch not available, API requests will fail');
+}
+
+class UserDatabaseClient {
+  constructor(apiBaseUrl = null) {
+    // Default to production API server, or use provided URL
+    this.apiBaseUrl = apiBaseUrl || process.env.VIBECODINGMACHINE_API_URL || 'https://api.vibecodingmachine.com';
+    this.authToken = null;
+  }
+
+  /**
+   * Set the authentication token for API requests
+   */
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+
+  /**
+   * Make authenticated API request
+   */
+  async apiRequest(endpoint, options = {}) {
+    const url = `${this.apiBaseUrl}${endpoint}`;
+    const headers = {
+      'Content-Type': 'application/json',
+      ...options.headers
+    };
+
+    if (this.authToken) {
+      headers.Authorization = `Bearer ${this.authToken}`;
+    }
+
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Network error' }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Register or update user in the database
+   */
+  async registerUser(userInfo) {
+    if (!this.authToken) {
+      console.warn('UserDatabase: No auth token, skipping user registration');
+      return null;
+    }
+
+    try {
+      const result = await this.apiRequest('/api/users/register', {
+        method: 'POST',
+        body: JSON.stringify(userInfo)
+      });
+      return result.user;
+    } catch (error) {
+      console.warn('UserDatabase: registerUser failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Register or update computer information
+   */
+  async registerComputer(userId, computerInfo = {}) {
+    if (!this.authToken) {
+      console.warn('UserDatabase: No auth token, skipping computer registration');
+      return null;
+    }
+
+    try {
+      // Collect local computer info
+      const localInfo = {
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        release: os.release(),
+        cpus: os.cpus().length,
+        totalMemory: Math.round(os.totalmem() / (1024 * 1024 * 1024)), // GB
+        ipAddress: this.getLocalIP(),
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        ...computerInfo
+      };
+
+      const result = await this.apiRequest('/api/computers/register', {
+        method: 'POST',
+        body: JSON.stringify(localInfo)
+      });
+      return result.computer;
+    } catch (error) {
+      console.warn('UserDatabase: registerComputer failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Register a new project
+   */
+  async registerProject(userId, projectInfo) {
+    if (!this.authToken) {
+      console.warn('UserDatabase: No auth token, skipping project registration');
+      return null;
+    }
+
+    try {
+      const result = await this.apiRequest('/api/projects/register', {
+        method: 'POST',
+        body: JSON.stringify(projectInfo)
+      });
+      return result.project;
+    } catch (error) {
+      console.warn('UserDatabase: registerProject failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Update user's terms and privacy acceptance
+   */
+  async updateComplianceStatus(userId, complianceData) {
+    if (!this.authToken) {
+      console.warn('UserDatabase: updateComplianceStatus skipped (no auth token)');
+      return;
+    }
+
+    try {
+      await this.apiRequest('/api/users/compliance', {
+        method: 'POST',
+        body: JSON.stringify(complianceData)
+      });
+    } catch (error) {
+      console.warn('UserDatabase: updateComplianceStatus failed:', error.message);
+    }
+  }
+
+  /**
+   * Track user activity and interface usage
+   */
+  async trackActivity(userId, activityData) {
+    if (!this.authToken) {
+      console.warn('UserDatabase: trackActivity skipped (no auth token)');
+      return;
+    }
+
+    try {
+      await this.apiRequest('/api/users/activity', {
+        method: 'POST',
+        body: JSON.stringify(activityData)
+      });
+    } catch (error) {
+      console.warn('UserDatabase: trackActivity failed:', error.message);
+    }
+  }
+
+  /**
+   * Get user by ID (not implemented client-side for security)
+   */
+  async getUser(userId) {
+    if (!this.authToken) {
+      return null;
+    }
+
+    try {
+      const result = await this.apiRequest('/api/users/me');
+      return result.user;
+    } catch (error) {
+      console.warn('UserDatabase: getUser failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get user by email
+   */
+  async getUserByEmail(email) {
+    // Client-side implementation just calls getUser
+    return this.getUser(this.generateUserId(email));
+  }
+
+  /**
+   * Update user activity timestamp (handled by trackActivity)
+   */
+  async updateUserActivity(userId, updates) {
+    // This is handled by trackActivity on the client side
+    console.warn('UserDatabase: updateUserActivity not implemented on client side');
+  }
+
+  /**
+   * Check if user has accepted terms and privacy policy
+   */
+  async checkCompliance(userId) {
+    if (!this.authToken) {
+      return { termsAccepted: false, privacyAccepted: false };
+    }
+
+    try {
+      const result = await this.apiRequest('/api/users/compliance');
+      return result.compliance;
+    } catch (error) {
+      console.warn('UserDatabase: checkCompliance failed:', error.message);
+      return { termsAccepted: false, privacyAccepted: false };
+    }
+  }
+
+  /**
+   * Set admin status (not allowed from client)
+   */
+  async setAdminStatus(userId, isAdmin) {
+    throw new Error('setAdminStatus not allowed from client');
+  }
+
+  /**
+   * Check if user is an admin (not implemented client-side for security)
+   */
+  async isAdmin(userId) {
+    return false; // Client-side can't check admin status
+  }
+
+  // Helper methods (same as server-side)
+  generateUserId(email) {
+    return crypto.createHash('sha256').update(email.toLowerCase()).digest('hex').substring(0, 16);
+  }
+
+  generateComputerId() {
+    const hostname = os.hostname();
+    const platform = os.platform();
+    return crypto.createHash('sha256').update(`${hostname}-${platform}-${Date.now()}`).digest('hex').substring(0, 16);
+  }
+
+  generateProjectId() {
+    return crypto.createHash('sha256').update(`${Date.now()}-${Math.random()}`).digest('hex').substring(0, 16);
+  }
+
+  getLocalIP() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const networkInterface of interfaces[name]) {
+        if (networkInterface.family === 'IPv4' && !networkInterface.internal) {
+          return networkInterface.address;
+        }
+      }
+    }
+    return '127.0.0.1';
+  }
+}
+
+module.exports = UserDatabaseClient;

package/src/database/user-schema.js

@@ -0,0 +1,118 @@
+/**
+ * User Database for VibeCodingMachine Client Applications
+ * 
+ * This is the CLIENT-SIDE version that makes HTTP requests to the API server.
+ * The API server handles all direct AWS operations.
+ * 
+ * This replaces the old direct AWS approach for better security and architecture.
+ */
+
+const UserDatabaseClient = require('./user-database-client')
+
+class UserDatabase {
+  constructor() {
+    // This is now ALWAYS the client version
+    // The API server uses a separate UserDatabase class
+    this.apiClient = new UserDatabaseClient()
+    console.log('UserDatabase: Client mode - will make API requests to server')
+  }
+
+  /**
+   * Set authentication token for API requests
+   */
+  setAuthToken(token) {
+    this.apiClient.setAuthToken(token)
+  }
+
+  /**
+   * Register or update user in the database
+   */
+  async registerUser(userInfo) {
+    return this.apiClient.registerUser(userInfo)
+  }
+
+  /**
+   * Register or update computer information
+   */
+  async registerComputer(userId, computerInfo = {}) {
+    return this.apiClient.registerComputer(userId, computerInfo)
+  }
+
+  /**
+   * Register a new project
+   */
+  async registerProject(userId, projectInfo) {
+    return this.apiClient.registerProject(userId, projectInfo)
+  }
+
+  /**
+   * Update user's terms and privacy acceptance
+   */
+  async updateComplianceStatus(userId, complianceData) {
+    return this.apiClient.updateComplianceStatus(userId, complianceData)
+  }
+
+  /**
+   * Track user activity and interface usage
+   */
+  async trackActivity(userId, activityData) {
+    return this.apiClient.trackActivity(userId, activityData)
+  }
+
+  /**
+   * Get user by ID
+   */
+  async getUser(userId) {
+    return this.apiClient.getUser(userId)
+  }
+
+  /**
+   * Get user by email
+   */
+  async getUserByEmail(email) {
+    return this.apiClient.getUserByEmail(email)
+  }
+
+  /**
+   * Update user activity timestamp
+   */
+  async updateUserActivity(userId, updates) {
+    return this.apiClient.updateUserActivity(userId, updates)
+  }
+
+  /**
+   * Check if user has accepted terms and privacy policy
+   */
+  async checkCompliance(userId) {
+    return this.apiClient.checkCompliance(userId)
+  }
+
+  /**
+   * Set admin status for a user (not allowed from client)
+   */
+  async setAdminStatus(userId, isAdmin) {
+    return this.apiClient.setAdminStatus(userId, isAdmin)
+  }
+
+  /**
+   * Check if user is an admin
+   */
+  async isAdmin(userId) {
+    return this.apiClient.isAdmin(userId)
+  }
+
+  // Helper methods - delegate to API client
+  generateUserId(email) {
+    return this.apiClient.generateUserId(email)
+  }
+
+  generateComputerId() {
+    return this.apiClient.generateComputerId()
+  }
+
+  generateProjectId() {
+    return this.apiClient.generateProjectId()
+  }
+}
+
+module.exports = UserDatabase