vibecodingmachine-core 2025.12.24-2348 → 2025.12.25-1541

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-core",
-  "version": "2025.12.24-2348",
+  "version": "2025.12.25-1541",
   "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/database/user-database-client.js

@@ -228,13 +228,51 @@ 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)
    */
   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);

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
    */

package/src/sync/aws-setup.js

@@ -116,12 +116,12 @@ async function setupCognitoWithGoogle() {
     
     // Add Google OAuth provider if not already configured
     try {
-      const googleClientId = process.env.GOOGLE_CLIENT_ID;
+      const googleClientId = process.env.REACT_APP_GOOGLE_CLIENT_ID;
       const googleClientSecret = process.env.GOOGLE_CLIENT_SECRET;
       
       if (!googleClientId || !googleClientSecret) {
         console.log('⚠ Google OAuth credentials not provided. Skipping Google provider setup.');
-        console.log('  Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables.');
+        console.log('  Set REACT_APP_GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables.');
         return { userPoolId: existingPoolId, status: 'existing' };
       }
       
@@ -198,7 +198,7 @@ async function setupCognitoWithGoogle() {
     console.log(`✓ Created Cognito User Pool: ${userPoolId}`);
     
     // Add Google OAuth provider first (if credentials provided)
-    const googleClientId = process.env.GOOGLE_CLIENT_ID;
+    const googleClientId = process.env.REACT_APP_GOOGLE_CLIENT_ID;
     const googleClientSecret = process.env.GOOGLE_CLIENT_SECRET;
     
     let supportedProviders = ['COGNITO'];
@@ -231,7 +231,7 @@ async function setupCognitoWithGoogle() {
       }
     } else {
       console.log('⚠ Google OAuth credentials not provided');
-      console.log('  Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to enable Google login');
+      console.log('  Set REACT_APP_GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to enable Google login');
     }
     
     // Create app client