spense-core 0.1.1

package/src/conversation.ts

@@ -0,0 +1,339 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { AwsCredentials, DeployConfig, Ec2Choice, PRICING, ProjectInfo, DatabaseType } from './types';
+import { validateCredentials, checkPermissions } from './aws-validator';
+import { listEc2Instances, listRdsInstances } from './aws-resources';
+
+export async function runConversation(project: ProjectInfo): Promise<DeployConfig> {
+  console.log(chalk.blue('\n🚀 Spense - Let\'s deploy your app!\n'));
+  console.log(chalk.gray(`Detected: ${project.type} project "${project.name}"\n`));
+
+  // Step 1: AWS Credentials
+  const credentials = await askCredentials();
+
+  // Step 2: Validate & check permissions
+  await validateAndCheckPermissions(credentials);
+
+  // Step 3: EC2 configuration
+  const ec2 = await askEc2Config(credentials);
+
+  // Step 4: Elastic IP
+  const useElasticIp = await askElasticIp(ec2);
+
+  // Step 5: Database
+  const { database, dbInstanceClass } = await askDatabase(credentials);
+
+  // Step 6: Domain & HTTPS
+  const { domain, useHttps } = await askDomain();
+
+  // Step 7: Summary & confirm
+  const config: DeployConfig = {
+    credentials,
+    ec2,
+    useElasticIp,
+    database,
+    dbInstanceClass,
+    domain,
+    useHttps,
+  };
+
+  await showSummary(config);
+
+  return config;
+}
+
+async function askCredentials(): Promise<AwsCredentials> {
+  console.log(chalk.yellow('Step 1: AWS Credentials\n'));
+  console.log(chalk.gray('We need AWS credentials to deploy your app. These are stored locally and never sent anywhere.\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'accessKeyId',
+      message: 'AWS Access Key ID:',
+      mask: '*',
+      validate: (v: string) => v.length === 20 || 'Access Key ID should be 20 characters'
+    },
+    {
+      type: 'password',
+      name: 'secretAccessKey',
+      message: 'AWS Secret Access Key:',
+      mask: '*',
+      validate: (v: string) => v.length === 40 || 'Secret Access Key should be 40 characters'
+    },
+    {
+      type: 'list',
+      name: 'region',
+      message: 'AWS Region:',
+      choices: [
+        { name: 'US East (N. Virginia) - us-east-1', value: 'us-east-1' },
+        { name: 'US West (Oregon) - us-west-2', value: 'us-west-2' },
+        { name: 'EU (Ireland) - eu-west-1', value: 'eu-west-1' },
+        { name: 'Asia Pacific (Singapore) - ap-southeast-1', value: 'ap-southeast-1' },
+        { name: 'Asia Pacific (Sydney) - ap-southeast-2', value: 'ap-southeast-2' },
+      ]
+    }
+  ]);
+
+  return answers;
+}
+
+async function validateAndCheckPermissions(creds: AwsCredentials): Promise<void> {
+  console.log(chalk.yellow('\nStep 2: Validating credentials...\n'));
+
+  const validation = await validateCredentials(creds);
+  if (!validation.valid) {
+    console.log(chalk.red(`✗ Invalid credentials: ${validation.error}`));
+    process.exit(1);
+  }
+  console.log(chalk.green(`✓ Authenticated as: ${validation.username}\n`));
+
+  console.log(chalk.gray('Checking permissions for required services...\n'));
+  const permissions = await checkPermissions(creds);
+
+  let allGood = true;
+  for (const p of permissions) {
+    if (p.hasAccess) {
+      console.log(chalk.green(`  ✓ ${p.service}`));
+    } else {
+      console.log(chalk.red(`  ✗ ${p.service}: ${p.error}`));
+      allGood = false;
+    }
+  }
+
+  if (!allGood) {
+    console.log(chalk.red('\n⚠ Some permissions are missing. Deployment may fail.'));
+    const { proceed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'proceed',
+      message: 'Continue anyway?',
+      default: false
+    }]);
+    if (!proceed) process.exit(1);
+  }
+  console.log('');
+}
+
+async function askEc2Config(creds: AwsCredentials): Promise<Ec2Choice> {
+  console.log(chalk.yellow('Step 3: EC2 Configuration\n'));
+
+  const existing = await listEc2Instances(creds);
+
+  if (existing.length > 0) {
+    console.log(chalk.gray('Found existing EC2 instances:\n'));
+    existing.forEach((inst, i) => {
+      console.log(chalk.gray(`  ${i + 1}. ${inst.name} (${inst.id}) - ${inst.type} - ${inst.state}`));
+    });
+    console.log('');
+  }
+
+  const { useExisting } = await inquirer.prompt([{
+    type: 'list',
+    name: 'useExisting',
+    message: 'How would you like to deploy?',
+    choices: [
+      { name: '🆕 Create new EC2 instances (recommended for production)', value: false },
+      ...(existing.length > 0 ? [{ name: '📦 Use existing EC2 instance(s)', value: true }] : [])
+    ]
+  }]);
+
+  if (useExisting) {
+    const { selectedInstances } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selectedInstances',
+      message: 'Select instance(s) to deploy to:',
+      choices: existing.map(inst => ({
+        name: `${inst.name} (${inst.id}) - ${inst.type}`,
+        value: inst.id
+      })),
+      validate: (v: string[]) => v.length > 0 || 'Select at least one instance'
+    }]);
+    return { useExisting: true, existingInstanceIds: selectedInstances };
+  }
+
+  // New instances
+  console.log(chalk.gray('\nLet\'s configure your new instances:\n'));
+
+  const instanceTypes = Object.entries(PRICING.ec2).map(([type, price]) => ({
+    name: `${type} - $${(price * 730).toFixed(2)}/month (~$${price}/hr)`,
+    value: type
+  }));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'instanceType',
+      message: 'Instance type:',
+      choices: instanceTypes,
+      default: 't3.small'
+    },
+    {
+      type: 'number',
+      name: 'minInstances',
+      message: 'Minimum instances (for auto-scaling):',
+      default: 1,
+      validate: (v: number) => v >= 1 || 'At least 1'
+    },
+    {
+      type: 'number',
+      name: 'maxInstances',
+      message: 'Maximum instances (for auto-scaling):',
+      default: 3,
+      validate: (v: number, answers: any) => v >= answers.minInstances || 'Must be >= minimum'
+    }
+  ]);
+
+  return { useExisting: false, ...answers };
+}
+
+async function askElasticIp(ec2: Ec2Choice): Promise<boolean> {
+  if (ec2.useExisting) return false;
+
+  console.log(chalk.yellow('\nStep 4: Elastic IP\n'));
+  console.log(chalk.gray('An Elastic IP gives your instances a static public IP address.\n'));
+  console.log(chalk.cyan('Benefits:'));
+  console.log(chalk.gray('  • IP stays the same even if instance restarts'));
+  console.log(chalk.gray('  • Required if you want to point a domain directly to an instance'));
+  console.log(chalk.gray('  • Useful for whitelisting in firewalls\n'));
+  console.log(chalk.cyan('Cost:'));
+  console.log(chalk.gray(`  • ${PRICING.elasticIp.note}`));
+  console.log(chalk.gray('  • With ALB (which we create), you typically don\'t need Elastic IPs\n'));
+
+  const { useElasticIp } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'useElasticIp',
+    message: 'Assign Elastic IP to each instance?',
+    default: false
+  }]);
+
+  return useElasticIp;
+}
+
+async function askDatabase(creds: AwsCredentials): Promise<{ database: DatabaseType; dbInstanceClass?: string }> {
+  console.log(chalk.yellow('\nStep 5: Database\n'));
+
+  const existing = await listRdsInstances(creds);
+  if (existing.length > 0) {
+    console.log(chalk.gray('Found existing RDS databases:\n'));
+    existing.forEach(db => {
+      console.log(chalk.gray(`  • ${db.id} (${db.engine}) - ${db.instanceClass}`));
+    });
+    console.log('');
+  }
+
+  const { database } = await inquirer.prompt([{
+    type: 'list',
+    name: 'database',
+    message: 'Database:',
+    choices: [
+      { name: '🐘 PostgreSQL (recommended)', value: 'postgresql' },
+      { name: '🐬 MySQL', value: 'mysql' },
+      { name: '❌ No database', value: 'none' }
+    ]
+  }]);
+
+  if (database === 'none') {
+    return { database };
+  }
+
+  const dbTypes = Object.entries(PRICING.rds).map(([type, price]) => ({
+    name: `${type} - $${(price * 730).toFixed(2)}/month`,
+    value: type
+  }));
+
+  const { dbInstanceClass } = await inquirer.prompt([{
+    type: 'list',
+    name: 'dbInstanceClass',
+    message: 'Database instance size:',
+    choices: dbTypes,
+    default: 'db.t3.micro'
+  }]);
+
+  return { database, dbInstanceClass };
+}
+
+async function askDomain(): Promise<{ domain?: string; useHttps: boolean }> {
+  console.log(chalk.yellow('\nStep 6: Domain & HTTPS\n'));
+
+  const { hasDomain } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'hasDomain',
+    message: 'Do you have a domain to use?',
+    default: false
+  }]);
+
+  if (!hasDomain) {
+    console.log(chalk.gray('\nNo problem! You\'ll get an ALB URL like: my-app-123456.us-east-1.elb.amazonaws.com\n'));
+    return { useHttps: false };
+  }
+
+  const { domain } = await inquirer.prompt([{
+    type: 'input',
+    name: 'domain',
+    message: 'Domain (e.g., api.myapp.com):',
+    validate: (v: string) => /^[a-z0-9.-]+\.[a-z]{2,}$/.test(v) || 'Enter a valid domain'
+  }]);
+
+  console.log(chalk.gray('\nHTTPS encrypts traffic between users and your app.'));
+  console.log(chalk.gray('We\'ll use AWS Certificate Manager (free) to provision an SSL certificate.\n'));
+
+  const { useHttps } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'useHttps',
+    message: 'Enable HTTPS?',
+    default: true
+  }]);
+
+  return { domain, useHttps };
+}
+
+async function showSummary(config: DeployConfig): Promise<void> {
+  console.log(chalk.yellow('\n📋 Deployment Summary\n'));
+
+  // Calculate costs
+  let monthlyCost = 0;
+
+  console.log(chalk.cyan('Infrastructure:'));
+  
+  if (config.ec2.useExisting) {
+    console.log(chalk.gray(`  • EC2: Using existing (${config.ec2.existingInstanceIds?.join(', ')})`));
+  } else {
+    const ec2Cost = PRICING.ec2[config.ec2.instanceType!] * 730 * config.ec2.minInstances!;
+    monthlyCost += ec2Cost;
+    console.log(chalk.gray(`  • EC2: ${config.ec2.minInstances}-${config.ec2.maxInstances} x ${config.ec2.instanceType} (~$${ec2Cost.toFixed(2)}/mo min)`));
+  }
+
+  if (config.useElasticIp) {
+    console.log(chalk.gray(`  • Elastic IP: Yes (free when attached)`));
+  }
+
+  const albCost = PRICING.alb.perHour * 730;
+  monthlyCost += albCost;
+  console.log(chalk.gray(`  • ALB: Yes (~$${albCost.toFixed(2)}/mo + LCU charges)`));
+
+  if (config.database !== 'none') {
+    const dbCost = PRICING.rds[config.dbInstanceClass!] * 730;
+    monthlyCost += dbCost;
+    console.log(chalk.gray(`  • RDS: ${config.database} ${config.dbInstanceClass} (~$${dbCost.toFixed(2)}/mo)`));
+  }
+
+  if (config.domain) {
+    console.log(chalk.gray(`  • Domain: ${config.domain}`));
+    console.log(chalk.gray(`  • HTTPS: ${config.useHttps ? 'Yes' : 'No'}`));
+  }
+
+  console.log(chalk.cyan(`\nEstimated minimum cost: ~$${monthlyCost.toFixed(2)}/month`));
+  console.log(chalk.gray('(Actual cost depends on usage, data transfer, etc.)\n'));
+
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: 'Proceed with deployment?',
+    default: true
+  }]);
+
+  if (!confirm) {
+    console.log(chalk.yellow('Deployment cancelled.'));
+    process.exit(0);
+  }
+}

