Winget-Per-Pro (WPP)

[KnifMelti]

This project uses Windows Package Manager (WinGet) p.p./per pro. = "per procurationem" (by proxy) via Powershell to update apps (in system context) on clients/servers that Winget-AutoUpdate (WAU) can't be installed on (no internet/no Microsoft Store Barebone).

With the upcoming feature of WinGet (download) it would make sense that a WAU enabled client could download apps and dependencies to a share that a non WAU enabled client/server then could pull the installations from.
Just a thought...

[KnifMelti]

A simple start (with the $file for Get-AppList containing calibre.calibre,calibre 64bit,calibre,6.26.2 and version 6.26.0 of Calibre x64 installed triggering an action...):

# WinGet from v1.6.2561:
# winget download -d C:\_WinGet-Apps --id calibre.calibre -e --accept-package-agreements --accept-source-agreements -s winget --scope machine
#
# C:\_WinGet-Apps\
#   _WinGet-Apps.txt
#   calibre_6.26.0_Machine_X64_wix_en-US.msi
#   calibre_6.26.0_Machine_X64_wix_en-US.yaml
#
# _WinGet-Apps.txt:
# Line 1:calibre.calibre,calibre 64bit,calibre,6.26.2
#
# *.yaml:
# Line 1:PackageIdentifier: calibre.calibre
# Line 2:PackageVersion: 6.26.0
#
# Winget-Upgrade.ps1:
# $($app.Id)/$($app.Name)/$($app.Version) + $($app.PackageName)

function Get-AppList ($file) {
    # Read the file contents into a PowerShell variable.
    $fileContents = Get-Content -Path $file

    # Split the file contents into an array of strings, where each string contains the software name and version.
    $softwareArray = $fileContents.Split("`n")

    # Convert the array of strings to an array of objects, where each object contains the software name and version.
    $softwareObjects = @()
    foreach ($software in $softwareArray) {
        $id, $name, $packagename, $version = $software.Split(",")
        $object = New-Object -TypeName PSObject -Property @{
            Id = $id
            Name = $name
            PackageName = $packagename
            Version = $version
        }
        $softwareObjects += $object
    }
    return $softwareObjects
}

