wyxrouter 0.4.71

package/src/shared/hooks/useCopyToClipboard.js

@@ -0,0 +1,43 @@
+"use client";
+
+import { useState, useCallback, useRef } from "react";
+
+/**
+ * Hook for copy to clipboard with feedback
+ * @param {number} resetDelay - Time in ms before resetting copied state (default: 2000)
+ * @returns {{ copied: string|null, copy: (text: string, id?: string) => void }}
+ */
+export function useCopyToClipboard(resetDelay = 2000) {
+  const [copied, setCopied] = useState(null);
+  const timeoutRef = useRef(null);
+
+  const copy = useCallback((text, id = "default") => {
+    const write = async () => {
+      if (navigator?.clipboard?.writeText) {
+        await navigator.clipboard.writeText(text);
+      } else {
+        const textarea = document.createElement("textarea");
+        textarea.value = text;
+        textarea.style.position = "fixed";
+        textarea.style.opacity = "0";
+        document.body.appendChild(textarea);
+        textarea.select();
+        document.execCommand("copy");
+        document.body.removeChild(textarea);
+      }
+    };
+    write();
+    setCopied(id);
+
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+
+    timeoutRef.current = setTimeout(() => {
+      setCopied(null);
+    }, resetDelay);
+  }, [resetDelay]);
+
+  return { copied, copy };
+}
+

package/src/shared/hooks/useTheme.js

