swayrouter 1.0.0

package/src/services/usage/misc.js

@@ -0,0 +1,264 @@
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { U } from "./shared.js";
+
+const GLM_QUOTA_URLS = {
+  international: U("glm").url,
+  china: U("glm-cn").url,
+};
+
+const VERCEL_AI_GATEWAY_CREDITS_URL = U("vercel-ai-gateway").url;
+
+export async function getOllamaUsage(apiKey, providerSpecificData, proxyOptions = null) {
+  if (!apiKey) {
+    return { message: "Ollama Cloud API key not available." };
+  }
+
+  try {
+    const response = await proxyAwareFetch("https://ollama.com/api/usage", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    }, proxyOptions);
+
+    if (response.status === 401 || response.status === 403) {
+      return { message: "Ollama Cloud API key invalid or expired." };
+    }
+
+    if (!response.ok) {
+      return { message: `Ollama Cloud usage API error (${response.status}).` };
+    }
+
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      return { message: "Ollama Cloud usage response was not JSON." };
+    }
+
+    const me = await proxyAwareFetch("https://ollama.com/api/me", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+        "Content-Length": "0",
+      },
+    }, proxyOptions).then((r) => (r.ok ? r.json() : null)).catch(() => null);
+
+    const planRaw = typeof me?.Plan === "string" ? me.Plan : "";
+    const plan = planRaw
+      ? planRaw.charAt(0).toUpperCase() + planRaw.slice(1).toLowerCase()
+      : "Ollama Cloud";
+
+    const limits = data?.limits && typeof data.limits === "object" ? data.limits : {};
+
+    function ratioQuota(usageRatio, resetAt = null) {
+      const ratio = Math.max(0, Math.min(1, Number(usageRatio) || 0));
+      const usedPct = Math.round(ratio * 100);
+      return { used: usedPct, total: 100, remainingPercentage: 100 - usedPct, resetAt, unlimited: false };
+    }
+
+    const sessionRaw = limits.session?.usage;
+    const weeklyRaw = limits.weekly?.usage;
+    const sessionNum = Number(sessionRaw);
+    const weeklyNum = Number(weeklyRaw);
+    const hasSession = sessionRaw !== undefined && sessionRaw !== null && !Number.isNaN(sessionNum);
+    const hasWeekly = weeklyRaw !== undefined && weeklyRaw !== null && !Number.isNaN(weeklyNum);
+
+    if (!hasSession && !hasWeekly) {
+      return {
+        plan,
+        message: "Ollama Cloud connected. No usage limits reported.",
+        quotas: {},
+      };
+    }
+
+    const quotas = {};
+    if (hasSession) quotas["Session (5h)"] = ratioQuota(sessionNum);
+    if (hasWeekly) quotas["Weekly (7d)"] = ratioQuota(weeklyNum);
+
+    return { plan, quotas };
+  } catch (error) {
+    console.error("[Ollama Cloud Usage] Failed to fetch usage:", error);
+    return { message: "Ollama Cloud usage request failed." };
+  }
+}
+
+export async function getGlmUsage(apiKey, provider, proxyOptions = null) {
+  if (!apiKey) {
+    return { message: "GLM API key not available." };
+  }
+
+  const region = provider === "glm-cn" ? "china" : "international";
+  const quotaUrl = GLM_QUOTA_URLS[region];
+
+  try {
+    const response = await proxyAwareFetch(quotaUrl, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    }, proxyOptions);
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        return { message: "GLM API key invalid or expired." };
+      }
+      return { message: `GLM quota API error (${response.status}).` };
+    }
+
+    const json = await response.json();
+    const data = json?.data && typeof json.data === "object" ? json.data : {};
+    const limits = Array.isArray(data.limits) ? data.limits : [];
+    const quotas = {};
+
+    for (const limit of limits) {
+      if (!limit || limit.type !== "TOKENS_LIMIT") continue;
+      const usedPercent = Number(limit.percentage) || 0;
+      const resetMs = Number(limit.nextResetTime) || 0;
+      const remaining = Math.max(0, 100 - usedPercent);
+
+      quotas["session"] = {
+        used: usedPercent,
+        total: 100,
+        remaining,
+        remainingPercentage: remaining,
+        resetAt: resetMs > 0 ? new Date(resetMs).toISOString() : null,
+        unlimited: false,
+      };
+    }
+
+    const levelRaw = typeof data.level === "string" ? data.level : "";
+    const plan = levelRaw
+      ? levelRaw.charAt(0).toUpperCase() + levelRaw.slice(1).toLowerCase()
+      : "Unknown";
+
+    return { plan, quotas };
+  } catch (error) {
+    console.error("[GLM Usage] Failed to fetch quota:", error);
+    return { message: "GLM usage request failed." };
+  }
+}
+
+export async function getVercelAiGatewayUsage(apiKey, proxyOptions = null) {
+  if (!apiKey) {
+    return { message: "Vercel AI Gateway API key not available." };
+  }
+
+  try {
+    const response = await proxyAwareFetch(VERCEL_AI_GATEWAY_CREDITS_URL, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    }, proxyOptions);
+
+    if (response.status === 401 || response.status === 403) {
+      return { message: "Vercel AI Gateway API key invalid or expired." };
+    }
+
+    if (!response.ok) {
+      await response.text().catch(() => "");
+      return { message: `Vercel AI Gateway credits API error (${response.status}).` };
+    }
+
+    const data = await response.json();
+
+    const balance = Number(data?.balance) || 0;
+    const totalUsed = Number(data?.total_used) || 0;
+
+    const MONTHLY_CREDIT = 5;
+    const remainingPercentage = (balance / MONTHLY_CREDIT) * 100;
+
+    if (balance <= 0 && totalUsed <= 0) {
+      return {
+        plan: "Pay-as-you-go",
+        message: "Vercel AI Gateway connected. No credit allocation found (BYOK or unfunded account).",
+        quotas: {},
+      };
+    }
+
+    return {
+      plan: "Pay-as-you-go",
+      quotas: {
+        "Used (USD)": {
+          used: totalUsed,
+          total: 0,
+          remaining: 0,
+          remainingPercentage: 100,
+          unlimited: true,
+        },
+        "Remaining (USD)": {
+          used: balance,
+          total: MONTHLY_CREDIT,
+          remaining: balance,
+          remainingPercentage,
+          unlimited: false,
+        },
+      },
+    };
+  } catch (error) {
+    console.error("[Vercel AI Gateway Usage] Failed to fetch credits:", error);
+    return { message: "Vercel AI Gateway usage request failed." };
+  }
+}
+
+export async function getQoderUsage(accessToken, proxyOptions = null) {
+  if (!accessToken) {
+    return { message: "Qoder usage unavailable: no access token" };
+  }
+  try {
+    const response = await proxyAwareFetch(
+      U("qoder").url,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          Accept: "application/json",
+        },
+      },
+      proxyOptions,
+    );
+    if (!response.ok) {
+      return { message: `Qoder connected. Usage fetch returned ${response.status}.` };
+    }
+    const body = await response.json().catch(() => null);
+    if (!body) {
+      return { message: "Qoder connected. Usage response was not JSON." };
+    }
+
+    const userQuota = body.userQuota || {};
+    const orgQuota = body.orgResourcePackage || {};
+
+    const expiresAtMs = Number.isFinite(Number(body.expiresAt)) && Number(body.expiresAt) > 0
+      ? Number(body.expiresAt)
+      : null;
+    const resetAt = expiresAtMs ? new Date(expiresAtMs).toISOString() : null;
+    const quotas = {
+      user: {
+        total: Number(userQuota.total) || 0,
+        used: Number(userQuota.used) || 0,
+        remaining: Number(userQuota.remaining) || 0,
+        unit: userQuota.unit || "credits",
+        resetAt,
+      },
+      organization: {
+        total: Number(orgQuota.total) || 0,
+        used: Number(orgQuota.used) || 0,
+        remaining: Number(orgQuota.remaining) || 0,
+        unit: orgQuota.unit || "credits",
+        resetAt,
+      },
+    };
+    return {
+      quotas,
+      totalUsagePercentage: Number(body.totalUsagePercentage) || 0,
+      isQuotaExceeded: !!body.isQuotaExceeded,
+      expiresAt: expiresAtMs,
+    };
+  } catch (error) {
+    console.error("[Qoder Usage] Failed to fetch usage:", error);
+    return { message: "Qoder connected. Unable to fetch usage." };
+  }
+}

