swayrouter 1.0.0

package/src/services/projectId.js

@@ -0,0 +1,240 @@
+import { CLOUD_CODE_API, LOAD_CODE_ASSIST_HEADERS, ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS, LOAD_CODE_ASSIST_METADATA } from "../config/appConstants.js";
+
+const projectIdCache = new Map();
+
+const CACHE_TTL_MS = 60 * 60 * 1000;
+
+const pendingFetches = new Map();
+
+const PENDING_TTL_MS = 2 * 60 * 1000;
+
+const CLEANUP_INTERVAL_MS = 10 * 60 * 1000;
+
+let _cleanupTimer = null;
+
+export function cleanupNow() {
+    const now = Date.now();
+
+    for (const [id, entry] of projectIdCache) {
+        if (!entry || now - entry.fetchedAt >= CACHE_TTL_MS) {
+            projectIdCache.delete(id);
+        }
+    }
+
+    for (const [id, item] of pendingFetches) {
+        if (!item || typeof item.startedAt !== "number") {
+            pendingFetches.delete(id);
+            continue;
+        }
+        if (now - item.startedAt > PENDING_TTL_MS) {
+            try { item.controller.abort(); } catch (_) {              }
+            pendingFetches.delete(id);
+        }
+    }
+}
+
+export function startCacheCleanup() {
+    if (_cleanupTimer) return;
+    _cleanupTimer = setInterval(() => {
+        try { cleanupNow(); } catch (e) {
+            console.warn("[ProjectId] cleanup sweep error:", e?.message ?? e);
+        }
+    }, CLEANUP_INTERVAL_MS);
+
+    _cleanupTimer?.unref?.();
+}
+
+export function stopCacheCleanup() {
+    if (!_cleanupTimer) return;
+    clearInterval(_cleanupTimer);
+    _cleanupTimer = null;
+}
+
+startCacheCleanup();
+
+export async function getProjectIdForConnection(connectionId, accessToken, provider = "gemini-cli") {
+    if (!connectionId || !accessToken) return null;
+
+    const cached = projectIdCache.get(connectionId);
+    if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+        return cached.projectId;
+    }
+
+    if (pendingFetches.has(connectionId)) {
+        return pendingFetches.get(connectionId).promise;
+    }
+
+    const controller = new AbortController();
+
+    const promise = (async () => {
+        try {
+            const projectId = await fetchProjectId(accessToken, controller.signal, provider);
+            if (projectId) {
+                projectIdCache.set(connectionId, {projectId, fetchedAt: Date.now()});
+                return projectId;
+            }
+            console.warn("[ProjectId] could not fetch projectId for connection", connectionId.slice(0, 8));
+            return null;
+        } catch (error) {
+            console.warn(`[ProjectId] Error fetching project ID: ${error.message}`);
+            return null;
+        } finally {
+            pendingFetches.delete(connectionId);
+        }
+    })();
+
+    pendingFetches.set(connectionId, {promise, controller, startedAt: Date.now()});
+    return promise;
+}
+
+export function invalidateProjectId(connectionId) {
+    projectIdCache.delete(connectionId);
+}
+
+export function removeConnection(connectionId) {
+    if (!connectionId) return;
+    projectIdCache.delete(connectionId);
+    const pending = pendingFetches.get(connectionId);
+    if (pending) {
+        try { pending.controller.abort(); } catch (_) {              }
+        pendingFetches.delete(connectionId);
+    }
+}
+
+async function fetchProjectId(accessToken, signal, provider) {
+    const endpoints = CLOUD_CODE_API[provider] || CLOUD_CODE_API["gemini-cli"];
+    const headers = provider === "antigravity" ? ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS : LOAD_CODE_ASSIST_HEADERS;
+    const response = await fetch(endpoints.loadCodeAssist, {
+        method: "POST",
+        headers: { ...headers, "Authorization": `Bearer ${accessToken}` },
+        body: JSON.stringify({ metadata: LOAD_CODE_ASSIST_METADATA }),
+        signal
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`loadCodeAssist failed: HTTP ${response.status} ${errorText.slice(0, 200)}`);
+    }
+
+    const data = await response.json();
+    const projectId = extractProjectId(data);
+    if (projectId) return projectId;
+
+    let tierID = "legacy-tier";
+    if (Array.isArray(data.allowedTiers)) {
+        for (const tier of data.allowedTiers) {
+            if (tier && typeof tier === "object" && tier.isDefault === true) {
+                if (tier.id && typeof tier.id === "string" && tier.id.trim()) {
+                    tierID = tier.id.trim();
+                    break;
+                }
+            }
+        }
+    }
+
+    return onboardUser(accessToken, tierID, signal, endpoints, provider);
+}
+
+async function onboardUser(accessToken, tierID, externalSignal, endpoints, provider) {
+    console.log(`[ProjectId] Onboarding user with tier: ${tierID}`);
+
+    const reqBody = { tierId: tierID, metadata: LOAD_CODE_ASSIST_METADATA };
+    const headers = provider === "antigravity" ? ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS : LOAD_CODE_ASSIST_HEADERS;
+    const MAX_ATTEMPTS = 5;
+
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+
+        if (externalSignal?.aborted) return null;
+
+        const localCtrl = new AbortController();
+        const timeoutId = setTimeout(() => localCtrl.abort(), 30_000);
+        const forwardAbort = () => localCtrl.abort();
+        externalSignal?.addEventListener("abort", forwardAbort);
+
+        try {
+            const response = await fetch(endpoints.onboardUser, {
+                method: "POST",
+                headers: { ...headers, "Authorization": `Bearer ${accessToken}` },
+                body: JSON.stringify(reqBody),
+                signal: localCtrl.signal
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`onboardUser HTTP ${response.status}: ${errorText.slice(0, 200)}`);
+            }
+
+            const data = await response.json();
+
+            if (data.done === true) {
+                const projectId = extractProjectIdFromOnboard(data);
+                if (projectId) {
+                    console.log(`[ProjectId] Successfully onboarded, project ID: ${projectId}`);
+                    return projectId;
+                }
+
+                console.warn("[ProjectId] onboardUser completed without project_id; using fallback");
+                return null;
+            }
+
+            console.log(`[ProjectId] Onboard attempt ${attempt}/${MAX_ATTEMPTS}: not done yet, waiting...`);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+
+        } catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === "AbortError") {
+                console.warn(`[ProjectId] onboardUser attempt ${attempt} aborted (timeout or connection removed)`);
+                if (externalSignal?.aborted) return null;
+                continue;
+            }
+            if (attempt === MAX_ATTEMPTS) {
+                console.warn(`[ProjectId] onboardUser failed after ${MAX_ATTEMPTS} attempts: ${error.message}`);
+                return null;
+            }
+
+            console.warn(`[ProjectId] onboardUser attempt ${attempt} failed: ${error.message}, retrying...`);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        } finally {
+            clearTimeout(timeoutId);
+            externalSignal?.removeEventListener("abort", forwardAbort);
+        }
+    }
+
+    return null;
+}
+
+function extractProjectId(data) {
+    if (!data) return null;
+
+    if (typeof data.cloudaicompanionProject === "string") {
+        const id = data.cloudaicompanionProject.trim();
+        if (id) return id;
+    }
+
+    if (data.cloudaicompanionProject && typeof data.cloudaicompanionProject === "object") {
+        const id = data.cloudaicompanionProject.id;
+        if (typeof id === "string" && id.trim()) return id.trim();
+    }
+
+    return null;
+}
+
+function extractProjectIdFromOnboard(data) {
+    if (!data?.response) return null;
+
+    const project = data.response.cloudaicompanionProject;
+
+    if (typeof project === "string") {
+        const id = project.trim();
+        if (id) return id;
+    }
+
+    if (project && typeof project === "object") {
+        const id = project.id;
+        if (typeof id === "string" && id.trim()) return id.trim();
+    }
+
+    return null;
+}

