npm - zevairouter - Versions diffs - 1.0.0 - Mend

zevairouter 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2011) hide show

package/src/lib/oauth/utils/server.js ADDED Viewed

@@ -0,0 +1,415 @@
+import http from "http";
+import { URL } from "url";
+/**
+ * Start a local HTTP server to receive OAuth callback
+ * @param {Function} onCallback - Called with query params when callback received
+ * @param {number} fixedPort - Optional fixed port number (default: random)
+ * @returns {Promise<{server: http.Server, port: number, close: Function}>}
+ */
+export function startLocalServer(onCallback, fixedPort = null) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname === "/callback" || url.pathname === "/auth/callback") {
+        const params = Object.fromEntries(url.searchParams);
+        // Send success response to browser with auto-close attempt
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Authentication Successful</title>
+  <style>
+    body { font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #f5f5f5; }
+    .container { text-align: center; padding: 2rem; background: white; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+    .success { color: #22c55e; font-size: 3rem; }
+    h1 { margin: 1rem 0; }
+    p { color: #666; }
+    #countdown { font-weight: bold; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="success">&#10003;</div>
+    <h1>Authentication Successful</h1>
+    <p id="message">Closing in <span id="countdown">3</span> seconds...</p>
+  </div>
+  <script>
+    let count = 3;
+    const countdown = document.getElementById("countdown");
+    const message = document.getElementById("message");
+    const timer = setInterval(() => {
+      count--;
+      countdown.textContent = count;
+      if (count <= 0) {
+        clearInterval(timer);
+        window.close();
+        setTimeout(() => {
+          message.textContent = "Please close this tab manually.";
+        }, 500);
+      }
+    }, 1000);
+  </script>
+</body>
+</html>`);
+        // Call callback with params
+        onCallback(params);
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    // Listen on fixed port or find available port
+    const portToUse = fixedPort || 0;
+    server.listen(portToUse, "127.0.0.1", () => {
+      const { port } = server.address();
+      resolve({
+        server,
+        port,
+        close: () => server.close(),
+      });
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE" && fixedPort) {
+        reject(new Error(`Port ${fixedPort} is already in use. Please close other applications using this port.`));
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+/**
+ * Wait for callback with timeout
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<Object>} - Callback params
+ */
+export function waitForCallback(timeoutMs = 300000) {
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        reject(new Error("Authentication timeout"));
+      }
+    }, timeoutMs);
+    const onCallback = (params) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve(params);
+      }
+    };
+    // Return the callback function
+    resolve.__onCallback = onCallback;
+  });
+}
+// Singleton proxy server for Codex OAuth callback on fixed port
+let codexProxyServer = null;
+let codexProxyTimeout = null;
+const CODEX_PROXY_TIMEOUT_MS = 300000; // 5 minutes
+const CODEX_PORT = 1455;
+// Pending exchange sessions keyed by state — used by server-side exchange mode
+const pendingExchanges = new Map();
+/**
+ * Register a pending exchange session for server-side mode.
+ * Modal client calls this before opening popup.
+ */
+export function registerCodexSession({ state, codeVerifier, redirectUri }) {
+  if (!state || !codeVerifier || !redirectUri) return false;
+  pendingExchanges.set(state, {
+    codeVerifier,
+    redirectUri,
+    status: "pending",
+    createdAt: Date.now(),
+  });
+  return true;
+}
+/**
+ * Read session status (modal polls this).
+ */
+export function getCodexSessionStatus(state) {
+  return pendingExchanges.get(state) || null;
+}
+/**
+ * Clear a session (called after modal consumes status).
+ */
+export function clearCodexSession(state) {
+  pendingExchanges.delete(state);
+}
+function renderCodexResultPage(success, message) {
+  const color = success ? "#22c55e" : "#ef4444";
+  const icon = success ? "&#10003;" : "&#10007;";
+  const title = success ? "Authentication Successful" : "Authentication Failed";
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${title}</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#f5f5f5}.c{text-align:center;padding:2rem;background:#fff;border-radius:8px;box-shadow:0 2px 10px rgba(0,0,0,.1)}.i{color:${color};font-size:3rem}h1{margin:1rem 0}p{color:#666}</style>
+</head><body><div class="c"><div class="i">${icon}</div><h1>${title}</h1><p>${message}</p><p>Closing in <span id="cd">3</span>s...</p>
+<script>let n=3;const c=document.getElementById("cd");const t=setInterval(()=>{n--;c.textContent=n;if(n<=0){clearInterval(t);window.close();}},1000);</script>
+</div></body></html>`;
+}
+/**
+ * Start Codex proxy on fixed port 1455.
+ * Mode A (server-side): if any session was registered, proxy auto-exchanges + saves DB.
+ * Mode B (channel fallback): if no session, proxy 302 redirects to app port for legacy channel-based flow.
+ */
+export function startCodexProxy(appPort) {
+  return new Promise((resolve) => {
+    if (codexProxyServer) {
+      resolve({ success: true });
+      return;
+    }
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, "http://localhost");
+      if (url.pathname !== "/callback" && url.pathname !== "/auth/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const errorParam = url.searchParams.get("error");
+      const session = state ? pendingExchanges.get(state) : null;
+      // Mode A: server-side exchange (session registered)
+      if (session) {
+        try {
+          if (errorParam) {
+            throw new Error(url.searchParams.get("error_description") || errorParam);
+          }
+          if (!code) throw new Error("No authorization code received");
+          // Lazy import to avoid circular deps
+          const { exchangeTokens } = await import("../providers.js");
+          const { createProviderConnection } = await import("@/models");
+          const tokenData = await exchangeTokens(
+            "codex",
+            code,
+            session.redirectUri,
+            session.codeVerifier,
+            state
+          );
+          const connection = await createProviderConnection({
+            provider: "codex",
+            authType: "oauth",
+            ...tokenData,
+            expiresAt: tokenData.expiresIn
+              ? new Date(Date.now() + tokenData.expiresIn * 1000).toISOString()
+              : null,
+            testStatus: "active",
+          });
+          session.status = "done";
+          session.connectionId = connection.id;
+          session.email = connection.email;
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(renderCodexResultPage(true, "You can close this window."));
+        } catch (err) {
+          session.status = "error";
+          session.error = err.message;
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(renderCodexResultPage(false, err.message));
+        } finally {
+          stopCodexProxy();
+        }
+        return;
+      }
+      // Mode B: legacy channel fallback — 302 redirect to app /callback
+      const redirectUrl = `http://localhost:${appPort}/callback${url.search}`;
+      res.writeHead(302, { Location: redirectUrl });
+      res.end();
+      stopCodexProxy();
+    });
+    server.listen(CODEX_PORT, "127.0.0.1", () => {
+      codexProxyServer = server;
+      codexProxyTimeout = setTimeout(() => stopCodexProxy(), CODEX_PROXY_TIMEOUT_MS);
+      resolve({ success: true });
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve({ success: false, reason: "port_busy" });
+      } else {
+        resolve({ success: false, reason: err.message });
+      }
+    });
+  });
+}
+/**
+ * Stop the Codex proxy server and cleanup
+ */
+export function stopCodexProxy() {
+  if (codexProxyTimeout) {
+    clearTimeout(codexProxyTimeout);
+    codexProxyTimeout = null;
+  }
+  if (codexProxyServer) {
+    codexProxyServer.close();
+    codexProxyServer = null;
+  }
+}
+// ───────────────────────────────────────────────────────────────────────────
+// xAI fixed-port proxy on 127.0.0.1:56121
+// Same shape as the Codex proxy. Kept as a parallel implementation rather than
+// generalizing the Codex one to keep the codex hot-path byte-equivalent.
+// ───────────────────────────────────────────────────────────────────────────
+let xaiProxyServer = null;
+let xaiProxyTimeout = null;
+const XAI_PROXY_TIMEOUT_MS = 300000; // 5 minutes
+const XAI_PROXY_PORT = 56121;
+const xaiPendingExchanges = new Map();
+export function registerXaiSession({ state, codeVerifier, redirectUri }) {
+  if (!state || !codeVerifier || !redirectUri) return false;
+  xaiPendingExchanges.set(state, {
+    codeVerifier,
+    redirectUri,
+    status: "pending",
+    createdAt: Date.now(),
+  });
+  return true;
+}
+export function getXaiSessionStatus(state) {
+  return xaiPendingExchanges.get(state) || null;
+}
+export function clearXaiSession(state) {
+  xaiPendingExchanges.delete(state);
+}
+function renderXaiResultPage(success, message) {
+  return renderCodexResultPage(success, message);
+}
+/**
+ * Start xAI proxy on fixed port 56121.
+ * Mode A (server-side): if any session was registered, proxy auto-exchanges + saves DB.
+ * Mode B (channel fallback): if no session, proxy 302 redirects to app port.
+ */
+export function startXaiProxy(appPort) {
+  return new Promise((resolve) => {
+    if (xaiProxyServer) {
+      resolve({ success: true });
+      return;
+    }
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, "http://localhost");
+      if (url.pathname !== "/callback" && url.pathname !== "/auth/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const errorParam = url.searchParams.get("error");
+      const session = state ? xaiPendingExchanges.get(state) : null;
+      // Mode A: server-side exchange
+      if (session) {
+        try {
+          if (errorParam) {
+            throw new Error(url.searchParams.get("error_description") || errorParam);
+          }
+          if (!code) throw new Error("No authorization code received");
+          const { exchangeTokens } = await import("../providers.js");
+          const { createProviderConnection } = await import("@/models");
+          const tokenData = await exchangeTokens(
+            "xai",
+            code,
+            session.redirectUri,
+            session.codeVerifier,
+            state
+          );
+          const connection = await createProviderConnection({
+            provider: "xai",
+            authType: "oauth",
+            ...tokenData,
+            expiresAt: tokenData.expiresIn
+              ? new Date(Date.now() + tokenData.expiresIn * 1000).toISOString()
+              : null,
+            testStatus: "active",
+          });
+          session.status = "done";
+          session.connectionId = connection.id;
+          session.email = connection.email;
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(renderXaiResultPage(true, "You can close this window."));
+        } catch (err) {
+          session.status = "error";
+          session.error = err.message;
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(renderXaiResultPage(false, err.message));
+        } finally {
+          stopXaiProxy();
+        }
+        return;
+      }
+      // Mode B: legacy fallback redirect
+      const redirectUrl = `http://localhost:${appPort}/callback${url.search}`;
+      res.writeHead(302, { Location: redirectUrl });
+      res.end();
+      stopXaiProxy();
+    });
+    server.listen(XAI_PROXY_PORT, "127.0.0.1", () => {
+      xaiProxyServer = server;
+      xaiProxyTimeout = setTimeout(() => stopXaiProxy(), XAI_PROXY_TIMEOUT_MS);
+      resolve({ success: true });
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve({ success: false, reason: "port_busy" });
+      } else {
+        resolve({ success: false, reason: err.message });
+      }
+    });
+  });
+}
+export function stopXaiProxy() {
+  if (xaiProxyTimeout) {
+    clearTimeout(xaiProxyTimeout);
+    xaiProxyTimeout = null;
+  }
+  if (xaiProxyServer) {
+    xaiProxyServer.close();
+    xaiProxyServer = null;
+  }
+}

