@btraut/browser-bridge 0.11.1 → 0.12.1

package/extension/assets/ui.css

@@ -36,7 +36,7 @@ body.bb-page {
 body.bb-page.bb-page--popup {
   height: auto;
   padding: 10px 10px 12px;
-  min-width: 260px;
+  min-width: 300px;
   background: var(--bb-surface);
 }
 
@@ -68,6 +68,37 @@ body.bb-page.bb-page--popup {
   padding: 2px;
 }
 
+.bb-connection {
+  border: 1px solid var(--bb-border-2);
+  border-radius: var(--bb-radius-sm);
+  background: var(--bb-bg);
+  box-shadow: 0 3px 8px rgba(0, 0, 0, 0.06);
+  padding: 10px 12px;
+  margin: 0 0 10px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.bb-connection-label {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--bb-ink);
+}
+
+.bb-connection-dot {
+  width: 11px;
+  height: 11px;
+  border-radius: 999px;
+  border: 1px solid rgba(162, 43, 43, 0.35);
+  background: #c93939;
+}
+
+.bb-connection-dot[data-connected='true'] {
+  border-color: rgba(31, 111, 63, 0.4);
+  background: #2b9a52;
+}
+
 .bb-popup-head {
   display: flex;
   align-items: center;

package/extension/dist/background.js

@@ -410,10 +410,86 @@ var PermissionPromptController = class {
   }
 };
 
+// packages/extension/src/connection-state.ts
+var toIso = (ms) => new Date(ms).toISOString();
+var ConnectionStateTracker = class {
+  constructor(now = Date.now, failureLogThrottleMs = 15e3) {
+    this.now = now;
+    this.failureLogThrottleMs = failureLogThrottleMs;
+    this.state = "disconnected";
+    this.consecutiveFailures = 0;
+    this.lastFailureLogAt = 0;
+    this.suppressedFailureLogs = 0;
+  }
+  setEndpoint(endpoint) {
+    this.endpoint = endpoint;
+  }
+  markConnecting() {
+    this.state = "connecting";
+    this.reconnectDelayMs = void 0;
+    this.retryAt = void 0;
+  }
+  markConnected() {
+    this.state = "connected";
+    this.lastConnectedAt = toIso(this.now());
+    this.reconnectDelayMs = void 0;
+    this.retryAt = void 0;
+    this.consecutiveFailures = 0;
+  }
+  markDisconnected() {
+    this.state = "disconnected";
+    this.reconnectDelayMs = void 0;
+    this.retryAt = void 0;
+    this.lastDisconnectedAt = toIso(this.now());
+  }
+  markBackoff(delayMs2) {
+    this.state = "backoff";
+    this.reconnectDelayMs = delayMs2;
+    this.retryAt = toIso(this.now() + Math.max(0, delayMs2));
+  }
+  recordFailure(message) {
+    this.lastErrorAt = toIso(this.now());
+    this.lastErrorMessage = message;
+    this.consecutiveFailures += 1;
+  }
+  consumeFailureLogBudget() {
+    const now = this.now();
+    if (this.lastFailureLogAt === 0 || now - this.lastFailureLogAt >= this.failureLogThrottleMs) {
+      const suppressedCount = this.suppressedFailureLogs;
+      this.suppressedFailureLogs = 0;
+      this.lastFailureLogAt = now;
+      return { shouldLog: true, suppressedCount };
+    }
+    this.suppressedFailureLogs += 1;
+    return { shouldLog: false, suppressedCount: this.suppressedFailureLogs };
+  }
+  flushSuppressedFailureLogs() {
+    const count = this.suppressedFailureLogs;
+    this.suppressedFailureLogs = 0;
+    return count;
+  }
+  getStatus() {
+    return {
+      state: this.state,
+      endpoint: this.endpoint,
+      ws_url: this.endpoint ? `ws://${this.endpoint.host}:${this.endpoint.port}/drive` : void 0,
+      reconnect_delay_ms: this.reconnectDelayMs,
+      retry_at: this.retryAt,
+      last_connected_at: this.lastConnectedAt,
+      last_disconnected_at: this.lastDisconnectedAt,
+      last_error_at: this.lastErrorAt,
+      last_error_message: this.lastErrorMessage,
+      consecutive_failures: this.consecutiveFailures
+    };
+  }
+};
+
 // packages/extension/src/background.ts
 var DEFAULT_CORE_PORT = 3210;
 var CORE_PORT_KEY = "corePort";
 var CORE_WS_PATH = "/drive";
+var CORE_HEALTH_PATH = "/health";
+var CORE_HEALTH_TIMEOUT_MS = 1200;
 var DEBUGGER_PROTOCOL_VERSION = "1.3";
 var DEBUGGER_IDLE_TIMEOUT_KEY = "debuggerIdleTimeoutMs";
 var DEFAULT_DEBUGGER_IDLE_TIMEOUT_MS = 15e3;
@@ -598,24 +674,36 @@ var renderDataUrlToFormat = async (dataUrl, format, quality) => {
     bitmap.close();
   }
 };
