wyxrouter 0.4.71 → 0.4.73

package/cli/src/cli/utils/format.js

@@ -0,0 +1,125 @@
+/**
+ * Truncate text with ellipsis
+ * @param {string} text - Text to truncate
+ * @param {number} maxLength - Maximum length
+ * @returns {string} Truncated text
+ */
+function truncate(text, maxLength) {
+  if (!text || text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength - 3) + "...";
+}
+
+/**
+ * Mask API key showing only first and last characters
+ * @param {string} key - API key to mask
+ * @returns {string} Masked key
+ */
+function maskKey(key) {
+  if (!key || key.length < 8) {
+    return "***";
+  }
+  const firstChars = key.substring(0, 4);
+  const lastChars = key.substring(key.length - 4);
+  return `${firstChars}${"*".repeat(key.length - 8)}${lastChars}`;
+}
+
+/**
+ * Format date to readable string
+ * @param {Date|string|number} date - Date to format
+ * @returns {string} Formatted date string
+ */
+function formatDate(date) {
+  const d = new Date(date);
+  if (isNaN(d.getTime())) {
+    return "Invalid Date";
+  }
+
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+/**
+ * Format number with commas
+ * @param {number} num - Number to format
+ * @returns {string} Formatted number
+ */
+function formatNumber(num) {
+  if (typeof num !== "number" || isNaN(num)) {
+    return "0";
+  }
+  return num.toLocaleString("en-US");
+}
+
+/**
+ * Format bytes to human readable size
+ * @param {number} bytes - Bytes to format
+ * @returns {string} Formatted size string
+ */
+function formatBytes(bytes) {
+  if (typeof bytes !== "number" || isNaN(bytes) || bytes < 0) {
+    return "0 B";
+  }
+
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+
+/**
+ * Get relative time string
+ * @param {Date|string|number} date - Date to compare
+ * @returns {string} Relative time string
+ */
+function getRelativeTime(date) {
+  const d = new Date(date);
+  if (isNaN(d.getTime())) {
+    return "Invalid Date";
+  }
+
+  const now = new Date();
+  const diffMs = now - d;
+  const diffSec = Math.floor(diffMs / 1000);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+  const diffMonth = Math.floor(diffDay / 30);
+  const diffYear = Math.floor(diffDay / 365);
+
+  if (diffSec < 60) {
+    return "just now";
+  } else if (diffMin < 60) {
+    return `${diffMin} minute${diffMin > 1 ? "s" : ""} ago`;
+  } else if (diffHour < 24) {
+    return `${diffHour} hour${diffHour > 1 ? "s" : ""} ago`;
+  } else if (diffDay < 30) {
+    return `${diffDay} day${diffDay > 1 ? "s" : ""} ago`;
+  } else if (diffMonth < 12) {
+    return `${diffMonth} month${diffMonth > 1 ? "s" : ""} ago`;
+  } else {
+    return `${diffYear} year${diffYear > 1 ? "s" : ""} ago`;
+  }
+}
+
+module.exports = {
+  truncate,
+  maskKey,
+  formatDate,
+  formatNumber,
+  formatBytes,
+  getRelativeTime
+};

package/cli/src/cli/utils/input.js

@@ -0,0 +1,156 @@
+const readline = require("readline");
+
+const COLORS = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  underline: "\x1b[4m",
+  reverse: "\x1b[7m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  white: "\x1b[37m",
+  bgGreen: "\x1b[42m",
+  bgBlue: "\x1b[44m",
+  black: "\x1b[30m",
+  terracotta: "\x1b[38;2;217;119;87m",
+  bgTerracotta: "\x1b[48;2;217;119;87m"
+};
+
+// Prime stdin once globally. Toggling raw mode between menus adds latency on
+// macOS, so we keep raw mode on for the whole TUI session.
+let rawPrimed = false;
+function primeRawOnce() {
+  if (rawPrimed || !process.stdin.isTTY) return;
+  try {
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+    rawPrimed = true;
+  } catch {}
+}
+
+function suspendRawFor(fn) {
+  // Temporarily drop raw mode so readline.question can buffer line input.
+  const wasPrimed = rawPrimed;
+  if (wasPrimed && process.stdin.isTTY) {
+    try { process.stdin.setRawMode(false); } catch {}
+  }
+  return fn().finally(() => {
+    if (wasPrimed && process.stdin.isTTY) {
+      try { process.stdin.setRawMode(true); } catch {}
+      process.stdin.resume();
+    }
+  });
+}
+
+async function prompt(question) {
+  return suspendRawFor(() => new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve((answer || "").trim());
+    });
+  }));
+}
+
+async function select(question, options) {
+  console.log(question);
+  options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt}`));
+  while (true) {
+    const answer = await prompt("\nSelect option (number): ");
+    const num = parseInt(answer, 10);
+    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
+    console.log(`Invalid selection. Please enter a number between 1 and ${options.length}`);
+  }
+}
+
+async function confirm(question) {
+  while (true) {
+    const answer = await prompt(`${question} (y/n): `);
+    const lower = answer.toLowerCase();
+    if (lower === "y" || lower === "yes") return true;
+    if (lower === "n" || lower === "no") return false;
+    console.log("Please answer 'y' or 'n'");
+  }
+}
+
+async function pause(message = "Press Enter to continue...") {
+  return suspendRawFor(() => new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(message, () => { rl.close(); resolve(); });
+  }));
+}
+
+/**
+ * Interactive arrow-key menu. Renders ★/☆ icons; selected line uses reverse+bright
+ * (no underline). Uses readline keypress + raw 'data' fallback to prevent
+ * arrow-key escape sequence leaks on macOS.
+ */
+async function selectMenu(title, items, defaultIndex = 0, subtitle = "", headerContent = "", breadcrumb = []) {
+  return new Promise((resolve) => {
+    let selectedIndex = defaultIndex;
+    let isActive = true;
+
+    primeRawOnce();
+    if (!process.stdin.isTTY) { resolve(-1); return; }
+
+    const renderMenu = () => {
+      if (!isActive) return;
+      process.stdout.write("\x1b[2J\x1b[H");
+      const width = Math.min(process.stdout.columns || 40, 40);
+      console.log(`\n${COLORS.terracotta}${"=".repeat(width)}${COLORS.reset}`);
+      console.log(`  ${COLORS.bright}${COLORS.terracotta}${title}${COLORS.reset}`);
+      if (subtitle) console.log(`  ${COLORS.dim}${subtitle}${COLORS.reset}`);
+      console.log(`${COLORS.terracotta}${"=".repeat(width)}${COLORS.reset}`);
+      if (breadcrumb.length > 0) console.log(`  ${COLORS.dim}${breadcrumb.join(" > ")}${COLORS.reset}`);
+      console.log();
+      if (headerContent) { console.log(headerContent); console.log(); }
+
+      const isWin = process.platform === "win32";
+      items.forEach((item, index) => {
+        const isSelected = index === selectedIndex;
+        const icon = isSelected ? (isWin ? ">" : "★") : (isWin ? " " : "☆");
+        if (isSelected) {
+          console.log(` ${COLORS.reverse}${COLORS.bright}${icon} ${item.label}${COLORS.reset}`);
+        } else {
+          console.log(`  ${icon} ${item.label}`);
+        }
+      });
+    };
+
+    const cleanup = () => {
+      if (!isActive) return;
+      isActive = false;
+      process.stdin.removeListener("keypress", onKeypress);
+    };
+
+    const move = (delta) => {
+      selectedIndex = (selectedIndex + delta + items.length) % items.length;
+      renderMenu();
+    };
+
+    const onKeypress = (_str, key) => {
+      if (!isActive || !key) return;
+      if (key.name === "up") return move(-1);
+      if (key.name === "down") return move(1);
+      if (key.name === "return") { cleanup(); resolve(selectedIndex); return; }
+      if (key.name === "escape") { cleanup(); resolve(-1); return; }
+      if (key.ctrl && key.name === "c") { cleanup(); process.exit(0); }
+    };
+
+    process.stdin.on("keypress", onKeypress);
+    renderMenu();
+  });
+}
+
+module.exports = {
+  prompt,
+  select,
+  confirm,
+  pause,
+  selectMenu,
+  COLORS
+};

package/cli/src/cli/utils/menuHelper.js

@@ -0,0 +1,156 @@
+const { selectMenu } = require("./input");
+
+/**
+ * Show a menu with back button at top and handle selection
+ * @param {Object} config - Menu configuration
+ * @param {string} config.title - Menu title
+ * @param {string} config.headerContent - Optional header content
+ * @param {Array<{label: string, action: Function}>} config.items - Menu items with actions
+ * @param {string} config.backLabel - Back button label (default: "← Back")
+ * @param {number} config.defaultIndex - Default selected index (default: 0)
+ * @param {Function} config.refresh - Optional refresh function to call after each action
+ * @param {Array<string>} config.breadcrumb - Optional breadcrumb path
+ * @returns {Promise<void>}
+ */
+async function showMenuWithBack(config) {
+  const {
+    title,
+    headerContent = "",
+    items,
+    backLabel = "← Back",
+    defaultIndex = 0,
+    refresh = null,
+    breadcrumb = []
+  } = config;
+
+  while (true) {
+    // Call refresh if provided
+    let refreshedData = null;
+    if (refresh) {
+      refreshedData = await refresh();
+      if (refreshedData === null) {
+        // Refresh failed, exit menu
+        return;
+      }
+    }
+
+    // Build menu items with back at top
+    const menuItems = [
+      { label: backLabel, icon: "☆" },
+      ...items.map(item => ({
+        label: typeof item.label === "function" ? item.label(refreshedData) : item.label,
+        icon: "☆"
+      }))
+    ];
+
+    // Resolve headerContent if it's a function
+    const resolvedHeader = typeof headerContent === "function" 
+      ? await headerContent(refreshedData) 
+      : headerContent;
+
+    const selected = await selectMenu(
+      title,
+      menuItems,
+      defaultIndex,
+      "",
+      resolvedHeader,
+      breadcrumb
+    );
+
+    // Back or ESC
+    if (selected === -1 || selected === 0) {
+      return;
+    }
+
+    // Execute action for selected item
+    const actionIndex = selected - 1;
+    const item = items[actionIndex];
+    
+    if (item && item.action) {
+      const shouldContinue = await item.action(refreshedData);
+      // If action returns false, exit menu
+      if (shouldContinue === false) {
+        return;
+      }
+    }
+  }
+}
+
+/**
+ * Show a list menu where items are fetched dynamically
+ * @param {Object} config - Menu configuration
+ * @param {string} config.title - Menu title
+ * @param {string} config.headerContent - Optional header content
+ * @param {Function} config.fetchItems - Async function to fetch items array
+ * @param {Function} config.formatItem - Function to format each item to {label, data}
+ * @param {Function} config.onSelect - Action when item is selected
+ * @param {Object} config.createAction - Optional create action {label, action}
+ * @param {string} config.backLabel - Back button label
+ * @param {Array<string>} config.breadcrumb - Optional breadcrumb path
+ * @returns {Promise<void>}
+ */
+async function showListMenu(config) {
+  const {
+    title,
+    headerContent = "",
+    fetchItems,
+    formatItem,
+    onSelect,
+    createAction = null,
+    backLabel = "← Back",
+    breadcrumb = []
+  } = config;
+
+  while (true) {
+    // Fetch items
+    const result = await fetchItems();
+    if (!result) {
+      return;
+    }
+
+    const items = result.items || [];
+    const metadata = result.metadata || {};
+
+    // Build menu items
+    const menuItems = [{ label: backLabel, icon: "☆" }];
+    
+    if (createAction) {
+      menuItems.push({ label: createAction.label, icon: "☆" });
+    }
+
+    items.forEach(item => {
+      const formatted = formatItem(item);
+      menuItems.push({ label: formatted, icon: "☆" });
+    });
+
+    const header = typeof headerContent === "function" 
+      ? await headerContent(metadata) 
+      : headerContent;
+
+    const selected = await selectMenu(title, menuItems, 0, "", header, breadcrumb);
+
+    // Back or ESC
+    if (selected === -1 || selected === 0) {
+      return;
+    }
+
+    // Create action
+    if (createAction && selected === 1) {
+      await createAction.action();
+      continue;
+    }
+
+    // Select item
+    const offset = createAction ? 2 : 1;
+    const itemIndex = selected - offset;
+    
+    if (itemIndex >= 0 && itemIndex < items.length) {
+      await onSelect(items[itemIndex]);
+    }
+  }
+}
+
+module.exports = {
+  showMenuWithBack,
+  showListMenu
+};

package/cli/src/cli/utils/modelSelector.js

@@ -0,0 +1,136 @@
+const api = require("../api/client");
+const { prompt } = require("./input");
+const { clearScreen } = require("./display");
+
+// Provider alias order: OAuth first, then API Key (matches ModelSelectModal)
+const PROVIDER_ALIAS_ORDER = [
+  "cc", "ag", "cx", "if", "qw", "gc", "gh", "kr",
+  "openrouter", "glm", "kimi", "minimax", "openai", "anthropic", "gemini"
+];
+
+// Alias to display name mapping
+const PROVIDER_ALIAS_NAMES = {
+  cc: "Claude Code",
+  ag: "Antigravity", 
+  cx: "OpenAI Codex",
+  if: "iFlow AI",
+  qw: "Qwen Code",
+  gc: "Gemini CLI",
+  gh: "GitHub Copilot",
+  kr: "Kiro AI",
+  openrouter: "OpenRouter",
+  glm: "GLM Coding",
+  kimi: "Kimi Coding",
+  minimax: "Minimax Coding",
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  gemini: "Gemini"
+};
+
+/**
+ * Get all available models grouped by provider + combos
+ * @returns {Promise<{combos: Array, groups: Object}>}
+ */
+async function getAvailableModelsGrouped() {
+  const result = await api.getAvailableModels();
+  if (!result.success) return { combos: [], groups: {} };
+  
+  const models = result.data?.data || [];
+  const combos = [];
+  const groups = {};
+  
+  models.forEach(m => {
+    if (m.owned_by === "combo") {
+      combos.push(m.id);
+    } else {
+      const provider = m.owned_by;
+      if (!groups[provider]) {
+        groups[provider] = [];
+      }
+      groups[provider].push(m.id);
+    }
+  });
+  
+  return { combos, groups };
+}
+
+/**
+ * Display model list and prompt for selection
+ * @param {string} title - Title to display
+ * @param {string} currentValue - Current selected value (optional)
+ * @param {Object} options - { excludeCombos?: boolean }
+ * @returns {Promise<string|null>} Selected model ID or null if cancelled
+ */
+async function selectModelFromList(title, currentValue = "", options = {}) {
+  const { excludeCombos = false } = options;
+  const { combos: rawCombos, groups } = await getAvailableModelsGrouped();
+  const combos = excludeCombos ? [] : rawCombos;
+
+  const totalModels = combos.length + Object.values(groups).flat().length;
+  if (totalModels === 0) {
+    return null;
+  }
+  
+  // Build flat list for selection
+  const allModels = [];
+  
+  // Display
+  clearScreen();
+  console.log(`\n🎯 ${title}`);
+  console.log("=".repeat(50));
+  if (currentValue) {
+    console.log(`Current: ${currentValue}\n`);
+  } else {
+    console.log();
+  }
+  
+  let idx = 1;
+  
+  // Combos first (skipped when excludeCombos is true)
+  if (combos.length > 0) {
+    console.log("[Combos]");
+    combos.forEach(combo => {
+      console.log(`  ${idx}. ${combo}`);
+      allModels.push(combo);
+      idx++;
+    });
+    console.log();
+  }
+  
+  // Provider groups in order (by alias)
+  const sortedProviders = Object.keys(groups).sort((a, b) => {
+    const idxA = PROVIDER_ALIAS_ORDER.indexOf(a);
+    const idxB = PROVIDER_ALIAS_ORDER.indexOf(b);
+    return (idxA === -1 ? 999 : idxA) - (idxB === -1 ? 999 : idxB);
+  });
+  
+  sortedProviders.forEach(provider => {
+    const providerName = PROVIDER_ALIAS_NAMES[provider] || provider;
+    console.log(`[${providerName}]`);
+    groups[provider].forEach(model => {
+      console.log(`  ${idx}. ${model}`);
+      allModels.push(model);
+      idx++;
+    });
+    console.log();
+  });
+  
+  console.log("  0. Cancel\n");
+  
+  // Prompt for number input
+  const input = await prompt("Enter number: ");
+  const num = parseInt(input, 10);
+  
+  if (isNaN(num) || num === 0 || num < 0 || num > allModels.length) {
+    return null;
+  }
+  
+  return allModels[num - 1];
+}
+
+module.exports = {
+  selectModelFromList,
+  getAvailableModelsGrouped,
+  PROVIDER_ALIAS_ORDER,
+  PROVIDER_ALIAS_NAMES
+};

package/open-sse/services/usage.js

@@ -53,7 +53,7 @@ const CLAUDE_CONFIG = {
 };
 
 const CODEBUDDY_CONFIG = {
-  usageUrl: "https://www.codebuddy.ai/billing/meter/get-user-resource",
+  usageUrl: "https://www.codebuddy.ai/v2/billing/meter/get-user-resource",
   productCode: "p_tcaca",
   packageCodes: {
     free: "TCACA_code_001_PqouKr6QWV",
@@ -112,15 +112,46 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
   }
 }
 
+async function fetchCodeBuddyUid(accessToken, providerSpecificData = {}, proxyOptions = null) {
+  const cachedUid = providerSpecificData?.uid || providerSpecificData?.rawAuth?.uid;
+  if (cachedUid) return { uid: cachedUid, enterpriseId: providerSpecificData?.enterpriseId || null };
+
+  const domain = providerSpecificData?.domain || providerSpecificData?.rawAuth?.domain || "www.codebuddy.ai";
+  try {
+    const response = await proxyAwareFetch(`https://${domain}/v2/plugin/accounts`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "X-Domain": domain,
+      },
+    }, proxyOptions);
+
+    if (!response.ok) return { uid: null, enterpriseId: null };
+
+    const body = await response.json();
+    const accounts = body?.data?.accounts || [];
+    const account = accounts.find((a) => a.lastLogin) || accounts[0] || {};
+    return {
+      uid: account.uid || null,
+      enterpriseId: account.enterpriseId || null,
+    };
+  } catch {
+    return { uid: null, enterpriseId: null };
+  }
+}
+
 async function getCodeBuddyUsage(accessToken, providerSpecificData = {}, proxyOptions = null) {
   if (!accessToken) {
     return { plan: "CodeBuddy", message: "CodeBuddy access token not available.", quotas: {} };
   }
 
   try {
+    const { uid, enterpriseId } = await fetchCodeBuddyUid(accessToken, providerSpecificData, proxyOptions);
+
     const response = await proxyAwareFetch(CODEBUDDY_CONFIG.usageUrl, {
       method: "POST",
-      headers: buildCodeBuddyUsageHeaders(accessToken, providerSpecificData),
+      headers: buildCodeBuddyUsageHeaders(accessToken, providerSpecificData, uid, enterpriseId),
       body: JSON.stringify(buildCodeBuddyUsageBody()),
     }, proxyOptions);
 
@@ -135,7 +166,7 @@ async function getCodeBuddyUsage(accessToken, providerSpecificData = {}, proxyOp
     if (response.status === 401 || response.status === 403) {
       return {
         plan: "CodeBuddy",
-        message: "CodeBuddy quota endpoint requires a web console session; the current CLI/plugin OAuth token can fetch account data but not credit usage.",
+        message: `CodeBuddy quota: auth failed (${response.status}). uid=${uid ? "yes" : "missing"}.`,
         quotas: {},
       };
     }
@@ -209,20 +240,26 @@ function buildCodeBuddyUsageBody() {
   };
 }
 
-function buildCodeBuddyUsageHeaders(accessToken, providerSpecificData = {}) {
+function buildCodeBuddyUsageHeaders(accessToken, providerSpecificData = {}, uid = null, enterpriseId = null) {
   const domain = providerSpecificData?.domain || providerSpecificData?.rawAuth?.domain || "www.codebuddy.ai";
-  const webCookie = providerSpecificData?.webCookie || providerSpecificData?.cookie || providerSpecificData?.codeBuddyCookie;
 
-  return {
-    ...(webCookie ? { Cookie: webCookie } : { Authorization: `Bearer ${accessToken}` }),
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
     Accept: "application/json, text/plain, */*",
+    "Accept-Language": "zh-CN,zh;q=0.9",
     "Content-Type": "application/json",
-    "User-Agent": "Mozilla/5.0 CodeBuddy quota probe",
-    "X-Requested-With": "XMLHttpRequest",
     "X-Domain": domain,
-    Origin: `https://${domain}`,
-    Referer: `https://${domain}/profile/usage`,
   };
+
+  if (uid) {
+    headers["X-User-Id"] = uid;
+  }
+  if (enterpriseId) {
+    headers["X-Enterprise-Id"] = enterpriseId;
+    headers["X-Tenant-Id"] = enterpriseId;
+  }
+
+  return headers;
 }
 
 function parseCodeBuddyUsage(payload) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyxrouter",
-  "version": "0.4.71",
+  "version": "0.4.73",
   "description": "WYx0 fork of 9Router - AI Router with Kiro/CodeBuddy automation and quota tracking",
   "bin": {
     "wyxrouter": "./cli/cli.js"
@@ -30,7 +30,8 @@
     "dev:bun": "bun --bun next dev --webpack --port 20128",
     "build:bun": "bun --bun next build --webpack",
     "start:bun": "bun ./.next/standalone/server.js",
-    "prepublishOnly": "npm run build"
+    "prepack": "echo 'Ensure cli/app is built before publishing: node cli/scripts/build-cli.js'",
+    "postinstall": "node cli/hooks/postinstall.js"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -94,7 +95,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/decolua/9router"
+    "url": "https://github.com/Wisyam/9router_wyx0"
   },
   "homepage": "https://9router.com"
 }