swayrouter 1.0.0

package/src/services/cursorModels.js

@@ -0,0 +1,197 @@
+import crypto from "crypto";
+import http2 from "http2";
+import { PROVIDER_OAUTH } from "../providers/index.js";
+import { buildCursorHeaders } from "../utils/cursorChecksum.js";
+import { decodeMessage } from "../utils/cursorProtobuf.js";
+
+const FETCH_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const FAILURE_BACKOFF_MS = 10 * 60 * 1000;
+
+const MODEL_ID_FIELD = 1;
+const DISPLAY_MODEL_ID_FIELD = 3;
+const DISPLAY_NAME_FIELD = 4;
+const DISPLAY_NAME_SHORT_FIELD = 5;
+const RESPONSE_MODELS_FIELD = 1;
+
+const catalogCache = new Map();
+const failureCache = new Map();
+
+function getCursorModelsUrl() {
+  const config = PROVIDER_OAUTH.cursor;
+  if (!config?.agentEndpoint || !config?.modelsEndpoint) return null;
+  return `${config.agentEndpoint.replace(/\/$/, "")}${config.modelsEndpoint}`;
+}
+
+function cacheKey(credentials) {
+  const seed = [
+    credentials?.providerSpecificData?.machineId,
+    credentials?.accessToken,
+  ].filter(Boolean).join(":");
+  if (!seed) return "cursor-anonymous";
+  return crypto.createHash("sha256").update(`cursor:${seed}`).digest("hex");
+}
+
+function firstString(fields, fieldNumber) {
+  const value = fields.get(fieldNumber)?.[0]?.value;
+  if (!value || typeof value === "number") return "";
+  return Buffer.from(value).toString("utf8");
+}
+
+export function parseCursorUsableModels(payload) {
+  const response = decodeMessage(payload);
+  const seen = new Set();
+  const models = [];
+
+  for (const entry of response.get(RESPONSE_MODELS_FIELD) || []) {
+    if (!entry?.value || typeof entry.value === "number") continue;
+    const detail = decodeMessage(entry.value);
+    const id = firstString(detail, MODEL_ID_FIELD).trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+
+    const name = (
+      firstString(detail, DISPLAY_NAME_FIELD)
+      || firstString(detail, DISPLAY_NAME_SHORT_FIELD)
+      || firstString(detail, DISPLAY_MODEL_ID_FIELD)
+      || id
+    ).trim();
+    models.push({ id, name });
+  }
+
+  return models;
+}
+
+function http2PostProto(url, headers, body, signal, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const client = http2.connect(`https://${urlObj.host}`);
+    const chunks = [];
+    let responseHeaders = {};
+    let settled = false;
+
+    const finish = (fn) => (...args) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      try { client.close(); } catch {}
+      fn(...args);
+    };
+
+    const timeoutId = setTimeout(finish(() => {
+      reject(new Error("Cursor GetUsableModels timed out"));
+    }), timeoutMs);
+
+    client.on("error", finish(reject));
+
+    const req = client.request({
+      ":method": "POST",
+      ":path": urlObj.pathname,
+      ":authority": urlObj.host,
+      ":scheme": "https",
+      ...headers,
+    });
+
+    req.on("response", (hdrs) => { responseHeaders = hdrs; });
+    req.on("data", (chunk) => { chunks.push(chunk); });
+    req.on("end", finish(() => {
+      resolve({
+        status: Number(responseHeaders[":status"] || 0),
+        body: Buffer.concat(chunks),
+      });
+    }));
+    req.on("error", finish(reject));
+
+    if (signal) {
+      const onAbort = finish(() => reject(new Error("Request aborted")));
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    req.end(body && body.length ? Buffer.from(body) : undefined);
+  });
+}
+
+async function fetchCursorCatalog(credentials, signal) {
+  const accessToken = credentials?.accessToken;
+  const machineId = credentials?.providerSpecificData?.machineId;
+  const url = getCursorModelsUrl();
+  if (!accessToken || !machineId || !url) return null;
+
+  const headers = {
+    ...buildCursorHeaders(accessToken, machineId, credentials?.providerSpecificData?.ghostMode !== false),
+
+    accept: "application/proto",
+    "content-type": "application/proto",
+  };
+  delete headers["connect-accept-encoding"];
+  delete headers["connect-protocol-version"];
+
+  const response = await http2PostProto(url, headers, new Uint8Array(), signal, FETCH_TIMEOUT_MS);
+  if (response.status !== 200) {
+    const error = new Error(`Cursor GetUsableModels returned ${response.status}`);
+    error.status = response.status;
+    throw error;
+  }
+
+  return parseCursorUsableModels(new Uint8Array(response.body));
+}
+
+export async function resolveCursorModels(credentials, options = {}) {
+  if (!credentials?.accessToken || !credentials?.providerSpecificData?.machineId) {
+    options.log?.debug?.("CURSOR_MODELS", "No Cursor access token or machine ID; skipping live fetch");
+    return null;
+  }
+
+  const key = cacheKey(credentials);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached?.expiresAt > now) return { models: cached.models };
+
+    const failure = failureCache.get(key);
+    if (failure?.expiresAt > now) {
+      return {
+        models: null,
+        credentialStatus: failure.status === 401 ? "stale" : "unavailable",
+        warning: failure.warning,
+      };
+    }
+    if (failure) failureCache.delete(key);
+  }
+
+  try {
+    const models = await fetchCursorCatalog(credentials, options.signal);
+    if (!models?.length) return null;
+    catalogCache.set(key, { expiresAt: now + CACHE_TTL_MS, models });
+    failureCache.delete(key);
+    return { models };
+  } catch (error) {
+    const status = Number(error?.status || 0);
+    const isCredentialFailure = status === 401;
+    const warning = isCredentialFailure
+      ? "Cursor credentials were rejected (401); re-authenticate Cursor. Using the static model catalog until the cooldown expires."
+      : `Cursor live model fetch failed; using the static model catalog until the next refresh.`;
+
+    if (isCredentialFailure) {
+      failureCache.set(key, {
+        expiresAt: Date.now() + FAILURE_BACKOFF_MS,
+        status,
+        warning,
+      });
+      try {
+        await options.onAuthFailure?.({ status, error, retryAt: new Date(Date.now() + FAILURE_BACKOFF_MS).toISOString() });
+      } catch (persistError) {
+        options.log?.debug?.("CURSOR_MODELS", `Failed to persist Cursor stale status: ${persistError?.message || persistError}`);
+      }
+    }
+
+    options.log?.warn?.("CURSOR_MODELS", `${error?.message || error}${isCredentialFailure ? "; re-authenticate Cursor credentials" : ""}`);
+    return { models: null, credentialStatus: isCredentialFailure ? "stale" : "unavailable", warning };
+  }
+}
+
+export function clearCursorModelCache() {
+  catalogCache.clear();
+  failureCache.clear();
+}

