nekostream 2026.0.1

package/isolate.js

@@ -0,0 +1,178 @@
+(() => {
+  const rootSelectors = ['.watch-player', '.player-section', '.video-container', '.art-video-player', '#player', '.player-wrapper'];
+  const anchorSelectors = [
+    '.watch-player .jwplayer', '.player-section .jwplayer', '.video-container .jwplayer',
+    '.player-wrapper.jw-active', '.player-wrapper .jwplayer', '.jwplayer', '.jw-video',
+    '.video-js', '.vjs-tech', '.player-section video', '.video-container video',
+    '.watch-player video', 'iframe[src*="anime47"]', 'iframe[src*="nonprofit"]',
+    'iframe[src*="vlogphim"]', 'iframe[src*="anime3s"]', 'video', '.art-video-player'
+  ];
+  const containerSelectors = [
+    '.watch-player', '.player-section', '.video-container', '.player-wrapper.jw-active',
+    '.player-wrapper', '.jw-player-wrapper', '.jwplayer', 'main.q-page.watch-page',
+    'main.q-page', 'main', '.art-video-player', '#player', '.player'
+  ];
+
+  const firstMatch = (selectors) => {
+    for (const selector of selectors) {
+      const found = document.querySelector(selector);
+      if (found instanceof HTMLElement) return found;
+    }
+    return null;
+  };
+
+  const firstMatchWithin = (root, selectors) => {
+    if (!(root instanceof HTMLElement)) return null;
+    for (const selector of selectors) {
+      const found = root.querySelector(selector);
+      if (found instanceof HTMLElement) return found;
+    }
+    return null;
+  };
+
+  const stretch = (el) => {
+    if (!(el instanceof HTMLElement)) return;
+    el.style.setProperty('width', '100%', 'important');
+    el.style.setProperty('height', '100%', 'important');
+    el.style.setProperty('max-width', '100%', 'important');
+    el.style.setProperty('max-height', '100%', 'important');
+    el.style.setProperty('margin', '0', 'important');
+    el.style.setProperty('padding', '0', 'important');
+    el.style.setProperty('padding-bottom', '0', 'important');
+    el.style.setProperty('padding-top', '0', 'important');
+    el.style.setProperty('top', '0', 'important');
+    el.style.setProperty('left', '0', 'important');
+    el.style.setProperty('transform', 'none', 'important');
+    el.style.setProperty('background', '#000', 'important');
+  };
+
+  const hideSiblingBranches = (node, anchorNode) => {
+    if (!(node instanceof HTMLElement)) return;
+    let current = node;
+    
+    // Hide siblings upwards from root to body
+    while (current?.parentElement) {
+      const parent = current.parentElement;
+      for (const sibling of Array.from(parent.children)) {
+        if (!(sibling instanceof HTMLElement) || sibling === current) continue;
+        sibling.style.setProperty('display', 'none', 'important');
+      }
+      if (parent === document.body) break;
+      current = parent;
+    }
+
+    // Hide siblings downwards from anchor to root
+    if (anchorNode && anchorNode instanceof HTMLElement && node.contains(anchorNode)) {
+      let currChild = anchorNode;
+      while (currChild && currChild !== node && currChild.parentElement) {
+        const parent = currChild.parentElement;
+        if (!parent.classList.contains('jwplayer') && !parent.classList.contains('jw-wrapper')) {
+          for (const sibling of Array.from(parent.children)) {
+            if (!(sibling instanceof HTMLElement) || sibling === currChild) continue;
+            sibling.style.setProperty('display', 'none', 'important');
+            sibling.style.setProperty('visibility', 'hidden', 'important');
+            sibling.style.setProperty('opacity', '0', 'important');
+            sibling.style.setProperty('pointer-events', 'none', 'important');
+            sibling.style.setProperty('width', '0', 'important');
+            sibling.style.setProperty('height', '0', 'important');
+          }
+        }
+        currChild = parent;
+      }
+    }
+  };
+
+  const isolateOnce = () => {
+    const root = firstMatch(rootSelectors);
+    const anchor = (root && firstMatchWithin(root, anchorSelectors)) || firstMatch(anchorSelectors);
+    if (!(anchor instanceof HTMLElement)) return false;
+
+    let toKeep = root;
+    if (!(toKeep instanceof HTMLElement)) {
+      for (const selector of containerSelectors) {
+        const candidate = anchor.closest(selector);
+        if (candidate instanceof HTMLElement && candidate !== document.body) {
+          toKeep = candidate;
+          break;
+        }
+      }
+    }
+    if (!(toKeep instanceof HTMLElement)) toKeep = anchor;
+
+    toKeep.style.setProperty('position', 'fixed', 'important');
+    toKeep.style.setProperty('inset', '0', 'important');
+    toKeep.style.setProperty('width', '100vw', 'important');
+    toKeep.style.setProperty('height', '100vh', 'important');
+    toKeep.style.setProperty('max-width', '100vw', 'important');
+    toKeep.style.setProperty('max-height', '100vh', 'important');
+    toKeep.style.setProperty('overflow', 'hidden', 'important');
+    toKeep.style.setProperty('background', '#000', 'important');
+    toKeep.style.setProperty('z-index', '2147483000', 'important');
+
+    stretch(anchor);
+    stretch(toKeep);
+    toKeep.querySelectorAll('video, iframe, .jwplayer, .jw-player-wrapper, .jw-holder, .jw-media, .jw-video, .video-js, .vjs-tech')
+          .forEach((el) => stretch(el));
+
+    document.documentElement.style.setProperty('overflow', 'hidden', 'important');
+    document.body.style.setProperty('overflow', 'hidden', 'important');
+    document.body.style.setProperty('background', '#000', 'important');
+
+    hideSiblingBranches(toKeep, anchor);
+    return true;
+  };
+
+  const hideOverlayAds = () => {
+    const collapse = (node) => {
+      if (!(node instanceof HTMLElement)) return;
+      node.style.setProperty('display', 'none', 'important');
+      node.style.setProperty('visibility', 'hidden', 'important');
+      node.style.setProperty('opacity', '0', 'important');
+      node.style.setProperty('width', '0', 'important');
+      node.style.setProperty('height', '0', 'important');
+      node.style.setProperty('pointer-events', 'none', 'important');
+    };
+
+    document.querySelectorAll('#avs-pause-ad, .avs-pause-ad, .avs-pause-ad-box, [id*="avs-pause" i], [class*="avs-pause" i]')
+            .forEach(collapse);
+    
+    document.querySelectorAll('[id*="adblock" i], [class*="adblock" i], [id*="anti-ad" i], [class*="anti-ad" i]')
+            .forEach(collapse);
+
+    document.querySelectorAll('.jwplayer, .jw-wrapper, .jw-media').forEach(el => {
+      el.style.setProperty('background', '#000', 'important');
+    });
+  };
+
+  let matchedCount = 0;
+  let attempts = 0;
+  const maxAttempts = 120;
+
+  const observer = new MutationObserver(() => {
+    if (isolateOnce()) matchedCount += 1;
+  });
+  observer.observe(document.documentElement, { childList: true, subtree: true });
+
+  const timer = window.setInterval(() => {
+    attempts += 1;
+    if (isolateOnce()) matchedCount += 1;
+    if (attempts >= maxAttempts || matchedCount >= 3) {
+      window.clearInterval(timer);
+      observer.disconnect();
+    }
+  }, 500);
+
+  let adHideTimer = null;
+  const startAdCleanupLoop = () => {
+    if (adHideTimer) return;
+    hideOverlayAds();
+    isolateOnce();
+    adHideTimer = window.setInterval(() => {
+      hideOverlayAds();
+      isolateOnce();
+    }, 1000);
+  };
+
+  window.setTimeout(startAdCleanupLoop, 2000);
+  isolateOnce();
+})();

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "nekostream",
+  "version": "2026.0.1",
+  "description": "Bettter version of NekoStream ",
+  "keywords": [
+    "anime",
+    "scraper",
+    "animevietsub",
+    "animetvn",
+    "anime47",
+    "nekostream",
+    "cli",
+    "video-player",
+    "streaming",
+    "vietsub",
+    "anime-cli"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "nekostream": "./bin/nekostream.js"
+  },
+  "scripts": {
+    "start": "tsx index.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "postinstall": "playwright install chromium"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "player-main.js",
+    "player.html",
+    "isolate.js",
+    "isolate.css"
+  ],
+  "dependencies": {
+    "@cliqz/adblocker-playwright": "^1.34.0",
+    "@ghostery/adblocker-playwright": "^2.17.1",
+    "@inquirer/prompts": "^8.4.2",
+    "artplayer": "^5.3.0",
+    "chalk": "^4.1.2",
+    "cheerio": "^1.2.0",
+    "cross-fetch": "^4.1.0",
+    "discord-rpc": "^4.0.1",
+    "electron": "^34.0.0",
+    "hls.js": "^1.6.0",
+    "ora": "^5.4.1",
+    "playwright": "^1.59.1",
+    "playwright-extra": "^4.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "tsx": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/discord-rpc": "^4.0.10",
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "eruda": "^3.4.3",
+    "typescript": "^5.0.0"
+  }
+}