package/src/lib/oauth/utils/ui.js ADDED Viewed

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import ora from "ora";
+/**
+ * UI Helper Functions
+ */
+export function success(message) {
+  console.log(chalk.green(`\n✓ ${message}\n`));
+}
+export function error(message) {
+  console.log(chalk.red(`\n✗ ${message}\n`));
+}
+export function info(message) {
+  console.log(chalk.blue(`\n${message}\n`));
+}
+export function warn(message) {
+  console.log(chalk.yellow(`\n⚠ ${message}\n`));
+}
+export function gray(message) {
+  console.log(chalk.gray(message));
+}
+export function spinner(text) {
+  return ora(text);
+}
+export function printSection(title) {
+  console.log(chalk.blue(`\n${title}\n`));
+}
+export function printKeyValue(key, value, isSuccess = false) {
+  const color = isSuccess ? chalk.green : chalk.gray;
+  console.log(color(`  ${key}: ${value}`));
+}
+export function printList(items, isSuccess = false) {
+  const symbol = isSuccess ? "✓" : "✗";
+  const color = isSuccess ? chalk.green : chalk.gray;
+  items.forEach((item) => {
+    console.log(color(`  ${symbol} ${item}`));
+  });
+}

package/src/lib/providerNormalization.js ADDED Viewed

