Brave Real Browser MCP Server

import type { Page } from 'brave-real-puppeteer-core';
import { Logger } from './logger';

const log = new Logger();

/**
 * VIDEO AD BLOCKING
 * Blocks: VAST/VPAID ads, pre-roll, mid-roll, post-roll, video overlays
 */
export async function injectVideoAdBlocking(page: Page): Promise<void> {

    // ==========================================
    // 1. BLOCK VIDEO AD NETWORK REQUESTS
    // ==========================================
    const client = await page.target().createCDPSession();
    await client.send('Network.enable');
    
    // Block VAST/VPAID ad requests at network level
    await client.send('Network.setBlockedURLs', {
        urls: [
            // VAST/VPAID endpoints
            '*vast*', '*vpaid*', '*vmap*',
            '*imasdk.googleapis.com*',
            '*googleads.g.doubleclick.net*',
            '*pubads.g.doubleclick.net*',
            '*securepubads.g.doubleclick.net*',
            '*pagead2.googlesyndication.com*',
            
            // Video ad networks
            '*video.unrulymedia.com*',
            '*vid.springserve.com*',
            '*ads.adap.tv*',
            '*spotxchange.com/vast*',
            '*video.taboola.com*',
            '*outbrain.com/video*',
            '*teads.tv*',
            '*innovid.com*',
            
            // Pre-roll ad domains
            '*preroll*', '*midroll*', '*postroll*',
            '*videoads*', '*videoad*',
            
            // Common video ad patterns
            '*ad.doubleclick.net*',
            '*ad-score*', '*adscore*',
            '*adserver*video*',
            '*video*adserver*'
        ]
    });

    // ==========================================
    // 2. CDP SCRIPT INJECTION FOR VIDEO ADS
    // ==========================================
    await client.send('Page.enable');
    await client.send('Page.addScriptToEvaluateOnNewDocument', {
        source: `
(function() {
    'use strict';
    
    // ==========================================
    // VAST/VPAID BLOCKING
    // ==========================================
    const VAST_PATTERNS = [
        /vast/i, /vpaid/i, /vmap/i, /imasdk/i,
        /googima/i, /ima3/i, /dai\\.google/i,
        /adpod/i, /adbreak/i, /preroll/i, /midroll/i, /postroll/i
    ];
    
    const AD_VIDEO_DOMAINS = [
        'imasdk.googleapis.com',
        'googleads.g.doubleclick.net',
        'pubads.g.doubleclick.net',
        'securepubads.g.doubleclick.net',
        'pagead2.googlesyndication.com',
        'video.unrulymedia.com',
        'vid.springserve.com',
        'spotxchange.com',
        'teads.tv',
        'innovid.com'
    ];
    
    // ==========================================
    // BLOCK FETCH/XHR FOR VIDEO ADS
    // ==========================================
    const originalFetch = window.fetch;
    window.fetch = async function(resource, init) {
        const url = typeof resource === 'string' ? resource : resource.url || '';
        const urlLower = url.toLowerCase();
        
        // Block VAST/VPAID requests
        if (VAST_PATTERNS.some(p => p.test(urlLower)) ||
            AD_VIDEO_DOMAINS.some(d => urlLower.includes(d))) {
            console.log('[VideoAdBlocker] Blocked fetch:', urlLower.substring(0, 60));
            // Return empty VAST response
            return new Response('<?xml version="1.0"?><VAST version="3.0"></VAST>', {
                status: 200,
                headers: { 'Content-Type': 'application/xml' }
            });
        }
        
        return originalFetch.call(this, resource, init);
    };
    
    const originalXhrOpen = XMLHttpRequest.prototype.open;
    const originalXhrSend = XMLHttpRequest.prototype.send;
    
    XMLHttpRequest.prototype.open = function(method, url, ...args) {
        this._adBlockUrl = url;
        return originalXhrOpen.call(this, method, url, ...args);
    };
    
    XMLHttpRequest.prototype.send = function(body) {
        const url = String(this._adBlockUrl || '').toLowerCase();
        
        if (VAST_PATTERNS.some(p => p.test(url)) ||
            AD_VIDEO_DOMAINS.some(d => url.includes(d))) {
            console.log('[VideoAdBlocker] Blocked XHR:', url.substring(0, 60));
            
            // Fake successful empty response
            Object.defineProperty(this, 'readyState', { value: 4, writable: false });
            Object.defineProperty(this, 'status', { value: 200, writable: false });
            Object.defineProperty(this, 'responseText', { 
                value: '<?xml version="1.0"?><VAST version="3.0"></VAST>', 
                writable: false 
            });
            Object.defineProperty(this, 'response', { 
                value: '<?xml version="1.0"?><VAST version="3.0"></VAST>', 
                writable: false 
            });
            
            // Dispatch events
            setTimeout(() => {
                if (this.onreadystatechange) this.onreadystatechange();
                if (this.onload) this.onload();
            }, 10);
            return;
        }
        
        return originalXhrSend.call(this, body);
    };
    
    // ==========================================
    // IMA SDK BLOCKING (Google Video Ads)
    // ==========================================
    // Block Google IMA SDK
    Object.defineProperty(window, 'google', {
        get: function() {
            return new Proxy({}, {
                get: function(target, prop) {
                    if (prop === 'ima') {
                        console.log('[VideoAdBlocker] Blocked Google IMA SDK');
                        return {
                            AdDisplayContainer: function() {
                                return { initialize: function() {}, destroy: function() {} };
                            },
                            AdsLoader: function() {
                                return {
                                    addEventListener: function() {},
                                    removeEventListener: function() {},
                                    requestAds: function() {},
                                    contentComplete: function() {},
                                    destroy: function() {}
                                };
                            },
                            AdsManager: function() {
                                return {
                                    addEventListener: function() {},
                                    removeEventListener: function() {},
                                    init: function() {},
                                    start: function() {},
                                    pause: function() {},
                                    resume: function() {},
                                    stop: function() {},
                                    skip: function() {},
                                    destroy: function() {},
                                    getRemainingTime: function() { return 0; },
                                    setVolume: function() {}
                                };
                            },
                            AdsManagerLoadedEvent: { Type: { ADS_MANAGER_LOADED: 'adsManagerLoaded' } },
                            AdErrorEvent: { Type: { AD_ERROR: 'adError' } },
                            AdEvent: { Type: { 
                                ALL_ADS_COMPLETED: 'allAdsCompleted',
                                CONTENT_RESUME_REQUESTED: 'contentResumeRequested',
                                CONTENT_PAUSE_REQUESTED: 'contentPauseRequested',
                                LOADED: 'loaded',
                                STARTED: 'started',
                                COMPLETE: 'complete',
                                SKIPPED: 'skipped'
                            }},
                            settings: { setPlayerType: function() {}, setPlayerVersion: function() {} },
                            ImaSdkSettings: function() { return {}; },
                            AdsRenderingSettings: function() { return {}; },
                            AdsRequest: function() { return { adTagUrl: '', linearAdSlotWidth: 0, linearAdSlotHeight: 0 }; },
                            ViewMode: { NORMAL: 'normal', FULLSCREEN: 'fullscreen' }
                        };
                    }
                    return target[prop];
                }
            });
        },
        set: function() { return true; },
        configurable: true
    });
    
    // ==========================================
    // VIDEO.JS AD PLUGINS BLOCKING
    // ==========================================
    Object.defineProperty(window, 'DMVAST', {
        get: function() { return { parse: function() { return null; } }; },
        set: function() { return true; }
    });
    
    // Block videojs-ima
    const videojsHook = {
        ima: function() { return { controller: { skip: function() {} } }; },
        ads: function() { return { startLinearAdMode: function() {}, endLinearAdMode: function() {} }; },
        contrib: { ads: function() {} }
    };
    
    // ==========================================
    // JWPLAYER AD BLOCKING
    // ==========================================
    const originalJWPlayer = window.jwplayer;
    Object.defineProperty(window, 'jwplayer', {
        get: function() {
            if (!originalJWPlayer) {
                return function() {
                    return {
                        on: function() { return this; },
                        off: function() { return this; },
                        setup: function(config) {
                            // Remove advertising config
                            if (config && config.advertising) {
                                delete config.advertising;
                            }
                            return this;
                        },
                        getConfig: function() { return {}; },
                        playAd: function() { return this; },
                        pauseAd: function() { return this; },
                        skipAd: function() { return this; },
                        play: function() { return this; },
                        pause: function() { return this; }
                    };
                };
            }
            // Wrap original jwplayer to remove ads
            return function(id) {
                const player = originalJWPlayer(id);
                if (player && player.setup) {
                    const originalSetup = player.setup;
                    player.setup = function(config) {
                        if (config && config.advertising) {
                            console.log('[VideoAdBlocker] Removed JWPlayer advertising config');
                            delete config.advertising;
                        }
                        return originalSetup.call(this, config);
                    };
                }
                // Override ad methods
                player.playAd = function() { console.log('[VideoAdBlocker] Blocked JWPlayer ad'); return this; };
                return player;
            };
        },
        set: function(val) { originalJWPlayer = val; return true; },
        configurable: true
    });
    
    // ==========================================
    // VIDEO PLAYER AD SKIP BUTTONS
    // ==========================================
    function autoSkipAds() {
        // YouTube skip button
        const ytSkipBtn = document.querySelector('.ytp-ad-skip-button, .ytp-ad-skip-button-modern, .ytp-skip-ad-button');
        if (ytSkipBtn) {
            ytSkipBtn.click();
            console.log('[VideoAdBlocker] Auto-skipped YouTube ad');
        }
        
        // Generic skip buttons
        const skipSelectors = [
            '[class*="skip-ad"]', '[class*="skip_ad"]', '[class*="skipAd"]',
            '[class*="ad-skip"]', '[class*="ad_skip"]', '[class*="adSkip"]',
            '[id*="skip-ad"]', '[id*="skip_ad"]', '[id*="skipAd"]',
            'button[class*="skip"]', '.skip-button', '.skip-btn',
            '[data-skip]', '[data-skip-ad]'
        ];
        
        skipSelectors.forEach(selector => {
            try {
                const btn = document.querySelector(selector);
                if (btn && btn.offsetParent !== null) {
                    btn.click();
                    console.log('[VideoAdBlocker] Auto-skipped ad via:', selector);
                }
            } catch(e) {}
        });
        
        // Speed up video ads (play at 16x)
        const videos = document.querySelectorAll('video');
        videos.forEach(video => {
            if (video.closest('[class*="ad"]') || video.closest('[id*="ad"]')) {
                video.playbackRate = 16;
                video.muted = true;
                video.currentTime = video.duration || 0;
            }
        });
    }
    
    // Check for skip buttons periodically
    setInterval(autoSkipAds, 500);
    
    // ==========================================
    // VIDEO AD OVERLAY REMOVAL
    // ==========================================
    function removeVideoAdOverlays() {
        const overlaySelectors = [
            // Generic ad overlays
            '[class*="video-ad"]', '[class*="video_ad"]', '[class*="videoAd"]',
            '[class*="ad-overlay"]', '[class*="ad_overlay"]', '[class*="adOverlay"]',
            '[id*="video-ad"]', '[id*="video_ad"]', '[id*="videoAd"]',
            
            // YouTube ad overlays
            '.ytp-ad-overlay-container', '.ytp-ad-text-overlay',
            '.ytp-ad-image-overlay', '.video-ads',
            
            // Pre-roll containers
            '[class*="preroll"]', '[class*="pre-roll"]', '[class*="pre_roll"]',
            '[class*="midroll"]', '[class*="mid-roll"]', '[class*="mid_roll"]',
            
            // Common video ad containers
            '.ima-ad-container', '.video-ad-container',
            '[class*="adContainer"]', '[id*="adContainer"]'
        ];
        
        overlaySelectors.forEach(selector => {
            try {
                document.querySelectorAll(selector).forEach(el => {
                    el.style.display = 'none';
                    el.style.visibility = 'hidden';
                    el.style.opacity = '0';
                    el.style.pointerEvents = 'none';
                });
            } catch(e) {}
        });
    }
    
    // MutationObserver for dynamic ad overlays
    const observer = new MutationObserver(function(mutations) {
        let shouldClean = false;
        mutations.forEach(mutation => {
            mutation.addedNodes.forEach(node => {
                if (node.nodeType === 1) {
                    const el = node;
                    const className = (el.className || '').toLowerCase();
                    const id = (el.id || '').toLowerCase();
                    
                    if (className.includes('ad') || id.includes('ad') ||
                        className.includes('preroll') || className.includes('overlay')) {
                        shouldClean = true;
                    }
                }
            });
        });
        
        if (shouldClean) {
            removeVideoAdOverlays();
            autoSkipAds();
        }
    });
    
    if (document.body) {
        observer.observe(document.body, { childList: true, subtree: true });
    } else {
        document.addEventListener('DOMContentLoaded', function() {
            observer.observe(document.body, { childList: true, subtree: true });
        });
    }
    
    // Initial cleanup
    setTimeout(removeVideoAdOverlays, 500);
    setTimeout(removeVideoAdOverlays, 1000);
    setTimeout(removeVideoAdOverlays, 2000);
    
    console.log('[VideoAdBlocker] Video ad blocking active');
})();
        `
    });

    log.info('VideoAds', 'Video ad blocking initialized');
}