swayrouter 1.0.0

package/src/shared/constants/providers.js

@@ -0,0 +1,128 @@
+import REGISTRY from "open-sse/providers/registry/index.js";
+import { RISK_NOTICE } from "@/shared/constants/providersDisplay";
+
+function buildProviderEntry(r) {
+  const display = { ...(r.display || {}) };
+  if (display.deprecationNotice === "RISK_NOTICE") display.deprecationNotice = RISK_NOTICE;
+  return {
+    ...display,
+    id: r.id,
+    alias: r.uiAlias || r.alias,
+    ...(r.hidden ? { hidden: true } : {}),
+    ...(r.priority !== undefined ? { priority: r.priority } : {}),
+    ...(r.hasFree ? { hasFree: true } : {}),
+    ...(r.thinkingConfig ? { thinkingConfig: r.thinkingConfig } : {}),
+    ...(r.regions ? { regions: r.regions, defaultRegion: r.defaultRegion } : {}),
+    ...(r.hasProviderSpecificData ? { hasProviderSpecificData: true } : {}),
+    ...(r.noAuth ? { noAuth: true } : {}),
+    ...(r.passthroughModels ? { passthroughModels: true } : {}),
+    ...(r.hasOAuth ? { hasOAuth: true } : {}),
+    ...(r.authModes ? { authModes: r.authModes } : {}),
+    ...(r.authType ? { authType: r.authType } : {}),
+    ...(r.authHint ? { authHint: r.authHint } : {}),
+  };
+}
+
+const byCategory = (cat) => Object.fromEntries(
+  REGISTRY.filter(r => r.category === cat).map(r => [r.id, buildProviderEntry(r)])
+);
+
+export const APIKEY_PROVIDERS = byCategory("apikey");
+export const NO_AUTH_PROVIDERS = byCategory("none");
+
+export const THINKING_CONFIG = {
+  extended: {
+    options: ["auto", "on", "off"],
+    defaultMode: "auto",
+    defaultBudgetTokens: 10000
+  },
+  effort: {
+    options: ["auto", "none", "low", "medium", "high"],
+    defaultMode: "auto"
+  }
+};
+
+export const OAUTH_PROVIDERS = byCategory("oauth");
+
+export const WEB_COOKIE_PROVIDERS = byCategory("webCookie");
+
+export const OPENAI_COMPATIBLE_PREFIX = "openai-compatible-";
+export const ANTHROPIC_COMPATIBLE_PREFIX = "anthropic-compatible-";
+export const CUSTOM_EMBEDDING_PREFIX = "custom-embedding-";
+
+const BUILTIN_OPENAI_COMPATIBLE_PROVIDERS = new Set(
+  REGISTRY
+    .filter((entry) => entry.transport?.openaiCompatible === true)
+    .map((entry) => entry.id),
+);
+
+export function isOpenAICompatibleProvider(providerId) {
+  return typeof providerId === "string" && (
+    providerId.startsWith(OPENAI_COMPATIBLE_PREFIX)
+    || BUILTIN_OPENAI_COMPATIBLE_PROVIDERS.has(providerId)
+  );
+}
+
+export function isCustomOpenAICompatibleProvider(providerId) {
+  return typeof providerId === "string" && providerId.startsWith(OPENAI_COMPATIBLE_PREFIX);
+}
+
+export function isAnthropicCompatibleProvider(providerId) {
+  return typeof providerId === "string" && providerId.startsWith(ANTHROPIC_COMPATIBLE_PREFIX);
+}
+
+export function isCustomEmbeddingProvider(providerId) {
+  return typeof providerId === "string" && providerId.startsWith(CUSTOM_EMBEDDING_PREFIX);
+}
+
+export const AI_PROVIDERS = { ...APIKEY_PROVIDERS, ...OAUTH_PROVIDERS, ...WEB_COOKIE_PROVIDERS, ...NO_AUTH_PROVIDERS };
+
+export const AUTH_METHODS = {
+  oauth: { id: "oauth" },
+  apikey: { id: "apikey" },
+  cookie: { id: "cookie" },
+};
+
+export function getProviderByAlias(alias) {
+  for (const provider of Object.values(AI_PROVIDERS)) {
+    if (provider.alias === alias || provider.id === alias) {
+      return provider;
+    }
+  }
+  return null;
+}
+
+export function resolveProviderId(aliasOrId) {
+  const provider = getProviderByAlias(aliasOrId);
+  return provider?.id || aliasOrId;
+}
+
+export function getProviderAlias(providerId) {
+  const provider = AI_PROVIDERS[providerId];
+  return provider?.alias || providerId;
+}
+
+export const ALIAS_TO_ID = Object.values(AI_PROVIDERS).reduce((acc, p) => {
+  acc[p.alias] = p.id;
+  return acc;
+}, {});
+
+export const ID_TO_ALIAS = Object.values(AI_PROVIDERS).reduce((acc, p) => {
+  acc[p.id] = p.alias;
+  return acc;
+}, {});
+
+export function getProvidersByKind(kind) {
+  if (kind !== "llm") return [];
+  return Object.values(AI_PROVIDERS)
+    .filter((p) => !p.hidden)
+    .sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999));
+}
+
+export const USAGE_SUPPORTED_PROVIDERS = REGISTRY
+  .filter(r => r.features?.usage)
+  .map(r => r.id);
+
+export const USAGE_APIKEY_PROVIDERS = REGISTRY
+  .filter(r => r.features?.usageApikey)
+  .map(r => r.id);

