@vforsh/argus 0.1.19 → 0.1.20

package/dist/extension/dist/background/cdp-proxy.js

@@ -0,0 +1,201 @@
+/**
+ * CDP Proxy - Routes CDP commands and events between the Native Messaging
+ * host (argus-watcher in extension mode) and the chrome.debugger API.
+ */
+export class CdpProxy {
+    debuggerManager;
+    bridgeClient;
+    constructor(debuggerManager, bridgeClient) {
+        this.debuggerManager = debuggerManager;
+        this.bridgeClient = bridgeClient;
+        this.setupEventForwarding();
+        this.setupMessageHandling();
+    }
+    /**
+     * Forward CDP events from debugger to bridge.
+     */
+    setupEventForwarding() {
+        this.debuggerManager.onEvent((tabId, method, params, meta) => {
+            this.bridgeClient.send({
+                type: 'cdp_event',
+                tabId,
+                method,
+                params,
+                sessionId: meta?.sessionId ?? undefined,
+            });
+        });
+        this.debuggerManager.onDetach((tabId, reason) => {
+            this.bridgeClient.send({
+                type: 'tab_detached',
+                tabId,
+                reason,
+            });
+        });
+    }
+    /**
+     * Handle messages from the bridge.
+     */
+    setupMessageHandling() {
+        this.bridgeClient.onMessage((message) => {
+            this.handleMessage(message);
+        });
+    }
+    /**
+     * Process a message from the bridge.
+     */
+    async handleMessage(message) {
+        switch (message.type) {
+            case 'attach_tab':
+                await this.handleAttachTab(message);
+                break;
+            case 'detach_tab':
+                await this.handleDetachTab(message);
+                break;
+            case 'cdp_command':
+                await this.handleCdpCommand(message);
+                break;
+            case 'list_tabs':
+                await this.handleListTabs(message);
+                break;
+            case 'enable_domain':
+                await this.handleEnableDomain(message);
+                break;
+            case 'host_info':
+            case 'target_info':
+                break;
+            default:
+                console.warn('[CdpProxy] Unknown message type:', message.type);
+        }
+    }
+    /**
+     * Attach to a tab.
+     */
+    async handleAttachTab(message) {
+        try {
+            const target = await this.debuggerManager.attach(message.tabId);
+            this.bridgeClient.send({
+                type: 'tab_attached',
+                tabId: target.tabId,
+                url: target.url,
+                title: target.title,
+                faviconUrl: target.faviconUrl,
+                topFrameId: target.topFrameId,
+                frames: this.debuggerManager.getFrames(target.tabId),
+            });
+        }
+        catch (err) {
+            console.error('[CdpProxy] Failed to attach:', err);
+            this.bridgeClient.send({
+                type: 'tab_detached',
+                tabId: message.tabId,
+                reason: err instanceof Error ? err.message : 'attach_failed',
+            });
+        }
+    }
+    /**
+     * Detach from a tab.
+     */
+    async handleDetachTab(message) {
+        await this.debuggerManager.detach(message.tabId);
+    }
+    /**
+     * Execute a CDP command.
+     */
+    async handleCdpCommand(message) {
+        try {
+            const result = await this.debuggerManager.sendCommand(message.tabId, message.method, message.params, message.sessionId);
+            this.bridgeClient.send({
+                type: 'cdp_response',
+                requestId: message.requestId,
+                result,
+            });
+        }
+        catch (err) {
+            this.bridgeClient.send({
+                type: 'cdp_response',
+                requestId: message.requestId,
+                error: {
+                    message: err instanceof Error ? err.message : 'Unknown error',
+                },
+            });
+        }
+    }
+    /**
+     * List available tabs.
+     */
+    async handleListTabs(message) {
+        const chromeTabs = await chrome.tabs.query({});
+        const attachedTargets = this.debuggerManager.listAttached();
+        const attachedTabIds = new Set(attachedTargets.map((t) => t.tabId));
+        let tabs = chromeTabs
+            .filter((tab) => tab.id !== undefined && tab.url !== undefined)
+            .map((tab) => ({
+            tabId: tab.id,
+            url: tab.url,
+            title: tab.title ?? '',
+            faviconUrl: tab.favIconUrl,
+            attached: attachedTabIds.has(tab.id),
+        }));
+        // Apply filters if provided
+        if (message.filter) {
+            if (message.filter.url) {
+                const urlFilter = message.filter.url.toLowerCase();
+                tabs = tabs.filter((t) => t.url.toLowerCase().includes(urlFilter));
+            }
+            if (message.filter.title) {
+                const titleFilter = message.filter.title.toLowerCase();
+                tabs = tabs.filter((t) => t.title.toLowerCase().includes(titleFilter));
+            }
+        }
+        this.bridgeClient.send({
+            type: 'list_tabs_response',
+            tabs,
+        });
+    }
+    /**
+     * Enable a CDP domain for a tab.
+     */
+    async handleEnableDomain(message) {
+        try {
+            await this.debuggerManager.enableDomain(message.tabId, message.domain);
+        }
+        catch (err) {
+            console.error('[CdpProxy] Failed to enable domain:', err);
+        }
+    }
+    /**
+     * Manually attach to a tab (called from popup).
+     */
+    async attachTab(tabId) {
+        await this.handleAttachTab({ type: 'attach_tab', tabId });
+    }
+    /**
+     * Manually detach from a tab (called from popup).
+     */
+    async detachTab(tabId) {
+        await this.debuggerManager.detach(tabId);
+        this.bridgeClient.send({
+            type: 'tab_detached',
+            tabId,
+            reason: 'user_requested',
+        });
+    }
+    /**
+     * Get list of tabs for popup UI.
+     */
+    async getTabsForPopup() {
+        const chromeTabs = await chrome.tabs.query({});
+        const attachedTargets = this.debuggerManager.listAttached();
+        const attachedTabIds = new Set(attachedTargets.map((t) => t.tabId));
+        return chromeTabs
+            .filter((tab) => tab.id !== undefined && tab.url !== undefined)
+            .filter((tab) => !tab.url.startsWith('chrome://') && !tab.url.startsWith('chrome-extension://'))
+            .map((tab) => ({
+            tabId: tab.id,
+            url: tab.url,
+            title: tab.title ?? '',
+            faviconUrl: tab.favIconUrl,
+            attached: attachedTabIds.has(tab.id),
+        }));
+    }
+}

