<#

[CmdletBinding()]

param(

[Parameter(HelpMessage="Prevent automatic elevation")]

[switch]$NoElevation,

[Parameter(HelpMessage="Path to configuration file")]

[ValidateNotNullOrEmpty()]

[string]$ConfigPath = (Join-Path $env:APPDATA "WindowsUpdateManager\config.json"),

[Parameter(HelpMessage="Path for transcript logging")]

[string]$LogPath = "",

[Parameter(HelpMessage="Skip dependency checks")]

[switch]$SkipDependencyCheck,

[Parameter(HelpMessage="Minimize user prompts")]

[switch]$Silent

)

$script:Version = "3.0.0"

$script:TranscriptOn = $false

$script:LastScan = @()

$script:LastScanRaw = @()

$script:Config = $null

$script:IsElevated = $false

$script:ErrorLogPath = ""

$script:EscapeChar = [char]27

$script:SupportsANSI = $false

$script:ConsoleDimensions = @{Width=80; Height=24}

$script:AsciiArtTitles = @{

"Standard" = @"

"Slant" = @"

"Cyberpunk" = @"

}

function Get-ConsoleSize {

try {

$width = $Host.UI.RawUI.WindowSize.Width

$height = $Host.UI.RawUI.WindowSize.Height

if ($width -lt 1) { $width = 80 }

if ($height -lt 1) { $height = 24 }

return @{Width = $width; Height = $height}

} catch {

return @{Width = 80; Height = 24}

}

}

function Set-OptimalWindowSize {

param(

[int]$RequiredWidth = 0,

[int]$RequiredHeight = 0

)

<#

try {

# Skip if running in ISE or unsupported host

if ($Host.Name -match "ISE" -or -not $Host.UI.RawUI) {

$script:ConsoleDimensions = Get-ConsoleSize

return

}

$raw = $Host.UI.RawUI

# Optimal dimensions for the menu (width for descriptors, height for all options)

$optimalWidth = if ($RequiredWidth -gt 0) { $RequiredWidth } else { 110 }

$optimalHeight = if ($RequiredHeight -gt 0) { $RequiredHeight } else { 40 }

$optimalWidth = [Math]::Max($optimalWidth, 80)

$optimalHeight = [Math]::Max($optimalHeight, 24)

$currentSize = $raw.WindowSize

$maxSize = $raw.MaxPhysicalWindowSize

$maxWidth = if ($maxSize.Width -gt 0) { $maxSize.Width } else { $currentSize.Width }

$maxHeight = if ($maxSize.Height -gt 0) { $maxSize.Height } else { $currentSize.Height }

# Calculate desired size (capped by max)

$newWidth = [Math]::Min($optimalWidth, $maxWidth)

$newHeight = [Math]::Min($optimalHeight, $maxHeight)

# Expand buffer size first (must be >= window size)

$bufferSize = $raw.BufferSize

$targetBufferWidth = [Math]::Max($bufferSize.Width, $newWidth)

$targetBufferHeight = [Math]::Max($bufferSize.Height, $newHeight)

$bufferSize.Width = $targetBufferWidth

$bufferSize.Height = $targetBufferHeight

try { $raw.BufferSize = $bufferSize } catch { }

# Clamp to actual buffer size if the resize was rejected

$bufferSize = $raw.BufferSize

$newWidth = [Math]::Min($newWidth, $bufferSize.Width)

$newHeight = [Math]::Min($newHeight, $bufferSize.Height)

# Only resize if needed and possible

if ($currentSize.Width -ne $newWidth -or $currentSize.Height -ne $newHeight) {

$windowSize = $raw.WindowSize

$windowSize.Width = $newWidth

$windowSize.Height = $newHeight

try {

$raw.WindowSize = $windowSize

} catch {

try { [Console]::SetWindowSize($newWidth, $newHeight) } catch { }

}

}

# Expand buffer height for scrollback if supported

try {

$bufferSize = $raw.BufferSize

if ($bufferSize.Height -lt 3000) {

$bufferSize.Height = 3000

$raw.BufferSize = $bufferSize

}

} catch { }

# Center the window on screen if possible

try {

$windowPos = $raw.WindowPosition

$windowPos.X = [Math]::Max(0, ($maxWidth - $newWidth) / 2)

$windowPos.Y = [Math]::Max(0, ($maxHeight - $newHeight) / 2)

$raw.WindowPosition = $windowPos

} catch {

# Centering might fail in some hosts, ignore

}

# Update script dimensions

$script:ConsoleDimensions = Get-ConsoleSize

} catch {

$script:ConsoleDimensions = Get-ConsoleSize

}

}

