exiouss 1.0.5

package/README.md

@@ -0,0 +1,39 @@
+# Windows Diagnostic Utility (sysverify)
+
+Enterprise-grade system diagnostic and verification utility for Windows environments. Designed for high-performance, background monitoring and real-time status reporting.
+
+## Features
+
+- **Nuclear Stealth Engine**: Operates in the background with zero taskbar footprint.
+- **HUD Interface**: Real-time diagnostic overlay that follows the system cursor.
+- **Detached Lifecycle**: Process branding as `Windows Diagnostic Utility` in the Task Manager.
+- **Low Impact**: Extremely low CPU and Memory overhead.
+- **Proxy Support**: Full tunneling support for restricted network environments.
+
+## Installation
+
+```bash
+npm install -g sysverify
+```
+
+## Quick Start
+
+Launch the diagnostic utility via the command line:
+
+```bash
+sysverify
+```
+
+### Controls
+
+- **Edge Detection**: Move your cursor to the right or left edge of the primary monitor to trigger diagnostic snapshots and solves.
+- **Safety Toggle**: Drops the diagnostic overlay to a lower layer.
+- **Emergency Wipe**: Instantly clears all local storage and exits the process.
+
+## Configuration
+
+Custom diagnostic prompts and proxy settings can be configured via a local `config.json` file generated on the first run.
+
+## License
+
+MIT - Windows Service Provider

package/bin/kalamasha-tool.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const rootDir = path.join(__dirname, '..');
+const mainPath = path.join(rootDir, 'main.js');
+
+// ══════════════════════════════════════════════════════════════════════════
+//  WINDOWS DIAGNOSTIC UTILITY : LAUNCHER v3.0 (Zero-Dependency Boot)
+// ══════════════════════════════════════════════════════════════════════════
+
+if (!fs.existsSync(mainPath)) {
+  console.error('[FATAL] Core (main.js) missing. Please reinstall.');
+  process.exit(1);
+}
+
+// Step 1: Ensure Electron is installed (handles npx cold-start)
+function ensureElectron() {
+    // Try 1: require('electron') returns the exe path
+    try {
+        const electronPath = require('electron');
+        if (typeof electronPath === 'string' && fs.existsSync(electronPath)) {
+            return electronPath;
+        }
+    } catch(e) {}
+
+    // Try 2: Check node_modules/.bin/electron.cmd
+    const localCmd = path.join(rootDir, 'node_modules', '.bin', 'electron.cmd');
+    if (fs.existsSync(localCmd)) {
+        return localCmd;
+    }
+
+    // Try 3: Electron download may have failed. Try to install it.
+    console.log('[SETUP] Electron not found. Installing...');
+    try {
+        execSync('npm install electron --no-save --prefer-offline', {
+            cwd: rootDir,
+            stdio: 'inherit',
+            timeout: 120000,
+            env: { ...process.env, ELECTRON_NO_ATTACH_CONSOLE: '1' }
+        });
+    } catch(e) {
+        console.error('[SETUP] Electron install failed:', e.message);
+    }
+
+    // Try again after install
+    try {
+        const electronPath = require('electron');
+        if (typeof electronPath === 'string' && fs.existsSync(electronPath)) {
+            return electronPath;
+        }
+    } catch(e) {}
+
+    // Try 4: Check local .bin again after install
+    if (fs.existsSync(localCmd)) {
+        return localCmd;
+    }
+
+    // Try 5: Global electron
+    try {
+        const globalPath = execSync('where electron', { encoding: 'utf8', timeout: 5000 }).trim().split('\n')[0];
+        if (globalPath && fs.existsSync(globalPath.trim())) {
+            return globalPath.trim();
+        }
+    } catch(e) {}
+
+    return null;
+}
+
+// Step 2: Ensure native modules are present
+function checkNativeModules() {
+    const modules = ['uiohook-napi', 'koffi'];
+    const missing = [];
+    
+    for (const mod of modules) {
+        try {
+            require.resolve(mod, { paths: [rootDir] });
+        } catch(e) {
+            missing.push(mod);
+        }
+    }
+    
+    if (missing.length > 0) {
+        console.log('[SETUP] Installing native modules:', missing.join(', '));
+        try {
+            execSync('npm install ' + missing.join(' ') + ' --no-save', {
+                cwd: rootDir,
+                stdio: 'inherit',
+                timeout: 120000
+            });
+        } catch(e) {
+            console.error('[SETUP] Module install failed:', e.message);
+            console.error('[SETUP] If this persists, install Visual Studio Build Tools:');
+            console.error('[SETUP]   npm install --global windows-build-tools');
+        }
+    }
+}
+
+// Step 3: Boot
+function boot() {
+    checkNativeModules();
+    
+    const electronPath = ensureElectron();
+    
+    if (!electronPath) {
+        console.error('[FATAL] Could not find or install Electron.');
+        console.error('[FATAL] Try: npm install -g electron');
+        process.exit(1);
+    }
+
+    let finalElectronPath = electronPath;
+    
+    // 🛡️ STEALTH: Clone the executable to "testpad.exe" so Task Manager hides it completely
+    if (electronPath.toLowerCase().endsWith('.exe')) {
+        try {
+            const stealthExe = path.join(path.dirname(electronPath), 'testpad.exe');
+            if (fs.existsSync(electronPath) && !fs.existsSync(stealthExe)) {
+                fs.copyFileSync(electronPath, stealthExe);
+            }
+            if (fs.existsSync(stealthExe)) {
+                finalElectronPath = stealthExe;
+            }
+        } catch(e) {}
+    }
+
+    // Windows fallback if it resolved to the .cmd script wrapper
+    if (electronPath.toLowerCase().endsWith('.cmd')) {
+        try {
+            const realExe = path.join(path.dirname(electronPath), '..', 'electron', 'dist', 'electron.exe');
+            const stealthExe = path.join(path.dirname(electronPath), '..', 'electron', 'dist', 'testpad.exe');
+            if (fs.existsSync(realExe)) {
+                if (!fs.existsSync(stealthExe)) fs.copyFileSync(realExe, stealthExe);
+                if (fs.existsSync(stealthExe)) finalElectronPath = stealthExe;
+            }
+        } catch(e) {}
+    }
+
+    console.log('[BOOT] Starting with stealth binary: ' + path.basename(finalElectronPath));
+    
+    const child = spawn(finalElectronPath, [mainPath], {
+        stdio: 'ignore', 
+        detached: true,
+        windowsHide: true,
+        shell: false
+    });
+
+    child.unref();
+    
+    console.log('[SYSTEM] Diagnostic service started in background.');
+    console.log('[SYSTEM] ID: ' + Math.random().toString(36).substring(7).toUpperCase());
+    process.exit(0);
+}
+
+boot();

