@vforsh/argus 0.1.18 → 0.1.20

package/dist/extension/dist/background/auth-header-monitor.js

@@ -0,0 +1,77 @@
+const AUTH_HEADER_NAMES = new Set([
+    'authorization',
+    'cookie',
+    'x-api-key',
+    'x-auth-token',
+    'x-csrf-token',
+    'x-csrftoken',
+    'x-xsrf-token',
+    'csrf-token',
+    'xsrf-token',
+]);
+const WEB_REQUEST_FILTER = { urls: ['<all_urls>'] };
+const WEB_REQUEST_EXTRA_INFO = ['requestHeaders', 'extraHeaders'];
+/**
+ * Observe auth-related request headers for currently attached tabs.
+ * We keep the extension payload narrow so the native bridge never has to ship full request headers.
+ */
+export class AuthHeaderMonitor {
+    debuggerManager;
+    bridgeClient;
+    constructor(debuggerManager, bridgeClient) {
+        this.debuggerManager = debuggerManager;
+        this.bridgeClient = bridgeClient;
+        chrome.webRequest.onBeforeSendHeaders.addListener((details) => {
+            this.handleBeforeSendHeaders(details);
+        }, WEB_REQUEST_FILTER, WEB_REQUEST_EXTRA_INFO);
+    }
+    handleBeforeSendHeaders(details) {
+        const message = createObservedHeadersMessage(details, this.debuggerManager);
+        if (!message) {
+            return;
+        }
+        this.bridgeClient.send(message);
+    }
+}
+const createObservedHeadersMessage = (details, debuggerManager) => {
+    if (details.tabId < 0 || !debuggerManager.isAttached(details.tabId)) {
+        return null;
+    }
+    const requestHeaders = pickObservedAuthHeaders(details.requestHeaders);
+    if (!requestHeaders) {
+        return null;
+    }
+    return {
+        type: 'auth_headers_observed',
+        tabId: details.tabId,
+        url: details.url,
+        method: details.method,
+        ts: typeof details.timeStamp === 'number' ? details.timeStamp : Date.now(),
+        requestHeaders,
+    };
+};
+const pickObservedAuthHeaders = (headers) => {
+    if (!headers || headers.length === 0) {
+        return undefined;
+    }
+    const observed = {};
+    for (const header of headers) {
+        const name = header.name?.trim().toLowerCase();
+        if (!name || !AUTH_HEADER_NAMES.has(name)) {
+            continue;
+        }
+        const value = normalizeHeaderValue(header.value);
+        if (!value) {
+            continue;
+        }
+        observed[name] = value;
+    }
+    return Object.keys(observed).length > 0 ? observed : undefined;
+};
+const normalizeHeaderValue = (value) => {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+};

package/dist/extension/dist/background/bridge-client.js

@@ -0,0 +1,120 @@
+/**
+ * Native Messaging client for communicating with argus-watcher (extension mode).
+ * Handles connection lifecycle, message serialization, and reconnection.
+ */
+export class BridgeClient {
+    port = null;
+    hostName;
+    messageHandlers = new Set();
+    connectHandler = null;
+    disconnectHandler = null;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    reconnectDelay = 1000;
+    constructor(hostName = 'com.vforsh.argus.bridge') {
+        this.hostName = hostName;
+    }
+    /**
+     * Set handler for incoming messages from the host.
+     */
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+    }
+    /**
+     * Set handler for successful connection.
+     */
+    onConnect(handler) {
+        this.connectHandler = handler;
+    }
+    /**
+     * Set handler for disconnection.
+     */
+    onDisconnect(handler) {
+        this.disconnectHandler = handler;
+    }
+    /**
+     * Connect to the Native Messaging host.
+     */
+    connect() {
+        if (this.port) {
+            return true; // Already connected
+        }
+        try {
+            this.port = chrome.runtime.connectNative(this.hostName);
+            this.port.onMessage.addListener((message) => {
+                this.reconnectAttempts = 0; // Reset on successful message
+                for (const handler of this.messageHandlers) {
+                    handler(message);
+                }
+            });
+            this.port.onDisconnect.addListener(() => {
+                const error = chrome.runtime.lastError;
+                console.log('[BridgeClient] Disconnected:', error?.message ?? 'unknown reason');
+                this.port = null;
+                if (this.disconnectHandler) {
+                    this.disconnectHandler();
+                }
+                // Attempt reconnection
+                this.scheduleReconnect();
+            });
+            console.log('[BridgeClient] Connected to', this.hostName);
+            this.reconnectAttempts = 0;
+            if (this.connectHandler) {
+                this.connectHandler();
+            }
+            return true;
+        }
+        catch (err) {
+            console.error('[BridgeClient] Failed to connect:', err);
+            this.scheduleReconnect();
+            return false;
+        }
+    }
+    /**
+     * Disconnect from the Native Messaging host.
+     */
+    disconnect() {
+        if (this.port) {
+            this.port.disconnect();
+            this.port = null;
+        }
+    }
+    /**
+     * Send a message to the Native Messaging host.
+     */
+    send(message) {
+        if (!this.port) {
+            console.warn('[BridgeClient] Cannot send, not connected');
+            return false;
+        }
+        try {
+            this.port.postMessage(message);
+            return true;
+        }
+        catch (err) {
+            console.error('[BridgeClient] Send failed:', err);
+            return false;
+        }
+    }
+    /**
+     * Check if connected to the host.
+     */
+    isConnected() {
+        return this.port !== null;
+    }
+    /**
+     * Schedule a reconnection attempt with exponential backoff.
+     */
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.log('[BridgeClient] Max reconnection attempts reached');
+            return;
+        }
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+        this.reconnectAttempts++;
+        console.log(`[BridgeClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => {
+            this.connect();
+        }, delay);
+    }
+}

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 });
+        }
+    }
+}