@mayank3238/keymux 1.0.0

package/dist/cli.cjs

@@ -0,0 +1,870 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs2 = require('fs');
+var path2 = require('path');
+var os = require('os');
+var chalk = require('chalk');
+var http = require('http');
+var child_process = require('child_process');
+var net = require('net');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+var net__namespace = /*#__PURE__*/_interopNamespace(net);
+
+// keymux v1.0.0 — Smart API Key Multiplexer for LLM Providers
+
+var configPath = path2__namespace.join(os__namespace.homedir(), ".keymux", "config.json");
+var config = readConfig();
+var draftConfig = JSON.parse(JSON.stringify(config));
+var flashMessage = "";
+function readConfig() {
+  try {
+    if (fs2__namespace.existsSync(configPath)) {
+      const parsed = JSON.parse(fs2__namespace.readFileSync(configPath, "utf8"));
+      if (parsed && typeof parsed === "object") {
+        if (!parsed.keys) parsed.keys = { openrouter: [], nvidia: [], mistral: [], gemini: [], groq: [] };
+        return parsed;
+      }
+    }
+  } catch (e) {
+  }
+  return { defaultProvider: null, defaultModel: "", keys: { openrouter: [], nvidia: [], mistral: [], gemini: [], groq: [] } };
+}
+function saveConfig(cfg) {
+  try {
+    fs2__namespace.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+  } catch (e) {
+  }
+}
+var proxyPort = process.argv.includes("--port") ? parseInt(process.argv[process.argv.indexOf("--port") + 1] || "3002", 10) : 3002;
+async function triggerReload() {
+  return new Promise((resolve) => {
+    const req = http__namespace.request({
+      hostname: "localhost",
+      port: proxyPort,
+      path: "/v1/keymux/reload",
+      method: "POST"
+    }, (res) => {
+      resolve(true);
+    });
+    req.on("error", () => {
+      resolve(false);
+    });
+    req.end();
+  });
+}
+function readUsageData() {
+  const usagePath = path2__namespace.join(os__namespace.homedir(), ".keymux", "usage.json");
+  try {
+    if (fs2__namespace.existsSync(usagePath)) {
+      const parsed = JSON.parse(fs2__namespace.readFileSync(usagePath, "utf8"));
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    }
+  } catch (e) {
+  }
+  return { totalInputTokens: 0, totalOutputTokens: 0, totalCacheTokens: 0, providerUsage: {}, daily: {}, sessions: 0 };
+}
+function formatTokens(num) {
+  if (num > 1e6) return (num / 1e6).toFixed(1) + "m";
+  if (num > 1e3) return (num / 1e3).toFixed(1) + "k";
+  return num.toString();
+}
+var TABS = ["Status", "Usage", "Stats", "Settings"];
+var currentTabIdx = 0;
+var settingsSelectionIdx = 0;
+var expandedProviders = [];
+var currentTreeItems = [];
+var usageViewMode = "today";
+var settingsView = "main";
+var isInputMode = false;
+var inputTarget = "";
+var inputBuffer = "";
+var isListening = false;
+var orange = chalk__default.default.hex("#e27d60");
+var lightBlue = chalk__default.default.hex("#8b9df2");
+var gray = chalk__default.default.hex("#808080");
+var highlight = chalk__default.default.bgHex("#8b9df2").black;
+var whiteHighlight = chalk__default.default.bgWhite.black;
+function renderTabs() {
+  let out = "";
+  for (let i = 0; i < TABS.length; i++) {
+    if (i === currentTabIdx) {
+      out += highlight(` ${TABS[i]} `) + "  ";
+    } else {
+      out += lightBlue(TABS[i]) + "  ";
+    }
+  }
+  console.log(out + "");
+}
+async function renderStats() {
+  console.log("\n" + whiteHighlight(" Overview "));
+  console.log(chalk__default.default.gray.italic("  (Showing all-time cumulative history and lifetime session metrics)\n"));
+  const data = readUsageData();
+  let favProvider = "None";
+  let maxUsage = 0;
+  for (const [prov, count] of Object.entries(data.providerUsage || {})) {
+    if (count > maxUsage) {
+      maxUsage = count;
+      favProvider = prov;
+    }
+  }
+  const totalTokens = (data.totalInputTokens || 0) + (data.totalOutputTokens || 0);
+  const formattedTotal = formatTokens(totalTokens);
+  const inTokensStr = formatTokens(data.totalInputTokens || 0);
+  const outTokensStr = formatTokens(data.totalOutputTokens || 0);
+  const cacheTokensStr = formatTokens(data.totalCacheTokens || 0);
+  const sessions = data.sessions || 1;
+  const dailyDates = Object.keys(data.daily || {}).sort();
+  const activeDays = dailyDates.length;
+  let mostActiveDay = "None";
+  let maxDailyTokens = 0;
+  for (const date of dailyDates) {
+    const dayData = data.daily[date];
+    const dayTokens = (dayData.inputTokens || 0) + (dayData.outputTokens || 0);
+    if (dayTokens > maxDailyTokens) {
+      maxDailyTokens = dayTokens;
+      mostActiveDay = date;
+    }
+  }
+  let currentStreak = 0;
+  if (activeDays > 0) {
+    const today2 = /* @__PURE__ */ new Date();
+    for (let i = 0; i < 365; i++) {
+      const checkDate = new Date(today2);
+      checkDate.setDate(today2.getDate() - i);
+      const dateStr = checkDate.toISOString().split("T")[0];
+      if (data.daily && data.daily[dateStr]) {
+        currentStreak++;
+      } else if (i > 0) {
+        break;
+      }
+    }
+  }
+  const numWeeks = 52;
+  const blocks = [gray("\xB7"), orange("\u2591"), orange("\u2592"), orange("\u2593"), orange("\u2588")];
+  const grid = Array.from({ length: 7 }, () => Array(numWeeks).fill(" "));
+  const today = /* @__PURE__ */ new Date();
+  const todayDayOfWeek = today.getDay();
+  for (let col = 0; col < numWeeks; col++) {
+    for (let row = 0; row < 7; row++) {
+      const weeksAgo = numWeeks - 1 - col;
+      const daysAgo = weeksAgo * 7 + (todayDayOfWeek - row);
+      if (daysAgo < 0 || daysAgo > 364) {
+        if (grid[row] && typeof col === "number") grid[row][col] = " ";
+      } else {
+        const d = /* @__PURE__ */ new Date();
+        d.setDate(today.getDate() - daysAgo);
+        const dateStr = d.toISOString().split("T")[0];
+        const dayData = data.daily && data.daily[dateStr] ? data.daily[dateStr] : null;
+        if (!dayData) {
+          if (grid[row] && typeof col === "number") grid[row][col] = blocks[0];
+        } else {
+          const tokens = (dayData.inputTokens || 0) + (dayData.outputTokens || 0);
+          let b = 1;
+          if (tokens > 1e4) b = 2;
+          if (tokens > 5e4) b = 3;
+          if (tokens > 1e5) b = 4;
+          if (grid[row] && typeof col === "number") grid[row][col] = blocks[b];
+        }
+      }
+    }
+  }
+  console.log("    Sep Oct Nov Dec Jan Feb Mar Apr May Jun Jul Aug");
+  const rowLabels = ["   ", "Mon", "   ", "Wed", "   ", "Fri", "   "];
+  for (let row = 0; row < 7; row++) {
+    process.stdout.write(rowLabels[row] + " ");
+    for (let col = 0; col < numWeeks; col++) {
+      process.stdout.write(grid[row] && grid[row][col] ? grid[row][col] : " ");
+    }
+    console.log();
+  }
+  console.log("    Less " + blocks.join("") + " More");
+  console.log(orange("All time") + gray(" \xB7 Last 7 days \xB7 Last 30 days") + "");
+  console.log(`Favorite provider: ${orange(favProvider.padEnd(16))}Total tokens: ${orange(formattedTotal)}`);
+  console.log(`Sessions: ${orange(sessions.toString().padEnd(25))}Active days: ${orange(activeDays.toString())}`);
+  console.log(`Most active day: ${orange(mostActiveDay.padEnd(17))}Current streak: ${orange(currentStreak + " days")}`);
+  console.log();
+  console.log(gray(`Input ${inTokensStr} \xB7 Output ${outTokensStr} \xB7 Cache read ${cacheTokensStr}`));
+  console.log();
+  console.log();
+  console.log(gray("\u2193 stats \xB7 r to refresh"));
+}
+async function renderStatus() {
+  console.log("\n\n  STATUS");
+  let activeMode = "auto";
+  let activeModel = "none";
+  let currentProvider = "auto";
+  try {
+    const amRes = await fetch(`http://localhost:${proxyPort}/v1/keymux/activeModel`);
+    if (amRes.ok) {
+      const am = await amRes.json();
+      activeMode = am.mode === "STRICT" ? "strict" : "auto";
+      activeModel = am.model === "auto" ? "auto (best available)" : am.model;
+      currentProvider = am.provider === "auto" ? "auto" : am.provider.toLowerCase();
+    }
+  } catch (e) {
+  }
+  let activeKey = "";
+  let lastUsedModel = "none";
+  let lastUsedProvider = "none";
+  try {
+    const lrRes = await fetch(`http://localhost:${proxyPort}/v1/keymux/lastRoute`);
+    if (lrRes.ok) {
+      const lr = await lrRes.json();
+      if (lr && lr.provider) {
+        activeKey = lr.key || "";
+        lastUsedModel = lr.model || "none";
+        lastUsedProvider = lr.provider || "none";
+      }
+    }
+  } catch (e) {
+  }
+  const leftColWidth = 35;
+  const printRow = (label, value) => {
+    console.log(`  ${chalk__default.default.white(label.padEnd(leftColWidth))} ${chalk__default.default.white(value)}`);
+  };
+  let maskedActiveKey = "none";
+  if (activeKey) {
+    maskedActiveKey = activeKey.length > 10 ? `${activeKey.substring(0, 4)}...${activeKey.slice(-4)}` : activeKey;
+  }
+  let displayModel = activeModel;
+  let displayProvider = currentProvider;
+  if (activeMode === "auto") {
+    if (lastUsedModel && lastUsedModel !== "none") {
+      displayModel = `auto (last: ${lastUsedModel})`;
+    }
+    if (lastUsedProvider && lastUsedProvider !== "none") {
+      displayProvider = `auto (last: ${lastUsedProvider})`;
+    }
+  }
+  printRow("Active mode", activeMode);
+  printRow("Active model", displayModel);
+  printRow("Current provider", displayProvider);
+  printRow("Last used key", maskedActiveKey);
+  console.log("\n  CONNECTIONS (Real-time health, RPM limits, latency)");
+  console.log("  " + "\u2500".repeat(60));
+  try {
+    const res = await fetch(`http://localhost:${proxyPort}/v1/keymux/stats`);
+    if (res.ok) {
+      const stats = await res.json();
+      if (stats.length === 0) {
+        console.log(chalk__default.default.dim("  No active keys found."));
+      }
+      for (const ep of stats) {
+        let providerName = ep.id?.split("-")[0] || "unk";
+        if (providerName.toLowerCase() === "openrouter") providerName = "OpenRouter";
+        else if (providerName.toLowerCase() === "nvidia") providerName = "Nvidia NIM";
+        else if (providerName.toLowerCase() === "mistral") providerName = "Mistral AI";
+        else if (providerName.toLowerCase() === "gemini") providerName = "Google Gemini";
+        else if (providerName.toLowerCase() === "groq") providerName = "Groq";
+        else providerName = providerName.charAt(0).toUpperCase() + providerName.slice(1);
+        let kStr = ep.key || "unk";
+        if (kStr.length > 10) {
+          kStr = kStr.substring(0, 4) + "..." + kStr.slice(-4);
+        }
+        const isH = ep.isHealthy;
+        const cooldownS = ep.cooldownRemainingMs ? Math.ceil(ep.cooldownRemainingMs / 1e3) : 0;
+        let healthStr = "";
+        if (!isH && (ep.circuitState === "open" || cooldownS > 0)) {
+          healthStr = chalk__default.default.red(`BLOCKED   ${cooldownS}s cdn`.padEnd(19));
+        } else if (!isH) {
+          healthStr = chalk__default.default.red("BLOCKED            ".padEnd(19));
+        } else {
+          healthStr = chalk__default.default.green("ACTIVE             ".padEnd(19));
+        }
+        const rpm = ep.rpm || 0;
+        const lim = ep.rpmLimit;
+        let rStr = lim && lim > 0 ? `${rpm} rpm` : `${rpm} rpm`;
+        rStr = rStr.padEnd(16);
+        const lat = ep.latency || ep.avgLatencyMs || 0;
+        let lStr = !isH && (ep.circuitState === "open" || cooldownS > 0) ? "---" : lat >= 6e4 ? `${(lat / 6e4).toFixed(1)}m` : lat >= 1e3 ? `${(lat / 1e3).toFixed(1)}s` : `${lat}ms`;
+        if (lStr === "---") {
+          lStr = chalk__default.default.gray("---");
+        } else {
+          lStr = chalk__default.default.white(lStr);
+        }
+        console.log(`  ${chalk__default.default.white(providerName.padEnd(15))}${chalk__default.default.white(kStr.padEnd(16))}${healthStr}${chalk__default.default.white(rStr)}${lStr}`);
+      }
+    } else {
+      console.log(chalk__default.default.dim("  Proxy returned an error."));
+    }
+  } catch (e) {
+    console.log(chalk__default.default.dim("  Proxy offline or unreachable."));
+  }
+}
+function renderSettings() {
+  const isUnsaved = JSON.stringify(draftConfig) !== JSON.stringify(config);
+  const unsavedTag = isUnsaved ? chalk__default.default.yellow(" (Unsaved Changes - Press S to Save)") : "";
+  if (flashMessage) {
+    console.log(chalk__default.default.green(`  \u2714 ${flashMessage}`));
+    flashMessage = "";
+  }
+  currentTreeItems = [];
+  let index = 0;
+  const leftColWidth = 35;
+  const renderRow = (label, value, isSelected) => {
+    const bg = isSelected ? chalk__default.default.bgHex("#333333").white : chalk__default.default.white;
+    const padding = Math.max(0, leftColWidth - label.length);
+    console.log(bg(`  ${label}${" ".repeat(padding)} ${value}`.padEnd(80)));
+  };
+  if (settingsView === "main") {
+    console.log("\n\n  SETTINGS" + unsavedTag);
+    console.log("  " + "\u2500".repeat(60));
+    currentTreeItems.push({ type: "main_mode", index: index++ });
+    const isAuto = !draftConfig.strictMode;
+    renderRow("Routing mode", isAuto ? "auto" : "strict", index - 1 === settingsSelectionIdx);
+    currentTreeItems.push({ type: "main_model", index: index++ });
+    renderRow("Active model", isAuto ? chalk__default.default.gray("auto") : draftConfig.defaultModel || "none", index - 1 === settingsSelectionIdx);
+    currentTreeItems.push({ type: "main_keys", index: index++ });
+    const totalKeys = Object.values(draftConfig.keys || {}).reduce((acc, arr) => acc + arr.length, 0);
+    renderRow("API keys", `${totalKeys} active keys`, index - 1 === settingsSelectionIdx);
+    console.log("\n\n  " + chalk__default.default.gray("Enter to toggle/select \xB7 S to save \xB7 X to discard"));
+  } else if (settingsView === "models") {
+    console.log("\n\n  SELECT ACTIVE MODEL");
+    console.log("  " + "\u2500".repeat(110));
+    const modelList = [
+      { provider: "openrouter", id: "inclusionai/ling-3.0-flash-vl:free", capa: "Vision \u2022 Free tier \u2022 Multimodal logic & QA" },
+      { provider: "groq", id: "qwen/qwen3.8-27b", capa: "Vision tower \u2022 Ultra fast LPU \u2022 Native reasoning tags" },
+      { provider: "groq", id: "openai/gpt-oss-120b", capa: "120B \u2022 Reasoning traces \u2022 Structured output \u2022 Tool use" },
+      { provider: "groq", id: "groq/compound", capa: "Multi-tool agent \u2022 Integrated web search & code execution" },
+      { provider: "nvidia", id: "nvidia/nemotron-3-super-120b-a12b", capa: "120B MoE \u2022 High volume agentic reasoning traces" },
+      { provider: "nvidia", id: "nvidia/nemotron-3-ultra-550b-a55b", capa: "550B MoE \u2022 Massive enterprise IT & logic solver" },
+      { provider: "gemini", id: "gemini-3.5-flash-lite", capa: "Multimodal \u2022 1M context \u2022 Low cost document parser" },
+      { provider: "mistral", id: "devstral-latest", capa: "Discontinued \u2022 Software engineering agentic workflow specialist" },
+      { provider: "mistral", id: "codestral-2508", capa: "256K context \u2022 Pure fill-in-the-middle code completion" }
+    ];
+    for (const m of modelList) {
+      currentTreeItems.push({ type: "model", provider: m.provider, id: m.id, index: index++ });
+      const isSelected = index - 1 === settingsSelectionIdx;
+      const isSaved = draftConfig.defaultModel === m.id;
+      const hasKeys = draftConfig.keys && draftConfig.keys[m.provider] && draftConfig.keys[m.provider].length > 0;
+      const modelStr = m.id.padEnd(leftColWidth);
+      const provStr = m.provider.padEnd(10);
+      const keyWarning = hasKeys ? "" : chalk__default.default.red(" \u26A0\uFE0F NO KEYS ");
+      const capaStr = chalk__default.default.gray(`${m.capa}`);
+      let line = "";
+      if (isSelected) {
+        line = chalk__default.default.bgHex("#333333").white(`  ${modelStr} `) + chalk__default.default.bgHex("#333333").gray(`${provStr}`) + (hasKeys ? "" : chalk__default.default.bgHex("#333333").red(" \u26A0\uFE0F NO KEYS ")) + chalk__default.default.bgHex("#333333").gray(`${m.capa}`);
+        console.log(chalk__default.default.bgHex("#333333")(line.padEnd(120)));
+      } else {
+        const idCol = isSaved ? chalk__default.default.blue(`  ${modelStr} `) : chalk__default.default.bold.white(`  ${modelStr} `);
+        console.log(`${idCol}${chalk__default.default.gray(provStr)}${keyWarning}${capaStr}`);
+      }
+    }
+    console.log("\n\n  " + chalk__default.default.gray("Enter to select \xB7 Esc to return"));
+  } else if (settingsView === "keys") {
+    console.log("\n\n  API SECRETS");
+    console.log("  " + "\u2500".repeat(60));
+    const providers = ["openrouter", "nvidia", "mistral", "gemini", "groq"];
+    const capitalize = (s) => {
+      if (s === "openrouter") return "OpenRouter";
+      if (s === "nvidia") return "Nvidia NIM";
+      if (s === "mistral") return "Mistral AI";
+      if (s === "gemini") return "Google Gemini";
+      if (s === "groq") return "Groq";
+      return s;
+    };
+    const maskKey = (k) => k.length > 8 ? k.substring(0, 4) + "..." + k.slice(-4) : "***";
+    for (const p of providers) {
+      const keys = draftConfig.keys?.[p] || [];
+      currentTreeItems.push({ type: "secret_provider", provider: p, index: index++ });
+      const isSelected = index - 1 === settingsSelectionIdx;
+      renderRow(capitalize(p), `${keys.length} active keys`, isSelected);
+      if (expandedProviders.includes(p)) {
+        for (const key of keys) {
+          currentTreeItems.push({ type: "key", provider: p, keyString: key, index: index++ });
+          const keySelected = index - 1 === settingsSelectionIdx;
+          const bg = keySelected ? chalk__default.default.bgHex("#333333").gray : chalk__default.default.gray;
+          console.log(bg(`    \u21B3 ${maskKey(key)}${keySelected ? chalk__default.default.red(" (Press D to delete)") : ""}`.padEnd(80)));
+        }
+        currentTreeItems.push({ type: "add", provider: p, index: index++ });
+        const addSelected = index - 1 === settingsSelectionIdx;
+        if (isInputMode && inputTarget === p) {
+          console.log(`    \u21B3 ${chalk__default.default.cyan("Enter new key:")} ` + chalk__default.default.bgCyan.black(` ${inputBuffer}_ `));
+        } else {
+          const bg = addSelected ? chalk__default.default.bgHex("#333333").gray : chalk__default.default.gray;
+          console.log(bg(`    \u21B3 [ Press Enter to Add ]`.padEnd(80)));
+        }
+      }
+    }
+    console.log("\n\n  " + chalk__default.default.gray("Enter to add/toggle \xB7 D to delete key \xB7 Esc to return \xB7 S to save"));
+  }
+}
+function formatCompact(num) {
+  if (num >= 1e6) return (num / 1e6).toFixed(1).replace(/\.0$/, "") + "M";
+  if (num >= 1e3) return (num / 1e3).toFixed(1).replace(/\.0$/, "") + "K";
+  return num.toString();
+}
+async function renderUsage() {
+  console.log("\n\n  USAGE & ANALYTICS");
+  let usageData = { providerUsage: {} };
+  try {
+    const res = await fetch(`http://localhost:${proxyPort}/v1/keymux/usage`);
+    if (res.ok) {
+      usageData = await res.json();
+    } else {
+      usageData = { providerUsage: readUsageData().providerUsage };
+    }
+  } catch (e) {
+    usageData = { providerUsage: readUsageData().providerUsage };
+  }
+  let liveStats = [];
+  let activeKey = "";
+  try {
+    const res = await fetch(`http://localhost:${proxyPort}/v1/keymux/stats`);
+    if (res.ok) {
+      liveStats = await res.json();
+    }
+    const lrRes = await fetch(`http://localhost:${proxyPort}/v1/keymux/lastRoute`);
+    if (lrRes.ok) {
+      const lr = await lrRes.json();
+      if (lr && lr.provider) activeKey = lr.key || "";
+    }
+  } catch (e) {
+  }
+  console.log(chalk__default.default.dim(`  [ ${usageViewMode === "today" ? "Last 24 Hours (Today)" : "Current Session"} ]   (Press Enter to toggle)
+`));
+  const getTokens = (usage) => typeof usage === "number" ? 0 : usage?.tokens || 0;
+  const getReqs = (usage) => typeof usage === "number" ? usage : usage?.requests || 0;
+  const currentUsageData = usageViewMode === "today" ? usageData.today || usageData.providerUsage : usageData.session || usageData.providerUsage;
+  const orUsage = currentUsageData?.openrouter;
+  const nvUsage = currentUsageData?.nvidia;
+  const miUsage = currentUsageData?.mistral;
+  const geUsage = currentUsageData?.gemini;
+  const gqUsage = currentUsageData?.groq;
+  const orTokens = getTokens(orUsage);
+  const nvTokens = getTokens(nvUsage);
+  const miTokens = getTokens(miUsage);
+  const geTokens = getTokens(geUsage);
+  const gqTokens = getTokens(gqUsage);
+  const totalTokens = orTokens + nvTokens + miTokens + geTokens + gqTokens;
+  const orPct = totalTokens > 0 ? Math.round(orTokens / totalTokens * 100) : 0;
+  const nvPct = totalTokens > 0 ? Math.round(nvTokens / totalTokens * 100) : 0;
+  const miPct = totalTokens > 0 ? Math.round(miTokens / totalTokens * 100) : 0;
+  const gePct = totalTokens > 0 ? Math.round(geTokens / totalTokens * 100) : 0;
+  const gqPct = totalTokens > 0 ? Math.round(gqTokens / totalTokens * 100) : 0;
+  const leftColWidth = 35;
+  console.log("  PROVIDER DISTRIBUTION (TOKENS)");
+  console.log("  " + "\u2500".repeat(60));
+  const printRow = (label, value) => {
+    console.log(`  ${chalk__default.default.white(label.padEnd(leftColWidth))} ${chalk__default.default.white(value)}`);
+  };
+  printRow("OpenRouter", `${formatCompact(orTokens)} Tokens (${orPct}%)`);
+  printRow("Nvidia NIM", `${formatCompact(nvTokens)} Tokens (${nvPct}%)`);
+  if (miTokens > 0 || getReqs(miUsage) > 0 || draftConfig.keys?.mistral?.length) {
+    printRow("Mistral AI", `${formatCompact(miTokens)} Tokens (${miPct}%)`);
+  }
+  if (geTokens > 0 || getReqs(geUsage) > 0 || draftConfig.keys?.gemini?.length) {
+    printRow("Google Gemini", `${formatCompact(geTokens)} Tokens (${gePct}%)`);
+  }
+  if (gqTokens > 0 || getReqs(gqUsage) > 0 || draftConfig.keys?.groq?.length) {
+    printRow("Groq", `${formatCompact(gqTokens)} Tokens (${gqPct}%)`);
+  }
+  console.log("\n  TRAFFIC ROUTING (REQUESTS)");
+  console.log("  " + "\u2500".repeat(60));
+  if (liveStats.length === 0) {
+    console.log(chalk__default.default.dim("  No active keys found."));
+  } else {
+    for (const stat of liveStats) {
+      const keyStr = stat.key || "";
+      let masked = keyStr;
+      if (keyStr.length > 10) {
+        masked = `${keyStr.substring(0, 4)}...${keyStr.slice(-4)}`;
+      }
+      const reqs = stat.totalRequests || 0;
+      const errs = stat.totalErrors || 0;
+      let label = masked;
+      if (activeKey && keyStr && activeKey.endsWith(keyStr.slice(-4))) {
+        label += chalk__default.default.dim(" (Active)");
+      }
+      const val = `${reqs} reqs  ${errs > 0 ? chalk__default.default.red(`[${errs} errs]`) : ""}`;
+      const rawLabel = label.replace(/\x1B\[\d+m/g, "");
+      const padding = Math.max(0, leftColWidth - rawLabel.length);
+      console.log(`  ${chalk__default.default.white(label)}${" ".repeat(padding)} ${chalk__default.default.white(val.trim())}`);
+    }
+  }
+}
+var lastFrameBuffer = "";
+async function render() {
+  let frameBuffer = "";
+  const originalLog = console.log;
+  const originalWrite = process.stdout.write;
+  console.log = (...args2) => {
+    frameBuffer += args2.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ") + "\n";
+  };
+  process.stdout.write = ((chunk) => {
+    frameBuffer += chunk.toString();
+    return true;
+  });
+  try {
+    renderTabs();
+    const tab = TABS[currentTabIdx];
+    if (tab === "Stats") await renderStats();
+    else if (tab === "Status") await renderStatus();
+    else if (tab === "Usage") await renderUsage();
+    else if (tab === "Settings") renderSettings();
+    console.log("" + chalk__default.default.gray("Tab to switch tabs \xB7 q to quit"));
+  } finally {
+    console.log = originalLog;
+    process.stdout.write = originalWrite;
+  }
+  if (frameBuffer !== lastFrameBuffer) {
+    process.stdout.write("\x1B[2J\x1B[H" + frameBuffer);
+    lastFrameBuffer = frameBuffer;
+  }
+}
+async function runDashboard() {
+  await render();
+  if (process.stdin.isTTY && !isListening) {
+    isListening = true;
+    let isRendering = false;
+    setInterval(async () => {
+      if (!isInputMode && !isRendering) {
+        isRendering = true;
+        try {
+          await render();
+        } finally {
+          isRendering = false;
+        }
+      }
+    }, 2e3);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", async (key) => {
+      if (key === "" || key === "q" && !isInputMode) {
+        process.stdout.write("\x1B[2J\x1B[H");
+        process.exit();
+      }
+      if (key === "r" && !isInputMode) {
+        await render();
+        return;
+      }
+      if (isInputMode) {
+        if (key === "\r" || key === "") {
+          const val = inputBuffer.trim();
+          if (val) {
+            if (!draftConfig.keys) draftConfig.keys = { openrouter: [], nvidia: [], mistral: [], gemini: [], groq: [] };
+            if (!draftConfig.keys[inputTarget]) {
+              draftConfig.keys[inputTarget] = [];
+            }
+            if (!draftConfig.keys[inputTarget].includes(val)) {
+              draftConfig.keys[inputTarget].push(val);
+            }
+          }
+          isInputMode = false;
+          await render();
+        } else if (key === "\x1B") {
+          isInputMode = false;
+          await render();
+        } else if (key === "\x7F" || key === "\b") {
+          inputBuffer = inputBuffer.slice(0, -1);
+          await render();
+        } else {
+          const cleanKey = key.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+          if (cleanKey) {
+            inputBuffer += cleanKey;
+            if (inputBuffer.length > 500) {
+              inputBuffer = inputBuffer.slice(0, 500);
+            }
+            await render();
+          }
+        }
+        return;
+      }
+      if (key === "	" || key === "\x1B[C" || key === "\x1BOC") {
+        currentTabIdx = (currentTabIdx + 1) % TABS.length;
+        isInputMode = false;
+        settingsView = "main";
+        settingsSelectionIdx = 0;
+        await render();
+      } else if (key === "\x1B[D" || key === "\x1BOD") {
+        currentTabIdx = (currentTabIdx - 1 + TABS.length) % TABS.length;
+        isInputMode = false;
+        settingsView = "main";
+        settingsSelectionIdx = 0;
+        await render();
+      } else if (TABS[currentTabIdx] === "Usage" && (key === "\r" || key === "" || key === " ")) {
+        usageViewMode = usageViewMode === "today" ? "session" : "today";
+        await render();
+      } else if (TABS[currentTabIdx] === "Settings") {
+        if (key === "\x1B" || key === "\x1B[27~") {
+          if (settingsView !== "main") {
+            settingsView = "main";
+            settingsSelectionIdx = 0;
+            await render();
+          }
+        } else if (key === "\x1B[A" || key === "\x1BOA") {
+          if (settingsSelectionIdx > 0) settingsSelectionIdx--;
+          await render();
+        } else if (key === "\x1B[B" || key === "\x1BOB") {
+          if (settingsSelectionIdx < currentTreeItems.length - 1) settingsSelectionIdx++;
+          await render();
+        } else if (key === "\r" || key === "" || key === " ") {
+          const selected = currentTreeItems[settingsSelectionIdx];
+          if (!selected) return;
+          if (selected.type === "main_mode") {
+            draftConfig.strictMode = !draftConfig.strictMode;
+            if (!draftConfig.strictMode) {
+              draftConfig.defaultModel = "";
+              draftConfig.defaultProvider = "";
+            }
+            await render();
+          } else if (selected.type === "main_model") {
+            settingsView = "models";
+            settingsSelectionIdx = 0;
+            await render();
+          } else if (selected.type === "main_keys") {
+            settingsView = "keys";
+            settingsSelectionIdx = 0;
+            await render();
+          } else if (selected.type === "model") {
+            draftConfig.defaultProvider = selected.provider;
+            draftConfig.defaultModel = selected.id;
+            draftConfig.strictMode = true;
+            settingsView = "main";
+            settingsSelectionIdx = 0;
+            await render();
+          } else if (selected.type === "secret_provider") {
+            if (expandedProviders.includes(selected.provider)) {
+              expandedProviders = expandedProviders.filter((p) => p !== selected.provider);
+            } else {
+              expandedProviders.push(selected.provider);
+            }
+            await render();
+          } else if (selected.type === "add") {
+            isInputMode = true;
+            inputTarget = selected.provider;
+            inputBuffer = "";
+            await render();
+          }
+        } else if (key.toLowerCase() === "m" && !isInputMode && settingsView === "main") {
+          draftConfig.strictMode = !draftConfig.strictMode;
+          if (!draftConfig.strictMode) {
+            draftConfig.defaultModel = "";
+            draftConfig.defaultProvider = "";
+          }
+          flashMessage = draftConfig.strictMode ? "\u{1F512} Switched to STRICT Mode" : "\u26A1 Switched to AUTO Mode";
+          await render();
+        } else if ((key.toLowerCase() === "d" || key === "\x7F" || key === "\b" || key === "\x1B[3~") && !isInputMode && settingsView === "keys") {
+          const selected = currentTreeItems[settingsSelectionIdx];
+          if (selected && selected.type === "key") {
+            const providerKeys = draftConfig.keys[selected.provider];
+            if (providerKeys) {
+              const idx = providerKeys.indexOf(selected.keyString);
+              if (idx > -1) {
+                providerKeys.splice(idx, 1);
+                flashMessage = `\u{1F5D1}\uFE0F Deleted key for ${selected.provider}`;
+                if (settingsSelectionIdx >= currentTreeItems.length - 1) {
+                  settingsSelectionIdx = Math.max(0, currentTreeItems.length - 2);
+                }
+              }
+            }
+          }
+          await render();
+        } else if (key.toLowerCase() === "s") {
+          config = JSON.parse(JSON.stringify(draftConfig));
+          saveConfig(config);
+          await triggerReload();
+          flashMessage = "Changes saved successfully!";
+          await render();
+        } else if (key.toLowerCase() === "x") {
+          draftConfig = JSON.parse(JSON.stringify(config));
+          settingsView = "main";
+          settingsSelectionIdx = 0;
+          flashMessage = "Changes discarded.";
+          await render();
+        }
+      }
+    });
+  }
+}
+function getPidFile() {
+  const dir = path2__namespace.join(os__namespace.homedir(), ".keymux");
+  if (!fs2__namespace.existsSync(dir)) fs2__namespace.mkdirSync(dir, { recursive: true });
+  return path2__namespace.join(dir, "proxy.pid");
+}
+async function startDaemon(port) {
+  return new Promise((resolve, reject) => {
+    const server = net__namespace.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.log(`Keymux proxy already running on port ${port}`);
+        resolve();
+      } else {
+        reject(err);
+      }
+    });
+    server.once("listening", () => {
+      server.close(async () => {
+        try {
+          let proxyScriptPath;
+          if (typeof __dirname !== "undefined") {
+            proxyScriptPath = path2__namespace.join(__dirname, "proxy", "index.js").replace(/\\/g, "\\\\");
+          } else {
+            const url = await import('url');
+            const dirname = url.fileURLToPath(new URL(".", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
+            proxyScriptPath = path2__namespace.join(dirname, "proxy", "index.js").replace(/\\/g, "\\\\");
+          }
+          const child = child_process.spawn("node", ["-e", `import('${proxyScriptPath}').then(m => m.startProxyServer({ port: ${port} })).catch(console.error)`], {
+            detached: true,
+            stdio: "ignore"
+          });
+          if (child.pid) {
+            fs2__namespace.writeFileSync(getPidFile(), child.pid.toString());
+          }
+          child.unref();
+          console.log(`Keymux proxy started on port ${port}`);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+    server.listen(port);
+  });
+}
+async function stopDaemon(port) {
+  const pidFile = getPidFile();
+  let stopped = false;
+  if (fs2__namespace.existsSync(pidFile)) {
+    try {
+      const pid = parseInt(fs2__namespace.readFileSync(pidFile, "utf8").trim(), 10);
+      if (pid && !isNaN(pid)) {
+        try {
+          const cmd = child_process.execSync(`ps -p ${pid} -o command=`).toString();
+          if (!cmd.includes("node") && !cmd.includes("keymux")) {
+            console.log(`Process ${pid} is not a Keymux proxy. Aborting.`);
+          } else {
+            process.kill(pid, "SIGTERM");
+            console.log(`Keymux proxy (PID ${pid}) stopped gracefully.`);
+            stopped = true;
+          }
+        } catch (e) {
+          console.log(`Failed to verify process ${pid}`);
+        }
+      }
+    } catch (e) {
+      if (e.code === "ESRCH") {
+        console.log("Proxy is not running (stale PID file).");
+      } else {
+        console.log("Failed to stop proxy via PID: " + e.message);
+      }
+    }
+    try {
+      fs2__namespace.unlinkSync(pidFile);
+    } catch (e) {
+    }
+  }
+  try {
+    const pkillCmd = `pkill -f "dist/proxy/index.js.*port: ${port}"`;
+    child_process.execSync(pkillCmd, { stdio: "ignore" });
+    if (!stopped) {
+      console.log(`Orphaned Keymux proxy on port ${port} forcefully stopped.`);
+      stopped = true;
+    }
+  } catch (e) {
+  }
+  if (!stopped) {
+    console.log("Keymux proxy is not running.");
+  }
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function runBootAnimation() {
+  const chalk2 = (await import('chalk')).default;
+  const logo = [
+    "  \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557",
+    "  \u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D",
+    "  \u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2557   \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2554\u255D",
+    "  \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u255D    \u255A\u2588\u2588\u2554\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2588\u2588\u2557",
+    "  \u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u255D \u2588\u2588\u2557",
+    "  \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D"
+  ];
+  console.clear();
+  console.log("\n");
+  for (const line of logo) {
+    console.log(chalk2.cyan(line));
+    await sleep(30);
+  }
+  console.log("\n" + chalk2.green(" \u2714 Keymux Gateway initialized successfully."));
+}
+var helpText = `Usage: keymux [command] [options]
+
+Commands:
+  -d, --dashboard    Run the interactive dashboard
+  proxy, start       Start the Keymux proxy daemon
+  stop               Stop the Keymux proxy daemon
+
+Options for proxy/start:
+  --port <port>      Specify the port to run the proxy on (default: 3002)
+
+Examples:
+  keymux -d
+  keymux start
+  keymux proxy --port 8080
+  keymux stop`;
+async function main() {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(helpText);
+    return;
+  }
+  if (args.length === 0 || args.includes("-d") || args.includes("--dashboard")) {
+    runDashboard().catch(console.error);
+    return;
+  }
+  const command = args[0];
+  if (command === "proxy" || command === "start") {
+    let port = 3002;
+    const portIndex = args.indexOf("--port");
+    if (portIndex !== -1 && args.length > portIndex + 1) {
+      port = parseInt(args[portIndex + 1] ?? "3002", 10);
+    }
+    await runBootAnimation();
+    await startDaemon(port);
+  } else if (command === "stop") {
+    let port = 3002;
+    const portIndex = args.indexOf("--port");
+    if (portIndex !== -1 && args.length > portIndex + 1) {
+      port = parseInt(args[portIndex + 1] ?? "3002", 10);
+    }
+    await stopDaemon(port);
+  } else {
+    console.log(`Unknown command: ${command}`);
+    console.log(helpText);
+    process.exit(1);
+  }
+}
+main().catch(console.error);
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map