swayrouter 1.0.0

package/src/sse/services/model.js

@@ -0,0 +1,129 @@
+import { getComboByName, getCustomModels, getProviderNodes } from "@/lib/localDb";
+import { parseModel as parseModelCore, getModelInfoCore } from "../../services/model.js";
+import REGISTRY from "../../providers/registry/index.js";
+
+const LOCAL_PROVIDER_ALIASES = {
+  xmtp: "xiaomi-tokenplan",
+  "xiaomi-tokenplan": "xiaomi-tokenplan",
+};
+
+const RESERVED_PROVIDER_PREFIXES = new Set(Object.keys(LOCAL_PROVIDER_ALIASES));
+for (const entry of REGISTRY) {
+  RESERVED_PROVIDER_PREFIXES.add(entry.id);
+  if (entry.alias) RESERVED_PROVIDER_PREFIXES.add(entry.alias);
+  for (const alias of entry.aliases || []) RESERVED_PROVIDER_PREFIXES.add(alias);
+}
+
+export function parseModel(modelStr) {
+  const parsed = parseModelCore(modelStr);
+  if (parsed?.providerAlias && LOCAL_PROVIDER_ALIASES[parsed.providerAlias]) {
+    return { ...parsed, provider: LOCAL_PROVIDER_ALIASES[parsed.providerAlias] };
+  }
+  return parsed;
+}
+
+function normalizeModelKey(value) {
+  return String(value || "")
+    .trim()
+    .replace(/^(?:clinepass|cline-pass)\//i, "")
+    .toLowerCase();
+}
+
+async function getCustomModelCapabilities(providerAlias, provider, model) {
+  try {
+    const aliases = new Set(
+      [providerAlias, provider]
+        .filter(Boolean)
+        .map((value) => String(value).trim().toLowerCase()),
+    );
+    if (aliases.size === 0) return null;
+
+    const customModels = await getCustomModels();
+    const match = customModels.find((entry) => (
+      aliases.has(String(entry?.providerAlias || "").trim().toLowerCase()) &&
+      normalizeModelKey(entry?.id) === normalizeModelKey(model)
+    ));
+    return match?.capabilities && typeof match.capabilities === "object"
+      ? match.capabilities
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+async function buildModelInfo({ providerAlias, provider, model }) {
+  const capabilities = await getCustomModelCapabilities(providerAlias, provider, model);
+  return {
+    provider,
+    model,
+    ...(capabilities ? { modelCapabilities: capabilities } : {}),
+  };
+}
+
+export async function getModelInfo(modelStr) {
+  const parsed = parseModel(modelStr);
+
+  if (!parsed.isAlias) {
+
+    if (!RESERVED_PROVIDER_PREFIXES.has(parsed.providerAlias)) {
+      const openaiNodes = await getProviderNodes({ type: "openai-compatible" });
+      const matchedOpenAI = openaiNodes.find((node) => node.prefix === parsed.providerAlias);
+      if (matchedOpenAI) {
+        return buildModelInfo({
+          providerAlias: parsed.providerAlias,
+          provider: matchedOpenAI.id,
+          model: parsed.model,
+        });
+      }
+
+      const anthropicNodes = await getProviderNodes({ type: "anthropic-compatible" });
+      const matchedAnthropic = anthropicNodes.find((node) => node.prefix === parsed.providerAlias);
+      if (matchedAnthropic) {
+        return buildModelInfo({
+          providerAlias: parsed.providerAlias,
+          provider: matchedAnthropic.id,
+          model: parsed.model,
+        });
+      }
+
+      const embeddingNodes = await getProviderNodes({ type: "custom-embedding" });
+      const matchedEmbedding = embeddingNodes.find((node) => node.prefix === parsed.providerAlias);
+      if (matchedEmbedding) {
+        return buildModelInfo({
+          providerAlias: parsed.providerAlias,
+          provider: matchedEmbedding.id,
+          model: parsed.model,
+        });
+      }
+    }
+    return buildModelInfo({
+      providerAlias: parsed.providerAlias,
+      provider: parsed.provider,
+      model: parsed.model,
+    });
+  }
+
+  const combo = await getComboByName(parsed.model);
+  if (combo) {
+
+    return { provider: null, model: parsed.model };
+  }
+
+  const info = await getModelInfoCore(modelStr);
+  return buildModelInfo({
+    providerAlias: parsed.providerAlias || info.provider,
+    provider: info.provider,
+    model: info.model,
+  });
+}
+
+export async function getComboModels(modelStr) {
+
+  if (modelStr.includes("/")) return null;
+
+  const combo = await getComboByName(modelStr);
+  if (combo && combo.models && combo.models.length > 0) {
+    return combo.models;
+  }
+  return null;
+}

package/src/sse/services/requestCancellation.js

@@ -0,0 +1,4 @@
+/** @param {{ requestSignal?: AbortSignal | null, status?: number | string | null }} [options] */
+export function isCallerCancellation({ requestSignal = null, status = null } = {}) {
+  return Boolean(requestSignal?.aborted) || Number(status) === 499;
+}

package/src/sse/services/tokenRefresh.js

@@ -0,0 +1,264 @@
+import * as log from "../utils/logger.js";
+import { updateProviderConnection } from "../../lib/localDb.js";
+import {
+  getProjectIdForConnection,
+  invalidateProjectId,
+  removeConnection,
+} from "../../services/projectId.js";
+import {
+  TOKEN_EXPIRY_BUFFER_MS as BUFFER_MS,
+  refreshAccessToken as _refreshAccessToken,
+  refreshClaudeOAuthToken as _refreshClaudeOAuthToken,
+  refreshGoogleToken as _refreshGoogleToken,
+  refreshCodexToken as _refreshCodexToken,
+  refreshGitHubToken as _refreshGitHubToken,
+  refreshCopilotToken as _refreshCopilotToken,
+  getAccessToken as _getAccessToken,
+  refreshTokenByProvider as _refreshTokenByProvider,
+  formatProviderCredentials as _formatProviderCredentials,
+  getAllAccessTokens as _getAllAccessTokens,
+  refreshKiroToken as _refreshKiroToken,
+  getRefreshLeadMs as _getRefreshLeadMs
+} from "../../services/tokenRefresh.js";
+import {
+  refreshProviderCredentials as _refreshProviderCredentials,
+  shouldRefreshCredentials as _shouldRefreshCredentials,
+} from "../../services/oauthCredentialManager.js";
+
+export const TOKEN_EXPIRY_BUFFER_MS = BUFFER_MS;
+
+export const refreshAccessToken = (provider, refreshToken, credentials) =>
+  _refreshAccessToken(provider, refreshToken, credentials, log);
+
+export const refreshClaudeOAuthToken = (refreshToken) =>
+  _refreshClaudeOAuthToken(refreshToken, log);
+
+export const refreshGoogleToken = (refreshToken, clientId, clientSecret) =>
+  _refreshGoogleToken(refreshToken, clientId, clientSecret, log);
+
+export const refreshCodexToken = (refreshToken) =>
+  _refreshCodexToken(refreshToken, log);
+
+export const refreshGitHubToken = (refreshToken) =>
+  _refreshGitHubToken(refreshToken, log);
+
+export const refreshCopilotToken = (githubAccessToken) =>
+  _refreshCopilotToken(githubAccessToken, log);
+
+export const refreshKiroToken = (refreshToken, providerSpecificData) =>
+  _refreshKiroToken(refreshToken, providerSpecificData, log);
+
+export const getAccessToken = (provider, credentials) =>
+  _getAccessToken(provider, credentials, log);
+
+export const refreshTokenByProvider = (provider, credentials) =>
+  _refreshTokenByProvider(provider, credentials, log);
+
+export const formatProviderCredentials = (provider, credentials) =>
+  _formatProviderCredentials(provider, credentials, log);
+
+export const getAllAccessTokens = (userInfo) =>
+  _getAllAccessTokens(userInfo, log);
+
+export const shouldRefreshCredentials = (provider, credentials) =>
+  _shouldRefreshCredentials(provider, credentials);
+
+export function releaseConnection(connectionId) {
+  if (!connectionId) return;
+  removeConnection(connectionId);
+  log.debug("TOKEN_REFRESH", "Released connection resources", { connectionId });
+}
+
+function toExpiresAt(expiresIn) {
+  return new Date(Date.now() + expiresIn * 1000).toISOString();
+}
+
+function normalizeExpiresAt(expiresAt) {
+  if (!expiresAt) return null;
+  const date = new Date(expiresAt);
+  if (!Number.isFinite(date.getTime())) return null;
+  return date.toISOString();
+}
+
+function needsProjectId(provider) {
+  return provider === "antigravity" || provider === "gemini-cli";
+}
+
+function _refreshProjectId(provider, connectionId, accessToken) {
+  if (!needsProjectId(provider) || !connectionId || !accessToken) return;
+
+  invalidateProjectId(connectionId);
+
+  getProjectIdForConnection(connectionId, accessToken)
+    .then((projectId) => {
+      if (!projectId) return;
+      updateProviderCredentials(connectionId, { projectId }).catch((err) => {
+        log.debug("TOKEN_REFRESH", "Failed to persist refreshed projectId", {
+          connectionId,
+          error: err?.message ?? err,
+        });
+      });
+    })
+    .catch((err) => {
+      log.debug("TOKEN_REFRESH", "Failed to fetch projectId after token refresh", {
+        connectionId,
+        error: err?.message ?? err,
+      });
+    });
+}
+
+export async function updateProviderCredentials(connectionId, newCredentials) {
+  try {
+    const updates = {};
+
+    if (newCredentials.accessToken)         updates.accessToken  = newCredentials.accessToken;
+    if (newCredentials.refreshToken)        updates.refreshToken = newCredentials.refreshToken;
+    if (newCredentials.idToken)             updates.idToken = newCredentials.idToken;
+    if (newCredentials.lastRefreshAt)       updates.lastRefreshAt = newCredentials.lastRefreshAt;
+    if (newCredentials.expiresAt)           updates.expiresAt = newCredentials.expiresAt;
+    if (newCredentials.expiresIn) {
+      updates.expiresAt = toExpiresAt(newCredentials.expiresIn);
+      updates.expiresIn = newCredentials.expiresIn;
+    } else if (newCredentials.expiresAt) {
+      const expiresAt = normalizeExpiresAt(newCredentials.expiresAt);
+      if (expiresAt) {
+        updates.expiresAt = expiresAt;
+        updates.expiresIn = Math.max(1, Math.floor((new Date(expiresAt).getTime() - Date.now()) / 1000));
+      }
+    }
+    if (newCredentials.providerSpecificData) {
+      updates.providerSpecificData = {
+        ...(newCredentials.existingProviderSpecificData || {}),
+        ...newCredentials.providerSpecificData,
+      };
+    }
+    if (newCredentials.copilotToken || newCredentials.copilotTokenExpiresAt) {
+      updates.providerSpecificData = {
+        ...(updates.providerSpecificData || newCredentials.existingProviderSpecificData || {}),
+        ...(newCredentials.copilotToken ? { copilotToken: newCredentials.copilotToken } : {}),
+        ...(newCredentials.copilotTokenExpiresAt ? { copilotTokenExpiresAt: newCredentials.copilotTokenExpiresAt } : {}),
+      };
+    }
+    if (newCredentials.projectId)            updates.projectId = newCredentials.projectId;
+    if (Object.prototype.hasOwnProperty.call(newCredentials, "testStatus")) {
+      updates.testStatus = newCredentials.testStatus;
+    }
+    if (Object.prototype.hasOwnProperty.call(newCredentials, "lastError")) {
+      updates.lastError = newCredentials.lastError;
+    }
+    if (Object.prototype.hasOwnProperty.call(newCredentials, "lastErrorAt")) {
+      updates.lastErrorAt = newCredentials.lastErrorAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(newCredentials, "errorCode")) {
+      updates.errorCode = newCredentials.errorCode;
+    }
+
+    const result = await updateProviderConnection(connectionId, updates);
+    log.info("TOKEN_REFRESH", "Credentials updated in localDb", {
+      connectionId,
+      success: !!result
+    });
+    return !!result;
+  } catch (error) {
+    log.error("TOKEN_REFRESH", "Error updating credentials in localDb", {
+      connectionId,
+      error: error.message,
+    });
+    return false;
+  }
+}
+
+export async function checkAndRefreshToken(provider, credentials, options = {}) {
+  let creds = { ...credentials };
+  if (!creds.connectionId && creds.id) {
+    creds.connectionId = creds.id;
+  }
+
+  const force = options?.force === true;
+
+  if (force || _shouldRefreshCredentials(provider, creds)) {
+    const expiresAt = creds.expiresAt ? new Date(creds.expiresAt).getTime() : null;
+    const remaining = expiresAt ? expiresAt - Date.now() : null;
+    const refreshLead = _getRefreshLeadMs(provider);
+
+    log.info("TOKEN_REFRESH", "Refreshing provider credentials proactively", {
+      provider,
+      expiresIn: remaining === null ? null : Math.round(remaining / 1000),
+      refreshLeadMs: refreshLead,
+      lastRefreshAt: creds.lastRefreshAt || null,
+    });
+
+    const newCreds = await _refreshProviderCredentials(provider, creds, log);
+    if (newCreds?.accessToken || newCreds?.apiKey || newCreds?.copilotToken) {
+      const mergedCreds = {
+        ...newCreds,
+        existingProviderSpecificData: creds.providerSpecificData,
+      };
+
+      await updateProviderCredentials(creds.connectionId, mergedCreds);
+
+      creds = {
+        ...creds,
+        ...newCreds,
+        expiresAt: newCreds.expiresIn
+          ? toExpiresAt(newCreds.expiresIn)
+          : normalizeExpiresAt(newCreds.expiresAt) || newCreds.expiresAt || creds.expiresAt,
+        providerSpecificData: newCreds.providerSpecificData
+          ? { ...creds.providerSpecificData, ...newCreds.providerSpecificData }
+          : creds.providerSpecificData,
+      };
+
+      _refreshProjectId(provider, creds.connectionId, creds.accessToken);
+    }
+  }
+
+  if (provider === "github") {
+    const copilotToken = creds.providerSpecificData?.copilotToken;
+    const copilotExpiresAt = creds.providerSpecificData?.copilotTokenExpiresAt
+      ? creds.providerSpecificData.copilotTokenExpiresAt * 1000
+      : 0;
+    const now              = Date.now();
+    const remaining        = copilotExpiresAt - now;
+
+    if (!copilotToken || remaining < TOKEN_EXPIRY_BUFFER_MS) {
+      log.info("TOKEN_REFRESH", "Copilot token expiring soon or missing, refreshing proactively", {
+        provider,
+        expiresIn: copilotToken ? Math.round(remaining / 1000) : "missing",
+      });
+
+      const copilotTokenResult = await refreshCopilotToken(creds.accessToken);
+      if (copilotTokenResult) {
+        const updatedSpecific = {
+          ...creds.providerSpecificData,
+          copilotToken:          copilotTokenResult.token,
+          copilotTokenExpiresAt: copilotTokenResult.expiresAt,
+        };
+
+        await updateProviderCredentials(creds.connectionId, {
+          providerSpecificData: updatedSpecific,
+        });
+
+        creds.providerSpecificData = updatedSpecific;
+        creds.copilotToken = copilotTokenResult.token;
+      }
+    }
+  }
+
+  return creds;
+}
+
+export async function refreshGitHubAndCopilotTokens(credentials) {
+  const newGitHubCreds = await refreshGitHubToken(credentials.refreshToken);
+  if (!newGitHubCreds?.accessToken) return newGitHubCreds;
+
+  const copilotToken = await refreshCopilotToken(newGitHubCreds.accessToken);
+  if (!copilotToken) return newGitHubCreds;
+
+  return {
+    ...newGitHubCreds,
+    providerSpecificData: {
+      copilotToken:          copilotToken.token,
+      copilotTokenExpiresAt: copilotToken.expiresAt,
+    },
+  };
+}

package/src/sse/utils/logger.js

@@ -0,0 +1,142 @@
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+
+const LEVEL = LOG_LEVELS[process.env.LOG_LEVEL?.toUpperCase?.()] ?? LOG_LEVELS.INFO;
+const ANSI = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  magenta: "\x1b[35m",
+};
+
+const USE_COLOR = process.env.NO_COLOR === undefined
+  && (process.env.FORCE_COLOR === "1" || process.stdout?.isTTY === true);
+
+function color(value, code) {
+  return USE_COLOR ? `${code}${value}${ANSI.reset}` : value;
+}
+
+function formatTime() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false });
+}
+
+export function formatLine(tag, label, message) {
+  const tagText = tag ? color(tag, ANSI.cyan) : "--";
+  const labelColors = {
+    START: ANSI.green,
+    FETCH: ANSI.cyan,
+    RESPONSE: ANSI.green,
+    RETRY: ANSI.yellow,
+    DONE: ANSI.green,
+    WARN: ANSI.yellow,
+    ERROR: ANSI.red,
+    FALLBACK: ANSI.magenta,
+    LOCK: ANSI.yellow,
+    DEBUG: ANSI.dim,
+  };
+  const labelText = labelColors[label] ? color(label, labelColors[label]) : label;
+  return `[${formatTime()}] ${tagText} ${labelText} ${message}`;
+}
+
+const REQ_TAGS = ["R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8"];
+let tagCursor = 0;
+
+export function nextTag() {
+  const tag = REQ_TAGS[tagCursor % REQ_TAGS.length];
+  tagCursor++;
+  return tag;
+}
+
+export function tagForSession(seed) {
+  if (!seed) return nextTag();
+  let h = 0;
+  for (let i = 0; i < seed.length; i++) h = (h * 31 + seed.charCodeAt(i)) | 0;
+  return REQ_TAGS[Math.abs(h) % REQ_TAGS.length];
+}
+
+export function line(tag, symbol, message) {
+  if (LEVEL > LOG_LEVELS.INFO) return;
+  console.log(formatLine(tag, symbol, message));
+}
+
+export function errorLine(tag, symbol, message) {
+  console.log(formatLine(tag, symbol, message));
+}
+
+export function fmtThink(intent) {
+  if (!intent || !intent.mode) return null;
+  if (intent.mode === "none") return "off";
+  if (intent.mode === "auto") return "auto";
+  if (intent.mode === "budget") {
+    const k = intent.budget >= 1000 ? `${Math.round(intent.budget / 1000)}k` : `${intent.budget}`;
+    return k;
+  }
+  if (intent.mode === "level") return intent.level;
+  return null;
+}
+
+function formatData(data) {
+  if (!data) return "";
+  if (typeof data === "string") return data;
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return String(data);
+  }
+}
+
+export function debug(tag, message, data) {
+  if (LEVEL <= LOG_LEVELS.DEBUG) {
+    const dataStr = data ? ` ${formatData(data)}` : "";
+    console.log(`[${formatTime()}] DEBUG [${tag}] ${message}${dataStr}`);
+  }
+}
+
+export function info(tag, message, data) {
+  if (LEVEL <= LOG_LEVELS.INFO) {
+    const dataStr = data ? ` ${formatData(data)}` : "";
+    console.log(`[${formatTime()}] INFO [${tag}] ${message}${dataStr}`);
+  }
+}
+
+export function warn(tag, message, data) {
+  if (LEVEL <= LOG_LEVELS.WARN) {
+    const dataStr = data ? ` ${formatData(data)}` : "";
+    console.warn(`[${formatTime()}] WARN [${tag}] ${message}${dataStr}`);
+  }
+}
+
+export function error(tag, message, data) {
+  if (LEVEL <= LOG_LEVELS.ERROR) {
+    const dataStr = data ? ` ${formatData(data)}` : "";
+    console.log(`[${formatTime()}] ERROR [${tag}] ${message}${dataStr}`);
+  }
+}
+
+export function request(method, path, extra) {
+  const dataStr = extra ? ` ${formatData(extra)}` : "";
+  console.log(`\x1b[36m[${formatTime()}] REQUEST ${method} ${path}${dataStr}\x1b[0m`);
+}
+
+export function response(status, duration, extra) {
+  const label = status < 400 ? "RESPONSE" : "RESPONSE_ERROR";
+  const dataStr = extra ? ` ${formatData(extra)}` : "";
+  console.log(`[${formatTime()}] ${label} ${status} (${duration}ms)${dataStr}`);
+}
+
+export function stream(event, data) {
+  const dataStr = data ? ` ${formatData(data)}` : "";
+  console.log(`[${formatTime()}] STREAM ${event}${dataStr}`);
+}
+
+export function maskKey(key) {
+  if (!key || key.length < 8) return "***";
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}

