vforclaude2 0.3.87

package/src/shared/constants/providers.js

@@ -0,0 +1,120 @@
+// Provider definitions
+
+// Free Providers
+export const FREE_PROVIDERS = {
+  iflow: { id: "iflow", alias: "if", name: "iFlow AI", icon: "water_drop", color: "#6366F1" },
+  qwen: { id: "qwen", alias: "qw", name: "Qwen Code", icon: "psychology", color: "#10B981" },
+  "gemini-cli": { id: "gemini-cli", alias: "gc", name: "Gemini CLI", icon: "terminal", color: "#4285F4" },
+  kiro: { id: "kiro", alias: "kr", name: "Kiro AI", icon: "psychology_alt", color: "#FF6B35" },
+};
+
+// OAuth Providers
+export const OAUTH_PROVIDERS = {
+  claude: { id: "claude", alias: "cc", name: "Claude Code", icon: "smart_toy", color: "#D97757" },
+  antigravity: { id: "antigravity", alias: "ag", name: "Antigravity", icon: "rocket_launch", color: "#F59E0B" },
+  codex: { id: "codex", alias: "cx", name: "OpenAI Codex", icon: "code", color: "#3B82F6" },
+  github: { id: "github", alias: "gh", name: "GitHub Copilot", icon: "code", color: "#333333" },
+  cursor: { id: "cursor", alias: "cu", name: "Cursor IDE", icon: "edit_note", color: "#00D4AA" },
+  // "kimi-coding": { id: "kimi-coding", alias: "kmc", name: "Kimi Coding", icon: "psychology", color: "#1E40AF", textIcon: "KC" },
+  kilocode: { id: "kilocode", alias: "kc", name: "Kilo Code", icon: "code", color: "#FF6B35", textIcon: "KC" },
+  cline: { id: "cline", alias: "cl", name: "Cline", icon: "smart_toy", color: "#5B9BD5", textIcon: "CL" },
+};
+
+export const APIKEY_PROVIDERS = {
+  openrouter: { id: "openrouter", alias: "openrouter", name: "OpenRouter", icon: "router", color: "#F97316", textIcon: "OR", passthroughModels: true, website: "https://openrouter.ai" },
+  glm: { id: "glm", alias: "glm", name: "GLM Coding", icon: "code", color: "#2563EB", textIcon: "GL", website: "https://open.bigmodel.cn" },
+  "glm-cn": { id: "glm-cn", alias: "glm-cn", name: "GLM (China)", icon: "code", color: "#DC2626", textIcon: "GC", website: "https://open.bigmodel.cn" },
+  kimi: { id: "kimi", alias: "kimi", name: "Kimi", icon: "psychology", color: "#1E3A8A", textIcon: "KM", website: "https://kimi.moonshot.cn" },
+  minimax: { id: "minimax", alias: "minimax", name: "Minimax Coding", icon: "memory", color: "#7C3AED", textIcon: "MM", website: "https://www.minimaxi.com" },
+  "minimax-cn": { id: "minimax-cn", alias: "minimax-cn", name: "Minimax (China)", icon: "memory", color: "#DC2626", textIcon: "MC", website: "https://www.minimaxi.com" },
+  alicode: { id: "alicode", alias: "alicode", name: "Alibaba", icon: "cloud", color: "#FF6A00", textIcon: "ALi" },
+  "alicode-intl": { id: "alicode-intl", alias: "alicode-intl", name: "Alibaba Intl", icon: "cloud", color: "#FF6A00", textIcon: "ALi" },
+  openai: { id: "openai", alias: "openai", name: "OpenAI", icon: "auto_awesome", color: "#10A37F", textIcon: "OA", website: "https://platform.openai.com" },
+  anthropic: { id: "anthropic", alias: "anthropic", name: "Anthropic", icon: "smart_toy", color: "#D97757", textIcon: "AN", website: "https://console.anthropic.com" },
+  gemini: { id: "gemini", alias: "gemini", name: "Gemini", icon: "diamond", color: "#4285F4", textIcon: "GE", website: "https://ai.google.dev" },
+  deepseek: { id: "deepseek", alias: "ds", name: "DeepSeek", icon: "bolt", color: "#4D6BFE", textIcon: "DS", website: "https://deepseek.com" },
+  groq: { id: "groq", alias: "groq", name: "Groq", icon: "speed", color: "#F55036", textIcon: "GQ", website: "https://groq.com" },
+  xai: { id: "xai", alias: "xai", name: "xAI (Grok)", icon: "auto_awesome", color: "#1DA1F2", textIcon: "XA", website: "https://x.ai" },
+  mistral: { id: "mistral", alias: "mistral", name: "Mistral", icon: "air", color: "#FF7000", textIcon: "MI", website: "https://mistral.ai" },
+  perplexity: { id: "perplexity", alias: "pplx", name: "Perplexity", icon: "search", color: "#20808D", textIcon: "PP", website: "https://www.perplexity.ai" },
+  together: { id: "together", alias: "together", name: "Together AI", icon: "group_work", color: "#0F6FFF", textIcon: "TG", website: "https://www.together.ai" },
+  fireworks: { id: "fireworks", alias: "fireworks", name: "Fireworks AI", icon: "local_fire_department", color: "#7B2EF2", textIcon: "FW", website: "https://fireworks.ai" },
+  cerebras: { id: "cerebras", alias: "cerebras", name: "Cerebras", icon: "memory", color: "#FF4F00", textIcon: "CB", website: "https://www.cerebras.ai" },
+  cohere: { id: "cohere", alias: "cohere", name: "Cohere", icon: "hub", color: "#39594D", textIcon: "CO", website: "https://cohere.com" },
+  nvidia: { id: "nvidia", alias: "nvidia", name: "NVIDIA NIM", icon: "developer_board", color: "#76B900", textIcon: "NV", website: "https://developer.nvidia.com/nim" },
+  nebius: { id: "nebius", alias: "nebius", name: "Nebius AI", icon: "cloud", color: "#6C5CE7", textIcon: "NB", website: "https://nebius.com" },
+  siliconflow: { id: "siliconflow", alias: "siliconflow", name: "SiliconFlow", icon: "cloud_queue", color: "#5B6EF5", textIcon: "SF", website: "https://cloud.siliconflow.com" },
+  hyperbolic: { id: "hyperbolic", alias: "hyp", name: "Hyperbolic", icon: "bolt", color: "#00D4FF", textIcon: "HY", website: "https://hyperbolic.xyz" },
+  deepgram: { id: "deepgram", alias: "dg", name: "Deepgram", icon: "mic", color: "#13EF93", textIcon: "DG", website: "https://deepgram.com" },
+  assemblyai: { id: "assemblyai", alias: "aai", name: "AssemblyAI", icon: "record_voice_over", color: "#0062FF", textIcon: "AA", website: "https://assemblyai.com" },
+  nanobanana: { id: "nanobanana", alias: "nb", name: "NanoBanana", icon: "image", color: "#FFD700", textIcon: "NB", website: "https://nanobananaapi.ai" },
+  chutes: { id: "chutes", alias: "ch", name: "Chutes AI", icon: "water_drop", color: "#ffffffff", textIcon: "CH", website: "https://chutes.ai" },
+  ollama: { id: "ollama", alias: "ollama", name: "Ollama Cloud", icon: "cloud", color: "#ffffffff", textIcon: "OL", website: "https://ollama.com" },
+  "ollama-local": { id: "ollama-local", alias: "ollama-local", name: "Ollama Local", icon: "cloud", color: "#ffffffff", textIcon: "OL", website: "https://ollama.com" },
+  vertex: { id: "vertex", alias: "vx", name: "Vertex AI", icon: "cloud", color: "#4285F4", textIcon: "VX", website: "https://cloud.google.com/vertex-ai" },
+  "vertex-partner": { id: "vertex-partner", alias: "vxp", name: "Vertex Partner", icon: "cloud", color: "#34A853", textIcon: "VP", website: "https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models" },
+};
+
+export const OPENAI_COMPATIBLE_PREFIX = "openai-compatible-";
+export const ANTHROPIC_COMPATIBLE_PREFIX = "anthropic-compatible-";
+
+export function isOpenAICompatibleProvider(providerId) {
+  return typeof providerId === "string" && providerId.startsWith(OPENAI_COMPATIBLE_PREFIX);
+}
+
+export function isAnthropicCompatibleProvider(providerId) {
+  return typeof providerId === "string" && providerId.startsWith(ANTHROPIC_COMPATIBLE_PREFIX);
+}
+
+// All providers (combined)
+export const AI_PROVIDERS = { ...FREE_PROVIDERS, ...OAUTH_PROVIDERS, ...APIKEY_PROVIDERS };
+
+// Auth methods
+export const AUTH_METHODS = {
+  oauth: { id: "oauth", name: "OAuth", icon: "lock" },
+  apikey: { id: "apikey", name: "API Key", icon: "key" },
+};
+
+// Helper: Get provider by alias
+export function getProviderByAlias(alias) {
+  for (const provider of Object.values(AI_PROVIDERS)) {
+    if (provider.alias === alias || provider.id === alias) {
+      return provider;
+    }
+  }
+  return null;
+}
+
+// Helper: Get provider ID from alias
+export function resolveProviderId(aliasOrId) {
+  const provider = getProviderByAlias(aliasOrId);
+  return provider?.id || aliasOrId;
+}
+
+// Helper: Get alias from provider ID
+export function getProviderAlias(providerId) {
+  const provider = AI_PROVIDERS[providerId];
+  return provider?.alias || providerId;
+}
+
+// Alias to ID mapping (for quick lookup)
+export const ALIAS_TO_ID = Object.values(AI_PROVIDERS).reduce((acc, p) => {
+  acc[p.alias] = p.id;
+  return acc;
+}, {});
+
+// ID to Alias mapping
+export const ID_TO_ALIAS = Object.values(AI_PROVIDERS).reduce((acc, p) => {
+  acc[p.id] = p.alias;
+  return acc;
+}, {});
+
+// Providers that support usage/quota API
+export const USAGE_SUPPORTED_PROVIDERS = [
+  "claude",
+  "antigravity",
+  "kiro",
+  "github",
+  "codex",
+  "kimi-coding",
+];

