AmdCorePerformanceBoost.ps1

#requires -Version 5.1
#requires -RunAsAdministrator
<#
.SUMMARY
    Manages AMD Core Performance Boost in supported HP Notebooks BIOS firmware.

.DESCRIPTION
    Automatically checks whether HP Client Management Script Library (HPCMSL)
    is installed. If it is missing, the script updates the Windows PowerShell
    package-management components when necessary, installs HPCMSL from the
    PowerShell Gallery in a clean process, and then continues.

    With no action switch, the script toggles the current BIOS value after an
    interactive confirmation. Use -Enable or -Disable to request a specific
    state without a confirmation prompt. Add -Silent for unattended execution.
    Add -DryRun to preview the BIOS change without writing it.

.NOTES
    License: MIT (open source).
    Project: https://github.com/ChrispyBacon-dev/AMD-Core-Boost-PS
    Run in an elevated Windows PowerShell session on the target HP computer.
    Internet access to the PowerShell Gallery is required only when HPCMSL is
    not already installed. The installation bootstrap requires 64-bit Windows
    PowerShell 5.1. BIOS reads use Get-HPBIOSSetting/Get-HPBIOSSettingValue.
    Production testing showed that a complete shutdown and subsequent power-on
    are required to apply a successful BIOS change reliably.
#>

[CmdletBinding()]
param(
    [switch]$Enable,
    [switch]$Disable,
    [switch]$Silent,
    [switch]$DryRun
)

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

$settingName = 'AMD Core Performance Boost'
function Write-Status {
    param([Parameter(Mandatory)][string]$Message)
    Write-Information $Message -InformationAction Continue
}

function Get-HighestInstalledModuleVersion {
    param([Parameter(Mandatory)][string]$Name)

    $module = Get-Module -ListAvailable -Name $Name |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $module) {
        return [version]'0.0'
    }

    return [version]$module.Version
}

function Invoke-CleanWindowsPowerShell {
    param(
        [Parameter(Mandatory)][string]$ScriptContent,
        [Parameter(Mandatory)][string]$StageName
    )

    if (-not [Environment]::Is64BitProcess) {
        throw 'HPCMSL requires 64-bit Windows PowerShell. Open the 64-bit Windows PowerShell as Administrator and run the script again.'
    }

    $powerShellExe = Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe'
    if (-not (Test-Path -LiteralPath $powerShellExe)) {
        throw "Windows PowerShell 5.1 could not be found at '$powerShellExe'."
    }

    $temporaryScript = Join-Path $env:TEMP (
        'AmdCorePerformanceBoost-{0}-{1}.ps1' -f
            $StageName,
            ([guid]::NewGuid().ToString('N'))
    )

    try {
        $utf8WithoutBom = New-Object System.Text.UTF8Encoding($false)
        [System.IO.File]::WriteAllText($temporaryScript, $ScriptContent, $utf8WithoutBom)

        & $powerShellExe `
            -NoLogo `
            -NoProfile `
            -NonInteractive `
            -ExecutionPolicy Bypass `
            -File $temporaryScript

        $childExitCode = $LASTEXITCODE
        if ($childExitCode -ne 0) {
            throw "The '$StageName' installation stage failed with exit code $childExitCode."
        }
    }
    finally {
        Remove-Item -LiteralPath $temporaryScript -Force -ErrorAction SilentlyContinue
    }
}

function Install-HPCMSLIfMissing {
    if (Get-Module -ListAvailable -Name HPCMSL) {
        Write-Status 'HPCMSL is already installed.'
        return
    }

    Write-Status 'HPCMSL is not installed. Preparing the PowerShell package manager...'

    $minimumPowerShellGetVersion = [version]'2.2.5'
    $installedPowerShellGetVersion = Get-HighestInstalledModuleVersion -Name 'PowerShellGet'

    if ($installedPowerShellGetVersion -lt $minimumPowerShellGetVersion) {
        Write-Status (
            'Updating PowerShellGet from version {0} to 2.2.5...' -f
                $installedPowerShellGetVersion
        )

        $bootstrapScript = @'
$ErrorActionPreference = 'Stop'
Set-StrictMode -Version Latest

try {
    [Net.ServicePointManager]::SecurityProtocol =
        [Net.ServicePointManager]::SecurityProtocol -bor
        [Net.SecurityProtocolType]::Tls12

    $nugetProvider = Get-PackageProvider -Name NuGet -ListAvailable -ErrorAction SilentlyContinue |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $nugetProvider -or [version]$nugetProvider.Version -lt [version]'2.8.5.201') {
        Write-Host 'Installing the NuGet package provider...'
        Install-PackageProvider `
            -Name NuGet `
            -MinimumVersion 2.8.5.201 `
            -Force `
            -Confirm:$false | Out-Null
    }

    if (-not (Get-PSRepository -Name PSGallery -ErrorAction SilentlyContinue)) {
        Write-Host 'Registering the PowerShell Gallery...'
        Register-PSRepository -Default
    }

    $installedPowerShellGet = Get-Module -ListAvailable -Name PowerShellGet |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $installedPowerShellGet -or
        [version]$installedPowerShellGet.Version -lt [version]'2.2.5') {
        Write-Host 'Installing PowerShellGet 2.2.5 and its PackageManagement dependency...'
        Install-Module `
            -Name PowerShellGet `
            -RequiredVersion 2.2.5 `
            -Repository PSGallery `
            -Scope AllUsers `
            -Force `
            -AllowClobber `
            -Confirm:$false
    }

    $verifiedPowerShellGet = Get-Module -ListAvailable -Name PowerShellGet |
        Where-Object { [version]$_.Version -ge [version]'2.2.5' } |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $verifiedPowerShellGet) {
        throw 'PowerShellGet 2.2.5 was not found after installation.'
    }

    Write-Host ("PowerShellGet {0} is installed." -f $verifiedPowerShellGet.Version)
    exit 0
}
catch {
    Write-Error ("PowerShellGet bootstrap failed: {0}" -f $_.Exception.Message)
    exit 1
}
'@

        Invoke-CleanWindowsPowerShell `
            -ScriptContent $bootstrapScript `
            -StageName 'PowerShellGet-bootstrap'
    }
    else {
        Write-Status (
            'Compatible PowerShellGet version {0} is already installed.' -f
                $installedPowerShellGetVersion
        )
    }

    Write-Status 'Installing HPCMSL in a fresh Windows PowerShell session...'

    $hpcmslInstallScript = @'