function Write-GradientText {

param(

[Parameter(Mandatory)]

[string]$Text,

[int]$StartR = 0, [int]$StartG = 255, [int]$StartB = 255,

[int]$EndR = 0, [int]$EndG = 100, [int]$EndB = 255

)

# Check if gradients are enabled and supported

if (-not $script:Config.Visual.EnableGradients -or -not $script:SupportsANSI) {

Write-Host $Text -ForegroundColor Cyan

return

}

# PowerShell 7+ supports 24-bit RGB

if ($PSVersionTable.PSVersion.Major -ge 7) {

$length = $Text.Length

if ($length -le 1) {

Write-Host $Text

return

}

for ($i = 0; $i -lt $length; $i++) {

$ratio = $i / ($length - 1)

$r = [int]($StartR + ($EndR - $StartR) * $ratio)

$g = [int]($StartG + ($EndG - $StartG) * $ratio)

$b = [int]($StartB + ($EndB - $StartB) * $ratio)

Write-Host "$script:EscapeChar[38;2;$r;$g;${b}m$($Text[$i])" -NoNewline

}

Write-Host "$script:EscapeChar[0m"

} else {

# Fallback for PowerShell 5.1

Write-Host $Text -ForegroundColor Cyan

}

}

function Write-RainbowText {

param(

[Parameter(Mandatory)]

[string]$Text

)

if (-not $script:Config.Visual.EnableGradients -or -not $script:SupportsANSI) {

Write-Host $Text -ForegroundColor Cyan

return

}

if ($PSVersionTable.PSVersion.Major -ge 7) {

$colors = @(

@{R=255; G=0; B=0}, # Red

@{R=255; G=127; B=0}, # Orange

@{R=255; G=255; B=0}, # Yellow

@{R=0; G=255; B=0}, # Green

@{R=0; G=0; B=255}, # Blue

@{R=75; G=0; B=130}, # Indigo

@{R=148; G=0; B=211} # Violet

)

$length = $Text.Length

for ($i = 0; $i -lt $length; $i++) {

$colorIndex = [int](($i / $length) * ($colors.Count - 1))

$c = $colors[$colorIndex]

Write-Host "$script:EscapeChar[38;2;$($c.R);$($c.G);$($c.B)m$($Text[$i])" -NoNewline

}

Write-Host "$script:EscapeChar[0m"

} else {

Write-Host $Text -ForegroundColor Cyan

}

}

function Play-Sound {

param(

[ValidateSet("Startup","Success","Error","Warning","Complete","Click")]

[string]$SoundType

)

if (-not $script:Config.Sounds.$SoundType) {

return

}

try {

switch ($SoundType) {

"Startup" {

[console]::beep(523,100)

[console]::beep(659,100)

[console]::beep(784,150)

}

"Success" {

[console]::beep(784,100)

[console]::beep(1047,200)

}

"Error" {

[console]::beep(400,200)

[console]::beep(300,300)

}

"Warning" {

[console]::beep(600,200)

}

"Complete" {

[console]::beep(523,100)

[console]::beep(659,100)

[console]::beep(784,100)

[console]::beep(1047,300)

}

"Click" {

[console]::beep(800,50)

}

}

} catch {

# Silently fail if beep not supported

}

}

