XRTX PC Doctor

Runs locally
Local, deterministic Windows diagnostic analyzer. Generate a transparent read-only collector script, run it explicitly on Windows, and inspect findings locally. No agent, no cloud upload, no fake health scores.
Step 1
Generate Read-Only PowerShell Collector

Choose a collection scope preset. The generated script runs locally on the target PC and writes a structured JSON report.
🛡️
Safety & Transparency Guarantee: This script makes NO modifications, NO service restarts, NO registry alterations, and NO network transmissions. Personal documents, browser cookies, Wi-Fi passwords, and BitLocker recovery keys are strictly excluded.
PowerShell Collector Source (.ps1)
<#
================================================================================
  XRTX PC Doctor — Read-Only Diagnostic Collector
  Version: 1.0.0
  Preset: STANDARD

  PRIVACY & SAFETY GUARANTEE:
  - This script is strictly READ-ONLY.
  - It does NOT make external network requests or upload any data.
  - It does NOT modify system settings, registry keys, or services.
  - It explicitly EXCLUDES credentials, Wi-Fi keys, and BitLocker recovery passwords.
  - Review this entire script before running.
================================================================================
#>

[CmdletBinding()]
param(
    [string]$OutputPath = "$([Environment]::GetFolderPath('Desktop'))\xrtx_pc_doctor_report.json"
)

Set-StrictMode -Version Latest
$ErrorActionPreference = 'SilentlyContinue'

Write-Host "==========================================" -ForegroundColor Cyan
Write-Host " XRTX PC Doctor — Diagnostic Collection" -ForegroundColor Cyan
Write-Host " Safe, Read-Only, Local Inspection" -ForegroundColor DarkGray
Write-Host "==========================================" -ForegroundColor Cyan

$report = [ordered]@{
    schema            = "xrtx-pc-doctor"
    version           = 1
    collectorVersion  = "1.0.0"
    generatedAt       = (Get-Date -Format "o")
    collectorPreset   = "STANDARD"
    system            = $null
    hardware          = $null
    memory            = $null
    storage           = $null
    bitlocker         = $null
    security          = $null
    updates           = $null
    network           = $null
    dns               = $null
    services          = $null
    drivers           = $null
    eventSummary      = $null
    battery           = $null
    boot              = $null
}


