vibecodingmachine-core 2025.12.25-25 → 2026.1.22-1441

package/__tests__/utils/git-branch-manager.test.js

@@ -0,0 +1,61 @@
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { isGitRepo, getCurrentBranch, hasUncommittedChanges } = require('../../src/utils/git-branch-manager');
+
+describe('git-branch-manager', () => {
+    let tempRepoPath;
+
+    beforeEach(async () => {
+        tempRepoPath = path.join(os.tmpdir(), `vcm-test-repo-${Date.now()}`);
+        await fs.ensureDir(tempRepoPath);
+    });
+
+    afterEach(async () => {
+        await fs.remove(tempRepoPath);
+    });
+
+    const initRepo = () => {
+        execSync('git init', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git config user.email "test@example.com"', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git config user.name "Test User"', { cwd: tempRepoPath, stdio: 'ignore' });
+    };
+
+    test('isGitRepo identifies git repositories', () => {
+        expect(isGitRepo(tempRepoPath)).toBe(false);
+        initRepo();
+        expect(isGitRepo(tempRepoPath)).toBe(true);
+    });
+
+    test('getCurrentBranch returns the current branch name', async () => {
+        initRepo();
+        // Must commit something for HEAD to exist
+        await fs.writeFile(path.join(tempRepoPath, 'initial.txt'), 'init');
+        execSync('git add .', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git commit -m "initial commit"', { cwd: tempRepoPath, stdio: 'ignore' });
+
+        const branch = getCurrentBranch(tempRepoPath);
+        expect(branch).toMatch(/^(main|master)$/);
+    });
+
+    test('hasUncommittedChanges detects dirty repository', async () => {
+        initRepo();
+        // Should be false initially (even if empty)
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(false);
+
+        // Create a file
+        await fs.writeFile(path.join(tempRepoPath, 'test.txt'), 'hello');
+        // Untracked file counts as uncommitted change
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(true);
+
+        // Commit it
+        execSync('git add .', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git commit -m "initial commit"', { cwd: tempRepoPath, stdio: 'ignore' });
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(false);
+
+        // Modify it
+        await fs.appendFile(path.join(tempRepoPath, 'test.txt'), ' world');
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-core",
-  "version": "2025.12.25-0025",
+  "version": "2026.01.22-1441",
   "description": "Shared core logic for Vibe Coding Machine IDE integration",
   "main": "src/index.cjs",
   "module": "src/index.js",

package/src/beta-request.js

@@ -0,0 +1,160 @@
+/**
+ * Beta Request Management for VibeCodingMachine
+ * 
+ * Handles beta access requests from web, CLI, and GUI applications
+ */
+
+const crypto = require('crypto');
+
+class BetaRequestManager {
+  constructor(apiBaseUrl = null) {
+    this.apiBaseUrl = apiBaseUrl || process.env.VIBECODINGMACHINE_API_URL || 'https://api.vibecodingmachine.com';
+    this.authToken = null;
+  }
+
+  /**
+   * Set 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 fetch = globalThis.fetch || require('node-fetch');
+    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();
+  }
+
+  /**
+   * Submit a beta access request
+   */
+  async submitBetaRequest(requestData) {
+    try {
+      const result = await this.apiRequest('/api/beta/request', {
+        method: 'POST',
+        body: JSON.stringify({
+          ...requestData,
+          requestDate: Date.now(),
+          status: 'REQUEST'
+        })
+      });
+      return result;
+    } catch (error) {
+      console.error('Beta request submission failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if user already has a pending or approved request
+   */
+  async checkExistingRequest(email) {
+    try {
+      const userId = this.generateUserId(email);
+      const result = await this.apiRequest(`/api/users/${userId}`);
+      return result.user;
+    } catch (error) {
+      // User doesn't exist or API error
+      return null;
+    }
+  }
+
+  /**
+   * Validate request data
+   */
+  validateRequestData(data) {
+    const errors = [];
+
+    if (!data.email || !data.email.trim()) {
+      errors.push('Email is required');
+    }
+
+    if (data.email && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(data.email)) {
+      errors.push('Invalid email format');
+    }
+
+    if (!data.name || !data.name.trim()) {
+      errors.push('Name is required');
+    }
+
+    if (!data.language) {
+      errors.push('Language preference is required');
+    }
+
+    if (!data.appPurpose || !data.appPurpose.trim()) {
+      errors.push('App purpose description is required');
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Get supported languages
+   */
+  getSupportedLanguages() {
+    return {
+      'en': 'English',
+      'es': 'Spanish'
+    };
+  }
+
+  /**
+   * Generate user ID from email (consistent with existing system)
+   */
+  generateUserId(email) {
+    return crypto.createHash('sha256').update(email.toLowerCase()).digest('hex').substring(0, 16);
+  }
+
+  /**
+   * Format request data for email notification
+   */
+  formatRequestForEmail(requestData) {
+    const supportedLanguages = this.getSupportedLanguages();
+    const languageName = supportedLanguages[requestData.language] || requestData.language;
+
+    return {
+      recipient: 'jesse.d.olsen@gmail.com',
+      subject: `New Beta Request: ${requestData.name} (${requestData.email})`,
+      body: `
+New VibeCodingMachine beta access request received:
+
+Name: ${requestData.name}
+Email: ${requestData.email}
+Language: ${languageName}
+App Purpose: ${requestData.appPurpose}
+Other Info: ${requestData.otherInfo || 'None provided'}
+Request Date: ${new Date(requestData.requestDate).toLocaleString()}
+Source: ${requestData.source || 'Unknown'}
+
+Please review and approve/reject this request in the admin panel.
+      `.trim()
+    };
+  }
+}
+
+module.exports = BetaRequestManager;

package/src/compliance/compliance-manager.js

@@ -10,8 +10,11 @@ const fs = require('fs').promises
 const path = require('path')
 
 class ComplianceManager {
-  constructor() {
+  constructor(authToken = null) {
     this.userDb = new UserDatabase()
+    if (authToken) {
+      this.userDb.setAuthToken(authToken)
+    }
   }
 
   /**
@@ -19,7 +22,7 @@ class ComplianceManager {
    * Returns what needs to be acknowledged
    */
   async checkComplianceStatus(userId) {
-    const user = await this.userDb.getUser(userId)
+    const user = await this.userDb.getUser()
     
     if (!user) {
       throw new Error('User not found')

package/src/database/migrations.js

@@ -6,11 +6,11 @@
  */
 
 const { DynamoDBClient } = require('@aws-sdk/client-dynamodb')
-const { 
-  CreateTableCommand, 
-  DescribeTableCommand, 
+const {
+  CreateTableCommand,
+  DescribeTableCommand,
   UpdateTableCommand,
-  ListTablesCommand 
+  ListTablesCommand
 } = require('@aws-sdk/client-dynamodb')
 
 class DatabaseMigrations {
@@ -25,13 +25,15 @@ class DatabaseMigrations {
    */
   async runMigrations() {
     console.log('🔄 Running database migrations...')
-    
+
     try {
       await this.createUsersTable()
       await this.createComputersTable()
       await this.createProjectsTable()
       await this.createActivityTable()
-      
+      await this.createErrorsTable()
+      await this.createFeedbackTable()
+
       console.log('✅ All migrations completed successfully')
     } catch (error) {
       console.error('❌ Migration failed:', error)
@@ -44,7 +46,7 @@ class DatabaseMigrations {
    */
   async createUsersTable() {
     const tableName = 'vibecodingmachine-users'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -94,7 +96,7 @@ class DatabaseMigrations {
    */
   async createComputersTable() {
     const tableName = 'vibecodingmachine-computers'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -137,7 +139,7 @@ class DatabaseMigrations {
    */
   async createProjectsTable() {
     const tableName = 'vibecodingmachine-projects'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -180,7 +182,7 @@ class DatabaseMigrations {
    */
   async createActivityTable() {
     const tableName = 'vibecodingmachine-activity'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -222,6 +224,126 @@ class DatabaseMigrations {
     console.log(`✅ Created table: ${tableName}`)
   }
 
+  /**
+   * Create errors table for tracking application errors
+   */
+  async createErrorsTable() {
+    const tableName = 'vibecodingmachine-errors'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'errorId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'errorId', AttributeType: 'S' }
+      ],
+      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 feedback table for user comments
+   */
+  async createFeedbackTable() {
+    const tableName = 'vibecodingmachine-feedback'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'feedbackId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'feedbackId', AttributeType: 'S' }
+      ],
+      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 errors table for tracking application errors
+   */
+  async createErrorsTable() {
+    const tableName = 'vibecodingmachine-errors'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'errorId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'errorId', AttributeType: 'S' }
+      ],
+      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 feedback table for user comments
+   */
+  async createFeedbackTable() {
+    const tableName = 'vibecodingmachine-feedback'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'feedbackId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'feedbackId', AttributeType: 'S' }
+      ],
+      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}`)
+  }
+
   /**
    * Check if a table exists
    */
@@ -272,10 +394,11 @@ class DatabaseMigrations {
    */
   async getAllTableStatus() {
     const tableNames = [
-      'vibecodingmachine-users',
       'vibecodingmachine-computers',
       'vibecodingmachine-projects',
-      'vibecodingmachine-activity'
+      'vibecodingmachine-activity',
+      'vibecodingmachine-errors',
+      'vibecodingmachine-feedback'
     ]
 
     const statuses = await Promise.all(

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

@@ -18,9 +18,21 @@ try {
 
 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';
+    // Check if we're in a development workspace
+    const fs = require('fs');
+    const path = require('path');
+    const rootDir = path.join(__dirname, '..', '..', '..', '..');
+    const isDevWorkspace = fs.existsSync(path.join(rootDir, '.git'));
+    
+    // Default to local dev server in development, production otherwise
+    if (isDevWorkspace && !apiBaseUrl && !process.env.VIBECODINGMACHINE_API_URL) {
+      this.apiBaseUrl = 'http://localhost:3457';
+    } else {
+      this.apiBaseUrl = apiBaseUrl || process.env.VIBECODINGMACHINE_API_URL || 'https://api.vibecodingmachine.com';
+    }
+    
     this.authToken = null;
+    console.log(require('chalk').gray(`UserDatabaseClient: Using API at ${this.apiBaseUrl}`));
   }
 
   /**
@@ -44,14 +56,36 @@ class UserDatabaseClient {
       headers.Authorization = `Bearer ${this.authToken}`;
     }
 
-    const response = await fetch(url, {
-      ...options,
-      headers
-    });
+    let response;
+    try {
+      response = await fetch(url, {
+        ...options,
+        headers
+      });
+    } catch (fetchError) {
+      const msg = `Connection failed: ${fetchError.message}`;
+      console.warn(`UserDatabaseClient: ${msg} [${url}]`);
+      throw new Error(msg);
+    }
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Network error' }));
-      throw new Error(error.error || `HTTP ${response.status}`);
+      let errorDetail = '';
+      let bodyText = '';
+      try {
+        bodyText = await response.text();
+        try {
+          const errorJson = JSON.parse(bodyText);
+          errorDetail = errorJson.error || errorJson.message || '';
+        } catch (e) {
+          errorDetail = bodyText;
+        }
+      } catch (e) {
+        errorDetail = 'Could not read response body';
+      }
+
+      if (errorDetail.length > 200) errorDetail = errorDetail.substring(0, 200) + '...';
+      const errorMsg = errorDetail || `HTTP ${response.status}`;
+      throw new Error(errorMsg);
     }
 
     return response.json();
@@ -228,6 +262,45 @@ class UserDatabaseClient {
     throw new Error('setAdminStatus not allowed from client');
   }
 
+  /**
+   * Submit a beta access request
+   */
+  async submitBetaRequest(requestData) {
+    if (!this.authToken) {
+      console.warn('UserDatabase: No auth token, beta request submission requires authentication');
+      throw new Error('Authentication required for beta request');
+    }
+
+    try {
+      const result = await this.apiRequest('/api/beta/request', {
+        method: 'POST',
+        body: JSON.stringify({
+          ...requestData,
+          requestDate: Date.now(),
+          status: 'REQUEST'
+        })
+      });
+      return result;
+    } catch (error) {
+      console.warn('UserDatabase: submitBetaRequest failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if user already has a pending or approved request
+   */
+  async checkExistingRequest(email) {
+    try {
+      const userId = this.generateUserId(email);
+      const result = await this.apiRequest(`/api/users/${userId}`);
+      return result.user;
+    } catch (error) {
+      // User doesn't exist or API error
+      return null;
+    }
+  }
+
   /**
    * Check if user is an admin (not implemented client-side for security)
    */
@@ -235,6 +308,52 @@ class UserDatabaseClient {
     return false; // Client-side can't check admin status
   }
 
+  /**
+   * Submit user feedback to the admin database
+   */
+  async submitFeedback(feedbackData) {
+    try {
+      const response = await this.apiRequest('/api/feedback', {
+        method: 'POST',
+        body: JSON.stringify({
+          timestamp: Date.now(),
+          hostname: os.hostname(),
+          platform: os.platform(),
+          ...feedbackData
+        })
+      });
+      return response;
+    } catch (error) {
+      console.warn('UserDatabase: submitFeedback failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Report an error to the admin database for tracking and fixing
+   */
+  async reportError(errorData) {
+    try {
+      const errorReport = {
+        timestamp: Date.now(),
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion: process.version,
+        ...errorData
+      };
+
+      await this.apiRequest('/api/errors/report', {
+        method: 'POST',
+        body: JSON.stringify(errorReport)
+      });
+
+      return true;
+    } catch (error) {
+      console.warn('UserDatabase: reportError failed:', error.message);
+      return false;
+    }
+  }
   // Helper methods (same as server-side)
   generateUserId(email) {
     return crypto.createHash('sha256').update(email.toLowerCase()).digest('hex').substring(0, 16);

package/src/database/user-schema.js

@@ -94,6 +94,20 @@ class UserDatabase {
     return this.apiClient.setAdminStatus(userId, isAdmin)
   }
 
+  /**
+   * Submit a beta access request
+   */
+  async submitBetaRequest(requestData) {
+    return this.apiClient.submitBetaRequest(requestData)
+  }
+
+  /**
+   * Check if user already has a pending or approved request
+   */
+  async checkExistingRequest(email) {
+    return this.apiClient.checkExistingRequest(email)
+  }
+
   /**
    * Check if user is an admin
    */
@@ -101,6 +115,20 @@ class UserDatabase {
     return this.apiClient.isAdmin(userId)
   }
 
+  /**
+   * Submit user feedback to the admin database
+   */
+  async submitFeedback(feedbackData) {
+    return this.apiClient.submitFeedback(feedbackData)
+  }
+
+  /**
+   * Report an error to the admin database for tracking and fixing
+   */
+  async reportError(errorData) {
+    return this.apiClient.reportError(errorData)
+  }
+
   // Helper methods - delegate to API client
   generateUserId(email) {
     return this.apiClient.generateUserId(email)