package/src/services/grokCliModels.js

@@ -0,0 +1,130 @@
+import {
+  GROK_CLI_BASE_URL,
+  GROK_CLI_CLIENT_IDENTIFIER,
+  GROK_CLI_MODEL,
+  GROK_CLI_USER_AGENT,
+  GROK_CLI_VERSION,
+} from "../config/grokCli.js";
+import { refreshProviderCredentials } from "./oauthCredentialManager.js";
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+
+const MODELS_URL = `${GROK_CLI_BASE_URL}/models`;
+
+function modelEntries(data) {
+  const value = Array.isArray(data) ? data : data?.data ?? data?.models ?? data?.results ?? [];
+  if (Array.isArray(value)) return value.map((item) => [null, item]);
+  if (value && typeof value === "object") return Object.entries(value);
+  return [];
+}
+
+function readModelId(item, fallback) {
+  return String(
+    item.id ?? item.model_id ?? item.modelId ?? item.model ?? item.slug ?? fallback ?? item.name ?? "",
+  ).trim();
+}
+
+function addPositiveNumber(target, key, value) {
+  const number = Number(value);
+  if (Number.isFinite(number) && number > 0) target[key] = number;
+}
+
+export function parseGrokCliModels(data) {
+  const seen = new Set();
+  const models = [];
+
+  for (const [key, raw] of modelEntries(data)) {
+    const item = typeof raw === "string" ? { id: raw } : raw;
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const id = readModelId(item, key);
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+
+    const model = {
+      ...item,
+      id,
+      name: item.display_name ?? item.displayName ?? item.name ?? id,
+    };
+    addPositiveNumber(model, "contextLength", item.context_length ?? item.contextLength ?? item.context_window ?? item.contextWindow);
+    addPositiveNumber(model, "maxOutputTokens", item.max_output_tokens ?? item.maxOutputTokens);
+    if (id === GROK_CLI_MODEL) {
+      model.contextLength ||= 500000;
+      model.maxOutputTokens ||= 64000;
+    }
+    models.push(model);
+  }
+
+  return models;
+}
+
+function buildHeaders(accessToken, providerSpecificData = {}) {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    Accept: "application/json",
+    "User-Agent": GROK_CLI_USER_AGENT,
+    "x-xai-token-auth": "xai-grok-cli",
+    "x-grok-client-version": GROK_CLI_VERSION,
+    "x-grok-client-identifier": GROK_CLI_CLIENT_IDENTIFIER,
+    "x-grok-client-mode": "headless",
+  };
+  const email = providerSpecificData?.email;
+  const userId = providerSpecificData?.userId || providerSpecificData?.principalId;
+  if (email) headers["x-email"] = email;
+  if (userId) headers["x-userid"] = userId;
+  return headers;
+}
+
+export async function resolveGrokCliModels(credentials, options = {}) {
+  const {
+    fetchFn = proxyAwareFetch,
+    log = console,
+    proxyOptions = null,
+    onCredentialsRefreshed,
+  } = options;
+  let accessToken = credentials?.accessToken;
+  if (!accessToken) return { models: [], warning: "Grok CLI access token is missing." };
+
+  const request = (token) => fetchFn(
+    MODELS_URL,
+    {
+      method: "GET",
+      headers: buildHeaders(token, credentials?.providerSpecificData),
+    },
+    proxyOptions,
+  );
+
+  try {
+    let response = await request(accessToken);
+    if ((response.status === 401 || response.status === 403) && credentials?.refreshToken) {
+      const refreshed = await refreshProviderCredentials(
+        "grok-cli",
+        credentials,
+        log,
+        proxyOptions,
+      );
+      if (refreshed?.accessToken) {
+        accessToken = refreshed.accessToken;
+        try {
+          await onCredentialsRefreshed?.(refreshed);
+        } catch (error) {
+          log?.warn?.("Grok CLI credential persistence failed", error);
+        }
+        response = await request(accessToken);
+      }
+    }
+
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      return {
+        models: [],
+        warning: `Grok CLI model discovery failed (${response.status})${detail ? `: ${detail.slice(0, 160)}` : ""}`,
+      };
+    }
+
+    const models = parseGrokCliModels(await response.json());
+    return models.length
+      ? { models }
+      : { models: [], warning: "Grok CLI returned no selectable models." };
+  } catch (error) {
+    return { models: [], warning: `Grok CLI model discovery failed: ${error.message}` };
+  }
+}