package/src/services/provider.js

@@ -0,0 +1,145 @@
+import { PROVIDERS } from "../config/providers.js";
+import { OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE } from "../providers/shared.js";
+
+const OPENAI_COMPATIBLE_PREFIX = "openai-compatible-";
+const OPENAI_COMPATIBLE_DEFAULTS = {
+  baseUrl: OPENAI_COMPAT_BASE,
+};
+
+const ANTHROPIC_COMPATIBLE_PREFIX = "anthropic-compatible-";
+const ANTHROPIC_COMPATIBLE_DEFAULTS = {
+  baseUrl: ANTHROPIC_COMPAT_BASE,
+};
+
+function isOpenAICompatible(provider) {
+  return typeof provider === "string" && provider.startsWith(OPENAI_COMPATIBLE_PREFIX);
+}
+
+function isAnthropicCompatible(provider) {
+  return typeof provider === "string" && provider.startsWith(ANTHROPIC_COMPATIBLE_PREFIX);
+}
+
+export function resolveOpenAICompatibleApiType(provider, credentials = null) {
+  const stored = credentials?.providerSpecificData?.apiType;
+  if (stored === "chat" || stored === "responses") return stored;
+  return typeof provider === "string" && provider.includes("responses") ? "responses" : "chat";
+}
+
+export function detectFormat(body) {
+
+  if (body.input && (Array.isArray(body.input) || typeof body.input === "string") && !body.messages) {
+    return "openai-responses";
+  }
+
+  if (body.request?.contents && body.userAgent === "antigravity") {
+    return "antigravity";
+  }
+
+  if (body.contents && Array.isArray(body.contents)) {
+    return "gemini";
+  }
+
+  if (
+    body.stream_options ||
+    body.response_format ||
+    body.logprobs !== undefined ||
+    body.top_logprobs !== undefined ||
+    body.n !== undefined ||
+    body.presence_penalty !== undefined ||
+    body.frequency_penalty !== undefined ||
+    body.logit_bias ||
+    body.user
+  ) {
+    return "openai";
+  }
+
+  if (body.messages && Array.isArray(body.messages)) {
+    const firstMsg = body.messages[0];
+
+    if (firstMsg?.content && Array.isArray(firstMsg.content)) {
+      const firstContent = firstMsg.content[0];
+
+      if (firstContent?.type === "text" && !body.model?.includes("/")) {
+
+        if (body.system || body.anthropic_version) {
+          return "claude";
+        }
+
+        const hasClaudeImage = firstMsg.content.some(c =>
+          c.type === "image" && c.source?.type === "base64"
+        );
+        const hasOpenAIImage = firstMsg.content.some(c =>
+          c.type === "image_url" && c.image_url?.url
+        );
+        if (hasClaudeImage) return "claude";
+        if (hasOpenAIImage) return "openai";
+
+        const hasClaudeTool = firstMsg.content.some(c =>
+          c.type === "tool_use" || c.type === "tool_result"
+        );
+        if (hasClaudeTool) return "claude";
+      }
+    }
+
+    if (body.system !== undefined || body.anthropic_version) {
+      return "claude";
+    }
+  }
+
+  return "openai";
+}
+
+function getProviderConfig(provider, credentials = null) {
+  if (isOpenAICompatible(provider)) {
+    const apiType = resolveOpenAICompatibleApiType(provider, credentials);
+    return {
+      ...PROVIDERS.openai,
+      format: apiType === "responses" ? "openai-responses" : "openai",
+      baseUrl: OPENAI_COMPATIBLE_DEFAULTS.baseUrl,
+    };
+  }
+  if (isAnthropicCompatible(provider)) {
+    return {
+      ...PROVIDERS.anthropic,
+      format: "claude",
+      baseUrl: ANTHROPIC_COMPATIBLE_DEFAULTS.baseUrl,
+    };
+  }
+  return PROVIDERS[provider] || PROVIDERS.openai;
+}
+
+export function getTargetFormat(provider, credentials = null) {
+  if (isOpenAICompatible(provider)) {
+    return resolveOpenAICompatibleApiType(provider, credentials) === "responses" ? "openai-responses" : "openai";
+  }
+  if (isAnthropicCompatible(provider)) {
+    return "claude";
+  }
+  const config = getProviderConfig(provider, credentials);
+  return config.format || "openai";
+}
+
+export function resolveTransport(provider, sourceFormat) {
+  const config = PROVIDERS[provider];
+  const transports = config?.transports;
+  if (!Array.isArray(transports) || !transports.length) return null;
+  return transports.find(t => t.format === sourceFormat) || null;
+}
+
+export function isLastMessageFromUser(body) {
+  const messages = body.messages || body.contents;
+  if (!messages?.length) return true;
+  const lastMsg = messages[messages.length - 1];
+  return lastMsg?.role === "user";
+}
+
+export function hasThinkingConfig(body) {
+  return !!(body.reasoning_effort || body.thinking?.type === "enabled");
+}
+
+export function normalizeThinkingConfig(body) {
+  if (!isLastMessageFromUser(body)) {
+    delete body.thinking;
+  }
+  return body;
+}