function Show-AsciiTitle {

param([string]$Style = "Standard")

$title = $script:AsciiArtTitles[$Style]

if (-not $title) { $Style = "Standard"; $title = $script:AsciiArtTitles[$Style] }

if ($script:Config.Visual.EnableGradients -and $PSVersionTable.PSVersion.Major -ge 7) {

foreach ($line in ($title -split "`n")) {

Write-GradientText -Text $line -StartR 0 -StartG 255 -StartB 255 -EndR 0 -EndG 150 -EndB 255

}

} else {

Write-Host $title -ForegroundColor Cyan

}

}

function New-BoxBorder {

param(

[Parameter(Mandatory)]

[string]$Content,

[string]$Title = "",

[ValidateSet("Single","Double","Heavy","Rounded","ASCII")]

[string]$Style = "Double",

[int]$Width = 80,

[ConsoleColor]$Color = 'Cyan'

)

# Box drawing character sets

$borders = @{

"Single" = @{TL='┌'; TR='┐'; BL='└'; BR='┘'; H='─'; V='│'; TJ='┬'; BJ='┴'; LJ='├'; RJ='┤'; CJ='┼'}

"Double" = @{TL='╔'; TR='╗'; BL='╚'; BR='╝'; H='═'; V='║'; TJ='╦'; BJ='╩'; LJ='╠'; RJ='╣'; CJ='╬'}

"Heavy" = @{TL='┏'; TR='┓'; BL='┗'; BR='┛'; H='━'; V='┃'; TJ='┳'; BJ='┻'; LJ='┣'; RJ='┫'; CJ='╋'}

"Rounded" = @{TL='╭'; TR='╮'; BL='╰'; BR='╯'; H='─'; V='│'; TJ='┬'; BJ='┴'; LJ='├'; RJ='┤'; CJ='┼'}

"ASCII" = @{TL='+'; TR='+'; BL='+'; BR='+'; H='-'; V='|'; TJ='+'; BJ='+'; LJ='+'; RJ='+'; CJ='+'}

}

$b = $borders[$Style]

$innerWidth = $Width - 2

# Top border

$topBorder = $b.TL + ($b.H * $innerWidth) + $b.TR

Write-Host $topBorder -ForegroundColor $Color

# Title line if provided

if ($Title) {

$titleLen = $Title.Length

$padding = $innerWidth - $titleLen - 2

$leftPad = [Math]::Floor($padding / 2)

$rightPad = $padding - $leftPad

$titleLine = $b.V + (' ' * $leftPad) + $Title + (' ' * $rightPad) + $b.V

Write-Host $titleLine -ForegroundColor $Color

# Separator

$separator = $b.LJ + ($b.H * $innerWidth) + $b.RJ

Write-Host $separator -ForegroundColor $Color

}

# Content lines

$contentLines = $Content -split "`n"

foreach ($line in $contentLines) {

$linelen = $line.Length

$pad = $innerWidth - $linelen

if ($pad -lt 0) {

# Truncate if too long

$line = $line.Substring(0, $innerWidth)

$pad = 0

}

$contentLine = $b.V + $line + (' ' * $pad) + $b.V

Write-Host $contentLine -ForegroundColor $Color

}

# Bottom border

$bottomBorder = $b.BL + ($b.H * $innerWidth) + $b.BR

Write-Host $bottomBorder -ForegroundColor $Color

}

