<#

using module Microsoft.PowerShell.PSResourceGet

[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSAvoidUsingWriteHost','',

Justification='This script is not intended for pipelining.')]

[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseSingularNouns','',

Justification='Some of these functions may deal with multiple updates.')]

[CmdletBinding()] Param(

[ValidateSet('Apt','Chocolatey','DellCommand','Dotnet','Essential','Flatpak','GitHubCli','Npm','ScriptsData',

'PSHelp','PSModule','Scoop','VSCodeExtenions','WindowsUpdate','WindowsStore','WinGet')]

[Parameter(Position=0,ValueFromRemainingArguments=$true)][string[]] $Steps =

@('Essential','WindowsStore','PSModule','Scoop','Chocolatey','WinGet','Npm','Dotnet',

'GitHubCli','VSCodeExtensions','ScriptsData','PSHelp','DellCommand','WindowsUpdate','Apt','Flatpak')

)

{

$Script:IsNotAdministrator = !(Test-Administrator.ps1)

Import-CharConstants.ps1 ':UP:' ':TOP:' -Scope Script

function Test-EmptyDesktop

{

[CmdletBinding()][OutputType([bool])] Param(

[switch] $Shared

)

if(!$IsWindows) {return}

if($Shared -and $Script:IsNotAdministrator) {return $false}

$dir = [environment]::GetFolderPath(($Shared ? 'CommonDesktopDirectory' : 'Desktop' ))

return !(Join-Path $dir *.lnk |Get-Item)

}

function Clear-Desktop

{

[CmdletBinding()] Param(

[switch] $Shared

)

if(!$IsWindows) {return}

if($Shared -and $Script:IsNotAdministrator) {return}

$dir = [environment]::GetFolderPath(($Shared ? 'CommonDesktopDirectory' : 'Desktop' ))

Remove-Item (Join-Path $dir *.lnk)

}

function Write-Step

{

[CmdletBinding()] Param(

[string]$Message

)

Write-Info.ps1 $Message -ForegroundColor White -BackgroundColor DarkGray

}

function Invoke-EssentialUpdate

{

[CmdletBinding()] Param()

Write-Step "$UP Updating PowerShell & Windows Terminal"

Get-Process powershell -ErrorAction Ignore |Where-Object Id -ne $PID |Stop-Process -Force

Get-Process pwsh -ErrorAction Ignore |Where-Object Id -ne $PID |Stop-Process -Force

Start-Process ([io.path]::ChangeExtension($PSCommandPath,'cmd')) -Verb RunAs -WindowStyle Maximized

$host.SetShouldExit(0)

exit

}

function Update-Essential

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping Essential."; return}

Write-Step "$TOP Checking for essential updates"

if(Get-Command winget -ErrorAction Ignore)

{

if(@(winget list -e --id Microsoft.WindowsTerminal -s winget --upgrade-available --disable-interactivity --nowarn |

Select-Object -Skip 2 -First 1 |

Select-String Available &&

winget list -e --id Microsoft.PowerShell -s winget --upgrade-available --disable-interactivity --nowarn |

Select-Object -Skip 2 -First 1 |

Select-String Available).Count -gt 0)

{Invoke-EssentialUpdate}

}

elseif(Get-Command choco -ErrorAction Ignore)

{

if(choco outdated -r |

ConvertFrom-Csv -Delimiter '|' -Header PackageName,LocalVersion,AvailableVersion |

Where-Object PackageName -in powershell,powershell-core,microsoft-windows-terminal)

{Invoke-EssentialUpdate}

}

else

{

Write-Verbose 'Neither Chocolatey nor WinGet found, skipping essential updates'

}

}

function Update-WindowsStore

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping WindowsStore."; return}

if(!(Get-Command Get-CimInstance -ErrorAction Ignore)) {Write-Verbose 'Get-CimInstance not found, skipping WindowsStore updates'; return}

Write-Step "$UP Updating Windows Store apps (asynchronously)"

Get-CimInstance MDM_EnterpriseModernAppManagement_AppManagement01 -Namespace root\cimv2\mdm\dmmap |

Invoke-CimMethod -MethodName UpdateScanMethod

}

function Test-NoProfileMode

{

[CmdletBinding()][OutputType([bool])] Param()

return [bool]([Environment]::GetCommandLineArgs() |Where-Object {$_ -ilike '-NoP*'})

}