package/src/shared/hooks/index.js

@@ -0,0 +1,2 @@
+// Shared Hooks - Export all
+export { useTheme } from "./useTheme";

package/src/shared/hooks/useCopyToClipboard.js

@@ -0,0 +1,29 @@
+"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") => {
+    navigator.clipboard.writeText(text);
+    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/cloudSyncScheduler.js

@@ -0,0 +1,122 @@
+import { getConsistentMachineId } from "@/shared/utils/machineId";
+import { isCloudEnabled } from "@/lib/localDb";
+
+const INTERNAL_BASE_URL =
+  process.env.BASE_URL ||
+  process.env.NEXT_PUBLIC_BASE_URL ||
+  "http://localhost:20128";
+
+/**
+ * Cloud sync scheduler
+ */
+export class CloudSyncScheduler {
+  constructor(machineId = null, intervalMinutes = 15) {
+    this.machineId = machineId;
+    this.intervalMinutes = intervalMinutes;
+    this.intervalId = null;
+  }
+
+  /**
+   * Initialize machine ID if not provided
+   */
+  async initializeMachineId() {
+    if (!this.machineId) {
+      this.machineId = await getConsistentMachineId();
+    }
+  }
+
+  /**
+   * Start periodic sync (delays first sync to allow server to be ready)
+   */
+  async start() {
+    if (this.intervalId) {
+      return;
+    }
+
+    await this.initializeMachineId();
+    
+    // Delay first sync by 30 seconds to ensure server is ready
+    setTimeout(() => {
+      this.syncWithRetry().catch(() => {});
+    }, 30000);
+    
+    // Then sync periodically
+    this.intervalId = setInterval(() => {
+      this.syncWithRetry().catch(() => {});
+    }, this.intervalMinutes * 60 * 1000);
+  }
+
+  /**
+   * Stop periodic sync
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+
+  /**
+   * Sync with retry logic (exponential backoff)
+   */
+  async syncWithRetry(maxRetries = 1) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await this.sync();
+        return result;
+      } catch (error) {
+        if (attempt === maxRetries) {
+          return null;
+        }
+        
+        const delay = Math.min(1000 * Math.pow(2, attempt), 10000); // Max 10s
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  /**
+   * Perform sync via internal API route (handles token update to db.json)
+   */
+  async sync() {
+    // Check if cloud is enabled
+    const enabled = await isCloudEnabled();
+    if (!enabled) {
+      return null;
+    }
+
+    await this.initializeMachineId();
+    
+    // Call internal API route which handles both sync and token update
+    const response = await fetch(`${INTERNAL_BASE_URL}/api/sync/cloud`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ machineId: this.machineId, action: "sync" })
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || "Sync failed");
+    }
+
+    const result = await response.json();
+    return result;
+  }
+
+  /**
+   * Check if scheduler is running
+   */
+  isRunning() {
+    return this.intervalId !== null;
+  }
+}
+
+// Export a singleton instance if needed
+let cloudSyncScheduler = null;
+
+export async function getCloudSyncScheduler(machineId = null, intervalMinutes = 15) {
+  if (!cloudSyncScheduler) {
+    cloudSyncScheduler = new CloudSyncScheduler(machineId, intervalMinutes);
+  }
+  return cloudSyncScheduler;
+}

