import { CostExplorerClient, GetCostAndUsageCommand } from '@aws-sdk/client-cost-explorer';
import { DatabaseConnection } from '../database/connection.js';
import { Logger } from '../utils/logger.js';
export interface BillingRecord {
id: string;
accountId: string;
service: string;
region: string;
usageType: string;
cost: number;
currency: string;
startDate: Date;
endDate: Date;
tags: Record<string, string>;
createdAt: Date;
updatedAt: Date;
}
export interface CostData {
service: string;
cost: number;
currency: string;
startDate: string;
endDate: string;
region?: string;
usageType?: string;
}
export interface RetryConfig {
maxRetries: number;
baseDelay: number;
maxDelay: number;
backoffMultiplier: number;
}
export class BillingClient {
private static instance: BillingClient;
private db!: DatabaseConnection;
private logger: Logger;
private retryConfig: RetryConfig;
private refreshInterval: NodeJS.Timeout | null = null;
private constructor() {
this.logger = Logger.getInstance();
this.retryConfig = {
maxRetries: 3,
baseDelay: 1000,
maxDelay: 60000,
backoffMultiplier: 2
};
}
public static async getInstance(): Promise<BillingClient> {
if (!BillingClient.instance) {
BillingClient.instance = new BillingClient();
BillingClient.instance.db = await DatabaseConnection.getInstance();
}
return BillingClient.instance;
}
private async sleep(ms: number): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms));
}
private calculateDelay(attempt: number): number {
const delay = this.retryConfig.baseDelay * Math.pow(this.retryConfig.backoffMultiplier, attempt);
return Math.min(delay, this.retryConfig.maxDelay);
}
private async executeWithRetry<T>(
operation: () => Promise<T>,
operationName: string
): Promise<T> {
let lastError: Error;
for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
try {
const startTime = Date.now();
const result = await operation();
const duration = Date.now() - startTime;
this.logger.logAWSAPICall('cost-explorer', operationName, duration, true);
return result;
} catch (error: any) {
lastError = error;
const duration = Date.now();
this.logger.logAWSAPICall('cost-explorer', operationName, duration, false);
this.logger.error(`AWS API call failed (attempt ${attempt + 1}/${this.retryConfig.maxRetries + 1})`, {
operation: operationName,
error: error.message,
attempt: attempt + 1
});
if (attempt < this.retryConfig.maxRetries) {
const delay = this.calculateDelay(attempt);
this.logger.info(`Retrying in ${delay}ms`, { operation: operationName });
await this.sleep(delay);
}
}
}
throw lastError!;
}
private async createCostExplorerClient(): Promise<CostExplorerClient> {
// For Claude Desktop use case, use environment variables directly
const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
const region = process.env.AWS_REGION || 'us-east-1';
const sessionToken = process.env.AWS_SESSION_TOKEN;
if (!accessKeyId || !secretAccessKey) {
throw new Error('AWS credentials not found in environment variables. Please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in your Claude Desktop config.');
}
const credentialsConfig: any = {
accessKeyId,
secretAccessKey
};
if (sessionToken) {
credentialsConfig.sessionToken = sessionToken;
}
return new CostExplorerClient({
region,
credentials: credentialsConfig
});
}
public async fetchBillingData(
startDate: Date,
endDate: Date,
granularity: 'DAILY' | 'MONTHLY' = 'DAILY'
): Promise<CostData[]> {
const client = await this.createCostExplorerClient();
const command = new GetCostAndUsageCommand({
TimePeriod: {
Start: startDate.toISOString().split('T')[0],
End: endDate.toISOString().split('T')[0]
},
Granularity: granularity,
Metrics: ['BlendedCost', 'UsageQuantity'],
GroupBy: [
{ Type: 'DIMENSION', Key: 'SERVICE' },
{ Type: 'DIMENSION', Key: 'REGION' }
]
});
const response = await this.executeWithRetry(
() => client.send(command),
'GetCostAndUsage'
);
const costData: CostData[] = [];
if (response.ResultsByTime) {
for (const result of response.ResultsByTime) {
if (result.Groups) {
for (const group of result.Groups) {
const [service, region] = group.Keys || ['Unknown', 'Unknown'];
const cost = parseFloat(group.Metrics?.BlendedCost?.Amount || '0');
const currency = group.Metrics?.BlendedCost?.Unit || 'USD';
costData.push({
service,
region,
cost,
currency,
startDate: result.TimePeriod?.Start || startDate.toISOString().split('T')[0],
endDate: result.TimePeriod?.End || endDate.toISOString().split('T')[0]
});
}
}
}
}
this.logger.info('Billing data fetched successfully', {
recordCount: costData.length,
startDate: startDate.toISOString(),
endDate: endDate.toISOString()
});
return costData;
}
public async cacheBillingData(costData: CostData[]): Promise<void> {
// For Claude Desktop use case, use a default account ID
const accountId = 'default-account';
const records: BillingRecord[] = costData.map(data => ({
id: this.generateRecordId(),
accountId,
service: data.service,
region: data.region || 'Unknown',
usageType: data.usageType || 'Unknown',
cost: data.cost,
currency: data.currency,
startDate: new Date(data.startDate),
endDate: new Date(data.endDate),
tags: {},
createdAt: new Date(),
updatedAt: new Date()
}));
// Clear existing data for the same time period
const startDate = records[0]?.startDate.toISOString();
const endDate = records[0]?.endDate.toISOString();
if (startDate && endDate) {
await this.db.run(
'DELETE FROM billing_records WHERE account_id = ? AND start_date >= ? AND end_date <= ?',
[accountId, startDate, endDate]
);
}
// Insert new records
for (const record of records) {
await this.db.run(
`INSERT INTO billing_records
(id, account_id, service, region, usage_type, cost, currency, start_date, end_date, tags, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
[
record.id,
record.accountId,
record.service,
record.region,
record.usageType,
record.cost,
record.currency,
record.startDate.toISOString(),
record.endDate.toISOString(),
JSON.stringify(record.tags),
record.createdAt.toISOString(),
record.updatedAt.toISOString()
]
);
}
this.logger.info('Billing data cached successfully', {
recordCount: records.length
});
}
public async getCachedBillingData(
startDate?: Date,
endDate?: Date
): Promise<BillingRecord[]> {
// For Claude Desktop use case, use a default account ID
const accountId = 'default-account';
let query = 'SELECT * FROM billing_records WHERE account_id = ?';
const params: any[] = [accountId];
if (startDate) {
query += ' AND start_date >= ?';
params.push(startDate.toISOString());
}
if (endDate) {
query += ' AND end_date <= ?';
params.push(endDate.toISOString());
}
query += ' ORDER BY start_date DESC';
const results = await this.db.all(query, params) as any[];
return results.map(row => ({
id: row.id,
accountId: row.account_id,
service: row.service,
region: row.region,
usageType: row.usage_type,
cost: row.cost,
currency: row.currency,
startDate: new Date(row.start_date),
endDate: new Date(row.end_date),
tags: JSON.parse(row.tags || '{}'),
createdAt: new Date(row.created_at),
updatedAt: new Date(row.updated_at)
}));
}
public async refreshBillingData(): Promise<void> {
try {
const endDate = new Date();
const startDate = new Date();
startDate.setMonth(startDate.getMonth() - 12); // Last 12 months
this.logger.info('Starting billing data refresh');
const costData = await this.fetchBillingData(startDate, endDate);
await this.cacheBillingData(costData);
this.logger.info('Billing data refresh completed');
} catch (error: any) {
this.logger.error('Billing data refresh failed', {
error: error.message
});
throw error;
}
}
public startAutoRefresh(intervalHours: number = 24): void {
if (this.refreshInterval) {
clearInterval(this.refreshInterval);
}
const intervalMs = intervalHours * 60 * 60 * 1000;
this.refreshInterval = setInterval(async () => {
try {
await this.refreshBillingData();
} catch (error: any) {
this.logger.error('Auto refresh failed', { error: error.message });
}
}, intervalMs);
this.logger.info('Auto refresh started', { intervalHours });
}
public stopAutoRefresh(): void {
if (this.refreshInterval) {
clearInterval(this.refreshInterval);
this.refreshInterval = null;
this.logger.info('Auto refresh stopped');
}
}
public async getBillingData(
startDate?: Date,
endDate?: Date
): Promise<BillingRecord[]> {
try {
// Check if AWS credentials are available in environment
if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
this.logger.info('No AWS credentials in environment, returning mock billing data');
return this.generateMockBillingData(startDate, endDate);
}
// Try to get cached data first
const cachedData = await this.getCachedBillingData(startDate, endDate);
// If no cached data or data is stale, fetch fresh data
if (cachedData.length === 0 || this.isDataStale(cachedData)) {
this.logger.info('Cached data is stale or missing, fetching fresh data from AWS');
const fetchStartDate = startDate || new Date(Date.now() - 12 * 30 * 24 * 60 * 60 * 1000); // 12 months ago
const fetchEndDate = endDate || new Date();
try {
const costData = await this.fetchBillingData(fetchStartDate, fetchEndDate);
await this.cacheBillingData(costData);
return await this.getCachedBillingData(startDate, endDate);
} catch (error: any) {
this.logger.warn('Failed to fetch fresh data from AWS, falling back to cached data', {
error: error.message
});
// If we have cached data, return it even if stale
if (cachedData.length > 0) {
return cachedData;
}
// If no cached data and AWS fetch failed, return mock data
this.logger.info('No cached data available, returning mock billing data');
return this.generateMockBillingData(startDate, endDate);
}
}
return cachedData;
} catch (error: any) {
this.logger.error('Failed to get billing data', {
error: error.message
});
// Return mock data as fallback
this.logger.info('Returning mock billing data as fallback');
return this.generateMockBillingData(startDate, endDate);
}
}
private isDataStale(records: BillingRecord[]): boolean {
if (records.length === 0) return true;
// Consider data stale if the most recent record is older than 24 hours
const mostRecentRecord = records.reduce((latest, record) =>
record.updatedAt > latest.updatedAt ? record : latest
);
const staleThreshold = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
return Date.now() - mostRecentRecord.updatedAt.getTime() > staleThreshold;
}
private generateRecordId(): string {
return 'rec_' + Date.now().toString(36) + Math.random().toString(36).substr(2);
}
private generateMockBillingData(startDate?: Date, endDate?: Date): BillingRecord[] {
const start = startDate || new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
const end = endDate || new Date();
const services = ['EC2-Instance', 'S3', 'RDS', 'Lambda', 'CloudFront', 'EBS'];
const regions = ['us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1'];
const usageTypes = ['BoxUsage', 'DataTransfer', 'Storage', 'Requests', 'Compute'];
const mockRecords: BillingRecord[] = [];
const accountId = 'mock-account-123456789';
// Generate records for each day in the date range
const currentDate = new Date(start);
while (currentDate <= end) {
// Generate 2-4 records per day
const recordsPerDay = Math.floor(Math.random() * 3) + 2;
for (let i = 0; i < recordsPerDay; i++) {
const service = services[Math.floor(Math.random() * services.length)];
const region = regions[Math.floor(Math.random() * regions.length)];
const usageType = usageTypes[Math.floor(Math.random() * usageTypes.length)];
// Generate realistic costs based on service
let baseCost = 0;
switch (service) {
case 'EC2-Instance':
baseCost = Math.random() * 100 + 10; // $10-110
break;
case 'S3':
baseCost = Math.random() * 20 + 1; // $1-21
break;
case 'RDS':
baseCost = Math.random() * 200 + 20; // $20-220
break;
case 'Lambda':
baseCost = Math.random() * 5 + 0.1; // $0.1-5.1
break;
case 'CloudFront':
baseCost = Math.random() * 30 + 2; // $2-32
break;
case 'EBS':
baseCost = Math.random() * 50 + 5; // $5-55
break;
}
const recordDate = new Date(currentDate);
const nextDay = new Date(currentDate);
nextDay.setDate(nextDay.getDate() + 1);
mockRecords.push({
id: this.generateRecordId(),
accountId,
service,
region,
usageType,
cost: Math.round(baseCost * 100) / 100, // Round to 2 decimal places
currency: 'USD',
startDate: recordDate,
endDate: nextDay,
tags: {
Environment: Math.random() > 0.5 ? 'Production' : 'Development',
Team: ['Engineering', 'Marketing', 'Sales'][Math.floor(Math.random() * 3)],
Project: ['WebApp', 'DataPipeline', 'Analytics'][Math.floor(Math.random() * 3)]
},
createdAt: new Date(),
updatedAt: new Date()
});
}
currentDate.setDate(currentDate.getDate() + 1);
}
this.logger.info('Generated mock billing data', {
recordCount: mockRecords.length,
startDate: start.toISOString(),
endDate: end.toISOString(),
totalCost: mockRecords.reduce((sum, record) => sum + record.cost, 0)
});
return mockRecords;
}
}