package/src/deploy.ts

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { ProjectInfo, DeployConfig } from './types';
+import { runConversation } from './conversation';
+import { deployInfra } from './infra';
+
+export async function deploy(project: ProjectInfo): Promise<void> {
+  const config = await runConversation(project);
+
+  console.log(chalk.blue('\n🚀 Starting deployment...\n'));
+
+  const spinner = ora('Creating infrastructure...').start();
+
+  try {
+    const outputs = await deployInfra(project, config);
+    spinner.succeed('Deployment complete!\n');
+
+    console.log(chalk.green('✓ Your app is live!\n'));
+    console.log(chalk.cyan('Endpoints:'));
+    console.log(chalk.gray(`  • URL: ${outputs.url}`));
+    if (outputs.dbEndpoint) {
+      console.log(chalk.gray(`  • Database: ${outputs.dbEndpoint}`));
+    }
+    console.log('');
+  } catch (err) {
+    spinner.fail('Deployment failed');
+    throw err;
+  }
+}

package/src/detector.ts

@@ -0,0 +1,43 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ProjectInfo } from './types';
+
+export function detectNodeProject(dir: string): ProjectInfo {
+  const pkgPath = path.join(dir, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    throw new Error('No package.json found');
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  
+  return {
+    type: 'nodejs',
+    name: pkg.name || path.basename(dir),
+    port: parseInt(process.env.PORT || '3000'),
+    buildCommand: pkg.scripts?.build ? 'npm run build' : '',
+    startCommand: pkg.scripts?.start || 'node index.js',
+    artifactPath: dir,
+  };
+}
+
+export function detectSpringBootProject(dir: string): ProjectInfo {
+  const pomPath = path.join(dir, 'pom.xml');
+  const gradlePath = path.join(dir, 'build.gradle');
+  const isGradle = fs.existsSync(gradlePath);
+  const isMaven = fs.existsSync(pomPath);
+
+  if (!isMaven && !isGradle) {
+    throw new Error('No pom.xml or build.gradle found');
+  }
+
+  const name = path.basename(dir);
+  
+  return {
+    type: 'springboot',
+    name,
+    port: 8080,
+    buildCommand: isGradle ? './gradlew build' : 'mvn package',
+    startCommand: `java -jar target/${name}.jar`,
+    artifactPath: isGradle ? 'build/libs/*.jar' : 'target/*.jar',
+  };
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export { detectNodeProject, detectSpringBootProject } from './detector';
+export { deploy } from './deploy';
+export { runConversation } from './conversation';
+export { validateCredentials, checkPermissions } from './aws-validator';