package/src/shared/services/initializeApp.js

@@ -0,0 +1,249 @@
+import { cleanupProviderConnections, getSettings, updateSettings, getApiKeys } from "@/lib/localDb";
+import { enableTunnel, isTunnelManuallyDisabled, isTunnelReconnecting } from "@/lib/tunnel/tunnelManager";
+import { killCloudflared, isCloudflaredRunning, ensureCloudflared } from "@/lib/tunnel/cloudflared";
+import { getMitmStatus, startMitm, loadEncryptedPassword, initDbHooks } from "@/mitm/manager";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+
+import os from "os";
+
+// Inject correct paths and DB hooks into manager.js (CJS) from ESM context.
+// Must run before any MITM function is called.
+(function bootstrapMitm() {
+  // 1. Resolve server.js path from real ESM __filename (not bundled path)
+  if (!process.env.MITM_SERVER_PATH) {
+    try {
+      const thisFile = fileURLToPath(import.meta.url);
+      const appSrc = dirname(dirname(thisFile)); // src/
+      const candidate = join(appSrc, "mitm", "server.js");
+      if (existsSync(candidate)) {
+        process.env.MITM_SERVER_PATH = candidate;
+      }
+    } catch { /* ignore */ }
+  }
+
+  // 2. Inject DB functions so manager.js (CJS) can save/load settings
+  //    without dynamic import issues inside webpack bundles
+  try {
+    initDbHooks(getSettings, updateSettings);
+  } catch { /* ignore */ }
+})();
+
+// Multiple modules register SIGINT/SIGTERM handlers legitimately
+process.setMaxListeners(20);
+
+// Use global to survive Next.js hot reload — prevents duplicate intervals
+const g = global.__appSingleton ??= {
+  signalHandlersRegistered: false,
+  watchdogInterval: null,
+  networkMonitorInterval: null,
+  licenseValidationInterval: null,
+  lastNetworkFingerprint: null,
+  lastWatchdogTick: Date.now(),
+  lastTunnelRestartAt: 0,
+  tunnelRestartInProgress: false,
+  mitmStartInProgress: false,
+};
+
+const WATCHDOG_INTERVAL_MS = 60000;
+const NETWORK_CHECK_INTERVAL_MS = 5000;
+const NETWORK_RESTART_COOLDOWN_MS = 30000;
+const LICENSE_CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Initialize app on startup
+ * - Cleanup stale data
+ * - Auto-reconnect tunnel if previously enabled
+ * - Register shutdown handler to kill cloudflared
+ * - Start watchdog to recover tunnel after sleep/wake
+ */
+export async function initializeApp() {
+  try {
+    await cleanupProviderConnections();
+
+    // Auto-reconnect tunnel if it was enabled before restart
+    const settings = await getSettings();
+    if (settings.tunnelEnabled && !isCloudflaredRunning()) {
+      console.log("[InitApp] Tunnel was enabled, auto-reconnecting...");
+      try {
+        await enableTunnel();
+        console.log("[InitApp] Tunnel reconnected");
+      } catch (error) {
+        console.log("[InitApp] Tunnel reconnect failed:", error.message);
+      }
+    }
+
+    // Kill cloudflared on process exit (register once only)
+    if (!g.signalHandlersRegistered) {
+      const cleanup = () => {
+        killCloudflared();
+        process.exit();
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      g.signalHandlersRegistered = true;
+    }
+
+    // Pre-download cloudflared binary in background
+    ensureCloudflared().catch(() => {});
+
+    // Watchdog: recover tunnel after process crash
+    startWatchdog();
+
+    // Network monitor: detect sleep/wake + network changes → restart tunnel
+    startNetworkMonitor();
+
+    // License validation: periodic check every hour
+    startLicenseValidation();
+
+    // Auto-start MITM if it was enabled before restart
+    autoStartMitm();
+  } catch (error) {
+    console.error("[InitApp] Error:", error);
+  }
+}
+
+/** Auto-start MITM if it was enabled before restart */
+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;
+    }
+
+    // Need an active API key
+    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_vforclaude", password);
+    console.log("[InitApp] MITM auto-started");
+  } catch (err) {
+    console.log("[InitApp] MITM auto-start failed:", err.message);
+  } finally {
+    g.mitmStartInProgress = false;
+  }
+}
+
+/** Periodically check tunnel process health and reconnect if crashed */
+function startWatchdog() {
+  if (g.watchdogInterval) return;
+  g.watchdogInterval = setInterval(async () => {
+    try {
+      if (isTunnelManuallyDisabled()) return;
+      if (isTunnelReconnecting()) return;
+      if (g.tunnelRestartInProgress) return;
+      const settings = await getSettings();
+      if (!settings.tunnelEnabled) return;
+      if (isCloudflaredRunning()) return;
+      console.log("[Watchdog] Tunnel process is down, attempting recovery...");
+      g.tunnelRestartInProgress = true;
+      try {
+        await enableTunnel();
+        console.log("[Watchdog] Tunnel recovered");
+      } finally {
+        g.tunnelRestartInProgress = false;
+      }
+    } catch (err) {
+      console.log("[Watchdog] Recovery failed:", err.message);
+    }
+  }, WATCHDOG_INTERVAL_MS);
+
+  if (g.watchdogInterval.unref) g.watchdogInterval.unref();
+}
+
+/** Get network fingerprint from active interfaces (IPv4 only) */
+function getNetworkFingerprint() {
+  const interfaces = os.networkInterfaces();
+  const active = [];
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (!addrs) continue;
+    for (const addr of addrs) {
+      if (!addr.internal && addr.family === "IPv4") {
+        active.push(`${name}:${addr.address}`);
+      }
+    }
+  }
+  return active.sort().join("|");
+}
+
+/** Monitor network changes + sleep/wake → kill and reconnect tunnel */
+function startNetworkMonitor() {
+  if (g.networkMonitorInterval) return;
+
+  g.lastNetworkFingerprint = getNetworkFingerprint();
+  g.lastWatchdogTick = Date.now();
+
+  g.networkMonitorInterval = setInterval(async () => {
+    try {
+      if (isTunnelManuallyDisabled()) return;
+      const settings = await getSettings();
+      if (!settings.tunnelEnabled) return;
+
+      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 * 3;
+
+      if (networkChanged) g.lastNetworkFingerprint = currentFingerprint;
+
+      if (!networkChanged && !wasSleep) return;
+
+      // Skip if restart already in progress or restarted recently
+      if (g.tunnelRestartInProgress) return;
+      if (isTunnelReconnecting()) return;
+      if (now - g.lastTunnelRestartAt < NETWORK_RESTART_COOLDOWN_MS) return;
+
+      const reason = wasSleep && networkChanged ? "sleep/wake + network change"
+        : wasSleep ? "sleep/wake" : "network change";
+      console.log(`[NetworkMonitor] ${reason} detected, restarting tunnel...`);
+
+      g.tunnelRestartInProgress = true;
+      g.lastTunnelRestartAt = now;
+      try {
+        killCloudflared();
+        await new Promise(r => setTimeout(r, 2000));
+        await enableTunnel();
+        console.log("[NetworkMonitor] Tunnel restarted");
+        g.lastNetworkFingerprint = getNetworkFingerprint();
+      } finally {
+        g.tunnelRestartInProgress = false;
+      }
+    } catch (err) {
+      console.log("[NetworkMonitor] Tunnel restart failed:", err.message);
+    }
+  }, NETWORK_CHECK_INTERVAL_MS);
+
+  if (g.networkMonitorInterval.unref) g.networkMonitorInterval.unref();
+}
+
+/** Periodic license validation check (every 1 hour) */
+function startLicenseValidation() {
+  if (g.licenseValidationInterval) return;
+
+  g.licenseValidationInterval = setInterval(async () => {
+    try {
+      const { periodicValidationCheck } = await import('@/lib/license/manager.js');
+      await periodicValidationCheck();
+    } catch (err) {
+      console.error('[LicenseValidation] Periodic check failed:', err.message);
+    }
+  }, LICENSE_CHECK_INTERVAL_MS);
+
+  if (g.licenseValidationInterval.unref) g.licenseValidationInterval.unref();
+}
+
+export default initializeApp;

