sneedium/main.js

// Modules to control application life and create native browser window
const {app, BrowserWindow, session, ipcMain, systemPreferences} = require('electron')
const path = require('path')
const fetch = require("cross-fetch")
const { ElectronChromeExtensions } = require('electron-chrome-extensions')
const { ElectronBlocker } = require('@ghostery/adblocker-electron');
const http = require('http');
const fs = require('fs');
const { createProxy } = require('proxy');
const buildChromeContextMenu = require('electron-chrome-context-menu').default
var extensions
var mic
var cam
app.on('web-contents-created', (event, webContents) => {
  webContents.on('context-menu', (e, params) => {
    const menu = buildChromeContextMenu({
      params,
      webContents,
      openLink: (url, disposition) => {
        webContents.loadURL(url)
      }
    })

    menu.popup()
  })
})


ipcMain.on('windowmaker', (event, arg) => {
  createWindow();
})

ipcMain.on('allowCam', (event, arg) => {
  mic = systemPreferences.askForMediaAccess('microphone');
  cam = systemPreferences.askForMediaAccess('camera');
})

const proxy = createProxy(http.createServer());
proxy.listen(3129)
//Function to enable AD Blocking...
let blocker = undefined
async function enableGoodies(s) {
  blocker = await ElectronBlocker.fromLists(fetch, [
    "https://github.com/uBlockOrigin/uAssets/raw/refs/heads/master/filters/ubol-filters.txt",
    'https://easylist.to/easylist/easylist.txt',
    'https://secure.fanboy.co.nz/fanboy-annoyance.txt',
    'https://easylist.to/easylist/easyprivacy.txt',
    'https://easylist-downloads.adblockplus.org/antiadblockfilters.txt',
    'https://raw.githubusercontent.com/hoshsadiq/adblock-nocoin-list/master/nocoin.txt',
    'https://cdn.jsdelivr.net/gh/hagezi/dns-blocklists@latest/adblock/pro.plus.txt',
    "https://github.com/yokoffing/filterlists/raw/refs/heads/main/youtube_clear_view.txt",
    "https://pgl.yoyo.org/as/serverlist.php?showintro=0;hostformat=adblock",
    "https://github.com/uBlockOrigin/uAssets/raw/refs/heads/master/filters/unbreak.txt",
    "https://github.com/uBlockOrigin/uAssets/raw/refs/heads/master/filters/quick-fixes.txt",
    "https://github.com/uBlockOrigin/uAssets/raw/refs/heads/master/filters/privacy.txt",
    "https://github.com/uBlockOrigin/uAssets/raw/refs/heads/master/filters/badware.txt",
    "https://github.com/uBlockOrigin/uAssets/raw/refs/heads/master/filters/filters.txt"
  ])
  blocker.enableBlockingInSession(s);
}

// 0.0.0.0 day fix
const locals = [
  '0.0.0.0', '127.0.0.1', '192.168', '.local', '.example', '.staging', 'fe80::', '::1'
];

// Function to check if a URL is restricted
function isLocal(url) {
  return locals.some(local => url.includes(local));
}

function createWindow () {
  try {
    extensions = new ElectronChromeExtensions()
  } catch {
    console.log("Creating a new window in the same extension session...")
  }
  const mainWindow = new BrowserWindow({
    width: 1220,
    height: 600,
    minWidth: 1220,
    minHeight: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      webviewTag: true,
      devTools: false,
      nodeIntegration: false,
      sandbox: true,
      contextIsolation: true
    }
  })

  const homePath = app.getPath('home');
  const extensionsDir = path.join(homePath, 'SneedExtensions');

  if (!fs.existsSync(extensionsDir)) {
    fs.mkdirSync(extensionsDir, { recursive: true });
  }

  const extensionFolders = fs.readdirSync(extensionsDir, { withFileTypes: true })
    .filter(dirent => dirent.isDirectory())
    .map(dirent => path.join(extensionsDir, dirent.name));

  for (const extensionPath of extensionFolders) {
    extensions.loadExtension(extensionPath);
  }

  extensions.addTab(mainWindow.webContents, mainWindow)
  mainWindow.setMinimumSize(1000, 300)

  
