opendevbrowser 0.0.12 → 0.0.16

package/extension/dist/services/CDPRouter.js

@@ -1,79 +1,559 @@
+import { TabManager } from "./TabManager.js";
+import { TargetSessionMap } from "./TargetSessionMap.js";
+import { logError } from "../logging.js";
+import { handleSetDiscoverTargets, handleSetAutoAttach, handleCreateTarget, handleCloseTarget, handleActivateTarget, handleAttachToTarget, handleRoutedCommand } from "./cdp-router-commands.js";
+const FLAT_SESSION_ERROR = "Chrome 125+ required for extension relay (flat sessions).";
+const DEPRECATED_SEND_MESSAGE = "Target.sendMessageToTarget is deprecated in flat session mode. Use sessionId routing.";
+const DEFAULT_BROWSER_CONTEXT_ID = "default";
 export class CDPRouter {
-    debuggee = null;
+    debuggees = new Map();
+    sessions = new TargetSessionMap();
+    tabManager = new TabManager();
+    rootAttachedSessions = new Set();
     callbacks = null;
+    autoAttachOptions = { autoAttach: false, waitForDebuggerOnStart: false, flatten: true };
+    discoverTargets = false;
+    listenersActive = false;
+    flatSessionValidated = false;
+    primaryTabId = null;
+    lastActiveTabId = null;
+    sessionCounter = 1;
+    quarantinedSessions = new Map();
+    churnTracker = new Map();
+    churnWindowMs = 5000;
+    churnThreshold = 3;
     handleEventBound = (source, method, params) => {
         this.handleEvent(source, method, params);
     };
-    handleDetachBound = (source) => {
-        this.handleDetach(source);
+    handleDetachBound = (source, reason) => {
+        this.handleDetach(source, reason);
     };
     setCallbacks(callbacks) {
         this.callbacks = callbacks;
     }
     async attach(tabId) {
-        if (this.debuggee?.tabId === tabId) {
+        await this.attachInternal(tabId, true);
+    }
+    async attachInternal(tabId, allowRetry) {
+        if (this.debuggees.has(tabId)) {
+            this.updatePrimaryTab(tabId);
             return;
         }
-        if (this.debuggee) {
-            await this.detach();
-        }
-        this.debuggee = { tabId };
+        const debuggee = { tabId };
+        this.debuggees.set(tabId, debuggee);
+        this.ensureListeners();
         try {
             await this.runDebuggerAction((done) => {
-                chrome.debugger.attach(this.debuggee, "1.3", done);
+                chrome.debugger.attach(debuggee, "1.3", done);
             });
-            chrome.debugger.onEvent.addListener(this.handleEventBound);
-            chrome.debugger.onDetach.addListener(this.handleDetachBound);
+            await this.ensureFlatSessionSupport(debuggee);
+            const targetInfo = await this.registerRootTab(tabId);
+            if (this.discoverTargets) {
+                this.emitTargetCreated(targetInfo);
+            }
+            if (this.autoAttachOptions.autoAttach) {
+                await this.applyAutoAttach(debuggee);
+                this.emitRootAttached(targetInfo);
+            }
+            this.updatePrimaryTab(tabId);
         }
         catch (error) {
-            this.debuggee = null;
+            this.debuggees.delete(tabId);
+            if (this.debuggees.size === 0) {
+                this.removeListeners();
+            }
+            await this.safeDetach(debuggee);
+            if (allowRetry && this.isStaleTabError(error)) {
+                const attemptedTabIds = new Set([tabId]);
+                let lastStaleError = error;
+                const activeTabId = await this.tabManager.getActiveTabId();
+                if (activeTabId && !attemptedTabIds.has(activeTabId)) {
+                    attemptedTabIds.add(activeTabId);
+                    try {
+                        return await this.attachInternal(activeTabId, false);
+                    }
+                    catch (candidateError) {
+                        if (!this.isStaleTabError(candidateError)) {
+                            throw candidateError;
+                        }
+                        lastStaleError = candidateError;
+                    }
+                }
+                const fallbackTabId = await this.tabManager.getFirstHttpTabId();
+                if (fallbackTabId && !attemptedTabIds.has(fallbackTabId)) {
+                    attemptedTabIds.add(fallbackTabId);
+                    try {
+                        return await this.attachInternal(fallbackTabId, false);
+                    }
+                    catch (candidateError) {
+                        if (!this.isStaleTabError(candidateError)) {
+                            throw candidateError;
+                        }
+                        lastStaleError = candidateError;
+                    }
+                }
+                try {
+                    const createdTab = await this.tabManager.createTab("about:blank", true);
+                    if (typeof createdTab.id === "number" && !attemptedTabIds.has(createdTab.id)) {
+                        return await this.attachInternal(createdTab.id, false);
+                    }
+                }
+                catch (candidateError) {
+                    if (!this.isStaleTabError(candidateError)) {
+                        throw candidateError;
+                    }
+                    lastStaleError = candidateError;
+                }
+                throw lastStaleError;
+            }
             throw error;
         }
     }
-    async detach() {
-        if (!this.debuggee)
+    async detachAll() {
+        const entries = Array.from(this.debuggees.entries());
+        this.debuggees.clear();
+        this.removeListeners();
+        for (const [tabId, debuggee] of entries) {
+            this.detachTabState(tabId);
+            await this.safeDetach(debuggee);
+        }
+        this.primaryTabId = null;
+        this.lastActiveTabId = null;
+        this.callbacks?.onDetach({ reason: "manual_disconnect" });
+    }
+    async detachTab(tabId) {
+        const debuggee = this.debuggees.get(tabId);
+        if (!debuggee) {
             return;
-        const current = this.debuggee;
-        this.debuggee = null;
-        chrome.debugger.onEvent.removeListener(this.handleEventBound);
-        chrome.debugger.onDetach.removeListener(this.handleDetachBound);
-        await this.runDebuggerAction((done) => {
-            chrome.debugger.detach(current, done);
-        });
+        }
+        this.debuggees.delete(tabId);
+        this.detachTabState(tabId);
+        await this.safeDetach(debuggee);
+        if (this.debuggees.size === 0) {
+            this.removeListeners();
+            this.primaryTabId = null;
+            this.lastActiveTabId = null;
+        }
+        else if (this.primaryTabId === tabId) {
+            this.updatePrimaryTab(this.selectFallbackPrimary());
+        }
+        this.callbacks?.onDetach({ tabId, reason: "manual_disconnect" });
     }
-    getAttachedTabId() {
-        return this.debuggee?.tabId ?? null;
+    getPrimaryTabId() {
+        return this.primaryTabId;
+    }
+    getAttachedTabIds() {
+        return Array.from(this.debuggees.keys());
     }
     async handleCommand(command) {
-        if (!this.debuggee || !this.callbacks) {
-            this.callbacks?.onResponse({ id: command.id, error: { message: "No tab attached" } });
+        if (!this.callbacks)
+            return;
+        if (this.debuggees.size === 0) {
+            this.respondError(command.id, "No tab attached");
             return;
         }
         const { method, params, sessionId } = command.params;
-        if (sessionId && method !== "Target.sendMessageToTarget") {
-            const message = JSON.stringify({ id: command.id, method, params });
-            try {
-                await this.sendCommand("Target.sendMessageToTarget", { sessionId, message });
+        const commandParams = isRecord(params) ? params : {};
+        const ctx = this.buildCommandContext();
+        switch (method) {
+            case "Browser.getVersion": {
+                const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "OpenDevBrowser Relay";
+                this.respond(command.id, {
+                    protocolVersion: "1.3",
+                    product: "Chrome",
+                    revision: "",
+                    userAgent,
+                    jsVersion: ""
+                });
+                return;
             }
-            catch (error) {
-                this.callbacks.onResponse({ id: command.id, error: { message: getErrorMessage(error) } });
+            case "Browser.setDownloadBehavior":
+                this.respond(command.id, {});
+                return;
+            case "Target.getBrowserContexts":
+                this.respond(command.id, { browserContextIds: [DEFAULT_BROWSER_CONTEXT_ID] });
+                return;
+            case "Target.attachToBrowserTarget": {
+                const rootSession = await this.ensureRootSessionForPrimary();
+                if (!rootSession) {
+                    this.respondError(command.id, "No tab attached");
+                    return;
+                }
+                this.respond(command.id, { sessionId: rootSession.sessionId });
+                return;
+            }
+            case "Target.sendMessageToTarget":
+                this.respondError(command.id, DEPRECATED_SEND_MESSAGE);
+                return;
+            case "Target.setDiscoverTargets":
+                await handleSetDiscoverTargets(ctx, command.id, commandParams);
+                return;
+            case "Target.getTargets":
+                this.respond(command.id, { targetInfos: this.sessions.listTargetInfos() });
+                return;
+            case "Target.getTargetInfo": {
+                const targetId = typeof commandParams.targetId === "string" ? commandParams.targetId : "";
+                const record = targetId ? this.sessions.getByTargetId(targetId) : null;
+                const targetInfo = record?.targetInfo
+                    ?? (record?.kind === "root" ? this.sessions.getByTabId(record.tabId)?.targetInfo ?? null : null);
+                this.respond(command.id, { targetInfo });
+                return;
             }
+            case "Target.setAutoAttach":
+                await handleSetAutoAttach(ctx, command.id, commandParams, sessionId);
+                return;
+            case "Target.createTarget":
+                await handleCreateTarget(ctx, command.id, commandParams);
+                return;
+            case "Target.closeTarget":
+                await handleCloseTarget(ctx, command.id, commandParams);
+                return;
+            case "Target.activateTarget":
+                await handleActivateTarget(ctx, command.id, commandParams);
+                return;
+            case "Target.attachToTarget":
+                await handleAttachToTarget(ctx, command.id, commandParams, sessionId);
+                return;
+            default:
+                await handleRoutedCommand(ctx, command.id, method, commandParams, sessionId);
+        }
+    }
+    buildCommandContext() {
+        return {
+            debuggees: this.debuggees,
+            sessions: this.sessions,
+            tabManager: this.tabManager,
+            autoAttachOptions: this.autoAttachOptions,
+            discoverTargets: this.discoverTargets,
+            flatSessionError: FLAT_SESSION_ERROR,
+            setAutoAttachOptions: (next) => {
+                this.autoAttachOptions = next;
+            },
+            setDiscoverTargets: (value) => {
+                this.discoverTargets = value;
+            },
+            respond: this.respond.bind(this),
+            respondError: this.respondError.bind(this),
+            emitTargetCreated: this.emitTargetCreated.bind(this),
+            emitRootAttached: this.emitRootAttached.bind(this),
+            emitRootDetached: this.emitRootDetached.bind(this),
+            resetRootAttached: this.resetRootAttached.bind(this),
+            updatePrimaryTab: this.updatePrimaryTab.bind(this),
+            detachTabState: this.detachTabState.bind(this),
+            safeDetach: this.safeDetach.bind(this),
+            attach: this.attach.bind(this),
+            registerRootTab: this.registerRootTab.bind(this),
+            applyAutoAttach: this.applyAutoAttach.bind(this),
+            sendCommand: this.sendCommand.bind(this),
+            getPrimaryDebuggee: this.getPrimaryDebuggee.bind(this)
+        };
+    }
+    async registerRootTab(tabId) {
+        const existing = this.sessions.getByTabId(tabId);
+        const sessionId = existing?.rootSessionId ?? this.createRootSessionId();
+        const targetInfo = await this.buildTargetInfo(tabId);
+        this.sessions.registerRootTab(tabId, targetInfo, sessionId);
+        return targetInfo;
+    }
+    updatePrimaryTab(tabId) {
+        if (tabId === this.primaryTabId)
+            return;
+        this.primaryTabId = tabId;
+        if (tabId !== null) {
+            this.lastActiveTabId = tabId;
+        }
+        this.callbacks?.onPrimaryTabChange?.(tabId);
+    }
+    selectFallbackPrimary() {
+        if (this.lastActiveTabId && this.debuggees.has(this.lastActiveTabId)) {
+            return this.lastActiveTabId;
+        }
+        const [first] = this.debuggees.keys();
+        return first ?? null;
+    }
+    getPrimaryDebuggee() {
+        if (this.primaryTabId !== null && this.debuggees.has(this.primaryTabId)) {
+            return { tabId: this.primaryTabId };
+        }
+        const [first] = this.debuggees.keys();
+        return typeof first === "number" ? { tabId: first } : null;
+    }
+    async ensureRootSessionForPrimary() {
+        const debuggee = this.getPrimaryDebuggee();
+        if (!debuggee || typeof debuggee.tabId !== "number") {
+            return null;
+        }
+        const existing = this.sessions.getByTabId(debuggee.tabId);
+        if (existing) {
+            return { sessionId: existing.rootSessionId, targetInfo: existing.targetInfo };
+        }
+        const targetInfo = await this.registerRootTab(debuggee.tabId);
+        const refreshed = this.sessions.getByTabId(debuggee.tabId);
+        if (!refreshed) {
+            return null;
+        }
+        return { sessionId: refreshed.rootSessionId, targetInfo: targetInfo ?? refreshed.targetInfo };
+    }
+    ensureListeners() {
+        if (this.listenersActive)
+            return;
+        chrome.debugger.onEvent.addListener(this.handleEventBound);
+        chrome.debugger.onDetach.addListener(this.handleDetachBound);
+        this.listenersActive = true;
+    }
+    removeListeners() {
+        if (!this.listenersActive)
+            return;
+        chrome.debugger.onEvent.removeListener(this.handleEventBound);
+        chrome.debugger.onDetach.removeListener(this.handleDetachBound);
+        this.listenersActive = false;
+    }
+    async ensureFlatSessionSupport(debuggee) {
+        if (this.flatSessionValidated)
             return;
+        try {
+            await this.sendCommand(debuggee, "Target.setAutoAttach", {
+                autoAttach: false,
+                waitForDebuggerOnStart: false,
+                flatten: true
+            });
+            this.flatSessionValidated = true;
+        }
+        catch (error) {
+            const detail = getErrorMessage(error);
+            console.warn(`[opendevbrowser] Target.setAutoAttach(flatten) failed: ${detail}`);
+            throw new Error(`${FLAT_SESSION_ERROR} (${detail})`);
+        }
+    }
+    async applyAutoAttach(debuggee) {
+        const params = {
+            autoAttach: this.autoAttachOptions.autoAttach,
+            waitForDebuggerOnStart: this.autoAttachOptions.waitForDebuggerOnStart,
+            flatten: true
+        };
+        if (typeof this.autoAttachOptions.filter !== "undefined") {
+            params.filter = this.autoAttachOptions.filter;
         }
         try {
-            const result = await this.sendCommand(method, params ?? {});
-            this.callbacks.onResponse({ id: command.id, result });
+            await this.sendCommand(debuggee, "Target.setAutoAttach", params);
         }
         catch (error) {
-            this.callbacks.onResponse({ id: command.id, error: { message: getErrorMessage(error) } });
+            const detail = getErrorMessage(error);
+            console.warn(`[opendevbrowser] Target.setAutoAttach failed: ${detail}`);
+            throw new Error(`${FLAT_SESSION_ERROR} (${detail})`);
         }
     }
-    async sendCommand(method, params) {
-        if (!this.debuggee) {
-            throw new Error("No tab attached");
+    async applyAutoAttachToChild(tabId, sessionId) {
+        if (!this.autoAttachOptions.autoAttach)
+            return;
+        const params = {
+            autoAttach: true,
+            waitForDebuggerOnStart: this.autoAttachOptions.waitForDebuggerOnStart,
+            flatten: true
+        };
+        if (typeof this.autoAttachOptions.filter !== "undefined") {
+            params.filter = this.autoAttachOptions.filter;
         }
-        return new Promise((resolve, reject) => {
-            chrome.debugger.sendCommand(this.debuggee, method, params, (result) => {
+        await this.sendCommand({ tabId, sessionId }, "Target.setAutoAttach", params);
+    }
+    recordSessionChurn(tabId, sessionId, reason) {
+        const now = Date.now();
+        const existing = this.churnTracker.get(tabId);
+        const record = !existing || now > existing.resetAt
+            ? { count: 0, resetAt: now + this.churnWindowMs }
+            : existing;
+        record.count += 1;
+        this.churnTracker.set(tabId, record);
+        const quarantined = this.quarantinedSessions.get(sessionId);
+        if (!quarantined) {
+            this.quarantinedSessions.set(sessionId, { tabId, count: 1, lastSeen: now });
+        }
+        if (record.count >= this.churnThreshold) {
+            this.churnTracker.delete(tabId);
+            this.reapplyAutoAttach(tabId, reason).catch((error) => {
+                logError("cdp.reapply_auto_attach", error, { code: "auto_attach_failed" });
+            });
+        }
+    }
+    quarantineUnknownSession(tabId, sessionId, method) {
+        const now = Date.now();
+        const existing = this.quarantinedSessions.get(sessionId);
+        if (existing) {
+            existing.count += 1;
+            existing.lastSeen = now;
+            return;
+        }
+        this.quarantinedSessions.set(sessionId, { tabId, count: 1, lastSeen: now });
+        this.recordSessionChurn(tabId, sessionId, `unknown_${method}`);
+    }
+    async reapplyAutoAttach(tabId, reason) {
+        if (!this.autoAttachOptions.autoAttach)
+            return;
+        const debuggee = this.debuggees.get(tabId);
+        if (!debuggee)
+            return;
+        try {
+            await this.applyAutoAttach(debuggee);
+        }
+        catch (error) {
+            const detail = getErrorMessage(error);
+            console.warn(`[opendevbrowser] Auto-attach retry failed (${reason}): ${detail}`);
+        }
+    }
+    handleEvent(source, method, params) {
+        if (!this.callbacks)
+            return;
+        const tabId = typeof source.tabId === "number" ? source.tabId : null;
+        if (tabId === null || !this.debuggees.has(tabId))
+            return;
+        if (method === "Target.receivedMessageFromTarget")
+            return;
+        if (method === "Target.attachedToTarget" && params && isRecord(params)) {
+            const sessionId = typeof params.sessionId === "string" ? params.sessionId : null;
+            const targetInfo = isTargetInfo(params.targetInfo) ? params.targetInfo : null;
+            if (sessionId && targetInfo) {
+                this.sessions.registerChildSession(tabId, targetInfo, sessionId);
+                this.quarantinedSessions.delete(sessionId);
+                this.applyAutoAttachToChild(tabId, sessionId).catch((error) => {
+                    logError("cdp.apply_auto_attach_child", error, { code: "auto_attach_failed" });
+                });
+            }
+            else if (sessionId) {
+                this.recordSessionChurn(tabId, sessionId, "attach_missing_target");
+            }
+        }
+        if (method === "Target.detachedFromTarget" && params && isRecord(params)) {
+            const detachedSessionId = typeof params.sessionId === "string" ? params.sessionId : null;
+            if (detachedSessionId) {
+                const removed = this.sessions.removeBySessionId(detachedSessionId);
+                if (!removed) {
+                    this.recordSessionChurn(tabId, detachedSessionId, "detach_unknown");
+                    this.quarantineUnknownSession(tabId, detachedSessionId, method);
+                    return;
+                }
+            }
+        }
+        const sourceSessionId = source.sessionId;
+        if (typeof sourceSessionId === "string" && !this.sessions.hasSession(sourceSessionId)) {
+            this.quarantineUnknownSession(tabId, sourceSessionId, method);
+            return;
+        }
+        const forwardSessionId = this.resolveForwardSessionId(method, source);
+        this.emitEvent(method, params, forwardSessionId);
+    }
+    handleDetach(source, reason) {
+        const tabId = typeof source.tabId === "number" ? source.tabId : null;
+        if (tabId === null || !this.debuggees.has(tabId))
+            return;
+        this.debuggees.delete(tabId);
+        this.detachTabState(tabId);
+        if (this.debuggees.size === 0) {
+            this.removeListeners();
+            this.callbacks?.onDetach({ tabId, reason });
+        }
+    }
+    detachTabState(tabId) {
+        const record = this.sessions.removeByTabId(tabId);
+        if (record) {
+            this.rootAttachedSessions.delete(record.rootSessionId);
+            if (this.autoAttachOptions.autoAttach) {
+                this.emitTargetDetached(record.rootSessionId, record.targetInfo.targetId);
+            }
+            if (this.discoverTargets) {
+                this.emitTargetDestroyed(record.targetInfo.targetId);
+            }
+        }
+        if (tabId === this.primaryTabId) {
+            const next = this.selectFallbackPrimary();
+            this.updatePrimaryTab(next);
+        }
+    }
+    resolveForwardSessionId(method, source) {
+        if (method === "Target.attachedToTarget" || method === "Target.detachedFromTarget") {
+            return undefined;
+        }
+        const sessionId = source.sessionId;
+        if (typeof sessionId === "string") {
+            return this.sessions.getBySessionId(sessionId) ? sessionId : undefined;
+        }
+        const tabId = typeof source.tabId === "number" ? source.tabId : null;
+        if (tabId === null)
+            return undefined;
+        const record = this.sessions.getByTabId(tabId);
+        if (!record)
+            return undefined;
+        return this.rootAttachedSessions.has(record.rootSessionId) ? record.rootSessionId : undefined;
+    }
+    async buildTargetInfo(tabId) {
+        const tab = await this.tabManager.getTab(tabId);
+        return {
+            targetId: `tab-${tabId}`,
+            type: "page",
+            browserContextId: DEFAULT_BROWSER_CONTEXT_ID,
+            title: tab?.title ?? undefined,
+            url: tab?.url ?? undefined
+        };
+    }
+    emitTargetCreated(targetInfo) {
+        this.emitEvent("Target.targetCreated", { targetInfo });
+    }
+    emitTargetDestroyed(targetId) {
+        this.emitEvent("Target.targetDestroyed", { targetId });
+    }
+    emitTargetDetached(sessionId, targetId) {
+        this.emitEvent("Target.detachedFromTarget", { sessionId, targetId });
+    }
+    emitRootAttached(targetInfo) {
+        const record = this.sessions.getByTargetId(targetInfo.targetId);
+        if (!record || record.kind !== "root")
+            return;
+        if (this.rootAttachedSessions.has(record.sessionId))
+            return;
+        this.rootAttachedSessions.add(record.sessionId);
+        this.emitEvent("Target.attachedToTarget", {
+            sessionId: record.sessionId,
+            targetInfo,
+            waitingForDebugger: false
+        });
+    }
+    emitRootDetached() {
+        for (const targetInfo of this.sessions.listTargetInfos()) {
+            const record = this.sessions.getByTargetId(targetInfo.targetId);
+            if (!record || record.kind !== "root")
+                continue;
+            if (!this.rootAttachedSessions.has(record.sessionId))
+                continue;
+            this.rootAttachedSessions.delete(record.sessionId);
+            this.emitTargetDetached(record.sessionId, targetInfo.targetId);
+        }
+    }
+    resetRootAttached() {
+        this.rootAttachedSessions.clear();
+    }
+    createRootSessionId() {
+        const sessionId = `pw-tab-${this.sessionCounter}`;
+        this.sessionCounter += 1;
+        return sessionId;
+    }
+    async sendCommand(debuggee, method, params) {
+        try {
+            return await this.sendCommandOnce(debuggee, method, params);
+        }
+        catch (error) {
+            const hasChildSession = typeof debuggee.sessionId === "string";
+            if (!this.isStaleTabError(error) || hasChildSession) {
+                throw error;
+            }
+            const recovered = await this.recoverFromStaleTab(debuggee);
+            if (!recovered) {
+                throw error;
+            }
+            return await this.sendCommandOnce(recovered, method, params);
+        }
+    }
+    async sendCommandOnce(debuggee, method, params) {
+        return await new Promise((resolve, reject) => {
+            chrome.debugger.sendCommand(debuggee, method, params, (result) => {
                 const lastError = chrome.runtime.lastError;
                 if (lastError) {
                     reject(new Error(lastError.message));
@@ -83,6 +563,26 @@ export class CDPRouter {
             });
         });
     }
+    async recoverFromStaleTab(debuggee) {
+        const staleTabId = typeof debuggee.tabId === "number" ? debuggee.tabId : null;
+        if (staleTabId === null) {
+            return null;
+        }
+        this.debuggees.delete(staleTabId);
+        this.detachTabState(staleTabId);
+        await this.safeDetach({ tabId: staleTabId });
+        try {
+            await this.attachInternal(staleTabId, true);
+        }
+        catch {
+            return null;
+        }
+        return this.getPrimaryDebuggee();
+    }
+    isStaleTabError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return message.includes("No tab with given id");
+    }
     async runDebuggerAction(action) {
         return new Promise((resolve, reject) => {
             action(() => {
@@ -95,68 +595,38 @@ export class CDPRouter {
             });
         });
     }
-    handleEvent(source, method, params) {
-        if (!this.matchesDebuggee(source) || !this.callbacks) {
-            return;
-        }
-        if (method === "Target.receivedMessageFromTarget" && params && isRecord(params)) {
-            const nested = parseNestedMessage(params.message);
-            const sessionId = typeof params.sessionId === "string" ? params.sessionId : undefined;
-            if (nested && (typeof nested.id === "string" || typeof nested.id === "number")) {
-                const error = normalizeError(nested.error);
-                this.callbacks.onResponse({
-                    id: nested.id,
-                    result: nested.result,
-                    error,
-                    sessionId
-                });
-                return;
-            }
-            if (nested && typeof nested.method === "string") {
-                this.callbacks.onEvent({
-                    method: "forwardCDPEvent",
-                    params: {
-                        method: nested.method,
-                        params: nested.params,
-                        sessionId
-                    }
-                });
-                return;
-            }
+    async safeDetach(debuggee) {
+        try {
+            await this.runDebuggerAction((done) => {
+                chrome.debugger.detach(debuggee, done);
+            });
         }
-        this.callbacks.onEvent({
-            method: "forwardCDPEvent",
-            params: {
-                method,
-                params
-            }
-        });
-    }
-    handleDetach(source) {
-        if (!this.matchesDebuggee(source) || !this.callbacks) {
-            return;
+        catch (error) {
+            logError("cdp.safe_detach", error, { code: "detach_failed" });
         }
-        this.callbacks.onDetach();
     }
-    matchesDebuggee(source) {
-        if (!this.debuggee)
-            return false;
-        return source.tabId === this.debuggee.tabId;
+    respond(id, result, sessionId) {
+        if (!this.callbacks)
+            return;
+        this.callbacks.onResponse({ id, result, ...(sessionId ? { sessionId } : {}) });
     }
-}
-const parseNestedMessage = (value) => {
-    if (typeof value !== "string")
-        return null;
-    try {
-        const parsed = JSON.parse(value);
-        return parsed;
+    respondError(id, message, sessionId) {
+        if (!this.callbacks)
+            return;
+        this.callbacks.onResponse({ id, error: { message }, ...(sessionId ? { sessionId } : {}) });
     }
-    catch {
-        return null;
+    emitEvent(method, params, sessionId) {
+        if (!this.callbacks)
+            return;
+        const payload = { method, params };
+        if (sessionId) {
+            payload.sessionId = sessionId;
+        }
+        this.callbacks.onEvent({ method: "forwardCDPEvent", params: payload });
     }
-};
-const isRecord = (value) => {
-    return typeof value === "object" && value !== null;
+}
+const isTargetInfo = (value) => {
+    return isRecord(value) && typeof value.targetId === "string" && typeof value.type === "string";
 };
 const getErrorMessage = (error) => {
     if (error instanceof Error) {
@@ -164,13 +634,6 @@ const getErrorMessage = (error) => {
     }
     return "Unknown error";
 };
-const normalizeError = (value) => {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const message = value.message;
-    if (typeof message !== "string") {
-        return undefined;
-    }
-    return { message };
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null;
 };