package/src/shared/constants/providersDisplay.js

@@ -0,0 +1 @@
+export const RISK_NOTICE = "⚠️ Risk Notice: This provider uses a subscription/OAuth session not officially licensed for proxy/router use. Account may be restricted or banned. Use at your own risk.";

package/src/shared/qoder/constants.js

@@ -0,0 +1,50 @@
+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_CHAT_BASE_ALT = "https://api2.qoder.sh";
+
+export const QODER_LOGIN_URL = "https://qoder.com/device/selectAccounts";
+
+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`;
+
+export const QODER_JOB_TOKEN_EXCHANGE_URL = `${QODER_OPENAPI_BASE}/api/v1/jobToken/exchange`;
+
+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`;
+
+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";
+
+export const QODER_MODEL_MAP = {
+
+  auto: "auto",
+  ultimate: "ultimate",
+  performance: "performance",
+  efficient: "efficient",
+  lite: "lite",
+
+  qmodel: "qmodel",
+  qmodel_latest: "qmodel_latest",
+  dmodel: "dmodel",
+  dfmodel: "dfmodel",
+  gm51model: "gm51model",
+  kmodel: "kmodel",
+  mmodel: "mmodel",
+};
+
+export const QODER_RSA_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;

package/src/shared/qoder/cosy.js

