Different update schedules

[pirathotten]

Hi, is it possible to have different update schedule's ?
Let's say you have your basic whitelist apps that you want to update daily then you have these other more sensitive apps that you want updates on a more controlled schedule...say bi weekly....is this possible ?
Can I modify something to do that ?
like through a GPO create a policy (scheduled task) that updates a specified app certain times ?
while still having priority apps updated daily ?

[KnifMelti]

Hi!
Do you have a specific use case I'll see what I can come up with using _WAU-mods.ps1?

[KnifMelti]

I.E. what specific apps, what priority apps, what schedule for the different app groups, other apps...

[pirathotten]

I don't have any actual examples.

But some software you might want to update everyday because of CVE issues, like vcredist, dot.net or other built in windows base software.
But then there might be other softwares that you would like to schedule that might have graphical changes or feature changes like notepad++, winrar... so you would like to push it to a pilot group before sending it to everyone and have times when you know that "this kind of software will be updated for example the second thursday every month the schedule can most probably be made in task scheduler.

[KnifMelti]

Found an error in the previous one.
Now this instead...

_WAU-mods.ps1:

<#
.SYNOPSIS
    Dynamic schedule-based filtering of included_apps.txt

.DESCRIPTION
    This mod runs AFTER WAU has downloaded the master included_apps.txt from external source
    but BEFORE WAU processes updates.
    
    It filters which apps should be updated today based on schedule rules.
    
    IMPORTANT: This script creates a backup and filters the list.
    _WAU-mods-postsys.ps1 will restore the original after updates complete.

.NOTES
    Author: WAU Community
    Version: 1.0
    
    Place this file on your external ModsPath (e.g., web server).
    WAU will download it and execute before checking for app updates.
    
    This script runs in the scope of Winget-Upgrade.ps1, so variables like
    $WAUInstallLocation are already available from the parent script.
#>

#region Configuration

# Daily apps (critical security - ALWAYS updated)
$DailyApps = @(
    'Microsoft.VCRedist.2015+.x64',
    'Microsoft.VCRedist.2015+.x86',
    'Microsoft.DotNet.DesktopRuntime.8',
    'Microsoft.DotNet.DesktopRuntime.7',
    'Microsoft.EdgeWebView2Runtime',
    'Mozilla.Firefox',
    'Google.Chrome',
    'Microsoft.Edge'
)

# Weekly apps (updated every Wednesday)
$WeeklyApps = @(
    '7zip.7zip',
    'VideoLAN.VLC',
    'Adobe.Acrobat.Reader.64-bit',
    'Notepad++.Notepad++'
)

# Monthly apps (second Thursday - pilot testing)
$MonthlyApps = @(
    'RARLab.WinRAR',
    'Microsoft.PowerToys',
    'Microsoft.VisualStudioCode'
)

# Pilot computers (get everything immediately)
$PilotComputers = @(
    'PILOT-PC-01',
    'PILOT-PC-02',
    'IT-ADMIN-LAPTOP'
)

# DEFAULT schedule for apps NOT in any category above
# Options: 'Daily', 'Weekly', 'Monthly', 'Never'
$DefaultSchedule = 'Weekly'  # All undefined apps will follow weekly schedule

# Schedule settings
$WeeklyUpdateDay = 'Wednesday'  # Day of week for weekly updates
$MonthlyUpdateWeek = 2          # Which week (1-4) for monthly updates
$MonthlyUpdateDay = 'Thursday'  # Day of week for monthly updates

#endregion Configuration

#region Functions

function Write-ModLog {
    <#
    .SYNOPSIS
        Write log message to mods-schedule.log
    #>
    param(
        [string]$Message,
        [ValidateSet('Info', 'Warning', 'Error', 'Success')]
        [string]$Level = 'Info'
    )
    
    $timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
    $logPath = Join-Path $WAUInstallLocation 'logs\mods-schedule.log'
    
    $color = switch ($Level) {
        'Warning' { 'Yellow' }
        'Error'   { 'Red' }
        'Success' { 'Green' }
        default   { 'White' }
    }
    
    $logLine = "[$timestamp] [$Level] $Message"
    $logLine | Out-File -FilePath $logPath -Append -Encoding UTF8
    Write-Host $logLine -ForegroundColor $color
}