const toBlock = [
  "*://*.doubleclick.*",
  "*://s.innovid.com/*",
  "*://partner.googleadservices.com/*",
  "*://*.googlesyndication.com/*",
  "*://*.google-analytics.com/*",
  "*://creative.ak.fbcdn.net/*",
  "*://*.adbrite.com/*",
  "*://*.exponential.com/*",
  "*://*.quantserve.com/*",
  "*://*.scorecardresearch.com/*",
  "*://*.zedo.com/*",
  "*://*.a-ads.com/*",
  "*://*.777partner.com/*",
  "*://*.77tracking.com/*",
  "*://*.abc-ads.com/*",
  "*://*.aaxads.com/*",
  "*://*.adizio.com/*",
  "*://*.adjix.com/*",
  "*://*.adjug.com/*",
  "*://*.adjuggler.com/*",
  "*://*.trafficjunky.net/*",
  "*://*.trafficleader.com/*",
  "*://*.trafficrouter.io/*",
  "*://*.monerominer.rocks/*",
  "*://*.2mdn.net/*",
  "*.exe",
  "*.vbs",
  "*://*.googlesyndication.*",
  "*pixels*",
  "*telemetry*",
  "*analytics*",
  "*://ads.*.com*",
  "*ae/us/audience*",
  "*/api/v*/science*",
  "*/api/v*/typing*"
  ]
  
const regexPatterns = [
"r[0-100]+---sn-.*\.googlevideo\.com$/g",
"r[0-100]+-sn-.*\.googlevideo\.com$/g"
] 
  
  function containsAD(url) {
    var i;
    for (i = 0; i < toBlock.length; i++) {
        let regex = toBlock[i].replace(/\*/g, "[^ ]*");
        if (url.match(regex)) {
            return true;
        }
    }
    
    for (i = 0; i < regexPatterns.length; i++) {
        let regex = regexPatterns[i]
        if (url.match(regex)) {
            return true;
        }
    }

    return false;
  }

  session.defaultSession.setProxy({
    proxyRules: 'http=localhost:3129;https=localhost:3129',
    proxyBypassRules: '<local>'
  })

  session.defaultSession.webRequest.onBeforeRequest((details, callback) => {
    if (containsAD(details.url)) {
      return callback({cancel: true})
    }

    const url = new URL(details.url);
    const hostname = url.hostname;
    const isLocalDomain = isLocal(hostname);
    
    // Check if the request is to a local domain
    if (isLocalDomain) {
      // Check if the request is initiated by a remote domain
      const initiator = details.initiator ? new URL(details.initiator).hostname : '';
      const isInitiatorLocal = isLocal(initiator);
      
      if (initiator && !isInitiatorLocal) {
        console.log(`[W] Local domain is being accessed by external source (${initiator}), don't allow!`);
        callback({ cancel: true }); // Block request to local domains from remote sources
      } else {
        //console.log("Local domain is not being accessed by external source, allow..."); // debug
        callback({ cancel: false }); // Allow request
      }
    } else {
      //console.log("Request is not to a local domain, allow..."); //debug
      callback({ cancel: false }); // Allow non-local requests
    }
  })
  
  // and load the index.html of the app.
  mainWindow.loadFile('index.html')

  
  return mainWindow;
}

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.whenReady().then(() => {
  let x = createWindow()
  enableGoodies().then()
  app.on('activate', function () {
    // On macOS it's common to re-create a window in the app when the
    // dock icon is clicked and there are no other windows open.
    if (BrowserWindow.getAllWindows().length === 0) createWindow()
  })
})

// Quit when all windows are closed, except on macOS. There, it's common
// for applications and their menu bar to stay active until the user quits
// explicitly with Cmd + Q.
app.on('window-all-closed', function () {
  if (process.platform !== 'darwin') { app.quit() }
})


// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.

// Set DNS and enable mic/cam
app.on('ready', () => {
  app.configureHostResolver({
    mode: 'secure',
    dohServers: [
      'https://dns9.quad9.net/dns-query',
      'https://cloudflare-dns.com/dns-query'
    ]
  });
});