cloud-cost-cli 0.1.0 → 0.2.0

package/dist/src/analyzers/pricing-service.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingService = void 0;
+exports.getS3MonthlyCost = getS3MonthlyCost;
+exports.getELBMonthlyCost = getELBMonthlyCost;
+exports.getEIPMonthlyCost = getEIPMonthlyCost;
+const client_pricing_1 = require("@aws-sdk/client-pricing");
+// Cache for pricing data to avoid repeated API calls
+const pricingCache = new Map();
+class PricingService {
+    pricingClient;
+    region;
+    constructor(region = 'us-east-1') {
+        this.region = region;
+        // Pricing API is only available in us-east-1 and ap-south-1
+        this.pricingClient = new client_pricing_1.PricingClient({ region: 'us-east-1' });
+    }
+    /**
+     * Get EC2 instance on-demand pricing for the configured region
+     */
+    async getEC2Price(instanceType) {
+        const cacheKey = `ec2-${this.region}-${instanceType}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonEC2',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'instanceType',
+                        Value: instanceType,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'tenancy',
+                        Value: 'Shared',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'operatingSystem',
+                        Value: 'Linux',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'preInstalledSw',
+                        Value: 'NA',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'capacitystatus',
+                        Value: 'Used',
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const hourlyPrice = this.extractPriceFromResponse(response.PriceList);
+            const monthlyPrice = hourlyPrice * 730; // 730 hours per month
+            pricingCache.set(cacheKey, monthlyPrice);
+            return monthlyPrice;
+        }
+        catch (error) {
+            // Fallback to estimate if API fails
+            return this.getFallbackEC2Price(instanceType);
+        }
+    }
+    /**
+     * Get EBS volume pricing per GB
+     */
+    async getEBSPrice(volumeType) {
+        const cacheKey = `ebs-${this.region}-${volumeType}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonEC2',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'productFamily',
+                        Value: 'Storage',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'volumeApiName',
+                        Value: volumeType,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const pricePerGB = this.extractPriceFromResponse(response.PriceList);
+            pricingCache.set(cacheKey, pricePerGB);
+            return pricePerGB;
+        }
+        catch (error) {
+            return this.getFallbackEBSPrice(volumeType);
+        }
+    }
+    /**
+     * Get RDS instance pricing
+     */
+    async getRDSPrice(instanceClass, engine = 'mysql') {
+        const cacheKey = `rds-${this.region}-${instanceClass}-${engine}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonRDS',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'instanceType',
+                        Value: instanceClass,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'databaseEngine',
+                        Value: this.normalizeEngine(engine),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'deploymentOption',
+                        Value: 'Single-AZ',
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const hourlyPrice = this.extractPriceFromResponse(response.PriceList);
+            const monthlyPrice = hourlyPrice * 730;
+            pricingCache.set(cacheKey, monthlyPrice);
+            return monthlyPrice;
+        }
+        catch (error) {
+            return this.getFallbackRDSPrice(instanceClass);
+        }
+    }
+    /**
+     * Extract price from AWS Pricing API response
+     */
+    extractPriceFromResponse(priceList) {
+        if (!priceList || priceList.length === 0) {
+            return 0;
+        }
+        try {
+            const product = JSON.parse(priceList[0]);
+            const terms = product.terms?.OnDemand;
+            if (!terms)
+                return 0;
+            const termKey = Object.keys(terms)[0];
+            const priceDimensions = terms[termKey]?.priceDimensions;
+            if (!priceDimensions)
+                return 0;
+            const dimensionKey = Object.keys(priceDimensions)[0];
+            const pricePerUnit = priceDimensions[dimensionKey]?.pricePerUnit?.USD;
+            return parseFloat(pricePerUnit || '0');
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    /**
+     * Convert AWS region code to location name used in Pricing API
+     */
+    getLocationName(region) {
+        const locationMap = {
+            'us-east-1': 'US East (N. Virginia)',
+            'us-east-2': 'US East (Ohio)',
+            'us-west-1': 'US West (N. California)',
+            'us-west-2': 'US West (Oregon)',
+            'eu-west-1': 'EU (Ireland)',
+            'eu-central-1': 'EU (Frankfurt)',
+            'ap-southeast-1': 'Asia Pacific (Singapore)',
+            'ap-southeast-2': 'Asia Pacific (Sydney)',
+            'ap-northeast-1': 'Asia Pacific (Tokyo)',
+            // Add more as needed
+        };
+        return locationMap[region] || 'US East (N. Virginia)';
+    }
+    /**
+     * Normalize RDS engine name for Pricing API
+     */
+    normalizeEngine(engine) {
+        const engineMap = {
+            'mysql': 'MySQL',
+            'postgres': 'PostgreSQL',
+            'mariadb': 'MariaDB',
+            'aurora': 'Aurora MySQL',
+            'aurora-mysql': 'Aurora MySQL',
+            'aurora-postgresql': 'Aurora PostgreSQL',
+        };
+        return engineMap[engine.toLowerCase()] || 'MySQL';
+    }
+    /**
+     * Fallback estimates when API calls fail (based on us-east-1)
+     */
+    getFallbackEC2Price(instanceType) {
+        const estimates = {
+            't3.micro': 7.59,
+            't3.small': 15.18,
+            't3.medium': 30.37,
+            't3.large': 60.74,
+            'm5.large': 70.08,
+            'm5.xlarge': 140.16,
+        };
+        return estimates[instanceType] || 50; // Generic estimate
+    }
+    getFallbackEBSPrice(volumeType) {
+        const estimates = {
+            'gp3': 0.08,
+            'gp2': 0.10,
+            'io1': 0.125,
+            'io2': 0.125,
+        };
+        return estimates[volumeType] || 0.08;
+    }
+    getFallbackRDSPrice(instanceClass) {
+        const estimates = {
+            'db.t3.micro': 11.01,
+            'db.t3.small': 22.63,
+            'db.t3.medium': 45.26,
+            'db.t3.large': 90.51,
+        };
+        return estimates[instanceClass] || 100;
+    }
+}
+exports.PricingService = PricingService;
+// Simple estimates for services where Pricing API is complex (S3, ELB, EIP)
+function getS3MonthlyCost(sizeGB, storageClass = 'standard') {
+    const pricing = {
+        'STANDARD': 0.023,
+        'INTELLIGENT_TIERING': 0.023,
+        'GLACIER': 0.004,
+        'DEEP_ARCHIVE': 0.00099,
+    };
+    const pricePerGB = pricing[storageClass] || 0.023;
+    return sizeGB * pricePerGB;
+}
+function getELBMonthlyCost(type = 'alb') {
+    // ELB pricing is relatively consistent across regions (~$16-18/month base)
+    return type === 'clb' ? 18.25 : 16.43;
+}
+function getEIPMonthlyCost() {
+    // ~$3.65/month when unattached (consistent across regions)
+    return 3.65;
+}

package/dist/src/commands/scan.d.ts

@@ -2,11 +2,14 @@ interface ScanCommandOptions {
     provider: string;
     region?: string;
     profile?: string;
+    subscriptionId?: string;
+    location?: string;
     top?: string;
     output?: string;
     days?: string;
     minSavings?: string;
     verbose?: boolean;
+    accurate?: boolean;
 }
 export declare function scanCommand(options: ScanCommandOptions): Promise<void>;
 export {};

package/dist/src/commands/scan.js

@@ -8,104 +8,191 @@ const rds_1 = require("../providers/aws/rds");
 const s3_1 = require("../providers/aws/s3");
 const elb_1 = require("../providers/aws/elb");
 const eip_1 = require("../providers/aws/eip");
+const client_2 = require("../providers/azure/client");
+const vms_1 = require("../providers/azure/vms");
+const disks_1 = require("../providers/azure/disks");
+const storage_1 = require("../providers/azure/storage");
+const sql_1 = require("../providers/azure/sql");
+const public_ips_1 = require("../providers/azure/public-ips");
 const table_1 = require("../reporters/table");
 const json_1 = require("../reporters/json");
 const logger_1 = require("../utils/logger");
 async function scanCommand(options) {
     try {
-        if (options.provider !== 'aws') {
-            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws`);
-            process.exit(1);
+        if (options.provider === 'aws') {
+            await scanAWS(options);
         }