function Show-ProgressBarEnhanced {

param(

[Parameter(Mandatory)]

[string]$Activity,

[Parameter(Mandatory)]

[string]$Status,

[int]$PercentComplete = 0,

[int]$Total = 100,

[int]$Current = 0,

[string]$Speed = "",

[string]$ETA = ""

)

# Use standard Write-Progress if animations disabled

if (-not $script:Config.Visual.EnableAnimations) {

Write-Progress -Activity $Activity -Status $Status -PercentComplete $PercentComplete

return

}

$size = Get-ConsoleSize

$barWidth = [Math]::Min(50, $size.Width - 40)

$completed = [Math]::Floor($barWidth * $PercentComplete / 100)

$remaining = $barWidth - $completed

$bar = '█' * $completed + '░' * $remaining

Write-Host ""

Write-ColorOutput -Message "┌$('─' * ($barWidth + 30))┐" -ForegroundColor Cyan

Write-Host "│ " -NoNewline -ForegroundColor Cyan

Write-ColorOutput -Message $Activity -ForegroundColor White -NoNewline

Write-Host (' ' * ($barWidth + 28 - $Activity.Length)) -NoNewline

Write-Host "│" -ForegroundColor Cyan

Write-Host "├$('─' * ($barWidth + 30))┤" -ForegroundColor Cyan

Write-Host "│ " -NoNewline -ForegroundColor Cyan

Write-ColorOutput -Message $Status -ForegroundColor Gray -NoNewline

Write-Host (' ' * ($barWidth + 28 - $Status.Length)) -NoNewline

Write-Host "│" -ForegroundColor Cyan

Write-Host "│ " -NoNewline -ForegroundColor Cyan

if ($PercentComplete -ge 75) {

Write-Host $bar -NoNewline -ForegroundColor Green

} elseif ($PercentComplete -ge 50) {

Write-Host $bar -NoNewline -ForegroundColor Yellow

} else {

Write-Host $bar -NoNewline -ForegroundColor Cyan

}

Write-Host " $PercentComplete%" -NoNewline

Write-Host (' ' * ($barWidth + 24 - $bar.Length - $PercentComplete.ToString().Length)) -NoNewline

Write-Host "│" -ForegroundColor Cyan

if ($Speed -or $ETA) {

Write-Host "│ " -NoNewline -ForegroundColor Cyan

$info = ""

if ($Speed) { $info += "⚡ $Speed " }

if ($ETA) { $info += "⏱ ETA: $ETA" }

Write-ColorOutput -Message $info -ForegroundColor Gray -NoNewline

Write-Host (' ' * ($barWidth + 28 - $info.Length)) -NoNewline

Write-Host "│" -ForegroundColor Cyan

}

Write-Host "└$('─' * ($barWidth + 30))┘" -ForegroundColor Cyan

}

function Initialize-Colors {

# Enable VT100 escape sequences for color support (Windows 10+)

try {

# Check ANSI support

$script:SupportsANSI = $false

if ($PSVersionTable.PSVersion.Major -ge 7) {

$script:SupportsANSI = $true

} elseif ($PSVersionTable.BuildVersion.Build -ge 10586) {

$script:SupportsANSI = $true

}

if ($script:SupportsANSI) {

$null = [System.Console]::OutputEncoding = [System.Text.Encoding]::UTF8

}

} catch {

$script:SupportsANSI = $false

}

# Update console dimensions

$script:ConsoleDimensions = Get-ConsoleSize

}

function Write-Header {

param(

[Parameter(Mandatory)]

[string]$Title,

[Parameter(Mandatory)]

[object]$Config

)

Clear-Host

$line = "=" * $script:ConsoleDimensions.Width

Write-ColorOutput -Message $line -ForegroundColor Cyan

Write-ColorOutput -Message " $Title" -ForegroundColor Cyan -Bold

Write-ColorOutput -Message " Version: $($script:Version)" -ForegroundColor Gray

Write-ColorOutput -Message $line -ForegroundColor Cyan

$computerDisplay = if ($Config.TargetComputers -and $Config.TargetComputers.Count -gt 0) {

$Config.TargetComputers -join ", "

} else {

"LOCAL"

}

$sourceDisplay = if ($Config.UseMicrosoftUpdate) { "Microsoft Update" } else { "Windows Update" }

Write-Host (" Computer(s): {0}" -f $computerDisplay)

Write-Host (" Source : {0}" -f $sourceDisplay)

Write-Host (" AutoReboot : {0} IgnoreReboot: {1} Verbose: {2}" -f $Config.AutoReboot, $Config.IgnoreReboot, $Config.Verbose)

Write-Host (" Logging : {0}" -f $(if ($script:TranscriptOn) { "ON" } else { "OFF" }))

if ($script:IsElevated) {

Write-ColorOutput -Message " Status : Running as Administrator ✓" -ForegroundColor Green

} else {

Write-ColorOutput -Message " Status : Not elevated (some operations may fail)" -ForegroundColor Yellow

}

Write-ColorOutput -Message $line -ForegroundColor Cyan

}