function Restart-UpdateWithoutProfile

{

[CmdletBinding()] Param()

Get-Process powershell -ErrorAction Ignore |Where-Object Id -ne $PID |Stop-Process -Force

Get-Process pwsh -ErrorAction Ignore |Where-Object Id -ne $PID |Stop-Process -Force

Start-Process pwsh -ArgumentList '-NoProfile','-File',$PSCommandPath

[Environment]::Exit(0)

}

function Restart-UpdateWithProfile

{

[CmdletBinding()] Param()

Start-Process pwsh

[Environment]::Exit(0)

}

function Test-AzModulesHasUpdate

{

[CmdletBinding()][OutputType([bool])] Param()

$version = @(Get-PSResource Az -ErrorAction Ignore |Measure-Object Version -Maximum)

if($version.Count -eq 0) {return}

if($version.Maximum -ge (Find-PSResource Az -Repository PSGallery).Version) {return}

$allUsers = (Get-ModuleScope.ps1 Az).Scope -eq 'AllUsers'

if($allUsers -and $Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping AzModules."; return}

return $true

}

function Update-AzModules

{

[CmdletBinding()] Param()

if(!(Test-AzModulesHasUpdate)) {return}

if(Get-Module Az) {Restart-UpdateWithoutProfile}

Write-Step "$UP Updating PowerShell Az modules"

Update-PSResource Az -Scope AllUsers -Confirm:$false

}

function Test-DbatoolsHasUpdate

{

[CmdletBinding()][OutputType([bool])] Param()

$version = @(Get-PSResource dbatools -ErrorAction Ignore |Measure-Object Version -Maximum)

if($version.Count -eq 0) {return}

if($version.Maximum -ge (Find-PSResource dbatools -Repository PSGallery).Version) {return}

$allUsers = (Get-ModuleScope.ps1 dbatools).Scope -eq 'AllUsers'

if($allUsers -and $Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping Dbatools."; return}

return $true

}

function Update-Dbatools

{

[CmdletBinding()] Param()

if(!(Test-DbatoolsHasUpdate)) {return}

if(Get-Module dbatools) {Restart-UpdateWithoutProfile}

Write-Step "$UP Upgrading PowerShell dbatools module"

Uninstall-PSResource dbatools,dbatools.library -SkipDependencyCheck

Install-PSResource dbatools -Scope AllUsers -Repository PSGallery -TrustRepository

}

function Update-PSModule

{

[CmdletBinding()] Param()

Update-Dbatools

Update-AzModules

Write-Step "$UP Updating PowerShell modules"

$isAllUsers = @{}

Get-PSResource -ErrorAction Ignore |

Group-Object Name |

Where-Object {

$found = Find-PSResource $_.Name -ErrorAction Ignore

if(!$found) {return $false}

$isAllUsers[$_.Name] = ($_ |Get-ModuleScope.ps1) -eq 'AllUsers'

if($Script:IsNotAdministrator -and $isAllUsers[$_.Name])

{

Write-Warning "Skipping module '$($_.Name)' with scope 'AllUsers'"

return $false

}

($_.Group |Measure-Object Version -Maximum).Maximum -lt [version]$found.Version

} |

ForEach-Object {

$module = $_

try {$module |Update-PSResource -Scope:( $isAllUsers[$_.Name] ? 'AllUsers' : 'CurrentUser') -TrustRepository -ErrorAction Stop}

catch

{

if($_.Exception.Message -notlike "Module '*' was not installed by using Install-PSResource, so it cannot be updated.") {throw}

Write-Warning "Unable to automatically update module '$($module.Name)'"

}

}

if(Get-Command Uninstall-OldModules.ps1 -ErrorAction Ignore)

{

Write-Step "$UP Uninstalling old PowerShell modules"

Uninstall-OldModules.ps1 -Force

}

}

function Update-Scoop

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if(!(Get-Command scoop -ErrorAction Ignore)) {Write-Verbose 'Scoop not found, skipping'; return}

Write-Step "$UP Updating Scoop packages"

scoop update *

}

function Update-Chocolatey

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping Chocolatey."; return}

if(!(Get-Command choco -ErrorAction Ignore))

{Write-Verbose 'Chocolatey not found, skipping'; return}

Write-Step "$UP Updating Chocolatey packages"

choco upgrade all -y

}