package/src/staticServe.ts

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, join, normalize, sep } from "node:path";
+
+function resolveDashboardDist(): string {
+  const candidates = [
+    join(import.meta.dir, "..", "dashboard", "dist"),
+    join(process.cwd(), "dashboard", "dist"),
+    join(process.cwd(), "dist-binary", "dashboard", "dist"),
+  ];
+  return candidates.find((candidate) => existsSync(candidate)) || candidates[0]!;
+}
+
+const DIST_DIR = resolveDashboardDist();
+const INDEX_HTML = join(DIST_DIR, "index.html");
+
+const CONTENT_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".txt": "text/plain; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+};
+
+const API_PREFIXES = ["/api", "/v1", "/codex", "/responses", "/health", "/version", "/metrics"];
+
+function isApiPath(pathname: string): boolean {
+  return API_PREFIXES.some((p) => pathname === p || pathname.startsWith(`${p}/`));
+}
+
+function serveFile(filePath: string, request: Request): Response {
+  const stat = statSync(filePath);
+  const type = CONTENT_TYPES[extname(filePath).toLowerCase()] || "application/octet-stream";
+
+  const since = request.headers.get("if-modified-since");
+  if (since) {
+    const sinceMs = Date.parse(since);
+    if (!Number.isNaN(sinceMs) && Math.floor(stat.mtimeMs / 1000) * 1000 <= sinceMs) {
+      return new Response(null, { status: 304 });
+    }
+  }
+
+  const body = readFileSync(filePath);
+  const isImmutable = filePath.includes(`${sep}assets${sep}`);
+  return new Response(body, {
+    headers: {
+      "content-type": type,
+      "cache-control": isImmutable ? "public, max-age=31536000, immutable" : "no-cache",
+      "last-modified": stat.mtime.toUTCString(),
+      "x-content-type-options": "nosniff",
+    },
+  });
+}
+
+export function tryServeDashboard(request: Request): Response | null {
+  if (!existsSync(DIST_DIR)) return null;
+
+  const url = new URL(request.url);
+  let pathname: string;
+  try {
+    pathname = decodeURIComponent(url.pathname);
+  } catch {
+
+    return null;
+  }
+
+  if (isApiPath(pathname)) return null;
+  if (pathname.includes("..")) return null;
+
+  const filePath = normalize(join(DIST_DIR, pathname));
+
+  if (filePath !== DIST_DIR && !filePath.startsWith(DIST_DIR + sep)) return null;
+
+  if (existsSync(filePath) && statSync(filePath).isFile()) {
+    return serveFile(filePath, request);
+  }
+
+  if (!extname(pathname)) {
+    if (existsSync(INDEX_HTML)) return serveFile(INDEX_HTML, request);
+    return null;
+  }
+
+  return null;
+}