@@ -0,0 +1,45 @@
+import { AI_PROVIDERS } from "../shared/constants/providers.js";
+/**
+ * Detect xAI Grok models by id pattern (grok-*, Grok_*, etc).
+ * @param {string} modelId
+ * @returns {boolean}
+ */
+export function isXaiModel(modelId) {
+  return typeof modelId === "string" && /^grok[-_]/i.test(modelId.trim());
+}
+export function normalizeProviderId(provider) {
+  if (typeof provider !== "string") return provider;
+  const trimmed = provider.trim();
+  if (AI_PROVIDERS[trimmed]) return trimmed;
+  const slug = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  if (AI_PROVIDERS[slug]) return slug;
+  const providerByName = Object.values(AI_PROVIDERS).find(
+    (entry) => entry.name?.toLowerCase() === trimmed.toLowerCase()
+  );
+  return providerByName?.id || trimmed;
+}
+export function normalizeProviderSpecificData(provider, body = {}, providerSpecificData = null) {
+  const next = providerSpecificData && typeof providerSpecificData === "object"
+    ? { ...providerSpecificData }
+    : {};
+  if (provider === "ollama-local") {
+    const baseUrl = (
+      next.baseUrl ||
+      body.baseUrl ||
+      body.baseURL ||
+      body.ollamaHostUrl ||
+      ""
+    ).trim();
+    if (baseUrl) next.baseUrl = baseUrl;
+  }
+  return Object.keys(next).length > 0 ? next : null;
+}

