spense-core 0.1.1

package/src/infra.ts

@@ -0,0 +1,315 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ProjectInfo, DeployConfig } from './types';
+import { S3Client, PutObjectCommand, CreateBucketCommand, HeadBucketCommand } from '@aws-sdk/client-s3';
+import * as archiver from 'archiver';
+
+export interface DeployOutputs {
+  url: string;
+  dbEndpoint?: string;
+}
+
+export async function deployInfra(project: ProjectInfo, config: DeployConfig): Promise<DeployOutputs> {
+  const stackDir = path.join(process.cwd(), '.spense');
+  fs.mkdirSync(stackDir, { recursive: true });
+
+  // Set AWS credentials as env vars for CDK
+  process.env.AWS_ACCESS_KEY_ID = config.credentials.accessKeyId;
+  process.env.AWS_SECRET_ACCESS_KEY = config.credentials.secretAccessKey;
+  process.env.AWS_REGION = config.credentials.region;
+
+  // Step 1: Package and upload app to S3
+  const bucketName = `spense-${project.name}-${config.credentials.region}`;
+  const s3Key = `app-${Date.now()}.zip`;
+  
+  console.log('📦 Packaging application...');
+  await packageAndUpload(project, config, bucketName, s3Key);
+
+  // Step 2: Generate and deploy CDK stack
+  const stackCode = generateStack(project, config, bucketName, s3Key);
+  fs.writeFileSync(path.join(stackDir, 'stack.ts'), stackCode);
+  fs.writeFileSync(path.join(stackDir, 'cdk.json'), '{"app":"npx ts-node stack.ts"}');
+  fs.writeFileSync(path.join(stackDir, 'package.json'), JSON.stringify({
+    dependencies: {
+      'aws-cdk-lib': '^2.170.0',
+      'constructs': '^10.4.2',
+      'ts-node': '^10.9.2',
+      'typescript': '^5.3.0'
+    }
+  }));
+
+  console.log('☁️  Deploying infrastructure...');
+  execSync('npm install', { cwd: stackDir, stdio: 'inherit' });
+  execSync('npx cdk bootstrap --require-approval never', { cwd: stackDir, stdio: 'inherit' });
+  execSync('npx cdk deploy --require-approval never --outputs-file outputs.json', { cwd: stackDir, stdio: 'inherit' });
+
+  const outputs = JSON.parse(fs.readFileSync(path.join(stackDir, 'outputs.json'), 'utf-8'));
+  const stackOutputs = outputs[`${project.name}-stack`] || {};
+
+  return {
+    url: stackOutputs.URL || stackOutputs.LoadBalancerDNS,
+    dbEndpoint: stackOutputs.DatabaseEndpoint
+  };
+}
+
+async function packageAndUpload(project: ProjectInfo, config: DeployConfig, bucket: string, key: string): Promise<void> {
+  const s3 = new S3Client({
+    region: config.credentials.region,
+    credentials: {
+      accessKeyId: config.credentials.accessKeyId,
+      secretAccessKey: config.credentials.secretAccessKey
+    }
+  });
+
+  // Create bucket if not exists
+  try {
+    await s3.send(new HeadBucketCommand({ Bucket: bucket }));
+  } catch {
+    await s3.send(new CreateBucketCommand({ Bucket: bucket }));
+  }
+
+  // Create zip of project
+  const zipPath = path.join(process.cwd(), '.spense', 'app.zip');
+  await createZip(process.cwd(), zipPath, project.type);
+
+  // Upload to S3
+  const zipContent = fs.readFileSync(zipPath);
+  await s3.send(new PutObjectCommand({
+    Bucket: bucket,
+    Key: key,
+    Body: zipContent
+  }));
+
+  console.log(`✓ Uploaded to s3://${bucket}/${key}`);
+}
+
+function createZip(sourceDir: string, outPath: string, projectType: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outPath);
+    const archive = archiver.default('zip', { zlib: { level: 9 } });
+
+    output.on('close', () => resolve());
+    archive.on('error', reject);
+
+    archive.pipe(output);
+
+    // Exclude common non-essential directories
+    const ignore = ['node_modules', '.git', '.spense', 'dist', 'build', 'target', '.idea', '.vscode'];
+    
+    archive.glob('**/*', {
+      cwd: sourceDir,
+      ignore: ignore.map(i => `**/${i}/**`)
+    });
+
+    archive.finalize();
+  });
+}
+
+function generateStack(project: ProjectInfo, config: DeployConfig, bucket: string, s3Key: string): string {
+  const stackName = `${project.name}-stack`;
+  const region = config.credentials.region;
+
+  return `import * as cdk from 'aws-cdk-lib';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import * as asg from 'aws-cdk-lib/aws-autoscaling';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+${config.useHttps ? "import * as acm from 'aws-cdk-lib/aws-certificatemanager';" : ''}
+${config.domain ? "import * as route53 from 'aws-cdk-lib/aws-route53';\nimport * as targets from 'aws-cdk-lib/aws-route53-targets';" : ''}
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, '${stackName}', { env: { region: '${region}' }});
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, natGateways: 1 });
+
+const appBucket = s3.Bucket.fromBucketName(stack, 'AppBucket', '${bucket}');
+
+${generateDbCode(config)}
+
+const role = new iam.Role(stack, 'InstanceRole', {
+  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+  ]
+});
+appBucket.grantRead(role);
+${config.database !== 'none' ? 'db.secret?.grantRead(role);' : ''}
+
+${generateAsgCode(project, config, bucket, s3Key)}
+
+const alb = new elbv2.ApplicationLoadBalancer(stack, 'ALB', { vpc, internetFacing: true });
+
+${generateListenerCode(config)}
+
+listener.addTargets('App', { 
+  port: ${project.port}, 
+  targets: [scaling],
+  healthCheck: { path: '/health', healthyHttpCodes: '200-399' }
+});
+
+${generateDomainCode(config)}
+
+new cdk.CfnOutput(stack, 'URL', { value: '${config.useHttps ? 'https' : 'http'}://' + ${config.domain ? `'${config.domain}'` : 'alb.loadBalancerDnsName'} });
+${config.database !== 'none' ? "new cdk.CfnOutput(stack, 'DatabaseEndpoint', { value: db.instanceEndpoint.hostname });" : ''}
+
+app.synth();
+`;
+}
+
+function generateDbCode(config: DeployConfig): string {
+  if (config.database === 'none') return '';
+
+  const engine = config.database === 'postgresql'
+    ? 'rds.DatabaseInstanceEngine.postgres({ version: rds.PostgresEngineVersion.VER_15 })'
+    : 'rds.DatabaseInstanceEngine.mysql({ version: rds.MysqlEngineVersion.VER_8_0 })';
+
+  return `const db = new rds.DatabaseInstance(stack, 'Database', {
+  vpc,
+  engine: ${engine},
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.${config.dbInstanceClass?.split('.')[2].toUpperCase() || 'MICRO'}),
+  credentials: rds.Credentials.fromGeneratedSecret('dbadmin'),
+  vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+  removalPolicy: cdk.RemovalPolicy.SNAPSHOT
+});`;
+}
+
+function generateAsgCode(project: ProjectInfo, config: DeployConfig, bucket: string, s3Key: string): string {
+  if (config.ec2.useExisting) {
+    return `// Using existing instances: ${config.ec2.existingInstanceIds?.join(', ')}`;
+  }
+
+  const instanceSize = config.ec2.instanceType?.split('.')[1].toUpperCase() || 'SMALL';
+
+  return `const scaling = new asg.AutoScalingGroup(stack, 'ASG', {
+  vpc,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.${instanceSize}),
+  machineImage: ec2.MachineImage.latestAmazonLinux2023(),
+  role,
+  minCapacity: ${config.ec2.minInstances || 1},
+  maxCapacity: ${config.ec2.maxInstances || 3},
+  vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+  ${config.useElasticIp ? 'associatePublicIpAddress: true,' : ''}
+});
+
+scaling.addUserData(\`${generateUserData(project, bucket, s3Key, config)}\`);
+
+scaling.scaleOnCpuUtilization('CpuScaling', { targetUtilizationPercent: 70 });`;
+}
+
+function generateUserData(project: ProjectInfo, bucket: string, s3Key: string, config: DeployConfig): string {
+  const dbEnvVars = config.database !== 'none' ? `
+# Get database credentials from Secrets Manager
+DB_SECRET=$(aws secretsmanager get-secret-value --secret-id \${DB_SECRET_ARN} --query SecretString --output text)
+export DATABASE_HOST=$(echo $DB_SECRET | jq -r '.host')
+export DATABASE_PORT=$(echo $DB_SECRET | jq -r '.port')
+export DATABASE_NAME=$(echo $DB_SECRET | jq -r '.dbname // "postgres"')
+export DATABASE_USER=$(echo $DB_SECRET | jq -r '.username')
+export DATABASE_PASSWORD=$(echo $DB_SECRET | jq -r '.password')
+export DATABASE_URL="${config.database === 'postgresql' ? 'postgresql' : 'mysql'}://\${DATABASE_USER}:\${DATABASE_PASSWORD}@\${DATABASE_HOST}:\${DATABASE_PORT}/\${DATABASE_NAME}"
+` : '';
+
+  if (project.type === 'nodejs') {
+    return `#!/bin/bash
+set -e
+
+# Install dependencies
+yum install -y nodejs npm aws-cli jq unzip
+
+# Download app from S3
+mkdir -p /app
+cd /app
+aws s3 cp s3://${bucket}/${s3Key} app.zip
+unzip -o app.zip
+rm app.zip
+
+# Install node dependencies
+npm install --production
+${project.buildCommand ? `npm run build` : ''}
+${dbEnvVars}
+# Set environment
+export NODE_ENV=production
+export PORT=${project.port}
+
+# Start app with pm2 for process management
+npm install -g pm2
+pm2 start ${project.startCommand.replace('node ', '')} --name app
+pm2 startup
+pm2 save
+`;
+  }
+  
+  return `#!/bin/bash
+set -e
+
+# Install dependencies
+yum install -y java-17-amazon-corretto aws-cli jq unzip
+
+# Download app from S3
+mkdir -p /app
+cd /app
+aws s3 cp s3://${bucket}/${s3Key} app.zip
+unzip -o app.zip
+rm app.zip
+${dbEnvVars}
+# Find and run the JAR
+JAR_FILE=$(find . -name "*.jar" -type f | head -1)
+export SERVER_PORT=${project.port}
+
+# Create systemd service
+cat > /etc/systemd/system/app.service << EOF
+[Unit]
+Description=Spring Boot App
+After=network.target
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/app
+ExecStart=/usr/bin/java -jar \${JAR_FILE}
+Restart=always
+Environment=SERVER_PORT=${project.port}
+${config.database !== 'none' ? 'Environment=SPRING_DATASOURCE_URL=${DATABASE_URL}' : ''}
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+systemctl daemon-reload
+systemctl enable app
+systemctl start app
+`;
+}
+
+function generateListenerCode(config: DeployConfig): string {
+  if (config.useHttps && config.domain) {
+    return `const cert = new acm.Certificate(stack, 'Cert', {
+  domainName: '${config.domain}',
+  validation: acm.CertificateValidation.fromDns()
+});
+
+const listener = alb.addListener('HTTPS', { 
+  port: 443, 
+  certificates: [cert]
+});
+
+alb.addListener('HTTP', { port: 80 }).addAction('Redirect', {
+  action: elbv2.ListenerAction.redirect({ protocol: 'HTTPS', port: '443', permanent: true })
+});`;
+  }
+  return `const listener = alb.addListener('HTTP', { port: 80 });`;
+}
+
+function generateDomainCode(config: DeployConfig): string {
+  if (!config.domain) return '';
+
+  const baseDomain = config.domain.split('.').slice(-2).join('.');
+  return `const zone = route53.HostedZone.fromLookup(stack, 'Zone', { domainName: '${baseDomain}' });
+new route53.ARecord(stack, 'DNS', {
+  zone,
+  recordName: '${config.domain}',
+  target: route53.RecordTarget.fromAlias(new targets.LoadBalancerTarget(alb))
+});`;
+}