function Get-NthDayOfMonth {
    <#
    .SYNOPSIS
        Calculate the Nth occurrence of a specific weekday in a month
    .EXAMPLE
        Get-NthDayOfMonth -Year 2025 -Month 11 -DayOfWeek Thursday -Occurrence 2
        Returns the second Thursday of November 2025
    #>
    param(
        [int]$Year,
        [int]$Month,
        [DayOfWeek]$DayOfWeek,
        [int]$Occurrence  # 1 = first, 2 = second, etc.
    )
    
    $firstDayOfMonth = [datetime]::new($Year, $Month, 1)
    $firstTargetDay = $firstDayOfMonth
    
    # Find first occurrence of target day
    while ($firstTargetDay.DayOfWeek -ne $DayOfWeek) {
        $firstTargetDay = $firstTargetDay.AddDays(1)
    }
    
    # Add weeks to get nth occurrence
    $targetDate = $firstTargetDay.AddDays(7 * ($Occurrence - 1))
    
    # Verify still in same month
    if ($targetDate.Month -eq $Month) {
        return $targetDate
    }
    else {
        return $null
    }
}

function Test-AppInSchedule {
    <#
    .SYNOPSIS
        Test if an app should be updated based on schedule
    #>
    param(
        [string]$AppId,
        [string]$Schedule,
        [datetime]$CurrentDate,
        [DayOfWeek]$WeeklyDay,
        [int]$MonthlyWeek,
        [DayOfWeek]$MonthlyDay
    )
    
    switch ($Schedule) {
        'Daily' {
            return $true
        }
        'Weekly' {
            return ($CurrentDate.DayOfWeek -eq $WeeklyDay)
        }
        'Monthly' {
            $targetDate = Get-NthDayOfMonth -Year $CurrentDate.Year `
                                            -Month $CurrentDate.Month `
                                            -DayOfWeek $MonthlyDay `
                                            -Occurrence $MonthlyWeek
            return ($targetDate -and $CurrentDate.Date -eq $targetDate.Date)
        }
        'Never' {
            return $false
        }
        default {
            return $false
        }
    }
}

#endregion Functions

#region Main Logic

try {
    # Use WAUInstallLocation from parent scope (set by Winget-Upgrade.ps1)
    if (-not $WAUInstallLocation) {
        Write-Host "ERROR: WAUInstallLocation not found in scope" -ForegroundColor Red
        exit 2
    }
    
    Write-ModLog "=== WAU Schedule Mod (PRE) Started ===" -Level Info
    Write-ModLog "Installation: $WAUInstallLocation" -Level Info
    
    # Define file paths
    $MasterListPath = Join-Path $WAUInstallLocation 'included_apps.txt'
    $BackupPath = "$MasterListPath.original-backup"
    
    # Verify master list exists
    if (-not (Test-Path $MasterListPath)) {
        Write-ModLog "Master included_apps.txt not found! Exiting." -Level Error
        exit 0
    }
    
    # CRITICAL: Backup original file WITH timestamps
    $OriginalFile = Get-Item $MasterListPath
    
    # Delete old backup first
    if (Test-Path $BackupPath) {
        Remove-Item $BackupPath -Force
    }
    
    # Create backup (preserves all attributes)
    Copy-Item $MasterListPath $BackupPath -Force
    Write-ModLog "Created backup: $BackupPath" -Level Success
    
    # Store timestamps in a separate metadata file for post script
    $TimestampFile = "$BackupPath.timestamps"
    @{
        CreationTime = $OriginalFile.CreationTime
        LastWriteTime = $OriginalFile.LastWriteTime
        LastAccessTime = $OriginalFile.LastAccessTime
    } | Export-Clixml -Path $TimestampFile -Force
    
    Write-ModLog "Saved original timestamps:" -Level Info
    Write-ModLog "  - Created:    $($OriginalFile.CreationTime.ToString('yyyy-MM-dd HH:mm:ss'))" -Level Info
    Write-ModLog "  - LastWrite:  $($OriginalFile.LastWriteTime.ToString('yyyy-MM-dd HH:mm:ss'))" -Level Info
    
    # Load master list
    $AllApps = Get-Content $MasterListPath -ErrorAction Stop | 
               Where-Object { $_ -and $_.Trim() -ne '' -and !$_.StartsWith('#') }
    
    Write-ModLog "Loaded $($AllApps.Count) apps from master list" -Level Info
    
    # Initialize categorized tracking
    $AppsToUpdate = [System.Collections.Generic.List[string]]::new()
    $CategoryCount = @{
        Daily    = 0
        Weekly   = 0
        Monthly  = 0
        Default  = 0
        Pilot    = 0
    }
    
    # Get current date/time info
    $Now = Get-Date
    $CurrentDayOfWeek = $Now.DayOfWeek
    
    # Check if this computer is in pilot group
    $IsPilotComputer = $PilotComputers -contains $env:COMPUTERNAME
    
    if ($IsPilotComputer) {
        Write-ModLog "This is a PILOT computer ($env:COMPUTERNAME) - including ALL apps" -Level Success
        foreach ($app in $AllApps) {
            $AppsToUpdate.Add($app)
            $CategoryCount.Pilot++
        }
    }
    else {
        # Regular computers follow schedule-based filtering
        foreach ($app in $AllApps) {
            $shouldInclude = $false
            $category = $null
            
            # Check Daily apps (highest priority)
            if ($DailyApps -contains $app) {
                $shouldInclude = $true
                $category = 'Daily'
            }
            # Check Weekly apps
            elseif ($WeeklyApps -contains $app) {
                if ($CurrentDayOfWeek -eq $WeeklyUpdateDay) {
                    $shouldInclude = $true
                    $category = 'Weekly'
                }
            }
            # Check Monthly apps
            elseif ($MonthlyApps -contains $app) {
                $monthlyDate = Get-NthDayOfMonth -Year $Now.Year `
                                                 -Month $Now.Month `
                                                 -DayOfWeek $MonthlyUpdateDay `
                                                 -Occurrence $MonthlyUpdateWeek
                
                if ($monthlyDate -and $Now.Date -eq $monthlyDate.Date) {
                    $shouldInclude = $true
                    $category = 'Monthly'
                }
            }
            # DEFAULT schedule for apps not explicitly categorized
            else {
                if (Test-AppInSchedule -AppId $app `
                                       -Schedule $DefaultSchedule `
                                       -CurrentDate $Now `
                                       -WeeklyDay $WeeklyUpdateDay `
                                       -MonthlyWeek $MonthlyUpdateWeek `
                                       -MonthlyDay $MonthlyUpdateDay) {
                    $shouldInclude = $true
                    $category = 'Default'
                }
            }
            
            # Add to update list if scheduled for today
            if ($shouldInclude) {
                $AppsToUpdate.Add($app)
                $CategoryCount[$category]++
            }
        }
        
        # Log categorization summary
        Write-ModLog "Apps by category:" -Level Info
        Write-ModLog "  - Daily (critical):         $($CategoryCount.Daily)" -Level Info
        Write-ModLog "  - Weekly:                   $($CategoryCount.Weekly)" -Level Info
        Write-ModLog "  - Monthly:                  $($CategoryCount.Monthly)" -Level Info
        Write-ModLog "  - Default ($DefaultSchedule): $($CategoryCount.Default)" -Level Info
    }
    
    # Remove duplicates and sort
    $AppsToUpdate = $AppsToUpdate | Select-Object -Unique | Sort-Object
    
    # Write filtered list to included_apps.txt
    if ($AppsToUpdate.Count -gt 0) {
        $AppsToUpdate | Out-File $MasterListPath -Encoding UTF8 -Force
        Write-ModLog "Updated included_apps.txt with $($AppsToUpdate.Count) apps for today" -Level Success
        Write-ModLog "Apps: $($AppsToUpdate -join ', ')" -Level Info
    }
    else {
        Write-ModLog "WARNING: No apps selected for update!" -Level Warning
        "" | Out-File $MasterListPath -Encoding UTF8 -Force
    }
    
    # Summary
    Write-ModLog "=== Schedule Mod (PRE) Completed ===" -Level Success
    Write-ModLog "Computer: $env:COMPUTERNAME $(if($IsPilotComputer){'(PILOT)'})" -Level Info
    Write-ModLog "Date: $($Now.ToString('yyyy-MM-dd (dddd)'))" -Level Info
    Write-ModLog "Total apps in master: $($AllApps.Count)" -Level Info
    Write-ModLog "Apps to update today: $($AppsToUpdate.Count)" -Level Info
    Write-ModLog "NOTE: Original will be restored by _WAU-mods-postsys.ps1" -Level Info
}
catch {
    Write-ModLog "CRITICAL ERROR: $($_.Exception.Message)" -Level Error
    Write-ModLog "Stack: $($_.ScriptStackTrace)" -Level Error
    exit 2
}

#endregion Main Logic

_WAU-mods-postsys.ps1:

<#
.SYNOPSIS
    Restore original included_apps.txt after WAU updates complete

.DESCRIPTION
    This post-system script runs AFTER WAU has processed all app updates.
    It restores the original included_apps.txt from backup with correct timestamps.
    
    This ensures that:
    1. The master list is restored for next WAU sync check
    2. Original timestamps are preserved so WAU can detect server updates

.NOTES
    Author: WAU Community
    Version: 1.0
    
    Place this file on your external ModsPath (e.g., web server).
    WAU will download it and execute after app updates complete.
    
    Naming: _WAU-mods-postsys.ps1 (runs after system context updates)
    
    This script runs in the scope of Winget-Upgrade.ps1, so variables like
    $WAUInstallLocation are already available from the parent script.
#>

try {
    # Use WAUInstallLocation from parent scope
    if (-not $WAUInstallLocation) {
        Write-Host "ERROR: WAUInstallLocation not found in scope" -ForegroundColor Red
        exit 2
    }
    
    $timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
    $logPath = Join-Path $WAUInstallLocation 'logs\mods-schedule.log'
    
    function Write-PostLog {
        <#
        .SYNOPSIS
            Write log message with POSTSYS prefix
        #>
        param([string]$Message, [string]$Color = 'White')
        $logLine = "[$timestamp] [POSTSYS] $Message"
        $logLine | Out-File -FilePath $logPath -Append -Encoding UTF8
        Write-Host $logLine -ForegroundColor $Color
    }
    
    Write-PostLog "=== WAU Schedule Mod (POSTSYS) Started ===" -Color Cyan
    
    # Define file paths
    $MasterListPath = Join-Path $WAUInstallLocation 'included_apps.txt'
    $BackupPath = "$MasterListPath.original-backup"
    $TimestampFile = "$BackupPath.timestamps"
    
    # Check if backup exists
    if (-not (Test-Path $BackupPath)) {
        Write-PostLog "No backup found - nothing to restore" -Color Yellow
        exit 0
    }
    
    # Restore original file from backup
    Copy-Item $BackupPath $MasterListPath -Force
    Write-PostLog "Restored original included_apps.txt from backup" -Color Green
    
    # Restore original timestamps
    if (Test-Path $TimestampFile) {
        $timestamps = Import-Clixml -Path $TimestampFile
        
        $restoredFile = Get-Item $MasterListPath
        $restoredFile.CreationTime = $timestamps.CreationTime
        $restoredFile.LastWriteTime = $timestamps.LastWriteTime
        $restoredFile.LastAccessTime = $timestamps.LastAccessTime
        
        Write-PostLog "Restored original timestamps:" -Color Green
        Write-PostLog "  - Created:    $($timestamps.CreationTime.ToString('yyyy-MM-dd HH:mm:ss'))" -Color Gray
        Write-PostLog "  - LastWrite:  $($timestamps.LastWriteTime.ToString('yyyy-MM-dd HH:mm:ss'))" -Color Gray
        
        # Clean up timestamp metadata file
        Remove-Item $TimestampFile -Force -ErrorAction SilentlyContinue
        Write-PostLog "Cleaned up timestamp metadata" -Color Gray
    }
    else {
        Write-PostLog "WARNING: Timestamp file not found - timestamps may not be accurate" -Color Yellow
    }
    
    # Optional: Keep backup for debugging (comment out to clean up)
    # Remove-Item $BackupPath -Force -ErrorAction SilentlyContinue
    # Write-PostLog "Cleaned up backup file" -Color Gray
    
    Write-PostLog "=== Schedule Mod (POSTSYS) Completed ===" -Color Cyan
    Write-PostLog "Master list restored - ready for next WAU sync check" -Color Green
}
catch {
    $timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
    $logPath = Join-Path $WAUInstallLocation 'logs\mods-schedule.log'
    "[$timestamp] [POSTSYS] ERROR: $($_.Exception.Message)" | Out-File -FilePath $logPath -Append -Encoding UTF8
    Write-Host "[$timestamp] [POSTSYS] ERROR: $($_.Exception.Message)" -ForegroundColor Red
    exit 2
}

WAU Schedule-Based Update Mod
Multi-schedule update solution for Winget-AutoUpdate (WAU) that allows different update cadences for different application categories.

🎯 Purpose
This mod enables you to:

Update critical security apps (browsers, runtimes) daily
Update standard apps (7zip, VLC) on a weekly schedule
Update pilot-tested apps (PowerToys, VS Code) on a monthly schedule
Set a default schedule for all other apps not explicitly categorized
Give pilot computers immediate access to all updates for testing

1. Customize Schedules
   Edit _WAU-mods.ps1 to configure your schedules:

Daily apps (critical security - ALWAYS updated)

$DailyApps = @(
'Microsoft.VCRedist.2015+.x64',
'Mozilla.Firefox',
'Google.Chrome'
)

Weekly apps (updated every Wednesday)

$WeeklyApps = @(
'7zip.7zip',
'VideoLAN.VLC'
)

Monthly apps (second Thursday - pilot testing)

$MonthlyApps = @(
'RARLab.WinRAR',
'Microsoft.PowerToys'
)

Pilot computers (get everything immediately)

$PilotComputers = @(
'PILOT-PC-01',
'PILOT-PC-02'
)

DEFAULT schedule for undefined apps

$DefaultSchedule = 'Weekly' # Options: 'Daily', 'Weekly', 'Monthly', 'Never'

Schedule settings

$WeeklyUpdateDay = 'Wednesday'
$MonthlyUpdateWeek = 2 # 1-4 (first, second, third, fourth)
$MonthlyUpdateDay = 'Thursday'

🔄 How It Works
Execution Flow

1. WAU Task Scheduler triggers (e.g., daily at 6 AM)

2. WAU syncs from external path:
   ✓ Downloads included_apps.txt (if newer)
   ✓ Downloads _WAU-mods.ps1 (if newer)
   ✓ Downloads _WAU-mods-postsys.ps1 (if newer)

3. WAU runs _WAU-mods.ps1 (PRE-processing):
   ├─ Backs up original included_apps.txt
   ├─ Saves file timestamps to metadata file
   ├─ Filters apps based on today's schedule
   └─ Writes filtered list to included_apps.txt

4. WAU processes app updates:
   └─ Only updates apps in filtered list

5. WAU runs _WAU-mods-postsys.ps1 (POST-processing):
   ├─ Restores original included_apps.txt from backup
   ├─ Restores original file timestamps
   └─ Cleans up metadata files

6. WAU completes
   └─ included_apps.txt restored with correct timestamps

Next Day:
✓ included_apps.txt = original content
✓ Timestamps = from last server download
✓ WAU can detect new server versions correctly

File Timestamp Management
Critical: The mod preserves original file timestamps to ensure WAU's sync mechanism works correctly:

Without timestamp preservation: WAU would think the local file is newer than the server version and never download updates
With timestamp preservation: WAU correctly compares timestamps and downloads updates when available

📊 Schedule Categories
Daily Updates (Highest Priority)
Apps that update every day regardless of schedule:
Critical security components (VCRedist, .NET Runtime)
Web browsers (Firefox, Chrome, Edge)
Security-critical utilities
Weekly Updates
Apps that update on a specific day of the week (default: Wednesday):

Standard utilities (7zip, VLC)
Common productivity tools
Apps explicitly listed in $WeeklyApps
Monthly Updates
Apps that update on a specific day of a specific week (default: 2nd Thursday):

Apps requiring pilot testing
Major productivity tools
Apps with significant UI/feature changes
Default Schedule
Apps not explicitly categorized follow the $DefaultSchedule:

Set to 'Daily' for aggressive updates
Set to 'Weekly' for balanced approach (recommended)
Set to 'Monthly' for conservative updates
Set to 'Never' to only update explicitly listed apps

Pilot Computers
Computers listed in $PilotComputers get ALL apps immediately:
Perfect for IT testing before broad deployment
Bypasses all schedule filtering
Useful for validation and early issue detection