package/src/shared/services/initializeCloudSync.js

@@ -0,0 +1,37 @@
+/* ========== CLOUD SYNC — COMMENTED OUT (replaced by Tunnel) ==========
+import { getCloudSyncScheduler } from "@/shared/services/cloudSyncScheduler";
+========== END CLOUD SYNC ========== */
+import { cleanupProviderConnections } from "@/lib/localDb";
+
+/**
+ * Initialize cloud sync scheduler
+ * This should be called when the application starts
+ */
+export async function initializeCloudSync() {
+  try {
+    // Cleanup null fields from existing data
+    await cleanupProviderConnections();
+    
+    /* ========== CLOUD SYNC — COMMENTED OUT (replaced by Tunnel) ==========
+    // Create scheduler instance with default 15-minute interval
+    const scheduler = await getCloudSyncScheduler(null, 15);
+    
+    // Start the scheduler
+    await scheduler.start();
+    
+    return scheduler;
+    ========== END CLOUD SYNC ========== */
+    return null;
+  } catch (error) {
+    console.error("[CloudSync] Error initializing scheduler:", error);
+    throw error;
+  }
+}
+
+// For development/testing purposes
+if (typeof require !== "undefined" && require.main === module) {
+  initializeCloudSync().catch(console.log);
+}
+
+export default initializeCloudSync;
+