@@ -0,0 +1,60 @@
+"use client";
+
+import { useEffect, useState, useSyncExternalStore } from "react";
+import useThemeStore from "@/store/themeStore";
+
+// Subscribe to system theme changes
+function subscribeToSystemTheme(callback) {
+  if (typeof window === "undefined") return () => {};
+  const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+  mediaQuery.addEventListener("change", callback);
+  return () => mediaQuery.removeEventListener("change", callback);
+}
+
+// Get current system theme preference
+function getSystemThemeSnapshot() {
+  if (typeof window === "undefined") return false;
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+
+// Server snapshot always returns false
+function getServerSnapshot() {
+  return false;
+}
+
+export function useTheme() {
+  const { theme, setTheme, toggleTheme, initTheme } = useThemeStore();
+
+  // Use useSyncExternalStore to safely subscribe to system theme
+  const systemPrefersDark = useSyncExternalStore(
+    subscribeToSystemTheme,
+    getSystemThemeSnapshot,
+    getServerSnapshot
+  );
+
+  useEffect(() => {
+    initTheme();
+  }, [initTheme]);
+
+  // Listen for system theme changes when theme is "system"
+  useEffect(() => {
+    if (theme !== "system") return;
+
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = () => initTheme();
+
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [theme, initTheme]);
+
+  // Compute isDark from current state (no effect needed)
+  const isDark = theme === "dark" || (theme === "system" && systemPrefersDark);
+
+  return {
+    theme,
+    setTheme,
+    toggleTheme,
+    isDark,
+  };
+}
+

package/src/shared/services/bootstrap.js

@@ -0,0 +1,12 @@
+import initializeApp from "./initializeApp.js";
+
+// Skip during Next.js build/prerender — bootstrap would download cloudflared, init DNS, etc.
+const isBuildPhase = process.env.NEXT_PHASE === "phase-production-build"
+  || process.env.NEXT_PHASE === "phase-export"
+  || process.env.NEXT_PHASE === "phase-static";
+
+// Server-only singleton: guard via global so HMR / re-imports don't double-init
+if (typeof window === "undefined" && !isBuildPhase && !global.__appBootstrapped) {
+  global.__appBootstrapped = true;
+  initializeApp().catch((e) => console.error("[Bootstrap] init failed:", e.message));
+}

package/src/shared/services/initializeApp.js

@@ -0,0 +1,268 @@
+import os from "os";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+import { cleanupProviderConnections, getSettings, updateSettings, getApiKeys } from "@/lib/localDb";
+import {
+  enableTunnel, enableTailscale,
+  isTunnelManuallyDisabled, isTunnelReconnecting, isTailscaleReconnecting,
+  getTunnelService, getTailscaleService, setTunnelUnexpectedExitCallback,
+  killCloudflared, isCloudflaredRunning, ensureCloudflared,
+  isTailscaleRunning, isTailscaleRunningStrict,
+  checkInternet,
+  RESTART_COOLDOWN_MS, NETWORK_SETTLE_MS,
+  WATCHDOG_INTERVAL_MS, NETWORK_CHECK_INTERVAL_MS, VIRTUAL_IFACE_REGEX,
+} from "@/lib/tunnel";
+import { getMitmStatus, startMitm, loadEncryptedPassword, initDbHooks, restoreToolDNS, removeAllDNSEntriesSync } from "@/mitm/manager";
+import { syncToJson as syncMitmAliasCache } from "@/lib/mitmAliasCache";
+
+// Inject correct paths and DB hooks into manager.js (CJS) from ESM context
+(function bootstrapMitm() {
+  if (!process.env.MITM_SERVER_PATH) {
+    try {
+      const thisFile = fileURLToPath(import.meta.url);
+      const appSrc = dirname(dirname(thisFile));
+      const candidate = join(appSrc, "mitm", "server.js");
+      if (existsSync(candidate)) process.env.MITM_SERVER_PATH = candidate;
+    } catch { /* ignore */ }
+  }
+  try { initDbHooks(getSettings, updateSettings); } catch { /* ignore */ }
+})();
+
+process.setMaxListeners(20);
+
+// Survive Next.js hot reload
+const g = global.__appSingleton ??= {
+  signalHandlersRegistered: false,
+  watchdogInterval: null,
+  networkMonitorInterval: null,
+  lastNetworkFingerprint: null,
+  lastWatchdogTick: Date.now(),
+  lastOnline: null,
+  mitmStartInProgress: false,
+  tunnelAutoResumed: false,
+  tailscaleAutoResumed: false,
+};
+
+export async function initializeApp() {
+  try {
+    await cleanupProviderConnections();
+    const settings = await getSettings();
+
+    // Auto-resume tunnel (once per process)
+    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));
+    }
+
+    // Auto-resume tailscale (once per process)
+    if (settings.tailscaleEnabled && !g.tailscaleAutoResumed) {
+      g.tailscaleAutoResumed = true;
+      console.log("[InitApp] Tailscale was enabled, auto-resuming...");
+      safeRestartTailscale("startup").catch((e) => console.log("[InitApp] Tailscale resume failed:", e.message));
+    }
+
+    if (!g.signalHandlersRegistered) {
+      const cleanup = () => {
+        try { removeAllDNSEntriesSync(); } catch { /* best effort */ }
+        killCloudflared();
+        process.exit();
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      process.on("exit", () => { try { removeAllDNSEntriesSync(); } catch { /* ignore */ } });
+      g.signalHandlersRegistered = true;
+    }
+
+    ensureCloudflared().catch(() => {});
+
+    // Sync mitmAlias DB → JSON cache so standalone MITM server can read it
+    syncMitmAliasCache().catch(() => {});
+
+    // Auto-respawn tunnel when cloudflared exits unexpectedly (e.g. network change drop)
+    setTunnelUnexpectedExitCallback(() => {
+      safeRestartTunnel("unexpected-exit").catch(() => {});
+    });
+
+    startWatchdog();
+    startNetworkMonitor();
+    autoStartMitm();
+  } catch (error) {
+    console.error("[InitApp] Error:", error);
+  }
+}
+
+async function autoStartMitm() {
+  if (g.mitmStartInProgress) return;
+  g.mitmStartInProgress = true;
+  try {
+    const settings = await getSettings();
+    if (!settings.mitmEnabled) return;
+    const mitmStatus = await getMitmStatus();
+    if (mitmStatus.running) return;
+
+    const password = await loadEncryptedPassword();
+    if (!password && process.platform !== "win32") {
+      console.log("[InitApp] MITM was enabled but no saved password found, skipping auto-start");
+      return;
+    }
+
+    const keys = await getApiKeys();
+    const activeKey = keys.find(k => k.isActive !== false);
+
+    console.log("[InitApp] MITM was enabled, auto-starting...");
+    await startMitm(activeKey?.key || "sk_9router", password);
+    console.log("[InitApp] MITM auto-started");
+    try {
+      await restoreToolDNS(password);
+      console.log("[InitApp] DNS restored from saved state");
+    } catch (e) {
+      console.log("[InitApp] DNS restore failed:", e.message);
+    }
+  } catch (err) {
+    console.log("[InitApp] MITM auto-start failed:", err.message);
+  } finally {
+    g.mitmStartInProgress = false;
+  }
+}
+
+// Cooldown only applies to repeating watchdog ticks (anti hammer-loop).
+// Network/exit events are one-shot transitions → bypass to recover fast.
+const FORCE_RESTART_REASONS = /^(startup|netchange|sleep|sleep\+netchange|online|unexpected-exit)$/;
+
+// ─── Safe restart (4 guards: spawn / cooldown / alive / internet) ────────────
+
+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);
+
+  // Process alive = trust cloudflared (self-reconnects via --retries 99, keeps same URL).
+  // Killing a live process on network change drops the tunnel and rotates the quick-tunnel URL.
+  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);
+    }
+  }
+}
+
+async function safeRestartTailscale(reason) {
+  const svc = getTailscaleService();
+  const settings = await getSettings();
+  if (!settings.tailscaleEnabled) return;
+  if (svc.cancelToken.cancelled) return;
+  if (svc.spawnInProgress) return;
+
+  // Tailscale daemon is OS-level with built-in reconnect; trust it when running (even on netchange).
+  // Startup uses strict probe — cached state is cold after process/dev reload.
+  const running = reason === "startup" ? isTailscaleRunningStrict() : isTailscaleRunning();
+  if (running) return;
+
+  const force = FORCE_RESTART_REASONS.test(reason);
+  if (!force && Date.now() - svc.lastRestartAt < RESTART_COOLDOWN_MS) {
+    console.log(`[Tailscale] degraded but cooldown active, skip (${reason})`);
+    return;
+  }
+  if (!await checkInternet()) return;
+
+  console.log(`[Tailscale] safeRestart (${reason}) — daemon not running${force ? " [force]" : ""}`);
+  try {
+    await enableTailscale();
+    svc.lastRestartAt = Date.now();
+    console.log("[Tailscale] restart success");
+  } catch (err) {
+    console.log("[Tailscale] restart failed:", err.message);
+  }
+}
+
+// ─── Watchdog: 60s tick check both services ──────────────────────────────────
+
+function startWatchdog() {
+  if (g.watchdogInterval) return;
+  g.watchdogInterval = setInterval(() => {
+    safeRestartTunnel("watchdog").catch(() => {});
+    safeRestartTailscale("watchdog").catch(() => {});
+  }, WATCHDOG_INTERVAL_MS);
+  if (g.watchdogInterval.unref) g.watchdogInterval.unref();
+}
+
+// ─── Network monitor: detect IPv4 fingerprint change + sleep/wake ────────────
+
+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;
+
+      // Real reachability check (TCP 1.1.1.1:443) — not just interface presence
+      const online = await checkInternet();
+      const wasOffline = g.lastOnline === false;
+      g.lastOnline = online;
+
+      if (!online) return; // no internet → idle, don't restart
+
+      const onlineEdge = wasOffline; // offline → online transition
+      if (!networkChanged && !wasSleep && !onlineEdge) return;
+
+      // Wait for DHCP/DNS to settle before probing
+      await new Promise((r) => setTimeout(r, NETWORK_SETTLE_MS));
+
+      const reason = onlineEdge ? "online"
+        : wasSleep && networkChanged ? "sleep+netchange"
+        : wasSleep ? "sleep" : "netchange";
+      safeRestartTunnel(reason).catch(() => {});
+      safeRestartTailscale(reason).catch(() => {});
+    } catch (err) {
+      console.log("[NetworkMonitor] error:", err.message);
+    }
+  }, NETWORK_CHECK_INTERVAL_MS);
+
+  if (g.networkMonitorInterval.unref) g.networkMonitorInterval.unref();
+}
+
+export default initializeApp;

