Progress SAve- downloader,blur,ghost mode(Partially) works

assets/scripts/ad_blocker_dom.js

@@ -0,0 +1,61 @@
+/**
+ * FocusGram DOM Ad Blocker (Fallback)
+ * 
+ * DEPRECATED: Use fetch_interceptor.js for reliable ad blocking.
+ * 
+ * This script provides DOM-based ad removal as a FALLBACK for ads that slip through
+ * GraphQL filtering. It's not reliable because Instagram has already rendered the content.
+ * 
+ * Injected at DOCUMENT_END
+ * Removes sponsored/posts/tracking elements from the DOM.
+ */
+(function () {
+  'use strict';
+
+  const AD_SIGNALS = [
+    'Sponsored',
+    'paid partnership',
+    'Promoted',
+  ];
+
+  const textMatchesSignal = (txt) => {
+    if (!txt) return false;
+    const t = txt.trim().toLowerCase();
+    return AD_SIGNALS.some((s) => t === s.toLowerCase());
+  };
+
+  const removeSponsoredArticles = () => {
+    try {
+      // aria-label routes (best-effort; localization may break)
+      document.querySelectorAll('a[aria-label]').forEach((a) => {
+        const aria = a.getAttribute('aria-label') || '';
+        if (textMatchesSignal(aria)) {
+          const article = a.closest('article');
+          if (article) article.remove();
+        }
+      });
+
+      // Text-based removal inside feed articles (best-effort)
+      document.querySelectorAll('article').forEach((article) => {
+        const walker = document.createTreeWalker(article, NodeFilter.SHOW_TEXT);
+        let node;
+        while ((node = walker.nextNode())) {
+          const txt = node.nodeValue;
+          if (textMatchesSignal(txt)) {
+            article.remove();
+            break;
+          }
+        }
+      });
+
+      // Suggested content is intentionally left alone. Removing suggested
+      // units after Instagram has virtualized the feed can snap the viewport
+      // back to the top on some accounts.
+    } catch (_) {}
+  };
+
+  const observer = new MutationObserver(() => removeSponsoredArticles());
+  observer.observe(document.body, { childList: true, subtree: true });
+
+  removeSponsoredArticles();
+})();

assets/scripts/autoplay_blocker.js

