infra-cost 1.6.0 → 1.8.0

package/dist/index.js

@@ -9,6 +9,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -29,6 +32,172 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module2) {
+    module2.exports = {
+      name: "infra-cost",
+      version: "1.8.0",
+      description: "Multi-cloud FinOps CLI tool for comprehensive cost analysis and infrastructure optimization across AWS, GCP, Azure, Alibaba Cloud, and Oracle Cloud",
+      keywords: [
+        "aws",
+        "gcp",
+        "azure",
+        "cloud-cost",
+        "finops",
+        "cost-optimization",
+        "multi-cloud",
+        "cost-analysis",
+        "infrastructure",
+        "cloud-billing",
+        "cost-management",
+        "devops",
+        "cli-tool",
+        "cost-monitoring",
+        "budget-tracking"
+      ],
+      author: {
+        name: "Code Collab",
+        email: "codecollab.co@gmail.com",
+        url: "https://github.com/codecollab-co/infra-cost"
+      },
+      files: [
+        "!tests/**/*",
+        "dist/**/*",
+        "!dist/**/*.js.map",
+        "bin/**/*"
+      ],
+      bin: {
+        "infra-cost": "./bin/index.js",
+        "aws-cost": "./bin/index.js"
+      },
+      main: "./dist/index.js",
+      scripts: {
+        prebuild: "run-s clean",
+        build: "tsup",
+        clean: "rm -rf dist",
+        typecheck: "tsc --noEmit",
+        lint: "eslint src --ext .ts",
+        "lint:fix": "eslint src --ext .ts --fix",
+        test: "jest",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage",
+        dev: "tsup --watch",
+        "version:check": `echo "Current version: $(npm pkg get version | tr -d '"')"`,
+        "version:next": "npm version patch --no-git-tag-version",
+        "version:bump:patch": "npm version patch",
+        "version:bump:minor": "npm version minor",
+        "version:bump:major": "npm version major",
+        "publish:dry": "npm publish --dry-run",
+        "publish:latest": "npm publish",
+        "publish:beta": "npm publish --tag beta",
+        "prepare-release": "npm run build && npm run test && npm run version:bump:patch",
+        postpublish: 'echo "\u{1F389} Published $(npm pkg get name)@$(npm pkg get version) to npm!"',
+        prepublishOnly: "npm run build"
+      },
+      repository: {
+        type: "git",
+        url: "https://github.com/codecollab-co/infra-cost.git"
+      },
+      bugs: {
+        url: "https://github.com/codecollab-co/infra-cost/issues"
+      },
+      homepage: "https://github.com/codecollab-co/infra-cost#readme",
+      license: "MIT",
+      engines: {
+        node: ">=20.0.0",
+        npm: ">=10.0.0"
+      },
+      dependencies: {
+        "@alicloud/bssopenapi20171214": "^2.0.1",
+        "@alicloud/cs20151215": "^4.0.1",
+        "@alicloud/ecs20140526": "^4.0.3",
+        "@alicloud/oss20190517": "^1.0.6",
+        "@alicloud/rds20140815": "^3.0.2",
+        "@alicloud/tea-util": "^1.4.7",
+        "@aws-sdk/client-budgets": "^3.975.0",
+        "@aws-sdk/client-cost-explorer": "^3.975.0",
+        "@aws-sdk/client-ec2": "^3.975.0",
+        "@aws-sdk/client-elastic-load-balancing-v2": "^3.975.0",
+        "@aws-sdk/client-iam": "^3.975.0",
+        "@aws-sdk/client-lambda": "^3.975.0",
+        "@aws-sdk/client-rds": "^3.975.0",
+        "@aws-sdk/client-s3": "^3.975.0",
+        "@aws-sdk/client-sts": "^3.975.0",
+        "@aws-sdk/credential-providers": "^3.975.0",
+        "@azure/arm-compute": "^23.3.0",
+        "@azure/arm-consumption": "^9.2.1",
+        "@azure/arm-containerservice": "^24.1.0",
+        "@azure/arm-costmanagement": "^1.0.0-beta.2",
+        "@azure/arm-network": "^35.0.0",
+        "@azure/arm-sql": "^10.0.0",
+        "@azure/arm-storage": "^19.1.0",
+        "@azure/arm-subscriptions": "^6.0.0",
+        "@azure/identity": "^4.13.0",
+        "@google-cloud/bigquery": "^8.1.1",
+        "@google-cloud/billing": "^5.1.1",
+        "@google-cloud/compute": "^6.7.0",
+        "@google-cloud/container": "^6.6.0",
+        "@google-cloud/monitoring": "^5.3.1",
+        "@google-cloud/resource-manager": "^6.2.1",
+        "@google-cloud/sql": "^0.24.0",
+        "@google-cloud/storage": "^7.18.0",
+        "@slack/web-api": "^7.5.0",
+        callsites: "^3.1.0",
+        chalk: "^4.1.2",
+        "cli-progress": "^3.12.0",
+        "cli-table3": "^0.6.5",
+        commander: "^12.1.0",
+        cors: "^2.8.6",
+        dayjs: "^1.11.19",
+        exceljs: "^4.4.0",
+        express: "^5.2.1",
+        "express-rate-limit": "^8.2.1",
+        "fd-slicer": "^1.1.0",
+        "google-auth-library": "^10.5.0",
+        googleapis: "^171.0.0",
+        helmet: "^8.1.0",
+        ini: "^6.0.0",
+        ink: "^6.6.0",
+        moment: "^2.30.1",
+        "node-fetch": "^2.7.0",
+        "oci-budget": "^2.88.0",
+        "oci-common": "^2.88.0",
+        "oci-containerengine": "^2.88.0",
+        "oci-core": "^2.88.0",
+        "oci-database": "^2.88.0",
+        "oci-identity": "^2.88.0",
+        "oci-objectstorage": "^2.88.0",
+        "oci-usageapi": "^2.88.0",
+        ora: "^9.1.0",
+        pako: "^2.1.0",
+        pend: "^1.2.0",
+        react: "^19.2.4",
+        "swagger-jsdoc": "^6.2.8",
+        "swagger-ui-express": "^5.0.1",
+        yauzl: "^3.0.0",
+        zod: "^3.23.8"
+      },
+      devDependencies: {
+        "@types/cors": "^2.8.19",
+        "@types/express": "^5.0.6",
+        "@types/jest": "^29.5.12",
+        "@types/node": "^22.5.4",
+        "@types/yauzl": "^2.10.3",
+        "@typescript-eslint/eslint-plugin": "^8.5.0",
+        "@typescript-eslint/parser": "^8.5.0",
+        eslint: "^8.57.0",
+        jest: "^29.7.0",
+        "npm-run-all": "^4.1.5",
+        "ts-jest": "^29.2.5",
+        tsup: "^6.7.0",
+        typescript: "^5.6.2"
+      }
+    };
+  }
+});
 
 // src/core/logging/structured-logger.ts
 function initializeLogger(config) {
@@ -565,6 +734,209 @@ var init_schema = __esm({
   }
 });
 
