c盘清理助手.ps1

param(
    [switch]$Execute,
    [int]$MinimumAgeDays = 3,
    [switch]$IncludeBrowserCaches,
    [switch]$IncludeDevCaches,
    [switch]$IncludeTencentCaches,
    [switch]$IncludeLarkCaches,
    [switch]$IncludeWpsCaches,
    [switch]$SkipCoreCaches,
    [switch]$IncludeVirtualMemoryReport,
    [switch]$OnlyExtraTargets,
    [string[]]$ExtraCachePath = @(),
    [string]$ReportPath = ""
)

$ErrorActionPreference = "Continue"
$script:CleanerBackendMarker = "CDriveCacheHelperBackend"

function Format-Size {
    param([double]$Bytes)
    if ($Bytes -ge 1GB) { return ("{0:N2} GB" -f ($Bytes / 1GB)) }
    if ($Bytes -ge 1MB) { return ("{0:N2} MB" -f ($Bytes / 1MB)) }
    if ($Bytes -ge 1KB) { return ("{0:N2} KB" -f ($Bytes / 1KB)) }
    return ("{0:N0} B" -f $Bytes)
}

function Get-FolderBytes {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { return 0 }
    $measure = Get-ChildItem -LiteralPath $Path -Recurse -Force -File -ErrorAction SilentlyContinue |
        Measure-Object -Property Length -Sum
    if ($null -eq $measure.Sum) { return 0 }
    return [double]$measure.Sum
}

