spense-core 0.1.1

package/dist/aws-resources.d.ts

@@ -0,0 +1,16 @@
+import { AwsCredentials } from './types';
+export interface ExistingInstance {
+    id: string;
+    name: string;
+    type: string;
+    state: string;
+    publicIp?: string;
+}
+export interface ExistingDatabase {
+    id: string;
+    engine: string;
+    instanceClass: string;
+    endpoint?: string;
+}
+export declare function listEc2Instances(creds: AwsCredentials): Promise<ExistingInstance[]>;
+export declare function listRdsInstances(creds: AwsCredentials): Promise<ExistingDatabase[]>;

package/dist/aws-resources.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listEc2Instances = listEc2Instances;
+exports.listRdsInstances = listRdsInstances;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_rds_1 = require("@aws-sdk/client-rds");
+async function listEc2Instances(creds) {
+    const ec2 = new client_ec2_1.EC2Client({
+        region: creds.region,
+        credentials: { accessKeyId: creds.accessKeyId, secretAccessKey: creds.secretAccessKey }
+    });
+    const res = await ec2.send(new client_ec2_1.DescribeInstancesCommand({}));
+    const instances = [];
+    for (const reservation of res.Reservations || []) {
+        for (const inst of reservation.Instances || []) {
+            if (inst.State?.Name === 'terminated')
+                continue;
+            instances.push({
+                id: inst.InstanceId || '',
+                name: inst.Tags?.find(t => t.Key === 'Name')?.Value || 'Unnamed',
+                type: inst.InstanceType || '',
+                state: inst.State?.Name || '',
+                publicIp: inst.PublicIpAddress,
+            });
+        }
+    }
+    return instances;
+}
+async function listRdsInstances(creds) {
+    const rds = new client_rds_1.RDSClient({
+        region: creds.region,
+        credentials: { accessKeyId: creds.accessKeyId, secretAccessKey: creds.secretAccessKey }
+    });
+    const res = await rds.send(new client_rds_1.DescribeDBInstancesCommand({}));
+    return (res.DBInstances || []).map(db => ({
+        id: db.DBInstanceIdentifier || '',
+        engine: db.Engine || '',
+        instanceClass: db.DBInstanceClass || '',
+        endpoint: db.Endpoint?.Address,
+    }));
+}

package/dist/aws-validator.d.ts

@@ -0,0 +1,12 @@
+import { AwsCredentials } from './types';
+export interface PermissionCheck {
+    service: string;
+    hasAccess: boolean;
+    error?: string;
+}
+export declare function validateCredentials(creds: AwsCredentials): Promise<{
+    valid: boolean;
+    username?: string;
+    error?: string;
+}>;
+export declare function checkPermissions(creds: AwsCredentials): Promise<PermissionCheck[]>;

package/dist/aws-validator.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCredentials = validateCredentials;
+exports.checkPermissions = checkPermissions;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_rds_1 = require("@aws-sdk/client-rds");
+const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2");
+const client_route_53_1 = require("@aws-sdk/client-route-53");
+const client_auto_scaling_1 = require("@aws-sdk/client-auto-scaling");
+const client_iam_1 = require("@aws-sdk/client-iam");
+async function validateCredentials(creds) {
+    const iam = new client_iam_1.IAMClient({
+        region: creds.region,
+        credentials: { accessKeyId: creds.accessKeyId, secretAccessKey: creds.secretAccessKey }
+    });
+    try {
+        const res = await iam.send(new client_iam_1.GetUserCommand({}));
+        return { valid: true, username: res.User?.UserName };
+    }
+    catch (err) {
+        return { valid: false, error: err.message };
+    }
+}
+async function checkPermissions(creds) {
+    const config = {
+        region: creds.region,
+        credentials: { accessKeyId: creds.accessKeyId, secretAccessKey: creds.secretAccessKey }
+    };
+    const checks = [];
+    // EC2
+    try {
+        const ec2 = new client_ec2_1.EC2Client(config);
+        await ec2.send(new client_ec2_1.DescribeInstancesCommand({ MaxResults: 5 }));
+        checks.push({ service: 'EC2', hasAccess: true });
+    }
+    catch (err) {
+        checks.push({ service: 'EC2', hasAccess: false, error: err.message });
+    }
+    // RDS
+    try {
+        const rds = new client_rds_1.RDSClient(config);
+        await rds.send(new client_rds_1.DescribeDBInstancesCommand({}));
+        checks.push({ service: 'RDS', hasAccess: true });
+    }
+    catch (err) {
+        checks.push({ service: 'RDS', hasAccess: false, error: err.message });
+    }
+    // ALB
+    try {
+        const elb = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client(config);
+        await elb.send(new client_elastic_load_balancing_v2_1.DescribeLoadBalancersCommand({}));
+        checks.push({ service: 'ALB', hasAccess: true });
+    }
+    catch (err) {
+        checks.push({ service: 'ALB', hasAccess: false, error: err.message });
+    }
+    // Route53
+    try {
+        const r53 = new client_route_53_1.Route53Client(config);
+        await r53.send(new client_route_53_1.ListHostedZonesCommand({}));
+        checks.push({ service: 'Route53', hasAccess: true });
+    }
+    catch (err) {
+        checks.push({ service: 'Route53', hasAccess: false, error: err.message });
+    }
+    // Auto Scaling
+    try {
+        const asg = new client_auto_scaling_1.AutoScalingClient(config);
+        await asg.send(new client_auto_scaling_1.DescribeAutoScalingGroupsCommand({ MaxRecords: 1 }));
+        checks.push({ service: 'AutoScaling', hasAccess: true });
+    }
+    catch (err) {
+        checks.push({ service: 'AutoScaling', hasAccess: false, error: err.message });
+    }
+    return checks;
+}