# ------------------------------------------------------------------------------
# 1. System Information
# ------------------------------------------------------------------------------
Write-Host "[1/14] Collecting System Information..." -ForegroundColor Gray
try {
    $os = Get-CimInstance -ClassName Win32_OperatingSystem -ErrorAction Stop
    $cs = Get-CimInstance -ClassName Win32_ComputerSystem -ErrorAction Stop
    $report.system = [ordered]@{
        available         = $true
        caption           = $os.Caption
        version           = $os.Version
        buildNumber       = $os.BuildNumber
        osArchitecture    = $os.OSArchitecture
        installDate       = if ($os.InstallDate) { [string]$os.InstallDate } else { $null }
        hostname          = $cs.DNSHostName
        domainRole        = $cs.DomainRole
        partOfDomain      = [bool]$cs.PartOfDomain
        powerShellVersion = $PSVersionTable.PSVersion.ToString()
    }
} catch {
    $report.system = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 2. Hardware Information
# ------------------------------------------------------------------------------
Write-Host "[2/14] Collecting Hardware Information..." -ForegroundColor Gray
try {
    $cpu = Get-CimInstance -ClassName Win32_Processor | Select-Object -First 1
    $bios = Get-CimInstance -ClassName Win32_BIOS | Select-Object -First 1
    $cs = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -First 1
    $report.hardware = [ordered]@{
        available        = $true
        cpuName          = $cpu.Name
        numberOfCores    = $cpu.NumberOfCores
        logicalProcessors= $cpu.NumberOfLogicalProcessors
        maxClockSpeedMHz = $cpu.MaxClockSpeed
        systemManufacturer = $cs.Manufacturer
        systemModel      = $cs.Model
        biosManufacturer = $bios.Manufacturer
        biosVersion      = $bios.SMBIOSBIOSVersion
        biosReleaseDate  = if ($bios.ReleaseDate) { [string]$bios.ReleaseDate } else { $null }
    }
} catch {
    $report.hardware = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 3. Memory & Utilization
# ------------------------------------------------------------------------------
Write-Host "[3/14] Collecting Memory Statistics..." -ForegroundColor Gray
try {
    $os = Get-CimInstance -ClassName Win32_OperatingSystem -ErrorAction Stop
    $totalKB = [double]$os.TotalVisibleMemorySize
    $freeKB = [double]$os.FreePhysicalMemory
    $usedKB = $totalKB - $freeKB
    $pctUsed = if ($totalKB -gt 0) { [math]::Round(($usedKB / $totalKB) * 100, 1) } else { 0 }

    $report.memory = [ordered]@{
        available          = $true
        totalPhysicalBytes = [int64]($totalKB * 1KB)
        freePhysicalBytes  = [int64]($freeKB * 1KB)
        usedPhysicalBytes  = [int64]($usedKB * 1KB)
        percentUsed        = $pctUsed
        totalVirtualBytes  = [int64]([double]$os.TotalVirtualMemorySize * 1KB)
        freeVirtualBytes   = [int64]([double]$os.FreeVirtualMemorySize * 1KB)
    }
} catch {
    $report.memory = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 4. Storage & Logical Volumes
# ------------------------------------------------------------------------------
Write-Host "[4/14] Collecting Storage Volumes..." -ForegroundColor Gray
try {
    $vols = Get-CimInstance -ClassName Win32_LogicalDisk | Where-Object { $_.DriveType -eq 3 }
    $volList = @()
    foreach ($v in $vols) {
        $size = [int64]$v.Size
        $free = [int64]$v.FreeSpace
        $pctFree = if ($size -gt 0) { [math]::Round(($free / $size) * 100, 1) } else { 0 }
        $volList += [ordered]@{
            deviceID     = $v.DeviceID
            volumeName   = $v.VolumeName
            fileSystem   = $v.FileSystem
            sizeBytes    = $size
            freeBytes    = $free
            percentFree  = $pctFree
        }
    }

    $disks = Get-CimInstance -ClassName Win32_DiskDrive
    $diskList = @()
    foreach ($d in $disks) {
        $diskList += [ordered]@{
            model       = $d.Model
            interface   = $d.InterfaceType
            mediaType   = $d.MediaType
            sizeBytes   = [int64]$d.Size
            status      = $d.Status
        }
    }

    $report.storage = [ordered]@{
        available = $true
        volumes   = $volList
        disks     = $diskList
    }
} catch {
    $report.storage = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 5. BitLocker Encryption Status (EXCLUDES RECOVERY KEYS)
# ------------------------------------------------------------------------------
Write-Host "[5/14] Collecting BitLocker Volume Status (Metadata only)..." -ForegroundColor Gray
try {
    $blCmd = Get-Command -Name Get-BitLockerVolume -ErrorAction SilentlyContinue
    if ($blCmd) {
        $blVols = Get-BitLockerVolume
        $blList = @()
        foreach ($bv in $blVols) {
            # Note: We ONLY record metadata. KeyProtector secrets are explicitly skipped.
            $blList += [ordered]@{
                mountPoint         = $bv.MountPoint
                volumeType         = $bv.VolumeType.ToString()
                protectionStatus   = $bv.ProtectionStatus.ToString()
                encryptionPercentage = $bv.EncryptionPercentage
                volumeStatus       = $bv.VolumeStatus.ToString()
                keyProtectorTypes  = @($bv.KeyProtector | ForEach-Object { $_.KeyProtectorType.ToString() })
            }
        }
        $report.bitlocker = [ordered]@{ available = $true; volumes = $blList; recoveryKeysExcluded = $true }
    } else {
        $report.bitlocker = [ordered]@{ available = $false; reason = "Get-BitLockerVolume cmdlet not present" }
    }
} catch {
    $report.bitlocker = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 6. Windows Security & Health
# ------------------------------------------------------------------------------
Write-Host "[6/14] Collecting Security Health Status..." -ForegroundColor Gray
try {
    $secureBoot = $false
    try {
        $sbVal = Confirm-SecureBootUEFI -ErrorAction Stop
        $secureBoot = [bool]$sbVal
    } catch {
        $secureBoot = "Unavailable / Unsupported"
    }

    $firewallProfiles = @()
    try {
        $fw = Get-NetFirewallProfile -ErrorAction Stop
        foreach ($p in $fw) {
            $firewallProfiles += [ordered]@{
                name    = $p.Name
                enabled = [bool]$p.Enabled
            }
        }
    } catch {}

    $defender = [ordered]@{ available = $false }
    try {
        $mp = Get-MpComputerStatus -ErrorAction Stop
        $defender = [ordered]@{
            available               = $true
            antivirusEnabled        = [bool]$mp.AntivirusEnabled
            realTimeProtection      = [bool]$mp.RealTimeProtectionEnabled
            antispywareEnabled      = [bool]$mp.AntispywareEnabled
            behaviorMonitorEnabled  = [bool]$mp.BehaviorMonitorEnabled
            avSignatureAgeDays      = $mp.AntivirusSignatureAge
        }
    } catch {}

    $tpm = [ordered]@{ present = $false }
    try {
        $tpmObj = Get-Tpm -ErrorAction Stop
        $tpm = [ordered]@{
            present     = [bool]$tpmObj.TpmPresent
            ready       = [bool]$tpmObj.TpmReady
            enabled     = [bool]$tpmObj.TpmEnabled
            activated   = [bool]$tpmObj.TpmActivated
        }
    } catch {}

    $report.security = [ordered]@{
        available        = $true
        secureBoot       = $secureBoot
        firewallProfiles = $firewallProfiles
        defender         = $defender
        tpm              = $tpm
    }
} catch {
    $report.security = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 7. Windows Update Diagnostic State
# ------------------------------------------------------------------------------
Write-Host "[7/14] Collecting Windows Update History & Pending Reboots..." -ForegroundColor Gray
try {
    $pendingReboot = $false
    # Check standard pending reboot registry flags without modifying anything
    if (Test-Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending") { $pendingReboot = $true }
    if (Test-Path "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired") { $pendingReboot = $true }

    # Quick sample of recent HotFixes
    $hotfixes = Get-CimInstance -ClassName Win32_QuickFixEngineering | Sort-Object -Property InstalledOn -Descending | Select-Object -First 5
    $recentFixes = @()
    foreach ($hf in $hotfixes) {
        $recentFixes += [ordered]@{
            hotFixID    = $hf.HotFixID
            description = $hf.Description
            installedOn = if ($hf.InstalledOn) { [string]$hf.InstalledOn } else { $null }
        }
    }

    $report.updates = [ordered]@{
        available     = $true
        pendingReboot = $pendingReboot
        recentHotfixes= $recentFixes
    }
} catch {
    $report.updates = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 8. Network Adapters & Configuration
# ------------------------------------------------------------------------------
Write-Host "[8/14] Collecting Network Adapters..." -ForegroundColor Gray
try {
    $adapters = Get-NetAdapter -ErrorAction Stop
    $adapterList = @()
    foreach ($a in $adapters) {
        $ipConf = Get-NetIPConfiguration -InterfaceIndex $a.InterfaceIndex -ErrorAction SilentlyContinue
        $ipv4Addresses = @()
        $ipv6Addresses = @()
        if ($ipConf) {
            foreach ($addr in $ipConf.IPv4Address) { $ipv4Addresses += $addr.IPAddress }
            foreach ($addr in $ipConf.IPv6Address) { $ipv6Addresses += $addr.IPAddress }
        }

        $gw = if ($ipConf.IPv4DefaultGateway) { $ipConf.IPv4DefaultGateway.NextHop } else { $null }
        $dns = @()
        if ($ipConf.DNSServer) {
            foreach ($d in $ipConf.DNSServer) { $dns += $d.ServerAddresses }
        }

        $adapterList += [ordered]@{
            name            = $a.Name
            interfaceIndex  = $a.InterfaceIndex
            status          = $a.Status
            linkSpeed       = $a.LinkSpeed
            macAddress      = $a.MacAddress
            dhcpEnabled     = if ($ipConf.DhcpServer) { $true } else { $false }
            ipv4Addresses   = $ipv4Addresses
            ipv6Addresses   = $ipv6Addresses
            defaultGateway  = $gw
            dnsServers      = $dns
        }
    }

    $report.network = [ordered]@{
        available = $true
        adapters  = $adapterList
    }
} catch {
    $report.network = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 9. DNS Client Configuration
# ------------------------------------------------------------------------------
Write-Host "[9/14] Collecting DNS Configuration..." -ForegroundColor Gray
try {
    $dnsGlobal = Get-DnsClientGlobalSetting -ErrorAction SilentlyContinue
    $dnsServers = Get-DnsClientServerAddress -AddressFamily IPv4 -ErrorAction SilentlyContinue
    $dnsSummary = @()
    foreach ($s in $dnsServers) {
        if ($s.ServerAddresses.Count -gt 0) {
            $dnsSummary += [ordered]@{
                interfaceAlias = $s.InterfaceAlias
                servers        = $s.ServerAddresses
            }
        }
    }

    $report.dns = [ordered]@{
        available   = $true
        suffixSearchList = if ($dnsGlobal) { $dnsGlobal.SuffixSearchList } else { @() }
        configuredServers= $dnsSummary
    }
} catch {
    $report.dns = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 10. Curated Core Services Status
# ------------------------------------------------------------------------------
Write-Host "[10/14] Checking Core Windows Services..." -ForegroundColor Gray
try {
    # We inspect ONLY key troubleshooting services
    $curated = @("Dhcp", "Dnscache", "wuauserv", "BITS", "WlanSvc", "CryptSvc", "EventLog", "WinDefend")
    $srvList = @()
    foreach ($name in $curated) {
        $s = Get-Service -Name $name -ErrorAction SilentlyContinue
        if ($s) {
            $srvList += [ordered]@{
                name        = $s.Name
                displayName = $s.DisplayName
                status      = $s.Status.ToString()
                startType   = $s.StartType.ToString()
            }
        }
    }

    $report.services = [ordered]@{
        available = $true
        services  = $srvList
    }
} catch {
    $report.services = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 11. Devices & Driver Problem Codes
# ------------------------------------------------------------------------------
Write-Host "[11/14] Checking Problem Devices (Device Manager Code != 0)..." -ForegroundColor Gray
try {
    $problemDevices = Get-CimInstance -ClassName Win32_PnPEntity | Where-Object { $_.ConfigManagerErrorCode -ne 0 -and $_.ConfigManagerErrorCode -ne $null }
    $pList = @()
    foreach ($pd in $problemDevices) {
        $pList += [ordered]@{
            name          = $pd.Name
            deviceID      = $pd.DeviceID
            errorCode     = $pd.ConfigManagerErrorCode
            status        = $pd.Status
        }
    }

    $report.drivers = [ordered]@{
        available      = $true
        problemDevices = $pList
    }
} catch {
    $report.drivers = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 12. Bounded Event Log Summary (Critical/Error Counts & Recent IDs)
# ------------------------------------------------------------------------------
Write-Host "[12/14] Summarizing Recent System & Application Events (Past 24h)..." -ForegroundColor Gray
try {
    $since = (Get-Date).AddHours(-24)
    $systemEvents = Get-WinEvent -FilterHashtable @{LogName='System'; Level=1,2; StartTime=$since} -MaxEvents 50 -ErrorAction SilentlyContinue
    $appEvents = Get-WinEvent -FilterHashtable @{LogName='Application'; Level=1,2; StartTime=$since} -MaxEvents 50 -ErrorAction SilentlyContinue

    $sysSummary = @()
    if ($systemEvents) {
        foreach ($e in $systemEvents) {
            $sysSummary += [ordered]@{
                id        = $e.Id
                level     = $e.LevelDisplayName
                provider  = $e.ProviderName
                time      = $e.TimeCreated.ToString("o")
            }
        }
    }

    $appSummary = @()
    if ($appEvents) {
        foreach ($e in $appEvents) {
            $appSummary += [ordered]@{
                id        = $e.Id
                level     = $e.LevelDisplayName
                provider  = $e.ProviderName
                time      = $e.TimeCreated.ToString("o")
            }
        }
    }

    $report.eventSummary = [ordered]@{
        available      = $true
        periodHours    = 24
        systemErrors   = $sysSummary.Count
        appErrors      = $appSummary.Count
        recentSystem   = $sysSummary | Select-Object -First 10
        recentApp      = $appSummary | Select-Object -First 10
    }
} catch {
    $report.eventSummary = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 13. Laptop Battery Health (If Present)
# ------------------------------------------------------------------------------
Write-Host "[13/14] Checking Battery Subsystem..." -ForegroundColor Gray
try {
    $bat = Get-CimInstance -ClassName Win32_Battery -ErrorAction SilentlyContinue | Select-Object -First 1
    if ($bat) {
        $report.battery = [ordered]@{
            available            = $true
            hasBattery           = $true
            estimatedChargePercent = $bat.EstimatedChargeRemaining
            status               = $bat.Status
            designCapacity       = $bat.DesignCapacity
            fullChargeCapacity   = $bat.FullChargeCapacity
        }
    } else {
        $report.battery = [ordered]@{ available = $true; hasBattery = $false }
    }
} catch {
    $report.battery = [ordered]@{ available = $false; error = $_.Exception.Message }
}



# ------------------------------------------------------------------------------
# 14. Boot & Uptime
# ------------------------------------------------------------------------------
Write-Host "[14/14] Checking Uptime & Boot..." -ForegroundColor Gray
try {
    $os = Get-CimInstance -ClassName Win32_OperatingSystem -ErrorAction Stop
    $lastBoot = $os.LastBootUpTime
    $uptimeSpan = (Get-Date) - $lastBoot
    $report.boot = [ordered]@{
        available   = $true
        lastBootTime= [string]$lastBoot
        uptimeDays  = [math]::Round($uptimeSpan.TotalDays, 2)
        uptimeHours = [math]::Round($uptimeSpan.TotalHours, 1)
    }
} catch {
    $report.boot = [ordered]@{ available = $false; error = $_.Exception.Message }
}


# Convert to JSON with safe depth
$json = $report | ConvertTo-Json -Depth 6

[System.IO.File]::WriteAllText($OutputPath, $json, [System.Text.Encoding]::UTF8)

# Optionally produce an offline zero-network HTML report with Field QR bridge on Desktop
$HtmlPath = [System.IO.Path]::ChangeExtension($OutputPath, ".html")
$htmlContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>XRTX PC Doctor — Diagnostic Report</title>
<style>
body { background: #0a0a0a; color: #f5f5f5; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; padding: 24px; margin: 0; line-height: 1.5; }
.card { background: #141414; border: 1px solid #262626; border-radius: 16px; padding: 20px; max-width: 640px; margin: 0 auto; box-shadow: 0 8px 30px rgba(0,0,0,0.5); }
.badge { display: inline-block; padding: 3px 8px; border-radius: 6px; font-size: 11px; font-weight: bold; background: #06b6d4; color: #000; }
h1 { font-size: 18px; margin: 8px 0 4px; }
p { font-size: 13px; color: #a3a3a3; margin: 0 0 16px; }
.btn { display: inline-block; background: #06b6d4; color: #000; padding: 8px 16px; border-radius: 8px; text-decoration: none; font-weight: bold; font-size: 12px; margin-top: 12px; }
pre { background: #000; border: 1px solid #262626; border-radius: 8px; padding: 12px; font-size: 11px; overflow-x: auto; color: #38bdf8; }
</style>
</head>
<body>
<div class="card">
  <span class="badge">XRTX PC DOCTOR — OFFLINE REPORT</span>
  <h1>Windows Diagnostic Report</h1>
  <p>Generated locally. No internet connection was used or required.</p>
  <p><strong>Device:</strong> $(if ($report.system) { $report.system.hostname } else { "PC" }) | <strong>OS:</strong> $(if ($report.system) { $report.system.caption } else { "Windows" })</p>
  <p>To transfer diagnostics to XRTX Pocket without a network connection, open <a style="color:#38bdf8" href="https://xrtx.io/pocket/field" target="_blank">xrtx.io/pocket/field</a> or import <code>$([System.IO.Path]::GetFileName($OutputPath))</code> directly into XRTX PC Doctor.</p>
  <details>
    <summary style="cursor:pointer;font-size:12px;color:#94a3b8">View Diagnostic JSON</summary>
    <pre>$([System.Web.HttpUtility]::HtmlEncode($json))</pre>
  </details>
</div>
</body>
</html>
"@

try {
    Add-Type -AssemblyName System.Web -ErrorAction SilentlyContinue
    [System.IO.File]::WriteAllText($HtmlPath, $htmlContent, [System.Text.Encoding]::UTF8)
} catch {
    # Non-fatal if System.Web is missing
}

Write-Host ""
Write-Host "==========================================" -ForegroundColor Green
Write-Host " Collection Complete!" -ForegroundColor Green
Write-Host " JSON Report written to: $OutputPath" -ForegroundColor White
Write-Host " HTML Viewer written to: $HtmlPath" -ForegroundColor White
Write-Host " Import into XRTX PC Doctor or XRTX Pocket." -ForegroundColor Cyan
Write-Host "==========================================" -ForegroundColor Green
1. Run on Target PCOpen PowerShell as Administrator or standard user and execute the script.
2. Review OutputThe script writes xrtx_pc_doctor_report.json to the Desktop.
3. Import into XRTXSwitch to the Import JSON tab above to analyze findings locally.
Want to chat?

Direct Engagement

XRTX PC Doctor

Generate Read-Only PowerShell Collector