+// src/core/config/loader.ts
+function discoverConfigFile() {
+  for (const configPath of CONFIG_PATHS) {
+    if ((0, import_fs.existsSync)(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function loadConfigFile(configPath) {
+  try {
+    const content = (0, import_fs.readFileSync)(configPath, "utf8");
+    const config = JSON.parse(content);
+    if (config.profiles && config.defaults?.profile) {
+      const activeProfile = config.profiles[config.defaults.profile];
+      if (activeProfile) {
+        return mergeConfigs(config.defaults, activeProfile);
+      }
+    }
+    return config.defaults || config;
+  } catch (error) {
+    console.warn(`Warning: Could not load config from ${configPath}: ${error.message}`);
+    return {};
+  }
+}
+function resolveEnvVars(config) {
+  const resolved = JSON.parse(JSON.stringify(config));
+  if (process.env.AWS_ACCESS_KEY_ID) {
+    resolved.accessKey = process.env.AWS_ACCESS_KEY_ID;
+  }
+  if (process.env.AWS_SECRET_ACCESS_KEY) {
+    resolved.secretKey = process.env.AWS_SECRET_ACCESS_KEY;
+  }
+  if (process.env.AWS_SESSION_TOKEN) {
+    resolved.sessionToken = process.env.AWS_SESSION_TOKEN;
+  }
+  if (process.env.AWS_REGION) {
+    resolved.region = process.env.AWS_REGION;
+  }
+  if (process.env.AWS_PROFILE) {
+    resolved.profile = process.env.AWS_PROFILE;
+  }
+  if (process.env.SLACK_TOKEN || process.env.SLACK_CHANNEL) {
+    resolved.slack = {
+      ...resolved.slack,
+      token: process.env.SLACK_TOKEN ?? resolved.slack?.token,
+      channel: process.env.SLACK_CHANNEL ?? resolved.slack?.channel,
+      enabled: true
+    };
+  }
+  return resolved;
+}
+function mergeConfigs(...configs) {
+  const result = {};
+  for (const config of configs) {
+    for (const [key, value] of Object.entries(config)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (typeof value === "object" && !Array.isArray(value)) {
+        result[key] = { ...result[key], ...value };
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function autoLoadConfig(cliOptions = {}) {
+  let config = { ...DEFAULT_CONFIG2 };
+  const configPath = cliOptions.configFile || discoverConfigFile();
+  if (configPath) {
+    const fileConfig = loadConfigFile(configPath);
+    config = mergeConfigs(config, fileConfig);
+  }
+  config = mergeConfigs(config, resolveEnvVars(config));
+  const cliConfig = mapCliOptionsToConfig(cliOptions);
+  config = mergeConfigs(config, cliConfig);
+  return config;
+}
+function mapCliOptionsToConfig(options) {
+  const config = {};
+  if (options.provider)
+    config.provider = options.provider;
+  if (options.profile)
+    config.profile = options.profile;
+  if (options.region)
+    config.region = options.region;
+  if (options.accessKey)
+    config.accessKey = options.accessKey;
+  if (options.secretKey)
+    config.secretKey = options.secretKey;
+  if (options.sessionToken)
+    config.sessionToken = options.sessionToken;
+  if (options.json || options.text || options.summary) {
+    config.output = config.output || {};
+    if (options.json)
+      config.output.format = "json";
+    if (options.text)
+      config.output.format = "text";
+    if (options.summary)
+      config.output.summary = true;
+  }
+  if (options.delta !== void 0) {
+    config.output = config.output || {};
+    config.output.showDelta = options.delta;
+  }
+  if (options.deltaThreshold) {
+    config.output = config.output || {};
+    config.output.deltaThreshold = parseFloat(options.deltaThreshold);
+  }
+  if (options.quickWins !== void 0) {
+    config.output = config.output || {};
+    config.output.showQuickWins = options.quickWins;
+  }
+  if (options.quickWinsCount) {
+    config.output = config.output || {};
+    config.output.quickWinsCount = parseInt(options.quickWinsCount, 10);
+  }
+  if (options.cache !== void 0 || options.noCache !== void 0) {
+    config.cache = config.cache || {};
+    config.cache.enabled = options.cache === true || options.noCache !== true;
+  }
+  if (options.cacheTtl) {
+    config.cache = config.cache || {};
+    config.cache.ttl = options.cacheTtl;
+  }
+  if (options.cacheType) {
+    config.cache = config.cache || {};
+    config.cache.type = options.cacheType;
+  }
+  if (options.slackToken || options.slackChannel) {
+    config.slack = config.slack || {};
+    if (options.slackToken)
+      config.slack.token = options.slackToken;
+    if (options.slackChannel)
+      config.slack.channel = options.slackChannel;
+    config.slack.enabled = true;
+  }
+  if (options.logLevel || options.verbose || options.quiet) {
+    config.logging = config.logging || {};
+    if (options.logLevel)
+      config.logging.level = options.logLevel;
+    if (options.verbose)
+      config.logging.level = "debug";
+    if (options.quiet)
+      config.logging.level = "error";
+  }
+  return config;
+}
+var import_fs, import_path, import_os, CONFIG_PATHS, DEFAULT_CONFIG2;
+var init_loader = __esm({
+  "src/core/config/loader.ts"() {
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    CONFIG_PATHS = [
+      (0, import_path.join)(process.cwd(), "infra-cost.config.json"),
+      // Project-specific
+      (0, import_path.join)(process.cwd(), ".infra-cost.config.json"),
+      // Project-specific (hidden)
+      (0, import_path.join)(process.cwd(), ".infra-cost", "config.json"),
+      // Project directory
+      (0, import_path.join)((0, import_os.homedir)(), ".infra-cost", "config.json"),
+      // User global
+      (0, import_path.join)((0, import_os.homedir)(), ".config", "infra-cost", "config.json")
+      // XDG standard
+    ];
+    DEFAULT_CONFIG2 = {
+      provider: "aws",
+      profile: "default",
+      region: "us-east-1",
+      output: {
+        format: "fancy",
+        summary: false,
+        showDelta: true,
+        // NEW: Show delta by default
+        showQuickWins: true,
+        // NEW: Show quick wins by default
+        deltaThreshold: 10,
+        quickWinsCount: 3
+      },
+      cache: {
+        enabled: true,
+        // NEW: Cache enabled by default
+        ttl: "4h",
+        type: "file"
+      },
+      logging: {
+        level: "info",
+        format: "pretty",
+        auditEnabled: false
+      }
+    };
+    __name(discoverConfigFile, "discoverConfigFile");
+    __name(loadConfigFile, "loadConfigFile");
+    __name(resolveEnvVars, "resolveEnvVars");
+    __name(mergeConfigs, "mergeConfigs");
+    __name(autoLoadConfig, "autoLoadConfig");
+    __name(mapCliOptionsToConfig, "mapCliOptionsToConfig");
+  }
+});
+
 // src/types/providers.ts
 var CloudProviderAdapter, ResourceType;
 var init_providers = __esm({
@@ -10208,366 +10580,669 @@ var init_multicloud = __esm({
   }
 });
 
-// src/cli/index.ts
-var import_commander = require("commander");
+// src/api/utils.ts
+async function getProviderFromConfig() {
+  const config = autoLoadConfig();
+  const factory = new CloudProviderFactory();
+  return factory.createProvider(config);
+}
+function getConfig2() {
+  return autoLoadConfig();
+}
+var init_utils = __esm({
+  "src/api/utils.ts"() {
+    init_factory();
+    init_loader();
+    __name(getProviderFromConfig, "getProviderFromConfig");
+    __name(getConfig2, "getConfig");
+  }
+});
 
-// package.json
-var package_default = {
-  name: "infra-cost",
-  version: "1.6.0",
-  description: "Multi-cloud FinOps CLI tool for comprehensive cost analysis and infrastructure optimization across AWS, GCP, Azure, Alibaba Cloud, and Oracle Cloud",
-  keywords: [
-    "aws",
-    "gcp",
-    "azure",
-    "cloud-cost",
-    "finops",
-    "cost-optimization",
-    "multi-cloud",
-    "cost-analysis",
-    "infrastructure",
-    "cloud-billing",
-    "cost-management",
-    "devops",
-    "cli-tool",
-    "cost-monitoring",
-    "budget-tracking"
-  ],
-  author: {
-    name: "Code Collab",
-    email: "codecollab.co@gmail.com",
-    url: "https://github.com/codecollab-co/infra-cost"
-  },
-  files: [
-    "!tests/**/*",
-    "dist/**/*",
-    "!dist/**/*.js.map",
-    "bin/**/*"
-  ],
-  bin: {
-    "infra-cost": "./bin/index.js",
-    "aws-cost": "./bin/index.js"
-  },
-  main: "./dist/index.js",
-  scripts: {
-    prebuild: "run-s clean",
-    build: "tsup",
-    clean: "rm -rf dist",
-    typecheck: "tsc --noEmit",
-    lint: "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    test: "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    dev: "tsup --watch",
-    "version:check": `echo "Current version: $(npm pkg get version | tr -d '"')"`,
-    "version:next": "npm version patch --no-git-tag-version",
-    "version:bump:patch": "npm version patch",
-    "version:bump:minor": "npm version minor",
-    "version:bump:major": "npm version major",
-    "publish:dry": "npm publish --dry-run",
-    "publish:latest": "npm publish",
-    "publish:beta": "npm publish --tag beta",
-    "prepare-release": "npm run build && npm run test && npm run version:bump:patch",
-    postpublish: 'echo "\u{1F389} Published $(npm pkg get name)@$(npm pkg get version) to npm!"',
-    prepublishOnly: "npm run build"
-  },
-  repository: {
-    type: "git",
-    url: "https://github.com/codecollab-co/infra-cost.git"
-  },
-  bugs: {
-    url: "https://github.com/codecollab-co/infra-cost/issues"
-  },
-  homepage: "https://github.com/codecollab-co/infra-cost#readme",
-  license: "MIT",
-  engines: {
-    node: ">=20.0.0",
-    npm: ">=10.0.0"
-  },
-  dependencies: {
-    "@alicloud/bssopenapi20171214": "^2.0.1",
-    "@alicloud/cs20151215": "^4.0.1",
-    "@alicloud/ecs20140526": "^4.0.3",
-    "@alicloud/oss20190517": "^1.0.6",
-    "@alicloud/rds20140815": "^3.0.2",
-    "@alicloud/tea-util": "^1.4.7",
-    "@aws-sdk/client-budgets": "^3.975.0",
-    "@aws-sdk/client-cost-explorer": "^3.975.0",
-    "@aws-sdk/client-ec2": "^3.975.0",
-    "@aws-sdk/client-elastic-load-balancing-v2": "^3.975.0",
-    "@aws-sdk/client-iam": "^3.975.0",
-    "@aws-sdk/client-lambda": "^3.975.0",
-    "@aws-sdk/client-rds": "^3.975.0",
-    "@aws-sdk/client-s3": "^3.975.0",
-    "@aws-sdk/client-sts": "^3.975.0",
-    "@aws-sdk/credential-providers": "^3.975.0",
-    "@azure/arm-compute": "^23.3.0",
-    "@azure/arm-consumption": "^9.2.1",
-    "@azure/arm-containerservice": "^24.1.0",
-    "@azure/arm-costmanagement": "^1.0.0-beta.2",
-    "@azure/arm-network": "^35.0.0",
-    "@azure/arm-sql": "^10.0.0",
-    "@azure/arm-storage": "^19.1.0",
-    "@azure/arm-subscriptions": "^6.0.0",
-    "@azure/identity": "^4.13.0",
-    "@google-cloud/bigquery": "^8.1.1",
-    "@google-cloud/billing": "^5.1.1",
-    "@google-cloud/compute": "^6.7.0",
-    "@google-cloud/container": "^6.6.0",
-    "@google-cloud/monitoring": "^5.3.1",
-    "@google-cloud/resource-manager": "^6.2.1",
-    "@google-cloud/sql": "^0.24.0",
-    "@google-cloud/storage": "^7.18.0",
-    "@slack/web-api": "^7.5.0",
-    callsites: "^3.1.0",
-    chalk: "^4.1.2",
-    "cli-progress": "^3.12.0",
-    "cli-table3": "^0.6.5",
-    commander: "^12.1.0",
-    dayjs: "^1.11.19",
-    exceljs: "^4.4.0",
-    express: "^5.2.1",
-    "fd-slicer": "^1.1.0",
-    "google-auth-library": "^10.5.0",
-    googleapis: "^171.0.0",
-    ini: "^6.0.0",
-    ink: "^6.6.0",
-    moment: "^2.30.1",
-    "node-fetch": "^2.7.0",
-    "oci-budget": "^2.88.0",
-    "oci-common": "^2.88.0",
-    "oci-containerengine": "^2.88.0",
-    "oci-core": "^2.88.0",
-    "oci-database": "^2.88.0",
-    "oci-identity": "^2.88.0",
-    "oci-objectstorage": "^2.88.0",
-    "oci-usageapi": "^2.88.0",
-    ora: "^9.1.0",
-    pako: "^2.1.0",
-    pend: "^1.2.0",
-    react: "^19.2.4",
-    yauzl: "^3.0.0",
-    zod: "^3.23.8"
-  },
-  devDependencies: {
-    "@types/jest": "^29.5.12",
-    "@types/node": "^22.5.4",
-    "@types/yauzl": "^2.10.3",
-    "@typescript-eslint/eslint-plugin": "^8.5.0",
-    "@typescript-eslint/parser": "^8.5.0",
-    eslint: "^8.57.0",
-    jest: "^29.7.0",
-    "npm-run-all": "^4.1.5",
-    "ts-jest": "^29.2.5",
-    tsup: "^6.7.0",
-    typescript: "^5.6.2"
+// src/api/routes/costs.ts
+var costs_exports2 = {};
+__export(costs_exports2, {
+  default: () => costs_default
+});
+var import_express, router, costs_default;
+var init_costs2 = __esm({
+  "src/api/routes/costs.ts"() {
+    import_express = require("express");
+    init_utils();
+    init_server();
+    router = (0, import_express.Router)();
+    router.get("/", async (req, res) => {
+      try {
+        const config = getConfig2();
+        const provider = await getProviderFromConfig();
+        const today = /* @__PURE__ */ new Date();
+        const todayStart = new Date(today.setHours(0, 0, 0, 0));
+        const todayEnd = new Date(today.setHours(23, 59, 59, 999));
+        const monthStart = new Date(today.getFullYear(), today.getMonth(), 1);
+        const monthEnd = new Date(today.getFullYear(), today.getMonth() + 1, 0);
+        const [todayCosts, mtdCosts] = await Promise.all([
+          provider.getCostBreakdown(todayStart, todayEnd, "SERVICE"),
+          provider.getCostBreakdown(monthStart, monthEnd, "SERVICE")
+        ]);
+        const serviceBreakdown = {};
+        todayCosts.breakdown.forEach((item) => {
+          serviceBreakdown[item.service] = item.cost;
+        });
+        const accountInfo = await provider.getAccountInfo();
+        const response = {
+          account: {
+            id: accountInfo.accountId,
+            name: accountInfo.accountAlias || accountInfo.accountId,
+            provider: config.provider
+          },
+          costs: {
+            today: {
+              total: todayCosts.totalCost,
+              currency: "USD",
+              byService: serviceBreakdown
+            },
+            mtd: {
+              total: mtdCosts.totalCost,
+              projected: mtdCosts.totalCost * (30 / today.getDate())
+            },
+            delta: {
+              vsYesterday: 0,
+              // Would need historical data
+              vsLastWeek: 0
+              // Would need historical data
+            }
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        res.json(createApiResponse(response));
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
+      }
+    });
+    router.get("/services", async (req, res) => {
+      try {
+        const provider = await getProviderFromConfig();
+        const { startDate, endDate } = req.query;
+        const start = startDate ? new Date(startDate) : /* @__PURE__ */ new Date();
+        const end = endDate ? new Date(endDate) : /* @__PURE__ */ new Date();
+        const breakdown = await provider.getCostBreakdown(start, end, "SERVICE");
+        const services = breakdown.breakdown.map((item) => ({
+          service: item.service,
+          cost: item.cost,
+          percentage: item.cost / breakdown.totalCost * 100
+        }));
+        res.json(
+          createApiResponse({
+            total: breakdown.totalCost,
+            services,
+            period: {
+              start: start.toISOString(),
+              end: end.toISOString()
+            }
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
+      }
+    });
+    router.get("/daily", async (req, res) => {
+      try {
+        const provider = await getProviderFromConfig();
+        const { days = 30 } = req.query;
+        const daysNum = parseInt(days, 10);
+        const end = /* @__PURE__ */ new Date();
+        const start = /* @__PURE__ */ new Date();
+        start.setDate(start.getDate() - daysNum);
+        const breakdown = await provider.getCostBreakdown(start, end, "DAILY");
+        const dailyCosts = breakdown.breakdown.map((item) => ({
+          date: item.date,
+          cost: item.cost
+        }));
+        res.json(
+          createApiResponse({
+            total: breakdown.totalCost,
+            daily: dailyCosts,
+            period: {
+              start: start.toISOString(),
+              end: end.toISOString(),
+              days: daysNum
+            }
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
+      }
+    });
+    router.get("/trends", async (req, res) => {
+      try {
+        const provider = await getProviderFromConfig();
+        const end = /* @__PURE__ */ new Date();
+        const start = /* @__PURE__ */ new Date();
+        start.setMonth(start.getMonth() - 3);
+        const breakdown = await provider.getCostBreakdown(start, end, "MONTHLY");
+        const trends = breakdown.breakdown.map((item, index, arr) => {
+          const previousMonth = index > 0 ? arr[index - 1].cost : null;
+          const changePercent = previousMonth ? (item.cost - previousMonth) / previousMonth * 100 : 0;
+          return {
+            month: item.date,
+            cost: item.cost,
+            change: item.cost - (previousMonth || 0),
+            changePercent
+          };
+        });
+        res.json(
+          createApiResponse({
+            trends,
+            average: breakdown.totalCost / breakdown.breakdown.length,
+            period: {
+              start: start.toISOString(),
+              end: end.toISOString()
+            }
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
+      }
+    });
+    costs_default = router;
   }
-};
+});
 
-// src/cli/index.ts
-init_logging();
+// src/api/routes/inventory.ts
+var inventory_exports2 = {};
+__export(inventory_exports2, {
+  default: () => inventory_default
+});
+var import_express2, router2, inventory_default;
+var init_inventory6 = __esm({
+  "src/api/routes/inventory.ts"() {
+    import_express2 = require("express");
+    init_utils();
+    init_server();
+    router2 = (0, import_express2.Router)();
+    router2.get("/", async (req, res) => {
+      try {
+        const provider = await getProviderFromConfig();
+        const inventory = await provider.getResourceInventory();
+        const summary = {
+          totalResources: inventory.resources.length,
+          byType: inventory.resources.reduce((acc, resource) => {
+            acc[resource.type] = (acc[resource.type] || 0) + 1;
+            return acc;
+          }, {}),
+          byRegion: inventory.resources.reduce((acc, resource) => {
+            const region = resource.region || "global";
+            acc[region] = (acc[region] || 0) + 1;
+            return acc;
+          }, {})
+        };
+        res.json(
+          createApiResponse({
+            summary,
+            resources: inventory.resources
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
+      }
+    });
+    inventory_default = router2;
+  }
+});
 
-// src/core/config/index.ts
-init_schema();
+// src/api/routes/optimization.ts
+var optimization_exports = {};
+__export(optimization_exports, {
+  default: () => optimization_default
+});
+var import_express3, router3, optimization_default;
+var init_optimization = __esm({
+  "src/api/routes/optimization.ts"() {
+    import_express3 = require("express");
+    init_utils();
+    init_server();
+    router3 = (0, import_express3.Router)();
+    router3.get("/", async (req, res) => {
+      try {
+        const provider = await getProviderFromConfig();
+        const recommendations = await provider.getOptimizationRecommendations();
+        const summary = {
+          totalSavings: recommendations.reduce((sum, rec) => sum + (rec.estimatedMonthlySavings || 0), 0),
+          recommendationCount: recommendations.length,
+          byCategory: recommendations.reduce((acc, rec) => {
+            const category = rec.category || "other";
+            acc[category] = (acc[category] || 0) + 1;
+            return acc;
+          }, {})
+        };
+        res.json(
+          createApiResponse({
+            summary,
+            recommendations
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
+      }
+    });
+    optimization_default = router3;
+  }
+});
 
-// src/core/config/loader.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var import_os = require("os");
-var CONFIG_PATHS = [
-  (0, import_path.join)(process.cwd(), "infra-cost.config.json"),
-  // Project-specific
-  (0, import_path.join)(process.cwd(), ".infra-cost.config.json"),
-  // Project-specific (hidden)
-  (0, import_path.join)(process.cwd(), ".infra-cost", "config.json"),
-  // Project directory
-  (0, import_path.join)((0, import_os.homedir)(), ".infra-cost", "config.json"),
-  // User global
-  (0, import_path.join)((0, import_os.homedir)(), ".config", "infra-cost", "config.json")
-  // XDG standard
-];
-var DEFAULT_CONFIG2 = {
-  provider: "aws",
-  profile: "default",
-  region: "us-east-1",
-  output: {
-    format: "fancy",
-    summary: false,
-    showDelta: true,
-    // NEW: Show delta by default
-    showQuickWins: true,
-    // NEW: Show quick wins by default
-    deltaThreshold: 10,
-    quickWinsCount: 3
-  },
-  cache: {
-    enabled: true,
-    // NEW: Cache enabled by default
-    ttl: "4h",
-    type: "file"
-  },
-  logging: {
-    level: "info",
-    format: "pretty",
-    auditEnabled: false
-  }
-};
-function discoverConfigFile() {
-  for (const configPath of CONFIG_PATHS) {
-    if ((0, import_fs.existsSync)(configPath)) {
-      return configPath;
-    }
-  }
-  return null;
-}
-__name(discoverConfigFile, "discoverConfigFile");
-function loadConfigFile(configPath) {
-  try {
-    const content = (0, import_fs.readFileSync)(configPath, "utf8");
-    const config = JSON.parse(content);
-    if (config.profiles && config.defaults?.profile) {
-      const activeProfile = config.profiles[config.defaults.profile];
-      if (activeProfile) {
-        return mergeConfigs(config.defaults, activeProfile);
+// src/api/routes/chargeback.ts
+var chargeback_exports = {};
+__export(chargeback_exports, {
+  default: () => chargeback_default
+});
+var import_express4, router4, chargeback_default;
+var init_chargeback = __esm({
+  "src/api/routes/chargeback.ts"() {
+    import_express4 = require("express");
+    init_utils();
+    init_server();
+    router4 = (0, import_express4.Router)();
+    router4.get("/", async (req, res) => {
+      try {
+        const provider = await getProviderFromConfig();
+        const { groupBy = "tag" } = req.query;
+        const now = /* @__PURE__ */ new Date();
+        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+        const breakdown = await provider.getCostBreakdown(
+          monthStart,
+          now,
+          groupBy === "tag" ? "TAG" : "SERVICE"
+        );
+        res.json(
+          createApiResponse({
+            total: breakdown.totalCost,
+            breakdown: breakdown.breakdown,
+            period: {
+              start: monthStart.toISOString(),
+              end: now.toISOString()
+            },
+            groupBy
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
       }
-    }
-    return config.defaults || config;
-  } catch (error) {
-    console.warn(`Warning: Could not load config from ${configPath}: ${error.message}`);
-    return {};
-  }
-}
-__name(loadConfigFile, "loadConfigFile");
-function resolveEnvVars(config) {
-  const resolved = JSON.parse(JSON.stringify(config));
-  if (process.env.AWS_ACCESS_KEY_ID) {
-    resolved.accessKey = process.env.AWS_ACCESS_KEY_ID;
-  }
-  if (process.env.AWS_SECRET_ACCESS_KEY) {
-    resolved.secretKey = process.env.AWS_SECRET_ACCESS_KEY;
-  }
-  if (process.env.AWS_SESSION_TOKEN) {
-    resolved.sessionToken = process.env.AWS_SESSION_TOKEN;
-  }
-  if (process.env.AWS_REGION) {
-    resolved.region = process.env.AWS_REGION;
-  }
-  if (process.env.AWS_PROFILE) {
-    resolved.profile = process.env.AWS_PROFILE;
+    });
+    chargeback_default = router4;
   }
-  if (process.env.SLACK_TOKEN || process.env.SLACK_CHANNEL) {
-    resolved.slack = {
-      ...resolved.slack,
-      token: process.env.SLACK_TOKEN ?? resolved.slack?.token,
-      channel: process.env.SLACK_CHANNEL ?? resolved.slack?.channel,
-      enabled: true
-    };
+});
+
+// src/api/routes/forecast.ts
+var forecast_exports = {};
+__export(forecast_exports, {
+  default: () => forecast_default
+});
+var import_express5, router5, forecast_default;
+var init_forecast = __esm({
+  "src/api/routes/forecast.ts"() {
+    import_express5 = require("express");
+    init_server();
+    router5 = (0, import_express5.Router)();
+    router5.get("/", async (req, res) => {
+      try {
+        const { days = 30 } = req.query;
+        const daysNum = parseInt(days, 10);
+        const currentDailyAverage = 150;
+        const projectedDaily = currentDailyAverage * 1.05;
+        const forecast = [];
+        for (let i = 1; i <= daysNum; i++) {
+          const date = /* @__PURE__ */ new Date();
+          date.setDate(date.getDate() + i);
+          forecast.push({
+            date: date.toISOString().split("T")[0],
+            projected: projectedDaily,
+            confidence: Math.max(0.9 - i * 0.01, 0.5)
+            // Decreasing confidence
+          });
+        }
+        const totalProjected = projectedDaily * daysNum;
+        res.json(
+          createApiResponse({
+            forecast,
+            summary: {
+              totalProjected,
+              averageDaily: projectedDaily,
+              period: {
+                days: daysNum,
+                start: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+                end: forecast[forecast.length - 1].date
+              }
+            },
+            model: "linear-growth",
+            confidence: 0.75
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FORECAST_ERROR", error.message));
+      }
+    });
+    forecast_default = router5;
   }
-  return resolved;
-}
-__name(resolveEnvVars, "resolveEnvVars");
-function mergeConfigs(...configs) {
-  const result = {};
-  for (const config of configs) {
-    for (const [key, value] of Object.entries(config)) {
-      if (value === void 0 || value === null) {
-        continue;
+});
+
+// src/api/routes/accounts.ts
+var accounts_exports = {};
+__export(accounts_exports, {
+  default: () => accounts_default
+});
+var import_express6, router6, accounts_default;
+var init_accounts = __esm({
+  "src/api/routes/accounts.ts"() {
+    import_express6 = require("express");
+    init_utils();
+    init_server();
+    router6 = (0, import_express6.Router)();
+    router6.get("/", async (req, res) => {
+      try {
+        const config = getConfig2();
+        const provider = await getProviderFromConfig();
+        const accountInfo = await provider.getAccountInfo();
+        const accounts = [
+          {
+            id: accountInfo.accountId,
+            name: accountInfo.accountAlias || accountInfo.accountId,
+            provider: config.provider,
+            region: accountInfo.region
+          }
+        ];
+        res.json(
+          createApiResponse({
+            accounts,
+            count: accounts.length
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
       }
-      if (typeof value === "object" && !Array.isArray(value)) {
-        result[key] = { ...result[key], ...value };
-      } else {
-        result[key] = value;
+    });
+    router6.get("/:id/costs", async (req, res) => {
+      try {
+        const config = getConfig2();
+        const provider = await getProviderFromConfig();
+        const { id } = req.params;
+        const accountInfo = await provider.getAccountInfo();
+        if (accountInfo.accountId !== id) {
+          return res.status(404).json(createErrorResponse("NOT_FOUND", `Account ${id} not found`));
+        }
+        const now = /* @__PURE__ */ new Date();
+        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+        const costs = await provider.getCostBreakdown(monthStart, now, "SERVICE");
+        res.json(
+          createApiResponse({
+            accountId: id,
+            costs: {
+              total: costs.totalCost,
+              breakdown: costs.breakdown
+            },
+            period: {
+              start: monthStart.toISOString(),
+              end: now.toISOString()
+            }
+          })
+        );
+      } catch (error) {
+        res.status(500).json(createErrorResponse("FETCH_ERROR", error.message));
       }
-    }
+    });
+    accounts_default = router6;
   }
-  return result;
-}
-__name(mergeConfigs, "mergeConfigs");
-function autoLoadConfig(cliOptions = {}) {
-  let config = { ...DEFAULT_CONFIG2 };
-  const configPath = cliOptions.configFile || discoverConfigFile();
-  if (configPath) {
-    const fileConfig = loadConfigFile(configPath);
-    config = mergeConfigs(config, fileConfig);
+});
+
+// src/api/routes/reports.ts
+var reports_exports2 = {};
+__export(reports_exports2, {
+  default: () => reports_default
+});
+var import_express7, router7, reports_default;
+var init_reports2 = __esm({
+  "src/api/routes/reports.ts"() {
+    import_express7 = require("express");
+    init_utils();
+    init_server();
+    router7 = (0, import_express7.Router)();
+    router7.post("/generate", async (req, res) => {
+      try {
+        const {
+          reportType = "summary",
+          startDate,
+          endDate,
+          format = "json",
+          groupBy = "service"
+        } = req.body;
+        const config = getConfig2();
+        const provider = await getProviderFromConfig();
+        const start = startDate ? new Date(startDate) : /* @__PURE__ */ new Date();
+        const end = endDate ? new Date(endDate) : /* @__PURE__ */ new Date();
+        let groupByType = "SERVICE";
+        if (groupBy === "tag")
+          groupByType = "TAG";
+        else if (groupBy === "daily")
+          groupByType = "DAILY";
+        else if (groupBy === "monthly")
+          groupByType = "MONTHLY";
+        const breakdown = await provider.getCostBreakdown(start, end, groupByType);
+        const report = {
+          reportType,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          period: {
+            start: start.toISOString(),
+            end: end.toISOString()
+          },
+          data: {
+            total: breakdown.totalCost,
+            breakdown: breakdown.breakdown,
+            groupBy
+          },
+          format
+        };
+        res.json(createApiResponse(report));
+      } catch (error) {
+        res.status(500).json(createErrorResponse("REPORT_ERROR", error.message));
+      }
+    });
+    reports_default = router7;
   }
-  config = mergeConfigs(config, resolveEnvVars(config));
-  const cliConfig = mapCliOptionsToConfig(cliOptions);
-  config = mergeConfigs(config, cliConfig);
-  return config;
+});
+
+// src/api/server.ts
+function createApiResponse(data) {
+  return {
+    status: "success",
+    data,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-__name(autoLoadConfig, "autoLoadConfig");
-function mapCliOptionsToConfig(options) {
-  const config = {};
-  if (options.provider)
-    config.provider = options.provider;
-  if (options.profile)
-    config.profile = options.profile;
-  if (options.region)
-    config.region = options.region;
-  if (options.accessKey)
-    config.accessKey = options.accessKey;
-  if (options.secretKey)
-    config.secretKey = options.secretKey;
-  if (options.sessionToken)
-    config.sessionToken = options.sessionToken;
-  if (options.json || options.text || options.summary) {
-    config.output = config.output || {};
-    if (options.json)
-      config.output.format = "json";
-    if (options.text)
-      config.output.format = "text";
-    if (options.summary)
-      config.output.summary = true;
-  }
-  if (options.delta !== void 0) {
-    config.output = config.output || {};
-    config.output.showDelta = options.delta;
-  }
-  if (options.deltaThreshold) {
-    config.output = config.output || {};
-    config.output.deltaThreshold = parseFloat(options.deltaThreshold);
-  }
-  if (options.quickWins !== void 0) {
-    config.output = config.output || {};
-    config.output.showQuickWins = options.quickWins;
-  }
-  if (options.quickWinsCount) {
-    config.output = config.output || {};
-    config.output.quickWinsCount = parseInt(options.quickWinsCount, 10);
-  }
-  if (options.cache !== void 0 || options.noCache !== void 0) {
-    config.cache = config.cache || {};
-    config.cache.enabled = options.cache === true || options.noCache !== true;
-  }
-  if (options.cacheTtl) {
-    config.cache = config.cache || {};
-    config.cache.ttl = options.cacheTtl;
-  }
-  if (options.cacheType) {
-    config.cache = config.cache || {};
-    config.cache.type = options.cacheType;
-  }
-  if (options.slackToken || options.slackChannel) {
-    config.slack = config.slack || {};
-    if (options.slackToken)
-      config.slack.token = options.slackToken;
-    if (options.slackChannel)
-      config.slack.channel = options.slackChannel;
-    config.slack.enabled = true;
-  }
-  if (options.logLevel || options.verbose || options.quiet) {
-    config.logging = config.logging || {};
-    if (options.logLevel)
-      config.logging.level = options.logLevel;
-    if (options.verbose)
-      config.logging.level = "debug";
-    if (options.quiet)
-      config.logging.level = "error";
-  }
-  return config;
+function createErrorResponse(code, message) {
+  return {
+    status: "error",
+    error: { code, message },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-__name(mapCliOptionsToConfig, "mapCliOptionsToConfig");
+var import_express8, import_cors, import_express_rate_limit, import_helmet, cache, ApiServer;
+var init_server = __esm({
+  "src/api/server.ts"() {
+    import_express8 = __toESM(require("express"));
+    import_cors = __toESM(require("cors"));
+    import_express_rate_limit = __toESM(require("express-rate-limit"));
+    import_helmet = __toESM(require("helmet"));
+    cache = /* @__PURE__ */ new Map();
+    ApiServer = class {
+      constructor(config) {
+        this.config = config;
+        this.app = (0, import_express8.default)();
+        this.setupMiddleware();
+        this.setupRoutes();
+      }
+      setupMiddleware() {
+        this.app.use((0, import_helmet.default)());
+        this.app.use(import_express8.default.json());
+        if (this.config.cors.enabled) {
+          this.app.use(
+            (0, import_cors.default)({
+              origin: this.config.cors.origins || "*",
+              methods: ["GET", "POST", "PUT", "DELETE"],
+              credentials: true
+            })
+          );
+        }
+        if (this.config.rateLimit.enabled) {
+          const limiter = (0, import_express_rate_limit.default)({
+            windowMs: this.config.rateLimit.windowMs,
+            max: this.config.rateLimit.max,
+            message: {
+              status: "error",
+              error: {
+                code: "RATE_LIMIT_EXCEEDED",
+                message: "Too many requests, please try again later."
+              },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          this.app.use("/api/", limiter);
+        }
+        this.app.use("/api/", this.authMiddleware.bind(this));
+        if (this.config.cache.enabled) {
+          this.app.use("/api/", this.cacheMiddleware.bind(this));
+        }
+      }
+      authMiddleware(req, res, next) {
+        if (req.path === "/api/v1/health") {
+          return next();
+        }
+        if (this.config.auth.type === "none") {
+          return next();
+        }
+        if (this.config.auth.type === "api-key") {
+          const apiKey = req.headers["x-api-key"] || req.query.apiKey;
+          if (!apiKey || !this.config.auth.apiKeys?.includes(apiKey)) {
+            return res.status(401).json({
+              status: "error",
+              error: {
+                code: "UNAUTHORIZED",
+                message: "Invalid or missing API key"
+              },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        next();
+      }
+      cacheMiddleware(req, res, next) {
+        if (req.method !== "GET") {
+          return next();
+        }
+        const key = `${req.method}:${req.path}:${JSON.stringify(req.query)}`;
+        const cached = cache.get(key);
+        if (cached && cached.expiry > Date.now()) {
+          return res.json(cached.data);
+        }
+        const originalJson = res.json.bind(res);
+        res.json = (body) => {
+          if (res.statusCode === 200) {
+            cache.set(key, {
+              data: body,
+              expiry: Date.now() + this.config.cache.ttl * 1e3
+            });
+          }
+          return originalJson(body);
+        };
+        next();
+      }
+      setupRoutes() {
+        this.app.get("/api/v1/health", (_req, res) => {
+          res.json({
+            status: "success",
+            data: {
+              healthy: true,
+              version: require_package().version,
+              uptime: process.uptime()
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        });
+        this.app.use("/api/v1/costs", (init_costs2(), __toCommonJS(costs_exports2)).default);
+        this.app.use("/api/v1/inventory", (init_inventory6(), __toCommonJS(inventory_exports2)).default);
+        this.app.use("/api/v1/optimization", (init_optimization(), __toCommonJS(optimization_exports)).default);
+        this.app.use("/api/v1/chargeback", (init_chargeback(), __toCommonJS(chargeback_exports)).default);
+        this.app.use("/api/v1/forecast", (init_forecast(), __toCommonJS(forecast_exports)).default);
+        this.app.use("/api/v1/accounts", (init_accounts(), __toCommonJS(accounts_exports)).default);
+        this.app.use("/api/v1/reports", (init_reports2(), __toCommonJS(reports_exports2)).default);
+        this.app.use((_req, res) => {
+          res.status(404).json({
+            status: "error",
+            error: {
+              code: "NOT_FOUND",
+              message: "API endpoint not found"
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        });
+        this.app.use((err, _req, res, _next) => {
+          console.error("API Error:", err);
+          res.status(500).json({
+            status: "error",
+            error: {
+              code: "INTERNAL_ERROR",
+              message: err.message || "Internal server error"
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        });
+      }
+      async start() {
+        return new Promise((resolve2, reject) => {
+          try {
+            this.server = this.app.listen(this.config.port, this.config.host, () => {
+              console.log(
+                `\u2705 API Server running at http://${this.config.host}:${this.config.port}`
+              );
+              console.log(`\u{1F4D6} API Documentation: http://${this.config.host}:${this.config.port}/api/docs`);
+              resolve2();
+            });
+            this.server.on("error", reject);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+      async stop() {
+        return new Promise((resolve2, reject) => {
+          if (!this.server) {
+            resolve2();
+            return;
+          }
+          this.server.close((err) => {
+            if (err) {
+              reject(err);
+            } else {
+              console.log("API Server stopped");
+              resolve2();
+            }
+          });
+        });
+      }
+      getApp() {
+        return this.app;
+      }
+    };
+    __name(ApiServer, "ApiServer");
+    __name(createApiResponse, "createApiResponse");
+    __name(createErrorResponse, "createErrorResponse");
+  }
+});
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_package = __toESM(require_package());
+init_logging();
+
+// src/core/config/index.ts
+init_schema();
+init_loader();
 
 // src/core/config/discovery.ts
 var import_chalk2 = __toESM(require("chalk"));
@@ -13881,6 +14556,661 @@ function registerPluginCommands(program) {
 }
 __name(registerPluginCommands, "registerPluginCommands");
 
+// src/cli/commands/server/index.ts
+var import_chalk22 = __toESM(require("chalk"));
+var import_fs8 = require("fs");
+var import_path7 = require("path");
+var import_os7 = require("os");
+init_server();
+var CONFIG_DIR4 = (0, import_path7.join)((0, import_os7.homedir)(), ".infra-cost");
+var SERVER_CONFIG_PATH = (0, import_path7.join)(CONFIG_DIR4, "server-config.json");
+var PID_FILE2 = (0, import_path7.join)(CONFIG_DIR4, "server.pid");
+var DEFAULT_CONFIG3 = {
+  port: 3e3,
+  host: "127.0.0.1",
+  cors: {
+    enabled: true,
+    origins: ["*"]
+  },
+  auth: {
+    type: "none"
+  },
+  rateLimit: {
+    enabled: true,
+    windowMs: 6e4,
+    max: 100
+  },
+  cache: {
+    enabled: true,
+    ttl: 300
+    // 5 minutes
+  }
+};
+function loadServerConfig() {
+  if ((0, import_fs8.existsSync)(SERVER_CONFIG_PATH)) {
+    const config = JSON.parse((0, import_fs8.readFileSync)(SERVER_CONFIG_PATH, "utf-8"));
+    return { ...DEFAULT_CONFIG3, ...config };
+  }
+  return DEFAULT_CONFIG3;
+}
+__name(loadServerConfig, "loadServerConfig");
+function saveServerConfig(config) {
+  (0, import_fs8.writeFileSync)(SERVER_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+__name(saveServerConfig, "saveServerConfig");
+async function handleStart2(options) {
+  try {
+    if ((0, import_fs8.existsSync)(PID_FILE2)) {
+      const pid = parseInt((0, import_fs8.readFileSync)(PID_FILE2, "utf-8").trim(), 10);
+      try {
+        process.kill(pid, 0);
+        console.log(import_chalk22.default.yellow("\u26A0\uFE0F  Server is already running"));
+        console.log(import_chalk22.default.gray(`   PID: ${pid}`));
+        return;
+      } catch {
+        require("fs").unlinkSync(PID_FILE2);
+      }
+    }
+    const config = loadServerConfig();
+    if (options.port)
+      config.port = parseInt(options.port, 10);
+    if (options.host)
+      config.host = options.host;
+    if (options.apiKey) {
+      config.auth = {
+        type: "api-key",
+        apiKeys: [options.apiKey]
+      };
+    }
+    if (options.apiKeyRequired && !options.apiKey) {
+      console.log(import_chalk22.default.red("\u274C --api-key is required when --api-key-required is set"));
+      process.exit(1);
+    }
+    const server = new ApiServer(config);
+    if (options.daemon) {
+      console.log(import_chalk22.default.blue("Starting server in daemon mode..."));
+      const { spawn } = require("child_process");
+      const child = spawn(
+        process.argv[0],
+        [process.argv[1], "server", "start", "--port", config.port.toString(), "--host", config.host],
+        {
+          detached: true,
+          stdio: "ignore"
+        }
+      );
+      child.unref();
+      (0, import_fs8.writeFileSync)(PID_FILE2, child.pid.toString());
+      console.log(import_chalk22.default.green("\u2705 Server started in background"));
+      console.log(import_chalk22.default.gray(`   PID: ${child.pid}`));
+      console.log(import_chalk22.default.gray(`   URL: http://${config.host}:${config.port}`));
+      return;
+    }
+    await server.start();
+    (0, import_fs8.writeFileSync)(PID_FILE2, process.pid.toString());
+    console.log();
+    console.log(import_chalk22.default.bold("Server Configuration:"));
+    console.log(import_chalk22.default.gray(`  Port:         ${config.port}`));
+    console.log(import_chalk22.default.gray(`  Host:         ${config.host}`));
+    console.log(import_chalk22.default.gray(`  Auth:         ${config.auth.type}`));
+    console.log(import_chalk22.default.gray(`  Rate Limit:   ${config.rateLimit.enabled ? "enabled" : "disabled"}`));
+    console.log(import_chalk22.default.gray(`  Cache:        ${config.cache.enabled ? `${config.cache.ttl}s` : "disabled"}`));
+    console.log();
+    if (config.auth.type === "api-key") {
+      console.log(import_chalk22.default.yellow("\u26A0\uFE0F  API Key Authentication Enabled"));
+      console.log(import_chalk22.default.gray("   Use header: X-API-Key: your-api-key"));
+      console.log();
+    }
+    console.log(import_chalk22.default.green("Press Ctrl+C to stop the server"));
+    const shutdown = /* @__PURE__ */ __name(async () => {
+      console.log(import_chalk22.default.yellow("\n\nShutting down server..."));
+      await server.stop();
+      if ((0, import_fs8.existsSync)(PID_FILE2)) {
+        require("fs").unlinkSync(PID_FILE2);
+      }
+      process.exit(0);
+    }, "shutdown");
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (error) {
+    console.error(import_chalk22.default.red("\u274C Failed to start server:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleStart2, "handleStart");
+async function handleStop2() {
+  try {
+    if (!(0, import_fs8.existsSync)(PID_FILE2)) {
+      console.log(import_chalk22.default.yellow("\u26A0\uFE0F  Server is not running"));
+      return;
+    }
+    const pid = parseInt((0, import_fs8.readFileSync)(PID_FILE2, "utf-8").trim(), 10);
+    try {
+      process.kill(pid, "SIGTERM");
+      console.log(import_chalk22.default.green("\u2705 Server stopped"));
+      setTimeout(() => {
+        if ((0, import_fs8.existsSync)(PID_FILE2)) {
+          require("fs").unlinkSync(PID_FILE2);
+        }
+      }, 1e3);
+    } catch {
+      console.log(import_chalk22.default.yellow("\u26A0\uFE0F  Server process not found"));
+      if ((0, import_fs8.existsSync)(PID_FILE2)) {
+        require("fs").unlinkSync(PID_FILE2);
+      }
+    }
+  } catch (error) {
+    console.error(import_chalk22.default.red("\u274C Failed to stop server:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleStop2, "handleStop");
+async function handleStatus3() {
+  try {
+    if (!(0, import_fs8.existsSync)(PID_FILE2)) {
+      console.log(import_chalk22.default.yellow("\u26A0\uFE0F  Server is not running"));
+      return;
+    }
+    const pid = parseInt((0, import_fs8.readFileSync)(PID_FILE2, "utf-8").trim(), 10);
+    try {
+      process.kill(pid, 0);
+      const config = loadServerConfig();
+      console.log(import_chalk22.default.green("\u2705 Server is running"));
+      console.log(import_chalk22.default.gray(`   PID:  ${pid}`));
+      console.log(import_chalk22.default.gray(`   URL:  http://${config.host}:${config.port}`));
+      console.log(import_chalk22.default.gray(`   Docs: http://${config.host}:${config.port}/api/docs`));
+    } catch {
+      console.log(import_chalk22.default.yellow("\u26A0\uFE0F  Server is not running (stale PID file)"));
+      require("fs").unlinkSync(PID_FILE2);
+    }
+  } catch (error) {
+    console.error(import_chalk22.default.red("\u274C Failed to check status:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleStatus3, "handleStatus");
+async function handleConfigure2(options) {
+  try {
+    const config = loadServerConfig();
+    if (options.port)
+      config.port = parseInt(options.port, 10);
+    if (options.host)
+      config.host = options.host;
+    if (options.enableCors !== void 0)
+      config.cors.enabled = options.enableCors === "true";
+    if (options.cacheEnabled !== void 0)
+      config.cache.enabled = options.cacheEnabled === "true";
+    if (options.cacheTtl)
+      config.cache.ttl = parseInt(options.cacheTtl, 10);
+    saveServerConfig(config);
+    console.log(import_chalk22.default.green("\u2705 Server configuration updated"));
+    console.log();
+    console.log(JSON.stringify(config, null, 2));
+  } catch (error) {
+    console.error(import_chalk22.default.red("\u274C Failed to configure server:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleConfigure2, "handleConfigure");
+function registerServerCommands(program) {
+  const server = program.command("server").description("API server mode for REST API access");
+  server.command("start").description("Start the API server").option("-p, --port <port>", "Port to listen on", "3000").option("-h, --host <host>", "Host to bind to", "127.0.0.1").option("--api-key <key>", "API key for authentication").option("--api-key-required", "Require API key authentication").option("-d, --daemon", "Run in background/daemon mode").action(handleStart2);
+  server.command("stop").description("Stop the running API server").action(handleStop2);
+  server.command("status").description("Check server status").action(handleStatus3);
+  server.command("configure").description("Configure server settings").option("-p, --port <port>", "Default port").option("-h, --host <host>", "Default host").option("--enable-cors <boolean>", "Enable/disable CORS").option("--cache-enabled <boolean>", "Enable/disable caching").option("--cache-ttl <seconds>", "Cache TTL in seconds").action(handleConfigure2);
+}
+__name(registerServerCommands, "registerServerCommands");
+
+// src/cli/commands/scorecard/index.ts
+var import_chalk23 = __toESM(require("chalk"));
+var import_cli_table32 = __toESM(require("cli-table3"));
+
+// src/core/scorecard.ts
+var DEFAULT_SCORECARD_CONFIG = {
+  enabled: true,
+  categories: {
+    budgetAdherence: { weight: 25, target: 80 },
+    costEfficiency: { weight: 20, target: 0 },
+    taggingCompliance: { weight: 15, target: 90 },
+    reservedCoverage: { weight: 15, target: 70 },
+    wasteElimination: { weight: 15, target: 80 },
+    optimizationActions: { weight: 10, target: 80 }
+  },
+  gradingScale: {
+    A: 90,
+    B: 80,
+    C: 70,
+    D: 60
+  },
+  notifications: {
+    weekly: true,
+    monthlyReport: true,
+    awardBadges: true
+  }
+};
+function calculateCategoryScore(currentValue, target, weight, isInverse = false) {
+  const maxScore = weight;
+  let performance;
+  if (isInverse) {
+    performance = target === 0 ? currentValue <= 0 ? 100 : 0 : Math.max(0, 100 - currentValue / target * 100);
+  } else {
+    performance = currentValue / target * 100;
+  }
+  performance = Math.min(100, Math.max(0, performance));
+  const score = performance / 100 * maxScore;
+  let status;
+  if (performance >= 95)
+    status = "excellent";
+  else if (performance >= 80)
+    status = "good";
+  else if (performance >= 60)
+    status = "warning";
+  else
+    status = "critical";
+  return { score, status };
+}
+__name(calculateCategoryScore, "calculateCategoryScore");
+function calculateGrade(score, config) {
+  if (score >= config.gradingScale.A)
+    return "A";
+  if (score >= config.gradingScale.B)
+    return "B+";
+  if (score >= config.gradingScale.C)
+    return "C+";
+  if (score >= config.gradingScale.D)
+    return "D";
+  return "F";
+}
+__name(calculateGrade, "calculateGrade");
+function generateQuickWins2(categories) {
+  const quickWins = [];
+  categories.forEach((category) => {
+    if (category.status === "warning" || category.status === "critical") {
+      const gap = category.target - category.currentValue;
+      const potentialPoints = gap / category.target * category.maxScore;
+      if (category.name === "Reserved Coverage") {
+        quickWins.push({
+          description: `Increase RI coverage by ${gap.toFixed(0)}%`,
+          pointsGain: Math.round(potentialPoints),
+          estimatedSavings: gap * 100,
+          // Rough estimate
+          difficulty: "medium"
+        });
+      } else if (category.name === "Tagging Compliance") {
+        const missingTags = Math.round(gap / 100 * 100);
+        quickWins.push({
+          description: `Add missing tags to ~${missingTags} resources`,
+          pointsGain: Math.round(potentialPoints),
+          difficulty: "easy"
+        });
+      } else if (category.name === "Waste Elimination") {
+        quickWins.push({
+          description: `Clean up unused resources (${gap.toFixed(0)}% remaining)`,
+          pointsGain: Math.round(potentialPoints),
+          estimatedSavings: gap * 50,
+          difficulty: "easy"
+        });
+      }
+    }
+  });
+  return quickWins.sort((a, b) => b.pointsGain - a.pointsGain).slice(0, 5);
+}
+__name(generateQuickWins2, "generateQuickWins");
+function checkBadges(scorecard, historicalData) {
+  const badges = [];
+  const today = (/* @__PURE__ */ new Date()).toISOString();
+  const budgetCategory = scorecard.categories.find((c) => c.name === "Budget Adherence");
+  if (budgetCategory && budgetCategory.currentValue >= budgetCategory.target) {
+    const last3Months = historicalData.slice(-3);
+    if (last3Months.length === 3 && last3Months.every((m) => m.score >= 80)) {
+      badges.push({
+        name: "Budget Champion",
+        emoji: "\u{1F3C5}",
+        description: "Under budget for 3 consecutive months",
+        awardedDate: today
+      });
+    }
+  }
+  const taggingCategory = scorecard.categories.find((c) => c.name === "Tagging Compliance");
+  if (taggingCategory && taggingCategory.currentValue >= 100) {
+    badges.push({
+      name: "Tagging Star",
+      emoji: "\u2B50",
+      description: "100% tagging compliance",
+      awardedDate: today
+    });
+  }
+  const costCategory = scorecard.categories.find((c) => c.name === "Cost Efficiency");
+  if (costCategory && costCategory.currentValue <= -20) {
+    badges.push({
+      name: "Green Team",
+      emoji: "\u{1F331}",
+      description: "Reduced costs 20% this quarter",
+      awardedDate: today
+    });
+  }
+  if (scorecard.totalScore >= 90) {
+    const last6Months = historicalData.slice(-6);
+    if (last6Months.length === 6 && last6Months.every((m) => m.score >= 90)) {
+      badges.push({
+        name: "Efficiency Expert",
+        emoji: "\u{1F48E}",
+        description: "Score above 90 for 6 months",
+        awardedDate: today
+      });
+    }
+  }
+  return badges;
+}
+__name(checkBadges, "checkBadges");
+function buildTeamScorecard(teamName, metrics, config = DEFAULT_SCORECARD_CONFIG, historicalData = []) {
+  const categories = [];
+  const budgetTarget = config.categories.budgetAdherence.target;
+  const budgetScore = calculateCategoryScore(
+    Math.min(metrics.budgetUsage, 100),
+    budgetTarget,
+    config.categories.budgetAdherence.weight,
+    false
+  );
+  categories.push({
+    name: "Budget Adherence",
+    weight: config.categories.budgetAdherence.weight,
+    target: budgetTarget,
+    currentValue: metrics.budgetUsage,
+    score: budgetScore.score,
+    maxScore: config.categories.budgetAdherence.weight,
+    status: budgetScore.status
+  });
+  const costEffScore = calculateCategoryScore(
+    Math.abs(metrics.costTrend),
+    Math.abs(config.categories.costEfficiency.target),
+    config.categories.costEfficiency.weight,
+    true
+  );
+  categories.push({
+    name: "Cost Efficiency",
+    weight: config.categories.costEfficiency.weight,
+    target: config.categories.costEfficiency.target,
+    currentValue: metrics.costTrend,
+    score: costEffScore.score,
+    maxScore: config.categories.costEfficiency.weight,
+    status: costEffScore.status
+  });
+  const taggingScore = calculateCategoryScore(
+    metrics.taggingCompliance,
+    config.categories.taggingCompliance.target,
+    config.categories.taggingCompliance.weight
+  );
+  categories.push({
+    name: "Tagging Compliance",
+    weight: config.categories.taggingCompliance.weight,
+    target: config.categories.taggingCompliance.target,
+    currentValue: metrics.taggingCompliance,
+    score: taggingScore.score,
+    maxScore: config.categories.taggingCompliance.weight,
+    status: taggingScore.status
+  });
+  const reservedScore = calculateCategoryScore(
+    metrics.reservedCoverage,
+    config.categories.reservedCoverage.target,
+    config.categories.reservedCoverage.weight
+  );
+  categories.push({
+    name: "Reserved Coverage",
+    weight: config.categories.reservedCoverage.weight,
+    target: config.categories.reservedCoverage.target,
+    currentValue: metrics.reservedCoverage,
+    score: reservedScore.score,
+    maxScore: config.categories.reservedCoverage.weight,
+    status: reservedScore.status
+  });
+  const wasteScore = calculateCategoryScore(
+    100 - metrics.wastePercentage,
+    config.categories.wasteElimination.target,
+    config.categories.wasteElimination.weight
+  );
+  categories.push({
+    name: "Waste Elimination",
+    weight: config.categories.wasteElimination.weight,
+    target: config.categories.wasteElimination.target,
+    currentValue: 100 - metrics.wastePercentage,
+    score: wasteScore.score,
+    maxScore: config.categories.wasteElimination.weight,
+    status: wasteScore.status
+  });
+  const optActionsPercent = metrics.optimizationsActed / Math.max(metrics.totalOptimizations, 1) * 100;
+  const optScore = calculateCategoryScore(
+    optActionsPercent,
+    config.categories.optimizationActions.target,
+    config.categories.optimizationActions.weight
+  );
+  categories.push({
+    name: "Optimization Actions",
+    weight: config.categories.optimizationActions.weight,
+    target: config.categories.optimizationActions.target,
+    currentValue: optActionsPercent,
+    score: optScore.score,
+    maxScore: config.categories.optimizationActions.weight,
+    status: optScore.status
+  });
+  const totalScore = Math.round(categories.reduce((sum, cat) => sum + cat.score, 0));
+  const grade = calculateGrade(totalScore, config);
+  const lastMonthScore = historicalData.length > 0 ? historicalData[historicalData.length - 1].score : totalScore;
+  const trend = totalScore - lastMonthScore;
+  const quickWins = generateQuickWins2(categories);
+  const scorecard = {
+    teamName,
+    totalScore,
+    grade,
+    trend,
+    categories,
+    quickWins,
+    badges: [],
+    monthlyHistory: historicalData
+  };
+  scorecard.badges = checkBadges(scorecard, historicalData);
+  return scorecard;
+}
+__name(buildTeamScorecard, "buildTeamScorecard");
+function generateLeaderboard(scorecards) {
+  return scorecards.map((sc, index) => ({
+    rank: index + 1,
+    teamName: sc.teamName,
+    score: sc.totalScore,
+    grade: sc.grade,
+    trend: sc.trend,
+    savings: sc.quickWins.reduce((sum, qw) => sum + (qw.estimatedSavings || 0), 0)
+  })).sort((a, b) => b.score - a.score).map((entry, index) => ({ ...entry, rank: index + 1 }));
+}
+__name(generateLeaderboard, "generateLeaderboard");
+
+// src/cli/commands/scorecard/index.ts
+function getMockTeamMetrics(teamName) {
+  const teams = {
+    "Backend Engineering": {
+      budgetUsage: 85,
+      costTrend: -5,
+      taggingCompliance: 92,
+      reservedCoverage: 65,
+      wastePercentage: 22,
+      optimizationsActed: 4,
+      totalOptimizations: 5
+    },
+    "Platform Team": {
+      budgetUsage: 75,
+      costTrend: -8,
+      taggingCompliance: 98,
+      reservedCoverage: 85,
+      wastePercentage: 8,
+      optimizationsActed: 5,
+      totalOptimizations: 5
+    },
+    "Data Engineering": {
+      budgetUsage: 82,
+      costTrend: -3,
+      taggingCompliance: 90,
+      reservedCoverage: 70,
+      wastePercentage: 15,
+      optimizationsActed: 4,
+      totalOptimizations: 5
+    },
+    "Frontend Team": {
+      budgetUsage: 88,
+      costTrend: 2,
+      taggingCompliance: 85,
+      reservedCoverage: 60,
+      wastePercentage: 25,
+      optimizationsActed: 3,
+      totalOptimizations: 5
+    },
+    "ML Team": {
+      budgetUsage: 95,
+      costTrend: 5,
+      taggingCompliance: 78,
+      reservedCoverage: 55,
+      wastePercentage: 30,
+      optimizationsActed: 2,
+      totalOptimizations: 5
+    }
+  };
+  return teams[teamName] || teams["Backend Engineering"];
+}
+__name(getMockTeamMetrics, "getMockTeamMetrics");
+function getStatusEmoji(status) {
+  switch (status) {
+    case "excellent":
+      return "\u2705";
+    case "good":
+      return "\u2705";
+    case "warning":
+      return "\u26A0\uFE0F";
+    case "critical":
+      return "\u274C";
+    default:
+      return "\u2022";
+  }
+}
+__name(getStatusEmoji, "getStatusEmoji");
+function formatTrendArrow(trend) {
+  if (trend > 0)
+    return import_chalk23.default.green(`\u2B06\uFE0F +${trend}`);
+  if (trend < 0)
+    return import_chalk23.default.red(`\u2B07\uFE0F ${trend}`);
+  return import_chalk23.default.gray("\u2192 0");
+}
+__name(formatTrendArrow, "formatTrendArrow");
+async function handleScorecard(options) {
+  try {
+    const teamName = options.team || "Backend Engineering";
+    const metrics = getMockTeamMetrics(teamName);
+    const historicalData = [
+      { month: "July 2025", score: 77, grade: "B" },
+      { month: "August 2025", score: 79, grade: "B" },
+      { month: "September 2025", score: 80, grade: "B+" }
+    ];
+    const scorecard = buildTeamScorecard(teamName, metrics, DEFAULT_SCORECARD_CONFIG, historicalData);
+    console.log();
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(70)));
+    console.log(import_chalk23.default.bold.white(`           \u{1F3C6} FinOps Scorecard - ${(/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { month: "long", year: "numeric" })}`));
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(70)));
+    console.log();
+    console.log(import_chalk23.default.bold.white(`Team: ${scorecard.teamName}`));
+    console.log(
+      import_chalk23.default.bold.cyan(
+        `Score: ${scorecard.totalScore}/100 (Grade: ${scorecard.grade}) ${formatTrendArrow(scorecard.trend)} from last month`
+      )
+    );
+    console.log(import_chalk23.default.gray("\u2500".repeat(70)));
+    console.log();
+    console.log(import_chalk23.default.bold("\u{1F4CA} Metrics:"));
+    scorecard.categories.forEach((category) => {
+      const emoji = getStatusEmoji(category.status);
+      const percentage = (category.score / category.maxScore * 100).toFixed(0);
+      const value = category.name === "Cost Efficiency" ? `${category.currentValue >= 0 ? "+" : ""}${category.currentValue}%` : category.name === "Optimization Actions" ? `${Math.round(category.currentValue)}%` : `${category.currentValue.toFixed(0)}%`;
+      console.log(
+        `\u251C\u2500\u2500 ${import_chalk23.default.white(category.name.padEnd(22))} ${value.padEnd(8)} ${emoji}  (target: ${category.target}${category.name.includes("Efficiency") || category.name.includes("Actions") ? "%" : "%"})  [${Math.round(category.score)}/${category.maxScore} pts]`
+      );
+    });
+    console.log();
+    if (scorecard.quickWins.length > 0) {
+      console.log(import_chalk23.default.bold("\u{1F3AF} Quick Wins to Improve Score:"));
+      scorecard.quickWins.forEach((qw) => {
+        const savingsText = qw.estimatedSavings ? import_chalk23.default.green(` (save ~$${qw.estimatedSavings.toFixed(0)})`) : "";
+        console.log(`\u2022 ${qw.description} \u2192 +${qw.pointsGain} points${savingsText}`);
+      });
+      console.log();
+    }
+    if (scorecard.badges.length > 0) {
+      console.log(import_chalk23.default.bold("\u{1F3C5} Badges Earned:"));
+      scorecard.badges.forEach((badge) => {
+        console.log(`${badge.emoji} ${import_chalk23.default.yellow(badge.name)} - ${import_chalk23.default.gray(badge.description)}`);
+      });
+      console.log();
+    }
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(70)));
+  } catch (error) {
+    console.error(import_chalk23.default.red("\u274C Failed to generate scorecard:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleScorecard, "handleScorecard");
+async function handleLeaderboard() {
+  try {
+    const teamNames = ["Platform Team", "Data Engineering", "Backend Engineering", "Frontend Team", "ML Team"];
+    const scorecards = teamNames.map((name) => {
+      const metrics = getMockTeamMetrics(name);
+      return buildTeamScorecard(name, metrics);
+    });
+    const leaderboard = generateLeaderboard(scorecards);
+    console.log();
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log(import_chalk23.default.bold.white(`           \u{1F3C6} FinOps Leaderboard - ${(/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { month: "long", year: "numeric" })}`));
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log();
+    const table = new import_cli_table32.default({
+      head: [
+        import_chalk23.default.bold("Rank"),
+        import_chalk23.default.bold("Team"),
+        import_chalk23.default.bold("Score"),
+        import_chalk23.default.bold("Grade"),
+        import_chalk23.default.bold("Trend"),
+        import_chalk23.default.bold("Savings")
+      ],
+      colWidths: [8, 25, 10, 10, 12, 15]
+    });
+    leaderboard.forEach((entry) => {
+      const rankEmoji = entry.rank === 1 ? "\u{1F947}" : entry.rank === 2 ? "\u{1F948}" : entry.rank === 3 ? "\u{1F949}" : `  ${entry.rank}`;
+      table.push([
+        rankEmoji,
+        entry.teamName,
+        entry.score.toString(),
+        entry.grade,
+        formatTrendArrow(entry.trend),
+        import_chalk23.default.green(`$${entry.savings.toLocaleString()}`)
+      ]);
+    });
+    console.log(table.toString());
+    console.log();
+    const mostImproved = leaderboard.reduce((max, entry) => entry.trend > max.trend ? entry : max, leaderboard[0]);
+    const biggestSaver = leaderboard.reduce((max, entry) => entry.savings > max.savings ? entry : max, leaderboard[0]);
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log(import_chalk23.default.yellow(`\u{1F396}\uFE0F  Most Improved: ${mostImproved.teamName} (${formatTrendArrow(mostImproved.trend)} points)`));
+    console.log(import_chalk23.default.green(`\u{1F4B0} Biggest Saver: ${biggestSaver.teamName} ($${biggestSaver.savings.toLocaleString()})`));
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log();
+  } catch (error) {
+    console.error(import_chalk23.default.red("\u274C Failed to generate leaderboard:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleLeaderboard, "handleLeaderboard");
+function registerScorecardCommand(program) {
+  const scorecard = program.command("scorecard").description("FinOps team performance scorecards and leaderboards");
+  scorecard.command("show").description("Show team scorecard").option("-t, --team <name>", "Team name", "Backend Engineering").action(handleScorecard);
+  scorecard.command("leaderboard").description("Show organization leaderboard").action(handleLeaderboard);
+  scorecard.action(handleScorecard);
+}
+__name(registerScorecardCommand, "registerScorecardCommand");
+
 // src/cli/middleware/auth.ts
 async function authMiddleware(thisCommand, actionCommand) {
   const isConfigCommand = actionCommand.name() === "config" || actionCommand.parent?.name() === "config";
@@ -13909,7 +15239,7 @@ async function validationMiddleware(thisCommand, actionCommand) {
 __name(validationMiddleware, "validationMiddleware");
 
 // src/cli/middleware/error-handler.ts
-var import_chalk22 = __toESM(require("chalk"));
+var import_chalk24 = __toESM(require("chalk"));
 function errorHandler(error) {
   const message = error?.message ?? String(error);
   const stack = error?.stack;
@@ -13917,15 +15247,15 @@ function errorHandler(error) {
     return;
   }
   console.error("");
-  console.error(import_chalk22.default.red("\u2716"), import_chalk22.default.bold("Error:"), message);
+  console.error(import_chalk24.default.red("\u2716"), import_chalk24.default.bold("Error:"), message);
   if (process.env.DEBUG || process.env.VERBOSE) {
     console.error("");
     if (stack) {
-      console.error(import_chalk22.default.gray(stack));
+      console.error(import_chalk24.default.gray(stack));
     }
   } else {
     console.error("");
-    console.error(import_chalk22.default.gray("Run with --verbose for detailed error information"));
+    console.error(import_chalk24.default.gray("Run with --verbose for detailed error information"));
   }
   console.error("");
 }
@@ -13935,7 +15265,7 @@ __name(errorHandler, "errorHandler");
 function createCLI() {
   const program = new import_commander.Command();
   program.exitOverride();
-  program.name("infra-cost").description(package_default.description).version(package_default.version);
+  program.name("infra-cost").description(import_package.default.description).version(import_package.default.version);
   program.option("--provider <provider>", "Cloud provider (aws, gcp, azure, alibaba, oracle)", "aws").option("-p, --profile <profile>", "Cloud provider profile", "default").option("-r, --region <region>", "Cloud provider region", "us-east-1").option("-k, --access-key <key>", "Access key for cloud provider").option("-s, --secret-key <key>", "Secret key for cloud provider").option("-T, --session-token <token>", "Session token").option("--project-id <id>", "GCP Project ID").option("--key-file <path>", "Path to service account key file (GCP/Oracle)").option("--subscription-id <id>", "Azure Subscription ID").option("--tenant-id <id>", "Azure Tenant ID").option("--client-id <id>", "Azure Client ID").option("--client-secret <secret>", "Azure Client Secret").option("--user-id <id>", "Oracle User OCID").option("--tenancy-id <id>", "Oracle Tenancy OCID").option("--fingerprint <fp>", "Oracle Public Key Fingerprint").option("--config-file <path>", "Path to configuration file").option("--config-profile <name>", "Use named profile from config").option("--output <format>", "Output format (json, text, fancy, table)", "fancy").option("--no-color", "Disable colored output").option("--quiet", "Quiet mode - minimal output").option("--verbose", "Verbose output with debug information").option("--no-cache", "Disable caching").option("--cache-ttl <duration>", "Cache TTL (e.g., 4h, 30m)", "4h").option("--log-level <level>", "Logging level (debug, info, warn, error)", "info").option("--log-format <format>", "Log format (pretty, json)", "pretty");
   registerNowCommand(program);
   registerFreeTierCommand(program);
@@ -13954,6 +15284,8 @@ function createCLI() {
   registerRBACCommands(program);
   registerSSOCommands(program);
   registerPluginCommands(program);
+  registerServerCommands(program);
+  registerScorecardCommand(program);
   program.hook("preAction", async (thisCommand, actionCommand) => {
     const opts = thisCommand.opts();
     const logLevel = opts.verbose ? "debug" : opts.quiet ? "error" : opts.logLevel;