package/src/services/qoderModels.js

@@ -0,0 +1,274 @@
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { buildCosyHeaders } from "../shared/qoder/cosy.js";
+import {
+  QODER_MODEL_LIST_URL,
+  QODER_CHAT_BASE_ALT,
+  QODER_JOB_TOKEN_EXCHANGE_URL,
+  QODER_USERINFO_URL,
+  QODER_IDE_VERSION,
+  QODER_CLIENT_TYPE,
+} from "../shared/qoder/constants.js";
+
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_TTL_MS = 60 * 60 * 1000;
+
+const PAT_PREFIX = "pt-";
+
+const PAT_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+const PAT_DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+
+export function isQoderPat(token) {
+  return typeof token === "string" && token.startsWith(PAT_PREFIX);
+}
+
+const patJobCache = new Map();
+
+const catalogCache = new Map();
+
+const inflight = new Map();
+
+async function exchangeJobToken(pat, proxyOptions = null, signal = null) {
+  const res = await proxyAwareFetch(
+    QODER_JOB_TOKEN_EXCHANGE_URL,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": "qodercli/1.0.0",
+        "Cosy-Version": QODER_IDE_VERSION,
+        "Cosy-ClientType": QODER_CLIENT_TYPE,
+      },
+      body: JSON.stringify({ personal_token: pat }),
+      signal,
+    },
+    proxyOptions,
+  );
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`qoder PAT exchange failed: ${res.status} ${text.slice(0, 200)}`);
+  }
+  const data = await res.json();
+  if (!data.token) throw new Error("qoder PAT exchange returned no job token");
+
+  let expiresAt = Date.now() + PAT_DEFAULT_TTL_MS;
+  if (data.expires_at) {
+    const parsed = Date.parse(data.expires_at);
+    if (!Number.isNaN(parsed)) expiresAt = parsed;
+  } else if (typeof data.expires_in === "number" && data.expires_in > 0) {
+    expiresAt = Date.now() + data.expires_in;
+  }
+  return { jobToken: data.token, jobRefreshToken: data.refresh_token || "", expiresAt };
+}
+
+async function fetchUserIdForJobToken(jobToken, proxyOptions = null, signal = null) {
+  try {
+    const res = await proxyAwareFetch(
+      QODER_USERINFO_URL,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${jobToken}`,
+          Accept: "application/json",
+          "User-Agent": "qodercli/1.0.0",
+        },
+        signal,
+      },
+      proxyOptions,
+    );
+    if (!res.ok) return "";
+    const data = await res.json().catch(() => ({}));
+    return data.id || data.userId || data.user_id || "";
+  } catch {
+    return "";
+  }
+}
+
+async function resolvePatCredential(pat, proxyOptions = null, signal = null) {
+  const cached = patJobCache.get(pat);
+  if (cached && cached.expiresAt - Date.now() > PAT_REFRESH_BUFFER_MS) return cached;
+
+  const { jobToken, expiresAt } = await exchangeJobToken(pat, proxyOptions, signal);
+  const userId = await fetchUserIdForJobToken(jobToken, proxyOptions, signal);
+  const resolved = { accessToken: jobToken, userId, expiresAt };
+  patJobCache.set(pat, resolved);
+  return resolved;
+}
+
+export async function resolveQoderCredentials(credentials, proxyOptions = null, signal = null) {
+  const raw = credentials?.apiKey || credentials?.accessToken;
+  if (isQoderPat(raw)) {
+    const resolved = await resolvePatCredential(raw, proxyOptions, signal);
+    return {
+      ...credentials,
+      accessToken: resolved.accessToken,
+      apiKey: undefined,
+      providerSpecificData: {
+        authMethod: "pat",
+        ...(credentials?.providerSpecificData || {}),
+        userId: resolved.userId || credentials?.providerSpecificData?.userId || "",
+        machineId: credentials?.providerSpecificData?.machineId || "",
+      },
+    };
+  }
+  return credentials;
+}
+
+function cacheKey(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || credentials?.refreshToken || credentials?.accessToken || "anonymous";
+  return createHash("sha256").update(`qoder:${seed}`).digest("hex");
+}
+
+function cosyCredsFromConnection(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  return {
+    userId: psd.userId,
+    authToken: credentials.accessToken,
+    name: credentials.displayName || "",
+    email: credentials.email || "",
+    machineId: psd.machineId || "",
+  };
+}
+
+async function fetchQoderCatalogRaw(credentials, signal, proxyOptions = null) {
+  const creds = cosyCredsFromConnection(credentials);
+  if (!creds.userId || !creds.authToken) return null;
+
+  const modelListUrl = String(creds.authToken).startsWith("jt-")
+    ? `${QODER_CHAT_BASE_ALT}/algo/api/v2/model/list`
+    : QODER_MODEL_LIST_URL;
+
+  const headers = {
+    Accept: "application/json",
+    "Accept-Encoding": "identity",
+    ...buildCosyHeaders(Buffer.alloc(0), modelListUrl, creds),
+  };
+
+  const controller = new AbortController();
+  let timer = null;
+  let abortListener = null;
+  let response;
+  try {
+    timer = setTimeout(() => controller.abort("timeout"), FETCH_TIMEOUT_MS);
+    if (signal && typeof signal.addEventListener === "function") {
+
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+      } else {
+        abortListener = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", abortListener);
+      }
+    }
+    response = await proxyAwareFetch(
+      modelListUrl,
+      {
+        method: "GET",
+        headers,
+        signal: controller.signal,
+      },
+      proxyOptions,
+    );
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+
+  if (!response.ok) return null;
+
+  const body = await response.json().catch(() => null);
+  if (!body || !Array.isArray(body.chat)) return null;
+
+  const models = [];
+  const rawConfigs = new Map();
+  for (const entry of body.chat) {
+    if (!entry || typeof entry !== "object") continue;
+    const key = entry.key;
+    if (!key) continue;
+
+    rawConfigs.set(key, entry);
+    if (entry.enable === false) continue;
+
+    const display = entry.display_name || key;
+    const ctx = Number(entry.max_input_tokens) || 131_072;
+    models.push({
+      id: key,
+      name: `${display}`,
+      contextLength: ctx,
+      isVL: !!entry.is_vl,
+      isReasoning: !!entry.is_reasoning,
+      maxOutputTokens: Number(entry.max_output_tokens) || 0,
+      description: entry.description || "",
+    });
+  }
+
+  return { models, rawConfigs };
+}
+
+export async function getQoderModelConfig(credentials, modelKey, options = {}) {
+  const cached = await resolveQoderModels(credentials, options);
+  if (!cached) return null;
+  const config = cached.rawConfigs.get(modelKey);
+  if (!config) return null;
+
+  return { ...config, key: modelKey };
+}
+
+export async function resolveQoderModels(credentials, options = {}) {
+  let resolved;
+  try {
+    resolved = await resolveQoderCredentials(credentials, options.proxyOptions, options.signal);
+  } catch (error) {
+    options.log?.warn?.("QODER", `PAT exchange failed: ${error.message}`);
+    return null;
+  }
+  if (!resolved?.accessToken || !(resolved.providerSpecificData || {}).userId) return null;
+
+  const key = cacheKey(resolved);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) {
+      return cached;
+    }
+  }
+
+  const existing = inflight.get(key);
+  if (existing && !options.forceRefresh) {
+    return existing;
+  }
+
+  const fetchPromise = (async () => {
+    const fetched = await fetchQoderCatalogRaw(resolved, options.signal, options.proxyOptions);
+    if (!fetched) return null;
+    const entry = {
+      expiresAt: Date.now() + CACHE_TTL_MS,
+      models: fetched.models,
+      rawConfigs: fetched.rawConfigs,
+      fetched: true,
+    };
+    catalogCache.set(key, entry);
+    return entry;
+  })();
+
+  inflight.set(key, fetchPromise);
+  try {
+    return await fetchPromise;
+  } finally {
+
+    if (inflight.get(key) === fetchPromise) {
+      inflight.delete(key);
+    }
+  }
+}
+
+export function invalidateQoderCatalog(credentials) {
+  if (!credentials) return;
+  catalogCache.delete(cacheKey(credentials));
+}
+
+export function clearQoderCatalog() {
+  catalogCache.clear();
+}