package/dist/conversation.d.ts

@@ -0,0 +1,2 @@
+import { DeployConfig, ProjectInfo } from './types';
+export declare function runConversation(project: ProjectInfo): Promise<DeployConfig>;

package/dist/conversation.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConversation = runConversation;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const types_1 = require("./types");
+const aws_validator_1 = require("./aws-validator");
+const aws_resources_1 = require("./aws-resources");
+async function runConversation(project) {
+    console.log(chalk_1.default.blue('\n🚀 Spense - Let\'s deploy your app!\n'));
+    console.log(chalk_1.default.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 = {
+        credentials,
+        ec2,
+        useElasticIp,
+        database,
+        dbInstanceClass,
+        domain,
+        useHttps,
+    };
+    await showSummary(config);
+    return config;
+}
+async function askCredentials() {
+    console.log(chalk_1.default.yellow('Step 1: AWS Credentials\n'));
+    console.log(chalk_1.default.gray('We need AWS credentials to deploy your app. These are stored locally and never sent anywhere.\n'));
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'password',
+            name: 'accessKeyId',
+            message: 'AWS Access Key ID:',
+            mask: '*',
+            validate: (v) => v.length === 20 || 'Access Key ID should be 20 characters'
+        },
+        {
+            type: 'password',
+            name: 'secretAccessKey',
+            message: 'AWS Secret Access Key:',
+            mask: '*',
+            validate: (v) => 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) {
+    console.log(chalk_1.default.yellow('\nStep 2: Validating credentials...\n'));
+    const validation = await (0, aws_validator_1.validateCredentials)(creds);
+    if (!validation.valid) {
+        console.log(chalk_1.default.red(`✗ Invalid credentials: ${validation.error}`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green(`✓ Authenticated as: ${validation.username}\n`));
+    console.log(chalk_1.default.gray('Checking permissions for required services...\n'));
+    const permissions = await (0, aws_validator_1.checkPermissions)(creds);
+    let allGood = true;
+    for (const p of permissions) {
+        if (p.hasAccess) {
+            console.log(chalk_1.default.green(`  ✓ ${p.service}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`  ✗ ${p.service}: ${p.error}`));
+            allGood = false;
+        }
+    }
+    if (!allGood) {
+        console.log(chalk_1.default.red('\n⚠ Some permissions are missing. Deployment may fail.'));
+        const { proceed } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'proceed',
+                message: 'Continue anyway?',
+                default: false
+            }]);
+        if (!proceed)
+            process.exit(1);
+    }
+    console.log('');
+}
+async function askEc2Config(creds) {
+    console.log(chalk_1.default.yellow('Step 3: EC2 Configuration\n'));
+    const existing = await (0, aws_resources_1.listEc2Instances)(creds);
+    if (existing.length > 0) {
+        console.log(chalk_1.default.gray('Found existing EC2 instances:\n'));
+        existing.forEach((inst, i) => {
+            console.log(chalk_1.default.gray(`  ${i + 1}. ${inst.name} (${inst.id}) - ${inst.type} - ${inst.state}`));
+        });
+        console.log('');
+    }
+    const { useExisting } = await inquirer_1.default.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_1.default.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) => v.length > 0 || 'Select at least one instance'
+            }]);
+        return { useExisting: true, existingInstanceIds: selectedInstances };
+    }
+    // New instances
+    console.log(chalk_1.default.gray('\nLet\'s configure your new instances:\n'));
+    const instanceTypes = Object.entries(types_1.PRICING.ec2).map(([type, price]) => ({
+        name: `${type} - $${(price * 730).toFixed(2)}/month (~$${price}/hr)`,
+        value: type
+    }));
+    const answers = await inquirer_1.default.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) => v >= 1 || 'At least 1'
+        },
+        {
+            type: 'number',
+            name: 'maxInstances',
+            message: 'Maximum instances (for auto-scaling):',
+            default: 3,
+            validate: (v, answers) => v >= answers.minInstances || 'Must be >= minimum'
+        }
+    ]);
+    return { useExisting: false, ...answers };
+}
+async function askElasticIp(ec2) {
+    if (ec2.useExisting)
+        return false;
+    console.log(chalk_1.default.yellow('\nStep 4: Elastic IP\n'));
+    console.log(chalk_1.default.gray('An Elastic IP gives your instances a static public IP address.\n'));
+    console.log(chalk_1.default.cyan('Benefits:'));
+    console.log(chalk_1.default.gray('  • IP stays the same even if instance restarts'));
+    console.log(chalk_1.default.gray('  • Required if you want to point a domain directly to an instance'));
+    console.log(chalk_1.default.gray('  • Useful for whitelisting in firewalls\n'));
+    console.log(chalk_1.default.cyan('Cost:'));
+    console.log(chalk_1.default.gray(`  • ${types_1.PRICING.elasticIp.note}`));
+    console.log(chalk_1.default.gray('  • With ALB (which we create), you typically don\'t need Elastic IPs\n'));
+    const { useElasticIp } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'useElasticIp',
+            message: 'Assign Elastic IP to each instance?',
+            default: false
+        }]);
+    return useElasticIp;
+}
+async function askDatabase(creds) {
+    console.log(chalk_1.default.yellow('\nStep 5: Database\n'));
+    const existing = await (0, aws_resources_1.listRdsInstances)(creds);
+    if (existing.length > 0) {
+        console.log(chalk_1.default.gray('Found existing RDS databases:\n'));
+        existing.forEach(db => {
+            console.log(chalk_1.default.gray(`  • ${db.id} (${db.engine}) - ${db.instanceClass}`));
+        });
+        console.log('');
+    }
+    const { database } = await inquirer_1.default.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(types_1.PRICING.rds).map(([type, price]) => ({
+        name: `${type} - $${(price * 730).toFixed(2)}/month`,
+        value: type
+    }));
+    const { dbInstanceClass } = await inquirer_1.default.prompt([{
+            type: 'list',
+            name: 'dbInstanceClass',
+            message: 'Database instance size:',
+            choices: dbTypes,
+            default: 'db.t3.micro'
+        }]);
+    return { database, dbInstanceClass };
+}
+async function askDomain() {
+    console.log(chalk_1.default.yellow('\nStep 6: Domain & HTTPS\n'));
+    const { hasDomain } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'hasDomain',
+            message: 'Do you have a domain to use?',
+            default: false
+        }]);
+    if (!hasDomain) {
+        console.log(chalk_1.default.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_1.default.prompt([{
+            type: 'input',
+            name: 'domain',
+            message: 'Domain (e.g., api.myapp.com):',
+            validate: (v) => /^[a-z0-9.-]+\.[a-z]{2,}$/.test(v) || 'Enter a valid domain'
+        }]);
+    console.log(chalk_1.default.gray('\nHTTPS encrypts traffic between users and your app.'));
+    console.log(chalk_1.default.gray('We\'ll use AWS Certificate Manager (free) to provision an SSL certificate.\n'));
+    const { useHttps } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'useHttps',
+            message: 'Enable HTTPS?',
+            default: true
+        }]);
+    return { domain, useHttps };
+}
+async function showSummary(config) {
+    console.log(chalk_1.default.yellow('\n📋 Deployment Summary\n'));
+    // Calculate costs
+    let monthlyCost = 0;
+    console.log(chalk_1.default.cyan('Infrastructure:'));
+    if (config.ec2.useExisting) {
+        console.log(chalk_1.default.gray(`  • EC2: Using existing (${config.ec2.existingInstanceIds?.join(', ')})`));
+    }
+    else {
+        const ec2Cost = types_1.PRICING.ec2[config.ec2.instanceType] * 730 * config.ec2.minInstances;
+        monthlyCost += ec2Cost;
+        console.log(chalk_1.default.gray(`  • EC2: ${config.ec2.minInstances}-${config.ec2.maxInstances} x ${config.ec2.instanceType} (~$${ec2Cost.toFixed(2)}/mo min)`));
+    }
+    if (config.useElasticIp) {
+        console.log(chalk_1.default.gray(`  • Elastic IP: Yes (free when attached)`));
+    }
+    const albCost = types_1.PRICING.alb.perHour * 730;
+    monthlyCost += albCost;
+    console.log(chalk_1.default.gray(`  • ALB: Yes (~$${albCost.toFixed(2)}/mo + LCU charges)`));
+    if (config.database !== 'none') {
+        const dbCost = types_1.PRICING.rds[config.dbInstanceClass] * 730;
+        monthlyCost += dbCost;
+        console.log(chalk_1.default.gray(`  • RDS: ${config.database} ${config.dbInstanceClass} (~$${dbCost.toFixed(2)}/mo)`));
+    }
+    if (config.domain) {
+        console.log(chalk_1.default.gray(`  • Domain: ${config.domain}`));
+        console.log(chalk_1.default.gray(`  • HTTPS: ${config.useHttps ? 'Yes' : 'No'}`));
+    }
+    console.log(chalk_1.default.cyan(`\nEstimated minimum cost: ~$${monthlyCost.toFixed(2)}/month`));
+    console.log(chalk_1.default.gray('(Actual cost depends on usage, data transfer, etc.)\n'));
+    const { confirm } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Proceed with deployment?',
+            default: true
+        }]);
+    if (!confirm) {
+        console.log(chalk_1.default.yellow('Deployment cancelled.'));
+        process.exit(0);
+    }
+}

package/dist/deploy.d.ts

@@ -0,0 +1,2 @@
+import { ProjectInfo } from './types';
+export declare function deploy(project: ProjectInfo): Promise<void>;

package/dist/deploy.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = deploy;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const conversation_1 = require("./conversation");
+const infra_1 = require("./infra");
+async function deploy(project) {
+    const config = await (0, conversation_1.runConversation)(project);
+    console.log(chalk_1.default.blue('\n🚀 Starting deployment...\n'));
+    const spinner = (0, ora_1.default)('Creating infrastructure...').start();
+    try {
+        const outputs = await (0, infra_1.deployInfra)(project, config);
+        spinner.succeed('Deployment complete!\n');
+        console.log(chalk_1.default.green('✓ Your app is live!\n'));
+        console.log(chalk_1.default.cyan('Endpoints:'));
+        console.log(chalk_1.default.gray(`  • URL: ${outputs.url}`));
+        if (outputs.dbEndpoint) {
+            console.log(chalk_1.default.gray(`  • Database: ${outputs.dbEndpoint}`));
+        }
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Deployment failed');
+        throw err;
+    }
+}

package/dist/detector.d.ts

@@ -0,0 +1,3 @@
+import { ProjectInfo } from './types';
+export declare function detectNodeProject(dir: string): ProjectInfo;
+export declare function detectSpringBootProject(dir: string): ProjectInfo;

package/dist/detector.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectNodeProject = detectNodeProject;
+exports.detectSpringBootProject = detectSpringBootProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function detectNodeProject(dir) {
+    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,
+    };
+}
+function detectSpringBootProject(dir) {
+    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/dist/index.d.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';

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPermissions = exports.validateCredentials = exports.runConversation = exports.deploy = exports.detectSpringBootProject = exports.detectNodeProject = void 0;
+__exportStar(require("./types"), exports);
+var detector_1 = require("./detector");
+Object.defineProperty(exports, "detectNodeProject", { enumerable: true, get: function () { return detector_1.detectNodeProject; } });
+Object.defineProperty(exports, "detectSpringBootProject", { enumerable: true, get: function () { return detector_1.detectSpringBootProject; } });
+var deploy_1 = require("./deploy");
+Object.defineProperty(exports, "deploy", { enumerable: true, get: function () { return deploy_1.deploy; } });
+var conversation_1 = require("./conversation");
+Object.defineProperty(exports, "runConversation", { enumerable: true, get: function () { return conversation_1.runConversation; } });
+var aws_validator_1 = require("./aws-validator");
+Object.defineProperty(exports, "validateCredentials", { enumerable: true, get: function () { return aws_validator_1.validateCredentials; } });
+Object.defineProperty(exports, "checkPermissions", { enumerable: true, get: function () { return aws_validator_1.checkPermissions; } });

package/dist/infra.d.ts

@@ -0,0 +1,6 @@
+import { ProjectInfo, DeployConfig } from './types';
+export interface DeployOutputs {
+    url: string;
+    dbEndpoint?: string;
+}
+export declare function deployInfra(project: ProjectInfo, config: DeployConfig): Promise<DeployOutputs>;