@@ -0,0 +1,129 @@
+/**
+ * FocusGram Autoplay Blocker
+ * Injected at DOCUMENT_START — before Instagram's JS loads.
+ * Prevents video autoplay by:
+ * 1. Blocking play() calls on video elements
+ * 2. Disabling autoplay attribute
+ * 3. Removing preload attributes
+ */
+(function () {
+  'use strict';
+
+  // This script is only registered when the setting is enabled, so default ON.
+  window.__fgBlockAutoplay = typeof window.__fgBlockAutoplay === 'boolean'
+    ? window.__fgBlockAutoplay : true;
+  const ALLOW_KEY = '__fgUserStartedPlayback';
+  let userGestureUntil = 0;
+
+  function isReelRoute() {
+    const path = window.location.pathname || '';
+    return path.indexOf('/reel/') >= 0 || path === '/reels' || path.indexOf('/reels/') >= 0;
+  }
+
+  function isUserGestureActive() {
+    return Date.now() < userGestureUntil;
+  }
+
+  function markUserGesture(target) {
+    userGestureUntil = Date.now() + 1200;
+    try {
+      let video = target && target.closest ? target.closest('video') : null;
+      if (!video && target && target.querySelector) video = target.querySelector('video');
+      if (video) video[ALLOW_KEY] = true;
+    } catch (_) {}
+  }
+
+  document.addEventListener('pointerdown', function (event) {
+    markUserGesture(event.target);
+  }, true);
+  document.addEventListener('touchstart', function (event) {
+    markUserGesture(event.target);
+  }, true);
+  document.addEventListener('click', function (event) {
+    markUserGesture(event.target);
+  }, true);
+
+  // Override HTMLMediaElement.play() to check our flag
+  const _play = HTMLMediaElement.prototype.play;
+  HTMLMediaElement.prototype.play = function () {
+    if (
+      window.__fgBlockAutoplay &&
+      !isReelRoute() &&
+      this[ALLOW_KEY] !== true &&
+      !isUserGestureActive()
+    ) {
+      // Return a resolved promise to avoid breaking Instagram's code
+      try { this.pause(); } catch (_) {}
+      return Promise.resolve();
+    }
+    return _play.call(this);
+  };
+
+  // Override autoplay property setter
+  const _videoDescriptor = Object.getOwnPropertyDescriptor(HTMLVideoElement.prototype, 'autoplay') || {};
+  const _originalAutoplaySetter = _videoDescriptor.set;
+
+  Object.defineProperty(HTMLVideoElement.prototype, 'autoplay', {
+    set: function (value) {
+      if (window.__fgBlockAutoplay && value) {
+        // Silently ignore autoplay attempts when blocking is enabled
+        return;
+      }
+      if (_originalAutoplaySetter) {
+        _originalAutoplaySetter.call(this, value);
+      }
+    },
+    get: function () {
+      if (_videoDescriptor.get) {
+        return _videoDescriptor.get.call(this);
+      }
+      return this.getAttribute('autoplay') !== null;
+    },
+    enumerable: _videoDescriptor.enumerable,
+    configurable: true,
+  });
+
+  // On page load and SPA navigation, scan for video elements and remove autoplay
+  const removeAutoplayFromVideos = () => {
+    document.querySelectorAll('video, [role="video"]').forEach(el => {
+      if (window.__fgBlockAutoplay && !isReelRoute() && el[ALLOW_KEY] !== true) {
+        el.autoplay = false;
+        el.removeAttribute('autoplay');
+        el.removeAttribute('preload');
+        try { el.preload = 'none'; } catch (_) {}
+        if (el.paused === false) {
+          el.pause();
+        }
+      }
+    });
+  };
+
+  // Run on load and when document changes
+  removeAutoplayFromVideos();
+
+  if (!window.__fgAutoplayObserver) {
+    let _timer = null;
+    window.__fgAutoplayObserver = new MutationObserver(() => {
+      clearTimeout(_timer);
+      _timer = setTimeout(removeAutoplayFromVideos, 500);
+    });
+    window.__fgAutoplayObserver.observe(document.documentElement, {
+      childList: true,
+      subtree: true,
+    });
+  }
+
+  // Allow Flutter to toggle
+  window.__fgSetBlockAutoplay = function (enabled) {
+    window.__fgBlockAutoplay = !!enabled;
+    if (enabled) {
+      removeAutoplayFromVideos();
+    }
+  };
+
+  document.addEventListener('play', function (event) {
+    if (event.target && event.target.tagName === 'VIDEO' && isUserGestureActive()) {
+      event.target[ALLOW_KEY] = true;
+    }
+  }, true);
+})();

assets/scripts/content_hider.js