package/src/services/kimchiModels.js

@@ -0,0 +1,175 @@
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+
+export const KIMCHI_API = "https://llm.kimchi.dev";
+export const KIMCHI_USER_AGENT = "kimchi/0.1.40";
+
+const FETCH_TIMEOUT_MS = 20_000;
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+
+const catalogCache = new Map();
+
+const metadataByModelId = new Map();
+
+function normalizeKimchiEndpoint(endpoint) {
+  const raw = typeof endpoint === "string" ? endpoint.trim() : "";
+  return (raw || KIMCHI_API).replace(/\/+$/, "");
+}
+
+export function buildKimchiModelsUrl(endpoint) {
+  return `${normalizeKimchiEndpoint(endpoint)}/v1/models/metadata?include_in_cli=true`;
+}
+
+function readToken(credentials) {
+  return (
+    credentials?.accessToken
+    || credentials?.apiKey
+    || credentials?.providerSpecificData?.apiKey
+    || null
+  );
+}
+
+function cacheKey(credentials, endpoint) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || psd.username || credentials?.refreshToken || readToken(credentials) || "anonymous";
+  return createHash("sha256")
+    .update(`kimchi:${normalizeKimchiEndpoint(endpoint)}:${seed}`)
+    .digest("hex");
+}
+
+function toModelKind(inputModalities) {
+  return Array.isArray(inputModalities) && inputModalities.includes("image")
+    ? "imageToText"
+    : "llm";
+}
+
+export function normalizeKimchiModel(item) {
+  if (!item || typeof item !== "object") return null;
+  const id = item.slug || item.id || item.model || item.name;
+  if (typeof id !== "string" || id.trim() === "") return null;
+
+  const inputModalities = Array.isArray(item.input_modalities)
+    ? item.input_modalities.filter((value) => value === "text" || value === "image")
+    : [];
+  const limits = item.limits && typeof item.limits === "object" ? item.limits : {};
+  const contextLength = Number(limits.context_window || item.contextLength || item.context_length) || undefined;
+  const maxOutputTokens = Number(limits.max_output_tokens || item.maxOutputTokens || item.max_output_tokens) || undefined;
+  const upstreamProvider = typeof item.provider === "string" ? item.provider : "";
+  const reasoning = item.reasoning === true;
+  const kind = toModelKind(inputModalities);
+
+  const model = {
+    ...item,
+    id: id.trim(),
+    name: String(item.display_name || item.displayName || item.name || id).trim(),
+    provider: upstreamProvider,
+    upstreamProvider,
+    reasoning,
+    inputModalities,
+    kind,
+    type: kind,
+    capabilities: {
+      vision: inputModalities.includes("image"),
+      reasoning,
+      ...(contextLength ? { contextWindow: contextLength } : {}),
+      ...(maxOutputTokens ? { maxOutput: maxOutputTokens } : {}),
+      ...(upstreamProvider ? { upstreamProvider } : {}),
+    },
+    ...(contextLength ? { contextLength } : {}),
+    ...(maxOutputTokens ? { maxOutputTokens } : {}),
+  };
+
+  if (upstreamProvider === "anthropic") {
+    model.compat = { supportsReasoningEffort: false, cacheControlFormat: "anthropic" };
+  }
+
+  return model;
+}
+
+function rememberModels(models) {
+  for (const model of models || []) {
+    if (!model?.id) continue;
+    metadataByModelId.set(model.id, model);
+    metadataByModelId.set(model.id.toLowerCase(), model);
+  }
+}
+
+export function getCachedKimchiModelMetadata(modelId) {
+  if (typeof modelId !== "string" || modelId.trim() === "") return null;
+  const raw = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+  return metadataByModelId.get(raw) || metadataByModelId.get(raw.toLowerCase()) || null;
+}
+
+async function fetchKimchiCatalogRaw(token, endpoint, options = {}) {
+  const url = buildKimchiModelsUrl(endpoint);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(new Error("Kimchi models fetch timeout")), FETCH_TIMEOUT_MS);
+  const signal = options.signal
+    ? AbortSignal.any([options.signal, controller.signal])
+    : controller.signal;
+
+  try {
+    const response = await proxyAwareFetch(url, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${token}`,
+        "User-Agent": KIMCHI_USER_AGENT,
+      },
+      cache: "no-store",
+      signal,
+    }, options.proxyOptions || null);
+
+    if (!response.ok) {
+      const error = new Error(`Kimchi models ${response.status}: ${response.statusText}`);
+      error.status = response.status;
+      error.retryable = RETRYABLE_STATUSES.has(response.status);
+      throw error;
+    }
+
+    const data = await response.json();
+    return Array.isArray(data?.models) ? data.models : [];
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function resolveKimchiModels(credentials, options = {}) {
+  const token = readToken(credentials);
+  if (!token) return null;
+
+  const endpoint = credentials?.providerSpecificData?.kimchiEndpoint || options.endpoint || KIMCHI_API;
+  const key = cacheKey(credentials, endpoint);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) return cached;
+  }
+
+  let rawModels;
+  try {
+    rawModels = await fetchKimchiCatalogRaw(token, endpoint, options);
+  } catch (error) {
+    options.log?.warn?.("KIMCHI_MODELS", error.message);
+    return null;
+  }
+
+  const models = rawModels.map(normalizeKimchiModel).filter(Boolean);
+  if (models.length === 0) return null;
+
+  rememberModels(models);
+  const entry = {
+    expiresAt: Date.now() + CACHE_TTL_MS,
+    models,
+    rawModels,
+  };
+  catalogCache.set(key, entry);
+  return entry;
+}
+
+export function clearKimchiCatalog() {
+  catalogCache.clear();
+  metadataByModelId.clear();
+}