package/src/services/usage/shared.js

@@ -0,0 +1,59 @@
+import { PROVIDERS } from "../../providers/index.js";
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+
+export const U = (id) => PROVIDERS[id]?.usage || {};
+
+export function parseResetTime(resetValue) {
+  if (!resetValue) return null;
+
+  try {
+
+    if (resetValue instanceof Date) {
+      return resetValue.toISOString();
+    }
+
+    if (typeof resetValue === 'number') {
+      return new Date(resetValue < 1e12 ? resetValue * 1000 : resetValue).toISOString();
+    }
+
+    if (typeof resetValue === 'string') {
+      if (/^\d+$/.test(resetValue)) {
+        const timestamp = Number(resetValue);
+        return new Date(timestamp < 1e12 ? timestamp * 1000 : timestamp).toISOString();
+      }
+      return new Date(resetValue).toISOString();
+    }
+
+    return null;
+  } catch (error) {
+    console.warn(`Failed to parse reset time: ${resetValue}`, error);
+    return null;
+  }
+}
+
+export function toFiniteNumber(value, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+
+export function normalizeCloudCodeProjectId(project) {
+  if (typeof project === "string") return project.trim() || null;
+  if (project && typeof project === "object" && typeof project.id === "string") {
+    return project.id.trim() || null;
+  }
+  return null;
+}
+
+export async function fetchWithTimeout(url, opts, ms = 10000, proxyOptions = null) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), ms);
+  try {
+    return await proxyAwareFetch(url, { ...opts, signal: controller.signal }, proxyOptions);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

package/src/services/usage.js

@@ -0,0 +1,56 @@
+import { getGitHubUsage } from "./usage/github.js";
+import { getGeminiUsage, getAntigravityUsage } from "./usage/google.js";
+import { getClaudeUsage } from "./usage/claude.js";
+import { getCodexUsage, consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits } from "./usage/codex.js";
+
+export { consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits };
+import { getKiroUsage } from "./usage/kiro.js";
+import { getMiniMaxUsage } from "./usage/minimax.js";
+import { getCodeBuddyCnUsage, getCodeBuddyIntlUsage } from "./usage/codebuddy-cn.js";
+import { getGrokCliUsage } from "./usage/grok-cli.js";
+import { getKimiUsage } from "./usage/kimi.js";
+import { getDeepseekUsage } from "./usage/deepseek.js";
+import { resolveQoderCredentials } from "./qoderModels.js";
+import {
+  getOllamaUsage,
+  getGlmUsage,
+  getVercelAiGatewayUsage,
+  getQoderUsage,
+} from "./usage/misc.js";
+
+const USAGE_HANDLERS = {
+  github: (c) => getGitHubUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  "gemini-cli": (c) => getGeminiUsage(c.accessToken, c.providerDataWithProjectId, c.proxyOptions),
+  antigravity: (c) => getAntigravityUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  claude: (c) => getClaudeUsage(c.accessToken, c.proxyOptions),
+  codex: (c) => getCodexUsage(c.accessToken, c.proxyOptions),
+  kiro: (c) => getKiroUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  qoder: async (c) => {
+
+    const resolved = await resolveQoderCredentials(c, c.proxyOptions).catch(() => null);
+    return getQoderUsage(resolved?.accessToken || c.accessToken, c.proxyOptions);
+  },
+  ollama: (c) => getOllamaUsage(c.apiKey, c.providerSpecificData, c.proxyOptions),
+  glm: (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
+  "glm-cn": (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
+  minimax: (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
+  "minimax-cn": (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
+  "vercel-ai-gateway": (c) => getVercelAiGatewayUsage(c.apiKey, c.proxyOptions),
+  "codebuddy-cn": (c) => getCodeBuddyCnUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
+  "codebuddy-intl": (c) => getCodeBuddyIntlUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
+  "grok-cli": (c) => getGrokCliUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  kimi: (c) => getKimiUsage(c.accessToken, c.apiKey, c.proxyOptions, c.providerSpecificData),
+  deepseek: (c) => getDeepseekUsage(c.apiKey, c.proxyOptions),
+};
+
+export async function getUsageForProvider(connection, proxyOptions = null) {
+  const { provider, accessToken, apiKey, providerSpecificData, projectId } = connection;
+  const providerDataWithProjectId = {
+    ...(providerSpecificData || {}),
+    ...(projectId ? { projectId } : {}),
+  };
+
+  const handler = USAGE_HANDLERS[provider];
+  if (!handler) return { message: `Usage API not implemented for ${provider}` };
+  return await handler({ provider, accessToken, apiKey, providerSpecificData, providerDataWithProjectId, proxyOptions });
+}

package/src/shared/clineAuth.js

@@ -0,0 +1,37 @@
+import pkg from "../../package.json" with { type: "json" };
+
+const APP_VERSION = pkg.version || "0.0.0";
+
+export function getClineAccessToken(token) {
+  if (typeof token !== "string") return "";
+  const trimmed = token.trim();
+  if (!trimmed) return "";
+  return trimmed.startsWith("workos:") ? trimmed : `workos:${trimmed}`;
+}
+
+export function getClineAuthorizationHeader(token) {
+  const accessToken = getClineAccessToken(token);
+  return accessToken ? `Bearer ${accessToken}` : "";
+}
+
+export function buildClineHeaders(token, extraHeaders = {}) {
+  const authorization = getClineAuthorizationHeader(token);
+  const headers = {
+    "HTTP-Referer": "https://cline.bot",
+    "X-Title": "Cline",
+    "User-Agent": `SwayRouter/${APP_VERSION}`,
+    "X-PLATFORM": process.platform || "unknown",
+    "X-PLATFORM-VERSION": process.version || "unknown",
+    "X-CLIENT-TYPE": "swayrouter",
+    "X-CLIENT-VERSION": APP_VERSION,
+    "X-CORE-VERSION": APP_VERSION,
+    "X-IS-MULTIROOT": "false",
+    ...extraHeaders,
+  };
+
+  if (authorization) {
+    headers.Authorization = authorization;
+  }
+
+  return headers;
+}

package/src/shared/constants/config.js

@@ -0,0 +1,80 @@
+import pkg from "../../../package.json" with { type: "json" };
+
+export const APP_CONFIG = {
+  name: "Sway Router",
+  description: "AI Infrastructure Management",
+  version: pkg.version,
+};
+
+export const RUNTIME_CONFIG = {
+  appPort: Number.parseInt(process.env.PORT || "14045", 10) || 14045,
+};
+
+export const THEME_CONFIG = {
+  storageKey: "theme",
+  defaultTheme: "system",
+};
+
+export const SUBSCRIPTION_CONFIG = {
+  price: 1.0,
+  currency: "USD",
+  interval: "month",
+  planName: "Pro Plan",
+};
+
+export const API_ENDPOINTS = {
+  users: "/api/users",
+  providers: "/api/providers",
+  payments: "/api/payments",
+  auth: "/api/auth",
+};
+
+export const CONSOLE_LOG_CONFIG = {
+  maxLines: 200,
+  pollIntervalMs: 1000,
+};
+
+export const CLIENT_STORE_TTL_MS = 60000;
+
+export const QUOTA_AUTOPING_CONFIG = {
+  tickIntervalMs: 60000,
+  pingLeadMs: 5000,
+  refreshAheadMs: 300000,
+  failureCooldownMs: 900000,
+  providers: {
+    claude: {
+      settingsKey: "claudeAutoPing",
+      quotaKey: "session (5h)",
+      pingModel: "claude-haiku-4-5-20251001",
+      pingText: "hi",
+      pingMaxTokens: 1,
+    },
+    codex: {
+      settingsKey: "codexAutoPing",
+      quotaKey: "session",
+      pingWhenResetAtSlides: true,
+      resetAtDriftMs: 30000,
+      minPingIntervalMs: 600000,
+      skipWhenBlockingQuotaExhausted: true,
+
+      pingModel: "gpt-5.5",
+      pingText: "hi",
+      pingInstructions: "Reply with OK.",
+      pingReasoningEffort: "none",
+    },
+  },
+};
+
+export {
+  OAUTH_PROVIDERS,
+  APIKEY_PROVIDERS,
+  WEB_COOKIE_PROVIDERS,
+  NO_AUTH_PROVIDERS,
+  AI_PROVIDERS,
+  AUTH_METHODS,
+} from "./providers.js";
+
+export {
+  PROVIDER_MODELS,
+  AI_MODELS,
+} from "./models.js";

package/src/shared/constants/coworkPlugins.js

@@ -0,0 +1,69 @@
+const DEFAULT_PLUGINS = [
+  {
+    name: "exa",
+    title: "Exa",
+    description: "Real-time web search and code documentation",
+    url: "https://mcp.exa.ai/mcp",
+    transport: "http",
+    oauth: false,
+    toolNames: ["web_search_exa", "web_fetch_exa"],
+  },
+  {
+    name: "tavily",
+    title: "Tavily",
+    description: "Real-time web search optimized for LLM agents",
+    url: "https://mcp.tavily.com/mcp",
+    transport: "http",
+    oauth: true,
+    toolNames: ["tavily_search", "tavily_extract", "tavily_crawl", "tavily_map"],
+  },
+];
+
+const LOCAL_STDIO_PLUGINS = [
+  {
+    name: "browsermcp",
+    title: "Browser MCP",
+    description: "Control your running Chrome (requires Chrome extension)",
+    extensionUrl: "https://chromewebstore.google.com/detail/browser-mcp-automate-your/bjfgambnhccakkhmkepdoekmckoijdlc",
+    command: "npx",
+    args: ["-y", "@browsermcp/mcp@latest"],
+    toolNames: ["browser_navigate", "browser_snapshot", "browser_click", "browser_type", "browser_screenshot", "browser_get_console_logs", "browser_wait", "browser_press_key", "browser_go_back", "browser_go_forward"],
+  },
+];
+
+function buildManagedMcpServers(plugins) {
+  const list = Array.isArray(plugins) ? plugins : [];
+  const out = [];
+  const seen = new Set();
+  for (const p of list) {
+    if (!p?.name || !p?.url || seen.has(p.name)) continue;
+    seen.add(p.name);
+    const entry = {
+      name: p.name,
+      url: p.url,
+      transport: p.transport || (/\/sse(\b|\/)/i.test(p.url) ? "sse" : "http"),
+    };
+    if (p.oauth) entry.oauth = true;
+    if (Array.isArray(p.toolNames) && p.toolNames.length > 0) {
+
+      const prefix = `${p.name}-`;
+      const bare = new Set();
+      for (const raw of p.toolNames) {
+        if (typeof raw !== "string" || !raw) continue;
+        let t = raw;
+        while (t.startsWith(prefix)) t = t.slice(prefix.length);
+        bare.add(t);
+      }
+      const policy = {};
+      for (const t of bare) {
+        policy[t] = "allow";
+        policy[`${prefix}${t}`] = "allow";
+      }
+      entry.toolPolicy = policy;
+    }
+    out.push(entry);
+  }
+  return out;
+}
+
+export { DEFAULT_PLUGINS, LOCAL_STDIO_PLUGINS, buildManagedMcpServers };

package/src/shared/constants/models.js

@@ -0,0 +1,41 @@
+export {
+  PROVIDER_MODELS,
+  getProviderModels,
+  getDefaultModel,
+  isValidModel as isValidModelCore,
+  findModelName,
+  getModelTargetFormat,
+  getModelStrip,
+  PROVIDER_ID_TO_ALIAS,
+  getModelsByProviderId,
+  getModelUpstreamId,
+  getModelQuotaFamily
+} from "open-sse/config/providerModels.js";
+
+import { AI_PROVIDERS, isOpenAICompatibleProvider } from "./providers.js";
+import { PROVIDER_MODELS as MODELS } from "open-sse/config/providerModels.js";
+
+const PASSTHROUGH_PROVIDERS = new Set(
+  Object.entries(AI_PROVIDERS)
+    .filter(([, p]) => p.passthroughModels)
+    .map(([key]) => key)
+);
+
+export function isValidModel(aliasOrId, modelId) {
+  if (isOpenAICompatibleProvider(aliasOrId)) return true;
+  if (PASSTHROUGH_PROVIDERS.has(aliasOrId)) return true;
+  const models = MODELS[aliasOrId];
+  if (!models) return false;
+  return models.some(m => m.id === modelId);
+}
+
+export const AI_MODELS = Object.entries(MODELS).flatMap(([alias, models]) =>
+  models.map(m => ({ provider: alias, model: m.id, name: m.name }))
+);
+
+export const getModelKind = (m, fallback = null) => m?.kind || m?.type || fallback;
+
+export const CAPACITY_META = {
+  vision: { icon: "visibility", label: "Vision", desc: "Supports image input", color: "text-blue-500" },
+  reasoning: { icon: "neurology", label: "Reasoning", desc: "Supports reasoning / thinking", color: "text-amber-500" },
+};