# Origin Website: https://adamtheautomator.com/powershell-list-installed-software/
function Get-InstalledSoftware {
    <#
	.SYNOPSIS
		Retrieves a list of all software installed on a Windows computer.
	.EXAMPLE
		PS> Get-InstalledSoftware
		
		This example retrieves all software installed on the local computer.
	.PARAMETER ComputerName
		If querying a remote computer, use the computer name here.
	
	.PARAMETER Name
		The software title you'd like to limit the query to.
	
	.PARAMETER Guid
		The software GUID you'e like to limit the query to
	#>
    [CmdletBinding()]
    param (
		
        [Parameter()]
        [ValidateNotNullOrEmpty()]
        [string]$ComputerName = $env:COMPUTERNAME,
		
        [Parameter()]
        [ValidateNotNullOrEmpty()]
        [string]$Name,
		
        [Parameter()]
        [guid]$Guid
    )
    process {
        try {
            $scriptBlock = {
                $args[0].GetEnumerator() | ForEach-Object { New-Variable -Name $_.Key -Value $_.Value }
				
                $UninstallKeys = @(
                    "HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall",
                    "HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall"
                )
                New-PSDrive -Name HKU -PSProvider Registry -Root Registry::HKEY_USERS | Out-Null
                $UninstallKeys += Get-ChildItem HKU: | Where-Object { $_.Name -match 'S-\d-\d+-(\d+-){1,14}\d+$' } | ForEach-Object {
                    "HKU:\$($_.PSChildName)\Software\Microsoft\Windows\CurrentVersion\Uninstall"
                }
                if (-not $UninstallKeys) {
                    Write-Warning -Message 'No software registry keys found'
                } else {
                    foreach ($UninstallKey in $UninstallKeys) {
                        $friendlyNames = @{
                            'DisplayName'    = 'Name'
                            'DisplayVersion' = 'Version'
                        }
                        Write-Verbose -Message "Checking uninstall key [$($UninstallKey)]"
                        if ($Name) {
                            $WhereBlock = { $_.GetValue('DisplayName') -like "$Name*" }
                        } elseif ($GUID) {
                            $WhereBlock = { $_.PsChildName -eq $Guid.Guid }
                        } else {
                            $WhereBlock = { $_.GetValue('DisplayName') }
                        }
                        $SwKeys = Get-ChildItem -Path $UninstallKey -ErrorAction SilentlyContinue | Where-Object $WhereBlock
                        if (-not $SwKeys) {
                            Write-Verbose -Message "No software keys in uninstall key $UninstallKey"
                        } else {
                            foreach ($SwKey in $SwKeys) {
                                $output = @{ }
                                foreach ($ValName in $SwKey.GetValueNames()) {
                                    if ($ValName -ne 'Version') {
                                        $output.InstallLocation = ''
                                        if ($ValName -eq 'InstallLocation' -and 
                                            ($SwKey.GetValue($ValName)) -and 
                                            (@('C:', 'C:\Windows', 'C:\Windows\System32', 'C:\Windows\SysWOW64') -notcontains $SwKey.GetValue($ValName).TrimEnd('\'))) {
                                            $output.InstallLocation = $SwKey.GetValue($ValName).TrimEnd('\')
                                        }
                                        [string]$ValData = $SwKey.GetValue($ValName)
                                        if ($friendlyNames[$ValName]) {
                                            $output[$friendlyNames[$ValName]] = $ValData.Trim() ## Some registry values have trailing spaces.
                                        } else {
                                            $output[$ValName] = $ValData.Trim() ## Some registry values trailing spaces
                                        }
                                    }
                                }
                                $output.GUID = ''
                                if ($SwKey.PSChildName -match '\b[A-F0-9]{8}(?:-[A-F0-9]{4}){3}-[A-F0-9]{12}\b') {
                                    $output.GUID = $SwKey.PSChildName
                                }
                                New-Object -TypeName PSObject -Prop $output
                            }
                        }
                    }
                }
            }
			
            if ($ComputerName -eq $env:COMPUTERNAME) {
                & $scriptBlock $PSBoundParameters
            } else {
                Invoke-Command -ComputerName $ComputerName -ScriptBlock $scriptBlock -ArgumentList $PSBoundParameters
            }
        } catch {
            Write-Error -Message "Error: $($_.Exception.Message) - Line Number: $($_.InvocationInfo.ScriptLineNumber)"
        }
    }
}

# Winget-Upgrade.ps1:
# $($app.Id)/$($app.Name)/$($app.Version) + $($app.PackageName)

# Get-AppInfo.ps1:
# $String = (& $winget show $AppID --accept-source-agreements -s winget | Out-String)
# # Search for PackageName
# $PackageName = [regex]::match($String, '(?<=Found\s*)(\w*)(?=\s*\[.*\]\s*\n)').Groups[0].Value
# Search for Release Note info
# $ReleaseNote = [regex]::match($String, '(?<=Release Notes Url: )(.*)(?=\n)').Groups[0].Value
# return $PackageName, $ReleaseNote


$Id = "calibre.calibre"
$Name = "calibre 64bit"
$PackageName = "calibre"
$Version = "6.26.2"
$AppList = "C:\_WinGet-Apps\_WinGet-Apps.txt"
$AppListPath = Split-Path $AppList -Parent
#Remove duplicate and blank lines and sort
$file = Get-Content $AppList | Select-Object -Unique | Where-Object { $_.trim() -ne "" -and $_ -notmatch $PackageName} | Sort-Object
$file | Out-File $AppList
#Add Id/Name/Version
Add-Content -path $AppList -Value "$Id,$Name,$PackageName,$Version" -Force

#Main
$softwareObjects = Get-AppList $AppList

# Iterate through the array of software objects from the file and compare them to the installed software.
foreach ($software in $softwareObjects) {
    # For each software object in the file, check if the software is installed by using Get-InstalledSoftware (REG) for the software name.
    $installedSoftwareObject = Get-InstalledSoftware -Name $software.Name
    if ($installedSoftwareObject) {
        # If the software is installed, compare the versions of the software.
        if ([version]$software.Version -gt [version]$installedSoftwareObject.Version) {
            # If the version of the software in the file is newer than the installed version, take the desired action.
            Write-Host "The version of $($software.Name) ($($software.Id)) installed on $env:COMPUTERNAME is $($installedSoftwareObject.Version) (version in file is $($software.Version))."
            Write-Host "The installer $AppListPath\$($software.PackageName)_$($software.Version)* will be used..."
        }
    }
}

[Romanitho]

This could be interesting indeed. But maybe on specific cases. We could use it as an add-on of WAU or dedicated project?

[KnifMelti]

Yes, I agree!
My loose thoughts (if implemented in WAU) is:

• Parameters for install (-WingetDownloadPath/-DownloadClients)
• Registry entries for the parameters for configuration
• Handle the registry entries via GPO
• When running Winget-Upgrade.ps1 check if COMPUTERNAME is member of -DownloadClients
• Download newer versions to the share (deleting older ones first) - writable by SYSTEM
• Upgrade/Install from the share (--manifest to run the install experience from a local YAML file if this *.yaml is that...)
• Requirement: winget settings --enable LocalManifestFiles

Then on the client/server check what type of installation it is (or try to read it from the manifest) - see my _Mods-Functions.ps1:

function Uninstall-ModsApp ($AppUninst) {
...
}

[KnifMelti]

Can't make the manifest InstallerUrl: to a file URI (tried a lot) - it points to the http: so it downloads again when winget tries...
...Winget install --manifest C:\_WinGet-Apps\calibre_6.26.0_Machine_X64_wix_en-US.yaml -h

[KnifMelti]

Manifests only support URL:s (InstallerUrl):
microsoft/winget-cli#306
So, a second download is inevitable when installing from the manifest (even if the file already is there)...

[KnifMelti]

Some hope...
microsoft/winget-cli#2911

[Romanitho]

seems very early for this kind of feature no? Winget is what it is 😅