swayrouter 1.0.0

package/src/lib/tunnel/cloudflare/requirements.js

@@ -0,0 +1,12 @@
+export function getTunnelEnableError(settings) {
+  if (settings?.requireApiKey !== true) {
+    return 'Enable "Require API key" before activating the tunnel.';
+  }
+  if (settings?.requireLogin !== true) {
+    return 'Enable "Require login" before activating the tunnel.';
+  }
+  if (!settings?.password) {
+    return "Set a custom dashboard password before activating the tunnel.";
+  }
+  return null;
+}

package/src/lib/tunnel/index.js

@@ -0,0 +1,26 @@
+export {
+  enableTunnel,
+  disableTunnel,
+  getTunnelStatus,
+  isTunnelManuallyDisabled,
+  isTunnelReconnecting,
+  getTunnelService,
+  setTunnelUnexpectedExitCallback,
+} from "./cloudflare/manager.js";
+export {
+  killCloudflared,
+  isCloudflaredRunning,
+  ensureCloudflared,
+  getDownloadStatus,
+} from "./cloudflare/cloudflared.js";
+export { probeUrlAlive as probeCloudflareAlive } from "./cloudflare/healthCheck.js";
+
+export { loadState, generateShortId } from "./shared/state.js";
+export { checkInternet } from "./shared/internetCheck.js";
+export {
+  RESTART_COOLDOWN_MS,
+  NETWORK_SETTLE_MS,
+  WATCHDOG_INTERVAL_MS,
+  NETWORK_CHECK_INTERVAL_MS,
+  VIRTUAL_IFACE_REGEX,
+} from "./shared/watchdogConfig.js";

package/src/lib/tunnel/shared/dnsResolver.js

@@ -0,0 +1,16 @@
+import dns from "dns";
+
+const resolver = new dns.promises.Resolver();
+resolver.setServers(["1.1.1.1", "1.0.0.1", "8.8.8.8"]);
+
+export async function resolveDns(hostname, timeoutMs) {
+  const tryResolver = (resolve) => {
+    const timeout = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("dns timeout")), timeoutMs);
+    });
+    return Promise.race([resolve(), timeout]).then(() => true).catch(() => false);
+  };
+
+  if (await tryResolver(() => resolver.resolve4(hostname))) return true;
+  return tryResolver(() => dns.promises.resolve4(hostname));
+}

package/src/lib/tunnel/shared/internetCheck.js

@@ -0,0 +1,30 @@
+import net from "net";
+
+const INTERNET_CHECK = {
+  host: "1.1.1.1",
+  port: 443,
+  timeoutMs: 3000,
+};
+
+function closeSocket(socket) {
+  try { socket.destroy(); } catch {}
+}
+
+export function checkInternet() {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let done = false;
+    const finish = (ok) => {
+      if (done) return;
+      done = true;
+      closeSocket(socket);
+      resolve(ok);
+    };
+    socket.setTimeout(INTERNET_CHECK.timeoutMs);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    try { socket.connect(INTERNET_CHECK.port, INTERNET_CHECK.host); }
+    catch { finish(false); }
+  });
+}

package/src/lib/tunnel/shared/state.js