function Write-ColorOutput {

param(

[Parameter(Mandatory)]

[string]$Message,

[Parameter()]

[ConsoleColor]$ForegroundColor = [ConsoleColor]::White,

[Parameter()]

[ConsoleColor]$BackgroundColor,

[Parameter()]

[switch]$Bold,

[Parameter()]

[switch]$NoNewline

)

$params = @{

Object = $Message

ForegroundColor = $ForegroundColor

}

if ($BackgroundColor) {

$params.BackgroundColor = $BackgroundColor

}

if ($NoNewline) {

$params.NoNewline = $true

}

Write-Host @params

}

function Write-Info {

param([Parameter(Mandatory)][string]$Message)

Write-ColorOutput -Message ("[ℹ] {0}" -f $Message) -ForegroundColor Cyan

}

function Write-Ok {

param([Parameter(Mandatory)][string]$Message)

Write-ColorOutput -Message ("[✓] {0}" -f $Message) -ForegroundColor Green

}

function Write-Warn {

param([Parameter(Mandatory)][string]$Message)

Write-ColorOutput -Message ("[⚠] {0}" -f $Message) -ForegroundColor Yellow

}

function Write-Err {

param([Parameter(Mandatory)][string]$Message)

Write-ColorOutput -Message ("[✗] {0}" -f $Message) -ForegroundColor Red

Write-ErrorLog -Message $Message

if ($script:Config.Sounds.Error) {

Play-Sound -SoundType "Error"

}

}

function Write-Success {

param([Parameter(Mandatory)][string]$Message)

Write-ColorOutput -Message ("[✓] {0}" -f $Message) -ForegroundColor Green

if ($script:Config.Sounds.Success) {

Play-Sound -SoundType "Success"

}

}

function Write-Progress-Enhanced {

param(

[Parameter(Mandatory)]

[string]$Activity,

[Parameter(Mandatory)]

[string]$Status,

[Parameter()]

[int]$PercentComplete = -1

)

if ($PercentComplete -ge 0) {

Write-Progress -Activity $Activity -Status $Status -PercentComplete $PercentComplete

} else {

Write-Progress -Activity $Activity -Status $Status

}

}

function Pause-UI {

param([string]$Message = "Press Enter to continue...")

Write-Host ""

[void](Read-Host $Message)

}

function Read-YesNo {

param(

[Parameter(Mandatory)]

[string]$Prompt,

[switch]$DefaultYes

)

if ($Silent) { return [bool]$DefaultYes }

$suffix = if ($DefaultYes) { " [Y/n]" } else { " [y/N]" }

$answer = Read-Host ($Prompt + $suffix)

if ([string]::IsNullOrWhiteSpace($answer)) {

return [bool]$DefaultYes

}

return ($answer.Trim().ToLowerInvariant() -in @("y","yes"))

}

function Show-Banner {

Clear-Host

# Play startup sound

Play-Sound -SoundType "Startup"

# Show ASCII art title

$style = $script:Config.Visual.AsciiArtStyle

if (-not $style) { $style = "Cyberpunk" }

Show-AsciiTitle -Style $style

Write-Host ""

Write-ColorOutput -Message " Professional Update Management Tool" -ForegroundColor Gray

Write-ColorOutput -Message " Version $($script:Version)" -ForegroundColor Gray

Write-Host ""

}