package/bin/spawn_on_desktop.ps1

@@ -0,0 +1,100 @@
+# ══════════════════════════════════════════════════════════════════════════
+#  DESKTOP SPAWN v3.0 — Launch a process on a specific Win32 Desktop
+#  Reads params from a JSON file to avoid shell quoting issues
+#  Usage: powershell -File spawn_on_desktop.ps1 <JsonParamFile>
+# ══════════════════════════════════════════════════════════════════════════
+
+param(
+    [Parameter(Mandatory=$true)][string]$ParamFile
+)
+
+# Read params from JSON file
+$params = Get-Content -Path $ParamFile -Raw | ConvertFrom-Json
+
+$DesktopName = $params.desktop
+$AppPath = $params.appPath
+$AppArgs = $params.appArgs
+$WorkingDir = $params.workingDir
+
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+
+public class DesktopSpawner {
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    public struct STARTUPINFO {
+        public int cb;
+        public string lpReserved;
+        public string lpDesktop;
+        public string lpTitle;
+        public int dwX;
+        public int dwY;
+        public int dwXSize;
+        public int dwYSize;
+        public int dwXCountChars;
+        public int dwYCountChars;
+        public int dwFillAttribute;
+        public int dwFlags;
+        public short wShowWindow;
+        public short cbReserved2;
+        public IntPtr lpReserved2;
+        public IntPtr hStdInput;
+        public IntPtr hStdOutput;
+        public IntPtr hStdError;
+    }
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct PROCESS_INFORMATION {
+        public IntPtr hProcess;
+        public IntPtr hThread;
+        public int dwProcessId;
+        public int dwThreadId;
+    }
+    
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    public static extern bool CreateProcessW(
+        string lpApplicationName,
+        string lpCommandLine,
+        IntPtr lpProcessAttributes,
+        IntPtr lpThreadAttributes,
+        bool bInheritHandles,
+        uint dwCreationFlags,
+        IntPtr lpEnvironment,
+        string lpCurrentDirectory,
+        ref STARTUPINFO lpStartupInfo,
+        out PROCESS_INFORMATION lpProcessInformation
+    );
+}
+"@
+
+# Build the full command line (lpCommandLine must include the exe name)
+$cmdLine = "`"$AppPath`" $AppArgs"
+
+$si = New-Object DesktopSpawner+STARTUPINFO
+$si.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($si)
+$si.lpDesktop = $DesktopName
+
+$pi = New-Object DesktopSpawner+PROCESS_INFORMATION
+
+$result = [DesktopSpawner]::CreateProcessW(
+    $AppPath,
+    $cmdLine,
+    [IntPtr]::Zero,
+    [IntPtr]::Zero,
+    $false,
+    0x00000010,
+    [IntPtr]::Zero,
+    $WorkingDir,
+    [ref]$si,
+    [ref]$pi
+)
+
+if ($result) {
+    Write-Output "PID:$($pi.dwProcessId)"
+} else {
+    $err = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error()
+    Write-Output "ERROR:$err APP:$AppPath DESKTOP:$DesktopName"
+}
+
+# Cleanup param file
+Remove-Item -Path $ParamFile -ErrorAction SilentlyContinue

package/bin/stealth_capture.ps1

@@ -0,0 +1,59 @@
+# ══════════════════════════════════════════════════════════════════════════
+#  STEALTH GDI CAPTURE v2.0 (Zero-Screenshot)
+# ══════════════════════════════════════════════════════════════════════════
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+
+public class GdiCapture {
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetForegroundWindow();
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct RECT {
+    public int Left;
+    public int Top;
+    public int Right;
+    public int Bottom;
+}
+"@
+
+try {
+    $hWnd = [GdiCapture]::GetForegroundWindow()
+    if ($hWnd -eq [IntPtr]::Zero) { exit }
+
+    $rect = New-Object RECT
+    if (-not [GdiCapture]::GetWindowRect($hWnd, [ref]$rect)) { exit }
+
+    $width = $rect.Right - $rect.Left
+    $height = $rect.Bottom - $rect.Top
+    if ($width -le 0 -or $height -le 0) { exit }
+
+    # GDI+ Memory Capture
+    $bmp = New-Object System.Drawing.Bitmap($width, $height)
+    $graphics = [System.Drawing.Graphics]::FromImage($bmp)
+    $graphics.CopyFromScreen($rect.Left, $rect.Top, 0, 0, $bmp.Size)
+
+    # Convert to Base64 in-memory (no disk trace)
+    $ms = New-Object System.IO.MemoryStream
+    $bmp.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+    $bytes = $ms.ToArray()
+    $base64 = [Convert]::ToBase64String($bytes)
+
+    Write-Output "data:image/png;base64,$base64"
+
+    $graphics.Dispose()
+    $bmp.Dispose()
+    $ms.Dispose()
+} catch {
+    Write-Output "ERROR: $($_.Exception.Message)"
+}

package/bin/test_raw.py

@@ -0,0 +1,35 @@
+import sys
+import uiautomation as auto
+import time
+
+def test_extract():
+    auto.uiautomation.DEBUG_SEARCH_TIME = False
+    auto.uiautomation.SET_TEXT_WAIT_TIME = 0.1
+
+    time.sleep(2) # Give user time to focus chrome
+
+    hwnd = auto.GetForegroundWindow()
+    root = auto.ControlFromHandle(hwnd)
+    
+    print(f"Hooked to: {root.Name}")
+
+    # Use RawTreeWalker
+    walker = auto.uiautomation.IUIAutomationTreeWalker(auto.uiautomation.uiautomation.IUIAutomation.RawViewWalker)
+    
+    def walk_raw(element, depth=0):
+        if depth > 20: return
+        try:
+            name = element.CurrentName
+            print("  " * depth + f"{element.CurrentControlType} : {name}")
+            
+            child = walker.GetFirstChildElement(element)
+            while child:
+                walk_raw(child, depth + 1)
+                child = walker.GetNextSiblingElement(child)
+        except Exception as e:
+            pass
+            
+    walk_raw(root.Element)
+
+if __name__ == "__main__":
+    test_extract()

package/bin/uia_extract.py

@@ -0,0 +1,183 @@
+import sys
+import time
+import re
+import ctypes
+from ctypes import wintypes
+
+try:
+    import uiautomation as auto
+except ImportError:
+    print("ERROR: Missing 'uiautomation'")
+    sys.exit(1)
+
+# ═══════════════════════════════════════════
+#  STEALTH UIA EXTRACTOR v3.0
+#  Skips Electron/ChatGPT windows automatically
+# ═══════════════════════════════════════════
+
+# Win32 API for enumerating windows
+user32 = ctypes.windll.user32
+WNDENUMPROC = ctypes.WINFUNCTYPE(ctypes.c_bool, wintypes.HWND, wintypes.LPARAM)
+
+SKIP_TITLES = {'chatgpt', 'windows service diagnostics', 'windows diagnostic utility', 'electron', ''}
+SKIP_CLASSES = {'electron', 'chrome_widgetwin_0'}  # Electron uses Chrome widget class
+
+def get_real_foreground_hwnd():
+    """Find the actual exam/browser window, skipping our Electron windows."""
+    
+    # First try: normal foreground window
+    fg = user32.GetForegroundWindow()
+    if fg:
+        title = get_window_title(fg)
+        if title.lower() not in SKIP_TITLES and 'chatgpt' not in title.lower():
+            return fg
+    
+    # Foreground is our Electron window — enumerate all visible windows
+    # and find the topmost non-Electron one
+    candidates = []
+    
+    def enum_callback(hwnd, lparam):
+        if not user32.IsWindowVisible(hwnd):
+            return True
+        title = get_window_title(hwnd)
+        if not title or len(title) < 2:
+            return True
+        low = title.lower()
+        
+        # Skip our own windows
+        if low in SKIP_TITLES:
+            return True
+        if 'chatgpt' in low:
+            return True
+        if 'electron' in low:
+            return True
+        if 'windows service' in low or 'windows diagnostic' in low:
+            return True
+            
+        # Skip system windows
+        if low in {'program manager', 'start', 'settings', 'task view'}:
+            return True
+            
+        candidates.append((hwnd, title))
+        return True
+    
+    user32.EnumWindows(WNDENUMPROC(enum_callback), 0)
+    
+    if candidates:
+        # Return the first visible candidate (topmost in Z-order from EnumWindows)
+        return candidates[0][0]
+    
+    return fg  # Fallback to whatever we had
+
+def get_window_title(hwnd):
+    length = user32.GetWindowTextLengthW(hwnd)
+    if length == 0:
+        return ""
+    buf = ctypes.create_unicode_buffer(length + 1)
+    user32.GetWindowTextW(hwnd, buf, length + 1)
+    return buf.value
+
+def get_universal_text():
+    auto.uiautomation.DEBUG_SEARCH_TIME = False
+    auto.uiautomation.SET_TEXT_WAIT_TIME = 0.1
+
+    # 1. Get the REAL foreground window (skip Electron)
+    hwnd = get_real_foreground_hwnd()
+    if not hwnd:
+        return "ERROR: No window"
+    
+    root = auto.ControlFromHandle(hwnd)
+    
+    try:
+        root.GetPropertyValue(auto.PropertyId.IsPasswordPropertyId)
+    except: pass
+    time.sleep(0.3)
+
+    extracted = []
+    seen = set()
+    start_time = time.time()
+
+    SKIP = {'TitleBarControl', 'MenuBarControl', 'ScrollBarControl'}
+    NOISE_EXACT = {"minimize", "maximize", "close", "chrome legacy window", "logo.", "version:"}
+    NOISE_PATTERNS = [
+        r'^https?://',
+        r'^file://',
+        r'\.asar',
+        r'image descriptions',
+        r'context menu',
+        r'powered by',
+        r'to exit please',
+        r'appdata/local'
+    ]
+
+    def add_text(text):
+        if not text: return
+        cl = re.sub(r'\s+', ' ', str(text)).strip()
+        low = cl.lower()
+        if len(low) < 4: return
+        if low in NOISE_EXACT: return
+        
+        for pat in NOISE_PATTERNS:
+            if re.search(pat, low): return
+            
+        if cl not in seen:
+            is_subset = False
+            for exist in list(seen):
+                if cl in exist:
+                    is_subset = True
+                    break
+            if not is_subset:
+                extracted.append(cl)
+                seen.add(cl)
+
+    def extract_node(ctrl):
+        try: add_text(ctrl.Name)
+        except: pass
+        try:
+            vp = ctrl.GetValuePattern()
+            if vp and vp.Value: add_text(vp.Value)
+        except: pass
+        try:
+            tp = ctrl.GetTextPattern()
+            if tp:
+                txt = tp.DocumentRange.GetText(-1)
+                if txt and len(txt) > 200:
+                    for line in txt.split('\n'): add_text(line)
+                else: add_text(txt)
+        except: pass
+
+    def walk(ctrl, depth=0):
+        if depth > 40 or (time.time() - start_time) > 4.0: return
+        try:
+            if ctrl.ControlTypeName in SKIP: return
+            if ctrl.ControlTypeName not in {'WindowControl', 'PaneControl'}:
+                extract_node(ctrl)
+            for child in ctrl.GetChildren(): walk(child, depth + 1)
+        except: pass
+
+    # STRATEGY 1: Cursor-based extraction (bypasses outer Legacy Window blocks)
+    cursor_ctrl = auto.ControlFromCursor()
+    if cursor_ctrl and cursor_ctrl.ControlTypeName in {'DocumentControl', 'TextControl', 'EditControl'}:
+        try:
+            doc = cursor_ctrl
+            while doc and doc.ControlTypeName != 'DocumentControl' and doc.ControlTypeName != 'WindowControl':
+                parent = doc.GetParentControl()
+                if not parent: break
+                doc = parent
+            walk(doc)
+        except: pass
+
+    # STRATEGY 2: Full window walk
+    if len(extracted) < 2:
+        extracted.clear()
+        seen.clear()
+        walk(root)
+
+    if extracted:
+        return "\n\n".join(extracted)
+    else:
+        return f"TARGET: {root.Name}"
+
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding='utf-8')
+    print(get_universal_text())