function Update-WinGet

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if(!(Get-Command winget -ErrorAction Ignore)) {Write-Verbose 'WinGet not found, skipping'; return}

Write-Step "$UP Updating WinGet packages"

winget upgrade --all

}

function Update-Npm

{

[CmdletBinding()] Param()

if(!(Get-Command npm -ErrorAction Ignore))

{Write-Verbose 'Npm not found, skipping'; return}

Write-Step "$UP Updating npm packages"

npm update -g

}

function Update-Dotnet

{

[CmdletBinding()] Param()

if(!(Get-Command dotnet -ErrorAction Ignore))

{Write-Verbose 'Dotnet not found, skipping'; return}

Write-Step "$UP Updating dotnet global tools"

& "$PSScriptRoot\Get-DotNetGlobalTools.ps1" |

Where-Object {

$_.Version -lt (& "$PSScriptRoot\Find-DotNetTools.ps1" $_.PackageName |

Where-Object PackageName -eq $_.PackageName).Version

} |

ForEach-Object {dotnet tool update -g $_.PackageName}

}

function Update-GitHubCli

{

[CmdletBinding()] Param()

if(!(Get-Command gh -ErrorAction Ignore))

{Write-Verbose 'gh not found, skipping'; return}

Write-Step "$UP Updating GitHub CLI extensions"

gh extension upgrade --all

}

function Update-VSCodeExtensions

{

[CmdletBinding()] Param()

if(!(Get-Command code -ErrorAction Ignore))

{Write-Verbose 'VSCode not found, skipping.'; return}

Write-Step "$UP Updating VSCode extensions"

code --update-extensions

}

function Update-PSHelp

{

[CmdletBinding()] Param()

Write-Step "$UP Updating PowerShell help"

Update-Help

}

function Update-ScriptsData

{

[CmdletBinding()] Param()

Write-Step "$UP Updating scripts data"

Get-UnicodeName.ps1 -Update

Get-UnicodeByName.ps1 -Update

}

function Update-DellCommand

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping DellCommand."; return}

if(!(Resolve-Path "C:\Program Files*\Dell\CommandUpdate\dcu-cli.exe"))

{Write-Verbose 'Dell Command not found, skipping'; return}

Write-Step "$UP Updating Dell firmware & system software"

Set-Alias dcu-cli "$(Resolve-Path "C:\Program Files*\Dell\CommandUpdate\dcu-cli.exe")"

dcu-cli /scan

if($LASTEXITCODE -ne 500) {dcu-cli /applyUpdates -reboot=enable}

Write-Info.ps1 ''

}

function Update-WindowsUpdate

{

[CmdletBinding()] Param()

if(!$IsWindows) {return}

if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping Windows."; return}

if(!(Get-Module PSWindowsUpdate -ListAvailable))

{Write-Verbose 'PSWindowsUpdate module not found, skipping Windows Updates'; return}

Write-Step "$UP Updating Windows"

Get-WindowsUpdate

Install-WindowsUpdate |Format-Table X,Result,KB,Size,Title

}

function Update-Apt

{

[CmdletBinding()] Param()

if(!$IsLinux) {return}

if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping apt."; return}

if(!(Get-Command apt -Type Application -ErrorAction Ignore))

{Write-Verbose 'apt not found, skipping'; return}

Write-Step "$UP Updating apt packages"

apt update

#apt dist-upgrade -y

apt autoremove -y

apt autoclean -y

}

function Update-Flatpak

{

[CmdletBinding()] Param()

if(!$IsLinux) {return}

#if($Script:IsNotAdministrator) {Write-Warning "Not running as admin; skipping flatpak."; return}

if(!(Get-Command flatpak -Type Application -ErrorAction Ignore))

{Write-Verbose 'flatpak not found, skipping'; return}

Write-Step "$UP Updating flatpak packages"

flatpak update -y --noninteractive

}

}

{

$emptyShared = Test-EmptyDesktop -Shared

$empty = Test-EmptyDesktop

try {$Steps |ForEach-Object {& "Update-$_"}}

finally

{

if($emptyShared) {Clear-Desktop -Shared}

if($empty) {Clear-Desktop}

if(Test-NoProfileMode) {Restart-UpdateWithProfile}

}

}