@expressots/cli 3.0.0-beta.4 → 4.0.0-preview.2

package/bin/costs/pricing-manager.js

@@ -0,0 +1,342 @@
+"use strict";
+/**
+ * Pricing Manager - orchestrates pricing fetching with cascading fallback
+ * Priority: API -> Remote JSON -> Local JSON -> Error
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetPricingManager = exports.getPricingManager = exports.PricingManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_source_1 = require("./sources/api-source");
+const remote_json_source_1 = require("./sources/remote-json-source");
+const local_json_source_1 = require("./sources/local-json-source");
+const config_1 = require("../config");
+const CACHE_DIR = path_1.default.join(os_1.default.homedir(), ".expressots", "cache");
+const CACHE_FILE = path_1.default.join(CACHE_DIR, "pricing.json");
+const DEFAULT_TTL = 21600; // 6 hours in seconds
+class PricingManager {
+    constructor(config) {
+        this.sources = [];
+        this.cachedData = null;
+        this.lastSource = null;
+        const globalConfig = (0, config_1.getConfigManager)().getPricingConfig();
+        const sourcesToUse = config?.sources || globalConfig.sources;
+        this.cacheTTL =
+            config?.cacheTTL || globalConfig.cacheTTL || DEFAULT_TTL;
+        // Initialize sources based on configuration
+        for (const source of sourcesToUse) {
+            switch (source) {
+                case "api":
+                    this.sources.push((0, api_source_1.createAPIPricingSource)());
+                    break;
+                case "remote":
+                    this.sources.push((0, remote_json_source_1.createRemoteJSONPricingSource)());
+                    break;
+                case "local":
+                    this.sources.push((0, local_json_source_1.createLocalJSONPricingSource)(config?.customLocalFile ||
+                        globalConfig.customFile ||
+                        undefined));
+                    break;
+            }
+        }
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    ensureCacheDir() {
+        if (!fs_1.default.existsSync(CACHE_DIR)) {
+            fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+        }
+    }
+    /**
+     * Load cached pricing data
+     */
+    loadCache() {
+        try {
+            if (!fs_1.default.existsSync(CACHE_FILE)) {
+                return null;
+            }
+            const content = fs_1.default.readFileSync(CACHE_FILE, "utf-8");
+            const entry = JSON.parse(content);
+            // Check if cache is still valid
+            const now = Date.now();
+            const expiresAt = entry.timestamp + this.cacheTTL * 1000;
+            if (now < expiresAt) {
+                return entry;
+            }
+            return null; // Cache expired
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save pricing data to cache
+     */
+    saveCache(data, source) {
+        this.ensureCacheDir();
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            source,
+        };
+        try {
+            fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(entry, null, 2), "utf-8");
+        }
+        catch {
+            // Silently fail - cache is optional
+        }
+    }
+    /**
+     * Fetch pricing data from sources with cascading fallback
+     */
+    async fetchPricing(forceRefresh = false) {
+        // Check memory cache first
+        if (!forceRefresh && this.cachedData) {
+            const now = Date.now();
+            const expiresAt = this.cachedData.timestamp + this.cacheTTL * 1000;
+            if (now < expiresAt) {
+                this.lastSource = this.cachedData.source + " (memory)";
+                return this.cachedData.data;
+            }
+        }
+        // Check disk cache
+        if (!forceRefresh) {
+            const diskCache = this.loadCache();
+            if (diskCache) {
+                this.cachedData = diskCache;
+                this.lastSource = diskCache.source + " (disk cache)";
+                return diskCache.data;
+            }
+        }
+        // Try each source in order
+        for (const source of this.sources) {
+            try {
+                const data = await source.fetch();
+                if (data && this.validatePricing(data)) {
+                    this.lastSource = source.name;
+                    this.cachedData = {
+                        data,
+                        timestamp: Date.now(),
+                        source: source.name,
+                    };
+                    this.saveCache(data, source.name);
+                    return data;
+                }
+            }
+            catch {
+                // Continue to next source
+            }
+        }
+        this.lastSource = null;
+        return null;
+    }
+    /**
+     * Validate pricing data structure
+     */
+    validatePricing(data) {
+        if (!data.version || !data.providers) {
+            return false;
+        }
+        // Check that at least one provider exists
+        if (Object.keys(data.providers).length === 0) {
+            return false;
+        }
+        // Validate each provider has required fields
+        for (const provider of Object.values(data.providers)) {
+            if (typeof provider.serviceName !== "string" ||
+                typeof provider.model !== "string" ||
+                typeof provider.cpuPerHour !== "number" ||
+                typeof provider.memoryPerGbHour !== "number") {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get pricing for a specific provider
+     */
+    async getProviderPricing(provider) {
+        const pricing = await this.fetchPricing();
+        if (!pricing) {
+            return null;
+        }
+        return pricing.providers[provider] || null;
+    }
+    /**
+     * Get all provider pricing
+     */
+    async getAllPricing() {
+        const pricing = await this.fetchPricing();
+        if (!pricing) {
+            return null;
+        }
+        return pricing.providers;
+    }
+    /**
+     * Calculate monthly cost for a provider
+     */
+    async calculateMonthlyCost(provider, resources) {
+        const pricing = await this.getProviderPricing(provider);
+        if (!pricing) {
+            return null;
+        }
+        const hoursRatio = resources.hours / 720;
+        let computeCost = 0;
+        let baseCost = 0;
+        switch (pricing.model) {
+            case "per-hour":
+                computeCost =
+                    resources.instances *
+                        (resources.cpu * pricing.cpuPerHour * resources.hours +
+                            resources.memory *
+                                pricing.memoryPerGbHour *
+                                resources.hours);
+                break;
+            case "per-month":
+                baseCost = resources.instances * pricing.basePrice * hoursRatio;
+                break;
+            case "usage":
+                baseCost = pricing.basePrice;
+                computeCost =
+                    resources.instances *
+                        (resources.cpu * pricing.cpuPerHour * resources.hours +
+                            resources.memory *
+                                pricing.memoryPerGbHour *
+                                resources.hours);
+                break;
+        }
+        // Storage cost
+        const storageCost = resources.storage * pricing.storagePerGb;
+        // Bandwidth cost (above free tier)
+        const billableBandwidth = Math.max(0, resources.bandwidth - pricing.freeBandwidth);
+        const bandwidthCost = billableBandwidth * pricing.bandwidthPerGb;
+        const totalCost = computeCost + storageCost + bandwidthCost + baseCost;
+        return {
+            provider,
+            monthlyCost: Math.round(totalCost * 100) / 100,
+            breakdown: {
+                compute: Math.round(computeCost * 100) / 100,
+                storage: Math.round(storageCost * 100) / 100,
+                bandwidth: Math.round(bandwidthCost * 100) / 100,
+                base: Math.round(baseCost * 100) / 100,
+            },
+            currency: "USD",
+            notes: pricing.notes,
+        };
+    }
+    /**
+     * Compare costs across all providers
+     */
+    async compareCosts(resources) {
+        const pricing = await this.fetchPricing();
+        if (!pricing) {
+            return [];
+        }
+        const estimates = [];
+        for (const provider of Object.keys(pricing.providers)) {
+            const estimate = await this.calculateMonthlyCost(provider, resources);
+            if (estimate) {
+                estimates.push(estimate);
+            }
+        }
+        // Sort by cost (ascending)
+        return estimates.sort((a, b) => a.monthlyCost - b.monthlyCost);
+    }
+    /**
+     * Update cached pricing
+     */
+    async updateCache() {
+        const data = await this.fetchPricing(true);
+        return data !== null;
+    }
+    /**
+     * Clear pricing cache
+     */
+    clearCache() {
+        this.cachedData = null;
+        try {
+            if (fs_1.default.existsSync(CACHE_FILE)) {
+                fs_1.default.unlinkSync(CACHE_FILE);
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    /**
+     * Get the source of the last fetch
+     */
+    getLastSource() {
+        return this.lastSource;
+    }
+    /**
+     * Get pricing info (version, last updated, source)
+     */
+    async getInfo() {
+        const pricing = await this.fetchPricing();
+        if (!pricing) {
+            return null;
+        }
+        let cacheAge = null;
+        if (this.cachedData) {
+            cacheAge = Math.floor((Date.now() - this.cachedData.timestamp) / 1000);
+        }
+        return {
+            version: pricing.version,
+            updated: pricing.updated,
+            source: this.lastSource,
+            cacheAge,
+        };
+    }
+    /**
+     * Print pricing status (for CLI output)
+     */
+    async printStatus() {
+        const info = await this.getInfo();
+        console.log(chalk_1.default.bold("\nPricing System Status:\n"));
+        if (info) {
+            console.log(`  Version:     ${chalk_1.default.green(info.version)}`);
+            console.log(`  Last Update: ${chalk_1.default.cyan(info.updated)}`);
+            console.log(`  Source:      ${chalk_1.default.yellow(info.source || "Unknown")}`);
+            if (info.cacheAge !== null) {
+                const hours = Math.floor(info.cacheAge / 3600);
+                const minutes = Math.floor((info.cacheAge % 3600) / 60);
+                console.log(`  Cache Age:   ${hours}h ${minutes}m`);
+            }
+        }
+        else {
+            console.log(chalk_1.default.red("  Unable to fetch pricing data"));
+            console.log(chalk_1.default.gray("  Run 'expressots costs update' to refresh"));
+        }
+    }
+    /**
+     * Get list of available providers
+     */
+    async getAvailableProviders() {
+        const pricing = await this.fetchPricing();
+        if (!pricing) {
+            return [];
+        }
+        return Object.keys(pricing.providers);
+    }
+}
+exports.PricingManager = PricingManager;
+// Singleton instance
+let pricingManagerInstance = null;
+function getPricingManager(config) {
+    if (!pricingManagerInstance) {
+        pricingManagerInstance = new PricingManager(config);
+    }
+    return pricingManagerInstance;
+}
+exports.getPricingManager = getPricingManager;
+function resetPricingManager() {
+    pricingManagerInstance = null;
+}
+exports.resetPricingManager = resetPricingManager;

package/bin/costs/providers/index.d.ts

@@ -0,0 +1,32 @@
+import type { CloudProvider } from "../cli";
+export interface ProviderPricing {
+    serviceName: string;
+    model: "per-hour" | "per-month" | "usage";
+    basePrice: number;
+    cpuPerHour: number;
+    memoryPerGbHour: number;
+    storagePerGb: number;
+    bandwidthPerGb: number;
+    freeBandwidth: number;
+    freeCredits?: number;
+    notes?: string;
+}
+/**
+ * Get pricing for a specific provider
+ */
+export declare function getPricing(provider: CloudProvider): ProviderPricing;
+/**
+ * Get all provider pricing
+ */
+export declare function getAllPricing(): Record<CloudProvider, ProviderPricing>;
+/**
+ * Calculate monthly cost for a provider
+ */
+export declare function calculateMonthlyCost(provider: CloudProvider, resources: {
+    instances: number;
+    cpu: number;
+    memory: number;
+    storage: number;
+    bandwidth: number;
+    hours: number;
+}): number;

package/bin/costs/providers/index.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMonthlyCost = exports.getAllPricing = exports.getPricing = void 0;
+/**
+ * Pricing data for various cloud providers
+ * Note: These are approximate prices for estimation purposes.
+ * Actual prices vary by region, instance type, and commitment.
+ */
+const PROVIDER_PRICING = {
+    aws: {
+        serviceName: "ECS Fargate",
+        model: "per-hour",
+        basePrice: 0,
+        cpuPerHour: 0.04048,
+        memoryPerGbHour: 0.004445,
+        storagePerGb: 0.1,
+        bandwidthPerGb: 0.09,
+        freeBandwidth: 100,
+        notes: "Prices for us-east-1 region",
+    },
+    gcp: {
+        serviceName: "Cloud Run",
+        model: "per-hour",
+        basePrice: 0,
+        cpuPerHour: 0.024,
+        memoryPerGbHour: 0.0025,
+        storagePerGb: 0.1,
+        bandwidthPerGb: 0.12,
+        freeBandwidth: 200,
+        freeCredits: 300,
+        notes: "Pay only for what you use, scales to zero",
+    },
+    azure: {
+        serviceName: "Container Apps",
+        model: "per-hour",
+        basePrice: 0,
+        cpuPerHour: 0.024,
+        memoryPerGbHour: 0.003,
+        storagePerGb: 0.1,
+        bandwidthPerGb: 0.087,
+        freeBandwidth: 100,
+        freeCredits: 200,
+        notes: "First 180,000 vCPU-seconds free per month",
+    },
+    railway: {
+        serviceName: "Web Service",
+        model: "usage",
+        basePrice: 5,
+        cpuPerHour: 0.000463,
+        memoryPerGbHour: 0.000231,
+        storagePerGb: 0.25,
+        bandwidthPerGb: 0,
+        freeBandwidth: 1000,
+        freeCredits: 5,
+        notes: "Usage-based pricing, great DX",
+    },
+    render: {
+        serviceName: "Web Service",
+        model: "per-month",
+        basePrice: 7,
+        cpuPerHour: 0,
+        memoryPerGbHour: 0,
+        storagePerGb: 0.25,
+        bandwidthPerGb: 0.1,
+        freeBandwidth: 100,
+        notes: "Simple pricing, auto-scaling available",
+    },
+    fly: {
+        serviceName: "Machines",
+        model: "per-hour",
+        basePrice: 0,
+        cpuPerHour: 0.0000158,
+        memoryPerGbHour: 0.0000047,
+        storagePerGb: 0.15,
+        bandwidthPerGb: 0.02,
+        freeBandwidth: 100,
+        freeCredits: 0,
+        notes: "Pay for resources while running, scales to zero",
+    },
+    digitalocean: {
+        serviceName: "App Platform",
+        model: "per-month",
+        basePrice: 5,
+        cpuPerHour: 0,
+        memoryPerGbHour: 0,
+        storagePerGb: 0.1,
+        bandwidthPerGb: 0.01,
+        freeBandwidth: 500,
+        notes: "Simple pricing, good for small projects",
+    },
+    heroku: {
+        serviceName: "Eco Dyno",
+        model: "per-month",
+        basePrice: 5,
+        cpuPerHour: 0,
+        memoryPerGbHour: 0,
+        storagePerGb: 0,
+        bandwidthPerGb: 0,
+        freeBandwidth: 2000,
+        notes: "Basic: $7/mo, Standard: $25/mo, Performance: $250+/mo",
+    },
+};
+/**
+ * Get pricing for a specific provider
+ */
+function getPricing(provider) {
+    return PROVIDER_PRICING[provider] || PROVIDER_PRICING.aws;
+}
+exports.getPricing = getPricing;
+/**
+ * Get all provider pricing
+ */
+function getAllPricing() {
+    return PROVIDER_PRICING;
+}
+exports.getAllPricing = getAllPricing;
+/**
+ * Calculate monthly cost for a provider
+ */
+function calculateMonthlyCost(provider, resources) {
+    const pricing = getPricing(provider);
+    const hoursRatio = resources.hours / 720;
+    let cost = 0;
+    switch (pricing.model) {
+        case "per-hour":
+            cost =
+                resources.instances *
+                    (resources.cpu * pricing.cpuPerHour * resources.hours +
+                        resources.memory *
+                            pricing.memoryPerGbHour *
+                            resources.hours);
+            break;
+        case "per-month":
+            cost = resources.instances * pricing.basePrice * hoursRatio;
+            break;
+        case "usage":
+            cost =
+                pricing.basePrice +
+                    resources.instances *
+                        (resources.cpu * pricing.cpuPerHour * resources.hours +
+                            resources.memory *
+                                pricing.memoryPerGbHour *
+                                resources.hours);
+            break;
+    }
+    // Add storage cost
+    cost += resources.storage * pricing.storagePerGb;
+    // Add bandwidth cost (above free tier)
+    const billableBandwidth = Math.max(0, resources.bandwidth - pricing.freeBandwidth);
+    cost += billableBandwidth * pricing.bandwidthPerGb;
+    return Math.round(cost * 100) / 100;
+}
+exports.calculateMonthlyCost = calculateMonthlyCost;

package/bin/costs/sources/api-source.d.ts

@@ -0,0 +1,10 @@
+/**
+ * API pricing source - fetches from ExpressoTS pricing API
+ * Currently a placeholder for future implementation
+ */
+import type { PricingData, PricingSource } from "../types";
+export declare class APIPricingSource implements PricingSource {
+    name: string;
+    fetch(): Promise<PricingData | null>;
+}
+export declare function createAPIPricingSource(): PricingSource;

package/bin/costs/sources/api-source.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * API pricing source - fetches from ExpressoTS pricing API
+ * Currently a placeholder for future implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAPIPricingSource = exports.APIPricingSource = void 0;
+const API_URL = "https://api.expressots.com/pricing/v1";
+class APIPricingSource {
+    constructor() {
+        this.name = "api";
+    }
+    async fetch() {
+        // API not yet implemented - return null to fall through to next source
+        // In the future, this will fetch from the ExpressoTS pricing API
+        try {
+            // Placeholder for future API implementation
+            // const response = await fetch(API_URL);
+            // if (!response.ok) return null;
+            // return await response.json();
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.APIPricingSource = APIPricingSource;
+function createAPIPricingSource() {
+    return new APIPricingSource();
+}
+exports.createAPIPricingSource = createAPIPricingSource;

package/bin/costs/sources/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pricing sources exports
+ */
+export { APIPricingSource, createAPIPricingSource } from "./api-source";
+export { RemoteJSONPricingSource, createRemoteJSONPricingSource, } from "./remote-json-source";
+export { LocalJSONPricingSource, createLocalJSONPricingSource, } from "./local-json-source";

package/bin/costs/sources/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Pricing sources exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalJSONPricingSource = exports.LocalJSONPricingSource = exports.createRemoteJSONPricingSource = exports.RemoteJSONPricingSource = exports.createAPIPricingSource = exports.APIPricingSource = void 0;
+var api_source_1 = require("./api-source");
+Object.defineProperty(exports, "APIPricingSource", { enumerable: true, get: function () { return api_source_1.APIPricingSource; } });
+Object.defineProperty(exports, "createAPIPricingSource", { enumerable: true, get: function () { return api_source_1.createAPIPricingSource; } });
+var remote_json_source_1 = require("./remote-json-source");
+Object.defineProperty(exports, "RemoteJSONPricingSource", { enumerable: true, get: function () { return remote_json_source_1.RemoteJSONPricingSource; } });
+Object.defineProperty(exports, "createRemoteJSONPricingSource", { enumerable: true, get: function () { return remote_json_source_1.createRemoteJSONPricingSource; } });
+var local_json_source_1 = require("./local-json-source");
+Object.defineProperty(exports, "LocalJSONPricingSource", { enumerable: true, get: function () { return local_json_source_1.LocalJSONPricingSource; } });
+Object.defineProperty(exports, "createLocalJSONPricingSource", { enumerable: true, get: function () { return local_json_source_1.createLocalJSONPricingSource; } });

package/bin/costs/sources/local-json-source.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Local JSON pricing source - reads from user's custom pricing file
+ */
+import type { PricingData, PricingSource } from "../types";
+export declare class LocalJSONPricingSource implements PricingSource {
+    name: string;
+    private filePath;
+    constructor(filePath?: string);
+    fetch(): Promise<PricingData | null>;
+    /**
+     * Check if custom pricing file exists
+     */
+    exists(): boolean;
+    /**
+     * Get the file path
+     */
+    getPath(): string;
+    /**
+     * Set custom file path
+     */
+    setPath(filePath: string): void;
+}
+export declare function createLocalJSONPricingSource(filePath?: string): PricingSource;

package/bin/costs/sources/local-json-source.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Local JSON pricing source - reads from user's custom pricing file
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalJSONPricingSource = exports.LocalJSONPricingSource = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const DEFAULT_PATH = path_1.default.join(os_1.default.homedir(), ".expressots", "pricing.json");
+class LocalJSONPricingSource {
+    constructor(filePath) {
+        this.name = "local";
+        this.filePath = filePath || DEFAULT_PATH;
+    }
+    async fetch() {
+        try {
+            if (!fs_1.default.existsSync(this.filePath)) {
+                return null;
+            }
+            const content = fs_1.default.readFileSync(this.filePath, "utf-8");
+            const pricing = JSON.parse(content);
+            // Basic validation
+            if (!pricing.version || !pricing.providers) {
+                return null;
+            }
+            return pricing;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if custom pricing file exists
+     */
+    exists() {
+        return fs_1.default.existsSync(this.filePath);
+    }
+    /**
+     * Get the file path
+     */
+    getPath() {
+        return this.filePath;
+    }
+    /**
+     * Set custom file path
+     */
+    setPath(filePath) {
+        this.filePath = filePath;
+    }
+}
+exports.LocalJSONPricingSource = LocalJSONPricingSource;
+function createLocalJSONPricingSource(filePath) {
+    return new LocalJSONPricingSource(filePath);
+}
+exports.createLocalJSONPricingSource = createLocalJSONPricingSource;

package/bin/costs/sources/remote-json-source.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Remote JSON pricing source - fetches from GitHub-hosted pricing file
+ */
+import type { PricingData, PricingSource } from "../types";
+export declare class RemoteJSONPricingSource implements PricingSource {
+    name: string;
+    private url;
+    constructor(url?: string);
+    fetch(): Promise<PricingData | null>;
+}
+export declare function createRemoteJSONPricingSource(url?: string): PricingSource;