@trops/dash-core 0.1.161 → 0.1.163

package/dist/electron/index.js

@@ -29,11 +29,12 @@ var require$$2$4 = require('os');
 var require$$4$1 = require('url');
 var require$$2$3 = require('vm');
 var require$$1$5 = require('croner');
+var require$$1$6 = require('node-vibrant/node');
+var require$$3$4 = require('http');
 var require$$0$c = require('events');
-var require$$2$5 = require('http');
-var require$$3$4 = require('net');
+var require$$3$5 = require('net');
 var require$$4$2 = require('tls');
-var require$$1$6 = require('crypto');
+var require$$1$7 = require('crypto');
 var require$$0$a = require('zlib');
 var require$$0$b = require('buffer');
 
@@ -3748,7 +3749,7 @@ const { getFileContents: getFileContents$5, writeToFile: writeToFile$2 } = file;
 const ObjectsToCsv = require$$5;
 const Transform = transform;
 const { extractColorsFromImageURL: extractColorsFromImageURL$1 } = color;
-const https$1 = require$$8;
+const https$2 = require$$8;
 const appName$5 = "Dashboard";
 
 const dataController$1 = {
@@ -3901,7 +3902,7 @@ const dataController$1 = {
 
       const writeStream = fs$8.createWriteStream(resolvedFilepath);
 
-      https$1
+      https$2
         .get(url, (resp) => {
           resp.on("data", (chunk) => {
             writeStream.write(chunk);
@@ -38774,10 +38775,14 @@ css$1.stringify = stringify;
  *
  * Color extraction pipeline for generating themes from a website URL.
  * Extracts brand colors from HTML meta tags, CSS custom properties,
- * and computed styles, then merges and ranks them into a palette.
+ * computed styles, and favicon/logo images (via node-vibrant).
  */
 
 const css = css$1;
+const { Vibrant } = require$$1$6;
+const https$1 = require$$8;
+const http$2 = require$$3$4;
+const { URL: URL$2 } = require$$4$1;
 
 // ─── Color conversion helpers ───────────────────────────────────────────────
 
@@ -39072,6 +39077,178 @@ function extractComputedColors(computedStyles) {
   return results;
 }
 
+// ─── Favicon extraction ──────────────────────────────────────────────────────
+
+/**
+ * Parse HTML to find favicon and apple-touch-icon URLs.
+ * Prefers apple-touch-icon (higher resolution) and largest available sizes.
+ * @param {string} htmlContent - Raw HTML string
+ * @returns {Array<{url: string, priority: number}>} Sorted by priority (highest first)
+ */
+function extractFaviconUrls(htmlContent) {
+  if (!htmlContent) return [];
+  const icons = [];
+
+  // apple-touch-icon (higher resolution, best for extraction)
+  const appleTouchPattern =
+    /<link[^>]*rel\s*=\s*["']apple-touch-icon(?:-precomposed)?["'][^>]*>/gi;
+  let match;
+  while ((match = appleTouchPattern.exec(htmlContent)) !== null) {
+    const hrefMatch = match[0].match(/href\s*=\s*["']([^"']+)["']/i);
+    if (hrefMatch) {
+      const sizesMatch = match[0].match(/sizes\s*=\s*["'](\d+)x(\d+)["']/i);
+      const size = sizesMatch ? parseInt(sizesMatch[1], 10) : 180; // apple-touch-icon defaults to 180
+      icons.push({ url: hrefMatch[1], priority: 100 + size });
+    }
+  }
+
+  // Standard favicon link tags (icon, shortcut icon)
+  const iconPattern =
+    /<link[^>]*rel\s*=\s*["'](?:shortcut\s+)?icon["'][^>]*>/gi;
+  while ((match = iconPattern.exec(htmlContent)) !== null) {
+    const hrefMatch = match[0].match(/href\s*=\s*["']([^"']+)["']/i);
+    if (hrefMatch) {
+      const sizesMatch = match[0].match(/sizes\s*=\s*["'](\d+)x(\d+)["']/i);
+      const size = sizesMatch ? parseInt(sizesMatch[1], 10) : 16;
+      icons.push({ url: hrefMatch[1], priority: size });
+    }
+  }
+
+  // Sort by priority descending (prefer largest / apple-touch-icon)
+  icons.sort((a, b) => b.priority - a.priority);
+  return icons;
+}
+
+/**
+ * Resolve a potentially relative URL against a base URL.
+ * @param {string} href - The href from the HTML (may be relative)
+ * @param {string} baseUrl - The page URL to resolve against
+ * @returns {string|null} Absolute URL or null if invalid
+ */
+function resolveUrl(href, baseUrl) {
+  try {
+    return new URL$2(href, baseUrl).href;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch a URL and return the response as a Buffer.
+ * Follows redirects (up to 5). Times out after 10 seconds.
+ * @param {string} url - Absolute URL to fetch
+ * @returns {Promise<Buffer>}
+ */
+function fetchBuffer(url) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL$2(url);
+    const client = parsedUrl.protocol === "https:" ? https$1 : http$2;
+    const request = client.get(
+      url,
+      { timeout: 10000, headers: { "User-Agent": "Dash/1.0" } },
+      (res) => {
+        // Follow redirects
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          const redirectUrl = resolveUrl(res.headers.location, url);
+          if (redirectUrl) {
+            fetchBuffer(redirectUrl).then(resolve).catch(reject);
+            return;
+          }
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      },
+    );
+    request.on("error", reject);
+    request.on("timeout", () => {
+      request.destroy();
+      reject(new Error("Timeout"));
+    });
+  });
+}
+
+/**
+ * Extract colors from favicon/logo images using node-vibrant.
+ * Tries icons in priority order (apple-touch-icon first, largest first).
+ * Returns on the first successful extraction.
+ *
+ * @param {string} htmlContent - Raw HTML to parse for icon URLs
+ * @param {string} baseUrl - Page URL for resolving relative icon paths
+ * @returns {Promise<Array<{hex: string, source: string, confidence: number}>>}
+ */
+async function extractFaviconColors(htmlContent, baseUrl) {
+  const iconEntries = extractFaviconUrls(htmlContent);
+  if (iconEntries.length === 0) {
+    // Fallback: try /favicon.ico at the domain root
+    try {
+      const rootFavicon = new URL$2("/favicon.ico", baseUrl).href;
+      iconEntries.push({ url: rootFavicon, priority: 1 });
+    } catch {
+      return [];
+    }
+  }
+
+  for (const entry of iconEntries) {
+    const absoluteUrl = resolveUrl(entry.url, baseUrl);
+    if (!absoluteUrl) continue;
+
+    try {
+      const buffer = await fetchBuffer(absoluteUrl);
+      const palette = await Vibrant.from(buffer).getPalette();
+
+      const results = [];
+      const swatchNames = [
+        "Vibrant",
+        "DarkVibrant",
+        "LightVibrant",
+        "Muted",
+        "DarkMuted",
+        "LightMuted",
+      ];
+
+      for (const name of swatchNames) {
+        const swatch = palette[name];
+        if (!swatch) continue;
+        const [r, g, b] = swatch.rgb;
+        const hex = rgbToHex({
+          r: Math.round(r),
+          g: Math.round(g),
+          b: Math.round(b),
+        });
+        results.push({
+          hex,
+          source: "favicon",
+          confidence: 0.7,
+        });
+      }
+
+      if (results.length > 0) {
+        console.log(
+          `[themeFromUrlController] Favicon vibrant: ${results.length} swatches from ${absoluteUrl}`,
+        );
+        return results;
+      }
+    } catch (err) {
+      console.warn(
+        `[themeFromUrlController] Favicon extraction failed for ${absoluteUrl}: ${err.message}`,
+      );
+      // Try next icon
+    }
+  }
+
+  return [];
+}
+
 // ─── Merge & rank ────────────────────────────────────────────────────────────
 
 /**
@@ -39198,13 +39375,23 @@ function mergeAndRank(allColors, maxColors = 6) {
 /**
  * Extract a ranked color palette from website content.
  *
+ * When `baseUrl` is provided, also extracts colors from favicon/logo images
+ * via node-vibrant (async). Without `baseUrl`, runs synchronously using only
+ * meta tags, CSS vars, and computed styles.
+ *
  * @param {Object} params
  * @param {string} params.htmlContent - Raw HTML of the page
  * @param {string} params.cssContent - Concatenated CSS content
  * @param {Object} params.computedStyles - Map of selector → { color, backgroundColor, borderColor }
- * @returns {{ palette: Array, rawCount: number }}
- */
-function extractColorsFromUrl({ htmlContent, cssContent, computedStyles }) {
+ * @param {string} [params.baseUrl] - Page URL for resolving favicon paths (enables image extraction)
+ * @returns {Promise<{ palette: Array, rawCount: number }>}
+ */
+async function extractColorsFromUrl({
+  htmlContent,
+  cssContent,
+  computedStyles,
+  baseUrl,
+}) {
   console.log("[themeFromUrlController] Starting color extraction pipeline");
 
   const metaColors = extractMetaColors(htmlContent);
@@ -39222,7 +39409,27 @@ function extractColorsFromUrl({ htmlContent, cssContent, computedStyles }) {
     `[themeFromUrlController] Computed styles: ${computedColors.length} colors`,
   );
 
-  const allColors = [...metaColors, ...cssVarColors, ...computedColors];
+  // Favicon extraction (async, requires baseUrl)
+  let faviconColors = [];
+  if (baseUrl) {
+    try {
+      faviconColors = await extractFaviconColors(htmlContent, baseUrl);
+      console.log(
+        `[themeFromUrlController] Favicon/logo: ${faviconColors.length} colors`,
+      );
+    } catch (err) {
+      console.warn(
+        `[themeFromUrlController] Favicon extraction failed: ${err.message}`,
+      );
+    }
+  }
+
+  const allColors = [
+    ...metaColors,
+    ...cssVarColors,
+    ...computedColors,
+    ...faviconColors,
+  ];
   console.log(`[themeFromUrlController] Total raw colors: ${allColors.length}`);
 
   const palette = mergeAndRank(allColors);
@@ -39238,6 +39445,8 @@ function extractColorsFromUrl({ htmlContent, cssContent, computedStyles }) {
 
 const themeFromUrlController$1 = {
   extractColorsFromUrl,
+  extractFaviconUrls,
+  extractFaviconColors,
 };
 
 var themeFromUrlController_1 = themeFromUrlController$1;
@@ -41465,7 +41674,7 @@ let Receiver$1 = class Receiver extends Writable {
 var receiver = Receiver$1;
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
-const { randomFillSync } = require$$1$6;
+const { randomFillSync } = require$$1$7;
 
 const PerMessageDeflate$2 = permessageDeflate;
 const { EMPTY_BUFFER: EMPTY_BUFFER$1, kWebSocket: kWebSocket$2, NOOP: NOOP$1 } = constants;
@@ -42560,10 +42769,10 @@ var extension$1 = { format: format$1, parse: parse$2 };
 
 const EventEmitter$1 = require$$0$c;
 const https = require$$8;
-const http$1 = require$$2$5;
-const net = require$$3$4;
+const http$1 = require$$3$4;
+const net = require$$3$5;
 const tls = require$$4$2;
-const { randomBytes, createHash: createHash$1 } = require$$1$6;
+const { randomBytes, createHash: createHash$1 } = require$$1$7;
 const { URL: URL$1 } = require$$4$1;
 
 const PerMessageDeflate$1 = permessageDeflate;
@@ -44170,8 +44379,8 @@ var subprotocol$1 = { parse };
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
 const EventEmitter = require$$0$c;
-const http = require$$2$5;
-const { createHash } = require$$1$6;
+const http = require$$3$4;
+const { createHash } = require$$1$7;
 
 const extension = extension$1;
 const PerMessageDeflate = permessageDeflate;
@@ -44740,6 +44949,10 @@ var ws = WebSocket$1;
  *   - pendingConnects Map for in-flight deduplication
  *   - Status constants matching MCP pattern
  *
+ * Features:
+ *   - Auto-reconnect with exponential backoff (1s → 2s → 4s → 8s → 16s, max 30s, 5 retries)
+ *   - Heartbeat ping/pong keepalive (30s interval, 10s pong timeout)
+ *
  * Uses the `ws` package (installed in dash-electron) for WebSocket clients.
  * Multiple widgets referencing the same provider share a single socket.
  */
@@ -44750,7 +44963,10 @@ const WebSocket = ws;
  * Active WebSocket connections
  * Map<string, { socket: WebSocket, status: string, config: object,
  *               consumers: Set<number>, messageCount: number,
- *               connectedAt: number|null, lastMessageAt: number|null }>
+ *               connectedAt: number|null, lastMessageAt: number|null,
+ *               retryCount: number, retryTimer: NodeJS.Timeout|null,
+ *               heartbeatTimer: NodeJS.Timeout|null, pongTimer: NodeJS.Timeout|null,
+ *               intentionalClose: boolean }>
  */
 const activeConnections = new Map();
 
@@ -44772,6 +44988,24 @@ const STATUS = {
   ERROR: "error",
 };
 
+/**
+ * Reconnect configuration
+ */
+const RECONNECT = {
+  BASE_DELAY: 1000, // 1 second
+  MULTIPLIER: 2,
+  MAX_DELAY: 30000, // 30 seconds
+  MAX_RETRIES: 5,
+};
+
+/**
+ * Heartbeat configuration
+ */
+const HEARTBEAT = {
+  PING_INTERVAL: 30000, // 30 seconds
+  PONG_TIMEOUT: 10000, // 10 seconds
+};
+
 /**
  * Interpolate {{fieldName}} placeholders in a string with credential values.
  * Reuses the same pattern as mcpController for URL and header templates.
@@ -44792,7 +45026,7 @@ function interpolate(template, credentials) {
  *
  * @param {string} providerName - The provider whose status changed
  * @param {string} status - New status value
- * @param {object} extra - Additional fields (error, etc.)
+ * @param {object} extra - Additional fields (error, retryCount, retryIn, etc.)
  */
 function broadcastStatusChange(providerName, status, extra = {}) {
   const { WS_STATUS_CHANGE } = webSocketEvents$1;
@@ -44828,6 +45062,320 @@ function broadcastMessage(providerName, data) {
   }
 }
 
+/**
+ * Calculate the backoff delay for a given retry attempt.
+ *
+ * @param {number} retryCount - Current retry attempt (0-based)
+ * @returns {number} Delay in milliseconds
+ */
+function getBackoffDelay(retryCount) {
+  const delay =
+    RECONNECT.BASE_DELAY * Math.pow(RECONNECT.MULTIPLIER, retryCount);
+  return Math.min(delay, RECONNECT.MAX_DELAY);
+}
+
+/**
+ * Clear heartbeat and pong timers for a connection.
+ *
+ * @param {object} conn - The connection object from activeConnections
+ */
+function clearHeartbeatTimers(conn) {
+  if (conn.heartbeatTimer) {
+    clearInterval(conn.heartbeatTimer);
+    conn.heartbeatTimer = null;
+  }
+  if (conn.pongTimer) {
+    clearTimeout(conn.pongTimer);
+    conn.pongTimer = null;
+  }
+}
+
+/**
+ * Clear the reconnect timer for a connection.
+ *
+ * @param {object} conn - The connection object from activeConnections
+ */
+function clearReconnectTimer(conn) {
+  if (conn.retryTimer) {
+    clearTimeout(conn.retryTimer);
+    conn.retryTimer = null;
+  }
+}
+
+/**
+ * Start heartbeat ping/pong for an active connection.
+ * Sends a WebSocket ping frame every HEARTBEAT.PING_INTERVAL ms.
+ * If no pong is received within HEARTBEAT.PONG_TIMEOUT ms, the connection
+ * is considered stale and a reconnect is triggered.
+ *
+ * @param {string} providerName - The provider name
+ */
+function startHeartbeat(providerName) {
+  const conn = activeConnections.get(providerName);
+  if (!conn || !conn.socket) return;
+
+  // Clear any existing heartbeat timers
+  clearHeartbeatTimers(conn);
+
+  conn.heartbeatTimer = setInterval(() => {
+    const current = activeConnections.get(providerName);
+    if (
+      !current ||
+      !current.socket ||
+      current.socket.readyState !== WebSocket.OPEN
+    ) {
+      clearHeartbeatTimers(current || conn);
+      return;
+    }
+
+    // Send ping
+    try {
+      current.socket.ping();
+    } catch {
+      // Socket errored during ping — will be caught by error/close handlers
+      return;
+    }
+
+    // Start pong timeout
+    current.pongTimer = setTimeout(() => {
+      const staleConn = activeConnections.get(providerName);
+      if (!staleConn || staleConn.intentionalClose) return;
+
+      console.log(
+        `[webSocketController] Heartbeat timeout (no pong): ${providerName}`,
+      );
+
+      // Clear heartbeat before triggering reconnect
+      clearHeartbeatTimers(staleConn);
+
+      // Close the stale socket to trigger the close handler → reconnect
+      if (staleConn.socket) {
+        try {
+          staleConn.socket.terminate();
+        } catch {
+          /* already closing */
+        }
+      }
+    }, HEARTBEAT.PONG_TIMEOUT);
+  }, HEARTBEAT.PING_INTERVAL);
+}
+
+/**
+ * Attempt to reconnect a provider with exponential backoff.
+ * Called from the socket close handler when the close was unexpected.
+ *
+ * @param {string} providerName - The provider to reconnect
+ */
+function scheduleReconnect(providerName) {
+  const conn = activeConnections.get(providerName);
+  if (!conn) return;
+
+  if (conn.retryCount >= RECONNECT.MAX_RETRIES) {
+    console.log(
+      `[webSocketController] Max retries (${RECONNECT.MAX_RETRIES}) reached for ${providerName}`,
+    );
+    activeConnections.set(providerName, {
+      ...conn,
+      socket: null,
+      status: STATUS.ERROR,
+      error: `Reconnect failed after ${RECONNECT.MAX_RETRIES} attempts`,
+    });
+    broadcastStatusChange(providerName, STATUS.ERROR, {
+      error: `Reconnect failed after ${RECONNECT.MAX_RETRIES} attempts`,
+    });
+    return;
+  }
+
+  const delay = getBackoffDelay(conn.retryCount);
+  console.log(
+    `[webSocketController] Reconnecting ${providerName} in ${delay}ms (attempt ${conn.retryCount + 1}/${RECONNECT.MAX_RETRIES})`,
+  );
+
+  // Broadcast connecting status with retry info
+  broadcastStatusChange(providerName, STATUS.CONNECTING, {
+    retryCount: conn.retryCount + 1,
+    retryIn: delay,
+  });
+
+  conn.retryTimer = setTimeout(async () => {
+    const current = activeConnections.get(providerName);
+    if (!current || current.intentionalClose) return;
+
+    // Update retry count before attempting
+    current.retryCount++;
+
+    try {
+      // Use the stored config to reconnect
+      const config = current.config;
+      const url = config.credentials
+        ? interpolate(config.url, config.credentials)
+        : config.url;
+
+      const wsOptions = {};
+      if (config.headers) {
+        const headers = {};
+        if (config.credentials) {
+          Object.entries(config.headers).forEach(([headerName, template]) => {
+            headers[headerName] = interpolate(template, config.credentials);
+          });
+        } else {
+          Object.assign(headers, config.headers);
+        }
+        wsOptions.headers = headers;
+      }
+
+      console.log(
+        `[webSocketController] Reconnect attempt ${current.retryCount}/${RECONNECT.MAX_RETRIES}: ${providerName}`,
+      );
+
+      const socket = new WebSocket(url, config.subprotocols || [], wsOptions);
+
+      // Wait for open or error
+      await new Promise((resolve, reject) => {
+        const onOpen = () => {
+          socket.removeListener("error", onError);
+          resolve();
+        };
+        const onError = (err) => {
+          socket.removeListener("open", onOpen);
+          reject(err);
+        };
+        socket.once("open", onOpen);
+        socket.once("error", onError);
+      });
+
+      // Reconnect succeeded — reset retry count, update connection
+      const reconnected = activeConnections.get(providerName);
+      if (!reconnected || reconnected.intentionalClose) {
+        // Was disconnected intentionally during reconnect
+        socket.close(1000, "Client disconnect");
+        return;
+      }
+
+      activeConnections.set(providerName, {
+        ...reconnected,
+        socket,
+        status: STATUS.CONNECTED,
+        connectedAt: Date.now(),
+        retryCount: 0,
+        retryTimer: null,
+        error: undefined,
+      });
+
+      // Wire up handlers on the new socket
+      wireSocketHandlers(providerName, socket);
+
+      // Start heartbeat on the new socket
+      startHeartbeat(providerName);
+
+      broadcastStatusChange(providerName, STATUS.CONNECTED);
+
+      console.log(
+        `[webSocketController] Reconnected: ${providerName} (after ${current.retryCount} attempt(s))`,
+      );
+    } catch (err) {
+      console.error(
+        `[webSocketController] Reconnect attempt ${current.retryCount} failed for ${providerName}:`,
+        err.message,
+      );
+
+      // Schedule next retry
+      scheduleReconnect(providerName);
+    }
+  }, delay);
+}
+
+/**
+ * Wire up message, close, error, and pong handlers on a WebSocket instance.
+ * Extracted so both initial connect and reconnect use the same handlers.
+ *
+ * @param {string} providerName - The provider name
+ * @param {WebSocket} socket - The WebSocket instance
+ */
+function wireSocketHandlers(providerName, socket) {
+  // Message handler
+  socket.on("message", (data) => {
+    const conn = activeConnections.get(providerName);
+    if (conn) {
+      conn.messageCount++;
+      conn.lastMessageAt = Date.now();
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(data.toString());
+    } catch {
+      parsed = data.toString();
+    }
+
+    broadcastMessage(providerName, parsed);
+  });
+
+  // Close handler — triggers auto-reconnect for unexpected closes
+  socket.on("close", (code, reason) => {
+    console.log(
+      `[webSocketController] Connection closed: ${providerName} (code: ${code})`,
+    );
+    const conn = activeConnections.get(providerName);
+    if (!conn || conn.socket !== socket) return;
+
+    // Clean up heartbeat timers
+    clearHeartbeatTimers(conn);
+
+    // Update status
+    activeConnections.set(providerName, {
+      ...conn,
+      socket: null,
+      status: STATUS.DISCONNECTED,
+    });
+
+    // Normal close (code 1000) or intentional disconnect — don't reconnect
+    if (conn.intentionalClose || code === 1000) {
+      broadcastStatusChange(providerName, STATUS.DISCONNECTED, {
+        code,
+        reason: reason?.toString(),
+      });
+      return;
+    }
+
+    // Unexpected close — attempt auto-reconnect
+    broadcastStatusChange(providerName, STATUS.DISCONNECTED, {
+      code,
+      reason: reason?.toString(),
+      reconnecting: true,
+    });
+    scheduleReconnect(providerName);
+  });
+
+  // Error handler
+  socket.on("error", (err) => {
+    console.error(
+      `[webSocketController] Socket error for ${providerName}:`,
+      err.message,
+    );
+    const conn = activeConnections.get(providerName);
+    if (conn && conn.socket === socket) {
+      activeConnections.set(providerName, {
+        ...conn,
+        status: STATUS.ERROR,
+        error: err.message,
+      });
+      broadcastStatusChange(providerName, STATUS.ERROR, {
+        error: err.message,
+      });
+    }
+  });
+
+  // Pong handler — clear the pong timeout when we receive a pong
+  socket.on("pong", () => {
+    const conn = activeConnections.get(providerName);
+    if (conn && conn.pongTimer) {
+      clearTimeout(conn.pongTimer);
+      conn.pongTimer = null;
+    }
+  });
+}
+
 const webSocketController$1 = {
   /**
    * connect
@@ -44867,8 +45415,11 @@ const webSocketController$1 = {
     // 3. Fresh connect — wrap in a promise and track it
     const connectPromise = (async () => {
       try {
-        // Clean up stale/error state
+        // Clean up stale/error state (including any pending reconnect timers)
         if (activeConnections.has(providerName)) {
+          const stale = activeConnections.get(providerName);
+          clearReconnectTimer(stale);
+          clearHeartbeatTimers(stale);
           await webSocketController$1.disconnect(win, providerName);
         }
 
@@ -44911,6 +45462,11 @@ const webSocketController$1 = {
           messageCount: 0,
           connectedAt: null,
           lastMessageAt: null,
+          retryCount: 0,
+          retryTimer: null,
+          heartbeatTimer: null,
+          pongTimer: null,
+          intentionalClose: false,
         });
         broadcastStatusChange(providerName, STATUS.CONNECTING);
 
@@ -44943,64 +45499,18 @@ const webSocketController$1 = {
           messageCount: 0,
           connectedAt: Date.now(),
           lastMessageAt: null,
+          retryCount: 0,
+          retryTimer: null,
+          heartbeatTimer: null,
+          pongTimer: null,
+          intentionalClose: false,
         });
 
-        // Wire up message handler
-        socket.on("message", (data) => {
-          const conn = activeConnections.get(providerName);
-          if (conn) {
-            conn.messageCount++;
-            conn.lastMessageAt = Date.now();
-          }
-
-          // Parse if JSON, otherwise pass as string
-          let parsed;
-          try {
-            parsed = JSON.parse(data.toString());
-          } catch {
-            parsed = data.toString();
-          }
+        // Wire up socket event handlers
+        wireSocketHandlers(providerName, socket);
 
-          broadcastMessage(providerName, parsed);
-        });
-
-        // Wire up close handler
-        socket.on("close", (code, reason) => {
-          console.log(
-            `[webSocketController] Connection closed: ${providerName} (code: ${code})`,
-          );
-          const conn = activeConnections.get(providerName);
-          if (conn && conn.socket === socket) {
-            activeConnections.set(providerName, {
-              ...conn,
-              socket: null,
-              status: STATUS.DISCONNECTED,
-            });
-            broadcastStatusChange(providerName, STATUS.DISCONNECTED, {
-              code,
-              reason: reason?.toString(),
-            });
-          }
-        });
-
-        // Wire up error handler
-        socket.on("error", (err) => {
-          console.error(
-            `[webSocketController] Socket error for ${providerName}:`,
-            err.message,
-          );
-          const conn = activeConnections.get(providerName);
-          if (conn && conn.socket === socket) {
-            activeConnections.set(providerName, {
-              ...conn,
-              status: STATUS.ERROR,
-              error: err.message,
-            });
-            broadcastStatusChange(providerName, STATUS.ERROR, {
-              error: err.message,
-            });
-          }
-        });
+        // Start heartbeat
+        startHeartbeat(providerName);
 
         broadcastStatusChange(providerName, STATUS.CONNECTED);
 
@@ -45026,6 +45536,11 @@ const webSocketController$1 = {
           messageCount: 0,
           connectedAt: null,
           lastMessageAt: null,
+          retryCount: 0,
+          retryTimer: null,
+          heartbeatTimer: null,
+          pongTimer: null,
+          intentionalClose: false,
           error: error.message,
         });
         broadcastStatusChange(providerName, STATUS.ERROR, {
@@ -45050,6 +45565,7 @@ const webSocketController$1 = {
   /**
    * disconnect
    * Close a WebSocket connection and clean up.
+   * Marks the close as intentional to suppress auto-reconnect.
    *
    * @param {BrowserWindow} win - the requesting window
    * @param {string} providerName - the provider to disconnect
@@ -45077,6 +45593,13 @@ const webSocketController$1 = {
 
       console.log(`[webSocketController] Disconnecting: ${providerName}`);
 
+      // Mark as intentional so the close handler doesn't auto-reconnect
+      conn.intentionalClose = true;
+
+      // Clear all timers
+      clearHeartbeatTimers(conn);
+      clearReconnectTimer(conn);
+
       // Close the socket
       if (conn.socket) {
         try {
@@ -45104,6 +45627,11 @@ const webSocketController$1 = {
         error,
       );
       // Clean up anyway
+      const conn = activeConnections.get(providerName);
+      if (conn) {
+        clearHeartbeatTimers(conn);
+        clearReconnectTimer(conn);
+      }
       activeConnections.delete(providerName);
       return {
         error: true,
@@ -45158,7 +45686,7 @@ const webSocketController$1 = {
    *
    * @param {BrowserWindow} win - the requesting window
    * @param {string} providerName - the provider name
-   * @returns {{ providerName, status, messageCount, connectedAt, lastMessageAt, error }}
+   * @returns {{ providerName, status, messageCount, connectedAt, lastMessageAt, error, retryCount }}
    */
   getStatus: (win, providerName) => {
     const conn = activeConnections.get(providerName);
@@ -45179,6 +45707,7 @@ const webSocketController$1 = {
       connectedAt: conn.connectedAt || null,
       lastMessageAt: conn.lastMessageAt || null,
       error: conn.error || null,
+      retryCount: conn.retryCount || 0,
     };
   },
 
@@ -45187,7 +45716,7 @@ const webSocketController$1 = {
    * Returns all active connections with their status.
    *
    * @param {BrowserWindow} win - the requesting window
-   * @returns {{ connections: Array<{ providerName, status, messageCount, connectedAt, lastMessageAt }> }}
+   * @returns {{ connections: Array<{ providerName, status, messageCount, connectedAt, lastMessageAt, retryCount }> }}
    */
   getAll: (win) => {
     const connections = [];
@@ -45199,6 +45728,7 @@ const webSocketController$1 = {
         connectedAt: conn.connectedAt || null,
         lastMessageAt: conn.lastMessageAt || null,
         error: conn.error || null,
+        retryCount: conn.retryCount || 0,
       });
     }
     return { success: true, connections };