vibecodingmachine-core 2025.11.2-9.855 → 2025.12.6-1702

package/src/sync/aws-setup.js

@@ -0,0 +1,445 @@
+/**
+ * AWS Infrastructure Setup for Vibe Coding Machine Multi-Computer Sync
+ * 
+ * This script sets up:
+ * 1. DynamoDB table for requirements storage
+ * 2. Cognito User Pool with Google OAuth
+ * 3. API Gateway for REST endpoints
+ * 4. Lambda functions for sync logic
+ */
+
+const { 
+  DynamoDBClient, 
+  CreateTableCommand, 
+  DescribeTableCommand 
+} = require('@aws-sdk/client-dynamodb');
+
+const {
+  CognitoIdentityProviderClient,
+  CreateUserPoolCommand,
+  CreateUserPoolClientCommand,
+  CreateIdentityProviderCommand,
+  DescribeUserPoolCommand
+} = require('@aws-sdk/client-cognito-identity-provider');
+
+const region = process.env.AWS_REGION || 'us-east-1';
+
+/**
+ * Create DynamoDB table for requirements sync
+ */
+async function createDynamoDBTable() {
+  const client = new DynamoDBClient({ region });
+  const tableName = 'vibecodingmachine-requirements';
+  
+  try {
+    // Check if table already exists
+    try {
+      const describeCommand = new DescribeTableCommand({ TableName: tableName });
+      await client.send(describeCommand);
+      console.log(`✓ DynamoDB table '${tableName}' already exists`);
+      return { tableName, status: 'exists' };
+    } catch (error) {
+      if (error.name !== 'ResourceNotFoundException') {
+        throw error;
+      }
+    }
+    
+    // Create table
+    const command = new CreateTableCommand({
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'computerId', KeyType: 'HASH' },  // Partition key
+        { AttributeName: 'timestamp', KeyType: 'RANGE' }   // Sort key
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'computerId', AttributeType: 'S' },
+        { AttributeName: 'timestamp', AttributeType: 'N' },
+        { AttributeName: 'requirementId', AttributeType: 'S' }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: 'requirementId-index',
+          KeySchema: [
+            { AttributeName: 'requirementId', KeyType: 'HASH' }
+          ],
+          Projection: { ProjectionType: 'ALL' }
+        },
+        {
+          IndexName: 'timestamp-index',
+          KeySchema: [
+            { AttributeName: 'timestamp', KeyType: 'HASH' }
+          ],
+          Projection: { ProjectionType: 'ALL' }
+        }
+      ],
+      BillingMode: 'PAY_PER_REQUEST', // On-demand pricing (no ProvisionedThroughput needed)
+      StreamSpecification: {
+        StreamEnabled: true,
+        StreamViewType: 'NEW_AND_OLD_IMAGES'
+      },
+      TimeToLiveSpecification: {
+        Enabled: true,
+        AttributeName: 'ttl'
+      },
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Purpose', Value: 'RequirementsSync' }
+      ]
+    });
+    
+    const response = await client.send(command);
+    console.log(`✓ Created DynamoDB table '${tableName}'`);
+    console.log(`  ARN: ${response.TableDescription.TableArn}`);
+    
+    return {
+      tableName,
+      status: 'created',
+      arn: response.TableDescription.TableArn
+    };
+  } catch (error) {
+    console.error(`✗ Failed to create DynamoDB table:`, error.message);
+    throw error;
+  }
+}
+
+/**
+ * Create or update Cognito User Pool with Google OAuth
+ */
+async function setupCognitoWithGoogle() {
+  const client = new CognitoIdentityProviderClient({ region });
+  
+  // Use existing user pool if specified
+  const existingPoolId = process.env.COGNITO_USER_POOL_ID;
+  
+  if (existingPoolId) {
+    console.log(`✓ Using existing Cognito User Pool: ${existingPoolId}`);
+    
+    // Add Google OAuth provider if not already configured
+    try {
+      const googleClientId = process.env.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.');
+        return { userPoolId: existingPoolId, status: 'existing' };
+      }
+      
+      const providerCommand = new CreateIdentityProviderCommand({
+        UserPoolId: existingPoolId,
+        ProviderName: 'Google',
+        ProviderType: 'Google',
+        ProviderDetails: {
+          client_id: googleClientId,
+          client_secret: googleClientSecret,
+          authorize_scopes: 'openid email profile'
+        },
+        AttributeMapping: {
+          email: 'email',
+          name: 'name',
+          picture: 'picture',
+          username: 'sub'
+        }
+      });
+      
+      await client.send(providerCommand);
+      console.log('✓ Added Google OAuth provider to Cognito User Pool');
+    } catch (error) {
+      if (error.name === 'DuplicateProviderException') {
+        console.log('✓ Google OAuth provider already configured');
+      } else {
+        console.error('⚠ Failed to add Google provider:', error.message);
+      }
+    }
+    
+    return { userPoolId: existingPoolId, status: 'existing' };
+  }
+  
+  // Create new user pool
+  console.log('Creating new Cognito User Pool...');
+  
+  try {
+    const poolCommand = new CreateUserPoolCommand({
+      PoolName: 'vibecodingmachine-users',
+      Policies: {
+        PasswordPolicy: {
+          MinimumLength: 8,
+          RequireUppercase: true,
+          RequireLowercase: true,
+          RequireNumbers: true,
+          RequireSymbols: false
+        }
+      },
+      AutoVerifiedAttributes: ['email'],
+      UsernameAttributes: ['email'],
+      Schema: [
+        {
+          Name: 'email',
+          AttributeDataType: 'String',
+          Required: true,
+          Mutable: true
+        },
+        {
+          Name: 'name',
+          AttributeDataType: 'String',
+          Required: false,
+          Mutable: true
+        }
+      ],
+      UserPoolTags: {
+        Application: 'VibeCodingMachine',
+        Purpose: 'Authentication'
+      }
+    });
+    
+    const poolResponse = await client.send(poolCommand);
+    const userPoolId = poolResponse.UserPool.Id;
+    
+    console.log(`✓ Created Cognito User Pool: ${userPoolId}`);
+    
+    // Add Google OAuth provider first (if credentials provided)
+    const googleClientId = process.env.GOOGLE_CLIENT_ID;
+    const googleClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+    
+    let supportedProviders = ['COGNITO'];
+    
+    if (googleClientId && googleClientSecret) {
+      try {
+        const providerCommand = new CreateIdentityProviderCommand({
+          UserPoolId: userPoolId,
+          ProviderName: 'Google',
+          ProviderType: 'Google',
+          ProviderDetails: {
+            client_id: googleClientId,
+            client_secret: googleClientSecret,
+            authorize_scopes: 'openid email profile'
+          },
+          AttributeMapping: {
+            email: 'email',
+            name: 'name',
+            picture: 'picture',
+            username: 'sub'
+          }
+        });
+        
+        await client.send(providerCommand);
+        console.log('✓ Added Google OAuth provider to Cognito User Pool');
+        supportedProviders.push('Google');
+      } catch (error) {
+        console.log('⚠ Could not add Google provider:', error.message);
+        console.log('  You can add it later via AWS Console');
+      }
+    } else {
+      console.log('⚠ Google OAuth credentials not provided');
+      console.log('  Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to enable Google login');
+    }
+    
+    // Create app client
+    const clientCommand = new CreateUserPoolClientCommand({
+      UserPoolId: userPoolId,
+      ClientName: 'vibecodingmachine-client',
+      GenerateSecret: false, // Public client for PKCE
+      RefreshTokenValidity: 30,
+      AccessTokenValidity: 1,
+      IdTokenValidity: 1,
+      TokenValidityUnits: {
+        RefreshToken: 'days',
+        AccessToken: 'hours',
+        IdToken: 'hours'
+      },
+      ExplicitAuthFlows: [
+        'ALLOW_REFRESH_TOKEN_AUTH',
+        'ALLOW_USER_SRP_AUTH'
+      ],
+      AllowedOAuthFlows: ['code'],
+      AllowedOAuthScopes: ['openid', 'email', 'profile'],
+      AllowedOAuthFlowsUserPoolClient: true,
+      SupportedIdentityProviders: supportedProviders,
+      CallbackURLs: [
+        'http://localhost:3000/callback',
+        'vibecodingmachine://callback'
+      ],
+      LogoutURLs: [
+        'http://localhost:3000/logout',
+        'vibecodingmachine://logout'
+      ]
+    });
+    
+    const clientResponse = await client.send(clientCommand);
+    const appClientId = clientResponse.UserPoolClient.ClientId;
+    
+    console.log(`✓ Created Cognito App Client: ${appClientId}`);
+    
+    return {
+      userPoolId,
+      appClientId,
+      status: 'created'
+    };
+  } catch (error) {
+    console.error('✗ Failed to create Cognito User Pool:', error.message);
+    throw error;
+  }
+}
+
+/**
+ * Create computers DynamoDB table
+ */
+async function createComputersTable() {
+  const client = new DynamoDBClient({ region });
+  const tableName = 'vibecodingmachine-computers';
+  
+  try {
+    // Check if table already exists
+    try {
+      const describeCommand = new DescribeTableCommand({ TableName: tableName });
+      await client.send(describeCommand);
+      console.log(`✓ Computers table '${tableName}' already exists`);
+      return { tableName, status: 'exists' };
+    } catch (error) {
+      if (error.name !== 'ResourceNotFoundException') {
+        throw error;
+      }
+    }
+    
+    // Create table
+    const command = new CreateTableCommand({
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'computerId', KeyType: 'HASH' }  // Partition key
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'computerId', AttributeType: 'S' }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Purpose', Value: 'ComputerRegistry' }
+      ]
+    });
+    
+    const response = await client.send(command);
+    console.log(`✓ Created computers table '${tableName}'`);
+    
+    return {
+      tableName,
+      status: 'created',
+      arn: response.TableDescription.TableArn
+    };
+  } catch (error) {
+    console.error(`✗ Failed to create computers table:`, error.message);
+    throw error;
+  }
+}
+
+/**
+ * Create beta customers DynamoDB table
+ */
+async function createBetaCustomersTable() {
+  const client = new DynamoDBClient({ region });
+  const tableName = 'vibecodingmachine-beta-customers';
+  
+  try {
+    // Check if table already exists
+    try {
+      const describeCommand = new DescribeTableCommand({ TableName: tableName });
+      await client.send(describeCommand);
+      console.log(`✓ Beta customers table '${tableName}' already exists`);
+      return { tableName, status: 'exists' };
+    } catch (error) {
+      if (error.name !== 'ResourceNotFoundException') {
+        throw error;
+      }
+    }
+    
+    // Create table
+    const command = new CreateTableCommand({
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'email', KeyType: 'HASH' }  // Partition key
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'email', AttributeType: 'S' }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Purpose', Value: 'BetaAccess' }
+      ]
+    });
+    
+    const response = await client.send(command);
+    console.log(`✓ Created beta customers table '${tableName}'`);
+    
+    return {
+      tableName,
+      status: 'created',
+      arn: response.TableDescription.TableArn
+    };
+  } catch (error) {
+    console.error(`✗ Failed to create beta customers table:`, error.message);
+    throw error;
+  }
+}
+
+/**
+ * Main setup function
+ */
+async function setup() {
+  console.log('🚀 Setting up AWS infrastructure for Vibe Coding Machine\n');
+  
+  try {
+    // 1. Create DynamoDB tables
+    console.log('1. Setting up DynamoDB tables...');
+    const requirementsTable = await createDynamoDBTable();
+    const computersTable = await createComputersTable();
+    const betaTable = await createBetaCustomersTable();
+    console.log('');
+    
+    // 2. Setup Cognito with Google OAuth
+    console.log('2. Setting up Cognito with Google OAuth...');
+    const cognito = await setupCognitoWithGoogle();
+    console.log('');
+    
+    // 3. Output configuration
+    console.log('✅ Setup complete!\n');
+    console.log('Configuration:');
+    console.log('─────────────────────────────────────────');
+    console.log(`AWS_REGION=${region}`);
+    console.log(`DYNAMODB_TABLE_NAME=${requirementsTable.tableName}`);
+    console.log(`DYNAMODB_COMPUTERS_TABLE_NAME=${computersTable.tableName}`);
+    console.log(`DYNAMODB_BETA_TABLE_NAME=${betaTable.tableName}`);
+    if (cognito.userPoolId) {
+      console.log(`COGNITO_USER_POOL_ID=${cognito.userPoolId}`);
+    }
+    if (cognito.appClientId) {
+      console.log(`COGNITO_APP_CLIENT_ID=${cognito.appClientId}`);
+    }
+    console.log('─────────────────────────────────────────\n');
+    
+    console.log('Next steps:');
+    console.log('1. Add the above configuration to your .env file');
+    console.log('2. Set up Google OAuth credentials in Google Cloud Console');
+    console.log('3. Configure Cognito domain for OAuth flows');
+    console.log('4. Deploy Lambda functions for sync logic');
+    console.log('5. Set up API Gateway endpoints\n');
+    
+    return {
+      requirementsTable,
+      computersTable,
+      betaTable,
+      cognito
+    };
+  } catch (error) {
+    console.error('\n❌ Setup failed:', error.message);
+    throw error;
+  }
+}
+
+// Run setup if called directly
+if (require.main === module) {
+  setup()
+    .then(() => process.exit(0))
+    .catch(() => process.exit(1));
+}
+
+module.exports = { setup, createDynamoDBTable, createComputersTable, setupCognitoWithGoogle, createBetaCustomersTable };