atlas-browser 0.2.0

package/src/main/blocker.ts

@@ -0,0 +1,121 @@
+import { Session } from 'electron';
+
+// Common tracker/ad domains to block
+const BLOCKED_DOMAINS = new Set([
+  // Ad networks
+  'doubleclick.net', 'googlesyndication.com', 'googleadservices.com',
+  'google-analytics.com', 'googletagmanager.com', 'googletagservices.com',
+  'adservice.google.com', 'pagead2.googlesyndication.com',
+  'ads.facebook.com', 'pixel.facebook.com', 'connect.facebook.net',
+  'ad.doubleclick.net', 'adnxs.com', 'adsrvr.org',
+  'amazon-adsystem.com', 'ads-twitter.com',
+  'advertising.com', 'criteo.com', 'criteo.net',
+  'outbrain.com', 'taboola.com', 'revcontent.com',
+  // Trackers
+  'hotjar.com', 'fullstory.com', 'mouseflow.com',
+  'mixpanel.com', 'amplitude.com', 'segment.com', 'segment.io',
+  'optimizely.com', 'crazyegg.com', 'clicktale.net',
+  'newrelic.com', 'nr-data.net', 'pingdom.net',
+  'quantserve.com', 'scorecardresearch.com', 'imrworldwide.com',
+  'comscore.com', 'chartbeat.com', 'parsely.com',
+  // Social trackers
+  'platform.twitter.com', 'syndication.twitter.com',
+  'platform.linkedin.com', 'snap.licdn.com',
+  'static.ads-twitter.com',
+  // Fingerprinting
+  'fingerprintjs.com', 'cdn.jsdelivr.net/npm/@aspect',
+  // Misc trackers
+  'tracking.', 'analytics.', 'telemetry.',
+  'sentry.io', 'bugsnag.com',
+]);
+
+// URL patterns to block
+const BLOCKED_PATTERNS = [
+  /\/ads\//i,
+  /\/tracking\//i,
+  /\/analytics\//i,
+  /\/pixel\//i,
+  /google-analytics/i,
+  /facebook.*pixel/i,
+  /doubleclick/i,
+  /\.gif\?.*utm_/i,
+  /__utm\.gif/i,
+  /beacon\./i,
+];
+
+type BlockCallback = () => void;
+
+export class Blocker {
+  private callbacks: Map<number, BlockCallback[]> = new Map();
+  private totalBlocked: number = 0;
+  private isEnabled: boolean = true;
+
+  setup(session: Session): void {
+    session.webRequest.onBeforeRequest((details, callback) => {
+      if (!this.isEnabled) {
+        callback({});
+        return;
+      }
+
+      const shouldBlock = this.shouldBlock(details.url);
+
+      if (shouldBlock) {
+        this.totalBlocked++;
+
+        // Notify tab-specific callbacks
+        const tabCallbacks = details.webContentsId != null ? this.callbacks.get(details.webContentsId) : undefined;
+        if (tabCallbacks) {
+          tabCallbacks.forEach(cb => cb());
+        }
+
+        callback({ cancel: true });
+      } else {
+        callback({});
+      }
+    });
+  }
+
+  private shouldBlock(url: string): boolean {
+    try {
+      const parsed = new URL(url);
+      const hostname = parsed.hostname;
+
+      // Check against blocked domains
+      for (const domain of BLOCKED_DOMAINS) {
+        if (hostname === domain || hostname.endsWith('.' + domain)) {
+          return true;
+        }
+      }
+
+      // Check URL patterns
+      for (const pattern of BLOCKED_PATTERNS) {
+        if (pattern.test(url)) {
+          return true;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  onBlocked(webContentsId: number, callback: BlockCallback): void {
+    const existing = this.callbacks.get(webContentsId) || [];
+    existing.push(callback);
+    this.callbacks.set(webContentsId, existing);
+  }
+
+  toggle(): boolean {
+    this.isEnabled = !this.isEnabled;
+    return this.isEnabled;
+  }
+
+  get enabled(): boolean {
+    return this.isEnabled;
+  }
+
+  get blockedTotal(): number {
+    return this.totalBlocked;
+  }
+}

package/src/main/bookmark-manager.ts

@@ -0,0 +1,99 @@
+import { app } from 'electron';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface Bookmark {
+  id: string;
+  title: string;
+  url: string;
+  favicon: string;
+  folder: string;
+  createdAt: number;
+}
+
+const STORE_PATH = path.join(app.getPath('userData'), 'bookmarks.json');
+
+function readStore(): Bookmark[] {
+  try { return JSON.parse(fs.readFileSync(STORE_PATH, 'utf8')); } catch { return []; }
+}
+
+function writeStore(data: Bookmark[]): void {
+  fs.writeFileSync(STORE_PATH, JSON.stringify(data, null, 2));
+}
+
+export class BookmarkManager {
+  getAll(): Bookmark[] {
+    return readStore();
+  }
+
+  getByFolder(folder: string): Bookmark[] {
+    return this.getAll().filter(b => b.folder === folder);
+  }
+
+  getBarBookmarks(): Bookmark[] {
+    return this.getByFolder('bar');
+  }
+
+  add(title: string, url: string, favicon: string = '', folder: string = 'bar'): Bookmark {
+    const bookmark: Bookmark = {
+      id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+      title,
+      url,
+      favicon,
+      folder,
+      createdAt: Date.now(),
+    };
+    const all = this.getAll();
+    all.push(bookmark);
+    writeStore(all);
+    return bookmark;
+  }
+
+  remove(id: string): boolean {
+    const all = this.getAll();
+    const filtered = all.filter(b => b.id !== id);
+    if (filtered.length === all.length) return false;
+    writeStore(filtered);
+    return true;
+  }
+
+  update(id: string, updates: Partial<Bookmark>): boolean {
+    const all = this.getAll();
+    const idx = all.findIndex(b => b.id === id);
+    if (idx < 0) return false;
+    all[idx] = { ...all[idx], ...updates };
+    writeStore(all);
+    return true;
+  }
+
+  isBookmarked(url: string): boolean {
+    return this.getAll().some(b => b.url === url);
+  }
+
+  findByUrl(url: string): Bookmark | undefined {
+    return this.getAll().find(b => b.url === url);
+  }
+
+  getFolders(): string[] {
+    const folders = new Set(this.getAll().map(b => b.folder));
+    return Array.from(folders);
+  }
+
+  exportAll(): string {
+    return JSON.stringify(this.getAll(), null, 2);
+  }
+
+  importAll(json: string): number {
+    const imported: Bookmark[] = JSON.parse(json);
+    const all = this.getAll();
+    let count = 0;
+    for (const bm of imported) {
+      if (!all.some(b => b.url === bm.url)) {
+        all.push({ ...bm, id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6) });
+        count++;
+      }
+    }
+    writeStore(all);
+    return count;
+  }
+}

package/src/main/download-manager.ts

@@ -0,0 +1,103 @@
+import { Session, DownloadItem, BrowserWindow } from 'electron';
+import * as path from 'path';
+import * as fs from 'fs';
+import { app } from 'electron';
+
+export interface DownloadRecord {
+  id: string;
+  filename: string;
+  url: string;
+  savePath: string;
+  totalBytes: number;
+  receivedBytes: number;
+  state: 'progressing' | 'completed' | 'cancelled' | 'interrupted';
+  startTime: number;
+}
+
+const STORE_PATH = path.join(app.getPath('userData'), 'downloads.json');
+function readDL(): DownloadRecord[] { try { return JSON.parse(fs.readFileSync(STORE_PATH, 'utf8')); } catch { return []; } }
+function writeDL(d: DownloadRecord[]): void { fs.writeFileSync(STORE_PATH, JSON.stringify(d, null, 2)); }
+
+export class DownloadManager {
+  private activeDownloads: Map<string, DownloadItem> = new Map();
+  private window: BrowserWindow;
+
+  constructor(window: BrowserWindow) {
+    this.window = window;
+  }
+
+  setup(session: Session): void {
+    session.on('will-download', (_event, item, _webContents) => {
+      const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+      const filename = item.getFilename();
+      const savePath = path.join(app.getPath('downloads'), filename);
+      item.setSavePath(savePath);
+
+      this.activeDownloads.set(id, item);
+
+      const record: DownloadRecord = {
+        id,
+        filename,
+        url: item.getURL(),
+        savePath,
+        totalBytes: item.getTotalBytes(),
+        receivedBytes: 0,
+        state: 'progressing',
+        startTime: Date.now(),
+      };
+
+      // Save to history
+      const all = readDL();
+      all.unshift(record);
+      writeDL(all);
+
+      // Notify renderer
+      this.window.webContents.send('download-started', record);
+
+      item.on('updated', (_e, state) => {
+        record.receivedBytes = item.getReceivedBytes();
+        record.totalBytes = item.getTotalBytes();
+        record.state = state === 'progressing' ? 'progressing' : 'interrupted';
+        this.updateRecord(record);
+        this.window.webContents.send('download-progress', record);
+      });
+
+      item.once('done', (_e, state) => {
+        record.receivedBytes = item.getReceivedBytes();
+        record.state = state === 'completed' ? 'completed' : 'cancelled';
+        this.updateRecord(record);
+        this.activeDownloads.delete(id);
+        this.window.webContents.send('download-done', record);
+      });
+    });
+  }
+
+  getHistory(): DownloadRecord[] {
+    return readDL();
+  }
+
+  clearHistory(): void {
+    writeDL([]);
+  }
+
+  pause(id: string): void {
+    this.activeDownloads.get(id)?.pause();
+  }
+
+  resume(id: string): void {
+    this.activeDownloads.get(id)?.resume();
+  }
+
+  cancel(id: string): void {
+    this.activeDownloads.get(id)?.cancel();
+  }
+
+  private updateRecord(record: DownloadRecord): void {
+    const all = readDL();
+    const idx = all.findIndex(d => d.id === record.id);
+    if (idx >= 0) {
+      all[idx] = record;
+      writeDL(all);
+    }
+  }
+}

package/src/main/index.ts

@@ -0,0 +1,93 @@
+import { app, BrowserWindow, session } from 'electron';
+import * as path from 'path';
+import { TabManager } from './tab-manager';
+import { Blocker } from './blocker';
+import { SecurityAnalyzer } from './security-analyzer';
+import { TorManager } from './tor-manager';
+import { BookmarkManager } from './bookmark-manager';
+import { DownloadManager } from './download-manager';
+import { SettingsManager } from './settings-manager';
+import { setupMenu } from './menu';
+import { setupIpcHandlers } from './ipc-handlers';
+
+const settingsManager = new SettingsManager();
+const SEARCH_ANGEL_URL = settingsManager.get('homepage');
+
+let mainWindow: BrowserWindow | null = null;
+let tabManager: TabManager | null = null;
+let blocker: Blocker | null = null;
+let securityAnalyzer: SecurityAnalyzer | null = null;
+let torManager: TorManager | null = null;
+let bookmarkManager: BookmarkManager | null = null;
+let downloadManager: DownloadManager | null = null;
+
+function createWindow(): void {
+  mainWindow = new BrowserWindow({
+    width: 1400,
+    height: 900,
+    minWidth: 800,
+    minHeight: 600,
+    title: 'Atlas Browser',
+    titleBarStyle: 'hiddenInset',
+    trafficLightPosition: { x: 12, y: 12 },
+    backgroundColor: '#0a0a0f',
+    webPreferences: {
+      preload: path.join(__dirname, '..', 'preload', 'preload.js'),
+      nodeIntegration: false,
+      contextIsolation: true,
+      sandbox: false,
+    },
+  });
+
+  mainWindow.loadFile(path.join(__dirname, '..', '..', 'src', 'renderer', 'index.html'));
+
+  // Initialize all components
+  blocker = new Blocker();
+  securityAnalyzer = new SecurityAnalyzer();
+  torManager = new TorManager();
+  bookmarkManager = new BookmarkManager();
+  downloadManager = new DownloadManager(mainWindow);
+  tabManager = new TabManager(mainWindow, SEARCH_ANGEL_URL, blocker, securityAnalyzer);
+
+  // Setup
+  setupIpcHandlers(mainWindow, tabManager, blocker, securityAnalyzer, torManager, bookmarkManager, downloadManager, settingsManager);
+  setupMenu(mainWindow, tabManager);
+  blocker.setup(session.defaultSession);
+  downloadManager.setup(session.defaultSession);
+
+  // First tab
+  mainWindow.webContents.once('did-finish-load', () => {
+    tabManager!.createTab(SEARCH_ANGEL_URL);
+  });
+
+  mainWindow.on('closed', () => {
+    mainWindow = null;
+    tabManager = null;
+  });
+}
+
+// Privacy flags
+app.commandLine.appendSwitch('disable-features', 'SpareRendererForSitePerProcess');
+app.commandLine.appendSwitch('disable-client-side-phishing-detection');
+app.commandLine.appendSwitch('disable-component-update');
+
+app.whenReady().then(() => {
+  session.defaultSession.setUserAgent(
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
+  );
+  session.defaultSession.cookies.flushStore();
+  createWindow();
+});
+
+app.on('window-all-closed', () => {
+  if (settingsManager.get('clearDataOnExit')) {
+    session.defaultSession.clearStorageData({
+      storages: ['cookies', 'localstorage', 'cachestorage'],
+    });
+  }
+  app.quit();
+});
+
+app.on('activate', () => {
+  if (BrowserWindow.getAllWindows().length === 0) createWindow();
+});

package/src/main/ipc-handlers.ts

@@ -0,0 +1,283 @@
+import { ipcMain, BrowserWindow, shell, app } from 'electron';
+import * as path from 'path';
+import * as fs from 'fs';
+import { TabManager } from './tab-manager';
+import { Blocker } from './blocker';
+import { SecurityAnalyzer } from './security-analyzer';
+import { TorManager } from './tor-manager';
+import { BookmarkManager } from './bookmark-manager';
+import { DownloadManager } from './download-manager';
+import { SettingsManager } from './settings-manager';
+
+// ── History Storage ─────────────────────────────────────────
+interface HistoryItem {
+  id: string;
+  title: string;
+  url: string;
+  timestamp: number;
+}
+
+function getHistoryPath(): string {
+  try { return path.join(app.getPath('userData'), 'history.json'); }
+  catch { return '/tmp/atlas-browser-history.json'; }
+}
+
+function readHistory(): HistoryItem[] {
+  try { return JSON.parse(fs.readFileSync(getHistoryPath(), 'utf8')); }
+  catch { return []; }
+}
+
+function writeHistory(items: HistoryItem[]): void {
+  try { fs.writeFileSync(getHistoryPath(), JSON.stringify(items, null, 2)); }
+  catch { /* ignore */ }
+}
+
+export function addHistoryItem(title: string, url: string): void {
+  if (url.startsWith('file://') || url === 'about:blank') return;
+  const items = readHistory();
+  items.unshift({
+    id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+    title,
+    url,
+    timestamp: Date.now(),
+  });
+  // Keep last 1000 entries
+  writeHistory(items.slice(0, 1000));
+}
+
+let sidebarOpen = false;
+const SIDEBAR_WIDTH = 300;
+const BOOKMARKS_BAR_HEIGHT = 28;
+
+export function setupIpcHandlers(
+  window: BrowserWindow,
+  tabManager: TabManager,
+  blocker: Blocker,
+  security: SecurityAnalyzer,
+  torManager: TorManager,
+  bookmarks: BookmarkManager,
+  downloads: DownloadManager,
+  settings: SettingsManager
+): void {
+  // ── Tab management ────────────────────────────────────────
+  ipcMain.on('new-tab', (_e, url?: string) => tabManager.createTab(url));
+  ipcMain.on('close-tab', (_e, tabId: number) => tabManager.closeTab(tabId));
+  ipcMain.on('switch-tab', (_e, tabId: number) => tabManager.switchTab(tabId));
+
+  // ── Navigation ────────────────────────────────────────────
+  ipcMain.on('navigate', (_e, url: string) => tabManager.navigateTo(url));
+  ipcMain.on('go-back', () => tabManager.goBack());
+  ipcMain.on('go-forward', () => tabManager.goForward());
+  ipcMain.on('reload', () => tabManager.reload());
+  ipcMain.on('go-home', () => tabManager.goHome());
+
+  // ── Internal pages ────────────────────────────────────────
+  ipcMain.on('open-page', (_e, page: string) => {
+    const pagePath = path.join(__dirname, '..', '..', 'src', 'renderer', `${page}.html`);
+    tabManager.createTab(`file://${pagePath}`);
+  });
+
+  // ── Blocker ───────────────────────────────────────────────
+  ipcMain.handle('toggle-blocker', () => blocker.toggle());
+  ipcMain.handle('get-blocker-stats', () => ({
+    enabled: blocker.enabled,
+    totalBlocked: blocker.blockedTotal,
+  }));
+
+  // ── Tor ───────────────────────────────────────────────────
+  ipcMain.handle('toggle-tor', async () => {
+    const enabled = await torManager.toggle();
+    window.webContents.send('tor-status-changed', enabled);
+    const tab = tabManager.getActiveTab();
+    if (tab) tab.view.webContents.reload();
+    return enabled;
+  });
+  ipcMain.handle('get-tor-status', () => ({ enabled: torManager.enabled }));
+  ipcMain.handle('get-tor-circuit', async () => torManager.getCircuitInfo());
+
+  // ── Sidebar ───────────────────────────────────────────────
+  ipcMain.on('toggle-sidebar', () => {
+    sidebarOpen = !sidebarOpen;
+    resizeBrowserView();
+    window.webContents.send('sidebar-toggled', sidebarOpen);
+  });
+
+  // ── Security ──────────────────────────────────────────────
+  ipcMain.handle('get-security-info', async () => {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return null;
+    return security.analyze(tab.view.webContents, tab.url);
+  });
+
+  // ── Tabs ──────────────────────────────────────────────────
+  ipcMain.handle('get-tabs', () => tabManager.getAllTabs());
+
+  // ── Bookmarks ─────────────────────────────────────────────
+  ipcMain.handle('get-bookmarks', () => bookmarks.getAll());
+  ipcMain.handle('get-bar-bookmarks', () => bookmarks.getBarBookmarks());
+  ipcMain.handle('add-bookmark', (_e, title: string, url: string, favicon: string) => {
+    return bookmarks.add(title, url, favicon);
+  });
+  ipcMain.handle('remove-bookmark', (_e, id: string) => bookmarks.remove(id));
+  ipcMain.handle('is-bookmarked', (_e, url: string) => bookmarks.isBookmarked(url));
+  ipcMain.handle('toggle-bookmark', (_e, title: string, url: string) => {
+    const existing = bookmarks.findByUrl(url);
+    if (existing) {
+      bookmarks.remove(existing.id);
+      return false;
+    } else {
+      bookmarks.add(title, url);
+      return true;
+    }
+  });
+
+  // ── Downloads ─────────────────────────────────────────────
+  ipcMain.handle('get-downloads', () => downloads.getHistory());
+  ipcMain.handle('clear-downloads', () => {
+    downloads.clearHistory();
+    return true;
+  });
+  ipcMain.on('open-download', (_e, filePath: string) => {
+    shell.openPath(filePath);
+  });
+  ipcMain.on('show-download', (_e, filePath: string) => {
+    shell.showItemInFolder(filePath);
+  });
+
+  // ── Settings ──────────────────────────────────────────────
+  ipcMain.handle('get-settings', () => settings.getAll());
+  ipcMain.handle('set-setting', (_e, key: string, value: any) => {
+    settings.set(key as any, value);
+    return settings.getAll();
+  });
+  ipcMain.handle('reset-settings', () => {
+    settings.reset();
+    return settings.getAll();
+  });
+
+  // ── Zoom ──────────────────────────────────────────────────
+  ipcMain.handle('zoom-in', () => {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return 100;
+    const level = tab.view.webContents.getZoomFactor();
+    const newLevel = Math.min(level + 0.1, 3.0);
+    tab.view.webContents.setZoomFactor(newLevel);
+    return Math.round(newLevel * 100);
+  });
+  ipcMain.handle('zoom-out', () => {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return 100;
+    const level = tab.view.webContents.getZoomFactor();
+    const newLevel = Math.max(level - 0.1, 0.3);
+    tab.view.webContents.setZoomFactor(newLevel);
+    return Math.round(newLevel * 100);
+  });
+  ipcMain.handle('zoom-reset', () => {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return 100;
+    tab.view.webContents.setZoomFactor(1.0);
+    return 100;
+  });
+  ipcMain.handle('get-zoom', () => {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return 100;
+    return Math.round(tab.view.webContents.getZoomFactor() * 100);
+  });
+
+  // ── History ────────────────────────────────────────────────
+  ipcMain.handle('get-history', () => readHistory());
+  ipcMain.handle('clear-history', () => { writeHistory([]); return true; });
+  ipcMain.handle('delete-history-item', (_e, id: string) => {
+    const items = readHistory().filter(i => i.id !== id);
+    writeHistory(items);
+    return true;
+  });
+
+  // Track page visits for history
+  // Note: called from tab-manager on did-navigate
+  ipcMain.on('add-history', (_e, title: string, url: string) => {
+    addHistoryItem(title, url);
+  });
+
+  // ── Phantom Mode (ephemeral Docker containers) ────────────
+  const PHANTOM_API = 'http://128.140.66.108:8080/api/v1/phantom';
+  const http = require('http');
+
+  ipcMain.handle('phantom-start', async () => {
+    const fetch = (await import('node:https')).default || require('http');
+    return new Promise((resolve, reject) => {
+      const req = http.request(`${PHANTOM_API}/start`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+      }, (res: any) => {
+        let data = '';
+        res.on('data', (chunk: string) => data += chunk);
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); }
+          catch { reject(new Error(data)); }
+        });
+      });
+      req.on('error', reject);
+      req.end();
+    });
+  });
+
+  ipcMain.handle('phantom-end', async (_e, sessionId: string) => {
+    return new Promise((resolve, reject) => {
+      const req = http.request(`${PHANTOM_API}/end/${sessionId}`, {
+        method: 'DELETE',
+      }, (res: any) => {
+        let data = '';
+        res.on('data', (chunk: string) => data += chunk);
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); }
+          catch { resolve({ status: 'destroyed' }); }
+        });
+      });
+      req.on('error', reject);
+      req.end();
+    });
+  });
+
+  ipcMain.handle('phantom-status', async (_e, sessionId: string) => {
+    return new Promise((resolve, reject) => {
+      http.get(`${PHANTOM_API}/status/${sessionId}`, (res: any) => {
+        let data = '';
+        res.on('data', (chunk: string) => data += chunk);
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); }
+          catch { resolve(null); }
+        });
+      }).on('error', reject);
+    });
+  });
+
+  // ── DNS lookup (for Internet Map) ─────────────────────────
+  ipcMain.handle('dns-lookup', async (_e, domain: string) => {
+    const dns = require('dns').promises;
+    try {
+      const addresses = await dns.resolve4(domain);
+      return { domain, addresses, error: null };
+    } catch (err: any) {
+      return { domain, addresses: [], error: err.message };
+    }
+  });
+
+  // ── Window resize ─────────────────────────────────────────
+  window.on('resize', () => resizeBrowserView());
+
+  function resizeBrowserView() {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return;
+    const bounds = window.getBounds();
+    const showBar = settings.get('showBookmarksBar');
+    const chromeH = 82 + (showBar ? BOOKMARKS_BAR_HEIGHT : 0);
+    const sidebarW = sidebarOpen ? SIDEBAR_WIDTH : 0;
+    tab.view.setBounds({
+      x: 0,
+      y: chromeH,
+      width: bounds.width - sidebarW,
+      height: bounds.height - chromeH,
+    });
+  }
+}