package/src/lib/qoder/constants.js ADDED Viewed

@@ -0,0 +1,64 @@
+/**
+ * Qoder API constants ported from CLIProxyAPIPlus qoder-provider branch.
+ *
+ * Endpoint set:
+ *   openapi.qoder.sh   - device flow + userinfo + quota usage
+ *   center.qoder.sh    - token refresh (best-effort, currently 403 for device tokens)
+ *   api3.qoder.sh      - inference (chat) + model list, requires COSY signing
+ *   qoder.com/device   - browser landing page for device authorization
+ */
+export const QODER_OPENAPI_BASE = "https://openapi.qoder.sh";
+export const QODER_CENTER_BASE = "https://center.qoder.sh";
+export const QODER_CHAT_BASE = "https://api3.qoder.sh";
+export const QODER_LOGIN_URL = "https://qoder.com/device/selectAccounts";
+// Device flow endpoints
+export const QODER_DEVICE_TOKEN_URL = `${QODER_OPENAPI_BASE}/api/v1/deviceToken/poll`;
+export const QODER_USERINFO_URL = `${QODER_OPENAPI_BASE}/api/v1/userinfo`;
+export const QODER_QUOTA_USAGE_URL = `${QODER_OPENAPI_BASE}/api/v2/quota/usage`;
+export const QODER_REFRESH_TOKEN_URL = `${QODER_CENTER_BASE}/algo/api/v3/user/refresh_token`;
+// Inference endpoints (under /algo on api3.qoder.sh, all COSY-signed)
+export const QODER_CHAT_SIG_PATH = "/api/v2/service/pro/sse/agent_chat_generation";
+export const QODER_CHAT_URL = `${QODER_CHAT_BASE}/algo${QODER_CHAT_SIG_PATH}?FetchKeys=llm_model_result&AgentId=agent_common`;
+export const QODER_CHAT_URL_ENCODED = `${QODER_CHAT_URL}&Encode=1`;
+export const QODER_MODEL_LIST_URL = `${QODER_CHAT_BASE}/algo/api/v2/model/list`;
+// COSY header constants. These are not arbitrary — the upstream signature
+// validation matches them against the values used at signing time.
+export const QODER_IDE_VERSION = "1.0.0";
+export const QODER_CLIENT_TYPE = "5";
+export const QODER_DATA_POLICY = "disagree";
+export const QODER_LOGIN_VERSION = "v2";
+export const QODER_MACHINE_OS = "x86_64_windows";
+export const QODER_MACHINE_TYPE = "5";
+// Canonical model identifiers. Identity map — keep as a map so callers can
+// cheaply test "is this a known qoder model?" before sending the request.
+export const QODER_MODEL_MAP = {
+  // Tier models
+  auto: "auto",
+  ultimate: "ultimate",
+  performance: "performance",
+  efficient: "efficient",
+  lite: "lite",
+  // Frontier models
+  qmodel: "qmodel",
+  qmodel_latest: "qmodel_latest",
+  dmodel: "dmodel",
+  dfmodel: "dfmodel",
+  gm51model: "gm51model",
+  kmodel: "kmodel",
+  mmodel: "mmodel",
+};
+// RSA public key for COSY encryption (extracted from Qoder IDE v0.9).
+// Matches the CLIProxyAPIPlus branch and live qodercli traffic.
+export const QODER_RSA_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;