$ErrorActionPreference = 'Stop'
Set-StrictMode -Version Latest

try {
    [Net.ServicePointManager]::SecurityProtocol =
        [Net.ServicePointManager]::SecurityProtocol -bor
        [Net.SecurityProtocolType]::Tls12

    Import-Module PowerShellGet -MinimumVersion 2.2.5 -Force -ErrorAction Stop

    $loadedPowerShellGet = Get-Module -Name PowerShellGet |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $loadedPowerShellGet -or
        [version]$loadedPowerShellGet.Version -lt [version]'2.2.5') {
        throw 'A compatible PowerShellGet version could not be loaded in the clean installation session.'
    }

    if (-not (Get-PSRepository -Name PSGallery -ErrorAction SilentlyContinue)) {
        Register-PSRepository -Default
    }

    $installParameters = @{
        Name          = 'HPCMSL'
        Repository    = 'PSGallery'
        Scope         = 'AllUsers'
        Force         = $true
        AllowClobber  = $true
        AcceptLicense = $true
        Confirm       = $false
        ErrorAction   = 'Stop'
    }

    Write-Host ("Using PowerShellGet {0}." -f $loadedPowerShellGet.Version)
    Install-Module @installParameters

    $installedHPCMSL = Get-Module -ListAvailable -Name HPCMSL |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $installedHPCMSL) {
        throw 'HPCMSL was not found after installation.'
    }

    Write-Host ("HPCMSL {0} was installed successfully." -f $installedHPCMSL.Version)
    exit 0
}
catch {
    Write-Error ("HPCMSL installation failed: {0}" -f $_.Exception.Message)
    exit 1
}
'@

    Invoke-CleanWindowsPowerShell `
        -ScriptContent $hpcmslInstallScript `
        -StageName 'HPCMSL-install'

    $installedModule = Get-Module -ListAvailable -Name HPCMSL |
        Sort-Object -Property Version -Descending |
        Select-Object -First 1

    if ($null -eq $installedModule) {
        throw 'HPCMSL installation finished, but the module is still not visible in the current session.'
    }

    Write-Status ("HPCMSL {0} is ready." -f $installedModule.Version)
}

function Write-Result {
    param(
        [Parameter(Mandatory)][string]$Status,
        [Parameter(Mandatory)][string]$Message,
        [string]$PreviousValue,
        [string]$CurrentValue
    )

    [pscustomobject]@{
        Setting       = $settingName
        Status        = $Status
        Message       = $Message
        PreviousValue = $PreviousValue
        CurrentValue  = $CurrentValue
        ShutdownNeeded = ($Status -eq 'Changed')
    }
}

if ($Enable -and $Disable) {
    throw 'Use either -Enable or -Disable, not both.'
}

Install-HPCMSLIfMissing

try {
    Import-Module HPCMSL -Force -ErrorAction Stop
}
catch {
    throw "HPCMSL is installed but could not be imported. $($_.Exception.Message)"
}

if (-not (Get-Command -Name Get-HPBIOSSetting -ErrorAction SilentlyContinue)) {
    try {
        Import-Module HP.ClientManagement -Force -ErrorAction Stop
    }
    catch {
        throw "The HP.ClientManagement module could not be imported. $($_.Exception.Message)"
    }
}

$requiredCommands = @(
    'Get-HPBIOSSetting',
    'Get-HPBIOSSettingValue',
    'Set-HPBIOSSettingValue'
)