package/src/types.ts

@@ -0,0 +1,59 @@
+export type ProjectType = 'nodejs' | 'springboot';
+export type DatabaseType = 'postgresql' | 'mysql' | 'none';
+
+export interface ProjectInfo {
+  type: ProjectType;
+  name: string;
+  port: number;
+  buildCommand: string;
+  startCommand: string;
+  artifactPath: string;
+}
+
+export interface AwsCredentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+  region: string;
+}
+
+export interface Ec2Choice {
+  useExisting: boolean;
+  existingInstanceIds?: string[];
+  instanceType?: string;
+  minInstances?: number;
+  maxInstances?: number;
+}
+
+export interface DeployConfig {
+  credentials: AwsCredentials;
+  ec2: Ec2Choice;
+  useElasticIp: boolean;
+  database: DatabaseType;
+  dbInstanceClass?: string;
+  domain?: string;
+  useHttps: boolean;
+}
+
+export const PRICING = {
+  ec2: {
+    't3.micro': 0.0104,
+    't3.small': 0.0208,
+    't3.medium': 0.0416,
+    't3.large': 0.0832,
+  } as Record<string, number>,
+  elasticIp: {
+    attached: 0,
+    detached: 0.005,
+    perHour: 0.005,
+    note: 'Free when attached to running instance, $0.005/hr when detached'
+  },
+  rds: {
+    'db.t3.micro': 0.017,
+    'db.t3.small': 0.034,
+    'db.t3.medium': 0.068,
+  } as Record<string, number>,
+  alb: {
+    perHour: 0.0225,
+    perLcu: 0.008,
+  }
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}