@@ -0,0 +1,134 @@
+import crypto from "crypto";
+import { v4 as uuidv4 } from "uuid";
+
+import {
+  QODER_CLIENT_TYPE,
+  QODER_DATA_POLICY,
+  QODER_IDE_VERSION,
+  QODER_LOGIN_VERSION,
+  QODER_MACHINE_OS,
+  QODER_MACHINE_TYPE,
+  QODER_RSA_PUBLIC_KEY,
+} from "./constants.js";
+
+function generateAesKey() {
+  return uuidv4().slice(0, 16);
+}
+
+function pkcs7Pad(data, blockSize) {
+  const padding = blockSize - (data.length % blockSize);
+  const padded = Buffer.alloc(data.length + padding, padding);
+  data.copy(padded, 0);
+  return padded;
+}
+
+function aesEncryptCbcBase64(plaintext, keyStr) {
+  const keyBytes = Buffer.from(keyStr, "utf8");
+  if (keyBytes.length !== 16) {
+    throw new Error(`aes key must be 16 bytes, got ${keyBytes.length}`);
+  }
+  const iv = keyBytes.subarray(0, 16);
+  const cipher = crypto.createCipheriv("aes-128-cbc", keyBytes, iv);
+  cipher.setAutoPadding(false);
+  const padded = pkcs7Pad(Buffer.from(plaintext, "utf8"), 16);
+  const encrypted = Buffer.concat([cipher.update(padded), cipher.final()]);
+  return encrypted.toString("base64");
+}
+
+function rsaEncryptBase64(data) {
+  const encrypted = crypto.publicEncrypt(
+    { key: QODER_RSA_PUBLIC_KEY, padding: crypto.constants.RSA_PKCS1_PADDING },
+    Buffer.from(data, "utf8"),
+  );
+  return encrypted.toString("base64");
+}
+
+function encryptUserInfo(userInfo) {
+  const aesKey = generateAesKey();
+  const plaintext = JSON.stringify(userInfo);
+  const infoB64 = aesEncryptCbcBase64(plaintext, aesKey);
+  const cosyKeyB64 = rsaEncryptBase64(aesKey);
+  return { cosyKey: cosyKeyB64, info: infoB64 };
+}
+
+function md5Hex(input) {
+  return crypto.createHash("md5").update(input).digest("hex");
+}
+
+function computeSigPath(requestUrl) {
+  let pathname;
+  try {
+    pathname = new URL(requestUrl).pathname || "";
+  } catch {
+    return "";
+  }
+  if (pathname.startsWith("/algo")) {
+    return pathname.slice("/algo".length);
+  }
+  return pathname;
+}
+
+export function generateMachineId() {
+  return uuidv4();
+}
+
+export function buildCosyHeaders(body, requestUrl, creds) {
+  if (!creds?.userId) throw new Error("cosy: user id is empty");
+  if (!creds?.authToken) throw new Error("cosy: auth token is empty");
+
+  const bodyBuf = Buffer.isBuffer(body)
+    ? body
+    : typeof body === "string"
+      ? Buffer.from(body, "latin1")
+      : Buffer.from(body || []);
+
+  const { cosyKey, info } = encryptUserInfo({
+    uid: creds.userId,
+    security_oauth_token: creds.authToken,
+    name: creds.name || "",
+    aid: "",
+    email: creds.email || "",
+  });
+
+  const timestamp = String(Math.floor(Date.now() / 1000));
+  const requestId = uuidv4();
+
+  const payloadJson = JSON.stringify({
+    version: "v1",
+    requestId,
+    info,
+    cosyVersion: QODER_IDE_VERSION,
+    ideVersion: "",
+  });
+  const payloadB64 = Buffer.from(payloadJson, "utf8").toString("base64");
+
+  const sigPath = computeSigPath(requestUrl);
+  const sigInput = `${payloadB64}\n${cosyKey}\n${timestamp}\n${bodyBuf.toString("latin1")}\n${sigPath}`;
+  const sig = md5Hex(Buffer.from(sigInput, "latin1"));
+
+  const machineId = creds.machineId || generateMachineId();
+  const bodyHash = md5Hex(bodyBuf);
+  const bodyLength = String(bodyBuf.length);
+
+  return {
+    Authorization: `Bearer COSY.${payloadB64}.${sig}`,
+    "Cosy-Key": cosyKey,
+    "Cosy-User": creds.userId,
+    "Cosy-Date": timestamp,
+    "Cosy-Version": QODER_IDE_VERSION,
+    "Cosy-Machineid": machineId,
+    "Cosy-Machinetoken": machineId,
+    "Cosy-Machinetype": QODER_MACHINE_TYPE,
+    "Cosy-Machineos": QODER_MACHINE_OS,
+    "Cosy-Clienttype": QODER_CLIENT_TYPE,
+    "Cosy-Clientip": "127.0.0.1",
+    "Cosy-Bodyhash": bodyHash,
+    "Cosy-Bodylength": bodyLength,
+    "Cosy-Sigpath": sigPath,
+    "Cosy-Data-Policy": QODER_DATA_POLICY,
+    "Cosy-Organization-Id": "",
+    "Cosy-Organization-Tags": "",
+    "Login-Version": QODER_LOGIN_VERSION,
+    "X-Request-Id": uuidv4(),
+  };
+}

package/src/shared/qoder/encoding.js

@@ -0,0 +1,36 @@
+const QODER_STD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const QODER_CUSTOM_ALPHABET = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
+
+const QODER_S2C = (() => {
+  const table = new Int16Array(128).fill(-1);
+  for (let i = 0; i < 64; i++) {
+    table[QODER_STD_ALPHABET.charCodeAt(i)] = QODER_CUSTOM_ALPHABET.charCodeAt(i);
+  }
+  table["=".charCodeAt(0)] = "$".charCodeAt(0);
+  return table;
+})();
+
+export function qoderEncodeBody(plaintext) {
+  const buf = Buffer.isBuffer(plaintext)
+    ? plaintext
+    : typeof plaintext === "string"
+      ? Buffer.from(plaintext, "utf8")
+      : Buffer.from(plaintext);
+
+  const std = buf.toString("base64");
+  const n = std.length;
+  const a = Math.floor(n / 3);
+
+  const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
+
+  const out = Buffer.alloc(n);
+  for (let i = 0; i < n; i++) {
+    const c = rearranged.charCodeAt(i);
+    if (c < 128 && QODER_S2C[c] >= 0) {
+      out[i] = QODER_S2C[c];
+    } else {
+      out[i] = c;
+    }
+  }
+  return out.toString("latin1");
+}