@@ -0,0 +1,304 @@
+/**
+ * FocusGram Content Hider
+ * Toggleable visibility for: stories tray, feed posts, reels, suggested content.
+ * Flutter controls via window.__fgContent.*
+ * Injected at DOCUMENT_END.
+ *
+ * Key fixes applied:
+ * - Blank-feed fix: hideReels uses DOM removal (not display:none) so layout doesn't collapse
+ * - MutationObserver callback now re-applies CSS AND re-runs all hide functions each cycle
+ * - SPA-heartbeat via window event listener re-applies CSS on pushState/replaceState
+ * - Stories tray detection strengthened for fresh SPA navigations
+ * - Suggested posts detection uses multiple text-node matching strategies
+ */
+(function () {
+  'use strict';
+
+  if (window.__fgContent && window.__fgContent.__focusgramReady) {
+    return;
+  }
+
+  const STYLE_ID = 'fg-content-hider';
+  let hideStories = false;
+  let hidePosts   = false;
+  let hideSuggested = false;
+  let hideReels   = false;
+
+  // ─── CSS rules ─────────────────────────────────────────────────────────────
+
+  function buildCSS() {
+    const selectors = [];
+
+    if (hideStories) {
+      selectors.push(
+        '[role="list"]:has([aria-label*="tory"])',
+        '[role="listbox"]:has([aria-label*="tory"])',
+        '[role="menu"] > ul',
+        'section > div > div:first-child [style*="overflow"]',
+        '[role="list"] [style*="overflow"]',
+      );
+    }
+
+    if (hidePosts) {
+      selectors.push(
+        'body:not([path*="direct"]):not([data-fg-path*="direct"]) article:not([aria-label])',
+        'body:not([path*="direct"]):not([data-fg-path*="direct"]) [data-pressable-container] > article',
+      );
+    }
+
+    // hideReels CSS is intentionally NOT added here.
+    // We use DOM removal instead (see removeReels()) so that room is never left
+    // blank in the feed, and Instagram's infinite-scroll can prove scroll height.
+
+    return selectors.length
+      ? selectors.join(',\n') + ' { display: none !important; visibility: hidden !important; }'
+      : '';
+  }
+
+  function applyCSS() {
+    if (document.body) {
+      document.body.setAttribute('data-fg-path', window.location.pathname || '/');
+    }
+    let style = document.getElementById(STYLE_ID);
+    if (!style) {
+      style = document.createElement('style');
+      style.id = STYLE_ID;
+      document.head.appendChild(style);
+    }
+    style.textContent = buildCSS();
+  }
+
+  // ─── Story tray JS ─────────────────────────────────────────────────────────
+
+  function hideStoryTray() {
+    if (!hideStories) return;
+
+    // Strategy 1: <ul> children of a named list or menu
+    document.querySelectorAll('[role="list"] ul, [role="menu"] ul').forEach(function (ul) {
+      try {
+        const items = ul.querySelectorAll('li, button, a');
+        if (items.length < 2) return;
+        ul.style.setProperty('display', 'none', 'important');
+      } catch (_) {}
+    });
+
+    // Strategy 2: horizontally scrolling container with circle items
+    document.querySelectorAll('[style*="overflow"], [style*="overflow-x"]').forEach(function (c) {
+      try {
+        if ('' === (window.getComputedStyle(c).overflow + '').replace(/none/g, '')) return;
+        const cands = c.querySelectorAll('li, div[class*="story"], [class*="story"]');
+        if (cands.length < 2) return;
+        const s0 = window.getComputedStyle(cands[0]);
+        if (s0.width && parseFloat(s0.width) <= 90) {
+          c.parentElement && (c.parentElement.style.setProperty('display', 'none', 'important'));
+        }
+      } catch (_) {}
+    });
+  }
+
+  // ─── Suggested posts ───────────────────────────────────────────────────────
+
+  function removeSuggested() {
+    if (!hideSuggested) return;
+
+    var SIGNALS = [
+      'suggested for you',
+      'suggested posts',
+      'suggested reels',
+      'suggested',
+      'because you watched',
+      'because you follow',
+      'you might like',
+      'posts you might like',
+      'accounts you might like',
+      'recommendations',
+    ];
+
+    function norm(s) {
+      return (s || '').replace(/\s+/g, ' ').trim().toLowerCase();
+    }
+
+    function hasSignal(s) {
+      var t = norm(s);
+      if (!t) return false;
+      return SIGNALS.some(function (signal) {
+        if (signal === 'suggested') return t === signal;
+        return t.indexOf(signal) >= 0;
+      });
+    }
+
+    function hideContainer(from) {
+      var parent = from;
+      for (var depth = 0; depth < 10 && parent && parent !== document.body; depth++) {
+        var role = parent.getAttribute && parent.getAttribute('role');
+        var tag = parent.tagName;
+        var hasMedia = parent.querySelector && parent.querySelector('img,video,a[href*="/p/"],a[href*="/reel/"]');
+        if (
+          tag === 'ARTICLE' ||
+          tag === 'SECTION' ||
+          role === 'listitem' ||
+          (hasMedia && parent.getBoundingClientRect && parent.getBoundingClientRect().height > 120)
+        ) {
+          parent.style.setProperty('display', 'none', 'important');
+          parent.setAttribute('data-fg-hidden-suggested', '1');
+          return true;
+        }
+        parent = parent.parentElement;
+      }
+      return false;
+    }
+
+    document.querySelectorAll('article, section, [role="listitem"]').forEach(function (node) {
+      try {
+        if (node.getAttribute('data-fg-hidden-suggested') === '1') return;
+        var ownLabel = node.getAttribute('aria-label');
+        if (hasSignal(ownLabel)) { hideContainer(node); return; }
+        var text = norm(node.innerText || node.textContent || '');
+        if (
+          text.indexOf('suggested for you') >= 0 ||
+          text.indexOf('suggested posts') >= 0 ||
+          text.indexOf('suggested reels') >= 0 ||
+          text.indexOf('because you watched') >= 0 ||
+          text.indexOf('because you follow') >= 0
+        ) {
+          hideContainer(node);
+        }
+      } catch (_) {}
+    });
+
+    document.querySelectorAll('span, h1, h2, h3, h4, div[aria-label], a[aria-label]').forEach(function (el) {
+      try {
+        if (hasSignal(el.textContent) || hasSignal(el.getAttribute('aria-label'))) {
+          hideContainer(el);
+        }
+      } catch (_) {}
+    });
+  }
+
+  // ─── Reels – DOM REMOVE (not display:none) ─────────────────────────────────
+  // display:none keeps the element in the DOM, so Instagram's virtual-scroll still
+  // reserves the slot → blank gaps. Removing the article from the DOM collapses the
+  // gap cleanly and lets the feed flow naturally.
+  function removeReels() {
+    if (!hideReels) return;
+
+    var toRemove = [];
+    document.querySelectorAll('article').forEach(function (el) {
+      try {
+        // Fast path: check for a reel-signal attribute first
+        var mt = (el.getAttribute('data-media-type') || el.dataset && el.dataset.mediaType || '').trim();
+        if (mt === '2') { toRemove.push(el); return; }
+
+        // Fallback: text-node scan for /reels/ markers
+        var walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+        var n;
+        while ((n = walker.nextNode())) {
+          if (n.nodeValue.indexOf('/reels/') >= 0 || n.nodeValue.indexOf('/reel/') >= 0) {
+            toRemove.push(el); break;
+          }
+        }
+      } catch (_) {}
+    });
+
+    toRemove.forEach(function (el) { try { el.remove(); } catch (_) {} });
+  }
+
+  // ─── Public API ────────────────────────────────────────────────────────────
+
+  window.__fgContent = {
+    __focusgramReady: true,
+    setHideStories: function (val) { hideStories = !!val; applyCSS(); hideStoryTray(); },
+    setHidePosts:   function (val) { hidePosts   = !!val; applyCSS(); },
+    setHideSuggested: function (val) {
+      hideSuggested = !!val;
+      applyCSS();
+      if (val) removeSuggested();
+    },
+    setHideReels: function (val) {
+      hideReels = !!val;
+      applyCSS();
+      if (val) removeReels();
+    },
+    applyAll: function (flags) {
+      hideStories   = !!flags.stories;
+      hidePosts     = !!flags.posts;
+      hideReels     = !!flags.reels;
+      hideSuggested = !!flags.suggested;
+      applyCSS();
+      if (hideSuggested) removeSuggested();
+      if (hideStories)   hideStoryTray();
+      if (hideReels)     removeReels();
+    },
+  };
+
+  // ─── SPA heartbeat ─────────────────────────────────────────────────────────
+  // pushState/replaceState don't fire any DOM event we can listen for.
+  // Hook the methods themselves so we know a navigation happened, then debounce
+  // re-apply. This also catches the case where the MutationObserver was on `body`
+  // and that node got replaced by Instagram's SPA re-render.
+
+  function scheduleReapply() {
+    clearTimeout(window.__fg_applyTimer);
+    window.__fg_applyTimer = setTimeout(function () {
+      applyCSS();
+      if (hideStories)   hideStoryTray();
+      if (hideSuggested) removeSuggested();
+      if (hideReels)     removeReels();
+    }, 250);
+  }
+
+  var _origPush    = history.pushState;
+  var _origReplace = history.replaceState;
+
+  history.pushState = function () {
+    _origPush.apply(this, arguments);
+    scheduleReapply();
+  };
+
+  history.replaceState = function () {
+    _origReplace.apply(this, arguments);
+    scheduleReapply();
+  };
+
+  // Reinforce on popstate too (user hits back/forward)
+  window.addEventListener('popstate', scheduleReapply, { passive: true });
+  // For pushState on the same URL (rare but possible) – poll path briefly
+  window.addEventListener('pageshow',  scheduleReapply, { passive: true });
+  window.addEventListener('focus',     scheduleReapply, { passive: true });
+
+  // ─── MutationObserver ───────────────────────────────────────────────────────
+  // Monitors for dynamic DOM changes (new rows, lazy-loaded articles) and
+  // re-applies everything on each cycle.  Does NOT guard on a per-element timer
+  // that would never re-fire after the body is replaced by SPA re-render.
+
+  if (!window.__fgContentObserver) {
+    window.__fgContentObserver = new MutationObserver(function () {
+      clearTimeout(window.__fg_moTimer);
+      window.__fg_moTimer = setTimeout(function () {
+        applyCSS();
+        if (hideStories)   hideStoryTray();
+        if (hideSuggested) removeSuggested();
+        if (hideReels)     removeReels();
+      }, 300);
+    });
+
+    // `document.documentElement` survives SPA navigations (body gets replaced
+    // but <html> stays). Observing it catches both subtree mutations and, via
+    // the SPA heartbeat above, re-applies after pushState.
+    window.__fgContentObserver.observe(document.documentElement, {
+      childList:  true,
+      subtree:    true,
+    });
+  }
+
+  // ─── Initial run ────────────────────────────────────────────────────────────
+  applyCSS();
+  if (hideStories)   hideStoryTray();
+  if (hideSuggested) removeSuggested();
+  if (hideReels)     removeReels();
+
+  // Signal ready — Flutter will call applyAll() with stored prefs
+  if (window.ContentChannel) {
+    window.ContentChannel.postMessage(JSON.stringify({ type: 'ready' }));
+  }
+})();

