opendevbrowser 0.0.17 → 0.0.19

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;
@@ -102,7 +138,7 @@ export class RelayClient {
                         this.handlers.onCanvasMessage?.(record);
                     }
                 });
-                this.socket.addEventListener("close", (event) => {
+                socket.addEventListener("close", (event) => {
                     if (this.pendingHandshakeAckReject) {
                         const reject = this.pendingHandshakeAckReject;
                         this.clearHandshakeAckWait();
@@ -122,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 {
@@ -172,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);
@@ -281,3 +318,6 @@ const isOpsEnvelope = (value) => {
 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) => {
@@ -68,16 +69,76 @@ export class TabManager {
             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) {
@@ -108,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;
+            const rawUrl = tab.url ?? tab.pendingUrl;
+            if (!rawUrl)
                 return false;
-            return tab.url.startsWith("http://") || tab.url.startsWith("https://");
+            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));
+};

package/extension/dist/services/cdp-router-commands.js

@@ -2,6 +2,15 @@ export async function handleSetDiscoverTargets(ctx, commandId, params) {
     const discover = params.discover === true;
     const shouldEmit = discover && !ctx.discoverTargets;
     ctx.setDiscoverTargets(discover);
+    try {
+        for (const debuggee of ctx.debuggees.values()) {
+            await ctx.applyDiscoverTargets(debuggee, discover);
+        }
+    }
+    catch (error) {
+        ctx.respondError(commandId, getErrorMessage(error));
+        return;
+    }
     if (shouldEmit) {
         for (const targetInfo of ctx.sessions.listTargetInfos()) {
             ctx.emitTargetCreated(targetInfo);
@@ -14,10 +23,6 @@ export async function handleSetAutoAttach(ctx, commandId, params, sessionId) {
         ctx.respondError(commandId, ctx.flatSessionError, sessionId);
         return;
     }
-    if (sessionId) {
-        ctx.respond(commandId, {}, sessionId);
-        return;
-    }
     const autoAttach = params.autoAttach === true;
     const waitForDebuggerOnStart = params.waitForDebuggerOnStart === true;
     ctx.setAutoAttachOptions({ autoAttach, waitForDebuggerOnStart, flatten: true, filter: params.filter });
@@ -25,18 +30,40 @@ export async function handleSetAutoAttach(ctx, commandId, params, sessionId) {
         ctx.resetRootAttached();
     }
     try {
-        for (const debuggee of ctx.debuggees.values()) {
-            await ctx.applyAutoAttach(debuggee);
+        if (sessionId) {
+            const session = ctx.sessions.getBySessionId(sessionId);
+            if (!session) {
+                ctx.respondError(commandId, `Unknown sessionId: ${sessionId}`, sessionId);
+                return;
+            }
+            await ctx.sendCommand(session.debuggerSession, "Target.setAutoAttach", {
+                autoAttach,
+                waitForDebuggerOnStart,
+                flatten: true,
+                ...(typeof params.filter !== "undefined" ? { filter: params.filter } : {})
+            });
+        }
+        else {
+            for (const debuggee of ctx.debuggees.values()) {
+                await ctx.applyAutoAttach(debuggee);
+            }
         }
     }
     catch (error) {
         ctx.respondError(commandId, getErrorMessage(error));
         return;
     }
+    if (sessionId) {
+        ctx.respond(commandId, {}, sessionId);
+        return;
+    }
     if (!autoAttach) {
         ctx.emitRootDetached();
     }
     else {
+        for (const tabId of ctx.sessions.listTabIds()) {
+            await ctx.refreshRootTargetInfo(tabId);
+        }
         for (const targetInfo of ctx.sessions.listTargetInfos()) {
             ctx.emitRootAttached(targetInfo);
         }
@@ -57,7 +84,8 @@ export async function handleCreateTarget(ctx, commandId, params) {
         await ctx.attach(tab.id);
         await ctx.sessions.waitForRootSession(tab.id);
         await ctx.sendCommand({ tabId: tab.id }, "Target.getTargets", {});
-        const targetInfo = await ctx.registerRootTab(tab.id);
+        await ctx.registerRootTab(tab.id);
+        const targetInfo = await ctx.refreshRootTargetInfo(tab.id);
         if (ctx.discoverTargets) {
             ctx.emitTargetCreated(targetInfo);
         }
@@ -175,11 +203,22 @@ export async function handleAttachToTarget(ctx, commandId, params, sessionId) {
 }
 export async function handleRoutedCommand(ctx, commandId, method, params, sessionId) {
     const session = sessionId ? ctx.sessions.getBySessionId(sessionId) : null;
+    const compatSession = resolveSyntheticCompatSession(ctx, session, sessionId);
+    if (compatSession) {
+        const compatResult = buildSyntheticRootCompatResult(compatSession, method, commandId);
+        if (compatResult) {
+            ctx.respond(commandId, compatResult.result, sessionId);
+            if (compatResult.emitExecutionContext) {
+                ctx.emitEvent("Runtime.executionContextCreated", compatResult.emitExecutionContext, sessionId);
+            }
+            return;
+        }
+    }
     if (sessionId && !session) {
         ctx.respondError(commandId, `Unknown sessionId: ${sessionId}`, sessionId);
         return;
     }
-    const debuggee = session?.debuggerSession ?? ctx.getPrimaryDebuggee();
+    const debuggee = await ctx.resolveCommandDebuggee(sessionId);
     if (!debuggee) {
         ctx.respondError(commandId, "No tab attached", sessionId);
         return;
@@ -201,3 +240,91 @@ const getErrorMessage = (error) => {
     }
     return "Unknown error";
 };
+const SYNTHETIC_ROOT_NOOP_METHODS = new Set([
+    "Runtime.runIfWaitingForDebugger",
+    "Emulation.setFocusEmulationEnabled",
+    "Emulation.setEmulatedMedia"
+]);
+const resolveSyntheticCompatSession = (ctx, session, sessionId) => {
+    if (session && isSyntheticSessionId(session.sessionId)) {
+        return session;
+    }
+    if (!isSyntheticSessionId(sessionId)) {
+        return null;
+    }
+    const primary = ctx.getPrimaryDebuggee();
+    if (typeof primary?.tabId !== "number") {
+        return null;
+    }
+    const record = ctx.sessions.getByTabId(primary.tabId);
+    if (!record) {
+        return null;
+    }
+    const rootSession = ctx.sessions.getBySessionId(record.rootSessionId);
+    if (rootSession) {
+        return rootSession;
+    }
+    return {
+        kind: "root",
+        sessionId,
+        tabId: record.tabId,
+        targetId: record.targetInfo.targetId,
+        debuggerSession: primary,
+        targetInfo: record.targetInfo
+    };
+};
+const buildSyntheticRootCompatResult = (session, method, commandId) => {
+    if (SYNTHETIC_ROOT_NOOP_METHODS.has(method)) {
+        return { result: {} };
+    }
+    const frame = buildSyntheticRootFrame(session);
+    if (method === "Page.getFrameTree") {
+        return { result: { frameTree: { frame } } };
+    }
+    if (method === "Page.addScriptToEvaluateOnNewDocument") {
+        return { result: { identifier: `odb-root-script-${String(commandId)}` } };
+    }
+    if (method === "Runtime.enable") {
+        return {
+            result: {},
+            emitExecutionContext: {
+                context: {
+                    id: 1,
+                    origin: deriveSecurityOrigin(frame.url),
+                    name: "",
+                    auxData: {
+                        frameId: frame.id,
+                        isDefault: true,
+                        type: "default"
+                    }
+                }
+            }
+        };
+    }
+    return null;
+};
+const buildSyntheticRootFrame = (session) => {
+    const targetInfo = session.targetInfo;
+    const url = typeof targetInfo?.url === "string" ? targetInfo.url : "";
+    return {
+        id: session.targetId,
+        loaderId: session.targetId,
+        url,
+        securityOrigin: deriveSecurityOrigin(url),
+        mimeType: "text/html"
+    };
+};
+const deriveSecurityOrigin = (url) => {
+    if (!url) {
+        return "";
+    }
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return "";
+    }
+};
+const isSyntheticSessionId = (value) => {
+    return typeof value === "string" && value.startsWith("pw-tab-");
+};