package/src/shared/services/initializeApp.js

@@ -0,0 +1,226 @@
+import os from "os";
+import { cleanupProviderConnections, getApiKeys, getSettings } from "@/lib/localDb";
+import {
+  enableTunnel,
+  isTunnelManuallyDisabled, isTunnelReconnecting,
+  getTunnelService, setTunnelUnexpectedExitCallback,
+  killCloudflared, isCloudflaredRunning, ensureCloudflared,
+  checkInternet,
+  RESTART_COOLDOWN_MS, NETWORK_SETTLE_MS,
+  WATCHDOG_INTERVAL_MS, NETWORK_CHECK_INTERVAL_MS, VIRTUAL_IFACE_REGEX,
+} from "@/lib/tunnel";
+import { killAllBridges } from "@/lib/mcp/stdioSseBridge";
+
+process.setMaxListeners(20);
+
+const STARTUP_DEFER_MS = 3000;
+
+let startupPromise = null;
+
+const g = global.__appSingleton ??= {
+  signalHandlersRegistered: false,
+  watchdogInterval: null,
+  networkMonitorInterval: null,
+  lastNetworkFingerprint: null,
+  lastWatchdogTick: Date.now(),
+  lastOnline: null,
+  tunnelAutoResumed: false,
+};
+
+export async function initializeApp() {
+  if (startupPromise) return startupPromise;
+
+  startupPromise = new Promise((resolve, reject) => {
+    try {
+      setTunnelUnexpectedExitCallback(() => {
+        safeRestartTunnel("unexpected-exit").catch(() => {});
+      });
+
+      setTimeout(() => {
+        runHeavyStartup().then(resolve, (error) => {
+          console.error("[InitApp] deferred startup failed:", error);
+          reject(error);
+        });
+      }, STARTUP_DEFER_MS);
+    } catch (error) {
+      console.error("[InitApp] Error:", error);
+      reject(error);
+    }
+  });
+
+  return startupPromise;
+}
+
+export function resetStartupForTests() {
+  startupPromise = null;
+}
+
+export { STARTUP_DEFER_MS };
+
+async function runHeavyStartup() {
+
+  await getApiKeys();
+  await cleanupProviderConnections();
+  const settings = await getSettings();
+
+  if (settings.tunnelEnabled && !g.tunnelAutoResumed) {
+    g.tunnelAutoResumed = true;
+    console.log("[InitApp] Tunnel was enabled, auto-resuming...");
+    safeRestartTunnel("startup").catch((e) => console.log("[InitApp] Tunnel resume failed:", e.message));
+  }
+
+  if (settings.tunnelEnabled) ensureCloudflared().catch(() => {});
+
+  configureTunnelMonitoring(settings);
+
+  if (hasQuotaAutoPingEnabled(settings)) {
+    import("@/shared/services/quotaAutoPing")
+      .then(({ startQuotaAutoPing }) => startQuotaAutoPing())
+      .catch((e) => console.log("[AutoPing] scheduler start failed:", e.message));
+  }
+
+  import("@/sse/services/backgroundTokenRefresh.js")
+    .then(({ startBackgroundTokenRefresh }) => startBackgroundTokenRefresh())
+    .catch((e) => console.log("[BackgroundTokenRefresh] scheduler start failed:", e.message));
+}
+
+function hasQuotaAutoPingEnabled(settings) {
+  return [settings?.claudeAutoPing, settings?.codexAutoPing]
+    .some((config) => Object.values(config?.connections || {}).some(Boolean));
+}
+
+const FORCE_RESTART_REASONS = /^(startup|netchange|sleep|sleep\+netchange|online|unexpected-exit)$/;
+
+async function safeRestartTunnel(reason) {
+  const svc = getTunnelService();
+  const settings = await getSettings();
+  if (!settings.tunnelEnabled) return;
+  if (svc.cancelToken.cancelled) return;
+  if (svc.spawnInProgress) return;
+
+  const force = FORCE_RESTART_REASONS.test(reason);
+
+  if (isCloudflaredRunning()) return;
+
+  if (!force && Date.now() - svc.lastRestartAt < RESTART_COOLDOWN_MS) {
+    console.log(`[Tunnel] degraded but cooldown active, skip (${reason})`);
+    return;
+  }
+  if (!await checkInternet()) return;
+
+  console.log(`[Tunnel] safeRestart (${reason}) — tunnel unreachable${force ? " [force]" : ""}`);
+  try {
+    await enableTunnel();
+    svc.lastRestartAt = Date.now();
+    console.log("[Tunnel] restart success");
+  } catch (err) {
+    if (!/cloudflared killed|tunnel cancelled/.test(err.message)) {
+      console.log("[Tunnel] restart failed:", err.message);
+    }
+  }
+}
+
+function startWatchdog() {
+  if (g.watchdogInterval) return;
+  g.watchdogInterval = setInterval(() => {
+    safeRestartTunnel("watchdog").catch(() => {});
+  }, WATCHDOG_INTERVAL_MS);
+  if (g.watchdogInterval.unref) g.watchdogInterval.unref();
+}
+
+function stopWatchdog() {
+  if (!g.watchdogInterval) return;
+  clearInterval(g.watchdogInterval);
+  g.watchdogInterval = null;
+}
+
+function getNetworkFingerprint() {
+  const interfaces = os.networkInterfaces();
+  const active = [];
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (!addrs) continue;
+    if (VIRTUAL_IFACE_REGEX.test(name)) continue;
+    for (const addr of addrs) {
+      if (!addr.internal && addr.family === "IPv4") {
+        active.push(`${name}:${addr.address}`);
+      }
+    }
+  }
+  return active.sort().join("|");
+}
+
+function startNetworkMonitor() {
+  if (g.networkMonitorInterval) return;
+
+  g.lastNetworkFingerprint = getNetworkFingerprint();
+  g.lastWatchdogTick = Date.now();
+  g.lastOnline = null;
+
+  g.networkMonitorInterval = setInterval(async () => {
+    try {
+      const now = Date.now();
+      const elapsed = now - g.lastWatchdogTick;
+      g.lastWatchdogTick = now;
+
+      const currentFingerprint = getNetworkFingerprint();
+      const networkChanged = currentFingerprint !== g.lastNetworkFingerprint;
+      const wasSleep = elapsed > NETWORK_CHECK_INTERVAL_MS * 6;
+      if (networkChanged) g.lastNetworkFingerprint = currentFingerprint;
+
+      const online = await checkInternet();
+      const wasOffline = g.lastOnline === false;
+      g.lastOnline = online;
+
+      if (!online) return;
+
+      const onlineEdge = wasOffline;
+      if (!networkChanged && !wasSleep && !onlineEdge) return;
+
+      await new Promise((r) => setTimeout(r, NETWORK_SETTLE_MS));
+
+      const reason = onlineEdge ? "online"
+        : wasSleep && networkChanged ? "sleep+netchange"
+        : wasSleep ? "sleep" : "netchange";
+      safeRestartTunnel(reason).catch(() => {});
+    } catch (err) {
+      console.log("[NetworkMonitor] error:", err.message);
+    }
+  }, NETWORK_CHECK_INTERVAL_MS);
+
+  if (g.networkMonitorInterval.unref) g.networkMonitorInterval.unref();
+}
+
+function stopNetworkMonitor() {
+  if (!g.networkMonitorInterval) return;
+  clearInterval(g.networkMonitorInterval);
+  g.networkMonitorInterval = null;
+  g.lastNetworkFingerprint = null;
+  g.lastOnline = null;
+}
+
+export function configureTunnelMonitoring(settings) {
+  if (settings?.tunnelEnabled) {
+    startWatchdog();
+    startNetworkMonitor();
+    return;
+  }
+  stopWatchdog();
+  stopNetworkMonitor();
+}
+
+export async function shutdownApp() {
+  stopWatchdog();
+  stopNetworkMonitor();
+  try { killAllBridges(); } catch {                   }
+  try { killCloudflared(); } catch {                   }
+  try {
+    const { stopQuotaAutoPing } = await import("./quotaAutoPing.js");
+    stopQuotaAutoPing();
+  } catch {                                                   }
+  try {
+    const { stopCacheCleanup } = await import("@/services/projectId.js");
+    stopCacheCleanup();
+  } catch {                                                            }
+}
+
+export default initializeApp;