@@ -0,0 +1,45 @@
+import fs from "fs";
+import path from "path";
+import { DATA_DIR } from "@/lib/dataDir.js";
+
+const TUNNEL_DIR = path.join(DATA_DIR, "tunnel");
+const STATE_FILE = path.join(TUNNEL_DIR, "state.json");
+
+const SHORT_ID_LENGTH = 6;
+const SHORT_ID_CHARS = "abcdefghijklmnpqrstuvwxyz23456789";
+
+function fileExists(file) {
+  return fs.existsSync(file);
+}
+
+export function ensureTunnelDir() {
+  if (!fileExists(TUNNEL_DIR)) fs.mkdirSync(TUNNEL_DIR, { recursive: true });
+}
+
+export function loadState() {
+  try {
+    if (fileExists(STATE_FILE)) return JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
+  } catch {}
+  return null;
+}
+
+export function saveState(state) {
+  ensureTunnelDir();
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+export function clearState() {
+  try {
+    if (fileExists(STATE_FILE)) fs.unlinkSync(STATE_FILE);
+  } catch {}
+}
+
+export function generateShortId() {
+  let result = "";
+  for (let i = 0; i < SHORT_ID_LENGTH; i++) {
+    result += SHORT_ID_CHARS.charAt(Math.floor(Math.random() * SHORT_ID_CHARS.length));
+  }
+  return result;
+}
+
+export { TUNNEL_DIR };

package/src/lib/tunnel/shared/watchdogConfig.js

@@ -0,0 +1,6 @@
+export const RESTART_COOLDOWN_MS = 120000;
+export const NETWORK_SETTLE_MS = 2500;
+export const WATCHDOG_INTERVAL_MS = 60000;
+export const NETWORK_CHECK_INTERVAL_MS = 5000;
+
+export const VIRTUAL_IFACE_REGEX = /^(utun|awdl|llw|anpi|bridge|gif|stf|ipsec|ap|tun|tap|vmnet|veth|docker)/i;

package/src/lib/update/installer.js

@@ -0,0 +1,52 @@
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import pkg from "../../../package.json" with { type: "json" };
+
+function isDockerRuntime() {
+  return process.env.SWAYROUTER_RUNTIME_MODE === "docker"
+    || process.env.DATA_DIR === "/app/data"
+    || existsSync("/.dockerenv");
+}
+
+export function canInstallUpdate() {
+  return pkg.private !== true && !isDockerRuntime();
+}
+
+function updateCommand() {
+  const customCommand = String(process.env.SWAYROUTER_PACKAGE_MANAGER_PATH || "").trim();
+  if (customCommand) return { command: customCommand, args: ["install", "--global"] };
+
+  const preferred = String(process.env.SWAYROUTER_PACKAGE_MANAGER || "").trim().toLowerCase();
+  if (preferred === "npm") return { command: "npm", args: ["install", "--global"] };
+  if (preferred === "bun") return { command: process.execPath, args: ["install", "--global"] };
+  return { command: process.execPath, args: ["install", "--global"] };
+}
+
+export function installPackageVersion(version) {
+  if (!canInstallUpdate()) {
+    return Promise.reject(new Error("Package updates are unavailable for this runtime"));
+  }
+  const spec = `${pkg.name || "swayrouter"}@${version}`;
+  const update = updateCommand();
+  return new Promise((resolve, reject) => {
+    const child = spawn(update.command, [...update.args, spec], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    let output = "";
+    const capture = (chunk) => {
+      output += String(chunk);
+      if (output.length > 4000) output = output.slice(-4000);
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    child.once("error", reject);
+    child.once("close", (code) => {
+      if (code === 0) {
+        resolve({ version, packageName: pkg.name || "swayrouter", manager: update.command, output });
+      } else {
+        reject(new Error(`${update.command} install failed${code === null ? "" : ` with exit code ${code}`}`));
+      }
+    });
+  });
+}

package/src/lib/update/version.js

@@ -0,0 +1,116 @@
+import pkg from "../../../package.json" with { type: "json" };
+
+const CHECK_TTL_MS = 6 * 60 * 60 * 1000;
+const REQUEST_TIMEOUT_MS = 4000;
+
+let cachedCheck = null;
+
+function packageName() {
+  return process.env.SWAYROUTER_PACKAGE_NAME || pkg.name || "swayrouter";
+}
+
+function registryUrl() {
+  return String(process.env.SWAYROUTER_NPM_REGISTRY || "https://registry.npmjs.org").replace(/\/+$/, "");
+}
+
+function normalizeVersion(value) {
+  const match = String(value || "").trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) return null;
+  return {
+    raw: String(value).trim(),
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : [],
+  };
+}
+
+function comparePrerelease(a, b) {
+  if (!a.length && !b.length) return 0;
+  if (!a.length) return 1;
+  if (!b.length) return -1;
+
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    const left = a[index];
+    const right = b[index];
+    if (left === undefined) return -1;
+    if (right === undefined) return 1;
+    if (left === right) continue;
+
+    const leftNumber = /^\d+$/.test(left) ? Number(left) : null;
+    const rightNumber = /^\d+$/.test(right) ? Number(right) : null;
+    if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+    if (leftNumber !== null) return -1;
+    if (rightNumber !== null) return 1;
+    return left < right ? -1 : 1;
+  }
+  return 0;
+}
+
+export function compareVersions(left, right) {
+  const a = normalizeVersion(left);
+  const b = normalizeVersion(right);
+  if (!a || !b) return 0;
+  if (a.major !== b.major) return a.major - b.major;
+  if (a.minor !== b.minor) return a.minor - b.minor;
+  if (a.patch !== b.patch) return a.patch - b.patch;
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+
+export function isNewerVersion(currentVersion, latestVersion) {
+  return Boolean(normalizeVersion(currentVersion) && normalizeVersion(latestVersion)
+    && compareVersions(latestVersion, currentVersion) > 0);
+}
+
+async function fetchLatestVersion(fetchImpl = globalThis.fetch) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetchImpl(
+      `${registryUrl()}/${encodeURIComponent(packageName())}/latest`,
+      {
+        headers: { accept: "application/json" },
+        signal: controller.signal,
+      },
+    );
+    if (response.status === 404) return null;
+    if (!response.ok) throw new Error(`registry returned ${response.status}`);
+    const body = await response.json();
+    return typeof body?.version === "string" ? body.version.trim() : null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function checkForUpdate({ force = false, fetchImpl = globalThis.fetch } = {}) {
+  const currentVersion = String(pkg.version || "0.0.0");
+  const now = Date.now();
+  if (!force && cachedCheck && now - cachedCheck.timestamp < CHECK_TTL_MS) {
+    return { ...cachedCheck.value };
+  }
+
+  let latestVersion = null;
+  let checkError = null;
+  try {
+    latestVersion = await fetchLatestVersion(fetchImpl);
+  } catch (error) {
+    checkError = error instanceof Error ? error.message : String(error);
+  }
+
+  const value = {
+    packageName: packageName(),
+    currentVersion,
+    latestVersion,
+    updateAvailable: isNewerVersion(currentVersion, latestVersion),
+    updateSupported: pkg.private !== true && Boolean(latestVersion),
+    checkedAt: new Date().toISOString(),
+    checkError,
+  };
+  cachedCheck = { timestamp: now, value };
+  return { ...value };
+}
+
+export function resetUpdateCheckCache() {
+  cachedCheck = null;
+}

package/src/lib/usageDb.js

@@ -0,0 +1,6 @@
+export {
+  statsEmitter, trackPendingRequest, getActiveRequests,
+  saveRequestUsage, clearUsageHistory, getUsageHistory, getUsageHistoryPage, getUsageStats, getChartData,
+  appendRequestLog, getRecentLogs, searchLogs,
+  saveRequestDetail, getRequestDetails, getRequestDetailById,
+} from "@/lib/db/index.js";

package/src/lib/usageRefresh.js

@@ -0,0 +1,88 @@
+import { updateProviderConnection } from "@/lib/localDb";
+import { getExecutor } from "../executors/index.js";
+
+export async function refreshAndUpdateCredentials(connection, force = false, proxyOptions = null) {
+  const executor = getExecutor(connection.provider);
+
+  const credentials = {
+    accessToken: connection.accessToken,
+    refreshToken: connection.refreshToken,
+    idToken: connection.idToken,
+    expiresAt: connection.expiresAt || connection.tokenExpiresAt,
+    lastRefreshAt: connection.lastRefreshAt,
+    connectionId: connection.id,
+    providerSpecificData: connection.providerSpecificData,
+
+    copilotToken: connection.providerSpecificData?.copilotToken,
+    copilotTokenExpiresAt: connection.providerSpecificData?.copilotTokenExpiresAt,
+  };
+
+  const needsRefresh = force || executor.needsRefresh(credentials);
+
+  if (!needsRefresh) {
+    return { connection, refreshed: false };
+  }
+
+  const refreshResult = await executor.refreshCredentials(credentials, console, proxyOptions);
+
+  if (!refreshResult) {
+
+    if (connection.accessToken) {
+      return { connection, refreshed: false };
+    }
+    throw new Error("Failed to refresh credentials. Please re-authorize the connection.");
+  }
+
+  const now = new Date().toISOString();
+  const updateData = {
+    updatedAt: now,
+  };
+
+  if (refreshResult.accessToken) {
+    updateData.accessToken = refreshResult.accessToken;
+  }
+
+  if (refreshResult.refreshToken) {
+    updateData.refreshToken = refreshResult.refreshToken;
+  }
+
+  if (refreshResult.idToken) {
+    updateData.idToken = refreshResult.idToken;
+  }
+
+  if (refreshResult.lastRefreshAt) {
+    updateData.lastRefreshAt = refreshResult.lastRefreshAt;
+  }
+
+  if (refreshResult.expiresIn) {
+    updateData.expiresAt = new Date(Date.now() + refreshResult.expiresIn * 1000).toISOString();
+    updateData.expiresIn = refreshResult.expiresIn;
+  } else if (refreshResult.expiresAt) {
+    updateData.expiresAt = refreshResult.expiresAt;
+  }
+
+  const providerSpecificUpdates = {
+    ...(refreshResult.providerSpecificData || {}),
+    ...(refreshResult.copilotToken ? { copilotToken: refreshResult.copilotToken } : {}),
+    ...(refreshResult.copilotTokenExpiresAt ? { copilotTokenExpiresAt: refreshResult.copilotTokenExpiresAt } : {}),
+  };
+  if (Object.keys(providerSpecificUpdates).length > 0) {
+    updateData.providerSpecificData = {
+      ...(connection.providerSpecificData || {}),
+      ...providerSpecificUpdates,
+    };
+  }
+
+  await updateProviderConnection(connection.id, updateData);
+
+  const updatedConnection = {
+    ...connection,
+    ...updateData,
+    providerSpecificData: updateData.providerSpecificData || connection.providerSpecificData,
+  };
+
+  return {
+    connection: updatedConnection,
+    refreshed: true,
+  };
+}

package/src/lifecycle/appLifecycle.ts

@@ -0,0 +1,99 @@
+export type LifecycleState = "starting" | "ready" | "degraded" | "stopping" | "stopped";
+
+export interface LifecycleSnapshot {
+  state: LifecycleState;
+  startedAt: string | null;
+  readyAt: string | null;
+  lastError: string | null;
+}
+
+export type ShutdownHandler = (exitCode?: number) => void | Promise<void>;
+export type ShutdownRequestResult =
+  | "accepted"
+  | "already_requested"
+  | "unavailable";
+
+const initialSnapshot: LifecycleSnapshot = {
+  state: "starting",
+  startedAt: null,
+  readyAt: null,
+  lastError: null,
+};
+
+let snapshot: LifecycleSnapshot = { ...initialSnapshot };
+let shutdownHandler: ShutdownHandler | null = null;
+let shutdownRequestState: "idle" | "accepted" = "idle";
+
+export function registerShutdownHandler(handler: ShutdownHandler): () => void {
+  shutdownHandler = handler;
+  shutdownRequestState = "idle";
+
+  return () => {
+    if (shutdownHandler === handler) {
+      shutdownHandler = null;
+      shutdownRequestState = "idle";
+    }
+  };
+}
+
+export function requestShutdown(exitCode = 0): ShutdownRequestResult {
+  if (!shutdownHandler) return "unavailable";
+  if (shutdownRequestState === "accepted") return "already_requested";
+
+  shutdownRequestState = "accepted";
+  const handler = shutdownHandler;
+  const timer = setTimeout(() => {
+    try {
+      void Promise.resolve(handler(exitCode)).catch((error) => {
+        console.error(
+          "[lifecycle] shutdown request failed:",
+          error instanceof Error ? error.message : String(error),
+        );
+      });
+    } catch (error) {
+      console.error(
+        "[lifecycle] shutdown request failed:",
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }, 100);
+  // The pending shutdown should not keep a test process alive by itself.
+  // @ts-ignore - Bun's Timer has unref; Node's typing doesn't expose it here.
+  timer.unref?.();
+
+  return "accepted";
+}
+
+export function markLifecycleStarted(at = new Date().toISOString()): void {
+  snapshot = { ...snapshot, state: "starting", startedAt: at, lastError: null };
+}
+
+export function markLifecycleReady(at = new Date().toISOString()): void {
+  snapshot = { ...snapshot, state: "ready", readyAt: at, lastError: null };
+}
+
+export function markLifecycleDegraded(error: unknown): void {
+  snapshot = {
+    ...snapshot,
+    state: "degraded",
+    lastError: error instanceof Error ? error.message : String(error || "unknown error"),
+  };
+}
+
+export function markLifecycleStopping(): void {
+  snapshot = { ...snapshot, state: "stopping" };
+}
+
+export function markLifecycleStopped(): void {
+  snapshot = { ...snapshot, state: "stopped" };
+}
+
+export function getLifecycleSnapshot(): LifecycleSnapshot {
+  return { ...snapshot };
+}
+
+export function resetLifecycleForTests(): void {
+  snapshot = { ...initialSnapshot };
+  shutdownHandler = null;
+  shutdownRequestState = "idle";
+}

package/src/models.js

@@ -0,0 +1,36 @@
+export {
+  getProviderConnections,
+  getProviderConnectionById,
+  getProviderConnectionsForRouting,
+  getProviderConnectionsPaged,
+  countProviderConnections,
+  countConnectionsByProxyPool,
+  createProviderConnection,
+  updateProviderConnection,
+  deleteProviderConnection,
+  getProviderNodes,
+  getProviderNodeById,
+  createProviderNode,
+  updateProviderNode,
+  deleteProviderNode,
+  getProxyPools,
+  getProxyPoolById,
+  createProxyPool,
+  updateProxyPool,
+  deleteProxyPool,
+  deleteProviderConnectionsByProvider,
+  getCombos,
+  getComboById,
+  getComboByName,
+  createCombo,
+  updateCombo,
+  deleteCombo,
+  getCustomModels,
+  addCustomModel,
+  deleteCustomModel,
+  getApiKeys,
+  createApiKey,
+  deleteApiKey,
+  validateApiKey,
+  isCloudEnabled,
+} from "@/lib/localDb";

package/src/next/headers.js

@@ -0,0 +1,12 @@
+import { cookieStoreAls } from "./server.js";
+
+export function cookies() {
+  const store = cookieStoreAls.getStore();
+  if (!store) throw new Error("cookies() called outside request scope");
+  return store.cookies;
+}
+
+export function headers() {
+  const store = cookieStoreAls.getStore();
+  return store ? store.headers : new Headers();
+}

package/src/next/server.js

@@ -0,0 +1,74 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export const cookieStoreAls = new AsyncLocalStorage();
+
+export const PASSTHROUGH = Symbol("nextResponse.next");
+
+export function createCookieStore(initial = new Map()) {
+  const map = new Map();
+  for (const [name, value] of initial) map.set(name, { name, value });
+  const store = {
+    map,
+    __set: [],
+    __dirty: false,
+    set(name, value, opts = {}) {
+      map.set(name, { name, value });
+      const parts = [`${name}=${encodeURIComponent(value)}`];
+      if (opts.httpOnly) parts.push("HttpOnly");
+      if (opts.secure) parts.push("Secure");
+      if (opts.sameSite) parts.push(`SameSite=${opts.sameSite}`);
+      if (opts.path) parts.push(`Path=${opts.path}`);
+      if (opts.maxAge !== undefined) parts.push(`Max-Age=${opts.maxAge}`);
+      if (opts.expires) {
+        parts.push(`Expires=${opts.expires instanceof Date ? opts.expires.toUTCString() : opts.expires}`);
+      }
+      store.__set.push(parts.join("; "));
+      store.__dirty = true;
+      return store;
+    },
+    get(name) {
+      const v = map.get(name);
+      return v ? { name, value: v.value } : undefined;
+    },
+    getAll() {
+      return [...map.values()];
+    },
+    has(name) {
+      return map.has(name);
+    },
+    delete(name) {
+      map.delete(name);
+      store.__set.push(`${name}=; Max-Age=0; Path=/`);
+      store.__dirty = true;
+      return true;
+    },
+  };
+  return store;
+}
+
+export class NextResponse extends Response {
+  constructor(body, init = {}) {
+    super(body, init);
+  }
+
+  static json(data, init = {}) {
+    const headers = new Headers(init.headers);
+    if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    return new NextResponse(JSON.stringify(data), { ...init, headers });
+  }
+
+  static redirect(url, init = {}) {
+    return new NextResponse(null, {
+      status: init.status ?? 307,
+      headers: { location: String(url), ...(init.headers || {}) },
+    });
+  }
+
+  static next(init = {}) {
+    const res = new NextResponse(null, init);
+    res[PASSTHROUGH] = true;
+    return res;
+  }
+}
+
+export const NextRequest = Request;