Automatiza la auditoría y actualización de programas en Windows con Winget y PowerShell

Problema real

En muchas computadoras con Windows, los programas se actualizan de forma desordenada: algunos muestran alertas, otros se actualizan solos y otros quedan olvidados durante meses. Esto genera tres problemas concretos:

1. Riesgo de seguridad por software desactualizado.
2. Pérdida de tiempo revisando programa por programa.
3. Falta de evidencia para saber qué se actualizó y qué quedó pendiente.

La solución práctica es usar winget, el administrador de paquetes oficial de Windows, junto con PowerShell para generar un reporte local y ejecutar actualizaciones de forma controlada.

Esta guía te permite crear un pequeño flujo de mantenimiento que puedes usar en tu propia PC, en equipos de oficina o como rutina básica de soporte técnico.

Qué vas a lograr

Al finalizar tendrás:

• Un inventario rápido de programas instalados.
• Una lista de aplicaciones con actualizaciones disponibles.
• Un reporte .csv guardado en tu escritorio.
• Un comando seguro para actualizar todo.
• Una alternativa para actualizar solo una aplicación específica.
• Un archivo JSON para respaldar la lista de programas instalables con winget.

Requisitos previos

Paso 1: Verifica si Winget está instalado

Abre PowerShell y ejecuta:

winget --version

Si aparece una versión, por ejemplo:

v1.10.390

entonces winget está disponible.

Si el sistema responde que el comando no existe, actualiza o instala App Installer desde Microsoft Store, ya que winget forma parte del Administrador de paquetes de Windows.

Paso 2: Lista los programas instalados

Ejecuta:

winget list

Este comando muestra aplicaciones instaladas en el equipo, tanto las instaladas con winget como muchas instaladas por otros medios.

Para buscar una aplicación concreta:

winget list --name "Google Chrome"

O por identificador:

winget list --id Google.Chrome

Paso 3: Revisa qué programas tienen actualización disponible

Ejecuta:

winget upgrade

Este comando muestra una tabla con aplicaciones que tienen una versión más reciente disponible.

Ejemplo de salida esperada:

Name                  Id                 Version      Available
Google Chrome         Google.Chrome      123.0.0      124.0.0
7-Zip                 7zip.7zip          23.01        24.05
Visual Studio Code    Microsoft.VisualStudioCode 1.89 1.90

Paso 4: Genera un reporte local en CSV

Crea una carpeta para reportes:

New-Item -ItemType Directory -Path "$env:USERPROFILE\Desktop\Reporte-Winget" -Force

Ahora genera un archivo de texto con las actualizaciones detectadas:

winget upgrade > "$env:USERPROFILE\Desktop\Reporte-Winget\actualizaciones-winget.txt"

Este método es simple y funciona bien para revisión rápida.

Si deseas un CSV estructurado, usa este script:

$Fecha = Get-Date -Format "yyyy-MM-dd_HH-mm"
$Ruta = "$env:USERPROFILE\Desktop\Reporte-Winget"
$Archivo = "$Ruta\actualizaciones-winget-$Fecha.csv"

New-Item -ItemType Directory -Path $Ruta -Force | Out-Null

$Salida = winget upgrade

$Lineas = $Salida | Select-Object -Skip 2 | Where-Object {
    $_ -match '\S' -and $_ -notmatch '^-+'
}

$Resultado = foreach ($Linea in $Lineas) {
    $Texto = $Linea -replace '\s{2,}', '|'
    $Partes = $Texto.Split('|')

    if ($Partes.Count -ge 4) {
        [PSCustomObject]@{
            Nombre             = $Partes[0].Trim()
            Id                 = $Partes[1].Trim()
            VersionInstalada   = $Partes[2].Trim()
            VersionDisponible  = $Partes[3].Trim()
            FechaReporte       = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
        }
    }
}

$Resultado | Export-Csv -Path $Archivo -NoTypeInformation -Encoding UTF8

Write-Host "Reporte generado en: $Archivo"

Resultado esperado:

actualizaciones-winget-2026-05-12_10-30.csv

Este archivo puede abrirse en Excel, Power BI o cualquier editor CSV.

Paso 5: Actualiza todas las aplicaciones disponibles

Para actualizar todo lo que winget detecte:

winget upgrade --all

Para evitar confirmaciones repetitivas en escenarios controlados:

winget upgrade --all --accept-package-agreements --accept-source-agreements

Recomendación: antes de ejecutar una actualización masiva, revisa la lista con:

winget upgrade

Paso 6: Actualiza una sola aplicación

Si solo quieres actualizar Google Chrome:

winget upgrade --id Google.Chrome

Para Visual Studio Code:

winget upgrade --id Microsoft.VisualStudioCode

Para 7-Zip:

winget upgrade --id 7zip.7zip

Este método es más seguro cuando estás en una PC de trabajo y no quieres modificar todo el entorno de una sola vez.

Paso 7: Exporta tu lista de aplicaciones instalables

Si quieres respaldar una lista de aplicaciones para reinstalarlas luego en otra PC, ejecuta:

winget export -o "$env:USERPROFILE\Desktop\Reporte-Winget\apps-winget.json"

Esto genera un archivo JSON con aplicaciones reconocidas por winget.

Ejemplo:

{
  "$schema": "https://aka.ms/winget-packages.schema.2.0.json",
  "Sources": [
    {
      "Packages": [
        {
          "PackageIdentifier": "Google.Chrome"
        },
        {
          "PackageIdentifier": "Microsoft.VisualStudioCode"
        }
      ],
      "SourceDetails": {
        "Argument": "https://cdn.winget.microsoft.com/cache",
        "Identifier": "Microsoft.Winget.Source_8wekyb3d8bbwe",
        "Name": "winget",
        "Type": "Microsoft.PreIndexed.Package"
      }
    }
  ]
}

Paso 8: Importa aplicaciones en otra PC

En una nueva computadora, puedes usar:

winget import -i "$env:USERPROFILE\Desktop\Reporte-Winget\apps-winget.json"

Esto es útil para:

• Reinstalar rápidamente programas después de formatear.
• Preparar una laptop nueva.
• Estandarizar equipos de oficina.
• Documentar entornos técnicos de trabajo.

Script completo: auditoría + reporte + actualización opcional

Guarda el siguiente contenido como:

mantenimiento-winget.ps1

Código:

$Ruta = "$env:USERPROFILE\Desktop\Reporte-Winget"
$Fecha = Get-Date -Format "yyyy-MM-dd_HH-mm"
$ArchivoTxt = "$Ruta\actualizaciones-winget-$Fecha.txt"
$ArchivoCsv = "$Ruta\actualizaciones-winget-$Fecha.csv"
$ArchivoJson = "$Ruta\apps-winget-$Fecha.json"

New-Item -ItemType Directory -Path $Ruta -Force | Out-Null

Write-Host "Verificando versión de Winget..."
winget --version

Write-Host "Generando reporte TXT..."
winget upgrade > $ArchivoTxt

Write-Host "Procesando reporte CSV..."
$Salida = winget upgrade

$Lineas = $Salida | Select-Object -Skip 2 | Where-Object {
    $_ -match '\S' -and $_ -notmatch '^-+'
}

$Resultado = foreach ($Linea in $Lineas) {
    $Texto = $Linea -replace '\s{2,}', '|'
    $Partes = $Texto.Split('|')

    if ($Partes.Count -ge 4) {
        [PSCustomObject]@{
            Nombre             = $Partes[0].Trim()
            Id                 = $Partes[1].Trim()
            VersionInstalada   = $Partes[2].Trim()
            VersionDisponible  = $Partes[3].Trim()
            FechaReporte       = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
        }
    }
}

$Resultado | Export-Csv -Path $ArchivoCsv -NoTypeInformation -Encoding UTF8

Write-Host "Exportando lista de aplicaciones reconocidas por Winget..."
winget export -o $ArchivoJson --accept-source-agreements

Write-Host ""
Write-Host "Reportes generados:"
Write-Host "TXT:  $ArchivoTxt"
Write-Host "CSV:  $ArchivoCsv"
Write-Host "JSON: $ArchivoJson"
Write-Host ""

$Respuesta = Read-Host "¿Deseas actualizar todas las aplicaciones ahora? Escribe SI para continuar"

if ($Respuesta -eq "SI") {
    winget upgrade --all --accept-package-agreements --accept-source-agreements
} else {
    Write-Host "Actualización cancelada. Solo se generaron los reportes."
}

Para ejecutarlo:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\mantenimiento-winget.ps1

Casos prácticos de uso

Caso 1: mantenimiento mensual de una laptop personal

Ejecutas el script una vez al mes, revisas el CSV y actualizas solo los programas importantes.

Comando recomendado:

winget upgrade

Luego actualizas individualmente:

winget upgrade --id Mozilla.Firefox

Caso 2: soporte técnico en oficina pequeña

Antes de intervenir una PC, generas evidencia:

winget upgrade > "$env:USERPROFILE\Desktop\actualizaciones-pendientes.txt"

Luego actualizas:

winget upgrade --all

Y guardas el archivo como respaldo de la atención realizada.

Caso 3: preparar una PC nueva

En la PC antigua:

winget export -o "$env:USERPROFILE\Desktop\apps-winget.json"

En la PC nueva:

winget import -i "$env:USERPROFILE\Desktop\apps-winget.json"

Esto no reemplaza una imagen corporativa completa, pero acelera mucho la reinstalación básica.

Errores comunes y soluciones

Buenas prácticas

1. Revisa primero con winget upgrade antes de actualizar.
2. Usa --id para evitar ambigüedades.
3. Ejecuta actualizaciones masivas fuera del horario de trabajo.
4. Genera reportes antes y después de actualizar.
5. No automatices actualizaciones críticas sin probarlas antes.
6. Mantén un respaldo de tu lista de aplicaciones con winget export.
7. En equipos institucionales, valida políticas internas antes de instalar software.
8. No mezcles actualizaciones de drivers, BIOS o firmware con este flujo; winget está enfocado en aplicaciones.

Comandos rápidos de referencia

Idea clave

Mantener Windows actualizado no debería depender de revisar programa por programa. Con winget y PowerShell puedes convertir una tarea manual y desordenada en un proceso repetible: auditar, registrar, actualizar y documentar. Esa es la diferencia entre “hacer mantenimiento” y tener una rutina técnica confiable.