package/src/shared/utils/api.js

@@ -0,0 +1,93 @@
+/**
+ * API utility functions for making HTTP requests
+ */
+
+const DEFAULT_HEADERS = {
+  "Content-Type": "application/json",
+};
+
+/**
+ * Make a GET request
+ * @param {string} url - API endpoint
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function get(url, options = {}) {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Make a POST request
+ * @param {string} url - API endpoint
+ * @param {object} data - Request body
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function post(url, data, options = {}) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    body: JSON.stringify(data),
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Make a PUT request
+ * @param {string} url - API endpoint
+ * @param {object} data - Request body
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function put(url, data, options = {}) {
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    body: JSON.stringify(data),
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Make a DELETE request
+ * @param {string} url - API endpoint
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function del(url, options = {}) {
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Handle API response
+ * @param {Response} response - Fetch response
+ * @returns {Promise<object>}
+ */
+async function handleResponse(response) {
+  const data = await response.json();
+
+  if (!response.ok) {
+    const error = new Error(data.error || "An error occurred");
+    error.status = response.status;
+    error.data = data;
+    throw error;
+  }
+
+  return data;
+}
+
+const api = { get, post, put, del };
+export default api;
+

package/src/shared/utils/apiKey.js

@@ -0,0 +1,98 @@
+import crypto from "crypto";
+
+const API_KEY_SECRET = process.env.API_KEY_SECRET || "endpoint-proxy-api-key-secret";
+
+/**
+ * Generate 6-char random keyId
+ */
+function generateKeyId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 6; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+/**
+ * Generate CRC (8-char HMAC)
+ */
+function generateCrc(machineId, keyId) {
+  return crypto
+    .createHmac("sha256", API_KEY_SECRET)
+    .update(machineId + keyId)
+    .digest("hex")
+    .slice(0, 8);
+}
+
+/**
+ * Generate API key with machineId embedded
+ * Format: sk-{machineId}-{keyId}-{crc8}
+ * @param {string} machineId - 16-char machine ID
+ * @returns {{ key: string, keyId: string }}
+ */
+export function generateApiKeyWithMachine(machineId) {
+  const keyId = generateKeyId();
+  const crc = generateCrc(machineId, keyId);
+  const key = `sk-${machineId}-${keyId}-${crc}`;
+  return { key, keyId };
+}
+
+/**
+ * Parse API key and extract machineId + keyId
+ * Supports both formats:
+ * - New: sk-{machineId}-{keyId}-{crc8}
+ * - Old: sk-{random8}
+ * @param {string} apiKey
+ * @returns {{ machineId: string, keyId: string, isNewFormat: boolean } | null}
+ */
+export function parseApiKey(apiKey) {
+  if (!apiKey || !apiKey.startsWith("sk-")) return null;
+
+  const parts = apiKey.split("-");
+  
+  // New format: sk-{machineId}-{keyId}-{crc8} = 4 parts
+  if (parts.length === 4) {
+    const [, machineId, keyId, crc] = parts;
+    
+    // Validate CRC
+    const expectedCrc = generateCrc(machineId, keyId);
+    if (crc !== expectedCrc) return null;
+    
+    return { machineId, keyId, isNewFormat: true };
+  }
+  
+  // Old format: sk-{random8} = 2 parts
+  if (parts.length === 2) {
+    return { machineId: null, keyId: parts[1], isNewFormat: false };
+  }
+  
+  return null;
+}
+
+/**
+ * Verify API key CRC (only for new format)
+ * @param {string} apiKey
+ * @returns {boolean}
+ */
+export function verifyApiKeyCrc(apiKey) {
+  const parsed = parseApiKey(apiKey);
+  if (!parsed) return false;
+  
+  // Old format doesn't have CRC, always valid if parsed
+  if (!parsed.isNewFormat) return true;
+  
+  // New format already verified in parseApiKey
+  return true;
+}
+
+/**
+ * Check if API key is new format (contains machineId)
+ * @param {string} apiKey
+ * @returns {boolean}
+ */
+export function isNewFormatKey(apiKey) {
+  const parsed = parseApiKey(apiKey);
+  return parsed?.isNewFormat === true;
+}
+

package/src/shared/utils/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": `9Router/${APP_VERSION}`,
+    "X-PLATFORM": process.platform || "unknown",
+    "X-PLATFORM-VERSION": process.version || "unknown",
+    "X-CLIENT-TYPE": "9router",
+    "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/utils/cn.js

@@ -0,0 +1,11 @@
+// Utility function to merge class names
+// Handles conditional classes and removes duplicates
+
+export function cn(...classes) {
+  return classes
+    .filter(Boolean)
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+