-        (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${options.region || 'us-east-1'})...`);
-        const client = new client_1.AWSClient({
-            region: options.region,
-            profile: options.profile,
-        });
-        // Run analyzers in parallel
-        (0, logger_1.info)('Analyzing EC2 instances...');
-        const ec2Promise = (0, ec2_1.analyzeEC2Instances)(client);
-        (0, logger_1.info)('Analyzing EBS volumes...');
-        const ebsPromise = (0, ebs_1.analyzeEBSVolumes)(client);
-        (0, logger_1.info)('Analyzing RDS instances...');
-        const rdsPromise = (0, rds_1.analyzeRDSInstances)(client);
-        (0, logger_1.info)('Analyzing S3 buckets...');
-        const s3Promise = (0, s3_1.analyzeS3Buckets)(client);
-        (0, logger_1.info)('Analyzing Load Balancers...');
-        const elbPromise = (0, elb_1.analyzeELBs)(client);
-        (0, logger_1.info)('Analyzing Elastic IPs...');
-        const eipPromise = (0, eip_1.analyzeElasticIPs)(client);
-        // Wait for all analyzers to complete
-        const [ec2Opportunities, ebsOpportunities, rdsOpportunities, s3Opportunities, elbOpportunities, eipOpportunities,] = await Promise.all([
-            ec2Promise,
-            ebsPromise,
-            rdsPromise,
-            s3Promise,
-            elbPromise,
-            eipPromise,
-        ]);
-        (0, logger_1.success)(`Found ${ec2Opportunities.length} EC2 opportunities`);
-        (0, logger_1.success)(`Found ${ebsOpportunities.length} EBS opportunities`);
-        (0, logger_1.success)(`Found ${rdsOpportunities.length} RDS opportunities`);
-        (0, logger_1.success)(`Found ${s3Opportunities.length} S3 opportunities`);
-        (0, logger_1.success)(`Found ${elbOpportunities.length} ELB opportunities`);
-        (0, logger_1.success)(`Found ${eipOpportunities.length} EIP opportunities`);
-        // Combine opportunities
-        const allOpportunities = [
-            ...ec2Opportunities,
-            ...ebsOpportunities,
-            ...rdsOpportunities,
-            ...s3Opportunities,
-            ...elbOpportunities,
-            ...eipOpportunities,
-        ];
-        // Filter by minimum savings if specified
-        const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
-        const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
-        // Calculate totals
-        const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
-        const summary = {
-            totalResources: filteredOpportunities.length,
-            idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
-            oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
-            unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
-        };
-        const report = {
-            provider: 'aws',
-            accountId: 'N/A', // Will fetch from STS in future
-            region: client.region,
-            scanPeriod: {
-                start: new Date(Date.now() - (parseInt(options.days || '30') * 24 * 60 * 60 * 1000)),
-                end: new Date(),
-            },
-            opportunities: filteredOpportunities,
-            totalPotentialSavings,
-            summary,
-        };
-        // Render output
-        const topN = parseInt(options.top || '5');
-        if (options.output === 'json') {
-            (0, json_1.renderJSON)(report);
+        else if (options.provider === 'azure') {
+            await scanAzure(options);
         }
         else {
-            (0, table_1.renderTable)(report, topN);
+            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws or --provider azure`);
+            process.exit(1);
         }
     }
     catch (err) {
-        if (err.name === 'CredentialsProviderError' || err.message?.includes('credentials')) {
-            (0, logger_1.error)('AWS credentials not found or invalid.');
-            console.log('\nTo configure AWS credentials:');
-            console.log('1. Run: aws configure');
-            console.log('2. Or set environment variables: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY');
-            console.log('3. Or use --profile flag with a configured profile');
-            console.log('\nSee: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html');
-        }
-        else {
-            (0, logger_1.error)(`Scan failed: ${err.message}`);
-            if (options.verbose) {
-                console.error(err);
-            }
+        (0, logger_1.error)(`Scan failed: ${err.message}`);
+        if (options.verbose) {
+            console.error(err);
         }
         process.exit(1);
     }
 }
