sneedium/main.js

// Modules to control application life and create native browser window
const {app, BrowserWindow, session, ipcMain, systemPreferences, dialog} = 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
const { installCrxExtension } = require('./crx-extractor');
var extensions
var mic
var cam

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

// Ensure extensions directory exists
if (!fs.existsSync(extensionsDir)) {
  fs.mkdirSync(extensionsDir, { recursive: true });
}

// IPC handlers for extension management
ipcMain.handle('get-extensions-list', async () => {
  try {
    const extensionFolders = fs.readdirSync(extensionsDir, { withFileTypes: true })
      .filter(dirent => dirent.isDirectory())
      .map(dirent => {
        const extPath = path.join(extensionsDir, dirent.name);
        let manifest = {};
        try {
          const manifestPath = path.join(extPath, 'manifest.json');
          if (fs.existsSync(manifestPath)) {
            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
          }
        } catch (e) {
          console.error(`Error reading manifest for extension ${dirent.name}:`, e);
        }
        return {
          id: dirent.name,
          name: manifest.name || dirent.name,
          version: manifest.version || 'unknown',
          description: manifest.description || '',
          path: extPath
        };
      });
    return extensionFolders;
  } catch (error) {
    console.error('Error getting extensions list:', error);
    return [];
  }
});

ipcMain.handle('install-extension', async (event, crxPath) => {
  try {
    // If no path provided, open dialog to select CRX file
    if (!crxPath) {
      const result = await dialog.showOpenDialog({
        properties: ['openFile'],
        filters: [{ name: 'Chrome Extension', extensions: ['crx'] }]
      });
      
      if (result.canceled || result.filePaths.length === 0) {
        return { success: false, message: 'No file selected' };
      }
      
      crxPath = result.filePaths[0];
    }
    
    // Use the CRX extractor to install the extension
    const installResult = await installCrxExtension(crxPath, extensionsDir);
    
    // If installation was successful, reload the extension
    if (installResult.success && extensions) {
      try {
        const loadResult = extensions.loadExtension(path.join(extensionsDir, installResult.extensionId));
        console.log(`Loaded extension ${installResult.extensionId}:`, loadResult);
      } catch (loadError) {
        console.error(`Error loading extension ${installResult.extensionId}:`, loadError);
      }
    }
    
    return installResult;
  } catch (error) {
    console.error('Error installing extension:', error);
    return { success: false, message: error.message };
  }
});

ipcMain.handle('remove-extension', async (event, extensionId) => {
  try {
    const extensionPath = path.join(extensionsDir, extensionId);
    if (fs.existsSync(extensionPath)) {
      fs.rmSync(extensionPath, { recursive: true, force: true });
      return { success: true };
    } else {
      return { success: false, message: 'Extension not found' };
    }
  } catch (error) {
    console.error('Error removing extension:', error);
    return { success: false, message: error.message };
  }
});

// Handle opening extension management page
ipcMain.on('open-extensions-page', (event) => {
  createExtensionsWindow();
});

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()
  })
})

// Create an extensions management window
function createExtensionsWindow() {
  const extensionsWindow = new BrowserWindow({
    width: 800,
    height: 600,
    title: 'Extension Manager',
    webPreferences: {
      preload: path.join(__dirname, 'extensions-preload.js'),
      nodeIntegration: false,
      contextIsolation: true
    }
  });

  extensionsWindow.loadFile('extensions.html');
  extensionsWindow.setMenuBarVisibility(false);
}

// Original IPC handlers
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) {
  try {
    if (!s) {
      console.log("No session provided to enableGoodies, using default session");
      s = session.defaultSession;
    }
    
    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);
    console.log("AD blocking enabled successfully");
  } catch (error) {
    console.error("Error enabling AD blocking:", error);
  }
}

// 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 {
    // Initialize extensions once if not already initialized
    if (!extensions) {
      extensions = new ElectronChromeExtensions({
        // Specify extension session
        session: session.defaultSession,
        // Set to true to enable background pages for extensions
        createBackgroundPages: true
      });
    }
  } catch (error) {
    console.error("Error initializing extensions:", error);
  }

  const mainWindow = new BrowserWindow({
    width: 1220,
    height: 600,
    minWidth: 1220,
    minHeight: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      webviewTag: true,
      // Enable devTools for development
      devTools: process.env.NODE_ENV === 'development',
      nodeIntegration: false,
      sandbox: true,
      contextIsolation: true,
      // Enable Chrome extension support
      additionalArguments: ['--enable-features=ExtensionsToolbarMenu'],
      // Allow access to chrome:// URLs for extensions
      allowRunningInsecureContent: false,
      webSecurity: true
    }
  })

  // Load installed extensions
  loadExtensions(extensions);

  // Register window with extensions system
  if (extensions) {
    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;
}

// Function to load all extensions from the extensions directory
function loadExtensions(extensionsInstance) {
  if (!extensionsInstance) return;

  try {
    // Get list of extension directories
    const extensionFolders = fs.readdirSync(extensionsDir, { withFileTypes: true })
      .filter(dirent => dirent.isDirectory())
      .map(dirent => path.join(extensionsDir, dirent.name));

    // Load each extension
    for (const extensionPath of extensionFolders) {
      try {
        if (fs.existsSync(path.join(extensionPath, 'manifest.json'))) {
          const loadResult = extensionsInstance.loadExtension(extensionPath);
          console.log(`Loaded extension from ${extensionPath}`, loadResult);
        } else {
          console.warn(`Missing manifest.json in extension directory: ${extensionPath}`);
        }
      } catch (extError) {
        console.error(`Failed to load extension at ${extensionPath}:`, extError);
      }
    }
  } catch (error) {
    console.error('Error loading extensions:', error);
  }
}

// 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(session.defaultSession).then(() => {
    console.log("Goodies enabled");
  }).catch(error => {
    console.error("Error enabling goodies:", error);
  });
  
  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'
    ]
  });
});