@yina-npm/openrouterx 0.4.22 → 0.4.24

package/app/src/mitm/handlers/openrouter.js

@@ -4,21 +4,35 @@ const { err } = require("../logger");
 const { fetchRouter, pipeSSE } = require("./base");
 
 const URL_MAP = {
+  "/api/v1/chat/completions": "/v1/chat/completions",
   "/v1/chat/completions": "/v1/chat/completions",
   "/chat/completions": "/v1/chat/completions",
   "/v1/messages": "/v1/messages",
+  "/api/v1/responses": "/v1/responses",
+  "/v1/responses": "/v1/responses",
   "/responses": "/v1/responses",
+  "/api/v1/models": "/v1/models",
+  "/v1/models": "/v1/models",
 };
 
 function resolveRouterPath(reqUrl) {
+  const [pathname, query = ""] = String(reqUrl || "").split("?");
   for (const [pattern, routerPath] of Object.entries(URL_MAP)) {
-    if (reqUrl.includes(pattern)) return routerPath;
+    if (pathname === pattern || pathname.endsWith(pattern)) {
+      return query ? `${routerPath}?${query}` : routerPath;
+    }
   }
   return "/v1/chat/completions";
 }
 
 function isModelsRequest(reqUrl) {
-  return reqUrl.includes("/models") || reqUrl.includes("/api/v1/models");
+  const pathname = String(reqUrl || "").split("?")[0];
+  return pathname === "/models" || pathname === "/v1/models" || pathname === "/api/v1/models" || pathname.endsWith("/models");
+}
+
+function isKeyInfoRequest(reqUrl) {
+  const pathname = String(reqUrl || "").split("?")[0];
+  return pathname === "/api/v1/key" || pathname === "/api/v1/auth/key";
 }
 
 function getLocalModelsPayload() {
@@ -36,6 +50,52 @@ function sendJsonPayload(res, payload) {
   res.end(payload);
 }
 
+function sendOptions(res) {
+  if (res.writableEnded) return;
+  res.writeHead(204, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "*",
+  });
+  res.end();
+}
+
+function buildKeyInfoPayload() {
+  return {
+    data: {
+      label: "openrouterX MITM API Key",
+      limit: null,
+      usage: 0,
+      usage_daily: 0,
+      usage_weekly: 0,
+      usage_monthly: 0,
+      byok_usage: 0,
+      byok_usage_daily: 0,
+      byok_usage_weekly: 0,
+      byok_usage_monthly: 0,
+      is_free_tier: false,
+      limit_remaining: null,
+      limit_reset: null,
+      include_byok_in_limit: false,
+      is_provisioning_key: false,
+      is_management_key: false,
+      rate_limit: { interval: "1h", requests: 100000 },
+    },
+  };
+}
+
+function sendKeyInfo(res) {
+  if (res.writableEnded) return;
+  const payload = JSON.stringify(buildKeyInfoPayload());
+  res.writeHead(200, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Access-Control-Allow-Origin": "*",
+    "Cache-Control": "no-store",
+    "Content-Length": Buffer.byteLength(payload),
+  });
+  res.end(payload);
+}
+
 function buildInjectedModel(publicModelId) {
   const [provider = "openrouter"] = String(publicModelId || "").split("/");
   return {
@@ -102,6 +162,16 @@ async function handleModelsRequest(req, res, bodyBuffer, passthrough, aliasMappi
  */
 async function intercept(req, res, bodyBuffer, mappedModel, passthrough, aliasMappings = {}) {
   try {
+    if (req.method === "OPTIONS") {
+      sendOptions(res);
+      return;
+    }
+
+    if (req.method === "GET" && isKeyInfoRequest(req.url)) {
+      sendKeyInfo(res);
+      return;
+    }
+
     if (isModelsRequest(req.url)) {
       return handleModelsRequest(req, res, bodyBuffer, passthrough, aliasMappings);
     }
@@ -119,4 +189,13 @@ async function intercept(req, res, bodyBuffer, mappedModel, passthrough, aliasMa
   }
 }
 
-module.exports = { intercept, resolveRouterPath, isModelsRequest, injectPublicModels, buildInjectedModel };
+module.exports = {
+  intercept,
+  resolveRouterPath,
+  isModelsRequest,
+  isKeyInfoRequest,
+  sendKeyInfo,
+  buildKeyInfoPayload,
+  injectPublicModels,
+  buildInjectedModel,
+};

package/app/src/mitm/logger.js

@@ -14,7 +14,7 @@ const err = (msg) => console.error(`[${time()}] ❌ [MITM] ${msg}`);
 function ensureDumpDir() {
   const candidates = [
     path.join(DATA_DIR, "logs", "mitm"),
-    path.join(require("os").tmpdir(), "9router", "logs", "mitm"),
+    path.join(require("os").tmpdir(), "openrouterx", "logs", "mitm"),
   ];
   for (const dir of candidates) {
     try {

package/app/src/mitm/manager.js

@@ -62,7 +62,7 @@ function resolveBundledServerPath() {
 
 const SERVER_PATH = resolveBundledServerPath();
 const ENCRYPT_ALGO = "aes-256-gcm";
-const ENCRYPT_SALT = "9router-mitm-pwd";
+const ENCRYPT_SALT = "openrouterx-mitm-pwd";
 
 function getProcessUsingPort443() {
   try {
@@ -524,10 +524,13 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
     log(`[MITM] server.js missing at ${effectiveServerPath} → recopying`);
     effectiveServerPath = ensureRuntimeServer(resolveBundledServerPath());
     if (!effectiveServerPath || !fs.existsSync(effectiveServerPath)) {
-      throw new Error(`MITM server.js not found at ${effectiveServerPath}. Reinstall 9router.`);
+      throw new Error(`MITM server.js not found at ${effectiveServerPath}. Reinstall openrouterX.`);
     }
   }
   const mitmRouterBase = await resolveMitmRouterBaseUrl();
+  const mitmServerCwd = MITM_DIR || os.homedir();
+  fs.mkdirSync(mitmServerCwd, { recursive: true });
+  const agMockBootstrap = process.env.OPENROUTERX_AG_MOCK_BOOTSTRAP === "1" ? "1" : "0";
   log(`🚀 Starting server... (router: ${mitmRouterBase})`);
   if (IS_WIN) {
     // Check port 443 — ask user before killing
@@ -549,6 +552,7 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
       process.execPath,
       [effectiveServerPath],
       {
+        cwd: mitmServerCwd,
         detached: false,
         windowsHide: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -557,6 +561,7 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
           ROUTER_API_KEY: apiKey,
           NODE_ENV: "production",
           MITM_ROUTER_BASE: mitmRouterBase,
+          OPENROUTERX_AG_MOCK_BOOTSTRAP: agMockBootstrap,
         },
       }
     );
@@ -569,19 +574,21 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
       `HOME=${shellQuoteSingle(os.homedir())}`,
       `ROUTER_API_KEY=${shellQuoteSingle(apiKey)}`,
       `MITM_ROUTER_BASE=${shellQuoteSingle(mitmRouterBase)}`,
+      `OPENROUTERX_AG_MOCK_BOOTSTRAP=${shellQuoteSingle(agMockBootstrap)}`,
       "NODE_ENV=production",
       shellQuoteSingle(process.execPath),
       shellQuoteSingle(effectiveServerPath),
     ].join(" ");
     serverProcess = spawn(
       "sudo", ["-S", "-E", "sh", "-c", inlineCmd],
-      { detached: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] }
+      { cwd: mitmServerCwd, detached: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] }
     );
     serverProcess.stdin.write(`${sudoPassword}\n`);
     serverProcess.stdin.end();
   } else {
     // Docker/minimal images: no sudo — same as Windows-style direct spawn
     serverProcess = spawn(process.execPath, [effectiveServerPath], {
+      cwd: mitmServerCwd,
       detached: false,
       windowsHide: true,
       stdio: ["ignore", "pipe", "pipe"],
@@ -590,6 +597,7 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
         ROUTER_API_KEY: apiKey,
         NODE_ENV: "production",
         MITM_ROUTER_BASE: mitmRouterBase,
+        OPENROUTERX_AG_MOCK_BOOTSTRAP: agMockBootstrap,
       },
     });
   }

package/app/src/mitm/server.js

@@ -2,10 +2,12 @@ const https = require("https");
 const fs = require("fs");
 const path = require("path");
 const dns = require("dns");
+const zlib = require("zlib");
 const { promisify } = require("util");
 const { execSync } = require("child_process");
 const { log, err, dumpRequest, createResponseDumper } = require("./logger");
 const { TARGET_HOSTS, URL_PATTERNS, MODEL_SYNONYMS, getToolForHost } = require("./config");
+const { buildAntigravityAvailableModelsResponse } = require("./antigravityModels");
 const { DATA_DIR, MITM_DIR } = require("./paths");
 const { getCertForDomain } = require("./cert/generate");
 
@@ -19,6 +21,7 @@ const INTERNAL_REQUEST_HEADER = { name: "x-request-source", value: "local" };
 // daily-cloudcode-pa (dev endpoint) accepts same body+token. Same trick as open-sse.
 const HOST_REWRITE = {
   "cloudcode-pa.googleapis.com": "daily-cloudcode-pa.googleapis.com",
+  "daily-cloudcode-pa.sandbox.googleapis.com": "daily-cloudcode-pa.googleapis.com",
 };
 
 // Load handlers — dev/ overrides handlers/ for private implementations
@@ -73,14 +76,34 @@ try {
 const cachedTargetIPs = {};
 const CACHE_TTL_MS = 5 * 60 * 1000;
 
+function getLocalIPv4Aliases() {
+  if (process.platform !== "darwin") return [];
+  try {
+    const out = execSync("ifconfig lo0", { encoding: "utf8", windowsHide: true });
+    return [...out.matchAll(/^\s+inet\s+(\d+\.\d+\.\d+\.\d+)\s+/gm)].map((m) => m[1]);
+  } catch {
+    return [];
+  }
+}
+
 async function resolveTargetIP(hostname) {
   const cached = cachedTargetIPs[hostname];
-  if (cached && Date.now() - cached.ts < CACHE_TTL_MS) return cached.ip;
+  const localAliases = new Set(getLocalIPv4Aliases());
+  if (cached && Date.now() - cached.ts < CACHE_TTL_MS && !localAliases.has(cached.ip)) return cached.ip;
   const resolver = new dns.Resolver();
   resolver.setServers(["8.8.8.8"]);
   const resolve4 = promisify(resolver.resolve4.bind(resolver));
-  const addresses = await resolve4(hostname);
-  cachedTargetIPs[hostname] = { ip: addresses[0], ts: Date.now() };
+  let addresses;
+  try {
+    addresses = await resolve4(hostname);
+  } catch (primaryError) {
+    const lookup = promisify(dns.lookup);
+    const records = await lookup(hostname, { family: 4, all: true }).catch(() => []);
+    addresses = records.map((record) => record.address).filter((addr) => !localAliases.has(addr));
+    if (addresses.length === 0) throw primaryError;
+  }
+  const ip = addresses.find((addr) => !localAliases.has(addr)) || addresses[0];
+  cachedTargetIPs[hostname] = { ip, ts: Date.now() };
   return cachedTargetIPs[hostname].ip;
 }
 
@@ -111,8 +134,10 @@ function getMappedModel(tool, model) {
   try {
     if (!fs.existsSync(DB_FILE)) return null;
     const db = JSON.parse(fs.readFileSync(DB_FILE, "utf-8"));
-    const aliases = db.mitmAlias?.[tool];
-    if (!aliases) return null;
+    const aliases = {
+      ...(MODEL_SYNONYMS?.[tool]?.__defaults || {}),
+      ...(db.mitmAlias?.[tool] || {}),
+    };
     // Normalize via synonym map (e.g., gemini-default → gemini-3-flash)
     const lookup = MODEL_SYNONYMS?.[tool]?.[model] || model;
     if (aliases[lookup]) return aliases[lookup];
@@ -122,17 +147,166 @@ function getMappedModel(tool, model) {
   } catch { return null; }
 }
 
+function respondJson(res, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json; charset=UTF-8",
+    "Content-Length": Buffer.byteLength(body),
+  });
+  res.end(body);
+}
+
+function shouldDumpRequest(req) {
+  if (process.env.OPENROUTERX_MITM_DUMP_ALL === "1") return true;
+  return !!getToolForHost(req.headers.host);
+}
+
+function handleLocalAntigravityBootstrap(req, res) {
+  if (req.url.includes(":fetchAvailableModels") && process.env.OPENROUTERX_AG_LOCAL_MODELS !== "0") {
+    const payload = buildAntigravityAvailableModelsResponse();
+    respondJson(res, 200, payload);
+    log(`🧩 bootstrap | antigravity | local fetchAvailableModels (${Object.keys(payload.models || {}).length} models)`);
+    return true;
+  }
+
+  // The language server refreshes this cache next to the model list. Upstream
+  // can reject the MITM-shaped request with INVALID_ARGUMENT, which then marks
+  // the whole background cache refresh as failed even when models were local.
+  if (req.url.includes(":fetchAdminControls")) {
+    respondJson(res, 200, { adminControls: [] });
+    log("🧩 bootstrap | antigravity | local fetchAdminControls");
+    return true;
+  }
+
+  const localAuthBootstrap = process.env.OPENROUTERX_AG_LOCAL_AUTH !== "0"
+    || process.env.OPENROUTERX_AG_MOCK_BOOTSTRAP === "1";
+
+  if (!localAuthBootstrap) return false;
+
+  if (req.url.includes(":loadCodeAssist")) {
+    respondJson(res, 200, {
+      cloudaicompanionProject: "local-openrouterx",
+      allowedTiers: [
+        {
+          id: "standard-tier",
+          name: "OpenRouterX Local",
+          description: "Local MITM bootstrap tier",
+          isDefault: true,
+        },
+      ],
+      currentTier: {
+        id: "standard-tier",
+        name: "OpenRouterX Local",
+      },
+      userTier: {
+        id: "standard-tier",
+        name: "OpenRouterX Local",
+      },
+      tosAccepted: true,
+      done: true,
+    });
+    log("🧩 bootstrap | antigravity | local loadCodeAssist");
+    return true;
+  }
+
+  if (req.url.includes(":onboardUser")) {
+    respondJson(res, 200, {
+      done: true,
+      response: {
+        cloudaicompanionProject: "local-openrouterx",
+      },
+    });
+    log("🧩 bootstrap | antigravity | local onboardUser");
+    return true;
+  }
+
+  if (req.url.includes("/cascadeNuxes")) {
+    respondJson(res, 200, {
+      nuxes: [],
+      completedNuxes: [],
+    });
+    log("🧩 bootstrap | antigravity | local cascadeNuxes");
+    return true;
+  }
+
+  return false;
+}
+
+function decodeResponseBody(buf, headers = {}) {
+  if (!buf || buf.length === 0) return buf;
+  const enc = String(headers["content-encoding"] || headers["Content-Encoding"] || "").toLowerCase();
+  try {
+    if (enc.includes("gzip")) return zlib.gunzipSync(buf);
+    if (enc.includes("br")) return zlib.brotliDecompressSync(buf);
+    if (enc.includes("deflate")) return zlib.inflateSync(buf);
+  } catch (e) {
+    err(`loadCodeAssist decode failed: ${e.message}`);
+  }
+  return buf;
+}
+
+function summarizeTier(tier) {
+  if (!tier || typeof tier !== "object") return String(tier || "unknown");
+  const id = tier.id || tier.tierId || tier.name || tier.displayName || "unknown";
+  const name = tier.displayName || tier.name || "";
+  const marker = tier.isDefault ? "*" : "";
+  return name && name !== id ? `${id}${marker}(${name})` : `${id}${marker}`;
+}
+
+function summarizeIneligibleTier(tier) {
+  if (!tier || typeof tier !== "object") return String(tier || "unknown");
+  const id = tier.id || tier.tierId || tier.name || tier.displayName || "unknown";
+  const reason = tier.ineligibilityReason || tier.reason || tier.reasonCode || tier.code || "unknown";
+  const message = tier.message || tier.ineligibilityMessage || tier.description || "";
+  return message ? `${id}:${reason}:${message}` : `${id}:${reason}`;
+}
+
+function inspectAntigravityLoadCodeAssist(rawBuffer, headers) {
+  const text = decodeResponseBody(rawBuffer, headers).toString("utf8");
+  try {
+    const payload = JSON.parse(text);
+    const allowed = Array.isArray(payload.allowedTiers)
+      ? payload.allowedTiers.map(summarizeTier)
+      : [];
+    const ineligible = Array.isArray(payload.ineligibleTiers)
+      ? payload.ineligibleTiers.map(summarizeIneligibleTier)
+      : [];
+    const project = payload.cloudaicompanionProject || payload.cloudaicompanionProjectId || payload.project || "";
+    const validationUrl = /https?:\/\/\S+/i.test(text) ? "present" : "none";
+
+    log(
+      `🧩 loadCodeAssist MITM | status=passthrough | project=${project || "none"} | ` +
+      `allowed=${allowed.length ? allowed.join(", ") : "none"} | ` +
+      `ineligible=${ineligible.length ? ineligible.join(" | ") : "none"} | validationUrl=${validationUrl}`
+    );
+  } catch {
+    log(`🧩 loadCodeAssist MITM | status=passthrough | non-json response bytes=${rawBuffer.length}`);
+  }
+}
+
 /**
  * Forward request to real upstream.
- * Optional onResponse(rawBuffer) callback — if provided, tees the response
+ * Optional onResponse(rawBuffer, headers) callback — if provided, tees the response
  * so it's both forwarded to client AND passed to the callback for inspection.
+ * Optional transformResponse(rawBuffer, headers) callback — if provided, buffers
+ * the full response, passes it to the callback, and sends the returned buffer
+ * to the client instead of the original response.
  * Also tees full stream into a dump file when ENABLE_FILE_LOG is on.
  */
-async function passthrough(req, res, bodyBuffer, onResponse) {
+async function passthrough(req, res, bodyBuffer, onResponse, transformResponse) {
   const originalHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
   const targetHost = HOST_REWRITE[originalHost] || originalHost;
-  const targetIP = await resolveTargetIP(targetHost);
-  const dumper = ENABLE_FILE_LOG ? createResponseDumper(req, "passthrough") : null;
+  const dumper = ENABLE_FILE_LOG && shouldDumpRequest(req) ? createResponseDumper(req, "passthrough") : null;
+  let targetIP;
+  try {
+    targetIP = await resolveTargetIP(targetHost);
+  } catch (e) {
+    err(`Passthrough resolve error for ${targetHost}: ${e.code || e.message}`);
+    if (dumper) { dumper.writeChunk(`\n[ERROR] resolve ${targetHost}: ${e.message}\n`); dumper.end(); }
+    if (!res.headersSent) res.writeHead(502, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: { message: `DNS resolve failed for ${targetHost}`, type: "mitm_dns_error" } }));
+    return;
+  }
 
   const forwardReq = https.request({
     hostname: targetIP,
@@ -143,25 +317,46 @@ async function passthrough(req, res, bodyBuffer, onResponse) {
     servername: targetHost,
     rejectUnauthorized: false
   }, (forwardRes) => {
-    res.writeHead(forwardRes.statusCode, forwardRes.headers);
-    if (dumper) dumper.writeHeader(forwardRes.statusCode, forwardRes.headers);
+    // When transformResponse is provided, buffer the full response so we can
+    // modify it before sending to the client.
+    const shouldBuffer = transformResponse != null;
+    if (!shouldBuffer) res.writeHead(forwardRes.statusCode, forwardRes.headers);
 
-    if (!onResponse && !dumper) {
+    if (!onResponse && !dumper && !shouldBuffer) {
       forwardRes.pipe(res);
       return;
     }
 
-    // Tee: forward to client AND optionally buffer + dump
     const chunks = [];
     forwardRes.on("data", chunk => {
       if (dumper) dumper.writeChunk(chunk);
-      if (onResponse) chunks.push(chunk);
-      res.write(chunk);
+      if (onResponse || shouldBuffer) chunks.push(chunk);
+      if (!shouldBuffer) res.write(chunk);
     });
     forwardRes.on("end", () => {
+      const rawBuffer = Buffer.concat(chunks);
+
+      if (shouldBuffer) {
+        try {
+          const modified = transformResponse(rawBuffer, forwardRes.headers);
+          // Update Content-Length if present to match modified body
+          const headers = { ...forwardRes.headers };
+          if (headers["content-length"] != null) {
+            headers["content-length"] = String(Buffer.byteLength(modified));
+          }
+          res.writeHead(forwardRes.statusCode, headers);
+          res.end(modified);
+        } catch (e) {
+          err(`transformResponse error: ${e.message}`);
+          if (!res.headersSent) res.writeHead(502);
+          res.end("Bad Gateway");
+        }
+      } else {
+        res.end();
+      }
+
       if (dumper) dumper.end();
-      res.end();
-      if (onResponse) try { onResponse(Buffer.concat(chunks), forwardRes.headers); } catch { /* ignore */ }
+      if (onResponse) try { onResponse(rawBuffer, forwardRes.headers); } catch { /* ignore */ }
     });
   });
 
@@ -187,7 +382,7 @@ const server = https.createServer(sslOptions, async (req, res) => {
     }
 
     const bodyBuffer = await collectBodyRaw(req);
-    if (ENABLE_FILE_LOG) dumpRequest(req, bodyBuffer, "raw");
+    if (ENABLE_FILE_LOG && shouldDumpRequest(req)) dumpRequest(req, bodyBuffer, "raw");
 
     // Anti-loop: skip requests from 9Router
     if (req.headers[INTERNAL_REQUEST_HEADER.name] === INTERNAL_REQUEST_HEADER.value) {
@@ -197,6 +392,12 @@ const server = https.createServer(sslOptions, async (req, res) => {
     const tool = getToolForHost(req.headers.host);
     if (!tool) return passthrough(req, res, bodyBuffer);
 
+    if (tool === "antigravity" && handleLocalAntigravityBootstrap(req, res)) return;
+    if (tool === "antigravity" && req.url.includes(":loadCodeAssist")) {
+      log("🧩 loadCodeAssist MITM | passthrough inspect");
+      return passthrough(req, res, bodyBuffer, inspectAntigravityLoadCodeAssist);
+    }
+
     const patterns = URL_PATTERNS[tool] || [];
     const isChat = patterns.some(p => req.url.includes(p));
     if (!isChat) return passthrough(req, res, bodyBuffer);

package/app/src/shared/constants/mitmToolHosts.js

@@ -3,7 +3,11 @@
  * Kept in sync with MITM routing; shared by Node (dnsConfig) and dashboard UI.
  */
 const TOOL_HOSTS = {
-  antigravity: ["daily-cloudcode-pa.googleapis.com", "cloudcode-pa.googleapis.com"],
+  antigravity: [
+    "daily-cloudcode-pa.googleapis.com",
+    "cloudcode-pa.googleapis.com",
+    "daily-cloudcode-pa.sandbox.googleapis.com",
+  ],
   copilot: ["api.individual.githubcopilot.com"],
   kiro: ["q.us-east-1.amazonaws.com", "codewhisperer.us-east-1.amazonaws.com"],
   cursor: ["api2.cursor.sh"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yina-npm/openrouterx",
-  "version": "0.4.22",
+  "version": "0.4.24",
   "description": "openrouterX CLI - Start and manage 9Router server",
   "bin": {
     "openrouterX": "./cli.js"

package/src/cli/api/client.js

@@ -10,8 +10,8 @@ const DEFAULT_CONFIG = {
   protocol: "http:",
 };
 
-const CLI_TOKEN_HEADER = "x-9r-cli-token";
-const CLI_TOKEN_SALT = "9r-cli-auth";
+const CLI_TOKEN_HEADER = "x-openrouterx-cli-token";
+const CLI_TOKEN_SALT = "openrouterx-cli-auth";
 
 let config = { ...DEFAULT_CONFIG };
 let cachedCliToken = null;

package/src/cli/terminalUI.js

@@ -57,11 +57,11 @@ async function startTerminalUI(port) {
   // Configure API client
   api.configure({ port });
   
-  const basePath = ["9Router"];
+  const basePath = ["openrouterX"];
   
   // Main menu
   await showMenuWithBack({
-    title: "📡 9Router Terminal UI",
+    title: "📡 openrouterX Terminal UI",
     breadcrumb: basePath,
     headerContent: async () => await buildHeaderContent(port),
     refresh: async () => ({}), // Refresh header on each loop