opendevbrowser 0.0.12 → 0.0.16

package/extension/dist/services/ConnectionManager.js

@@ -2,8 +2,38 @@ import { DEFAULT_PAIRING_ENABLED, DEFAULT_PAIRING_TOKEN, DEFAULT_RELAY_PORT } fr
 import { RelayClient } from "./RelayClient.js";
 import { CDPRouter } from "./CDPRouter.js";
 import { TabManager } from "./TabManager.js";
+import { logError } from "../logging.js";
+import { getRestrictionMessage } from "./url-restrictions.js";
+class ConnectionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const summarizeProtocol = (rawUrl) => {
+    if (!rawUrl) {
+        return "unknown";
+    }
+    try {
+        return new URL(rawUrl).protocol.replace(":", "");
+    }
+    catch (error) {
+        logError("connection.summarize_protocol", error, { code: "url_parse_failed" });
+        return "unknown";
+    }
+};
+const logInfo = (message) => {
+    console.info(`[opendevbrowser] ${message}`);
+};
+const logWarn = (message) => {
+    console.warn(`[opendevbrowser] ${message}`);
+};
+const RECONNECT_INITIAL_DELAY_MS = 12_000;
+const RECONNECT_MAX_DELAY_MS = 30_000;
 export class ConnectionManager {
     status = "disconnected";
+    lastError = null;
     listeners = new Set();
     relay = null;
     cdp = new CDPRouter();
@@ -13,14 +43,26 @@ export class ConnectionManager {
     shouldReconnect = false;
     reconnectTimer = null;
     reconnectAttempts = 0;
-    reconnectDelayMs = 500;
+    reconnectDelayMs = RECONNECT_INITIAL_DELAY_MS;
     pairingToken = DEFAULT_PAIRING_TOKEN;
     pairingEnabled = DEFAULT_PAIRING_ENABLED;
     relayPort = DEFAULT_RELAY_PORT;
-    maxReconnectAttempts = 5;
-    maxReconnectDelayMs = 5000;
+    relayInstanceId = null;
+    relayEpoch = null;
+    relayConfirmedPort = null;
+    relayNotice = null;
+    maxReconnectDelayMs = RECONNECT_MAX_DELAY_MS;
+    connectPromise = null;
+    annotationHandler = null;
+    opsHandler = null;
+    heartbeatTimer = null;
+    heartbeatInFlight = false;
+    heartbeatIntervalMs = 25_000;
+    heartbeatTimeoutMs = 2_000;
     constructor() {
-        this.loadSettings().catch(() => { });
+        this.loadSettings().catch((error) => {
+            logError("connection.load_settings", error, { code: "storage_load_failed" });
+        });
         chrome.storage.onChanged.addListener(this.handleStorageChange);
         chrome.tabs.onRemoved.addListener(this.handleTabRemoved);
         chrome.tabs.onUpdated.addListener(this.handleTabUpdated);
@@ -28,19 +70,106 @@ export class ConnectionManager {
     getStatus() {
         return this.status;
     }
-    async connect() {
-        if (this.status === "connected") {
+    getRelayIdentity() {
+        return {
+            instanceId: this.relayInstanceId,
+            relayPort: this.relayConfirmedPort
+        };
+    }
+    getRelayNotice() {
+        return this.relayNotice;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    clearLastError() {
+        this.lastError = null;
+    }
+    onAnnotationCommand(handler) {
+        this.annotationHandler = handler;
+    }
+    onOpsMessage(handler) {
+        this.opsHandler = handler;
+    }
+    sendAnnotationResponse(response) {
+        if (!this.relay)
+            return;
+        try {
+            this.relay.sendAnnotationResponse(response);
+        }
+        catch (error) {
+            logError("relay.send_annotation_response", error, { code: "relay_send_failed" });
+        }
+    }
+    sendAnnotationEvent(event) {
+        if (!this.relay)
             return;
+        try {
+            this.relay.sendAnnotationEvent(event);
         }
+        catch (error) {
+            logError("relay.send_annotation_event", error, { code: "relay_send_failed" });
+        }
+    }
+    sendOpsMessage(message) {
+        if (!this.relay)
+            return;
         try {
-            this.shouldReconnect = true;
-            this.reconnectAttempts = 0;
-            await this.loadSettings();
-            await this.attachToActiveTab();
-            await this.connectRelay();
+            this.relay.sendOpsMessage(message);
+        }
+        catch (error) {
+            logError("relay.send_ops_message", error, { code: "relay_send_failed" });
+        }
+    }
+    getCdpRouter() {
+        return this.cdp;
+    }
+    async relayHealthCheck() {
+        if (!this.relay || !this.relay.isConnected()) {
+            return null;
+        }
+        try {
+            return await this.relay.sendHealthCheck();
+        }
+        catch (error) {
+            logError("relay.health_check", error, { code: "relay_health_failed" });
+            return null;
+        }
+    }
+    async connect() {
+        if (this.connectPromise) {
+            return await this.connectPromise;
         }
-        catch {
-            await this.disconnect();
+        const run = (async () => {
+            if (this.status === "connected") {
+                return;
+            }
+            try {
+                this.clearLastError();
+                this.relayNotice = null;
+                this.shouldReconnect = true;
+                this.reconnectAttempts = 0;
+                await this.loadSettings();
+                await this.attachToActiveTab();
+                await this.connectRelay();
+                this.clearLastError();
+            }
+            catch (error) {
+                const info = this.normalizeError(error);
+                this.setLastError(info);
+                const detail = error instanceof Error ? error.message : "Unknown error";
+                logWarn(`Connect failed (${info.code}). ${detail}`);
+                await this.disconnect();
+            }
+        })();
+        this.connectPromise = run;
+        try {
+            return await run;
+        }
+        finally {
+            if (this.connectPromise === run) {
+                this.connectPromise = null;
+            }
         }
     }
     async disconnect() {
@@ -49,19 +178,22 @@ export class ConnectionManager {
         this.disconnecting = true;
         this.shouldReconnect = false;
         this.clearReconnectTimer();
+        this.stopHeartbeat();
         try {
             if (this.relay) {
                 this.relay.disconnect();
                 this.relay = null;
             }
-            if (this.trackedTab !== null) {
-                await this.cdp.detach();
-                this.trackedTab = null;
-            }
+            await this.cdp.detachAll();
+            this.trackedTab = null;
         }
         finally {
             this.disconnecting = false;
             this.setStatus("disconnected");
+            this.relayInstanceId = null;
+            this.relayConfirmedPort = null;
+            this.relayEpoch = null;
+            this.relayNotice = null;
         }
     }
     onStatus(listener) {
@@ -74,16 +206,148 @@ export class ConnectionManager {
             listener(status);
         }
     }
+    safeRelaySend(action, context) {
+        try {
+            action();
+        }
+        catch (error) {
+            logError(context, error, { code: "relay_send_failed" });
+        }
+    }
+    startHeartbeat() {
+        if (this.heartbeatTimer !== null) {
+            return;
+        }
+        this.heartbeatTimer = setInterval(() => {
+            this.runHeartbeat().catch((error) => {
+                logError("relay.heartbeat", error, { code: "relay_heartbeat_failed" });
+            });
+        }, this.heartbeatIntervalMs);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer !== null) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        this.heartbeatInFlight = false;
+    }
+    async runHeartbeat() {
+        if (!this.relay || !this.relay.isConnected()) {
+            return;
+        }
+        if (this.heartbeatInFlight) {
+            return;
+        }
+        this.heartbeatInFlight = true;
+        try {
+            await this.relay.sendPing(this.heartbeatTimeoutMs);
+        }
+        catch (error) {
+            logError("relay.heartbeat", error, { code: "relay_heartbeat_failed" });
+            if (this.shouldReconnect && !this.disconnecting) {
+                this.relay.disconnect();
+            }
+        }
+        finally {
+            this.heartbeatInFlight = false;
+        }
+    }
     async attachToActiveTab() {
-        const tab = await this.tabs.getActiveTab();
+        let tab = await this.tabs.getActiveTab();
         if (!tab || typeof tab.id !== "number") {
             this.trackedTab = null;
             this.setStatus("disconnected");
-            throw new Error("No active tab available");
+            logWarn("Active tab not found.");
+            throw new ConnectionError("no_active_tab", "No active browser tab found. Focus a normal tab (not the popup) and retry.");
+        }
+        if (!tab.url) {
+            logWarn("Active tab URL missing.");
+            const fallbackId = await this.tabs.getFirstHttpTabId();
+            if (fallbackId && fallbackId !== tab.id) {
+                const fallbackTab = await this.tabs.getTab(fallbackId);
+                if (fallbackTab && typeof fallbackTab.id === "number" && fallbackTab.url) {
+                    logInfo("Falling back to first http(s) tab.");
+                    tab = fallbackTab;
+                }
+            }
+            if (!tab.url) {
+                throw new ConnectionError("tab_url_missing", "Active tab URL is unavailable. Reload the tab and retry.");
+            }
+        }
+        let parsedUrl = null;
+        try {
+            parsedUrl = new URL(tab.url);
+        }
+        catch (error) {
+            logError("connection.parse_tab_url", error, { code: "tab_url_parse_failed" });
+            parsedUrl = null;
+        }
+        if (!parsedUrl) {
+            logWarn("Active tab URL is invalid.");
+            const fallbackId = await this.tabs.getFirstHttpTabId();
+            if (fallbackId && fallbackId !== tab.id) {
+                const fallbackTab = await this.tabs.getTab(fallbackId);
+                if (fallbackTab && typeof fallbackTab.id === "number" && fallbackTab.url) {
+                    logInfo("Falling back to first http(s) tab.");
+                    try {
+                        parsedUrl = new URL(fallbackTab.url);
+                        tab = fallbackTab;
+                    }
+                    catch {
+                        parsedUrl = null;
+                    }
+                }
+            }
+            if (!parsedUrl) {
+                throw new ConnectionError("tab_url_restricted", "Active tab URL is unsupported. Focus a normal http(s) tab and retry.");
+            }
+        }
+        const restrictionMessage = getRestrictionMessage(parsedUrl);
+        if (restrictionMessage) {
+            logWarn(`Active tab blocked: ${summarizeProtocol(tab.url)} scheme.`);
+            const fallbackId = await this.tabs.getFirstHttpTabId();
+            if (fallbackId && fallbackId !== tab.id) {
+                const fallbackTab = await this.tabs.getTab(fallbackId);
+                if (fallbackTab && typeof fallbackTab.id === "number" && fallbackTab.url) {
+                    try {
+                        const fallbackUrl = new URL(fallbackTab.url);
+                        const fallbackRestriction = getRestrictionMessage(fallbackUrl);
+                        if (!fallbackRestriction) {
+                            logInfo("Falling back to first http(s) tab.");
+                            tab = fallbackTab;
+                            parsedUrl = fallbackUrl;
+                        }
+                    }
+                    catch {
+                        // Ignore invalid fallback URL.
+                    }
+                }
+            }
+            if (restrictionMessage && getRestrictionMessage(parsedUrl)) {
+                throw new ConnectionError("tab_url_restricted", restrictionMessage);
+            }
+        }
+        const tabId = tab.id;
+        if (typeof tabId !== "number") {
+            this.trackedTab = null;
+            this.setStatus("disconnected");
+            throw new ConnectionError("no_active_tab", "No active browser tab found. Focus a normal tab (not the popup) and retry.");
+        }
+        logInfo("Active tab resolved.");
+        try {
+            await this.cdp.attach(tabId);
+            logInfo("Debugger attached.");
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : "Unknown error";
+            logWarn(`Debugger attach failed. ${detail}`);
+            const message = detail.includes("Chrome 125+")
+                ? detail
+                : "Debugger attach failed. Close DevTools for the tab and retry.";
+            throw new ConnectionError("debugger_attach_failed", message);
         }
-        await this.cdp.attach(tab.id);
         this.trackedTab = {
-            id: tab.id,
+            id: tabId,
             url: tab.url ?? undefined,
             title: tab.title ?? undefined,
             groupId: typeof tab.groupId === "number" ? tab.groupId : undefined
@@ -91,84 +355,134 @@ export class ConnectionManager {
     }
     async connectRelay() {
         if (!this.trackedTab) {
-            throw new Error("No tracked tab for relay connection");
+            throw new ConnectionError("relay_connect_failed", "Relay connection failed. Start the daemon and retry.");
         }
         const relay = new RelayClient(this.buildRelayUrl(), {
             onCommand: (command) => {
-                this.cdp.handleCommand(command).catch(() => {
-                    this.disconnect().catch(() => { });
+                this.cdp.handleCommand(command).catch((error) => {
+                    logError("cdp.handle_command", error, { code: "cdp_command_failed" });
+                    this.handleCdpDetach({ reason: "cdp_command_failed" });
                 });
             },
-            onClose: () => {
-                this.handleRelayClose();
+            onAnnotationCommand: (command) => {
+                this.annotationHandler?.(command);
+            },
+            onOpsMessage: (message) => {
+                this.opsHandler?.(message);
+            },
+            onClose: (detail) => {
+                this.handleRelayClose(detail);
             }
         });
         this.relay = relay;
         this.cdp.setCallbacks({
-            onEvent: (event) => this.relay?.sendEvent(event),
-            onResponse: (response) => this.relay?.sendResponse(response),
-            onDetach: () => {
-                this.disconnect().catch(() => { });
+            onEvent: (event) => {
+                this.safeRelaySend(() => this.relay?.sendEvent(event), "relay.send_event");
+            },
+            onResponse: (response) => {
+                this.safeRelaySend(() => this.relay?.sendResponse(response), "relay.send_response");
+            },
+            onDetach: (detail) => {
+                this.handleCdpDetach(detail);
+            },
+            onPrimaryTabChange: (tabId) => {
+                this.handlePrimaryTabChange(tabId).catch((error) => {
+                    logError("connection.primary_tab_change", error, { code: "primary_tab_change_failed" });
+                });
             }
         });
         try {
-            await relay.connect(this.buildHandshake());
+            const ack = await relay.connect(this.buildHandshake());
+            const relayEpoch = typeof ack.payload.epoch === "number" && Number.isFinite(ack.payload.epoch)
+                ? ack.payload.epoch
+                : null;
+            const mismatch = await this.reconcileRelayIdentity(ack);
+            this.relayInstanceId = ack.payload.instanceId;
+            this.relayEpoch = relayEpoch;
+            this.persistRelayPort(ack.payload.relayPort);
+            if (!mismatch) {
+                this.persistRelayIdentity(ack.payload.relayPort, this.relayInstanceId, this.relayEpoch);
+            }
+            logInfo("Relay WebSocket connected.");
             this.setStatus("connected");
+            this.startHeartbeat();
             this.reconnectAttempts = 0;
-            this.reconnectDelayMs = 500;
+            this.reconnectDelayMs = RECONNECT_INITIAL_DELAY_MS;
         }
         catch (error) {
+            const detail = error instanceof Error ? error.message : "Unknown error";
+            logWarn(`Relay WebSocket connect failed. ${detail}`);
             if (this.relay === relay) {
                 this.relay = null;
             }
-            throw error;
+            throw new ConnectionError("relay_connect_failed", "Relay connection failed. Start the daemon and retry.");
         }
     }
-    handleRelayClose() {
+    handleRelayClose(detail) {
+        this.stopHeartbeat();
         this.relay = null;
-        if (!this.shouldReconnect || !this.trackedTab) {
+        if (detail && (detail.code === 1008 || detail.reason?.includes("Invalid pairing token"))) {
+            this.clearStoredPairingToken();
+        }
+        if (!this.shouldReconnect) {
             return;
         }
         this.setStatus("disconnected");
+        this.relayInstanceId = null;
+        this.relayConfirmedPort = null;
+        this.relayEpoch = null;
         this.scheduleReconnect();
     }
-    scheduleReconnect() {
-        if (this.reconnectTimer !== null) {
+    handleCdpDetach(detail) {
+        const reason = detail?.reason ? ` (${detail.reason})` : "";
+        logWarn(`CDP detached${reason}.`);
+        if (this.disconnecting) {
+            return;
+        }
+        if (!this.shouldReconnect) {
+            this.disconnect().catch((error) => {
+                logError("connection.cdp_detach_disconnect", error, { code: "disconnect_failed" });
+            });
+            return;
+        }
+        if (this.cdp.getAttachedTabIds().length > 0) {
+            return;
+        }
+        this.setStatus("disconnected");
+        if (this.relay?.isConnected()) {
+            this.relay.disconnect();
             return;
         }
-        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            this.disconnect().catch(() => { });
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer !== null) {
             return;
         }
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;
             this.reconnectAttempts += 1;
             this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, this.maxReconnectDelayMs);
-            this.reconnectRelay().catch(() => {
+            this.reconnectRelay().catch((error) => {
+                logError("connection.reconnect", error, { code: "relay_reconnect_failed" });
                 this.scheduleReconnect();
             });
         }, this.reconnectDelayMs);
     }
     async reconnectRelay() {
-        if (!this.trackedTab || !this.shouldReconnect) {
+        if (!this.shouldReconnect) {
             return;
         }
-        const attachedId = this.cdp.getAttachedTabId();
-        if (attachedId !== this.trackedTab.id) {
-            this.disconnect().catch(() => { });
-            return;
+        const primaryId = this.cdp.getPrimaryTabId();
+        if (!primaryId) {
+            await this.attachToActiveTab();
         }
-        const tab = await this.tabs.getTab(this.trackedTab.id);
-        if (!tab) {
-            this.disconnect().catch(() => { });
-            return;
+        else {
+            await this.refreshTrackedTab(primaryId);
+        }
+        if (!this.trackedTab) {
+            throw new Error("Reconnect failed: no tracked tab available");
         }
-        this.trackedTab = {
-            id: tab.id ?? this.trackedTab.id,
-            url: tab.url ?? this.trackedTab.url,
-            title: tab.title ?? this.trackedTab.title,
-            groupId: typeof tab.groupId === "number" ? tab.groupId : this.trackedTab.groupId
-        };
         await this.connectRelay();
     }
     buildHandshake() {
@@ -204,12 +518,19 @@ export class ConnectionManager {
         }
         if (changes.relayPort) {
             this.updateRelayPort(changes.relayPort.newValue);
-            this.refreshRelay().catch(() => { });
+            this.refreshRelay().catch((error) => {
+                logError("connection.refresh_relay", error, { code: "relay_refresh_failed" });
+            });
         }
     };
     handleTabRemoved = (tabId) => {
-        if (this.trackedTab && this.trackedTab.id === tabId) {
-            this.disconnect().catch(() => { });
+        if (!this.trackedTab || this.trackedTab.id !== tabId) {
+            return;
+        }
+        if (this.cdp.getAttachedTabIds().length <= 1) {
+            this.disconnect().catch((error) => {
+                logError("connection.tab_removed_disconnect", error, { code: "disconnect_failed" });
+            });
         }
     };
     handleTabUpdated = (_tabId, _changeInfo, tab) => {
@@ -223,7 +544,7 @@ export class ConnectionManager {
             groupId: typeof tab.groupId === "number" ? tab.groupId : this.trackedTab.groupId
         };
         if (this.relay?.isConnected()) {
-            this.relay.sendHandshake(this.buildHandshake());
+            this.safeRelaySend(() => this.relay?.sendHandshake(this.buildHandshake()), "relay.send_handshake");
         }
     };
     async loadSettings() {
@@ -237,6 +558,18 @@ export class ConnectionManager {
         this.updateRelayPort(data.relayPort);
         this.ensurePairingTokenDefault();
     }
+    setLastError(error) {
+        this.lastError = error;
+    }
+    normalizeError(error) {
+        if (error instanceof ConnectionError) {
+            return { code: error.code, message: error.message };
+        }
+        return {
+            code: "unknown",
+            message: "Connection failed. Focus a normal tab and retry."
+        };
+    }
     updatePairingToken(value) {
         if (typeof value === "string" && value.trim().length > 0) {
             this.pairingToken = value.trim();
@@ -258,6 +591,12 @@ export class ConnectionManager {
         this.pairingToken = DEFAULT_PAIRING_TOKEN;
         chrome.storage.local.set({ pairingToken: DEFAULT_PAIRING_TOKEN });
     }
+    clearStoredPairingToken(clearMemory = true) {
+        if (clearMemory) {
+            this.pairingToken = null;
+        }
+        chrome.storage.local.set({ pairingToken: null, tokenEpoch: null });
+    }
     updateRelayPort(value) {
         if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535) {
             this.relayPort = value;
@@ -272,6 +611,52 @@ export class ConnectionManager {
         }
         this.relayPort = DEFAULT_RELAY_PORT;
     }
+    persistRelayPort(value) {
+        if (!Number.isInteger(value) || value <= 0 || value > 65535) {
+            return;
+        }
+        this.relayPort = value;
+        this.relayConfirmedPort = value;
+        chrome.storage.local.set({ relayPort: value });
+    }
+    persistRelayIdentity(port, instanceId, epoch) {
+        this.persistRelayPort(port);
+        chrome.storage.local.set({
+            relayInstanceId: instanceId,
+            relayEpoch: epoch
+        });
+    }
+    clearStoredRelayIdentity() {
+        chrome.storage.local.set({
+            relayInstanceId: null,
+            relayEpoch: null
+        });
+    }
+    async reconcileRelayIdentity(ack) {
+        const stored = await new Promise((resolve) => {
+            chrome.storage.local.get(["relayInstanceId", "relayEpoch"], (items) => resolve(items));
+        });
+        const storedInstanceId = typeof stored.relayInstanceId === "string" ? stored.relayInstanceId : null;
+        const storedEpoch = typeof stored.relayEpoch === "number" && Number.isFinite(stored.relayEpoch)
+            ? stored.relayEpoch
+            : null;
+        const ackEpoch = typeof ack.payload.epoch === "number" && Number.isFinite(ack.payload.epoch)
+            ? ack.payload.epoch
+            : null;
+        const instanceMismatch = Boolean(storedInstanceId && storedInstanceId !== ack.payload.instanceId);
+        const epochMismatch = storedEpoch !== null && ackEpoch !== null && storedEpoch !== ackEpoch;
+        if (instanceMismatch || epochMismatch) {
+            this.clearStoredRelayIdentity();
+            this.clearStoredPairingToken(false);
+            this.relayNotice = instanceMismatch
+                ? "Relay instance changed. Re-pair and reconnect."
+                : "Relay restarted. Re-pair and reconnect.";
+            this.safeRelaySend(() => this.relay?.sendHandshake(this.buildHandshake()), "relay.rehandshake");
+            return true;
+        }
+        this.relayNotice = null;
+        return false;
+    }
     /**
      * Chrome automatically sends Origin: chrome-extension://EXTENSION_ID
      * for WebSocket connections from extensions. The relay server validates
@@ -286,6 +671,30 @@ export class ConnectionManager {
         await this.disconnect();
         await this.connect();
     }
+    async handlePrimaryTabChange(tabId) {
+        if (!tabId) {
+            this.trackedTab = null;
+            if (this.relay?.isConnected()) {
+                this.relay.disconnect();
+            }
+            return;
+        }
+        await this.refreshTrackedTab(tabId);
+        this.refreshHandshake();
+    }
+    async refreshTrackedTab(tabId) {
+        const tab = await this.tabs.getTab(tabId);
+        if (!tab || typeof tab.id !== "number") {
+            this.trackedTab = null;
+            return;
+        }
+        this.trackedTab = {
+            id: tab.id,
+            url: tab.url ?? this.trackedTab?.url,
+            title: tab.title ?? this.trackedTab?.title,
+            groupId: typeof tab.groupId === "number" ? tab.groupId : this.trackedTab?.groupId
+        };
+    }
     clearReconnectTimer() {
         if (this.reconnectTimer !== null) {
             clearTimeout(this.reconnectTimer);
@@ -296,6 +705,6 @@ export class ConnectionManager {
         if (!this.trackedTab || !this.relay?.isConnected()) {
             return;
         }
-        this.relay.sendHandshake(this.buildHandshake());
+        this.safeRelaySend(() => this.relay?.sendHandshake(this.buildHandshake()), "relay.send_handshake");
     }
 }