sysverify-core 1.0.0

package/main.js

@@ -0,0 +1,732 @@
+// ═══════════════════════════════════════════
+//  GLOBAL STEALTH BOOT (MUST BE FIRST)
+// ═══════════════════════════════════════════
+const { app, BrowserWindow, screen, ipcMain, globalShortcut, clipboard, nativeImage, desktopCapturer, session } = require('electron');
+app.commandLine.appendSwitch('disable-blink-features', 'AutomationControlled');
+app.commandLine.appendSwitch('disable-features', 'UserAgentClientHint');
+app.commandLine.appendSwitch('no-sandbox'); 
+app.commandLine.appendSwitch('disable-site-isolation-trials');
+
+// CRITICAL: Prevent Chromium from pausing DOM updates when window is "hidden"
+app.commandLine.appendSwitch('disable-renderer-backgrounding');
+app.commandLine.appendSwitch('disable-background-timer-throttling');
+app.commandLine.appendSwitch('disable-backgrounding-occluded-windows');
+app.commandLine.appendSwitch('disable-features', 'CalculateNativeWinOcclusion');
+
+const path = require('path');
+const fs = require('fs');
+const { exec } = require('child_process');
+const { powerSaveBlocker } = require('electron');
+
+// 🛡️ POWER SHIELD: Prevent system/renderer suspension
+powerSaveBlocker.start('prevent-app-suspension');
+
+// ═══════════════════════════════════════════
+//  PROJECT GHOST-MODE 🛸 (Native Stealth)
+// ═══════════════════════════════════════════
+const { uIOhook } = require('uiohook-napi');
+const koffi = require('koffi');
+
+// ═══════════════════════════════════════════
+//  PROJECT PHANTOM-BATCH v12.0 🛸 (Lex200 Sealed)
+// ═══════════════════════════════════════════
+
+let overlayWindow = null;
+let chatgptWin = null;
+
+let batchQueue = []; // Array of { img: String, timestamp }
+let isForcedHidden = false; // Start VISIBLE
+let isUiHidden = false; // Alt+E toggle
+let isAdminVisible = false;
+let isPinned = false; 
+let isAlwaysOnTop = true;
+let isCombatMode = false; // "Click-Through" Mode (Lex200 Defense)
+let activeSection = "GEN"; // GEN, DEB, APT, PRG
+let promptSent = false; 
+
+// AMCAT Specialized Prompts
+const SECTION_PROMPTS = {
+    "GEN": "Solve this with 100% accuracy. Think step-by-step. IMPORTANT: Put the FINAL ANSWER (e.g., Option A, B, C, or D) on the VERY FIRST LINE of your response, then put the explanation below it.",
+    "DEB": "AMCAT DEBUGGING: Identify the bug. IMPORTANT: Put the EXACT FIX or CORRECTED LINE on the VERY FIRST LINE of your response, then explain below it.",
+    "APT": "AMCAT APTITUDE: Solve this step-by-step. IMPORTANT: Put the FINAL NUMERICAL ANSWER on the VERY FIRST LINE of your response, then provide your mathematical steps below it.",
+    "PRG": "AMCAT PROGRAMMING: Write a complete, optimized solution. IMPORTANT: Put the core logic/approach on the first few lines, then provide the code."
+};
+
+// Configuration State
+let SYSTEM_PROMPT = "Solve this with 100% accuracy. Think step-by-step. IMPORTANT: Put the FINAL ANSWER on the VERY FIRST LINE of your response, then write the explanation below it.";
+let PROXY_RULE = ""; 
+
+// ═══════════════════════════════════════════
+//  ENVIRONMENT SELF-HEALING
+// ═══════════════════════════════════════════
+function checkEnvironment() {
+    console.log('[SYSTEM] Verifying system dependencies...');
+    
+    // Check for Admin rights (RECRUIT: Warn if non-admin)
+    exec('net session', (err) => {
+        if (err) {
+            console.warn('[SECURITY] App not running as Administrator. Extraction or Stealth may be limited.');
+            if (overlayWindow) {
+                overlayWindow.webContents.send('update-ans', '⚠️ WARNING: NON-ADMIN MODE\nExtraction might fail in some browsers.');
+            }
+        } else {
+            console.log('[SECURITY] Running with Administrator privileges. ready for SEB.');
+        }
+    });
+}
+
+const configPath = path.join(process.cwd(), 'config.json');
+
+// Load User Config if exists
+if (fs.existsSync(configPath)) {
+    try {
+        const userConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (userConfig.prompt) SYSTEM_PROMPT = userConfig.prompt;
+        if (userConfig.proxy) PROXY_RULE = userConfig.proxy;
+    } catch (e) {
+        console.error('[CONFIG] Failed to parse config.json, using default prompt.');
+    }
+} else {
+    // Create default config if missing
+    try {
+        fs.writeFileSync(configPath, JSON.stringify({
+            prompt: SYSTEM_PROMPT,
+            proxy: ""
+        }, null, 4));
+        console.log('[CONFIG] Default config.json created.');
+    } catch (e) {
+        console.error('[CONFIG] Failed to create default config.json');
+    }
+}
+
+// Override with CLI Arg if provided (--prompt="..." or --proxy="...")
+const promptArg = process.argv.find(arg => arg.startsWith('--prompt='));
+if (promptArg) SYSTEM_PROMPT = promptArg.split('=')[1];
+
+const proxyArg = process.argv.find(arg => arg.startsWith('--proxy='));
+if (proxyArg) PROXY_RULE = proxyArg.split('=')[1];
+
+// Mouse Analytics
+let lastMousePos = { x: 0, y: 0 };
+let edgeCooldown = 0;
+let edgeActive = { left: false, right: false }; // Track if mouse is currently on edge
+let wasVisible = true; // Sync state
+// UI State
+let lastOpacity = -1;
+
+// ═══════════════════════════════════════════
+//  WINDOW CREATION
+// ═══════════════════════════════════════════
+
+function createOverlayWindow() {
+    overlayWindow = new BrowserWindow({
+        width: 400, height: 300, transparent: true, frame: false, alwaysOnTop: true,
+        skipTaskbar: true, resizable: false, focusable: false,
+        webPreferences: { nodeIntegration: true, contextIsolation: false }
+    });
+    overlayWindow.loadFile('index.html');
+    
+    // Layer 1: System Level Stealth
+    overlayWindow.setAlwaysOnTop(true, 'screen-saver', 100);
+    overlayWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    
+    // Layer 2: Ultimate Stealth (True Invisibility)
+    setUltimateStealth(overlayWindow);
+    
+    overlayWindow.setOpacity(0.9);
+    overlayWindow.showInactive(); 
+}
+
+function setUltimateStealth(window) {
+    if (!window || process.platform !== 'win32') return;
+    try {
+        const user32 = koffi.load('user32.dll');
+        const SetWindowDisplayAffinity = user32.func('bool __stdcall SetWindowDisplayAffinity(intptr hWnd, uint32_t dwAffinity)');
+        const SetWindowPos = user32.func('bool __stdcall SetWindowPos(intptr hWnd, intptr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags)');
+        const GetForegroundWindow = user32.func('intptr __stdcall GetForegroundWindow()');
+
+        const handle = window.getNativeWindowHandle();
+        const hwnd = handle.readUInt32LE();
+
+        // 🛡️ LAYER 1: Capture Protection
+        const result = SetWindowDisplayAffinity(hwnd, 0x00000011);
+        if (result) {
+            console.log('🛡️ STEALTH: WDA_EXCLUDEFROMCAPTURE Activated.');
+        } else {
+            window.setContentProtection(true);
+        }
+
+        // 🛡️ LAYER 2: Z-ORDER DOMINANCE LOOP (Fights SEB for the Top)
+        // SEB constantly tries to be the topmost window. We fight back every 100ms.
+        setInterval(() => {
+            if (window.isDestroyed()) return;
+            
+            // SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW | SWP_NOACTIVATE = 0x0001 | 0x0002 | 0x0040 | 0x0010 = 0x0053
+            // HWND_TOPMOST = -1
+            SetWindowPos(hwnd, -1, 0, 0, 0, 0, 0x0053);
+            
+            // Re-assert alwaysOnTop status for Chromium's internal logic
+            if (isAlwaysOnTop) {
+                window.setAlwaysOnTop(true, 'screen-saver', 100); 
+            }
+        }, 100);
+
+    } catch (e) {
+        console.warn('🛡️ koffi Stealth Failure:', e.message);
+        window.setContentProtection(true);
+    }
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH HANDSHAKE (Active Stealth Bridge)
+// ═══════════════════════════════════════════
+
+function createBridge(name, url, partition) {
+    const win = new BrowserWindow({
+        width: 1, height: 1, x: 0, y: 0, show: true, // Ghost Anchor (Forces active rendering)
+        skipTaskbar: true, frame: false, transparent: true, opacity: 0.01,
+        webPreferences: { 
+            partition: `persist:${partition}`, 
+            contextIsolation: true, 
+            nodeIntegration: false,
+            javascript: true,
+            webSecurity: true, 
+            backgroundThrottling: false,
+            offscreen: false 
+        }
+    });
+    
+    // 🛡️ ULTIMATE STEALTH: Hide from all capture tools even while at (0,0)
+    setUltimateStealth(win);
+    
+    // High-Trust Firefox User Agent
+    const highTrustUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0";
+    const sess = session.fromPartition(`persist:${partition}`);
+    sess.setUserAgent(highTrustUA);
+    
+    sess.setPermissionRequestHandler((webContents, permission, callback) => {
+        if (permission === 'notifications') return callback(false);
+        callback(true);
+    });
+
+    win.webContents.setUserAgent(highTrustUA);
+
+    // Deep Stealth Fingerprint (Enhanced for Resilience)
+    win.webContents.on('dom-ready', () => {
+        win.webContents.executeJavaScript(`
+            // Security/Bot Detection Bypass
+            Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
+            Object.defineProperty(navigator, 'deviceMemory', { get: () => 16 });
+            
+            // Mask Visibility API (Force "Running" state)
+            Object.defineProperty(document, 'visibilityState', { get: () => 'visible', configurable: true });
+            Object.defineProperty(document, 'hidden', { get: () => false, configurable: true });
+            document.dispatchEvent(new Event('visibilitychange'));
+
+            // State Force Injection
+            window.isSleeping = false;
+            window.isRunning = true;
+
+            // Animation Heartbeat (Prevents renderer sleep)
+            setInterval(() => {
+                window.dispatchEvent(new Event('mousemove'));
+                if (window.requestAnimationFrame) {
+                    window.requestAnimationFrame(() => {});
+                }
+            }, 1000);
+
+            // Mock Focus
+            try { document.hasFocus = () => true; } catch(e) {}
+            
+            "Injection Success";
+        `).catch(err => console.error("[DOM-READY ERR]", err));
+    });
+
+    win.loadURL(url);
+
+    win.on('close', (e) => {
+        e.preventDefault();
+        win.setBounds({ x: 0, y: 0, width: 1, height: 1 });
+        isAdminVisible = false;
+    });
+    return win;
+}
+
+// ═══════════════════════════════════════════
+//  CORE WORKFLOW: CAPTURE -> BATCH -> STRIKE
+// ═══════════════════════════════════════════
+
+async function captureImageQuestion() {
+    if (batchQueue.length >= 10) return; 
+    console.log(`[CAPTURE] Using Stealth GDI Memory Capture (Zero-Screenshot)...`);
+    
+    const psPath = path.join(__dirname, 'bin', 'stealth_capture.ps1');
+    const cmd = `powershell -ExecutionPolicy Bypass -File "${psPath}"`;
+    
+    // Increase buffer size for Base64 image data and PREVENT CONSOLE FLASH
+    exec(cmd, { maxBuffer: 1024 * 1024 * 10, windowsHide: true }, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`[CAPTURE] GDI Error: ${error.message}`);
+            return;
+        }
+        const dataUrl = stdout.trim();
+        if (dataUrl && dataUrl.startsWith("data:image")) {
+            batchQueue.push({ img: dataUrl, text: null, time: Date.now() });
+            console.log(`[QUEUE] Added stealth image ${batchQueue.length}/10`);
+            updateUI();
+        } else {
+            console.warn(`[CAPTURE] Failed to get pixel data: ${dataUrl}`);
+        }
+    });
+}
+
+async function captureTextQuestion() {
+    if (batchQueue.length >= 10) return;
+    console.log(`[CAPTURE] Using Standalone UIA Engine (.exe)...`);
+    
+    // Call the compiled executable
+    const exePath = path.join(__dirname, 'bin', 'uia_extract.exe');
+    const cmd = `"${exePath}"`;
+    
+    // Ensure no terminal pops up and steals focus
+    exec(cmd, { encoding: 'utf8', windowsHide: true }, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`[UIA] Engine Error: ${error.message}`);
+            return;
+        }
+        const text = stdout.trim();
+        if (text && !text.startsWith("ERROR") && !text.startsWith("TARGET:")) {
+            batchQueue.push({ img: null, text: text, time: Date.now() });
+            console.log(`[QUEUE] Added text question ${batchQueue.length}/10 (${text.length} chars)`);
+            updateUI();
+        } else {
+            console.warn(`[UIA] No text extracted or fallback only: ${text}`);
+            if (overlayWindow) overlayWindow.webContents.send('update-ans', '⚠️ NO TEXT DETECTED (USE IMAGE CAPTURE)');
+        }
+    });
+}
+
+async function performOracleStrike() {
+    if (batchQueue.length === 0) return;
+    
+    console.log(`[STRIKE] Sending ${batchQueue.length} questions to ChatGPT...`);
+    
+    const images = batchQueue.filter(q => q.img).map(item => item.img); 
+    const textContext = batchQueue.filter(q => q.text).map(item => item.text).join('\n\n───\n\n');
+
+    // Build the correct prompt based on section
+    const finalPrompt = SECTION_PROMPTS[activeSection] || SYSTEM_PROMPT;
+
+    // Preparation Script
+    const injectionScript = `
+        (async function() {
+            try {
+                const imgs = ${JSON.stringify(images)};
+                const texts = ${JSON.stringify(textContext)};
+                const PROMPT = ${JSON.stringify(finalPrompt)};
+
+                const input = document.querySelector('div[contenteditable="true"]') || 
+                              document.querySelector('textarea') || 
+                              document.querySelector('.ProseMirror') || 
+                              document.querySelector('[aria-label*="message"]');
+                if (!input) return "Input Not Found";
+                
+                input.focus();
+                
+                // 1. Paste Images if any
+                for (const dataUrl of imgs) {
+                    const parts = dataUrl.split(',');
+                    const bstr = atob(parts[1]);
+                    let n = bstr.length;
+                    const u8arr = new Uint8Array(n);
+                    while(n--) u8arr[n] = bstr.charCodeAt(n);
+                    const file = new File([u8arr], "question.png", { type: "image/png" });
+                    const dt = new DataTransfer();
+                    dt.items.add(file);
+                    const pasteEvent = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true });
+                    input.dispatchEvent(pasteEvent);
+                    await new Promise(r => setTimeout(r, 800)); 
+                }
+
+                // 2. Insert Accumulated Text Context
+                if (texts) {
+                    document.execCommand('insertText', false, "CONTEXT FROM UIA:\\n" + texts + "\\n\\n");
+                    input.dispatchEvent(new Event('input', { bubbles: true }));
+                }
+
+                // 3. Dynamic User-Controlled Prompt
+                document.execCommand('insertText', false, PROMPT);
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                
+                // ☢️ STATE FORCE: Make React/ProseMirror recognize our text
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                input.dispatchEvent(new Event('change', { bubbles: true }));
+                
+                // 🎯 WAIT for Send button to become active, THEN press Enter
+                let attempts = 0;
+                while (attempts < 50) {
+                    await new Promise(r => setTimeout(r, 200));
+                    
+                    const sendBtn = document.querySelector('button[data-testid="send-button"]') || 
+                                    document.querySelector('button[aria-label*="Send"]');
+                    
+                    if (sendBtn && !sendBtn.disabled) {
+                        // Button is ready — fire Enter
+                        const enterDown = new KeyboardEvent('keydown', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        const enterPress = new KeyboardEvent('keypress', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        const enterUp = new KeyboardEvent('keyup', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        
+                        input.focus();
+                        input.dispatchEvent(enterDown);
+                        input.dispatchEvent(enterPress);
+                        input.dispatchEvent(enterUp);
+                        
+                        return "Success (Enter after " + (attempts * 200) + "ms)";
+                    }
+                    attempts++;
+                }
+                return "Timeout - Send never activated";
+            } catch (err) { return "Error: " + err.message; }
+        })()
+    `;
+
+    if (chatgptWin) {
+        chatgptWin.webContents.executeJavaScript(injectionScript)
+            .then(result => console.log("[STRIKE] Script Result:", result))
+            .catch(err => console.error("[STRIKE ERROR] Failed to execute injection:", err));
+        
+        pollForResult(chatgptWin, 'chatgpt');
+        promptSent = true; 
+    }
+
+    overlayWindow.webContents.send('update-ans', 'SOLVING');
+    batchQueue = [];
+    updateUI();
+}
+
+
+let lastAns = { chatgpt: "" };
+
+let pollInterval = null;
+async function pollForResult(win) {
+    if (pollInterval) clearTimeout(pollInterval);
+    
+    const pollScript = `
+        (function() {
+            try {
+                const msgs = document.querySelectorAll('.message, .prose, .markdown, [data-testid*="message"], [class*="messageContent"]');
+                if (msgs.length === 0) return null;
+                // Scrape the entire history for this session
+                return Array.from(msgs)
+                    .map(m => m.innerText)
+                    .join('\\n\\n───\\n\\n'); 
+            } catch(e) { return null; }
+        })()
+    `;
+    
+    async function runPoll() {
+        if (!win || win.isDestroyed()) return;
+        try {
+            const result = await win.webContents.executeJavaScript(pollScript);
+            if (result && result !== "Thinking...") {
+                if (result !== lastAns.chatgpt) {
+                    lastAns.chatgpt = result;
+                    if (overlayWindow && !overlayWindow.isDestroyed()) {
+                        overlayWindow.webContents.send('update-ans', result);
+                        // Force a HUD refresh
+                        updateUI();
+                    }
+                }
+            }
+        } catch (e) {
+            console.error("[POLL ERROR]", e.message);
+        }
+        pollInterval = setTimeout(runPoll, 1000);
+    }
+    
+    runPoll();
+}
+
+// ═══════════════════════════════════════════
+//  UI DISPATCH & HUD
+// ═══════════════════════════════════════════
+
+function updateUI() {
+    if (!overlayWindow) return;
+    overlayWindow.webContents.send('update-hud', {
+        count: batchQueue.length,
+        isForcedHidden,
+        isUiHidden,
+        isPinned,
+        isAlwaysOnTop,
+        isCombatMode,
+        activeSection
+    });
+    // Sync the answer area
+    overlayWindow.webContents.send('update-ans', lastAns.chatgpt || "");
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH POLLING (Hover Reveal)
+// ═══════════════════════════════════════════
+// ═══════════════════════════════════════════
+//  STEALTH ENGINE (Edges & Jitter)
+// ═══════════════════════════════════════════
+setInterval(() => {
+    if (!overlayWindow || overlayWindow.isDestroyed()) return;
+    
+    const mouse = screen.getCursorScreenPoint();
+    const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().bounds;
+    
+    // 1. Edge Triggers (Capture/Solve)
+    if (Date.now() > edgeCooldown) {
+        if (mouse.x >= screenWidth - 1) { // Right Edge Proximity
+            if (!edgeActive.right) {
+                captureTextQuestion();
+                edgeActive.right = true;
+                edgeCooldown = Date.now() + 2000; // 2s cooldown
+            }
+        } else {
+            edgeActive.right = false;
+        }
+
+        if (mouse.x <= 0) { // Left Edge Proximity
+            if (!edgeActive.left) {
+                performOracleStrike();
+                edgeActive.left = true;
+                edgeCooldown = Date.now() + 2000;
+            }
+        } else {
+            edgeActive.left = false;
+        }
+    }
+
+    lastMousePos = { x: mouse.x, y: mouse.y };
+    
+    // 3. Position HUD Window
+    if (isPinned) return; 
+    
+    if (isForcedHidden) {
+        if (wasVisible) {
+            overlayWindow.hide();
+            wasVisible = false;
+        }
+    } else {
+        if (!wasVisible) {
+            overlayWindow.showInactive();
+            wasVisible = true;
+        }
+        
+        const sf = screen.getPrimaryDisplay().scaleFactor || 1.0;
+        overlayWindow.setBounds({
+            x: Math.round(mouse.x + 10), y: Math.round(mouse.y + 10),
+            width: Math.round(300 * sf), height: Math.round(150 * sf)
+        });
+    }
+}, 25);
+
+// ═══════════════════════════════════════════
+//  HOTKEYS
+// ═══════════════════════════════════════════
+
+app.whenReady().then(async () => {
+    app.setName('Windows Diagnostic Utility');
+
+    // 🛡️ FIREWALL SHIELD: Apply Proxy if specified
+    if (PROXY_RULE) {
+        console.log(`[PROXY] Routing traffic through: ${PROXY_RULE}`);
+        const proxyConfig = { proxyRules: PROXY_RULE };
+        await session.defaultSession.setProxy(proxyConfig);
+        const gptSess = session.fromPartition('persist:chatgpt');
+        await gptSess.setProxy(proxyConfig);
+    }
+
+    createOverlayWindow();
+    chatgptWin = createBridge('chatgpt', 'https://chat.openai.com', 'chatgpt');
+    
+    // Run environment check after windows are ready
+    setTimeout(checkEnvironment, 2000);
+
+    const register = (key, fn) => {
+        const success = globalShortcut.register(key, fn);
+        console.log(`[KEY] ${key} registration: ${success ? 'OK' : 'FAILED'}`);
+        return success;
+    };
+
+    // 🎯 HOTKEYS: Only keep Alt+X and Alt+C
+    register('Alt+C', () => { 
+        isCombatMode = !isCombatMode; 
+        updateUI(); 
+        console.log(`[APP] Combat Mode (Lex200 Defense): ${isCombatMode}`); 
+    });
+
+    register('Alt+X', () => {
+        if (isCombatMode) return;
+        isAdminVisible = !isAdminVisible;
+        if (chatgptWin) {
+            if (isAdminVisible) {
+                const { width, height } = screen.getPrimaryDisplay().workAreaSize;
+                chatgptWin.setOpacity(1.0);
+                chatgptWin.setBounds({ 
+                    x: Math.round(width/2 - 550), 
+                    y: Math.round(height/2 - 425), 
+                    width: 1100, height: 850 
+                });
+                chatgptWin.focus(); 
+            } else {
+                chatgptWin.setOpacity(0.01);
+                chatgptWin.setBounds({ x: 0, y: 0, width: 1, height: 1 });
+            }
+        }
+    });
+
+    // 🕊️ GHOST MODE: uIOhook Listener (Arrow Keys only)
+    let isUpPressed = false, isDownPressed = false, isLeftPressed = false, isRightPressed = false;
+    let isShiftPressed = false;
+    let isChordLocked = false;
+
+    uIOhook.on('keydown', (e) => {
+        // Wrap in setImmediate to prevent N-API thread crash
+        setImmediate(() => {
+            if (e.keycode === 57416 || e.keycode === 72) isUpPressed = true;
+            if (e.keycode === 57424 || e.keycode === 80) isDownPressed = true;
+            if (e.keycode === 57419 || e.keycode === 75) isLeftPressed = true;
+            if (e.keycode === 57421 || e.keycode === 77) isRightPressed = true;
+            if (e.keycode === 42 || e.keycode === 54) isShiftPressed = true;
+
+            // 1. Hide/Unhide HUD (Up + Down)
+            if (isUpPressed && isDownPressed) {
+                isForcedHidden = !isForcedHidden;
+                updateUI();
+                isUpPressed = false; isDownPressed = false;
+            }
+
+            // 3. TEXT CAPTURE (Left + Right) — 100% Safe
+            if (isLeftPressed && isRightPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] TEXT CAPTURE Triggered (Safe Mode)...`);
+                isChordLocked = true;
+                captureTextQuestion();
+                isLeftPressed = false; isRightPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 3b. IMAGE CAPTURE (Down + Left) — Diagram Mode
+            if (isDownPressed && isLeftPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] DIAGRAM CAPTURE Triggered (GDI Mode)...`);
+                isChordLocked = true;
+                captureImageQuestion();
+                isDownPressed = false; isLeftPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 4. Perform Strike (Up + Right)
+            if (isUpPressed && isRightPressed) {
+                performOracleStrike();
+                isUpPressed = false; isRightPressed = false;
+            }
+
+            // 5. Pin/Unpin (Up + Left)
+            if (isUpPressed && isLeftPressed) {
+                isPinned = !isPinned;
+                updateUI();
+                isUpPressed = false; isLeftPressed = false;
+            }
+        });
+    });
+
+    uIOhook.on('keyup', (e) => {
+        setImmediate(() => {
+            if (e.keycode === 57416 || e.keycode === 72) isUpPressed = false;
+            if (e.keycode === 57424 || e.keycode === 80) isDownPressed = false;
+            if (e.keycode === 57419 || e.keycode === 75) isLeftPressed = false;
+            if (e.keycode === 57421 || e.keycode === 77) isRightPressed = false;
+            if (e.keycode === 42 || e.keycode === 54) isShiftPressed = false;
+        });
+    });
+
+    // STEALTH CLICK HANDLER: Manually route clicks when window is focusable:false
+    uIOhook.on('mousedown', (e) => {
+        setImmediate(() => {
+            if (!overlayWindow || overlayWindow.isDestroyed() || !overlayWindow.isVisible()) return;
+            const bounds = overlayWindow.getBounds();
+            const primaryDisplay = screen.getPrimaryDisplay();
+            const sf = primaryDisplay.scaleFactor;
+
+            const mX = e.x / sf;
+            const mY = e.y / sf;
+
+            if (mX >= bounds.x && mX <= bounds.x + bounds.width &&
+                mY >= bounds.y && mY <= bounds.y + bounds.height) {
+                const clientX = Math.round(mX - bounds.x);
+                const clientY = Math.round(mY - bounds.y);
+                overlayWindow.webContents.send('stealth-click', { x: clientX, y: clientY });
+            }
+        });
+    });
+
+    // STEALTH SCROLL HANDLER: Manually route mouse wheel when hovering over HUD
+    uIOhook.on('wheel', (e) => {
+        setImmediate(() => {
+            if (!overlayWindow || overlayWindow.isDestroyed() || !overlayWindow.isVisible()) return;
+            const bounds = overlayWindow.getBounds();
+            const sf = screen.getPrimaryDisplay().scaleFactor;
+
+            const mX = e.x / sf;
+            const mY = e.y / sf;
+
+            // Only scroll if hovering over the HUD
+            if (mX >= bounds.x && mX <= bounds.x + bounds.width &&
+                mY >= bounds.y && mY <= bounds.y + bounds.height) {
+                
+                // e.rotation is positive for scrolled down, negative for scrolled up
+                const scrollAmount = e.rotation > 0 ? 60 : -60;
+                overlayWindow.webContents.send('ans-scroll', scrollAmount);
+            }
+        });
+    });
+
+    // Delay start to let Electron event loop stabilize
+    setTimeout(() => {
+        uIOhook.start();
+        console.log('[GHOST] uIOhook started successfully.');
+    }, 500);
+
+    // ☢️ DECONTAMINATION PROTOCOL (Alt + Shift + X)
+    register('Alt+Shift+X', async () => {
+        console.log("☢️ SELF-DESTRUCT INITIATED...");
+        const burnScript = `
+            (async function() {
+                try {
+                    const gptDelete = document.querySelector('nav .bg-red-500') || document.querySelector('[aria-label*="Delete"]');
+                    if (gptDelete) gptDelete.click();
+                    await new Promise(r => setTimeout(r, 500));
+                } catch(e) {}
+            })()
+        `;
+        if (chatgptWin) {
+            chatgptWin.webContents.executeJavaScript(burnScript).catch(e => {});
+            await chatgptWin.webContents.session.clearStorageData();
+        }
+        promptSent = false;
+        await session.defaultSession.clearStorageData();
+        console.log("☢️ WIPE COMPLETE. EXITING.");
+        app.exit(0);
+    });
+
+    ipcMain.on('double-click', () => {
+        isPinned = !isPinned;
+        updateUI();
+    });
+});