function Test-ProtectedPath {
    param([string]$Path)

    try {
        $full = [System.IO.Path]::GetFullPath($Path).TrimEnd('\')
    } catch {
        return $true
    }

    $protectedRoots = @(
        "C:\Program Files",
        "C:\Program Files (x86)",
        "C:\Windows\WinSxS",
        "C:\Windows\System32\DriverStore",
        "C:\Windows\Installer",
        "$env:USERPROFILE\Desktop",
        "$env:USERPROFILE\Documents",
        "$env:USERPROFILE\Downloads",
        "$env:USERPROFILE\Pictures",
        "$env:USERPROFILE\Videos",
        "$env:USERPROFILE\.codex"
    )

    $protectedPatterns = @(
        "\\WeChat Files(\\|$)",
        "\\FileStorage(\\|$)",
        "\\FileRecv(\\|$)",
        "\\Msg(\\|$)",
        "\\Message(\\|$)",
        "\\Database(\\|$)",
        "\\DB(\\|$)",
        "\\Image(\\|$)",
        "\\Images(\\|$)",
        "\\Video(\\|$)",
        "\\Videos(\\|$)",
        "\\Audio(\\|$)",
        "\\Voice(\\|$)",
        "\\Attachment(\\|$)",
        "\\Documents(\\|$)",
        "\\Download(\\|$)"
    )

    if (-not $full.StartsWith("C:\", [System.StringComparison]::OrdinalIgnoreCase)) {
        return $true
    }

    foreach ($root in $protectedRoots) {
        if (-not $root) { continue }
        try {
            $p = [System.IO.Path]::GetFullPath($root).TrimEnd('\')
            if ($full.Equals($p, [System.StringComparison]::OrdinalIgnoreCase)) { return $true }
            if ($full.StartsWith($p + "\", [System.StringComparison]::OrdinalIgnoreCase)) { return $true }
        } catch {
        }
    }

    foreach ($pattern in $protectedPatterns) {
        if ($full -match $pattern) { return $true }
    }

    return $false
}

function New-Target {
    param(
        [string]$Name,
        [string]$Path,
        [string]$Reason,
        [string]$Group
    )
    [PSCustomObject]@{
        Name = $Name
        Path = $Path
        Reason = $Reason
        Group = $Group
    }
}

function Add-ExistingTarget {
    param(
        [System.Collections.ArrayList]$List,
        [string]$Name,
        [string]$Path,
        [string]$Reason,
        [string]$Group
    )
    if ([string]::IsNullOrWhiteSpace($Path)) { return }
    if (Test-Path -LiteralPath $Path) {
        [void]$List.Add((New-Target $Name $Path $Reason $Group))
    }
}

function Find-CacheDirectories {
    param(
        [string[]]$Roots,
        [string]$Group,
        [string]$Reason
    )

    $safeNames = @(
        "cache",
        "code cache",
        "gpucache",
        "dawncache",
        "shadercache"
    )

    $found = New-Object System.Collections.ArrayList
    foreach ($root in $Roots) {
        if (-not (Test-Path -LiteralPath $root)) { continue }
        $dirs = Get-ChildItem -LiteralPath $root -Recurse -Force -Directory -ErrorAction SilentlyContinue |
            Where-Object {
                $leaf = $_.Name.ToLowerInvariant()
                $safeNames -contains $leaf -and -not (Test-ProtectedPath $_.FullName)
            }
        foreach ($dir in $dirs) {
            [void]$found.Add((New-Target $dir.Name $dir.FullName $Reason $Group))
        }
    }
    return $found
}

function Clear-CacheTarget {
    param(
        [string]$Path,
        [datetime]$Cutoff
    )

    $removedBytes = 0
    $removedFiles = 0
    $failed = 0

    if (-not (Test-Path -LiteralPath $Path)) {
        return [PSCustomObject]@{ RemovedBytes = 0; RemovedFiles = 0; Failed = 0 }
    }

    $files = Get-ChildItem -LiteralPath $Path -Recurse -Force -File -ErrorAction SilentlyContinue |
        Where-Object { $_.LastWriteTime -lt $Cutoff }

    foreach ($file in $files) {
        try {
            $length = [double]$file.Length
            Remove-Item -LiteralPath $file.FullName -Force -ErrorAction Stop
            $removedBytes += $length
            $removedFiles += 1
        } catch {
            $failed += 1
        }
    }

    $dirs = Get-ChildItem -LiteralPath $Path -Recurse -Force -Directory -ErrorAction SilentlyContinue |
        Sort-Object FullName -Descending

    foreach ($dir in $dirs) {
        try {
            $hasChildren = Get-ChildItem -LiteralPath $dir.FullName -Force -ErrorAction SilentlyContinue | Select-Object -First 1
            if ($null -eq $hasChildren) {
                Remove-Item -LiteralPath $dir.FullName -Force -ErrorAction Stop
            }
        } catch {
        }
    }

    return [PSCustomObject]@{
        RemovedBytes = $removedBytes
        RemovedFiles = $removedFiles
        Failed = $failed
    }
}

function Show-VirtualMemoryReport {
    Write-Host ""
    Write-Host "Virtual memory report (report only; no settings are changed)"

    $files = @("C:\pagefile.sys", "C:\swapfile.sys", "C:\hiberfil.sys")
    foreach ($file in $files) {
        if (Test-Path -LiteralPath $file) {
            $item = Get-Item -LiteralPath $file -Force -ErrorAction SilentlyContinue
            if ($null -ne $item) {
                Write-Host ("- {0}: {1}" -f $file, (Format-Size $item.Length))
            }
        } else {
            Write-Host ("- {0}: not found or not visible" -f $file)
        }
    }

    try {
        $pagefiles = Get-CimInstance Win32_PageFileUsage -ErrorAction Stop
        foreach ($pf in $pagefiles) {
            Write-Host ("- Pagefile {0}: allocated {1} MB, current usage {2} MB, peak {3} MB" -f $pf.Name, $pf.AllocatedBaseSize, $pf.CurrentUsage, $pf.PeakUsage)
        }
    } catch {
        Write-Host "- Pagefile WMI data unavailable."
    }
}

function Get-DefaultReportPath {
    param([bool]$IsExecuteMode)

    $reportDir = Join-Path $PSScriptRoot "reports"
    New-Item -ItemType Directory -Force -Path $reportDir | Out-Null

    $kind = if ($IsExecuteMode) { "clean" } else { "scan" }
    $stamp = Get-Date -Format "yyyyMMdd-HHmmss"
    return (Join-Path $reportDir ("{0}-{1}.txt" -f $kind, $stamp))
}

function Save-RunReport {
    param(
        [object[]]$Rows,
        [string]$Path,
        [string]$Mode,
        [int]$MinimumAgeDays,
        [datetime]$Cutoff,
        [double]$TotalScannable,
        [double]$TotalRemoved,
        [int]$TotalFailed,
        [bool]$IncludeVirtualMemoryReport
    )

    try {
        $parent = Split-Path -Parent $Path
        if (-not [string]::IsNullOrWhiteSpace($parent)) {
            New-Item -ItemType Directory -Force -Path $parent | Out-Null
        }

        $lines = @()
        $lines += "C drive cache helper report"
        $lines += ("Created: {0}" -f (Get-Date))
        $lines += ("Mode: {0}" -f $Mode)
        $lines += ("Minimum age: {0} day(s)" -f $MinimumAgeDays)
        $lines += ("Cutoff: {0}" -f $Cutoff)
        $lines += ""
        $lines += "Safety boundary:"
        $lines += "- Cache only."
        $lines += "- No software uninstall."
        $lines += "- No Program Files, Windows component folders, user documents, projects, chat records, received files, or Codex memory."
        $lines += "- Virtual memory is report-only."
        $lines += ""
        $lines += "Targets:"
        $lines += (($Rows | Sort-Object Group, Name, Path | Format-Table -AutoSize | Out-String).TrimEnd())
        $lines += ""
        $lines += ("Scannable cache total: {0}" -f (Format-Size $TotalScannable))
        if ($Mode -eq "EXECUTE") {
            $lines += ("Removed: {0}" -f (Format-Size $TotalRemoved))
            $lines += ("Failed file removals, usually locked files: {0}" -f $TotalFailed)
        } else {
            $lines += "No files were deleted."
        }
        if ($IncludeVirtualMemoryReport) {
            $lines += "Virtual memory: shown in console output only; no settings changed."
        }

        Set-Content -LiteralPath $Path -Value $lines -Encoding UTF8
        return $true
    } catch {
        Write-Host ("Report save failed: {0}" -f $_.Exception.Message)
        return $false
    }
}

$targets = New-Object System.Collections.ArrayList

if (-not $OnlyExtraTargets) {
    if (-not $SkipCoreCaches) {
        Add-ExistingTarget $targets "User temp" "$env:LOCALAPPDATA\Temp" "User temporary cache" "Core"
        Add-ExistingTarget $targets "Windows temp" "C:\Windows\Temp" "Windows temporary cache" "Core"
        Add-ExistingTarget $targets "Crash dumps" "$env:LOCALAPPDATA\CrashDumps" "Application crash dump cache" "Core"
        Add-ExistingTarget $targets "D3D shader cache" "$env:LOCALAPPDATA\D3DSCache" "DirectX shader cache" "Core"
        Add-ExistingTarget $targets "NVIDIA DX cache" "$env:LOCALAPPDATA\NVIDIA\DXCache" "NVIDIA DirectX cache" "Core"
        Add-ExistingTarget $targets "NVIDIA GL cache" "$env:LOCALAPPDATA\NVIDIA\GLCache" "NVIDIA OpenGL cache" "Core"
        Add-ExistingTarget $targets "NVIDIA downloader" "$env:PROGRAMDATA\NVIDIA Corporation\Downloader" "NVIDIA driver download cache" "Core"
        Add-ExistingTarget $targets "NVIDIA package cache" "$env:PROGRAMDATA\NVIDIA Corporation\NetService" "NVIDIA network service cache" "Core"
    }

    if ($IncludeTencentCaches) {
        $tencentTargets = Find-CacheDirectories -Roots @("$env:APPDATA\Tencent", "$env:LOCALAPPDATA\Tencent") -Group "Tencent" -Reason "Conservative Tencent cache directory; chat records and received files are excluded"
        foreach ($target in $tencentTargets) { [void]$targets.Add($target) }
    }

    if ($IncludeLarkCaches) {
        $larkTargets = Find-CacheDirectories -Roots @("$env:APPDATA\LarkShell", "$env:LOCALAPPDATA\LarkShell", "$env:APPDATA\Feishu", "$env:LOCALAPPDATA\Feishu") -Group "Lark" -Reason "Conservative Lark cache directory; chat records and received files are excluded"
        foreach ($target in $larkTargets) { [void]$targets.Add($target) }
    }

    if ($IncludeWpsCaches) {
        Add-ExistingTarget $targets "WPS office cache" "$env:APPDATA\kingsoft\office6\cache" "WPS rebuildable cache" "WPS"
        Add-ExistingTarget $targets "WPS PDF temp" "$env:APPDATA\kingsoft\office6\pdf\temp" "WPS PDF temporary files" "WPS"
        Add-ExistingTarget $targets "WPS font cache" "$env:APPDATA\kingsoft\office6\docerFonts\fontsdk\cache" "WPS downloadable font cache" "WPS"
        $wpsTargets = Find-CacheDirectories -Roots @("$env:APPDATA\kingsoft\wps\addons\data") -Group "WPS" -Reason "WPS rebuildable web cache; addon pool, templates and backups are excluded"
        foreach ($target in $wpsTargets) { [void]$targets.Add($target) }
    }

    if ($IncludeBrowserCaches) {
        Add-ExistingTarget $targets "Edge cache" "$env:LOCALAPPDATA\Microsoft\Edge\User Data\Default\Cache" "Edge browser cache" "Browser"
        Add-ExistingTarget $targets "Edge code cache" "$env:LOCALAPPDATA\Microsoft\Edge\User Data\Default\Code Cache" "Edge script cache" "Browser"
        Add-ExistingTarget $targets "Chrome cache" "$env:LOCALAPPDATA\Google\Chrome\User Data\Default\Cache" "Chrome browser cache" "Browser"
        Add-ExistingTarget $targets "Chrome code cache" "$env:LOCALAPPDATA\Google\Chrome\User Data\Default\Code Cache" "Chrome script cache" "Browser"
    }

    if ($IncludeDevCaches) {
        Add-ExistingTarget $targets "VS Code cache" "$env:APPDATA\Code\Cache" "VS Code cache" "Developer"
        Add-ExistingTarget $targets "VS Code cached data" "$env:APPDATA\Code\CachedData" "VS Code extension runtime cache" "Developer"
        Add-ExistingTarget $targets "VS Code extension installer cache" "$env:APPDATA\Code\CachedExtensionVSIXs" "Downloaded VS Code extension installer packages; installed extensions are kept" "Developer"
        Add-ExistingTarget $targets "Cursor cache" "$env:APPDATA\Cursor\Cache" "Cursor cache" "Developer"
        Add-ExistingTarget $targets "Cursor cached data" "$env:APPDATA\Cursor\CachedData" "Cursor extension runtime cache" "Developer"
        Add-ExistingTarget $targets "npm cache" "$env:LOCALAPPDATA\npm-cache" "npm download cache" "Developer"
    }
}

foreach ($extra in $ExtraCachePath) {
    Add-ExistingTarget $targets "Extra cache" $extra "User-provided cache path" "Extra"
}

$cutoff = (Get-Date).AddDays(-1 * $MinimumAgeDays)
$mode = if ($Execute) { "EXECUTE" } else { "SCAN ONLY" }

Write-Host "C drive cache helper"
Write-Host "Mode: $mode"
Write-Host "Minimum age: $MinimumAgeDays day(s)"
Write-Host "Cutoff: $cutoff"
Write-Host ""
Write-Host "This script never uninstalls software and never cleans Program Files, user documents, projects, chat records, or Codex memory."
Write-Host "WeChat, QQ, and Lark handling is cache-only; received files and message data are protected."
Write-Host ""

$report = @()
$totalScannable = 0
$totalRemoved = 0
$totalFailed = 0
$seen = @{}
$coveredRoots = New-Object System.Collections.ArrayList
$groupBytes = @{}

foreach ($target in ($targets | Sort-Object @{ Expression = { $_.Path.Length } }, Path)) {
    if ([string]::IsNullOrWhiteSpace($target.Path)) { continue }
    if (-not (Test-Path -LiteralPath $target.Path)) { continue }
    $key = $target.Path.ToLowerInvariant()
    if ($seen.ContainsKey($key)) { continue }
    $seen[$key] = $true

    $covered = $false
    foreach ($root in $coveredRoots) {
        if ($target.Path.StartsWith($root + "\", [System.StringComparison]::OrdinalIgnoreCase)) {
            $covered = $true
            break
        }
    }
    if ($covered) { continue }

    if (Test-ProtectedPath $target.Path) {
        $report += [PSCustomObject]@{
            Group = $target.Group
            Name = $target.Name
            Path = $target.Path
            Size = "PROTECTED"
            Removed = "-"
            Failed = "-"
            Reason = "Skipped protected path"
        }
        continue
    }

    [void]$coveredRoots.Add($target.Path.TrimEnd('\'))

    $before = Get-FolderBytes $target.Path
    $totalScannable += $before
    if (-not $groupBytes.ContainsKey($target.Group)) { $groupBytes[$target.Group] = 0.0 }
    $groupBytes[$target.Group] += $before

    $removedText = "-"
    $failedText = "-"

    if ($Execute) {
        $result = Clear-CacheTarget -Path $target.Path -Cutoff $cutoff
        $totalRemoved += $result.RemovedBytes
        $totalFailed += $result.Failed
        $removedText = Format-Size $result.RemovedBytes
        $failedText = [string]$result.Failed
    }

    $report += [PSCustomObject]@{
        Group = $target.Group
        Name = $target.Name
        Path = $target.Path
        Size = Format-Size $before
        Removed = $removedText
        Failed = $failedText
        Reason = $target.Reason
    }
}

$sortedReport = $report | Sort-Object Group, Name, Path
$sortedReport | Format-Table -AutoSize

Write-Host ""
Write-Host "Selected category totals:"
$groupBytes.GetEnumerator() | Sort-Object Name | ForEach-Object {
    Write-Host ("- {0}: {1}" -f $_.Name, (Format-Size $_.Value))
}
Write-Host ("Scannable cache total: {0}" -f (Format-Size $totalScannable))
if ($Execute) {
    Write-Host ("Removed: {0}" -f (Format-Size $totalRemoved))
    Write-Host ("Failed file removals, usually locked files: {0}" -f $totalFailed)
} else {
    Write-Host "No files were deleted. Add -Execute to clean cache files older than the selected age."
}

if ($IncludeVirtualMemoryReport) {
    Show-VirtualMemoryReport
}

if ([string]::IsNullOrWhiteSpace($ReportPath)) {
    $ReportPath = Get-DefaultReportPath -IsExecuteMode ([bool]$Execute)
}

if (Save-RunReport -Rows $sortedReport -Path $ReportPath -Mode $mode -MinimumAgeDays $MinimumAgeDays -Cutoff $cutoff -TotalScannable $totalScannable -TotalRemoved $totalRemoved -TotalFailed $totalFailed -IncludeVirtualMemoryReport ([bool]$IncludeVirtualMemoryReport)) {
    Write-Host ("Report saved: {0}" -f $ReportPath)
}