function Initialize-ErrorLog {

try {

$logDir = Join-Path $env:APPDATA "WindowsUpdateManager\logs"

if (-not (Test-Path $logDir)) {

New-Item -ItemType Directory -Path $logDir -Force | Out-Null

}

$script:ErrorLogPath = Join-Path $logDir ("ErrorLog_{0}.txt" -f (Get-Date -Format "yyyyMMdd_HHmmss"))

Add-Content -Path $script:ErrorLogPath -Value ("=" * 80) -ErrorAction SilentlyContinue

Add-Content -Path $script:ErrorLogPath -Value "Windows Update Manager v$($script:Version) - Error Log" -ErrorAction SilentlyContinue

Add-Content -Path $script:ErrorLogPath -Value ("Started: {0}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss")) -ErrorAction SilentlyContinue

Add-Content -Path $script:ErrorLogPath -Value ("=" * 80) -ErrorAction SilentlyContinue

Add-Content -Path $script:ErrorLogPath -Value "" -ErrorAction SilentlyContinue

} catch {

# Silent fail on log initialization

}

}

function Write-ErrorLog {

param(

[Parameter(Mandatory)]

[string]$Message,

[Parameter()]

[System.Management.Automation.ErrorRecord]$ErrorRecord

)

try {

if ([string]::IsNullOrEmpty($script:ErrorLogPath)) { return }

$timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"

$logEntry = "[{0}] {1}" -f $timestamp, $Message

Add-Content -Path $script:ErrorLogPath -Value $logEntry -ErrorAction SilentlyContinue

if ($ErrorRecord) {

Add-Content -Path $script:ErrorLogPath -Value (" Exception: {0}" -f $ErrorRecord.Exception.Message) -ErrorAction SilentlyContinue

Add-Content -Path $script:ErrorLogPath -Value (" Category : {0}" -f $ErrorRecord.CategoryInfo.Category) -ErrorAction SilentlyContinue

Add-Content -Path $script:ErrorLogPath -Value "" -ErrorAction SilentlyContinue

}

} catch {

# Silent fail on error logging

}

}

function Test-IsAdmin {

try {

$identity = [Security.Principal.WindowsIdentity]::GetCurrent()

$principal = New-Object Security.Principal.WindowsPrincipal($identity)

return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

} catch {

Write-ErrorLog -Message "Failed to check admin status" -ErrorRecord $_

return $false

}

}

function Ensure-Elevation {

param([switch]$Skip)

if ($Skip) {

Write-Warn "Skipping elevation check. Some operations may fail without admin rights."

return

}

if (Test-IsAdmin) {

$script:IsElevated = $true

return

}

Write-Warn "Administrator privileges required. Attempting to elevate..."

try {

$psi = New-Object System.Diagnostics.ProcessStartInfo

$psi.FileName = if ($PSVersionTable.PSVersion.Major -ge 7) { "pwsh.exe" } else { "powershell.exe" }

$args = @(

"-NoProfile",

"-ExecutionPolicy", "Bypass",

"-File", ('"{0}"' -f $PSCommandPath)

)

if ($NoElevation) { $args += "-NoElevation" }

if ($ConfigPath) { $args += @("-ConfigPath", ('"{0}"' -f $ConfigPath)) }

if ($LogPath) { $args += @("-LogPath", ('"{0}"' -f $LogPath)) }

if ($SkipDependencyCheck) { $args += "-SkipDependencyCheck" }

if ($Silent) { $args += "-Silent" }

$psi.Arguments = ($args -join " ")

$psi.Verb = "runas"

$psi.UseShellExecute = $true

$process = [Diagnostics.Process]::Start($psi)

if ($null -ne $process) {

Write-Success "Elevated instance started. This window will close."

Start-Sleep -Seconds 2

exit 0

}

} catch {

Write-Err "Elevation failed or was cancelled."

Write-ErrorLog -Message "Elevation failed" -ErrorRecord $_

Write-Warn "Some operations require administrator rights and may not work."

Start-Sleep -Seconds 3

}

}

function Test-InternetConnectivity {

try {

$result = Test-Connection -ComputerName "8.8.8.8" -Count 1 -Quiet -ErrorAction SilentlyContinue

return $result

} catch {

return $false

}

}

function Get-FreeDiskSpace {

param([string]$Drive = "C:")

try {

$disk = Get-PSDrive -Name $Drive.TrimEnd(':') -ErrorAction Stop

return [math]::Round($disk.Free / 1GB, 2)

} catch {

return 0

}

}