package/dist/extension/dist/background/debugger-manager.js

@@ -0,0 +1,296 @@
+/**
+ * Manages chrome.debugger attachment lifecycle.
+ * Handles root tab attachment, recursive child-target auto-attach, frame discovery,
+ * and session-aware CDP command routing.
+ */
+export class DebuggerManager {
+    attached = new Map();
+    globalEventHandler = null;
+    detachHandler = null;
+    constructor() {
+        chrome.debugger.onEvent.addListener((debuggee, method, params) => {
+            this.handleCdpEvent(debuggee, method, params);
+        });
+        chrome.debugger.onDetach.addListener((debuggee, reason) => {
+            if (debuggee.tabId) {
+                this.handleDetach(debuggee.tabId, debuggee.sessionId ?? null, reason);
+            }
+        });
+    }
+    onEvent(handler) {
+        this.globalEventHandler = handler;
+    }
+    onDetach(handler) {
+        this.detachHandler = handler;
+    }
+    async attach(tabId) {
+        if (this.attached.has(tabId)) {
+            return this.attached.get(tabId);
+        }
+        const debuggee = { tabId };
+        await chrome.debugger.attach(debuggee, '1.3');
+        const tab = await chrome.tabs.get(tabId);
+        const target = {
+            tabId,
+            debuggeeId: debuggee,
+            url: tab.url ?? '',
+            title: tab.title ?? '',
+            faviconUrl: tab.favIconUrl,
+            attachedAt: Date.now(),
+            enabledDomains: new Set(),
+            childSessions: new Map(),
+            frames: new Map(),
+            topFrameId: null,
+        };
+        this.attached.set(tabId, target);
+        await this.configureAutoAttach(tabId);
+        await this.refreshFrameTree(tabId, null);
+        return target;
+    }
+    async detach(tabId) {
+        const target = this.attached.get(tabId);
+        if (!target)
+            return;
+        try {
+            await chrome.debugger.detach(target.debuggeeId);
+        }
+        catch {
+            // Tab may already be closed
+        }
+        this.attached.delete(tabId);
+    }
+    async sendCommand(tabId, method, params, sessionId) {
+        const target = this.getRequiredTarget(tabId);
+        const debuggee = this.toDebuggee(target, sessionId);
+        const result = await chrome.debugger.sendCommand(debuggee, method, params);
+        return result;
+    }
+    async enableDomain(tabId, domain, sessionId) {
+        const enabledDomains = this.getRequiredEnabledDomains(tabId, sessionId);
+        if (enabledDomains.has(domain)) {
+            return;
+        }
+        await this.sendCommand(tabId, `${domain}.enable`, undefined, sessionId);
+        enabledDomains.add(domain);
+    }
+    isAttached(tabId) {
+        return this.attached.has(tabId);
+    }
+    listAttached() {
+        return [...this.attached.values()];
+    }
+    getTarget(tabId) {
+        return this.attached.get(tabId);
+    }
+    getFrames(tabId) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return [];
+        }
+        return [...target.frames.values()];
+    }
+    async configureAutoAttach(tabId, sessionId) {
+        await this.sendCommand(tabId, 'Target.setAutoAttach', {
+            autoAttach: true,
+            waitForDebuggerOnStart: false,
+            flatten: true,
+            filter: [{ type: 'iframe', exclude: false }],
+        }, sessionId);
+    }
+    getEnabledDomains(tabId, sessionId) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return null;
+        }
+        if (!sessionId) {
+            return target.enabledDomains;
+        }
+        return target.childSessions.get(sessionId)?.enabledDomains ?? null;
+    }
+    getRequiredTarget(tabId) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            throw new Error(`Tab ${tabId} is not attached`);
+        }
+        return target;
+    }
+    getRequiredEnabledDomains(tabId, sessionId) {
+        const enabledDomains = this.getEnabledDomains(tabId, sessionId);
+        if (!enabledDomains) {
+            throw new Error(`Tab ${tabId} is not attached`);
+        }
+        return enabledDomains;
+    }
+    toDebuggee(target, sessionId) {
+        if (!sessionId) {
+            return target.debuggeeId;
+        }
+        return { tabId: target.tabId, sessionId };
+    }
+    handleCdpEvent(debuggee, method, params) {
+        const tabId = debuggee.tabId;
+        if (!tabId || !this.attached.has(tabId))
+            return;
+        const sessionId = debuggee.sessionId ?? null;
+        if (method === 'Target.attachedToTarget' && params) {
+            void this.handleAttachedToTarget(tabId, params);
+            return;
+        }
+        if (method === 'Target.detachedFromTarget' && params) {
+            this.handleDetachedFromTarget(tabId, params);
+            return;
+        }
+        this.updateStateFromEvent(tabId, sessionId, method, params);
+        if (this.globalEventHandler) {
+            this.globalEventHandler(tabId, method, params ?? {}, { sessionId });
+        }
+    }
+    async handleAttachedToTarget(tabId, params) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return;
+        }
+        const record = params;
+        if (!record.sessionId) {
+            return;
+        }
+        target.childSessions.set(record.sessionId, {
+            sessionId: record.sessionId,
+            targetId: record.targetInfo?.targetId ?? record.sessionId,
+            type: record.targetInfo?.type ?? 'unknown',
+            url: record.targetInfo?.url ?? '',
+            title: record.targetInfo?.title ?? '',
+            attachedAt: Date.now(),
+            enabledDomains: new Set(),
+        });
+        try {
+            await this.configureAutoAttach(tabId, record.sessionId);
+            await this.enableChildSessionDomains(tabId, record.sessionId);
+            await this.refreshFrameTree(tabId, record.sessionId);
+        }
+        catch (error) {
+            console.warn('[DebuggerManager] Failed to bootstrap child target:', error);
+        }
+    }
+    async enableChildSessionDomains(tabId, sessionId) {
+        // Keep child sessions aligned with the root tab so watcher features can observe iframe traffic too.
+        for (const domain of ['Runtime', 'Page', 'Network']) {
+            await this.enableDomain(tabId, domain, sessionId);
+        }
+    }
+    handleDetachedFromTarget(tabId, params) {
+        const record = params;
+        if (!record.sessionId) {
+            return;
+        }
+        this.dropChildSession(tabId, record.sessionId);
+    }
+    async refreshFrameTree(tabId, sessionId) {
+        const frameTree = (await this.sendCommand(tabId, 'Page.getFrameTree', undefined, sessionId));
+        this.mergeFrameTree(tabId, sessionId, frameTree.frameTree);
+    }
+    mergeFrameTree(tabId, sessionId, node) {
+        if (!node?.frame?.id) {
+            return;
+        }
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return;
+        }
+        const frameId = node.frame.id;
+        target.frames.set(frameId, this.toFrameRecord(node.frame, sessionId));
+        if (!node.frame.parentId && !sessionId) {
+            target.topFrameId = frameId;
+        }
+        if (this.globalEventHandler) {
+            this.globalEventHandler(tabId, 'Page.frameNavigated', {
+                frame: {
+                    id: frameId,
+                    parentId: node.frame.parentId ?? null,
+                    url: node.frame.url ?? '',
+                    name: node.frame.name ?? null,
+                },
+            }, { sessionId });
+        }
+        for (const child of node.childFrames ?? []) {
+            this.mergeFrameTree(tabId, sessionId, child);
+        }
+    }
+    updateStateFromEvent(tabId, sessionId, method, params) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return;
+        }
+        if (method === 'Page.frameNavigated' && params) {
+            const frame = params.frame;
+            if (!frame?.id) {
+                return;
+            }
+            target.frames.set(frame.id, this.toFrameRecord(frame, sessionId));
+            if (!frame.parentId && !sessionId && frame.url) {
+                target.url = frame.url;
+                target.topFrameId = frame.id;
+            }
+            return;
+        }
+        if (method === 'Page.frameAttached' && params) {
+            const frame = params;
+            if (!frame.frameId) {
+                return;
+            }
+            const existing = target.frames.get(frame.frameId);
+            target.frames.set(frame.frameId, {
+                frameId: frame.frameId,
+                parentFrameId: frame.parentFrameId ?? target.topFrameId,
+                url: existing?.url ?? '',
+                title: existing?.title ?? null,
+                sessionId: existing?.sessionId ?? sessionId,
+            });
+            return;
+        }
+        if (method === 'Page.frameDetached' && params) {
+            const frame = params;
+            if (!frame.frameId) {
+                return;
+            }
+            target.frames.delete(frame.frameId);
+        }
+    }
+    toFrameRecord(frame, sessionId) {
+        return {
+            frameId: frame.id,
+            parentFrameId: frame.parentId ?? null,
+            url: frame.url ?? '',
+            title: frame.name ?? null,
+            sessionId,
+        };
+    }
+    handleDetach(tabId, sessionId, reason) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return;
+        }
+        if (sessionId) {
+            this.dropChildSession(tabId, sessionId);
+            return;
+        }
+        this.attached.delete(tabId);
+        if (this.detachHandler) {
+            this.detachHandler(tabId, reason);
+        }
+    }
+    dropChildSession(tabId, sessionId) {
+        const target = this.attached.get(tabId);
+        if (!target) {
+            return;
+        }
+        target.childSessions.delete(sessionId);
+        for (const [frameId, frame] of target.frames.entries()) {
+            if (frame.sessionId !== sessionId) {
+                continue;
+            }
+            target.frames.delete(frameId);
+            this.globalEventHandler?.(tabId, 'Page.frameDetached', { frameId }, { sessionId });
+        }
+    }
+}