@mseep/anything-analyzer 3.6.50

package/src/main/fingerprint/presets.ts

@@ -0,0 +1,173 @@
+/**
+ * Preset device configurations for fingerprint generation.
+ * Each preset is a logically consistent combination of platform, screen, GPU, etc.
+ */
+
+export interface DevicePreset {
+  platform: string;
+  oscpu: string;
+  screens: [number, number][];
+  dprs: number[];
+  webglVendors: string[];
+  webglRenderers: string[];
+  hardwareConcurrencies: number[];
+  deviceMemories: number[];
+  colorDepth: number;
+}
+
+/** Chrome version whitelist — 5 most recent stable versions */
+export const CHROME_VERSIONS = [
+  '131.0.0.0',
+  '130.0.0.0',
+  '129.0.0.0',
+  '128.0.0.0',
+  '127.0.0.0',
+] as const;
+
+export const WINDOWS_PRESETS: DevicePreset[] = [
+  {
+    platform: 'Win32',
+    oscpu: 'Windows NT 10.0; Win64; x64',
+    screens: [[1920, 1080], [2560, 1440], [1366, 768], [1536, 864]],
+    dprs: [1, 1.25, 1.5],
+    webglVendors: ['Google Inc. (NVIDIA)'],
+    webglRenderers: [
+      'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+      'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 SUPER Direct3D11 vs_5_0 ps_5_0, D3D11)',
+      'ANGLE (NVIDIA, NVIDIA GeForce RTX 4060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+    ],
+    hardwareConcurrencies: [4, 8, 12, 16],
+    deviceMemories: [8, 16, 32],
+    colorDepth: 24,
+  },
+  {
+    platform: 'Win32',
+    oscpu: 'Windows NT 10.0; Win64; x64',
+    screens: [[1920, 1080], [2560, 1440]],
+    dprs: [1, 1.25],
+    webglVendors: ['Google Inc. (Intel)'],
+    webglRenderers: [
+      'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+      'ANGLE (Intel, Intel(R) UHD Graphics 770 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+    ],
+    hardwareConcurrencies: [4, 8, 12],
+    deviceMemories: [8, 16],
+    colorDepth: 24,
+  },
+  {
+    platform: 'Win32',
+    oscpu: 'Windows NT 10.0; Win64; x64',
+    screens: [[1920, 1080], [2560, 1440], [3440, 1440]],
+    dprs: [1, 1.25, 1.5],
+    webglVendors: ['Google Inc. (AMD)'],
+    webglRenderers: [
+      'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)',
+      'ANGLE (AMD, AMD Radeon RX 580 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+    ],
+    hardwareConcurrencies: [8, 12, 16],
+    deviceMemories: [16, 32],
+    colorDepth: 24,
+  },
+];
+
+export const MACOS_PRESETS: DevicePreset[] = [
+  {
+    platform: 'MacIntel',
+    oscpu: 'Intel Mac OS X 10_15_7',
+    screens: [[1440, 900], [1680, 1050], [2560, 1600]],
+    dprs: [2],
+    webglVendors: ['Google Inc. (Apple)'],
+    webglRenderers: [
+      'ANGLE (Apple, Apple M1, OpenGL 4.1)',
+      'ANGLE (Apple, Apple M2, OpenGL 4.1)',
+      'ANGLE (Apple, Apple M3, OpenGL 4.1)',
+    ],
+    hardwareConcurrencies: [8, 10, 12],
+    deviceMemories: [8, 16],
+    colorDepth: 30,
+  },
+  {
+    platform: 'MacIntel',
+    oscpu: 'Intel Mac OS X 10_15_7',
+    screens: [[1440, 900], [1680, 1050]],
+    dprs: [2],
+    webglVendors: ['Google Inc. (Intel)'],
+    webglRenderers: [
+      'ANGLE (Intel, Intel(R) Iris Plus Graphics 645, OpenGL 4.1)',
+      'ANGLE (Intel, Intel(R) Iris Plus Graphics, OpenGL 4.1)',
+    ],
+    hardwareConcurrencies: [4, 8],
+    deviceMemories: [8, 16],
+    colorDepth: 24,
+  },
+];
+
+export const LINUX_PRESETS: DevicePreset[] = [
+  {
+    platform: 'Linux x86_64',
+    oscpu: 'Linux x86_64',
+    screens: [[1920, 1080], [2560, 1440]],
+    dprs: [1],
+    webglVendors: ['Google Inc. (NVIDIA)'],
+    webglRenderers: [
+      'ANGLE (NVIDIA, NVIDIA GeForce GTX 1080 Ti, OpenGL 4.5)',
+      'ANGLE (NVIDIA, NVIDIA GeForce RTX 3070, OpenGL 4.5)',
+    ],
+    hardwareConcurrencies: [8, 12, 16],
+    deviceMemories: [16, 32],
+    colorDepth: 24,
+  },
+  {
+    platform: 'Linux x86_64',
+    oscpu: 'Linux x86_64',
+    screens: [[1920, 1080]],
+    dprs: [1],
+    webglVendors: ['Google Inc. (Intel)'],
+    webglRenderers: [
+      'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.5)',
+    ],
+    hardwareConcurrencies: [4, 8],
+    deviceMemories: [8, 16],
+    colorDepth: 24,
+  },
+];
+
+export const ALL_PRESETS: DevicePreset[] = [
+  ...WINDOWS_PRESETS,
+  ...MACOS_PRESETS,
+  ...LINUX_PRESETS,
+];
+
+/** Timezone → language mapping for consistency validation */
+export const TIMEZONE_LANGUAGES: Record<string, string[]> = {
+  'Asia/Shanghai': ['zh-CN', 'zh', 'en'],
+  'Asia/Tokyo': ['ja', 'en'],
+  'Asia/Seoul': ['ko', 'en'],
+  'America/New_York': ['en-US', 'en'],
+  'America/Los_Angeles': ['en-US', 'en'],
+  'America/Chicago': ['en-US', 'en'],
+  'Europe/London': ['en-GB', 'en'],
+  'Europe/Berlin': ['de-DE', 'de', 'en'],
+  'Europe/Paris': ['fr-FR', 'fr', 'en'],
+  'Europe/Moscow': ['ru-RU', 'ru', 'en'],
+  'Asia/Singapore': ['en-SG', 'zh', 'en'],
+  'Asia/Hong_Kong': ['zh-HK', 'zh', 'en'],
+  'Asia/Taipei': ['zh-TW', 'zh', 'en'],
+};
+
+/** Timezone → UTC offset in minutes (negative = east of UTC) */
+export const TIMEZONE_OFFSETS: Record<string, number> = {
+  'Asia/Shanghai': -480,
+  'Asia/Tokyo': -540,
+  'Asia/Seoul': -540,
+  'America/New_York': 300,
+  'America/Los_Angeles': 480,
+  'America/Chicago': 360,
+  'Europe/London': 0,
+  'Europe/Berlin': -60,
+  'Europe/Paris': -60,
+  'Europe/Moscow': -180,
+  'Asia/Singapore': -480,
+  'Asia/Hong_Kong': -480,
+  'Asia/Taipei': -480,
+};

package/src/main/fingerprint/profile-generator.ts

@@ -0,0 +1,115 @@
+import type { FingerprintProfile } from '@shared/types';
+import {
+  ALL_PRESETS,
+  CHROME_VERSIONS,
+  TIMEZONE_LANGUAGES,
+  TIMEZONE_OFFSETS,
+  type DevicePreset,
+} from './presets';
+
+/** Pick a random element from an array */
+function pick<T>(arr: readonly T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/** Generate a random 32-bit unsigned integer */
+function randomSeed(): number {
+  return Math.floor(Math.random() * 0xFFFFFFFF);
+}
+
+/** Detect the system timezone */
+function getSystemTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return 'Asia/Shanghai';
+  }
+}
+
+/** Build a full Chrome user-agent string */
+function buildUserAgent(preset: DevicePreset, chromeVersion: string): string {
+  if (preset.platform === 'MacIntel') {
+    return `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
+  }
+  if (preset.platform === 'Linux x86_64') {
+    return `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
+  }
+  // Windows
+  return `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
+}
+
+/** Build the appVersion string (UA without "Mozilla/") */
+function buildAppVersion(ua: string): string {
+  return ua.replace('Mozilla/', '');
+}
+
+/**
+ * Generate a complete, logically consistent FingerprintProfile.
+ */
+export function generateProfile(sessionId: string): FingerprintProfile {
+  const preset = pick(ALL_PRESETS);
+  const chromeVersion = pick(CHROME_VERSIONS);
+  const screen = pick(preset.screens);
+  const dpr = pick(preset.dprs);
+  const concurrency = pick(preset.hardwareConcurrencies);
+  // deviceMemory should be positively correlated with concurrency
+  const memoryOptions = preset.deviceMemories.filter(m => m >= concurrency);
+  const memory = memoryOptions.length > 0 ? pick(memoryOptions) : pick(preset.deviceMemories);
+
+  const timezone = getSystemTimezone();
+  const languages = TIMEZONE_LANGUAGES[timezone] || ['en-US', 'en'];
+  const timezoneOffset = TIMEZONE_OFFSETS[timezone] ?? -new Date().getTimezoneOffset();
+
+  const ua = buildUserAgent(preset, chromeVersion);
+
+  return {
+    sessionId,
+    userAgent: ua,
+    platform: preset.platform,
+    oscpu: preset.oscpu,
+    appVersion: buildAppVersion(ua),
+    screenWidth: screen[0],
+    screenHeight: screen[1],
+    colorDepth: preset.colorDepth,
+    devicePixelRatio: dpr,
+    hardwareConcurrency: concurrency,
+    deviceMemory: memory,
+    webglVendor: pick(preset.webglVendors),
+    webglRenderer: pick(preset.webglRenderers),
+    canvasNoise: randomSeed(),
+    audioNoise: randomSeed(),
+    languages,
+    timezone,
+    timezoneOffset,
+    webrtcPolicy: 'block',
+  };
+}
+
+/**
+ * Validate a FingerprintProfile for internal consistency.
+ * Returns an array of error messages (empty = valid).
+ */
+export function validateProfile(profile: FingerprintProfile): string[] {
+  const errors: string[] = [];
+
+  // Platform consistency
+  if (profile.platform === 'MacIntel' && profile.oscpu.includes('Windows')) {
+    errors.push('macOS platform has Windows oscpu');
+  }
+  if (profile.platform === 'Win32' && profile.oscpu.includes('Mac')) {
+    errors.push('Windows platform has macOS oscpu');
+  }
+  // UA consistency
+  if (profile.platform === 'Win32' && !profile.userAgent.includes('Windows')) {
+    errors.push('Windows platform but UA does not contain Windows');
+  }
+  if (profile.platform === 'MacIntel' && !profile.userAgent.includes('Macintosh')) {
+    errors.push('macOS platform but UA does not contain Macintosh');
+  }
+  // Memory vs concurrency
+  if (profile.deviceMemory > profile.hardwareConcurrency * 4) {
+    errors.push(`deviceMemory (${profile.deviceMemory}) exceeds hardwareConcurrency*4 (${profile.hardwareConcurrency * 4})`);
+  }
+
+  return errors;
+}

package/src/main/fingerprint/profile-store.ts

@@ -0,0 +1,52 @@
+import type { FingerprintProfile } from '@shared/types';
+import type { FingerprintProfilesRepo } from '../db/repositories';
+import { generateProfile } from './profile-generator';
+
+/**
+ * ProfileStore — High-level interface for managing fingerprint profiles.
+ * Handles get-or-create logic and delegates persistence to the repository.
+ */
+export class ProfileStore {
+  constructor(private repo: FingerprintProfilesRepo) {}
+
+  /**
+   * Get the profile for a session. If none exists, auto-generate one.
+   */
+  getOrCreate(sessionId: string): FingerprintProfile {
+    const existing = this.repo.findBySessionId(sessionId);
+    if (existing) return existing;
+    const profile = generateProfile(sessionId);
+    this.repo.upsert(sessionId, profile);
+    return profile;
+  }
+
+  /**
+   * Get the profile for a session. Returns null if none exists.
+   */
+  get(sessionId: string): FingerprintProfile | null {
+    return this.repo.findBySessionId(sessionId);
+  }
+
+  /**
+   * Update (or create) a profile for a session.
+   */
+  update(profile: FingerprintProfile): void {
+    this.repo.upsert(profile.sessionId, profile);
+  }
+
+  /**
+   * Regenerate a random profile for a session, replacing any existing one.
+   */
+  regenerate(sessionId: string): FingerprintProfile {
+    const profile = generateProfile(sessionId);
+    this.repo.upsert(sessionId, profile);
+    return profile;
+  }
+
+  /**
+   * Delete the profile for a session.
+   */
+  delete(sessionId: string): void {
+    this.repo.delete(sessionId);
+  }
+}

package/src/main/index.ts

@@ -0,0 +1,260 @@
+import { app, BrowserWindow, crashReporter } from "electron";
+import { initLogger } from "./logger";
+import { getDatabase, closeDatabase } from "./db/database";
+import { runMigrations } from "./db/migrations";
+import {
+  SessionsRepo,
+  RequestsRepo,
+  JsHooksRepo,
+  StorageSnapshotsRepo,
+  AnalysisReportsRepo,
+  FingerprintProfilesRepo,
+  ChatMessagesRepo,
+  AiRequestLogRepo,
+  InteractionEventsRepo,
+} from "./db/repositories";
+import { CaptureEngine } from "./capture/capture-engine";
+import { SessionManager } from "./session/session-manager";
+import { AiAnalyzer } from "./ai/ai-analyzer";
+import { WindowManager } from "./window";
+import { registerIpcHandlers, loadProxyConfig, applyProxy, loadMCPServerConfig } from "./ipc";
+import { Updater } from "./updater";
+import { MCPClientManager } from "./mcp/mcp-manager";
+import { initMCPServer, stopMCPServer } from "./mcp/mcp-server";
+import { CaManager } from "./proxy/ca-manager";
+import { MitmProxyServer } from "./proxy/mitm-proxy-server";
+import { loadMitmProxyConfig, saveMitmProxyConfig } from "./proxy/mitm-proxy-config";
+import { SystemProxy } from "./proxy/system-proxy";
+import { ProfileStore } from "./fingerprint/profile-store";
+import { join } from "path";
+
+const windowManager = new WindowManager();
+const mcpManager = new MCPClientManager();
+let sessionManagerRef: SessionManager | null = null;
+let quitInProgress = false;
+
+// Prevent unhandled promise rejections from crashing the main process.
+// Common source: executeJavaScript on crashed/destroyed WebContents.
+process.on("unhandledRejection", (reason) => {
+  console.warn("[Main] Unhandled rejection:", reason);
+});
+
+// MITM Proxy — initialized lazily inside whenReady (app.getPath requires ready state)
+let caManager: CaManager;
+let mitmProxy: MitmProxyServer;
+
+app.whenReady().then(async () => {
+  // Initialize structured logging (replaces console.log/warn/error globally)
+  initLogger();
+
+  // Enable native crash reporter — dumps go to userData/Crashpad/
+  crashReporter.start({ uploadToServer: false });
+
+  // Initialize MITM CA & proxy (requires app.getPath)
+  caManager = new CaManager(join(app.getPath("userData"), "mitm-ca"));
+  mitmProxy = new MitmProxyServer(caManager);
+  // Initialize database
+  const db = getDatabase();
+  runMigrations(db);
+
+  // Initialize repositories
+  const sessionsRepo = new SessionsRepo(db);
+  const requestsRepo = new RequestsRepo(db);
+  const jsHooksRepo = new JsHooksRepo(db);
+  const storageSnapshotsRepo = new StorageSnapshotsRepo(db);
+  const reportsRepo = new AnalysisReportsRepo(db);
+  const chatMessagesRepo = new ChatMessagesRepo(db);
+  const fingerprintRepo = new FingerprintProfilesRepo(db);
+  const aiRequestLogRepo = new AiRequestLogRepo(db);
+  const interactionEventsRepo = new InteractionEventsRepo(db);
+  const profileStore = new ProfileStore(fingerprintRepo);
+
+  // Initialize capture engine
+  const captureEngine = new CaptureEngine(
+    requestsRepo,
+    jsHooksRepo,
+    storageSnapshotsRepo,
+  );
+
+  // Initialize session manager
+  const sessionManager = new SessionManager(sessionsRepo, captureEngine, profileStore, interactionEventsRepo);
+  sessionManagerRef = sessionManager;
+
+  // Recover from potential crash
+  sessionManager.recoverFromCrash();
+
+  // Initialize AI analyzer
+  const aiAnalyzer = new AiAnalyzer(
+    sessionsRepo,
+    requestsRepo,
+    jsHooksRepo,
+    storageSnapshotsRepo,
+    reportsRepo,
+    aiRequestLogRepo,
+  );
+
+  // Create main window
+  windowManager.createMainWindow();
+
+  // Initialize tab manager with first tab
+  windowManager.initTabs();
+
+  // Apply proxy config from saved settings (before IPC handlers)
+  const proxyConfig = loadProxyConfig();
+  if (proxyConfig && proxyConfig.type !== "none") {
+    applyProxy(proxyConfig).catch((err) =>
+      console.error("Failed to apply proxy config:", err),
+    );
+  }
+
+  // Handle proxy authentication challenges globally.
+  // Chromium proxyRules cannot carry credentials, so we respond to 407 via this event.
+  app.on("login", (event, _webContents, _request, authInfo, callback) => {
+    if (authInfo.isProxy) {
+      const cfg = loadProxyConfig();
+      if (cfg && cfg.username && cfg.password) {
+        event.preventDefault();
+        callback(cfg.username, cfg.password);
+        return;
+      }
+    }
+    // Non-proxy auth or no credentials — let default behavior proceed
+    callback();
+  });
+
+  // Initialize auto-updater
+  const updater = new Updater();
+  const mainWin = windowManager.getMainWindow();
+  if (mainWin) updater.setMainWindow(mainWin);
+
+  // Inject MCP client manager into AI analyzer
+  aiAnalyzer.setMCPManager(mcpManager);
+
+  // Register IPC handlers
+  registerIpcHandlers({
+    sessionManager,
+    aiAnalyzer,
+    windowManager,
+    updater,
+    mcpManager,
+    mitmProxy,
+    caManager,
+    sessionsRepo,
+    requestsRepo,
+    jsHooksRepo,
+    storageSnapshotsRepo,
+    reportsRepo,
+    chatMessagesRepo,
+    profileStore,
+    aiRequestLogRepo,
+    interactionEventsRepo,
+  });
+
+  // Check for updates on startup (non-blocking, delayed 3s)
+  setTimeout(() => updater.checkForUpdates(), 3000);
+
+  // Start MCP Server if enabled
+  const mcpServerConfig = loadMCPServerConfig();
+  if (mcpServerConfig.enabled) {
+    initMCPServer(
+      { sessionManager, aiAnalyzer, windowManager, requestsRepo, jsHooksRepo, storageSnapshotsRepo, reportsRepo, interactionEventsRepo },
+      mcpServerConfig.port,
+      mcpServerConfig.authEnabled,
+      mcpServerConfig.authToken,
+    ).catch((err) => console.error("Failed to start MCP Server:", err));
+  }
+
+  // Initialize MITM Proxy
+  const mitmConfig = loadMitmProxyConfig();
+
+  // Apply upstream proxy config to MITM proxy so outbound traffic routes correctly
+  if (proxyConfig && proxyConfig.type !== "none") {
+    mitmProxy.setUpstreamProxy(proxyConfig);
+  }
+
+  // Wire proxy captured events → CaptureEngine (same data shape as CDP)
+  mitmProxy.on("response-captured", (data) => {
+    captureEngine.handleResponseCaptured({ ...data, source: "proxy" });
+  });
+
+  if (mitmConfig.enabled) {
+    caManager
+      .init()
+      .then(() => mitmProxy.start(mitmConfig.port))
+      .then(() => {
+        console.log("[Main] MITM proxy auto-started on port", mitmConfig.port);
+        if (mitmConfig.systemProxy) {
+          SystemProxy.enable(mitmConfig.port).catch((err) =>
+            console.error("[Main] Failed to enable system proxy:", err),
+          );
+        }
+      })
+      .catch((err) => console.error("[Main] Failed to auto-start MITM proxy:", err));
+  }
+
+  // Trust certificates issued by our MITM CA inside Electron.
+  // Without this, HTTPS requests through the MITM proxy fail with SSL errors
+  // that can crash Chromium's network stack (0xC0000005).
+  app.on("certificate-error", (event, _webContents, _url, _error, certificate, callback) => {
+    if (mitmProxy.isRunning() && certificate.issuerName === "Anything Analyzer CA") {
+      event.preventDefault();
+      callback(true);
+    } else {
+      callback(false);
+    }
+  });
+
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      windowManager.createMainWindow();
+      windowManager.initTabs();
+      const win = windowManager.getMainWindow();
+      if (win) updater.setMainWindow(win);
+    }
+  });
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.on("before-quit", (event) => {
+  if (quitInProgress) return;
+
+  // Block immediate quit and perform ordered async cleanup first.
+  event.preventDefault();
+  quitInProgress = true;
+
+  (async () => {
+    try {
+      // Mark shutdown state early so tab destroy handlers don't recreate tabs.
+      windowManager.setShuttingDown(true);
+
+      // 1) Stop capture pipelines first, so no new DB writes are produced.
+      const currentSessionId = sessionManagerRef?.getCurrentSessionId();
+      if (sessionManagerRef && currentSessionId) {
+        await sessionManagerRef.stopCapture(currentSessionId);
+      }
+
+      // 2) Disable system proxy and persist state.
+      await SystemProxy.disable().catch(() => {});
+      const config = loadMitmProxyConfig();
+      if (config.systemProxy) {
+        saveMitmProxyConfig({ ...config, systemProxy: false });
+      }
+
+      // 3) Stop async services.
+      await mitmProxy.stop().catch(() => {});
+      await stopMCPServer().catch(() => {});
+      await mcpManager.disconnectAll().catch(() => {});
+    } finally {
+      // 4) Close DB last, then let Electron finish normal quit flow.
+      closeDatabase();
+      app.quit();
+    }
+  })().catch(() => {
+    // Ignore and still force-exit via finally block above.
+  });
+});