foreach ($commandName in $requiredCommands) {
    if (-not (Get-Command -Name $commandName -ErrorAction SilentlyContinue)) {
        throw "HPCMSL is installed, but the required command '$commandName' is unavailable. Reinstall HPCMSL and try again."
    }
}

try {
    $setting = Get-HPBIOSSetting -Name $settingName -ErrorAction Stop
    $currentValue = [string](Get-HPBIOSSettingValue -Name $settingName -ErrorAction Stop)
    $currentValue = $currentValue.Trim().TrimStart('*')
}
catch {
    throw "The BIOS setting '$settingName' could not be read. It may not be exposed by this HP model or BIOS version. $($_.Exception.Message)"
}

$statePairs = @(
    [pscustomobject]@{ Enabled = 'Checked';  Disabled = 'Unchecked' },
    [pscustomobject]@{ Enabled = 'Enable';   Disabled = 'Disable' },
    [pscustomobject]@{ Enabled = 'Enabled';  Disabled = 'Disabled' },
    [pscustomobject]@{ Enabled = 'On';       Disabled = 'Off' }
)

$currentPair = $statePairs |
    Where-Object {
        $currentValue -ieq $_.Enabled -or
        $currentValue -ieq $_.Disabled
    } |
    Select-Object -First 1

if ($null -eq $currentPair) {
    $reportedProperties = @($setting.PSObject.Properties.Name) -join ', '
    throw "The current value '$currentValue' is not a recognized enabled/disabled state for '$settingName'. Returned properties: $reportedProperties. No change was made."
}

$enabledValue = [string]$currentPair.Enabled
$disabledValue = [string]$currentPair.Disabled

if ($Enable) {
    $targetValue = $enabledValue
    $action = 'enable'
}
elseif ($Disable) {
    $targetValue = $disabledValue
    $action = 'disable'
}
elseif ($currentValue -eq $disabledValue) {
    $targetValue = $enabledValue
    $action = 'enable'
}
elseif ($currentValue -eq $enabledValue) {
    $targetValue = $disabledValue
    $action = 'disable'
}
else {
    Write-Result -Status 'Unchanged' -Message 'The current value is not recognized as enabled or disabled. No change was made.' -CurrentValue $currentValue
    return
}

if ($currentValue -eq $targetValue) {
    Write-Result -Status 'Unchanged' -Message "The setting is already ${action}d." -PreviousValue $currentValue -CurrentValue $currentValue
    return
}

if (-not ($Enable -or $Disable) -and -not $Silent -and -not $DryRun) {
    Write-Status "Current BIOS value: $currentValue"
    Write-Status "Proposed BIOS value: $targetValue"

    if (-not $PSCmdlet.ShouldContinue(
            "Do you want to $action '$settingName'?",
            'Confirm BIOS change')) {
        Write-Result -Status 'Cancelled' -Message 'No BIOS change was made.' -PreviousValue $currentValue -CurrentValue $currentValue
        return
    }
}

if ($DryRun) {
    Write-Result -Status 'DryRun' -Message "The setting would be changed to '$targetValue'." -PreviousValue $currentValue -CurrentValue $currentValue
    return
}

$setResult = Set-HPBIOSSettingValue -Name $settingName -Value $targetValue

$updatedValue = [string](Get-HPBIOSSettingValue -Name $settingName -ErrorAction Stop)
$updatedValue = $updatedValue.Trim().TrimStart('*')

if ($updatedValue -ne $targetValue) {
    throw "The BIOS change did not verify. Current reported value: $updatedValue. Command result: $setResult"
}

Write-Result -Status 'Changed' -Message 'The BIOS setting was updated successfully. Shut down Windows completely, then power the computer on again to apply it.' -PreviousValue $currentValue -CurrentValue $updatedValue

if (-not ($Enable -or $Disable) -and -not $Silent) {
    $shutdownChoices = [System.Management.Automation.Host.ChoiceDescription[]]@(
        (New-Object -TypeName System.Management.Automation.Host.ChoiceDescription -ArgumentList ('&Shut down now', 'Shut down Windows in 10 seconds.')),
        (New-Object -TypeName System.Management.Automation.Host.ChoiceDescription -ArgumentList ('Shut down &later', 'Leave Windows running so you can shut it down manually.'))
    )

    $shutdownChoice = $Host.UI.PromptForChoice(
        'Complete shutdown required',
        'The BIOS change requires a complete shutdown. Shut down Windows in 10 seconds?',
        $shutdownChoices,
        1
    )

    if ($shutdownChoice -eq 0) {
        Write-Status 'Windows will shutdown in 10 seconds. Power the computer on again to apply the BIOS change.'
        & shutdown.exe /s /t 10
    }
    else {
        Write-Status 'Shutdown postponed. Shutdown Windows completely, then power the computer on again to apply the BIOS change.'
    }
}