+async function scanAWS(options) {
+    const client = new client_1.AWSClient({
+        region: options.region,
+        profile: options.profile,
+    });
+    (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${client.region})...`);
+    if (options.accurate) {
+        (0, logger_1.info)('Note: --accurate flag is not yet implemented. Using estimated pricing.');
+        (0, logger_1.info)('Real-time pricing will be available in a future release.');
+    }
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing EC2 instances...');
+    const ec2Promise = (0, ec2_1.analyzeEC2Instances)(client);
+    (0, logger_1.info)('Analyzing EBS volumes...');
+    const ebsPromise = (0, ebs_1.analyzeEBSVolumes)(client);
+    (0, logger_1.info)('Analyzing RDS instances...');
+    const rdsPromise = (0, rds_1.analyzeRDSInstances)(client);
+    (0, logger_1.info)('Analyzing S3 buckets...');
+    const s3Promise = (0, s3_1.analyzeS3Buckets)(client);
+    (0, logger_1.info)('Analyzing Load Balancers...');
+    const elbPromise = (0, elb_1.analyzeELBs)(client);
+    (0, logger_1.info)('Analyzing Elastic IPs...');
+    const eipPromise = (0, eip_1.analyzeElasticIPs)(client);
+    // Wait for all analyzers to complete
+    const [ec2Opportunities, ebsOpportunities, rdsOpportunities, s3Opportunities, elbOpportunities, eipOpportunities,] = await Promise.all([
+        ec2Promise,
+        ebsPromise,
+        rdsPromise,
+        s3Promise,
+        elbPromise,
+        eipPromise,
+    ]);
+    (0, logger_1.success)(`Found ${ec2Opportunities.length} EC2 opportunities`);
+    (0, logger_1.success)(`Found ${ebsOpportunities.length} EBS opportunities`);
+    (0, logger_1.success)(`Found ${rdsOpportunities.length} RDS opportunities`);
+    (0, logger_1.success)(`Found ${s3Opportunities.length} S3 opportunities`);
+    (0, logger_1.success)(`Found ${elbOpportunities.length} ELB opportunities`);
+    (0, logger_1.success)(`Found ${eipOpportunities.length} EIP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...ec2Opportunities,
+        ...ebsOpportunities,
+        ...rdsOpportunities,
+        ...s3Opportunities,
+        ...elbOpportunities,
+        ...eipOpportunities,
+    ];
+    // Filter by minimum savings if specified
+    const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
+    const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
+    // Calculate totals
+    const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
+    const summary = {
+        totalResources: filteredOpportunities.length,
+        idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
+        oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
+        unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
+    };
+    const report = {
+        provider: 'aws',
+        accountId: 'N/A', // Will fetch from STS in future
+        region: client.region,
+        scanPeriod: {
+            start: new Date(Date.now() - (parseInt(options.days || '30') * 24 * 60 * 60 * 1000)),
+            end: new Date(),
+        },
+        opportunities: filteredOpportunities,
+        totalPotentialSavings,
+        summary,
+    };
+    // Render output
+    const topN = parseInt(options.top || '5');
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        (0, table_1.renderTable)(report, topN);
+    }
+}
+async function scanAzure(options) {
+    const client = new client_2.AzureClient({
+        subscriptionId: options.subscriptionId,
+        location: options.location,
+    });
+    (0, logger_1.info)(`Scanning Azure subscription (${client.subscriptionId})...`);
+    if (client.location) {
+        (0, logger_1.info)(`Filtering resources by location: ${client.location}`);
+    }
+    else {
+        (0, logger_1.info)('Scanning all locations (no filter specified)');
+    }
+    if (options.accurate) {
+        (0, logger_1.info)('Note: --accurate flag is not yet implemented. Using estimated pricing.');
+    }
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing Virtual Machines...');
+    const vmPromise = (0, vms_1.analyzeAzureVMs)(client);
+    (0, logger_1.info)('Analyzing Managed Disks...');
+    const diskPromise = (0, disks_1.analyzeAzureDisks)(client);
+    (0, logger_1.info)('Analyzing Storage Accounts...');
+    const storagePromise = (0, storage_1.analyzeAzureStorage)(client);
+    (0, logger_1.info)('Analyzing SQL Databases...');
+    const sqlPromise = (0, sql_1.analyzeAzureSQL)(client);
+    (0, logger_1.info)('Analyzing Public IP Addresses...');
+    const ipPromise = (0, public_ips_1.analyzeAzurePublicIPs)(client);
+    // Wait for all analyzers to complete
+    const [vmOpportunities, diskOpportunities, storageOpportunities, sqlOpportunities, ipOpportunities,] = await Promise.all([
+        vmPromise,
+        diskPromise,
+        storagePromise,
+        sqlPromise,
+        ipPromise,
+    ]);
+    (0, logger_1.success)(`Found ${vmOpportunities.length} VM opportunities`);
+    (0, logger_1.success)(`Found ${diskOpportunities.length} Disk opportunities`);
+    (0, logger_1.success)(`Found ${storageOpportunities.length} Storage opportunities`);
+    (0, logger_1.success)(`Found ${sqlOpportunities.length} SQL opportunities`);
+    (0, logger_1.success)(`Found ${ipOpportunities.length} Public IP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...vmOpportunities,
+        ...diskOpportunities,
+        ...storageOpportunities,
+        ...sqlOpportunities,
+        ...ipOpportunities,
+    ];
+    // Filter by minimum savings if specified
+    const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
+    const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
+    // Calculate totals
+    const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
+    const summary = {
+        totalResources: filteredOpportunities.length,
+        idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
+        oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
+        unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
+    };
+    const report = {
+        provider: 'azure',
+        accountId: client.subscriptionId,
+        region: client.location || 'all',
+        scanPeriod: {
+            start: new Date(Date.now() - (parseInt(options.days || '7') * 24 * 60 * 60 * 1000)),
+            end: new Date(),
+        },
+        opportunities: filteredOpportunities,
+        totalPotentialSavings,
+        summary,
+    };
+    // Render output
+    const topN = parseInt(options.top || '5');
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        (0, table_1.renderTable)(report, topN);
+    }
+}

package/dist/src/providers/aws/client.d.ts

@@ -18,6 +18,7 @@ export declare class AWSClient {
     region: string;
     profile: string;
     constructor(options: AWSClientOptions);
+    private getProfileRegion;
     getEC2Client(): EC2Client;
     getCloudWatchClient(): CloudWatchClient;
     getCostExplorerClient(): CostExplorerClient;

package/dist/src/providers/aws/client.js

@@ -1,4 +1,37 @@
 "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.AWSClient = void 0;
 const client_ec2_1 = require("@aws-sdk/client-ec2");
@@ -8,6 +41,9 @@ const client_rds_1 = require("@aws-sdk/client-rds");
 const client_s3_1 = require("@aws-sdk/client-s3");
 const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2");
 const credential_providers_1 = require("@aws-sdk/credential-providers");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ini = __importStar(require("ini"));
 class AWSClient {
     ec2;
     cloudwatch;
@@ -18,8 +54,9 @@ class AWSClient {
     region;
     profile;
     constructor(options) {
-        this.region = options.region || 'us-east-1';
         this.profile = options.profile || 'default';
+        // Determine region: CLI option > profile config > default
+        this.region = options.region || this.getProfileRegion(this.profile) || 'us-east-1';
         // Use environment credentials if available, otherwise fall back to profile
         const credentials = process.env.AWS_ACCESS_KEY_ID
             ? (0, credential_providers_1.fromEnv)()
@@ -31,6 +68,28 @@ class AWSClient {
         this.s3 = new client_s3_1.S3Client({ region: this.region, credentials });
         this.elb = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client({ region: this.region, credentials });
     }
+    getProfileRegion(profileName) {
+        try {
+            const configPath = path.join(process.env.HOME || process.env.USERPROFILE || '', '.aws', 'config');
+            if (!fs.existsSync(configPath)) {
+                return null;
+            }
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            const config = ini.parse(configContent);
+            // Profile names in config are prefixed with "profile " except for "default"
+            const profileKey = profileName === 'default' ? 'default' : `profile ${profileName}`;
+            const profileConfig = config[profileKey];
+            // Handle both regular objects and null prototype objects
+            if (profileConfig && typeof profileConfig === 'object') {
+                return profileConfig.region || null;
+            }
+            return null;
+        }
+        catch (error) {
+            // If we can't read the config, just return null
+            return null;
+        }
+    }
     getEC2Client() {
         return this.ec2;
     }

package/dist/src/providers/azure/client.d.ts

@@ -0,0 +1,20 @@
+import { ComputeManagementClient } from '@azure/arm-compute';
+import { StorageManagementClient } from '@azure/arm-storage';
+import { SqlManagementClient } from '@azure/arm-sql';
+import { NetworkManagementClient } from '@azure/arm-network';
+import { MonitorClient } from '@azure/arm-monitor';
+export interface AzureClientConfig {
+    subscriptionId?: string;
+    location?: string;
+}
+export declare class AzureClient {
+    private credential;
+    subscriptionId: string;
+    location: string;
+    constructor(config?: AzureClientConfig);
+    getComputeClient(): ComputeManagementClient;
+    getStorageClient(): StorageManagementClient;
+    getSqlClient(): SqlManagementClient;
+    getNetworkClient(): NetworkManagementClient;
+    getMonitorClient(): MonitorClient;
+}