-var readCorePort = async () => {
+var readCoreEndpointConfig = async () => {
   return await new Promise((resolve) => {
     chrome.storage.local.get(
       [CORE_PORT_KEY],
       (result) => {
         const raw = result?.[CORE_PORT_KEY];
         if (typeof raw === "number" && Number.isFinite(raw)) {
-          resolve(raw);
+          resolve({
+            host: "127.0.0.1",
+            port: raw,
+            portSource: "storage"
+          });
           return;
         }
         if (typeof raw === "string") {
           const parsed = Number(raw);
           if (Number.isFinite(parsed)) {
-            resolve(parsed);
+            resolve({
+              host: "127.0.0.1",
+              port: parsed,
+              portSource: "storage"
+            });
             return;
           }
         }
-        resolve(DEFAULT_CORE_PORT);
+        resolve({
+          host: "127.0.0.1",
+          port: DEFAULT_CORE_PORT,
+          portSource: "default"
+        });
       }
     );
   });
@@ -1060,10 +1148,14 @@ var waitForDomContentLoaded = async (tabId, timeoutMs) => {
     }, timeoutMs);
   });
 };
-var getWsUrl = async () => {
-  const port = await readCorePort();
-  return `ws://127.0.0.1:${port}${CORE_WS_PATH}`;
+var getWsEndpoint = async () => {
+  const endpoint = await readCoreEndpointConfig();
+  return {
+    endpoint,
+    url: `ws://${endpoint.host}:${endpoint.port}${CORE_WS_PATH}`
+  };
 };
+var getHealthEndpoint = (endpoint) => `http://${endpoint.host}:${endpoint.port}${CORE_HEALTH_PATH}`;
 var DriveSocket = class {
   constructor() {
     this.socket = null;
@@ -1074,10 +1166,12 @@ var DriveSocket = class {
     this.keepAliveIntervalMs = 3e4;
     this.debuggerSessions = /* @__PURE__ */ new Map();
     this.debuggerIdleTimeoutMs = null;
+    this.connection = new ConnectionStateTracker();
   }
   start() {
+    this.connection.markConnecting();
     void this.connect().catch((error) => {
-      console.error("DriveSocket connect failed:", error);
+      this.recordConnectionFailure("initial connect", error);
     });
   }
   stop() {
@@ -1090,6 +1184,7 @@ var DriveSocket = class {
       this.socket.close();
       this.socket = null;
     }
+    this.connection.markDisconnected();
   }
   sendTabReport() {
     void this.emitTabReport().catch((error) => {
@@ -1101,10 +1196,12 @@ var DriveSocket = class {
       return;
     }
     const delay2 = this.reconnectDelayMs;
+    this.connection.markBackoff(delay2);
     this.reconnectTimer = self.setTimeout(() => {
       this.reconnectTimer = null;
+      this.connection.markConnecting();
       void this.connect().catch((error) => {
-        console.error("DriveSocket reconnect failed:", error);
+        this.recordConnectionFailure("reconnect", error);
       });
     }, delay2);
     this.reconnectDelayMs = Math.min(
@@ -1113,12 +1210,30 @@ var DriveSocket = class {
     );
   }
   async connect() {
-    const url = await getWsUrl();
+    const { endpoint, url } = await getWsEndpoint();
+    this.connection.setEndpoint(endpoint);
+    const health = await this.checkCoreHealth(endpoint);
+    if (!health.ok) {
+      this.connection.markDisconnected();
+      this.recordConnectionFailure(
+        "core unavailable",
+        new Error(health.detail)
+      );
+      this.scheduleReconnect();
+      return;
+    }
     try {
       const socket2 = new WebSocket(url);
       this.socket = socket2;
       socket2.addEventListener("open", () => {
         this.reconnectDelayMs = 1e3;
+        this.connection.markConnected();
+        const suppressed = this.connection.flushSuppressedFailureLogs();
+        if (suppressed > 0) {
+          console.info(
+            `DriveSocket reconnected after suppressing ${suppressed} repeated connection failures.`
+          );
+        }
         this.startKeepAlive();
         void this.sendHello().catch((error) => {
           console.error("DriveSocket hello failed:", error);
@@ -1128,22 +1243,82 @@ var DriveSocket = class {
         this.handleMessage(event.data);
       });
       socket2.addEventListener("close", () => {
-        this.socket = null;
-        this.stopKeepAlive();
-        this.scheduleReconnect();
+        this.handleSocketUnavailable(socket2, "socket closed");
       });
       socket2.addEventListener("error", () => {
-        this.socket = null;
-        this.stopKeepAlive();
-        this.scheduleReconnect();
+        this.handleSocketUnavailable(socket2, "socket error");
       });
     } catch (error) {
-      console.debug("DriveSocket connect failed, scheduling reconnect.", error);
+      this.recordConnectionFailure("connect", error);
+      this.connection.markDisconnected();
       this.scheduleReconnect();
     }
   }
+  async checkCoreHealth(endpoint) {
+    const controller = new AbortController();
+    const timeoutId = self.setTimeout(() => {
+      controller.abort();
+    }, CORE_HEALTH_TIMEOUT_MS);
+    try {
+      const response = await fetch(getHealthEndpoint(endpoint), {
+        method: "GET",
+        cache: "no-store",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          detail: `health returned HTTP ${response.status}`
+        };
+      }
+      return { ok: true, detail: "ok" };
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        return {
+          ok: false,
+          detail: `health timed out after ${CORE_HEALTH_TIMEOUT_MS}ms`
+        };
+      }
+      return {
+        ok: false,
+        detail: error instanceof Error && error.message.length > 0 ? error.message : "health check failed"
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getConnectionStatus() {
+    return this.connection.getStatus();
+  }
+  handleSocketUnavailable(socket2, reason) {
+    if (this.socket !== socket2) {
+      return;
+    }
+    this.socket = null;
+    this.stopKeepAlive();
+    this.connection.markDisconnected();
+    this.recordConnectionFailure(reason, new Error(reason));
+    this.scheduleReconnect();
+  }
+  recordConnectionFailure(context, error) {
+    const detail = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+    this.connection.recordFailure(`${context}: ${detail}`);
+    const budget = this.connection.consumeFailureLogBudget();
+    if (!budget.shouldLog) {
+      return;
+    }
+    if (budget.suppressedCount > 0) {
+      console.warn(
+        `DriveSocket ${context} failed (${budget.suppressedCount} repeated failures suppressed).`,
+        error
+      );
+      return;
+    }
+    console.warn(`DriveSocket ${context} failed.`, error);
+  }
   async sendHello() {
     const manifest = chrome.runtime.getManifest();
+    const endpoint = await readCoreEndpointConfig();
     let tabs = [];
     try {
       tabs = await queryTabs();
@@ -1153,6 +1328,9 @@ var DriveSocket = class {
     }
     const params = {
       version: manifest.version,
+      core_host: endpoint.host,
+      core_port: endpoint.port,
+      core_port_source: endpoint.portSource,
       tabs
     };
     this.sendEvent("drive.hello", params);
@@ -3188,5 +3366,17 @@ chrome.debugger.onDetach.addListener(
     });
   }
 );
+chrome.runtime.onMessage.addListener(
+  (message, _sender, sendResponse) => {
+    if (!message || typeof message !== "object" || message.action !== "drive.connection_status") {
+      return void 0;
+    }
+    sendResponse({
+      ok: true,
+      result: socket.getConnectionStatus()
+    });
+    return true;
+  }
+);
 socket.start();
 //# sourceMappingURL=background.js.map