package/player-main.js

@@ -0,0 +1,225 @@
+const { app, BrowserWindow, session, ipcMain } = require('electron')
+const path = require('path')
+
+let mainWindow = null
+
+function createWindow() {
+  const streamData = process.env.NEKOSTREAM_CLI_STREAM
+  if (!streamData) {
+    console.error('No stream data provided.')
+    app.quit()
+    return
+  }
+
+  const streamInfo = JSON.parse(Buffer.from(streamData, 'base64').toString('utf-8'))
+
+  mainWindow = new BrowserWindow({
+    width: 1280,
+    height: 720,
+    frame: false,
+    autoHideMenuBar: true,
+    backgroundColor: '#000000',
+    webPreferences: {
+      nodeIntegration: true,
+      contextIsolation: false,
+      webSecurity: false, // Required for some streams (CORS bypass)
+      webviewTag: true,
+      autoplayPolicy: 'no-user-gesture-required'
+    }
+  })
+
+  const playerSession = session.fromPartition('persist:player-session')
+  const sessions = [session.defaultSession, playerSession]
+
+  sessions.forEach(sess => {
+    // Network-level ad-blocking (like browser extensions)
+    sess.webRequest.onBeforeRequest({ urls: ['*://*/*'] }, (details, callback) => {
+      const url = details.url;
+      const lowerUrl = url.toLowerCase();
+
+      // ── Whitelist: never block requests originating FROM or loaded in an animevietsub tab ──
+      // AVS fetches probe URLs (googlesyndication, doubleclick, etc.) to detect adblock.
+      // If we cancel those probes, the site shows the "Phát hiện trình chặn quảng cáo" overlay.
+      // We must let these probes succeed so AVS thinks ads loaded normally.
+      const referer   = (details.referrer  || '').toLowerCase();
+      const initiator = (details.initiator || '').toLowerCase();
+      const fromAvs   = referer.includes('animevietsub') || initiator.includes('animevietsub') || lowerUrl.includes('animevietsub');
+
+      let isAvsTab = false;
+      try {
+        const { webContents } = require('electron');
+        const wc = webContents.fromId(details.webContentsId);
+        if (wc) {
+          const tabUrl = wc.getURL().toLowerCase();
+          if (tabUrl.includes('animevietsub')) {
+            isAvsTab = true;
+          }
+        }
+      } catch (e) {}
+
+      if (fromAvs || isAvsTab) {
+        return callback({ cancel: false });
+      }
+
+      const adKeywords = [
+        'in88', 'quayhu', 'nohu', 'bet188', '188bet', 'w88', 'fun88', 'm88', 'fb88',
+        'bk8', 'cmd368', 'letou', 'kyna', 'vwin', 'lixi88', 'loto188', 'kubet', 'ku-bet',
+        'thabet', 'tha-bet', 'ae888', 'fi88', '12bet', 'junk', 'popunder', 'pop-under',
+        'histats.com', 'clickadu', 'exoclick', 'juicyads', 'adsterra', 'yandex.ru',
+        'adskeeper', 'mgid.com', 'ad-maven', 'onclickads', 'propellerads', 'cloudflareinsights.com'
+      ];
+
+      const shouldBlock = adKeywords.some(keyword => lowerUrl.includes(keyword)) ||
+                          lowerUrl.includes('doubleclick.net') ||
+                          lowerUrl.includes('googleads') ||
+                          lowerUrl.includes('googlesyndication') ||
+                          (lowerUrl.includes('banner') && (lowerUrl.includes('casino') || lowerUrl.includes('tai-xiu') || lowerUrl.includes('keo-nha-cai')));
+
+      if (shouldBlock) {
+        return callback({ cancel: true });
+      }
+
+      return callback({ cancel: false });
+    });
+
+    // Strip Content-Security-Policy and X-Frame-Options to allow script injection (Eruda) and cross-origin iframe handling
+    sess.webRequest.onHeadersReceived({ urls: ['*://*/*'] }, (details, callback) => {
+      const responseHeaders = { ...details.responseHeaders }
+      for (const key of Object.keys(responseHeaders)) {
+        const lowerKey = key.toLowerCase()
+        if (
+          lowerKey === 'content-security-policy' ||
+          lowerKey === 'content-security-policy-report-only' ||
+          lowerKey === 'x-frame-options'
+        ) {
+          delete responseHeaders[key]
+        }
+      }
+      callback({ cancel: false, responseHeaders })
+    })
+
+    // Always inject Referer/Origin headers (needed for iframe streams like googleapiscdn)
+    if (streamInfo.headers) {
+      const filter = { urls: ['*://*/*'] }
+      sess.webRequest.onBeforeSendHeaders(filter, (details, callback) => {
+        const headers = { ...details.requestHeaders }
+        if (streamInfo.headers.Referer) headers['Referer'] = streamInfo.headers.Referer
+        if (streamInfo.headers.Origin) headers['Origin'] = streamInfo.headers.Origin
+        callback({ requestHeaders: headers })
+      })
+    }
+  })
+
+  // Load eruda script content securely in Node process
+  const fs = require('fs')
+  let erudaCode = ''
+  try {
+    const erudaPath = require.resolve('eruda/eruda.js')
+    erudaCode = fs.readFileSync(erudaPath, 'utf-8')
+  } catch (err) {
+    try {
+      const fallbackPath = path.join(__dirname, 'node_modules', 'eruda', 'eruda.js')
+      erudaCode = fs.readFileSync(fallbackPath, 'utf-8')
+    } catch (err2) {
+      console.error('[Main] Failed to load eruda:', err2)
+    }
+  }
+
+  mainWindow.webContents.on('did-finish-load', () => {
+    mainWindow?.webContents.executeJavaScript(`
+      window.initPlayer(${JSON.stringify(streamInfo)});
+    `)
+  })
+
+  // Listen for webview attachment, then watch all frames it creates.
+  // frame-created fires for EVERY frame (including dynamically injected iframes),
+  // and WebFrameMain.executeJavaScript() bypasses all cross-origin restrictions.
+  mainWindow.webContents.on('did-attach-webview', (event, guestWebContents) => {
+    guestWebContents.on('frame-created', (e, details) => {
+      const frame = details.frame
+
+      frame.once('dom-ready', () => {
+        const frameUrl = frame.url
+
+        const isPlayer = frameUrl.includes('googleapiscdn.com') || frameUrl.includes('googleapis.com')
+        if (!isPlayer) return
+
+        // Dump DOM once for diagnostic (reads the real elements so we can write precise selectors)
+        frame.executeJavaScript('document.documentElement.outerHTML')
+          .then(html => {
+            if (html && html.length > 200) {
+              require('fs').writeFileSync(
+                path.join(__dirname, 'dom-dump.html'), html, 'utf-8'
+              )
+            }
+          })
+          .catch(() => {})
+
+        // Inject ad-blocking CSS + DOM cleaner directly inside the player frame
+        frame.executeJavaScript(`
+          (function() {
+            // --- CSS block ---
+            const style = document.createElement('style');
+            style.id = '__neko_adblock__';
+            style.textContent = [
+              'img[src*="in88"],img[src*="quayhu"],img[src*="nohu"],',
+              'img[src*="188bet"],img[src*="kubet"],img[src*="w88"],img[src*="fun88"],',
+              '[class*="pause-ad"],[id*="pause-ad"],[class*="ads-pause"],[id*="ads-pause"],',
+              '[class*="overlay-ad"],[id*="overlay-ad"],[class*="popup-ad"],[id*="popup-ad"],',
+              '[class*="quangcao"],[id*="quangcao"],[class*="qc-"],[id*="qc-"] { display:none!important }'
+            ].join('');
+            (document.head || document.documentElement).appendChild(style);
+
+            // --- DOM cleaner ---
+            const AD_TEXTS = ['Đóng quảng cáo', 'Đóng và xem tiếp', 'Quảng cáo'];
+            const AD_SRCS  = ['in88', 'quayhu', 'nohu', '188bet', 'kubet', 'w88', 'fun88'];
+
+            const clean = () => {
+              try {
+                if (!document.body) return;
+                document.querySelectorAll('div,section,article,button,a,span,img').forEach(el => {
+                  const txt = (el.innerText || el.textContent || '').trim();
+                  const src = (el.src || el.getAttribute('src') || el.getAttribute('href') || '').toLowerCase();
+                  const isAdTxt = AD_TEXTS.some(t => txt === t || txt.startsWith(t));
+                  const isAdSrc = AD_SRCS.some(k => src.includes(k));
+                  if (!isAdTxt && !isAdSrc) return;
+
+                  // Walk up to find fixed/absolute overlay container
+                  let node = el;
+                  for (let i = 0; i < 10; i++) {
+                    const p = node.parentElement;
+                    if (!p || p === document.body || p === document.documentElement) break;
+                    if (p.querySelector('video') || p.querySelector('canvas')) break;
+                    const cs = getComputedStyle(p);
+                    if (cs.position === 'fixed' || cs.position === 'absolute') {
+                      p.remove(); return;
+                    }
+                    node = p;
+                  }
+                  el.remove();
+                });
+              } catch(e) {}
+            };
+
+            clean();
+            setInterval(clean, 250);
+          })();
+        `).catch(() => {})
+      })
+    })
+  })
+
+  mainWindow.loadFile(path.join(__dirname, 'player.html'))
+
+  mainWindow.on('closed', () => {
+    mainWindow = null
+  })
+}
+
+app.whenReady().then(createWindow)
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})