opendevbrowser 0.0.16 → 0.0.18

package/extension/dist/services/RelayClient.js

@@ -1,4 +1,5 @@
 import { logError } from "../logging.js";
+const RELAY_OPEN_TIMEOUT_MS = 3000;
 export class RelayClient {
     url;
     handlers;
@@ -26,17 +27,48 @@ export class RelayClient {
             }
             else {
                 this.socket = new WebSocket(this.url);
+                const socket = this.socket;
                 await new Promise((resolve, reject) => {
-                    if (!this.socket) {
+                    if (!socket) {
                         reject(new Error("Relay socket not created"));
                         return;
                     }
-                    this.socket.addEventListener("open", () => resolve(), { once: true });
-                    this.socket.addEventListener("error", () => reject(new Error("Relay socket error")), {
+                    let settled = false;
+                    const finish = (error) => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        clearTimeout(timeoutId);
+                        if (error) {
+                            if (this.socket === socket) {
+                                this.socket = null;
+                            }
+                            try {
+                                if (socket.readyState === WebSocket.CONNECTING || socket.readyState === WebSocket.OPEN) {
+                                    socket.close();
+                                }
+                            }
+                            catch {
+                                // Ignore close failures on a half-open socket.
+                            }
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    };
+                    const timeoutId = setTimeout(() => {
+                        finish(new Error("Relay socket open timed out"));
+                    }, RELAY_OPEN_TIMEOUT_MS);
+                    socket.addEventListener("open", () => finish(), { once: true });
+                    socket.addEventListener("error", () => finish(new Error("Relay socket error")), {
+                        once: true
+                    });
+                    socket.addEventListener("close", () => finish(new Error("Relay socket closed before open")), {
                         once: true
                     });
                 });
-                this.socket.addEventListener("message", (event) => {
+                socket.addEventListener("message", (event) => {
                     const message = parseJson(event.data);
                     if (!message || typeof message !== "object")
                         return;
@@ -90,6 +122,10 @@ export class RelayClient {
                         this.handlers.onCommand(record);
                         return;
                     }
+                    if (isCdpControl(record)) {
+                        this.handlers.onCdpControl?.(record);
+                        return;
+                    }
                     if (record.type === "annotationCommand") {
                         this.handlers.onAnnotationCommand?.(record);
                         return;
@@ -98,8 +134,11 @@ export class RelayClient {
                         this.handlers.onOpsMessage?.(record);
                         return;
                     }
+                    if (isCanvasEnvelope(record)) {
+                        this.handlers.onCanvasMessage?.(record);
+                    }
                 });
-                this.socket.addEventListener("close", (event) => {
+                socket.addEventListener("close", (event) => {
                     if (this.pendingHandshakeAckReject) {
                         const reject = this.pendingHandshakeAckReject;
                         this.clearHandshakeAckWait();
@@ -119,29 +158,7 @@ export class RelayClient {
                     this.handlers.onClose({ code: event.code, reason: event.reason });
                 });
             }
-            const ackPromise = new Promise((resolve, reject) => {
-                this.clearHandshakeAckWait();
-                this.pendingHandshakeAckResolve = resolve;
-                this.pendingHandshakeAckReject = reject;
-                this.pendingHandshakeAckTimeoutId = setTimeout(() => {
-                    this.clearHandshakeAckWait();
-                    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                        this.socket.close(1000, "Handshake ack timeout");
-                    }
-                    reject(new Error("Relay handshake not acknowledged"));
-                }, 2000);
-            });
-            try {
-                this.send(handshake);
-            }
-            catch (error) {
-                this.clearHandshakeAckWait();
-                if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                    this.socket.close(1000, "Handshake send failed");
-                }
-                throw error;
-            }
-            return await ackPromise;
+            return await this.sendHandshake(handshake);
         })();
         this.connectPromise = run;
         try {
@@ -169,8 +186,31 @@ export class RelayClient {
     sendEvent(event) {
         this.send(event);
     }
-    sendHandshake(handshake) {
-        this.send(handshake);
+    async sendHandshake(handshake) {
+        this.lastHandshakeAck = null;
+        const ackPromise = new Promise((resolve, reject) => {
+            this.clearHandshakeAckWait();
+            this.pendingHandshakeAckResolve = resolve;
+            this.pendingHandshakeAckReject = reject;
+            this.pendingHandshakeAckTimeoutId = setTimeout(() => {
+                this.clearHandshakeAckWait();
+                if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                    this.socket.close(1000, "Handshake ack timeout");
+                }
+                reject(new Error("Relay handshake not acknowledged"));
+            }, 2000);
+        });
+        try {
+            this.send(handshake);
+        }
+        catch (error) {
+            this.clearHandshakeAckWait();
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                this.socket.close(1000, "Handshake send failed");
+            }
+            throw error instanceof Error ? error : new Error("Relay handshake send failed");
+        }
+        return await ackPromise;
     }
     sendAnnotationResponse(response) {
         this.send(response);
@@ -181,6 +221,9 @@ export class RelayClient {
     sendOpsMessage(message) {
         this.send(message);
     }
+    sendCanvasMessage(message) {
+        this.send(message);
+    }
     async sendHealthCheck(timeoutMs = 1500) {
         return await this.sendPing(timeoutMs);
     }
@@ -272,3 +315,9 @@ const isValidPong = (value) => {
 const isOpsEnvelope = (value) => {
     return typeof value.type === "string" && value.type.startsWith("ops_");
 };
+const isCanvasEnvelope = (value) => {
+    return typeof value.type === "string" && value.type.startsWith("canvas_");
+};
+const isCdpControl = (value) => {
+    return value.type === "cdp_control" && value.action === "client_closed";
+};

package/extension/dist/services/TabManager.js

@@ -1,3 +1,4 @@
+import { getRestrictionMessage } from "./url-restrictions.js";
 export class TabManager {
     async createTab(url, active = true) {
         return await new Promise((resolve, reject) => {
@@ -16,45 +17,128 @@ export class TabManager {
         });
     }
     async waitForTabComplete(tabId, timeoutMs = 10000) {
-        const existing = await this.getTab(tabId);
-        if (existing?.status === "complete") {
+        const isComplete = async () => {
+            const current = await this.getTab(tabId);
+            return current?.status === "complete";
+        };
+        if (await isComplete()) {
             return;
         }
         await new Promise((resolve, reject) => {
             let settled = false;
-            const timeoutId = setTimeout(() => {
+            let pollId = null;
+            const settle = (error) => {
                 if (settled)
                     return;
                 settled = true;
+                clearTimeout(timeoutId);
+                if (pollId !== null) {
+                    clearInterval(pollId);
+                }
                 chrome.tabs.onUpdated.removeListener(listener);
-                reject(new Error("Tab load timeout"));
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            };
+            const timeoutId = setTimeout(() => {
+                settle(new Error("Tab load timeout"));
             }, timeoutMs);
-            const listener = (updatedId, changeInfo) => {
+            const listener = (updatedId, changeInfo, tab) => {
                 if (updatedId !== tabId) {
                     return;
                 }
-                if (changeInfo.status === "complete") {
-                    if (settled)
-                        return;
-                    settled = true;
-                    clearTimeout(timeoutId);
-                    chrome.tabs.onUpdated.removeListener(listener);
-                    resolve();
+                if (changeInfo.status === "complete" || tab?.status === "complete") {
+                    settle();
                 }
             };
             chrome.tabs.onUpdated.addListener(listener);
+            const poll = () => {
+                void isComplete()
+                    .then((complete) => {
+                    if (complete) {
+                        settle();
+                    }
+                })
+                    .catch(() => {
+                    // Ignore transient tab lookup failures and let the timeout decide.
+                });
+            };
+            pollId = setInterval(poll, Math.min(250, Math.max(50, Math.floor(timeoutMs / 20))));
+            poll();
         });
     }
-    async closeTab(tabId) {
+    async closeTab(tabId, timeoutMs = 2000) {
         await new Promise((resolve, reject) => {
-            chrome.tabs.remove(tabId, () => {
-                const lastError = chrome.runtime.lastError;
-                if (lastError) {
-                    reject(new Error(lastError.message));
+            let settled = false;
+            let pollId = null;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutId);
+                if (pollId !== null) {
+                    clearInterval(pollId);
+                }
+                chrome.tabs.onRemoved?.removeListener?.(removedListener);
+                if (error) {
+                    reject(error);
                     return;
                 }
                 resolve();
-            });
+            };
+            const removedListener = (removedTabId) => {
+                if (removedTabId === tabId) {
+                    finish();
+                }
+            };
+            const checkClosed = () => {
+                void this.getTab(tabId)
+                    .then((tab) => {
+                    if (!tab) {
+                        finish();
+                    }
+                })
+                    .catch(() => {
+                    finish();
+                });
+            };
+            const timeoutId = setTimeout(() => {
+                void this.getTab(tabId)
+                    .then((tab) => {
+                    if (!tab) {
+                        finish();
+                        return;
+                    }
+                    finish(new Error("Tab close timed out"));
+                })
+                    .catch(() => {
+                    finish();
+                });
+            }, timeoutMs);
+            chrome.tabs.onRemoved?.addListener?.(removedListener);
+            pollId = setInterval(checkClosed, Math.min(250, Math.max(50, Math.floor(timeoutMs / 20))));
+            try {
+                chrome.tabs.remove(tabId, () => {
+                    const lastError = chrome.runtime.lastError;
+                    if (lastError) {
+                        const message = lastError.message ?? "Tab close failed";
+                        if (message.includes("No tab with id")) {
+                            finish();
+                            return;
+                        }
+                        finish(new Error(message));
+                        return;
+                    }
+                    finish();
+                });
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error("Tab close failed"));
+                return;
+            }
+            checkClosed();
         });
     }
     async activateTab(tabId) {
@@ -85,15 +169,27 @@ export class TabManager {
         const tab = await this.getActiveTab();
         return tab?.id ?? null;
     }
-    async getFirstHttpTabId() {
+    async getFirstAttachableTab(excludeTabId) {
         const tabs = await chrome.tabs.query({});
         const match = tabs.find((tab) => {
             if (typeof tab.id !== "number")
                 return false;
-            if (!tab.url)
+            if (typeof excludeTabId === "number" && tab.id === excludeTabId)
                 return false;
-            return tab.url.startsWith("http://") || tab.url.startsWith("https://");
+            const rawUrl = tab.url ?? tab.pendingUrl;
+            if (!rawUrl)
+                return false;
+            try {
+                return !getRestrictionMessage(new URL(rawUrl));
+            }
+            catch {
+                return false;
+            }
         });
-        return match?.id ?? null;
+        return match ?? null;
+    }
+    async getFirstHttpTabId(excludeTabId) {
+        const tab = await this.getFirstAttachableTab(excludeTabId);
+        return typeof tab?.id === "number" ? tab.id : null;
     }
 }

package/extension/dist/services/TargetSessionMap.js

@@ -2,23 +2,109 @@ export class TargetSessionMap {
     tabTargets = new Map();
     sessionsById = new Map();
     sessionByTarget = new Map();
+    rootTargetAliases = new Map();
     rootWaiters = new Map();
-    registerRootTab(tabId, targetInfo, sessionId) {
-        const record = { tabId, targetInfo, rootSessionId: sessionId };
+    registerRootTab(tabId, targetInfo, sessionId, attachTargetId, debuggerSession = { tabId }) {
+        const existing = this.tabTargets.get(tabId) ?? null;
+        if (existing) {
+            this.rememberRootTargetAlias(tabId, existing.targetInfo.targetId);
+            this.rememberRootTargetAlias(tabId, existing.attachTargetId);
+            this.sessionByTarget.delete(existing.targetInfo.targetId);
+            if (existing.rootSessionId !== sessionId) {
+                this.sessionsById.delete(existing.rootSessionId);
+            }
+        }
+        const record = {
+            tabId,
+            targetInfo,
+            rootSessionId: sessionId,
+            attachTargetId: attachTargetId ?? existing?.attachTargetId,
+            attachedRootSessionId: existing?.attachedRootSessionId,
+            browserSessionId: existing?.browserSessionId
+        };
         this.tabTargets.set(tabId, record);
         const session = {
             kind: "root",
             sessionId,
             tabId,
             targetId: targetInfo.targetId,
-            debuggerSession: { tabId },
+            debuggerSession,
             targetInfo
         };
         this.sessionsById.set(sessionId, session);
         this.sessionByTarget.set(targetInfo.targetId, sessionId);
+        this.rememberRootTargetAlias(tabId, targetInfo.targetId);
+        this.rememberRootTargetAlias(tabId, record.attachTargetId);
         this.resolveRootWaiters(tabId, session);
         return session;
     }
+    setRootAttachTargetId(tabId, attachTargetId) {
+        const record = this.tabTargets.get(tabId);
+        if (!record) {
+            return;
+        }
+        record.attachTargetId = attachTargetId;
+        this.rememberRootTargetAlias(tabId, attachTargetId);
+    }
+    getAttachedRootSession(tabId) {
+        const record = this.tabTargets.get(tabId) ?? null;
+        if (!record?.attachedRootSessionId) {
+            return null;
+        }
+        return this.sessionsById.get(record.attachedRootSessionId) ?? null;
+    }
+    registerAttachedRootSession(tabId, sessionId) {
+        const record = this.tabTargets.get(tabId) ?? null;
+        if (!record) {
+            return null;
+        }
+        if (record.attachedRootSessionId && record.attachedRootSessionId !== sessionId) {
+            this.sessionsById.delete(record.attachedRootSessionId);
+        }
+        record.attachedRootSessionId = sessionId;
+        const session = {
+            kind: "child",
+            sessionId,
+            tabId,
+            targetId: record.targetInfo.targetId,
+            debuggerSession: {
+                tabId,
+                sessionId,
+                ...(typeof record.attachTargetId === "string" && record.attachTargetId.length > 0
+                    ? { targetId: record.attachTargetId }
+                    : {})
+            },
+            targetInfo: record.targetInfo
+        };
+        this.sessionsById.set(sessionId, session);
+        return session;
+    }
+    getBrowserSession(tabId) {
+        const record = this.tabTargets.get(tabId) ?? null;
+        if (!record?.browserSessionId) {
+            return null;
+        }
+        return this.sessionsById.get(record.browserSessionId) ?? null;
+    }
+    registerBrowserSession(tabId, sessionId) {
+        const record = this.tabTargets.get(tabId) ?? null;
+        if (!record) {
+            return null;
+        }
+        if (record.browserSessionId && record.browserSessionId !== sessionId) {
+            this.sessionsById.delete(record.browserSessionId);
+        }
+        record.browserSessionId = sessionId;
+        const session = {
+            kind: "child",
+            sessionId,
+            tabId,
+            targetId: record.targetInfo.targetId,
+            debuggerSession: { tabId }
+        };
+        this.sessionsById.set(sessionId, session);
+        return session;
+    }
     registerChildSession(tabId, targetInfo, sessionId) {
         const session = {
             kind: "child",
@@ -45,6 +131,9 @@ export class TargetSessionMap {
         }
         return this.sessionsById.get(sessionId) ?? null;
     }
+    getTabIdByTargetAlias(targetId) {
+        return this.rootTargetAliases.get(targetId) ?? null;
+    }
     getByTabId(tabId) {
         return this.tabTargets.get(tabId) ?? null;
     }
@@ -80,6 +169,19 @@ export class TargetSessionMap {
     listSessionIds() {
         return Array.from(this.sessionsById.keys());
     }
+    reset() {
+        for (const waiters of this.rootWaiters.values()) {
+            for (const waiter of waiters) {
+                clearTimeout(waiter.timeoutId);
+                waiter.reject(new Error("Target attach reset"));
+            }
+        }
+        this.rootWaiters.clear();
+        this.tabTargets.clear();
+        this.sessionsById.clear();
+        this.sessionByTarget.clear();
+        this.rootTargetAliases.clear();
+    }
     removeByTabId(tabId) {
         const record = this.tabTargets.get(tabId) ?? null;
         if (!record) {
@@ -96,6 +198,11 @@ export class TargetSessionMap {
                 this.sessionByTarget.delete(targetId);
             }
         }
+        for (const [targetId, mappedTabId] of this.rootTargetAliases.entries()) {
+            if (mappedTabId === tabId) {
+                this.rootTargetAliases.delete(targetId);
+            }
+        }
         this.tabTargets.delete(tabId);
         return record;
     }
@@ -108,6 +215,17 @@ export class TargetSessionMap {
             this.removeByTabId(session.tabId);
             return session;
         }
+        const record = this.tabTargets.get(session.tabId) ?? null;
+        if (record?.browserSessionId === sessionId) {
+            record.browserSessionId = undefined;
+            this.sessionsById.delete(sessionId);
+            return session;
+        }
+        if (record?.attachedRootSessionId === sessionId) {
+            record.attachedRootSessionId = undefined;
+            this.sessionsById.delete(sessionId);
+            return session;
+        }
         this.sessionsById.delete(sessionId);
         this.sessionByTarget.delete(session.targetId);
         return session;
@@ -143,4 +261,10 @@ export class TargetSessionMap {
             this.rootWaiters.set(tabId, remaining);
         }
     }
+    rememberRootTargetAlias(tabId, targetId) {
+        if (typeof targetId !== "string" || targetId.length === 0) {
+            return;
+        }
+        this.rootTargetAliases.set(targetId, tabId);
+    }
 }

package/extension/dist/services/attach-errors.js

@@ -0,0 +1,20 @@
+const ATTACH_BLOCKED_ERROR_MARKERS = [
+    "Not allowed",
+    "Another debugger is already attached"
+];
+const readAttachErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (error && typeof error === "object" && "message" in error) {
+        const message = error.message;
+        if (typeof message === "string") {
+            return message;
+        }
+    }
+    return String(error);
+};
+export const isAttachBlockedError = (error) => {
+    const message = readAttachErrorMessage(error);
+    return ATTACH_BLOCKED_ERROR_MARKERS.some((marker) => message.includes(marker));
+};