goon_plugin/src/inject/interceptors.js

/**
 * interceptors.js — Main-world interceptors for HLS manifest detection.
 *
 * This file is injected into the main world via a <script src="..."> tag
 * (NOT inline textContent) to bypass strict CSP on sites that restrict
 * script-src.
 *
 * When loaded as an external script from the extension origin, Chrome treats
 * it as an extension content script — not as page inline code — so the
 * page's script-src CSP does not apply.
 *
 * Loaded by content.js at document_start before any page JS runs.
 */

(function () {
  'use strict';

  if (window.__goon_plugin_intercepted) return;
  window.__goon_plugin_intercepted = true;

  window.__goon_plugin_data = window.__goon_plugin_data || {
    manifests: [],
    sources: [],
  };

  // Helper: resolve relative URLs
  function resolveUrl(url) {
    if (!url) return null;
    try {
      if (url.startsWith('//')) return 'https:' + url;
      if (url.startsWith('http')) return url;
      return new URL(url, window.location.origin).href;
    } catch {
      return null;
    }
  }

  // Helper: check if a URL looks like an HLS manifest
  function isManifestUrl(url) {
    var u = url.toLowerCase();
    return u.includes('.m3u8') || u.includes('.hlsvod') ||
           u.includes('/hls/') || u.includes('/playlist') || u.includes('/manifest');
  }

  // Helper: report manifest to content script via postMessage
  function reportManifest(url, source) {
    var resolved = resolveUrl(url);
    if (!resolved) return;
    if (window.__goon_plugin_data.manifests.includes(resolved)) return;
    window.__goon_plugin_data.manifests.push(resolved);

    window.postMessage(
      {
        type: 'GOON_PLUGIN_HLS_INTERCEPT',
        url: resolved,
        source: source,
        timestamp: Date.now(),
      },
      '*',
    );
  }

  // === INTERCEPTORS ===

  // 1. Intercept XMLHttpRequest for manifest-like requests
  var originalOpen = XMLHttpRequest.prototype.open;
  var originalSend = XMLHttpRequest.prototype.send;
  XMLHttpRequest.prototype.open = function (method, url) {
    this._goon_url = url;
    return originalOpen.apply(this, arguments);
  };
  XMLHttpRequest.prototype.send = function (_body) {
    if (this._goon_url && typeof this._goon_url === 'string') {
      var resolved = resolveUrl(this._goon_url);
      if (resolved && isManifestUrl(resolved)) {
        reportManifest(resolved, 'xhr');
      }
    }
    return originalSend.apply(this, arguments);
  };

  // 2. Intercept fetch() for manifest-like requests
  var originalFetch = window.fetch;
  window.fetch = function (resource, _init) {
    var url = typeof resource === 'string' ? resource : resource && resource.url;
    if (url && typeof url === 'string') {
      var resolved = resolveUrl(url);
      if (resolved && isManifestUrl(resolved)) {
        reportManifest(resolved, 'fetch');
      }
    }
    return originalFetch.apply(this, arguments);
  };

  // 3. Intercept HLS.js loadSource (catches HLS.js instances)
  // Guard against double-patching: only wrap if the method hasn't been patched yet.
  var hlsPatched = false;
  function patchHlsPrototype() {
    if (typeof Hls === 'undefined') return;
    if (hlsPatched) return; // Already patched — skip

    var originalLoadSource = Hls.prototype.loadSource;
    if (!originalLoadSource) return;

    Hls.prototype.loadSource = function (url) {
      reportManifest(url, 'hls_loadSource');
      return originalLoadSource.apply(this, arguments);
    };

    var originalAttachMedia = Hls.prototype.attachMedia;
    if (originalAttachMedia) {
      Hls.prototype.attachMedia = function (media) {
        if (media && media.tagName === 'VIDEO') {
          media._goon_hls_manifest = this.url;
          reportManifest(this.url, 'hls_attachMedia');
        }
        return originalAttachMedia.apply(this, arguments);
      };
    }
    hlsPatched = true;
  }

  // Patch immediately if HLS is already defined
  patchHlsPrototype();

  // Watch for HLS.js to be dynamically defined later.
  // Use a combination of:
  // 1. Longer polling window (30s instead of 3s) to catch lazy-loaded players.
  // 2. MutationObserver on <head> for new <script> tags — catches late hls.js loads.
  if (!hlsPatched) {
    var pollCount = 0;
    var maxPolls = 600; // poll for up to ~30s (50ms interval)

    var pollHls = setInterval(function () {
      pollCount++;
      if (typeof Hls !== 'undefined' && !hlsPatched) {
        patchHlsPrototype();
        if (hlsPatched) clearInterval(pollHls);
      }
      if (pollCount >= maxPolls) clearInterval(pollHls);
    }, 50);

    // MutationObserver: watches for new <script> tags that may load hls.js late.
    // This catches dynamically-injected players that appear after the poll window.
    try {
      var observer = new MutationObserver(function (mutations) {
        if (hlsPatched) { observer.disconnect(); return; }
        for (var m = 0; m < mutations.length; m++) {
          var nodes = mutations[m].addedNodes;
          if (!nodes) continue;
          for (var n = 0; n < nodes.length; n++) {
            var node = nodes[n];
            if (node.tagName === 'SCRIPT' && node.src) {
              var src = node.src.toLowerCase();
              if (src.includes('hls') || src.includes('videojs') || src.includes('player')) {
                // Script tag loaded — check if Hls is now defined
                if (typeof Hls !== 'undefined' && !hlsPatched) {
                  patchHlsPrototype();
                  if (hlsPatched) observer.disconnect();
                }
              }
            }
          }
        }
      });
      observer.observe(document.head || document.documentElement, { childList: true, subtree: true });
    } catch { /* MutationObserver not available — polling still works */ }
  }
})();