assets/scripts/fetch_interceptor.js

@@ -0,0 +1,315 @@
+/**
+ * FocusGram Unified Feed Filter via Fetch Interception
+ * Injected at DOCUMENT_START — before Instagram's JS loads.
+ * 
+ * This script intercepts GraphQL fetch calls and filters feed content based on:
+ * - Ads (is_ad, ad_action_link, product_type, ad_id, ad_header_style)
+ * - Sponsored posts (ad_action_link, ad_header_style)
+ * - Suggested posts (is_suggested, is_suggested_for_you, __typename)
+ * - Videos/Reels (is_video, media_type, clips_metadata)
+ * - Autoplay blocking (video autoplay prevention)
+ */
+(function () {
+  'use strict';
+
+  // Configuration flags (set by Flutter via prefs)
+  window.__fgFilterConfig = {
+    blockAds: false,
+    blockSponsored: false,
+    blockSuggested: false,
+    blockVideos: false,
+    blockAutoplay: false,
+    blockGraphQLQueryWhenFeedPosts: false,
+  };
+
+  const textHasAdSignal = (value) => {
+    const s = String(value || '').toLowerCase();
+    return (
+      s === 'sponsored' ||
+      s.includes('"sponsored"') ||
+      s.includes('paid partnership') ||
+      s.includes('promoted') ||
+      s.includes('ad_id') ||
+      s.includes('ad_tracking') ||
+      s.includes('sponsor_tags')
+    );
+  };
+
+  // Helper: Check if a node is an ad
+  const isAdNode = (node) => {
+    if (!node || typeof node !== 'object') return false;
+    const typename = String(node.__typename || '');
+    const adText = JSON.stringify({
+      organic_tracking_token: node.organic_tracking_token,
+      sponsor_tags: node.sponsor_tags,
+      social_context: node.social_context,
+      title: node.title,
+      header: node.header,
+      label: node.label,
+      overlay_text: node.overlay_text,
+    });
+    
+    return !!(
+      node.is_ad ||
+      node.is_paid_partnership ||
+      node.sponsor_tags ||
+      node.ad_tracking_token ||
+      node.ad_action_link ||
+      node.ad_id ||
+      node.ad_impression_token ||
+      node.ad_metadata ||
+      node.commerciality_status === 'commercial' ||
+      (node.product_type && node.product_type === 'ad') ||
+      (node.ad_header_style && node.ad_header_style !== 'none') ||
+      typename === 'GraphAdStory' ||
+      typename.includes('Ad') ||
+      textHasAdSignal(adText)
+    );
+  };
+
+  // Helper: Check if a node is sponsored
+  const isSponsoredNode = (node) => {
+    if (!node || typeof node !== 'object') return false;
+    
+    return !!(
+      node.is_paid_partnership ||
+      node.sponsor_tags ||
+      (node.ad_action_link && node.ad_action_link.href) ||
+      (node.ad_header_style && node.ad_header_style !== 'none') ||
+      textHasAdSignal(JSON.stringify(node.social_context || node.header || node.label || ''))
+    );
+  };
+
+  // Helper: Check if a node is suggested content
+  const isSuggestedNode = (node) => {
+    if (!node || typeof node !== 'object') return false;
+    const typename = String(node.__typename || '');
+    const reason = JSON.stringify({
+      reason: node.suggested_reason,
+      social_context: node.social_context,
+      title: node.title,
+      header: node.header,
+      label: node.label,
+    }).toLowerCase();
+    
+    return !!(
+      node.is_suggested ||
+      node.is_suggested_for_you ||
+      node.is_recommendation ||
+      node.suggested_users ||
+      node.suggested_media ||
+      node.suggested_content ||
+      node.recommendation_source ||
+      typename.includes('Suggested') ||
+      typename.includes('Recommendation') ||
+      reason.includes('suggested') ||
+      reason.includes('recommend')
+    );
+  };
+
+  // Helper: Check if a node is a video/reel
+  const isVideoNode = (node) => {
+    if (!node || typeof node !== 'object') return false;
+    
+    return !!(
+      node.is_video ||
+      (node.media_type === 2) ||
+      node.clips_metadata ||
+      (node.__typename && (
+        node.__typename.includes('Clips') ||
+        node.__typename.includes('Video')
+      ))
+    );
+  };
+
+  const isFeedMediaNode = (node) => {
+    if (!node || typeof node !== 'object') return false;
+    return !!(
+      node.pk ||
+      node.id ||
+      node.code ||
+      node.media_type ||
+      node.image_versions2 ||
+      node.video_versions ||
+      node.carousel_media ||
+      node.__typename?.includes('Media') ||
+      node.__typename?.includes('Timeline')
+    );
+  };
+
+  // Helper: Check for media in carousel
+  const hasVideoInCarousel = (node) => {
+    if (!node || typeof node !== 'object') return false;
+
+    if (node.media_type === 8) {
+      const edges = node.edge_sidecar_to_children?.edges || [];
+      return edges.some(edge => isVideoNode(edge.node));
+    }
+    return false;
+  };
+
+  // Main filter function for feed nodes
+  const shouldFilterNode = (node) => {
+    const config = window.__fgFilterConfig;
+    
+    if (!node || typeof node !== 'object') return false;
+
+    if (config.blockGraphQLQueryWhenFeedPosts && isFeedMediaNode(node)) {
+      return true;
+    }
+
+    // Check ads
+    if (config.blockAds && isAdNode(node)) {
+      return true;
+    }
+
+    // Check sponsored (separate from ads)
+    if (config.blockSponsored && isSponsoredNode(node) && !isAdNode(node)) {
+      return true;
+    }
+
+    // Check suggested content
+    if (config.blockSuggested && isSuggestedNode(node)) {
+      return true;
+    }
+
+    // Check videos/reels
+    if (config.blockVideos && (isVideoNode(node) || hasVideoInCarousel(node))) {
+      return true;
+    }
+
+    return false;
+  };
+
+  // Recursively filter GraphQL response edges
+  const filterEdges = (edges, path = []) => {
+    if (!Array.isArray(edges)) return edges;
+    
+    return edges.filter(edge => {
+      if (!edge || !edge.node) return true;
+      const node = edge.node;
+      
+      // Keep the edge if it doesn't match any filter
+      if (!shouldFilterNode(node)) return true;
+      
+      // Log filtered content for debugging
+      if (window.__fgDebugFilter) {
+        const type = node.__typename || 'Unknown';
+        console.debug('[FocusGram Filter]', `Filtered ${type} at ${path.join('/')}`);
+      }
+      
+      return false;
+    });
+  };
+
+  // Recursively walk GraphQL response and filter edges
+  const walkAndFilter = (obj, visited = new Set()) => {
+    if (!obj || typeof obj !== 'object' || visited.has(obj)) return;
+    visited.add(obj);
+
+    // Handle arrays
+    if (Array.isArray(obj)) {
+      obj.forEach(item => walkAndFilter(item, visited));
+      return;
+    }
+
+    // Check for edges array (common GraphQL pattern)
+    if (obj.edges && Array.isArray(obj.edges)) {
+      obj.edges = filterEdges(obj.edges);
+    }
+
+    // Recurse into children
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key) && key !== '__typename') {
+        const val = obj[key];
+        if (val && typeof val === 'object') {
+          walkAndFilter(val, visited);
+        }
+      }
+    }
+  };
+
+  // Override fetch
+  const _fetch = window.fetch.bind(window);
+
+  window.fetch = async function (input, init) {
+    const url = typeof input === 'string'
+      ? input
+      : input instanceof URL
+      ? input.href
+      : input?.url ?? '';
+
+    // Call original fetch
+    let response = await _fetch(input, init);
+
+    // Only intercept GraphQL feed queries
+    if (!url.includes('/graphql/query') && !url.includes('/api/v1/feed')) {
+      return response;
+    }
+
+    // Clone response to read body
+    const cloned = response.clone();
+    
+    try {
+      const contentType = response.headers.get('content-type') || '';
+      if (!contentType.includes('application/json')) {
+        return response;
+      }
+
+      const data = await cloned.json();
+      
+      // Filter the response data
+      walkAndFilter(data);
+
+      // Return modified response
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    } catch (e) {
+      // On error, return original response
+      return response;
+    }
+  };
+
+  // Preserve native function appearance
+  Object.defineProperty(window, 'fetch', {
+    value: window.fetch,
+    writable: true,
+    configurable: true,
+  });
+  window.fetch.toString = () => 'function fetch() { [native code] }';
+
+  const _xhrOpen = XMLHttpRequest.prototype.open;
+  const _xhrSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function (method, url) {
+    this.__fgUrl = typeof url === 'string' ? url : String(url || '');
+    return _xhrOpen.apply(this, arguments);
+  };
+  XMLHttpRequest.prototype.send = function () {
+    if (
+      window.__fgFilterConfig.blockVideos &&
+      this.__fgUrl &&
+      (this.__fgUrl.includes('/api/v1/clips/') ||
+        this.__fgUrl.includes('/api/v1/discover/'))
+    ) {
+      try { this.abort(); } catch (_) {}
+      return;
+    }
+    return _xhrSend.apply(this, arguments);
+  };
+
+  // Allow Flutter to update config flags
+  window.__fgSetFilterConfig = function (config) {
+    if (typeof config === 'object') {
+      Object.assign(window.__fgFilterConfig, config);
+      if (window.__fgDebugFilter) {
+        console.debug('[FocusGram Filter] Config updated:', window.__fgFilterConfig);
+      }
+    }
+  };
+
+  // Enable debug logging
+  window.__fgDebugFilter = false;
+})();