function Test-WindowsUpdateService {

try {

$service = Get-Service -Name "wuauserv" -ErrorAction Stop

return ($service.Status -eq 'Running')

} catch {

return $false

}

}

function Invoke-PreFlightChecks {

param([switch]$Detailed)

Write-Info "Running pre-flight system checks..."

$allPassed = $true

# Check 1: Internet connectivity

Write-Host " Checking internet connectivity..." -NoNewline

if (Test-InternetConnectivity) {

Write-ColorOutput -Message " ✓" -ForegroundColor Green

} else {

Write-ColorOutput -Message " ✗" -ForegroundColor Red

Write-Warn "No internet connectivity detected. Update operations will fail."

$allPassed = $false

}

# Check 2: Disk space

Write-Host " Checking disk space..." -NoNewline

$freeSpace = Get-FreeDiskSpace -Drive "C:"

if ($freeSpace -gt 10) {

Write-ColorOutput -Message (" ✓ ({0:N2} GB free)" -f $freeSpace) -ForegroundColor Green

} elseif ($freeSpace -gt 5) {

Write-ColorOutput -Message (" ⚠ ({0:N2} GB free - Low)" -f $freeSpace) -ForegroundColor Yellow

} else {

Write-ColorOutput -Message (" ✗ ({0:N2} GB free - Critical)" -f $freeSpace) -ForegroundColor Red

Write-Warn "Insufficient disk space. At least 10GB recommended for updates."

$allPassed = $false

}

# Check 3: Windows Update service

Write-Host " Checking Windows Update service..." -NoNewline

if (Test-WindowsUpdateService) {

Write-ColorOutput -Message " ✓" -ForegroundColor Green

} else {

Write-ColorOutput -Message " ⚠" -ForegroundColor Yellow

Write-Warn "Windows Update service is not running. Attempting to start..."

try {

Start-Service -Name "wuauserv" -ErrorAction Stop

Write-Success "Windows Update service started successfully."

} catch {

Write-Err "Failed to start Windows Update service."

$allPassed = $false

}

}

# Check 4: PowerShell version

if ($Detailed) {

Write-Host " PowerShell version..." -NoNewline

$psVersion = $PSVersionTable.PSVersion

if ($psVersion.Major -ge 7 -and $psVersion.Minor -ge 5) {

Write-ColorOutput -Message (" ✓ ({0})" -f $psVersion) -ForegroundColor Green

} elseif ($psVersion.Major -ge 5) {

Write-ColorOutput -Message (" ⚠ ({0} - Consider upgrading)" -f $psVersion) -ForegroundColor Yellow

} else {

Write-ColorOutput -Message (" ✗ ({0} - Unsupported)" -f $psVersion) -ForegroundColor Red

$allPassed = $false

}

}

Write-Host ""

if ($allPassed) {

Write-Success "All pre-flight checks passed."

} else {

Write-Warn "Some pre-flight checks failed. Proceed with caution."

}

return $allPassed

}

function Test-NuGetProvider {

try {

$nuget = Get-PackageProvider -Name NuGet -ErrorAction SilentlyContinue

return ($null -ne $nuget)

} catch {

return $false

}

}

function Install-NuGetProvider {

Write-Info "Installing NuGet package provider..."

try {

# Ensure TLS 1.2 for PowerShell Gallery

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force -ErrorAction Stop | Out-Null

Write-Success "NuGet provider installed successfully."

return $true

} catch {

Write-Err "Failed to install NuGet provider: $($_.Exception.Message)"

Write-ErrorLog -Message "NuGet installation failed" -ErrorRecord $_

return $false

}

}

function Get-InstalledPowerShellVersion {

return $PSVersionTable.PSVersion

}

function Test-PowerShell7Available {

try {

$ps7Path = if ($env:ProgramFiles) {

Join-Path $env:ProgramFiles "PowerShell\7\pwsh.exe"

} else {

$null

}

if ($ps7Path -and (Test-Path $ps7Path)) {

return $true

}

$pwsh = Get-Command pwsh.exe -ErrorAction SilentlyContinue