assets/scripts/ghost_mode.js

@@ -0,0 +1,179 @@
+/**
+ * FocusGram Ghost Mode
+ * Injected at DOCUMENT_START — before Instagram's JS loads.
+ * Blocks story-seen, message-seen, and online-presence signals.
+ */
+(function () {
+  'use strict';
+
+  // ─── Seen API patterns ────────────────────────────────────────────────────
+  const SEEN_PATTERNS = [
+    /\/api\/v1\/media\/[\w-]+\/seen\//,
+    /\/api\/v1\/stories\/reel\/seen\//,
+    /\/api\/v1\/direct_v2\/threads\/[\w-]+\/seen\//,
+    /\/api\/v1\/direct_v2\/visual_message\/[\w-]+\/seen\//,
+    /\/api\/v1\/live\/[\w-]+\/comment\/seen\//,
+  ];
+
+  // ─── Activity patterns (like, comment) — intercepted for local history ────
+  const ACTIVITY_PATTERNS = [
+    /\/api\/v1\/web\/likes\/[\w-]+\/like\//,
+    /\/api\/v1\/web\/comments\/add\//,
+    /\/api\/v1\/friendships\/[\w-]+\/follow\//,
+  ];
+
+  const isSeen = (url) => SEEN_PATTERNS.some((p) => p.test(url));
+  const isActivity = (url) => ACTIVITY_PATTERNS.some((p) => p.test(url));
+
+  const fakeOkResponse = () =>
+    new Response(JSON.stringify({ status: 'ok' }), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+  // ─── Fetch override ───────────────────────────────────────────────────────
+  const _fetch = window.fetch.bind(window);
+
+  const patchedFetch = async function (input, init) {
+    const url =
+      typeof input === 'string'
+        ? input
+        : input instanceof URL
+        ? input.href
+        : input?.url ?? '';
+
+    // Block seen
+    if (isSeen(url)) {
+      if (window.GhostChannel) {
+        window.GhostChannel.postMessage(
+          JSON.stringify({ type: 'seen_blocked', url })
+        );
+      }
+      return fakeOkResponse();
+    }
+
+    // Intercept activity for local history
+    if (isActivity(url) && window.ActivityChannel) {
+      const body = init?.body;
+      const bodyText =
+        body instanceof URLSearchParams
+          ? body.toString()
+          : typeof body === 'string'
+          ? body
+          : '';
+      window.ActivityChannel.postMessage(
+        JSON.stringify({ url, body: bodyText, timestamp: Date.now() })
+      );
+    }
+
+    return _fetch(input, init);
+  };
+
+  // Disguise as native
+  Object.defineProperty(window, 'fetch', {
+    value: patchedFetch,
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  });
+  window.fetch.toString = () => 'function fetch() { [native code] }';
+  window.fetch[Symbol.toStringTag] = 'fetch';
+
+  // ─── XMLHttpRequest override ──────────────────────────────────────────────
+  const _XHROpen = XMLHttpRequest.prototype.open;
+  const _XHRSend = XMLHttpRequest.prototype.send;
+
+  XMLHttpRequest.prototype.open = function (method, url, ...args) {
+    this._fg_url = url ?? '';
+    this._fg_method = (method ?? '').toUpperCase();
+    return _XHROpen.call(this, method, url, ...args);
+  };
+
+  XMLHttpRequest.prototype.send = function (body) {
+    if (this._fg_url && isSeen(this._fg_url)) {
+      // Fire readyState 4 with fake success without actually sending
+      const self = this;
+      setTimeout(() => {
+        Object.defineProperty(self, 'readyState', { get: () => 4 });
+        Object.defineProperty(self, 'status', { get: () => 200 });
+        Object.defineProperty(self, 'responseText', {
+          get: () => '{"status":"ok"}',
+        });
+        Object.defineProperty(self, 'response', {
+          get: () => '{"status":"ok"}',
+        });
+        self.dispatchEvent(new Event('readystatechange'));
+        self.dispatchEvent(new Event('load'));
+      }, 10);
+      return;
+    }
+    return _XHRSend.call(this, body);
+  };
+
+  // ─── WebSocket intercept (message-seen via WS) ────────────────────────────
+  const _WS = window.WebSocket;
+
+  function PatchedWebSocket(url, protocols) {
+    const ws = protocols ? new _WS(url, protocols) : new _WS(url);
+    const _send = ws.send.bind(ws);
+
+    ws.send = function (data) {
+      if (typeof data === 'string') {
+        // IG sends seen ops as JSON with "op":"4" or "op":"seen" depending on version
+        try {
+          const parsed = JSON.parse(data);
+          if (
+            parsed?.op === '4' ||
+            parsed?.op === 'seen' ||
+            (parsed?.payload && JSON.parse(parsed.payload)?.op === 'seen')
+          ) {
+            return; // drop
+          }
+        } catch (_) {}
+        // Text-based seen signal check
+        if (data.includes('"seen"') && data.includes('"thread_id"')) {
+          return;
+        }
+      }
+      return _send(data);
+    };
+
+    return ws;
+  }
+
+  // Preserve WebSocket prototype chain so IG's ws checks pass
+  PatchedWebSocket.prototype = _WS.prototype;
+  PatchedWebSocket.CONNECTING = _WS.CONNECTING;
+  PatchedWebSocket.OPEN = _WS.OPEN;
+  PatchedWebSocket.CLOSING = _WS.CLOSING;
+  PatchedWebSocket.CLOSED = _WS.CLOSED;
+  window.WebSocket = PatchedWebSocket;
+
+  // ─── Visibility trick — hide "Active Now" ────────────────────────────────
+  // Only applied if user enables online-status hiding
+  // Wrapped in a named fn so Flutter can call it:
+  // controller.evaluateJavascript(source: 'window.__fgEnableOnlineHide()')
+  window.__fgEnableOnlineHide = function () {
+    Object.defineProperty(document, 'visibilityState', {
+      get: () => 'hidden',
+      configurable: true,
+    });
+    Object.defineProperty(document, 'hidden', {
+      get: () => true,
+      configurable: true,
+    });
+    document.dispatchEvent(new Event('visibilitychange'));
+  };
+
+  window.__fgDisableOnlineHide = function () {
+    // Restore by deleting the overrides (falls back to native getter)
+    delete document.visibilityState;
+    delete document.hidden;
+    document.dispatchEvent(new Event('visibilitychange'));
+  };
+
+  // Signal to Flutter that ghost mode JS is active
+  if (window.GhostChannel) {
+    window.GhostChannel.postMessage(JSON.stringify({ type: 'ready' }));
+  }
+})();

assets/scripts/theme_detector.js

@@ -0,0 +1,47 @@
+/**
+ * FocusGram Theme Detector
+ * Reads light/dark theme from page and bridges to Flutter.
+ * Injected at DOCUMENT_END.
+ */
+(function () {
+  'use strict';
+
+  (function fgThemeSync() {
+    if (window.__fgThemeSyncRunning) return;
+    window.__fgThemeSyncRunning = true;
+
+    function getTheme() {
+      try {
+        const h = document.documentElement;
+        if (h.classList.contains('style-dark')) return 'dark';
+        if (h.classList.contains('style-light')) return 'light';
+
+        const bg = window.getComputedStyle(document.body).backgroundColor;
+        const rgb = bg.match(/\d+/g);
+        if (rgb && rgb.length >= 3) {
+          const luminance =
+            (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255;
+          return luminance < 0.5 ? 'dark' : 'light';
+        }
+      } catch (_) {}
+      return 'dark';
+    }
+
+    let last = '';
+    function check() {
+      const current = getTheme();
+      if (current !== last) {
+        last = current;
+        if (window.flutter_inappwebview) {
+          window.flutter_inappwebview.callHandler(
+            'FocusGramThemeChannel',
+            current
+          );
+        }
+      }
+    }
+
+    setInterval(check, 1500);
+    check();
+  })();
+})();