From 9d50b8c47d8c7a2f0f2390cbbd9f2d959ab855f8 Mon Sep 17 00:00:00 2001 From: alemavaz1-afk Date: Sun, 13 Sep 2026 21:02:10 -0300 Subject: [PATCH 01/22] GameBoost v2 Fase 0: fundacao e reconstrucao da v1 O codigo-fonte da v1.0.0 nao existia mais (so o binario de 03/09/2026), entao a Fase 0 virou reconstruir a v1 dentro da arquitetura alvo da secao 4.1 do spec, em vez de refatorar. Motivo e consequencias em docs/DECISOES.md. Estrutura - GameBoost.Core: logica pura, sem WPF, testavel - GameBoost.App: WPF, tema escuro, MVVM com CommunityToolkit - GameBoost.Cli: parser e runner dos comandos de linha - GameBoost.Tests: xUnit + NSubstitute, 109 testes Infraestrutura compartilhada - SafetyGuard: blindagem central consultada por todos os modulos. Processos criticos, anti-cheats, antivirus (WMI SecurityCenter2 + lista estatica), caminhos e servicos protegidos. Comparacao de caminho por segmento, para C:\WindowsApps nao passar por C:\Windows. - RollbackEngine + StateBackup: valor anterior gravado antes de aplicar, reversao em ordem inversa, falha isolada nao interrompe o resto. - Logger estruturado com rotacao, settings com schemaVersion e migradores, modo portatil via portable.txt. Modo Game portado para IModule/ActionItem Varredura com blindagem, encerramento gracioso de 3 s antes do forcado, EmptyWorkingSet + purga da Standby List, plano de energia, prioridade Alta do jogo (nunca Realtime), silenciamento do sistema e pausa do wuauserv. Reabertura dos apps marcados com estrela e aviso quando o app foi fechado com o modo ativo. Dois bugs pegos pelos testes - AppSettings.SchemaVersion inicializado com VersaoAtual fazia um settings.json da v1 se disfarcar de atual: o migrador nunca rodava. - Converter de bool aplicado a uma string deixava o aviso de restauracao invisivel para sempre. Build e testes limpos, zero avisos, inclusive com -warnaserror. Co-Authored-By: Claude Opus 5 (1M context) --- .github/workflows/gameboost-build.yml | 83 +++ GameBoost/.gitignore | 16 + GameBoost/CHANGELOG.md | 43 ++ GameBoost/CLAUDE.md | 100 +++ GameBoost/Directory.Build.props | 20 + GameBoost/GAMEBOOST_V2_SPEC.md | 563 ++++++++++++++++ GameBoost/GameBoost.sln | 84 +++ GameBoost/README.md | 120 ++++ GameBoost/docs/DECISOES.md | 121 ++++ GameBoost/docs/PROTECAO.md | 140 ++++ GameBoost/docs/QA.md | 78 +++ GameBoost/docs/TWEAKS.md | 93 +++ GameBoost/installer/GameBoost.iss | 86 +++ GameBoost/src/GameBoost.App/App.xaml | 17 + GameBoost/src/GameBoost.App/App.xaml.cs | 85 +++ .../GameBoost.App/Converters/Converters.cs | 60 ++ .../src/GameBoost.App/GameBoost.App.csproj | 25 + GameBoost/src/GameBoost.App/Themes/Dark.xaml | 80 +++ .../ViewModels/ActionItemViewModel.cs | 45 ++ .../GameBoost.App/ViewModels/MainViewModel.cs | 240 +++++++ .../src/GameBoost.App/Views/MainWindow.xaml | 144 +++++ .../GameBoost.App/Views/MainWindow.xaml.cs | 25 + GameBoost/src/GameBoost.App/app.manifest | 27 + .../src/GameBoost.Cli/CommandLineOptions.cs | 148 +++++ GameBoost/src/GameBoost.Cli/CommandRunner.cs | 196 ++++++ .../src/GameBoost.Cli/GameBoost.Cli.csproj | 9 + .../src/GameBoost.Core/Abstractions/IClock.cs | 12 + .../Abstractions/IFileSystem.cs | 19 + .../Abstractions/IMemoryService.cs | 15 + .../Abstractions/IPowerService.cs | 10 + .../Abstractions/IProcessService.cs | 43 ++ .../Abstractions/IRegistryService.cs | 33 + .../Abstractions/IServiceControllerService.cs | 21 + GameBoost/src/GameBoost.Core/CoreServices.cs | 86 +++ .../src/GameBoost.Core/GameBoost.Core.csproj | 13 + .../Logging/IGameBoostLogger.cs | 29 + .../Logging/StructuredLogger.cs | 76 +++ .../src/GameBoost.Core/Modules/ActionItem.cs | 33 + .../Modules/GameMode/GameDetector.cs | 78 +++ .../Modules/GameMode/GameModeModule.cs | 600 ++++++++++++++++++ .../Modules/GameMode/GameSession.cs | 89 +++ .../Modules/GameMode/SystemSilencer.cs | 172 +++++ .../src/GameBoost.Core/Modules/IModule.cs | 43 ++ .../src/GameBoost.Core/Modules/RiskLevel.cs | 9 + .../GameBoost.Core/Native/NativeMethods.cs | 235 +++++++ .../Native/NativeMethodsBridge.cs | 21 + .../Safety/AntivirusDetector.cs | 56 ++ .../src/GameBoost.Core/Safety/ISafetyGuard.cs | 34 + .../GameBoost.Core/Safety/ProtectedPaths.cs | 36 ++ .../Safety/ProtectedProcesses.cs | 89 +++ .../Safety/ProtectedServices.cs | 26 + .../src/GameBoost.Core/Safety/SafetyGuard.cs | 174 +++++ .../Services/WindowsFileSystem.cs | 58 ++ .../Services/WindowsMemoryService.cs | 69 ++ .../Services/WindowsPowerService.cs | Bin 0 -> 2760 bytes .../Services/WindowsProcessService.cs | 330 ++++++++++ .../Services/WindowsRegistryService.cs | Bin 0 -> 3357 bytes .../WindowsServiceControllerService.cs | 177 ++++++ .../src/GameBoost.Core/Settings/AppPaths.cs | 52 ++ .../GameBoost.Core/Settings/AppSettings.cs | 54 ++ .../Settings/SettingsMigrator.cs | 50 ++ .../GameBoost.Core/Settings/SettingsStore.cs | 76 +++ .../src/GameBoost.Core/State/ChangeRecord.cs | 47 ++ .../GameBoost.Core/State/RollbackEngine.cs | Bin 0 -> 8111 bytes .../src/GameBoost.Core/State/StateBackup.cs | 137 ++++ .../CommandLineOptionsTests.cs | 95 +++ GameBoost/src/GameBoost.Tests/Fakes.cs | 175 +++++ .../GameBoost.Tests/GameBoost.Tests.csproj | 17 + .../src/GameBoost.Tests/IntegrationTests.cs | 177 ++++++ .../GameBoost.Tests/RollbackEngineTests.cs | 340 ++++++++++ .../src/GameBoost.Tests/SafetyGuardTests.cs | 305 +++++++++ .../src/GameBoost.Tests/SettingsTests.cs | 140 ++++ 72 files changed, 6999 insertions(+) create mode 100644 .github/workflows/gameboost-build.yml create mode 100644 GameBoost/.gitignore create mode 100644 GameBoost/CHANGELOG.md create mode 100644 GameBoost/CLAUDE.md create mode 100644 GameBoost/Directory.Build.props create mode 100644 GameBoost/GAMEBOOST_V2_SPEC.md create mode 100644 GameBoost/GameBoost.sln create mode 100644 GameBoost/README.md create mode 100644 GameBoost/docs/DECISOES.md create mode 100644 GameBoost/docs/PROTECAO.md create mode 100644 GameBoost/docs/QA.md create mode 100644 GameBoost/docs/TWEAKS.md create mode 100644 GameBoost/installer/GameBoost.iss create mode 100644 GameBoost/src/GameBoost.App/App.xaml create mode 100644 GameBoost/src/GameBoost.App/App.xaml.cs create mode 100644 GameBoost/src/GameBoost.App/Converters/Converters.cs create mode 100644 GameBoost/src/GameBoost.App/GameBoost.App.csproj create mode 100644 GameBoost/src/GameBoost.App/Themes/Dark.xaml create mode 100644 GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs create mode 100644 GameBoost/src/GameBoost.App/ViewModels/MainViewModel.cs create mode 100644 GameBoost/src/GameBoost.App/Views/MainWindow.xaml create mode 100644 GameBoost/src/GameBoost.App/Views/MainWindow.xaml.cs create mode 100644 GameBoost/src/GameBoost.App/app.manifest create mode 100644 GameBoost/src/GameBoost.Cli/CommandLineOptions.cs create mode 100644 GameBoost/src/GameBoost.Cli/CommandRunner.cs create mode 100644 GameBoost/src/GameBoost.Cli/GameBoost.Cli.csproj create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IClock.cs create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IFileSystem.cs create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IMemoryService.cs create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IPowerService.cs create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IProcessService.cs create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IRegistryService.cs create mode 100644 GameBoost/src/GameBoost.Core/Abstractions/IServiceControllerService.cs create mode 100644 GameBoost/src/GameBoost.Core/CoreServices.cs create mode 100644 GameBoost/src/GameBoost.Core/GameBoost.Core.csproj create mode 100644 GameBoost/src/GameBoost.Core/Logging/IGameBoostLogger.cs create mode 100644 GameBoost/src/GameBoost.Core/Logging/StructuredLogger.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/ActionItem.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/GameMode/GameDetector.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/GameMode/GameModeModule.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/GameMode/GameSession.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/GameMode/SystemSilencer.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/IModule.cs create mode 100644 GameBoost/src/GameBoost.Core/Modules/RiskLevel.cs create mode 100644 GameBoost/src/GameBoost.Core/Native/NativeMethods.cs create mode 100644 GameBoost/src/GameBoost.Core/Native/NativeMethodsBridge.cs create mode 100644 GameBoost/src/GameBoost.Core/Safety/AntivirusDetector.cs create mode 100644 GameBoost/src/GameBoost.Core/Safety/ISafetyGuard.cs create mode 100644 GameBoost/src/GameBoost.Core/Safety/ProtectedPaths.cs create mode 100644 GameBoost/src/GameBoost.Core/Safety/ProtectedProcesses.cs create mode 100644 GameBoost/src/GameBoost.Core/Safety/ProtectedServices.cs create mode 100644 GameBoost/src/GameBoost.Core/Safety/SafetyGuard.cs create mode 100644 GameBoost/src/GameBoost.Core/Services/WindowsFileSystem.cs create mode 100644 GameBoost/src/GameBoost.Core/Services/WindowsMemoryService.cs create mode 100644 GameBoost/src/GameBoost.Core/Services/WindowsPowerService.cs create mode 100644 GameBoost/src/GameBoost.Core/Services/WindowsProcessService.cs create mode 100644 GameBoost/src/GameBoost.Core/Services/WindowsRegistryService.cs create mode 100644 GameBoost/src/GameBoost.Core/Services/WindowsServiceControllerService.cs create mode 100644 GameBoost/src/GameBoost.Core/Settings/AppPaths.cs create mode 100644 GameBoost/src/GameBoost.Core/Settings/AppSettings.cs create mode 100644 GameBoost/src/GameBoost.Core/Settings/SettingsMigrator.cs create mode 100644 GameBoost/src/GameBoost.Core/Settings/SettingsStore.cs create mode 100644 GameBoost/src/GameBoost.Core/State/ChangeRecord.cs create mode 100644 GameBoost/src/GameBoost.Core/State/RollbackEngine.cs create mode 100644 GameBoost/src/GameBoost.Core/State/StateBackup.cs create mode 100644 GameBoost/src/GameBoost.Tests/CommandLineOptionsTests.cs create mode 100644 GameBoost/src/GameBoost.Tests/Fakes.cs create mode 100644 GameBoost/src/GameBoost.Tests/GameBoost.Tests.csproj create mode 100644 GameBoost/src/GameBoost.Tests/IntegrationTests.cs create mode 100644 GameBoost/src/GameBoost.Tests/RollbackEngineTests.cs create mode 100644 GameBoost/src/GameBoost.Tests/SafetyGuardTests.cs create mode 100644 GameBoost/src/GameBoost.Tests/SettingsTests.cs diff --git a/.github/workflows/gameboost-build.yml b/.github/workflows/gameboost-build.yml new file mode 100644 index 0000000..d95af8f --- /dev/null +++ b/.github/workflows/gameboost-build.yml @@ -0,0 +1,83 @@ +name: build + +on: + push: + branches: [main] + paths: ['GameBoost/**', '.github/workflows/build.yml'] + pull_request: + paths: ['GameBoost/**'] + workflow_dispatch: + +defaults: + run: + working-directory: GameBoost + +jobs: + build: + runs-on: windows-latest + + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-dotnet@v4 + with: + dotnet-version: '9.0.x' + + - name: Restaurar + run: dotnet restore GameBoost.sln + + - name: Compilar + run: dotnet build GameBoost.sln -c Release --no-restore -warnaserror + + - name: Testar + run: dotnet test GameBoost.sln -c Release --no-build --logger "trx;LogFileName=testes.trx" + + - name: Publicar testes + if: always() + uses: actions/upload-artifact@v4 + with: + name: resultado-testes + path: GameBoost/**/TestResults/*.trx + + - name: Publicar executavel + run: > + dotnet publish src/GameBoost.App/GameBoost.App.csproj + -c Release -r win-x64 --self-contained + -p:PublishSingleFile=true + -p:IncludeNativeLibrariesForSelfExtract=true + -p:PublishReadyToRun=true + -o publish + + # Trimming quebra WPF e reflexao (secao 10 do spec). Falha a build se alguem ligar. + - name: Conferir que o trimming segue desligado + shell: pwsh + run: | + $props = Get-Content Directory.Build.props -Raw + if ($props -notmatch 'false') { + throw 'PublishTrimmed precisa continuar false: trimming quebra WPF.' + } + + - name: Montar o instalador + shell: pwsh + run: | + choco install innosetup --no-progress -y + & "$env:ProgramFiles(x86)\Inno Setup 6\ISCC.exe" installer\GameBoost.iss + + - name: Gerar SHA256SUMS + shell: pwsh + run: | + $arquivos = @(Get-ChildItem publish\GameBoost.exe, installer\Output\*.exe -ErrorAction SilentlyContinue) + $arquivos | ForEach-Object { + $h = (Get-FileHash $_.FullName -Algorithm SHA256).Hash.ToLower() + "$h $($_.Name)" + } | Set-Content SHA256SUMS.txt -Encoding utf8 + Get-Content SHA256SUMS.txt + + - name: Publicar artefatos + uses: actions/upload-artifact@v4 + with: + name: gameboost + path: | + GameBoost/publish/GameBoost.exe + GameBoost/installer/Output/*.exe + GameBoost/SHA256SUMS.txt diff --git a/GameBoost/.gitignore b/GameBoost/.gitignore new file mode 100644 index 0000000..ac42ad8 --- /dev/null +++ b/GameBoost/.gitignore @@ -0,0 +1,16 @@ +# Build +bin/ +obj/ +publish/ +*.user +*.suo +.vs/ + +# Publish e instalador +installer/Output/ +*.exe +*.msi + +# Dados locais do app em modo portatil +data/ +*.log diff --git a/GameBoost/CHANGELOG.md b/GameBoost/CHANGELOG.md new file mode 100644 index 0000000..4955924 --- /dev/null +++ b/GameBoost/CHANGELOG.md @@ -0,0 +1,43 @@ +# Changelog + +Formato baseado em Keep a Changelog. Versionamento semantico. + +## [2.0.0] - em desenvolvimento + +### Fase 0 - Fundacao (2026-09-13) + +#### Adicionado +- Solucao dividida em `GameBoost.Core` (sem WPF, testavel), `GameBoost.App` (WPF), + `GameBoost.Cli` (parser e runner) e `GameBoost.Tests` (xUnit + NSubstitute). +- `SafetyGuard`: blindagem central consultada por todos os modulos. Listas de processos + criticos, anti-cheats, antivirus (WMI + estatica), caminhos e servicos protegidos. +- `RollbackEngine` e `StateBackup`: toda alteracao de sistema grava o valor anterior antes + de ser aplicada e tem reversao testada. Reversao em ordem inversa; falha em um item nao + interrompe os demais. +- `IGameBoostLogger` com log estruturado e rotacao (5 MB x 5 arquivos). +- `AppSettings` com `schemaVersion` e migradores em sequencia; arquivo antigo vira `.bak`. +- Modo portatil: `portable.txt` ao lado do exe move os dados para `.\data\`. +- Contrato `IModule` / `ActionItem` e tela generica de lista com checkbox, badge de risco e + botao "?" com o que faz, qual o risco e como desfazer. +- Modo Game portado para o contrato: varredura com blindagem, encerramento gracioso com + fallback forcado, limpeza de RAM (`EmptyWorkingSet` + purga da Standby List), plano de + energia, prioridade do jogo, silenciamento do sistema e pausa do Windows Update. +- Deteccao de jogo por nome conhecido, pasta de launcher e heuristica de consumo. +- CLI com a superficie da secao 8 do spec; `--scan` preserva o comportamento da v1. +- `--dry-run` funcional em todos os caminhos: mesmo relatorio, zero escrita. +- Modo somente leitura quando o app roda sem privilegios de administrador. +- Aviso na abertura quando o app foi fechado com o Modo Game ativo. +- CI no GitHub Actions: build, testes, publish e instalador. +- Documentacao: `CLAUDE.md`, `docs/PROTECAO.md`, `docs/TWEAKS.md`, `docs/DECISOES.md`, + `docs/QA.md`. + +#### Notas +- A v1.0.0 foi reconstruida a partir do `LEIA-ME.txt` porque o codigo-fonte original nao + existia mais. Ver `docs/DECISOES.md`. +- `--report` e `--clean` estao no parser mas respondem com a fase em que chegam. + +## [1.0.0] - 2026-09-03 + +Versao original. Modo Game com encerramento de processos, limpeza de RAM, plano de energia, +prioridade do jogo, silenciamento do sistema, snapshot e reversao, e `--scan`. +Codigo-fonte perdido. diff --git a/GameBoost/CLAUDE.md b/GameBoost/CLAUDE.md new file mode 100644 index 0000000..e0c17da --- /dev/null +++ b/GameBoost/CLAUDE.md @@ -0,0 +1,100 @@ +# CLAUDE.md — GameBoost + +Regras resumidas para quem escreve código neste repositório. Geradas a partir da seção 2 +do `GAMEBOOST_V2_SPEC.md`. **Valem para todo código novo, sem exceção.** + +--- + +## As 10 regras inegociáveis + +1. **Reversível ou não existe.** Toda alteração de sistema (registro, serviço, plano de + energia, tweak) grava o valor anterior num `ChangeRecord` em `state-backup.json` **antes** + de aplicar, e tem caminho de reversão testado em `RollbackEngineTests`. +2. **Nunca deletar sem lixeira ou confirmação.** Arquivos de usuário vão para a Lixeira + (`SHFileOperation` com `FOF_ALLOWUNDO`). Temporários de sistema podem ser apagados direto, + mas só das pastas da whitelist do módulo. +3. **Nada é pré-marcado se puder causar perda.** Jogos, launchers, IDEs com trabalho aberto e + apps de gravação aparecem na lista, nunca marcados. +4. **Honestidade sobre ganho.** Cada ação mostra o ganho **medido** (MB liberados, apps + fechados, segundos de boot). Proibido inventar número. Proibido "limpeza de registro". +5. **Sem telemetria, sem anúncios, sem upsell.** Nada sai da máquina sem o usuário clicar em + "Enviar diagnóstico". +6. **Blindagem primeiro.** `ISafetyGuard` é consultado por **todos** os módulos, não só pelo + Modo Game. +7. **Tudo em PT-BR.** Strings de UI em recurso para permitir EN depois. +8. **Log de tudo.** Toda ação grava linha estruturada em `gameboost.log` + (timestamp, módulo, ação, alvo, resultado) via `IGameBoostLogger`. +9. **Sem PowerShell quando houver API.** Win32/WMI/CIM via P/Invoke ou `System.Management`. + PowerShell só para o que não tem API razoável (`Get-AppxPackage`), sempre com + `-NoProfile -NonInteractive -ExecutionPolicy Bypass`. +10. **Nunca travar a UI.** Toda varredura roda em `Task` com `IProgress` e + `CancellationToken`. + +--- + +## Mapa de pastas + +``` +GameBoost/ +├── src/ +│ ├── GameBoost.Core/ Lógica pura, sem WPF. Testável. +│ │ ├── Abstractions/ Interfaces: IProcessService, IRegistryService, IFileSystem, IClock… +│ │ ├── Native/ P/Invoke centralizado (NativeMethods interno + Bridge público) +│ │ ├── Safety/ SafetyGuard, ProtectedProcesses/Paths/Services, AntivirusDetector +│ │ ├── State/ ChangeRecord, StateBackup, RollbackEngine +│ │ ├── Logging/ Logger estruturado, rotação 5 MB × 5 +│ │ ├── Settings/ AppPaths, AppSettings, SettingsStore, SettingsMigrator +│ │ ├── Services/ Implementações Windows das Abstractions +│ │ └── Modules/ +│ │ ├── IModule.cs, ActionItem.cs, RiskLevel.cs +│ │ └── GameMode/ GameModeModule, GameDetector, SystemSilencer, GameSession +│ ├── GameBoost.App/ WPF: Views, ViewModels, Converters, Themes +│ ├── GameBoost.Cli/ Parser e runner dos comandos de linha +│ └── GameBoost.Tests/ xUnit + NSubstitute +├── installer/GameBoost.iss +└── docs/ DECISOES.md, PROTECAO.md, TWEAKS.md, QA.md +``` + +--- + +## Contratos que todo módulo novo segue + +```csharp +public interface IModule +{ + string Id { get; } + Task ScanAsync(IProgress? progress, CancellationToken ct); + Task ApplyAsync(IReadOnlyList itemIds, bool dryRun, CancellationToken ct); + Task RevertAsync(IReadOnlyList changeIds, bool dryRun, CancellationToken ct); +} +``` + +Cada item acionável é um `ActionItem { Id, Categoria, Titulo, Descricao, Risco, +GanhoEstimado, PreMarcado, ComoDesfazer, Bloqueado, MotivoBloqueio }`. A UI é genérica: uma +lista de `ActionItem` com checkbox, badge de risco e botão "?". + +**Todo módulo precisa de `dryRun` funcional**: mesmo relatório, zero escrita. Existe teste +provando que os fakes não recebem chamadas de escrita. + +--- + +## Padrões + +- **MVVM** com CommunityToolkit.Mvvm (`[ObservableProperty]`, `[RelayCommand]`). +- **DI** com `Microsoft.Extensions.DependencyInjection`, montado em `CoreServices`. + Classe de módulo recebe interfaces, nunca `static`. +- **Elevação**: `requireAdministrator` no manifest. Sem admin o app entra em modo somente + leitura: varreduras funcionam, ações ficam desabilitadas com aviso. +- **Trimming**: proibido. Quebra WPF e reflexão. + +--- + +## Antes de abrir PR + +```powershell +dotnet build GameBoost.sln # 0 erros, 0 avisos +dotnet test GameBoost.sln # tudo verde +``` + +Qualquer decisão que fuja do `GAMEBOOST_V2_SPEC.md` vai para `docs/DECISOES.md` com data e +motivo. Tweak novo entra em `docs/TWEAKS.md`; lista de proteção nova, em `docs/PROTECAO.md`. diff --git a/GameBoost/Directory.Build.props b/GameBoost/Directory.Build.props new file mode 100644 index 0000000..ffe4cd8 --- /dev/null +++ b/GameBoost/Directory.Build.props @@ -0,0 +1,20 @@ + + + + 2.0.0 + GameBoost + Jonathan Vaz + Jonathan Vaz + Copyright (c) 2026 Jonathan Vaz + + latest + enable + enable + false + nullable + pt-BR + false + + false + + diff --git a/GameBoost/GAMEBOOST_V2_SPEC.md b/GameBoost/GAMEBOOST_V2_SPEC.md new file mode 100644 index 0000000..03d264a --- /dev/null +++ b/GameBoost/GAMEBOOST_V2_SPEC.md @@ -0,0 +1,563 @@ +# GameBoost v2 · Especificação completa para o Claude Code + +> Documento de trabalho para o Claude Code evoluir o GameBoost de "booster de jogos" para "central de otimização e manutenção do PC gamer". Leia inteiro antes de escrever código. As regras da seção 2 valem para todo o projeto. + +--- + +## 0. Como usar este documento + +1. Abra o repositório do GameBoost (`src/GameBoost/GameBoost.csproj`, `installer/GameBoost.iss`). +2. Rode a Fase 0 (seção 12) antes de qualquer feature nova: refatorar para módulos, criar a infraestrutura compartilhada. +3. Implemente as fases na ordem. Cada fase termina com build limpo, testes passando e um commit. +4. Toda decisão que fugir deste documento deve ser registrada em `docs/DECISOES.md` com data e motivo. + +--- + +## 1. Estado atual (v1.0.0) + +**Stack**: C# / .NET 9 / WPF, publish self-contained single-file, instalador Inno Setup 6, requer admin (manifest `requireAdministrator`). + +**O que já existe e deve ser preservado:** + +| Recurso | Implementação atual | +|---|---| +| Modo Game (ativar/desativar) | Varredura de processos, tela de confirmação pré-marcada, encerramento gracioso (3 s) depois forçado | +| Reabertura de apps essenciais (★) | `session.json` guarda caminho + argumentos | +| Limpeza de RAM | `EmptyWorkingSet` em todos os processos + purga da Standby List (`NtSetSystemInformation` / `SystemMemoryListInformation`) | +| Plano de energia | Alto desempenho / Desempenho Máximo, restaura o anterior | +| Prioridade do jogo | Detecção do jogo e prioridade Alta (nunca Realtime) | +| Silenciar sistema | Notificações, Game DVR, Game Bar overlay, pausa Windows Update | +| Blindagem | Lista de processos críticos, tudo em `C:\Windows`, antivírus/EDR via WMI, drivers, outras sessões | +| Snapshot e reversão | `state-backup.json`, botão "Reverter tudo", aviso na abertura se ficou ativo, reversão no desinstalador | +| Diagnóstico | `GameBoost.exe --scan relatorio.txt` | +| Persistência | `%LOCALAPPDATA%\GameBoost\` (`settings.json`, `session.json`, `state-backup.json`, `gameboost.log`) | + +**Limitações conhecidas da v1:** +- Uma única função (Modo Game). Usuário instala, usa uma vez, esquece. +- Sem visão de "o que está pesando" na máquina. O usuário não sabe por que o PC está lento. +- Sem manutenção contínua (limpeza, inicialização, espaço em disco). +- Sem assinatura digital (SmartScreen e falsos positivos de antivírus). +- Sem auto-update. + +--- + +## 2. Regras inegociáveis (valem para todo código novo) + +1. **Reversível ou não existe.** Toda alteração de sistema (registro, serviço, plano de energia, tweak) grava o valor anterior em `state-backup.json` antes de aplicar e tem um caminho de reversão testado. +2. **Nunca deletar sem lixeira ou confirmação.** Arquivos de usuário vão para a Lixeira (`SHFileOperation` com `FOF_ALLOWUNDO`). Arquivos de sistema temporários podem ser deletados direto, mas só das pastas da whitelist (seção 5.2). +3. **Nada é pré-marcado se puder causar perda.** Jogos, launchers, IDEs com trabalho aberto, apps de gravação: aparecem, nunca vêm marcados. +4. **Honestidade sobre ganho.** Cada ação mostra o ganho real medido (MB liberados, apps fechados, segundos de boot economizados). Proibido inventar número. Proibido "limpeza de registro" (não traz ganho mensurável e é risco puro). +5. **Sem telemetria, sem anúncios, sem upsell.** Nada sai da máquina sem o usuário clicar em "Enviar diagnóstico". +6. **Blindagem primeiro.** As listas de proteção (seção 9) são aplicadas em todos os módulos, não só no Modo Game. +7. **Tudo em PT-BR**, com strings em arquivo de recursos (`Resources/Strings.pt-BR.resx`) para permitir EN depois. +8. **Log de tudo.** Toda ação grava linha estruturada em `gameboost.log` (timestamp, módulo, ação, alvo, resultado). +9. **Sem PowerShell quando houver API.** Prefira Win32/WMI/CIM via P/Invoke ou `System.Management`. PowerShell só para o que não tem API razoável (ex.: `Get-AppxPackage`), e sempre com `-NoProfile -NonInteractive -ExecutionPolicy Bypass`. +10. **Nunca travar a UI.** Toda varredura roda em `Task` com `IProgress` e `CancellationToken`. + +--- + +## 3. Pesquisa de mercado + +> Referência de concorrentes e do que os usuários pedem. Validado com fontes de 2026 (guias de otimização, reviews e fóruns) em 13/09/2026. Fontes principais listadas em 3.5. + +### 3.1 Concorrentes diretos (boosters de jogos) + +| Produto | Preço | Pontos fortes | Reclamações recorrentes dos usuários | +|---|---|---|---| +| **Razer Cortex** | Grátis | Ainda o "free all-rounder" mais citado em 2026: suspende serviços, limpa RAM, restaura ao sair, contador de FPS, launcher unificado | Anúncios e promoções embutidos, ganho mínimo em PC bom, relatos de conflito com apps e jogos, consumo próprio de recursos, exige conta | +| **Wise Game Booster** | Grátis | Leve, simples, gerencia serviços e processos | Interface datada, sem monitoramento, pouco mantido | +| **IObit Advanced SystemCare / Game Booster** | Freemium (~US$20/ano) | Suite completa (limpeza, startup, drivers, privacidade) | Bloatware, pop-ups agressivos, instala outros produtos IObit, "limpeza de registro" placebo | +| **Smart Game Booster** | Freemium | Overlay FPS, monitor de temperatura, auto-boost | Falsos positivos de antivírus, upsell constante | +| **Game Fire / GearUP Booster / Chris-PC Game Booster** | Freemium | Preset por jogo antes de abrir, restauração ao sair, teste antes/depois dentro do app (Game Fire e GearUP) | Pouco conhecidos, parte das funções paga | +| **Process Lasso** | Freemium | Regras persistentes por processo, ProBalance, afinidade de CPU. Sempre citado como "o que funciona de verdade" | Curva de aprendizado, não é pensado pra leigo | +| **Windows Game Mode + Xbox Game Bar** | Grátis (nativo) | Integração de sistema, sem instalação | Game Bar consome recursos, Game Mode faz pouco, sem controle fino | +| **AMD Adrenalin / NVIDIA App** | Grátis | Overlay, gravação, tweaks de driver | Só GPU, não cuida de processos/disco | + +### 3.2 Concorrentes indiretos (limpeza e manutenção) + +| Categoria | Referências | O que fazem bem | +|---|---|---| +| Limpeza | CCleaner (Piriform/Gen), BleachBit (open source), Wise Disk Cleaner, Windows Storage Sense | Presets por app (navegadores, Discord, Steam shader cache), agendamento | +| Análise de disco | **WizTree 4.30 (mar/2026)**: lê a MFT, varre SSD grande em segundos, trata hard links, treemap, top arquivos, busca rápida, export CSV e localizador de duplicados desde a v4. WinDirStat, TreeSize Free, SpaceSniffer | É a referência unânime em 2026 ("free, blindingly fast"). Não apaga nada sozinho, só mostra e abre no Explorer. Guias sempre listam os mesmos suspeitos: hiberfil.sys, Windows.old (20 GB+ após update), temp, jogos de 80 a 150 GB, backups velhos | +| Desinstalação | **Bulk Crap Uninstaller** (Apache 2.0, acha desinstaladores quebrados/ocultos, portáteis, Store, Windows Features, Chocolatey, apps de lojas de jogos), **Revo Uninstaller Free 2.7.0 (mai/2026)** com Hunter Mode pra apps da Store e restos melhorados, Geek Uninstaller | Varredura de restos após desinstalar (com aviso de que não é garantida), desinstalação silenciosa em lote, remoção de bloatware da Store | +| Inicialização | Autoruns (Sysinternals), Gerenciador de Tarefas, Startup Delayer | Mostrar impacto real no boot, tarefas agendadas, serviços | +| Gerência de processos | Process Lasso, Process Explorer | Regras por processo persistentes, afinidade de CPU, ProBalance | +| Tweaks | Chris Titus WinUtil, Winaero Tweaker, O&O ShutUp10++, Atlas OS / ReviOS | Tweaks documentados, reversíveis, com explicação de cada um | +| Monitoramento | HWiNFO64, MSI Afterburner + RTSS, LibreHardwareMonitor, LatencyMon | Temperaturas, clocks, throttling, DPC latency, overlay em jogo | +| Drivers | Driver Booster (IObit), DDU, Snappy Driver Installer | Detectar driver de GPU desatualizado (mas instalar driver automaticamente é risco) | + +### 3.3 O que os usuários realmente pedem (Reddit r/pcgaming, r/Windows11, r/pcmasterrace, Steam forums, reviews da Microsoft Store) + +**Querem:** +1. Saber **o que está pesando** o PC agora (o "por que está lento?"). +2. **Espaço em disco**: onde estão os GB perdidos (shader cache, Windows.old, downloads antigos, jogos que não jogam mais). +3. **Desinstalar de verdade**, inclusive bloatware da Store e apps que reaparecem. +4. **Inicialização limpa**: o PC demora pra ligar e não sabem o que desativar com segurança. +5. **Ganho de FPS honesto**: dizer claramente o que faz diferença (fechar Chrome/Discord overlay, plano de energia, driver de GPU, HAGS, Fullscreen Optimizations) e o que é placebo. +6. **Leve, sem anúncio, sem conta, sem assinatura**, de preferência portátil. +7. **Explicação em cada opção**: "o que isso faz, qual o risco, como desfazer". +8. **Não quebrar nada**: medo de tweak que trava Windows Update, some com o Wi-Fi, quebra a impressora. +9. **Perfis por jogo**: ao abrir Valorant faz X, ao abrir Cyberpunk faz Y. +10. **Temperatura e throttling**: saber se o FPS caiu porque a CPU/GPU está esquentando. + +**Odeiam:** +- Limpeza de registro, "otimização de DNS mágica", "acelerador de RAM" sem número. +- Pop-up de upgrade, instalação de toolbar, envio de dados. +- App que fecha o anti-cheat ou o próprio jogo. +- Alterações sem explicação e sem "desfazer". + +### 3.4 Consenso técnico de 2026 sobre o que realmente dá ganho + +Os guias mais sérios convergem: cerca de seis ajustes explicam quase todo o ganho real, o resto é placebo, já é padrão ou troca segurança por poucos %. + +1. **Plano de energia em Alto desempenho / Melhor desempenho** (evita clock baixo). +2. **Podar inicialização e apps em background** (junto com o item 1, são os dois de maior valor e os mais fáceis de reverter). +3. **Game Mode do Windows ligado** (versão 22H2+ ajuda e evita Windows Update durante o jogo; só desligar se houver conflito). +4. **Game Bar / gravação em segundo plano desligados.** +5. **Jogo em SSD** (lançamentos de 2025/2026 já exigem SSD e engasgam em HDD). +6. **Driver de GPU atualizado da fonte oficial** e monitor configurado na taxa de atualização certa (Windows volta pra 60 Hz depois de driver ou troca de cabo com frequência). + +Pontos que exigem teste, não regra: +- **HAGS**: obrigatório para DLSS Frame Generation; melhora frame pacing em GPUs recentes (RTX 30+, RX 6000+) com driver atual, mas causa stutter em CPUs antigas ou certas versões de driver. É "o único ajuste que você precisa testar em vez de só ligar". Custa até 1 GB de VRAM (atenção em placas de 8 GB). +- **VBS / Memory Integrity (Core Isolation)**: vem ligado por padrão no Windows 11 e os guias medem 5 a 15% de FPS em jogos CPU-bound (até 25% em casos extremos). É recurso de segurança contra malware de kernel. Consenso: desligar só em PC exclusivo de jogo, manter em máquina de trabalho/banco. Por isso o GameBoost **informa e mede, mas não desliga**: mostra o estado, o impacto estimado e o caminho nas Configurações do Windows. +- **Updates grandes do Windows (24H2, 26H2) resetam** Game Mode, HAGS, plano de energia, efeitos visuais e Game Bar. O GameBoost deve detectar isso e avisar "seu perfil foi desfeito por uma atualização". + +Placebo ou risco confirmados: limpeza de registro, "defrag" em SSD, updaters de driver automáticos, tweaks agressivos de serviço. + +### 3.5 Fontes consultadas (set/2026) +- Frozen Tweaks, Gear-Rank, SmoothFPS, Switchblade Gaming, TechFixGrid: guias de otimização Windows 11 2026 (VBS, HAGS, Game Mode, 26H2). +- iTechGuides, TechBloat, TechBre, Techlasi, Gitnux, Worldmetrics: rankings de boosters 2026. +- Neat Net Tricks e Swastiktechnology: reviews WizTree 2026; RottenWifi: BCU, Revo 2.7.0, Storage Sense. +- Steam Community e Tom's Guide: percepção de usuário sobre boosters ("snake oil", "bloatware em PC bem cuidado"). +- Microsoft Learn: SmartScreen reputation, opções de assinatura de código, Azure Artifact Signing. + +### 3.6 Posicionamento do GameBoost v2 + +**"O booster que mostra o que faz e desfaz tudo."** Diferenciais: +- Transparência total (cada botão explica antes, mede depois, reverte sempre). +- Zero anúncios, zero telemetria, PT-BR nativo. +- Diagnóstico de gargalo em linguagem humana ("seu Chrome está usando 40% da CPU com 62 abas"). +- Portátil opcional (mesmo exe roda sem instalar). +- **Prova de ganho**: medição antes/depois em cada ação (Game Fire e GearUP já fazem isso e os reviews valorizam muito). +- **Detector de reset pós-update**: nenhum concorrente avisa que o Windows desfez os ajustes. + +--- + +## 4. Arquitetura alvo + +### 4.1 Estrutura de pastas + +``` +GameBoost/ +├── src/ +│ ├── GameBoost.Core/ # Lógica pura, sem WPF. Testável. +│ │ ├── Abstractions/ # Interfaces (IProcessService, IRegistryService, IFileSystem, IClock...) +│ │ ├── Native/ # P/Invoke centralizado (Kernel32, Psapi, NtDll, Advapi32, Shell32, PowrProf) +│ │ ├── Safety/ # Blindagem: ProtectedProcesses, ProtectedPaths, ProtectedServices, AntiCheatList +│ │ ├── State/ # Snapshot/rollback (StateBackup, ChangeRecord, RollbackEngine) +│ │ ├── Logging/ # Logger estruturado (JSON lines + texto legível) +│ │ ├── Settings/ # Settings, perfis, migração de versão +│ │ └── Modules/ +│ │ ├── GameMode/ # (existente, refatorado) +│ │ ├── Cleaner/ # Limpeza de temporários e caches +│ │ ├── Uninstaller/ # Desinstalador Win32 + Store + restos +│ │ ├── DiskAnalyzer/ # Análise de espaço (MFT + fallback) +│ │ ├── Bottleneck/ # Monitor e diagnóstico de gargalos +│ │ ├── Startup/ # Inicialização, tarefas agendadas +│ │ ├── Services/ # Serviços do Windows +│ │ ├── Tweaks/ # Tweaks de jogos reversíveis +│ │ ├── Network/ # Diagnóstico e ajustes de rede +│ │ ├── Drivers/ # Verificação de drivers de GPU +│ │ ├── Profiles/ # Perfis por jogo +│ │ └── HealthReport/ # Relatório e pontuação +│ ├── GameBoost.App/ # WPF: Views, ViewModels, Converters, Themes +│ │ ├── Views/ +│ │ ├── ViewModels/ +│ │ ├── Controls/ # Treemap, Gauge, ProcessList, ConfirmDialog +│ │ ├── Themes/ # Dark.xaml (padrão), Light.xaml +│ │ └── Resources/Strings.pt-BR.resx +│ ├── GameBoost.Cli/ # Modo linha de comando (--scan, --clean, --report) +│ └── GameBoost.Tests/ # xUnit + NSubstitute +├── installer/GameBoost.iss +├── docs/ +│ ├── DECISOES.md +│ ├── TWEAKS.md # Catálogo de cada tweak: chave, valor, efeito, risco, fonte +│ └── PROTECAO.md # Listas de blindagem documentadas +├── CLAUDE.md # Regras resumidas para o Claude Code (gerar a partir da seção 2) +└── README.md +``` + +### 4.2 Padrões + +- **MVVM** com CommunityToolkit.Mvvm (`[ObservableProperty]`, `[RelayCommand]`). +- **DI** com `Microsoft.Extensions.DependencyInjection`. Toda classe de módulo recebe interfaces, nunca `static`. +- **Cada módulo expõe** `IModule` com: `ScanAsync(progress, ct)` → `ScanResult`, `ApplyAsync(selection, ct)` → `ApplyResult`, `RevertAsync(changeIds)`. +- **Cada item acionável** é um `ActionItem { Id, Categoria, Titulo, Descricao, Risco (Baixo/Medio/Alto), GanhoEstimado, PreMarcado, ComoDesfazer }`. A UI é genérica: uma lista de `ActionItem` com checkbox, badge de risco e botão "?" com a explicação. +- **Elevação**: manter `requireAdministrator`. Adicionar modo "somente leitura" quando rodar sem admin (varreduras funcionam, ações ficam desabilitadas com aviso). + +--- + +## 5. Módulos: especificação funcional + +Cada módulo abaixo tem: objetivo, fonte de dados/API, itens gerados, regras, UI, critérios de aceite. + +### 5.1 Modo Game (existente, melhorias) + +**Melhorias:** +- Detecção automática de jogo: monitorar criação de processos (WMI `Win32_ProcessStartTrace` ou polling a cada 2 s) e cruzar com (a) lista de jogos conhecidos, (b) executáveis dentro de `steamapps/common`, `Epic Games`, `Riot Games`, `Battle.net`, `GOG Galaxy/Games`, `XboxGames`, (c) janela em fullscreen exclusivo/borderless ocupando 100% da tela. Ao detectar, oferecer "Ativar Modo Game para ?" via notificação (ou ativar direto se o perfil do jogo mandar). +- Timer resolution: `NtSetTimerResolution(0.5 ms)` enquanto Modo Game ativo (Windows 11 já lida bem, mas em 10 ajuda). Reverter ao sair. +- Afinidade de CPU opcional para o jogo (perfil avançado): permitir reservar núcleos. Padrão desligado. +- Modo "Só o essencial": encerrar apenas processos com >2% CPU ou >300 MB RAM nos últimos 30 s (evita lista gigante). +- Exibir ganho: RAM livre antes/depois, nº de processos fechados, % CPU em background antes/depois. + +**Critérios de aceite:** ativar e desativar 10 vezes seguidas sem vazar estado; matar o app durante o modo ativo e reabrir mostra o aviso de restauração; jogo nunca aparece pré-marcado. + +### 5.2 Limpeza de arquivos temporários e caches + +**Objetivo:** liberar espaço com segurança, mostrando o que será apagado e quanto ocupa. + +**Categorias e alvos (whitelist, só estes caminhos):** + +| Categoria | Caminhos | Risco | Pré-marcado | +|---|---|---|---| +| Temp do usuário | `%TEMP%` (arquivos não bloqueados, >24 h) | Baixo | Sim | +| Temp do sistema | `C:\Windows\Temp` | Baixo | Sim | +| Prefetch | `C:\Windows\Prefetch\*.pf` mais antigos que 30 dias | Baixo | Não (afeta boot por alguns dias) | +| Windows Update cache | `C:\Windows\SoftwareDistribution\Download` (parar serviço `wuauserv` antes) | Baixo | Sim | +| Delivery Optimization | via `IDOManager` ou `Get-DeliveryOptimizationStatus`; simples: `Clear-DeliveryOptimizationCache` não existe, usar Limpeza de Disco API `cleanmgr /sageset` presets ou pasta `%WINDIR%\ServiceProfiles\NetworkService\AppData\Local\Microsoft\Windows\DeliveryOptimization\Cache` | Baixo | Sim | +| Windows.old | `C:\Windows.old` (só se existir; usar `cleanmgr` handler "Previous Windows installation(s)" ou takeown + delete) | Médio | Não | +| Lixeira | `SHEmptyRecycleBin` | Médio | Não | +| Miniaturas / cache de ícones | `%LOCALAPPDATA%\Microsoft\Windows\Explorer\thumbcache_*.db`, `iconcache_*.db` | Baixo | Não | +| Logs do Windows | `C:\Windows\Logs\CBS\*.log` antigos, `%WINDIR%\Panther` (não), `C:\ProgramData\Microsoft\Windows\WER\ReportQueue` | Baixo | Sim (só WER) | +| Dumps de memória | `C:\Windows\Minidump`, `C:\Windows\MEMORY.DMP` | Baixo | Sim | +| Cache de navegadores | Chrome/Edge/Brave/Opera (`User Data\\Cache`, `Code Cache`, `GPUCache`), Firefox (`cache2`). NUNCA cookies, senhas, histórico | Baixo | Sim, só se navegador fechado | +| Discord | `%APPDATA%\discord\Cache`, `Code Cache`, `GPUCache` | Baixo | Sim, se fechado | +| Spotify | `%LOCALAPPDATA%\Spotify\Storage`, `Data` | Baixo | Não | +| Shader cache | NVIDIA: `%LOCALAPPDATA%\NVIDIA\DXCache`, `%LOCALAPPDATA%\NVIDIA\GLCache`, `%PROGRAMDATA%\NVIDIA Corporation\NV_Cache`; AMD: `%LOCALAPPDATA%\AMD\DxCache`, `GLCache`; DirectX: `%LOCALAPPDATA%\D3DSCache`; Steam: `Steam\steamapps\shadercache` | Médio (jogos vão engasgar ao recompilar) | Não, com explicação | +| Steam | `Steam\appcache\httpcache`, `Steam\logs`, `Steam\dumps` | Baixo | Sim | +| Epic / Riot / Battle.net | Logs e caches de cada launcher (documentar caminhos em `TWEAKS.md`) | Baixo | Sim | +| Instaladores esquecidos | `%USERPROFILE%\Downloads\*.exe|*.msi|*.zip` > 30 dias | Alto | Nunca. Apenas listar em "Sugestões" | + +**Regras:** +- Varredura calcula tamanho por categoria antes de mostrar. Exibir total "até X GB". +- Arquivos em uso (`IOException` sharing violation) são pulados e contados em "não foi possível remover N arquivos (em uso)". +- Cache de navegador/Discord só limpa se o processo não estiver rodando; senão, oferece "Fechar e limpar". +- Nunca tocar em: `AppData\Roaming` de jogos (saves), `Documents`, `Pictures`, `OneDrive`, qualquer pasta com `.git`. +- Guardar histórico: `cleanup-history.json` com data, categorias, MB liberados. +- Agendamento opcional: tarefa no Agendador (`schtasks`) semanal com `GameBoost.exe --clean --preset seguro`. + +**Critérios de aceite:** rodar limpeza duas vezes seguidas, segunda vez libera ~0; nenhum arquivo fora da whitelist é tocado (teste com `IFileSystem` fake registrando todos os caminhos); tamanho reportado bate com o `du` real com margem de 5%. + +### 5.3 Desinstalador de aplicativos + +**Objetivo:** listar tudo instalado (Win32, Store/UWP, portáteis detectados), permitir desinstalação em lote e limpar restos. + +**Fontes:** +- Registro: `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall`, `HKLM\SOFTWARE\WOW6432Node\...\Uninstall`, `HKCU\...\Uninstall`. Ler `DisplayName`, `DisplayVersion`, `Publisher`, `InstallDate`, `InstallLocation`, `EstimatedSize`, `UninstallString`, `QuietUninstallString`, `WindowsInstaller` (MSI → `msiexec /x {GUID} /qn`). +- Store/UWP: `Get-AppxPackage -AllUsers` via PowerShell (ou `PackageManager` da WinRT via `Windows.Management.Deployment`). Marcar `NonRemovable`, `IsFramework` e pacotes de sistema como protegidos. +- Uso real: cruzar com `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist` (decodificar ROT13) e `LastWriteTime` dos executáveis para mostrar "último uso" e "nunca usado". +- Tamanho real: `EstimatedSize` do registro é pouco confiável; se `InstallLocation` existir, calcular tamanho da pasta em background. + +**Lista de bloatware conhecido (sugestão, nunca pré-marcado):** Candy Crush, Spotify (Store), TikTok, Xbox TCUI (não remover se for jogar), Microsoft Solitaire, 3D Viewer, Clipchamp, LinkedIn, McAfee/Norton trial, Booking.com, Disney+, Netflix (Store shortcut), OEM utilities (HP Wolf, Lenovo Vantage é útil, cuidado), Cortana, Feedback Hub, Get Help, Mixed Reality Portal. + +**Nunca desinstalar (protegido):** Visual C++ Redistributables, .NET Runtimes, DirectX, drivers de GPU/áudio/chipset, Microsoft Edge (WebView2 é dependência), Xbox Identity Provider e Xbox Game Services (anti-cheat e jogos do Game Pass dependem), antivírus ativo, qualquer app do publisher "Microsoft Corporation" da lista de frameworks. + +**Fluxo:** +1. Lista com busca, filtros (Store / Win32 / Grandes / Nunca usados / Bloatware sugerido), ordenação por tamanho e último uso. +2. Seleção múltipla → "Desinstalar N apps" → tela de confirmação com badge de risco. +3. Execução sequencial: preferir `QuietUninstallString`; se não houver, rodar `UninstallString` e mostrar aviso "este app abre o desinstalador próprio". Timeout de 10 min por app. +4. Após cada desinstalação, **varredura de restos**: pasta `InstallLocation` residual, `%APPDATA%\`, `%LOCALAPPDATA%\`, `%PROGRAMDATA%\`, chaves `HKCU\Software\` e `HKLM\Software\`. Só sugerir se o nome tiver match exato (nunca substring curta). Restos vão para a Lixeira / chave exportada em `.reg` antes de apagar. +5. Ponto de restauração do sistema opcional antes de lote grande (`Checkpoint-Computer` via PowerShell ou `SystemRestore` WMI), com aviso de que o Windows limita a 1 por 24 h por padrão. + +**Critérios de aceite:** lista bate com "Aplicativos instalados" do Windows (±2 itens de diferença aceitável por apps ocultos); desinstalação silenciosa de um app MSI de teste funciona; restos de app removido são detectados; nenhum item protegido aparece selecionável. + +### 5.4 Analisador de espaço em disco + +**Objetivo:** responder "onde foram parar meus GB" em segundos, estilo WizTree. + +**Implementação:** +- **Caminho rápido (NTFS):** ler a MFT diretamente com `FSCTL_ENUM_USN_DATA` (`DeviceIoControl` em `\\.\C:`), reconstruir a árvore por `ParentFileReferenceNumber`, obter tamanho via `FSCTL_GET_RETRIEVAL_POINTERS` ou, mais simples, via `NtQueryDirectoryFile`/`FindFirstFileEx` com `FIND_FIRST_EX_LARGE_FETCH` só nos diretórios já enumerados. Alternativa aceitável na primeira versão: `FindFirstFileEx` recursivo paralelizado com `FIND_FIRST_EX_LARGE_FETCH`, que já é bem mais rápido que `DirectoryInfo`. +- **Fallback (FAT/exFAT/sem admin):** enumeração recursiva normal. +- Resultado em árvore com tamanho agregado, contagem de arquivos, extensão dominante. + +**UI:** +- **Treemap** (controle próprio em WPF, retângulos por tamanho, cor por categoria: jogos, vídeo, instaladores, cache, sistema, outros). Clique para descer nível, breadcrumb para voltar. +- **Top 100 maiores arquivos** e **Top 50 maiores pastas**. +- **Categorias inteligentes:** Jogos (pastas de launchers), Vídeos (>500 MB `.mp4/.mkv`), Instaladores (`.exe/.msi/.iso` em Downloads), Caches, Windows.old, Arquivos de hibernação (`hiberfil.sys`) e paginação (`pagefile.sys`) com explicação e opção "Desativar hibernação (`powercfg /h off`)" com badge de risco Médio. +- Ações por item: abrir no Explorer, mover para Lixeira, "Ignorar sempre". +- Duplicados (fase posterior): hash parcial (primeiros 64 KB + tamanho) e só depois hash completo dos candidatos. + +**Critérios de aceite:** varredura de 500 GB com 1 milhão de arquivos em < 30 s via MFT em SSD; treemap responde a clique em < 100 ms; nunca oferece apagar nada dentro de `C:\Windows`, `Program Files` (só via Desinstalador) ou pastas de saves. + +### 5.5 Diagnóstico de gargalos (o "por que está lento?") + +**Objetivo:** mostrar em tempo real e em linguagem simples o que está consumindo CPU, GPU, RAM, disco e rede, e quem é o culpado. + +**Coleta (intervalo 1 s, buffer de 5 min em memória):** +- **CPU:** total e por processo (`PerformanceCounter` ou delta de `Process.TotalProcessorTime`; preferir `NtQuerySystemInformation(SystemProcessInformation)` que traz tudo numa chamada). Frequência atual vs. base (`Win32_Processor.CurrentClockSpeed` é lento; usar contador `\Processor Information(_Total)\% Processor Performance`). +- **RAM:** `GlobalMemoryStatusEx`, Standby List, Commit, por processo (Working Set privado). +- **GPU:** contadores `\GPU Engine(*)\Utilization Percentage` e `\GPU Adapter Memory(*)\Dedicated Usage` (disponíveis no Windows 10 1709+). Por processo via instância do contador (`pid_XXXX_luid...`). Temperatura e clocks via **LibreHardwareMonitorLib** (NuGet, MPL 2.0) para NVIDIA/AMD/Intel. +- **Disco:** `\PhysicalDisk(*)\% Idle Time`, fila, MB/s; por processo via ETW (`Microsoft.Diagnostics.Tracing.TraceEvent`, kernel provider `DiskIO`) ou, mais simples, `Process` IO counters delta (`GetProcessIoCounters`). +- **Rede:** `\Network Interface(*)\Bytes Total/sec`; por processo via `GetExtendedTcpTable` + ETW `TcpIp` provider (fase posterior). +- **Temperaturas:** CPU package, GPU core, NVMe (LibreHardwareMonitor). Detectar **throttling**: CPU com `% Processor Performance` < 80% enquanto uso > 70% e temperatura > 90 °C. +- **Latência DPC/ISR** (opcional, avançado): ETW kernel `DPC`/`Interrupt` events para apontar driver problemático (estilo LatencyMon). Marcar como experimental. + +**Diagnóstico automático (regras, cada uma gera um `Finding` com texto humano e ação sugerida):** + +| Regra | Texto exemplo | Ação sugerida | +|---|---|---| +| Processo > 25% CPU por 30 s fora do jogo | "Chrome está usando 38% da CPU (62 abas abertas)" | Fechar / adicionar ao Modo Game | +| RAM disponível < 10% | "Só 1,2 GB de RAM livre. Discord + Chrome usam 4,1 GB" | Limpar RAM / fechar apps | +| Standby List > 40% da RAM | "6 GB de RAM presos em cache do sistema" | Purgar Standby | +| Disco do sistema > 90% ocupado | "C: com 94% de uso. SSD cheio fica lento" | Abrir Analisador de Disco | +| Disco com % Idle < 20% por 30 s | "Seu disco está no limite. Windows Search está indexando" | Pausar indexação / ver processo | +| GPU > 95% e FPS baixo | "GPU no máximo. Reduza resolução/qualidade ou ative DLSS/FSR" | Informativo | +| CPU > 95% e GPU < 60% em jogo | "Gargalo de CPU: o processador não alimenta a placa de vídeo" | Fechar apps / prioridade | +| Throttling térmico | "CPU a 97 °C reduzindo clock. Limpe o cooler / ajuste curva" | Informativo | +| Plano de energia balanceado em jogo | "Plano Balanceado ativo durante o jogo" | Ativar Alto desempenho | +| Driver de GPU > 6 meses | "Driver NVIDIA de fev/2026. Nova versão disponível" | Abrir página oficial | +| Muitos apps na inicialização | "23 programas iniciam com o Windows (boot estimado +48 s)" | Abrir Inicialização | +| Windows Search / Defender / Update usando disco | "Windows Defender fazendo varredura completa" | Informativo (nunca desativar Defender) | +| Xbox Game Bar / Game DVR ligado | "Gravação em segundo plano ativa" | Desativar (reversível) | +| Build do Windows mudou desde a última execução e tweaks/perfil não batem mais | "A atualização 26H2 desfez 4 ajustes seus" | Reaplicar perfil | +| Monitor a 60 Hz sendo capaz de mais (`EnumDisplaySettings`) | "Seu monitor de 165 Hz está em 60 Hz" | Abrir configurações de vídeo | +| VBS / Memory Integrity ativo | "Isolamento do núcleo ativo (custo típico 5 a 15% em jogos CPU-bound)" | Informativo com link | +| HDD como disco do jogo | "Jogo instalado em HDD. Mova para SSD" | Informativo | +| Memória em single channel | Via `Win32_PhysicalMemory` contagem de pentes | Informativo | + +**UI:** painel com 5 medidores (CPU, GPU, RAM, Disco, Rede) + temperatura, gráfico de 60 s, tabela "Top 10 processos" por recurso selecionado, e lista de `Findings` ordenada por impacto. Modo compacto "sempre no topo" (janela pequena) para deixar ao lado do jogo em segundo monitor. + +**Critérios de aceite:** coleta consome < 1,5% de CPU e < 60 MB de RAM; funciona sem LibreHardwareMonitor (temperaturas ficam "indisponível"); Findings não repetem a cada segundo (debounce de 30 s). + +### 5.6 Gerenciador de inicialização + +**Fontes:** `HKCU/HKLM\...\Run`, `RunOnce`, pasta Startup do usuário e comum, `HKLM\...\Explorer\StartupApproved` (estado ativado/desativado igual ao Gerenciador de Tarefas), Tarefas Agendadas com gatilho "no logon" (`Microsoft.Win32.TaskScheduler` NuGet ou `schtasks /query /xml`), serviços com início Automático de terceiros. + +**Dados por item:** nome, publisher, caminho, assinado digitalmente (sim/não, via `WinVerifyTrust` ou `X509Certificate.CreateFromSignedFile`), impacto no boot (ler `HKCU\...\Explorer\StartupApproved` não traz impacto; estimar via tamanho do exe + nº de DLLs importadas, ou usar dados de `Windows Performance` se disponíveis; mostrar como Baixo/Médio/Alto estimado). + +**Ações:** Desativar (gravar em `StartupApproved` com o mesmo formato do Gerenciador de Tarefas, para o Windows mostrar coerente), Atrasar (criar tarefa agendada com delay de N s e desativar a entrada original), Abrir local, Ver no Desinstalador. + +**Protegidos:** drivers de áudio/vídeo, antivírus, OneDrive (avisar), Bluetooth/touchpad OEM, SecurityHealth. Sugerir desativar: Spotify, Discord (se o usuário quiser abrir manualmente), Steam/Epic/EA app, Teams, Adobe Updater, iTunes Helper, Cortana. + +### 5.7 Serviços do Windows + +Lista de serviços com filtro "terceiros" e "otimizáveis para jogos". Tweaks reversíveis (guardar `StartType` anterior): + +| Serviço | Ação sugerida | Risco | +|---|---|---| +| `SysMain` (Superfetch) | Desativar só em SSD com <16 GB RAM? Não. Manter. Apenas explicar | Médio | +| `WSearch` | Manual (busca do Explorer fica lenta) | Baixo | +| `DiagTrack` (telemetria) | Desativar | Baixo | +| `XblAuthManager`, `XblGameSave`, `XboxNetApiSvc` | Manter se usa Game Pass / anti-cheat da MS. Explicar | Médio | +| `Fax`, `RemoteRegistry`, `WMPNetworkSvc`, `MapsBroker` | Desativar | Baixo | +| `Spooler` | Manual se não tem impressora | Baixo | +| `wuauserv` | Nunca desativar. Só pausar dentro do Modo Game (já existe) | Alto | +| Serviços de antivírus, `WinDefend`, `SecurityHealthService` | Protegido | Alto | + +### 5.8 Tweaks de jogos (catálogo documentado em `docs/TWEAKS.md`) + +Cada tweak: chave/valor, efeito, evidência, risco, reversão. Todos desligados por padrão, aplicados individualmente, com snapshot. + +| Tweak | Onde | Efeito real | Risco | +|---|---|---|---| +| Hardware-Accelerated GPU Scheduling (HAGS) | `HKLM\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\HwSchMode = 2` (reboot) | Obrigatório para DLSS Frame Gen; melhora frame pacing em RTX 30+/RX 6000+ com driver atual, piora em CPU antiga. Usa até 1 GB de VRAM. Oferecer "Testar com/sem" com benchmark rápido | Médio | +| Game Mode do Windows | `HKCU\Software\Microsoft\GameBar\AutoGameModeEnabled` | Positivo no 22H2+ (bloqueia Update durante o jogo). Recomendar ligado; desligar só se der conflito com streaming | Baixo | +| Game DVR / Game Bar | `HKCU\System\GameConfigStore\GameDVR_Enabled = 0`, `HKCU\Software\Microsoft\GameBar\UseNexusForGameBarEnabled = 0` | Reduz overhead de gravação | Baixo | +| Fullscreen Optimizations por exe | `HKCU\System\GameConfigStore` `GameDVR_FSEBehaviorMode`, e `HKCU\...\AppCompatFlags\Layers` `DISABLEDXMAXIMIZEDWINDOWEDMODE` por jogo | Depende do jogo; oferecer por perfil | Baixo | +| Multi-Plane Overlay (MPO) | `HKLM\SOFTWARE\Microsoft\Windows\Dwm\OverlayTestMode = 5` | Resolve stutter/flicker em alguns setups NVIDIA | Médio | +| Nagle (TcpAckFrequency, TCPNoDelay) | `HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\` | Ganho marginal em jogos com muitos pacotes pequenos; a maioria já usa UDP. Explicar honestamente | Baixo | +| Network Throttling Index | `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Multimedia\SystemProfile\NetworkThrottlingIndex = 0xFFFFFFFF` | Marginal | Baixo | +| SystemResponsiveness | mesma chave, `SystemResponsiveness = 0` | Prioriza foreground | Baixo | +| Games task priority | `...\SystemProfile\Tasks\Games` `GPU Priority = 8`, `Priority = 6`, `Scheduling Category = High` | Marginal | Baixo | +| Mouse: desativar aceleração | `HKCU\Control Panel\Mouse` `MouseSpeed=0`, `MouseThreshold1/2=0` | Consistência de mira | Baixo | +| Power throttling off para o jogo | `powercfg /setacvalueindex ... PERFBOOSTMODE` e `HKLM\...\Power\PowerThrottling\PowerThrottlingOff` | Evita clock baixo em notebook | Baixo | +| Desativar hibernação | `powercfg /h off` | Libera espaço = tamanho da RAM, perde Inicialização Rápida | Médio | +| Ultimate Performance plan | `powercfg /duplicatescheme e9a42b02-...` | Já existe no Modo Game | Baixo | +| Visual effects "melhor desempenho" | `HKCU\...\Explorer\VisualEffects` | Ajuda só em máquina muito fraca; afeta UX | Baixo | +| Timer resolution | Já no Modo Game | Baixo | +| Core Isolation / VBS (Memory Integrity) | **Não alterar.** Detectar via `msinfo32`/WMI `Win32_DeviceGuard` e mostrar Finding: "VBS ativo, custo medido pela comunidade de 5 a 15% em jogos CPU-bound". Botão abre Configurações → Segurança do Windows → Isolamento do núcleo. Explicar o trade-off (PC só de jogo vs. máquina de trabalho/banco) | Alto | +| Spectre/Meltdown mitigations | **Nunca.** | Alto | + +### 5.9 Rede + +- Diagnóstico: ping para 3 hosts (gateway, 1.1.1.1, servidor de jogo configurado), jitter, perda, DNS resolução tempo (comparar DNS atual vs. Cloudflare/Google/Quad9, mostrar tabela, deixar o usuário decidir). +- Ações: `ipconfig /flushdns`, resetar Winsock (`netsh winsock reset`, exige reboot, risco Médio), trocar DNS do adaptador (`SetDNSServerSearchOrder` via WMI, reversível). +- Mostrar quem está usando banda agora (`GetExtendedTcpTable` + contadores de processo). +- Wi-Fi: mostrar banda (2,4/5/6 GHz), sinal, canal, e recomendar cabo para jogo competitivo. + +### 5.10 Drivers de GPU + +- Detectar fabricante e versão (`Win32_VideoController.DriverVersion`, `DriverDate`) e traduzir para versão "de marketing" (NVIDIA: últimos 5 dígitos do DriverVersion → `5xx.xx`). +- Comparar com versão mais recente conhecida via arquivo JSON estático atualizado a cada release do GameBoost e, se web permitida pelo usuário, endpoint oficial (NVIDIA tem API não documentada; AMD/Intel via página). Sem web: só "seu driver tem N meses". +- **Nunca instalar driver.** Abrir a página oficial. Opcional: link para DDU com explicação de quando usar. + +### 5.11 Perfis por jogo + +- Perfil = `{ executavel, nome, acoes: [modo game on, plano energia X, prioridade Y, afinidade Z, tweaks por exe, apps a fechar, apps a reabrir], auto: bool }`. +- Detecção via 5.1. Ao fechar o jogo, reverter automaticamente. +- Biblioteca: varrer launchers para listar jogos instalados (Steam `libraryfolders.vdf` + `appmanifest_*.acf`; Epic `C:\ProgramData\Epic\EpicGamesLauncher\Data\Manifests\*.item`; GOG registry; Xbox `.GamingRoot`), mostrar tamanho e último jogado (para sugerir desinstalar jogos parados, que é onde estão os GB de verdade). + +### 5.12 Relatório de saúde e pontuação + +- Executa todas as varreduras em modo leitura e gera nota 0 a 100 por área (Desempenho, Espaço, Inicialização, Configuração para jogos) com os 5 principais `Findings`. +- Exportar `relatorio.html` (para o usuário mandar para quem dá suporte) e `relatorio.json`. +- `GameBoost.exe --report saida.html` na CLI. + +### 5.13 Ferramentas rápidas (atalhos de coisas que o usuário procura) + +- Reiniciar Explorer, reiniciar driver de vídeo (`Win+Ctrl+Shift+B` programático via `SendInput`), limpar cache DNS, esvaziar Lixeira, abrir Limpeza de Disco do Windows, criar ponto de restauração, verificar integridade (`sfc /scannow` e `DISM /RestoreHealth` com console embutido), teste de velocidade de disco (leitura/escrita sequencial 1 GB em arquivo temporário), informações do sistema (CPU, GPU, RAM canais/velocidade, discos e tipo, versão do Windows, BIOS) com botão copiar. + +--- + +## 6. UI / UX + +- **Tema escuro padrão**, acento único (manter identidade atual do GameBoost). Fluent-like, sem gradientes exagerados. +- **Navegação lateral** com ícones: Início (Modo Game + pontuação + findings), Diagnóstico, Limpeza, Espaço, Apps, Inicialização, Jogos (perfis), Tweaks, Rede, Ferramentas, Configurações. +- **Padrão de tela de módulo:** cabeçalho com botão "Varrer" e resumo (ex.: "12,4 GB podem ser liberados"), lista de `ActionItem` agrupada por categoria com checkbox, badge de risco (verde/amarelo/vermelho), botão "?" que abre painel lateral com "O que faz / Risco / Como desfazer", rodapé fixo com "Aplicar N selecionados" e "Reverter". +- **Tela de confirmação única e genérica** (reusar a do Modo Game) para tudo que altera o sistema. +- **Histórico** (Configurações → Histórico): toda ação aplicada, com botão "Desfazer" individual enquanto a reversão for possível. +- **Bandeja do sistema**: ícone com menu (Ativar Modo Game, Limpar RAM, Abrir, Sair). Opção "iniciar minimizado com o Windows" (desligada por padrão, e o GameBoost aparece na própria lista de inicialização, com honestidade). +- **Acessibilidade**: fontes escaláveis, navegação por teclado, contraste AA. +- **Onboarding** na primeira abertura: 3 telas explicando "reversível / sem telemetria / o que faz diferença de verdade" e oferecendo o Relatório de Saúde inicial. + +--- + +## 7. Dados e persistência + +Tudo em `%LOCALAPPDATA%\GameBoost\`: + +| Arquivo | Conteúdo | Formato | +|---|---|---| +| `settings.json` | Preferências, tema, whitelist, essenciais, agendamentos, `schemaVersion` | JSON | +| `profiles/*.json` | Um perfil por jogo | JSON | +| `state-backup.json` | Pilha de `ChangeRecord { Id, Modulo, Tipo (Registry/Service/Power/File/Startup), Alvo, ValorAnterior, ValorNovo, Data, Revertido }` | JSON | +| `session.json` | Sessão do Modo Game | JSON | +| `history/*.json` | Histórico de ações por dia | JSON | +| `cache/disk-scan-.bin` | Último resultado da varredura de disco (para abrir instantâneo) | Binário | +| `gameboost.log` | Log texto rotacionado (5 MB × 5 arquivos) | Texto | +| `backups/*.reg` | Export de chaves antes de remover restos | REG | + +Migração: ao abrir, se `schemaVersion` < atual, rodar migradores em sequência. Nunca apagar arquivo antigo, renomear para `.bak`. + +Modo portátil: se existir `portable.txt` ao lado do exe, usar `.\data\` em vez de `%LOCALAPPDATA%`. + +--- + +## 8. CLI (`GameBoost.Cli` ou argumentos no exe principal) + +``` +GameBoost.exe --scan [arquivo] # relatório de varredura do Modo Game (já existe) +GameBoost.exe --report saida.html # relatório de saúde completo +GameBoost.exe --clean --preset seguro # limpeza com preset (seguro | completo) +GameBoost.exe --clean --categorias temp,wu,wer +GameBoost.exe --revert-all # reverte tudo do state-backup +GameBoost.exe --gamemode on|off +GameBoost.exe --dry-run # combina com qualquer comando, não altera nada +``` + +Saída em texto e `--json`. + +--- + +## 9. Blindagem (documentar em `docs/PROTECAO.md`) + +Aplicada por `SafetyGuard` central, consultado por todos os módulos. + +- **Processos:** lista da v1 + anti-cheats (`EasyAntiCheat`, `BEService`, `vgc`, `vgtray` (Vanguard), `FACEIT`, `PnkBstr`, `XignCode`, `GameGuard`, `nProtect`, `Ricochet`, `EAAntiCheat`), launchers nunca pré-marcados, `RTSS`, `MSIAfterburner` (usuário pode querer), overlays de captura (aviso). +- **Caminhos:** `C:\Windows` (exceto whitelist de limpeza), `Program Files*` (exceto via Desinstalador), pastas de usuário (`Documents`, `Pictures`, `Videos`, `Desktop`, `OneDrive`), qualquer pasta contendo `.git`, `saves`, `Saved Games`, `%APPDATA%` de jogos. +- **Serviços:** núcleo do Windows, antivírus, `wuauserv` (só pausa), rede (`Dhcp`, `Dnscache`, `nsi`, `NlaSvc`), áudio (`Audiosrv`, `AudioEndpointBuilder`), `Themes`, `DcomLaunch`, `RpcSs`, `Winmgmt`, `EventLog`, `Schedule`, `TrustedInstaller`, `CryptSvc`, `BFE`, `mpssvc`. +- **Registro:** nunca tocar em `HKLM\SYSTEM\CurrentControlSet\Services\*` além de `Start`, nunca em `Winlogon`, `Image File Execution Options`, `Policies`. +- **Apps:** ver 5.3. +- **Tweaks proibidos:** VBS/Core Isolation, mitigações de CPU, Defender, UAC, SmartScreen, assinatura de drivers. + +Teste obrigatório: `SafetyGuardTests` com casos para cada lista. + +--- + +## 10. Build, distribuição e atualização + +- `dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -p:PublishReadyToRun=true` (ReadyToRun reduz tempo de abertura). +- Trimming: **não** habilitar (WPF e reflexão quebram). +- Versão semântica em `Directory.Build.props`, propagada para Inno Setup. +- **Assinatura de código (validado set/2026):** + - **Azure Artifact Signing** (ex-Trusted Signing, a partir de US$ 9,99/mês) é a opção barata da Microsoft, mas para **desenvolvedor individual só aceita EUA e Canadá**; organizações precisam estar em EUA/Canadá/UE/UK e outros poucos países. **Brasil está fora**, tanto PF quanto PJ. Não contar com isso. + - **Certificado OV** de uma CA (Certum, Sectigo, DigiCert, GlobalSign): caminho viável para o Brasil. Desde jun/2023 a chave privada precisa ficar em token USB ou HSM em nuvem (a CA fornece). Faixa de US$ 70 a 300/ano. Certum costuma ser a mais barata para dev individual. + - **EV não pula mais o SmartScreen** desde 2024: OV e EV passam pelo mesmo processo de reputação. Não vale pagar EV. + - **Microsoft Store (MSIX)**: a Microsoft reassina o pacote e o SmartScreen nunca aparece. Exige `runFullTrust` e o app precisa passar na certificação (o Modo Game e as ações de sistema podem gerar perguntas). Vale como meta de médio prazo. + - Independente da opção: reputação só acumula com downloads, então assinar sempre com a mesma identidade e submeter cada release ao Microsoft Security Intelligence para reduzir falsos positivos. +- **Auto-update:** Velopack (sucessor do Squirrel, .NET moderno) apontando para GitHub Releases. Checar na abertura, baixar em background, aplicar no próximo início. Configurável. Sem web, apenas mostrar "versão X disponível" se o usuário clicar "Verificar". +- **Portátil:** o mesmo exe publicado, zipado, com `portable.txt`. +- **CI:** GitHub Actions `windows-latest`: build, testes, publish, Inno Setup, anexar ao Release. Gerar `SHA256SUMS.txt`. +- **Instalador:** manter Inno Setup. Adicionar página de opções: atalho na bandeja ao iniciar, associar tarefa de limpeza semanal (desligada por padrão), instalar para todos os usuários vs. só atual. + +--- + +## 11. Testes + +- **Unit (xUnit):** `SafetyGuard`, `RollbackEngine` (aplicar → reverter → estado igual), parsers (registro Uninstall, `libraryfolders.vdf`, UserAssist ROT13, versão de driver NVIDIA), regras de `Bottleneck` (dado um snapshot de métricas, gera os Findings esperados), whitelist do Cleaner (todo caminho gerado pertence à whitelist). +- **Integração (rodam só em Windows, tag `[Trait("Category","Windows")]`):** limpeza real em pasta temp sintética; leitura de MFT em volume real (só leitura); desinstalação de um MSI de teste (criar com WiX ou usar `msiexec` em pacote conhecido); startup toggle em chave `HKCU` fake. +- **Manual (checklist em `docs/QA.md`):** SmartScreen, antivírus, máquina com 8 GB, notebook com iGPU + dGPU, usuário sem admin, Windows 10 22H2 e Windows 11 24H2+, disco FAT32 externo, jogo com Vanguard rodando (nada pode ser fechado). +- **Dry-run** em todos os módulos: `--dry-run` produz o mesmo relatório sem tocar em nada; teste garante que `IFileSystem`/`IRegistry` fakes não recebem chamadas de escrita. + +--- + +## 12. Fases de implementação (ordem obrigatória) + +Cada fase: branch própria, PR, changelog em `CHANGELOG.md`. + +### Fase 0 · Fundação (refatorar sem mudar comportamento) +- Separar `GameBoost.Core` (sem WPF) de `GameBoost.App`. +- Extrair `SafetyGuard`, `RollbackEngine`, `Logger`, `Settings` com `schemaVersion`. +- Criar `IModule` / `ActionItem` e portar o Modo Game para esse contrato. +- Criar a tela genérica de lista de `ActionItem` + confirmação. +- Configurar DI, CommunityToolkit.Mvvm, xUnit, GitHub Actions. +- Gerar `CLAUDE.md` com a seção 2 e o mapa de pastas. +- **Pronto quando:** app faz exatamente o que a v1 fazia, com testes de `SafetyGuard` e `RollbackEngine` passando. + +### Fase 1 · Diagnóstico de gargalos (5.5) + Relatório (5.12) +Motivo: é o que faz o usuário abrir o app todo dia e entender o valor do resto. + +### Fase 2 · Limpeza (5.2) + Ferramentas rápidas (5.13) + +### Fase 3 · Analisador de disco (5.4) + Biblioteca de jogos (parte de 5.11) + +### Fase 4 · Desinstalador (5.3) + Inicialização (5.6) + +### Fase 5 · Tweaks (5.8) + Serviços (5.7) + Rede (5.9) + Drivers (5.10) + +### Fase 6 · Perfis por jogo com detecção automática (5.1 + 5.11), bandeja, onboarding + +### Fase 7 · Distribuição: Velopack, CI completo, portátil, assinatura, submissão de falsos positivos + +### Backlog (depois da v2.0) +- Overlay de FPS in-game (integração com RTSS via shared memory, ou hook próprio em D3D11/12, que é trabalho grande e risco com anti-cheat; preferir RTSS). +- Duplicados e arquivos grandes esquecidos com sugestão de compressão NTFS (`compact /c /exe:xpress8k` em pastas de jogos, que economiza 20 a 40% sem perda de FPS em SSD). +- Curva de ventoinha (fora de escopo, depende de hardware). +- Versão EN e loja Microsoft Store (MSIX com `runFullTrust`). +- Benchmark rápido antes/depois (rodar 30 s de carga sintética e comparar) para provar ganho. + +--- + +## 13. Prompts sugeridos para o Claude Code (um por fase) + +**Fase 0** +> Leia `GAMEBOOST_V2_SPEC.md` inteiro. Execute a Fase 0: refatore o projeto para a estrutura da seção 4.1 sem alterar nenhum comportamento visível. Crie `SafetyGuard`, `RollbackEngine`, `Logger` e `Settings` conforme seções 2, 7 e 9. Porte o Modo Game para `IModule`/`ActionItem`. Adicione xUnit com testes para `SafetyGuard` e `RollbackEngine`. Gere `CLAUDE.md` com as regras da seção 2. Ao final, `dotnet build` e `dotnet test` limpos, e liste em `docs/DECISOES.md` qualquer desvio. + +**Fase 1** +> Implemente o módulo `Bottleneck` (seção 5.5) e `HealthReport` (5.12). Coleta a cada 1 s com buffer de 5 min, contadores de CPU/GPU/RAM/disco/rede, LibreHardwareMonitorLib opcional para temperaturas. Implemente todas as regras de diagnóstico da tabela como classes `IFindingRule` testáveis. Tela com 5 medidores, gráfico de 60 s, top 10 processos e lista de Findings. Exporte `relatorio.html`. Meça e garanta < 1,5% CPU. + +**Fases seguintes:** mesmo padrão: "Implemente o módulo X conforme seção 5.Y, respeitando seções 2 e 9, com testes das regras, dry-run funcional e entrada no `docs/TWEAKS.md` ou `docs/PROTECAO.md` quando aplicável." + +--- + +## 14. Glossário rápido (para textos da UI) + +- **Standby List:** memória que o Windows guarda "por precaução" com dados já usados. Liberar ajuda quando falta RAM, não aumenta FPS por si só. +- **Shader cache:** arquivos que o jogo gera para não recompilar efeitos. Apagar libera espaço, mas o jogo engasga nas primeiras horas até recriar. +- **HAGS:** deixa a placa de vídeo gerenciar a própria fila de trabalho. Ajuda em alguns casos, atrapalha em outros. Teste com e sem. +- **Throttling:** o processador reduz a velocidade para não superaquecer. Sinal de cooler sujo ou pasta térmica velha. +- **Gargalo de CPU:** o processador não consegue preparar quadros rápido o suficiente; a placa de vídeo fica esperando. + +--- + +*Documento gerado em 13/09/2026 para o projeto GameBoost, com pesquisa de mercado validada por fontes web na mesma data. Autor do produto: Jonathan Vaz.* diff --git a/GameBoost/GameBoost.sln b/GameBoost/GameBoost.sln new file mode 100644 index 0000000..7731860 --- /dev/null +++ b/GameBoost/GameBoost.sln @@ -0,0 +1,84 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.Core", "src\GameBoost.Core\GameBoost.Core.csproj", "{67F62495-3B0A-4309-BC87-D97EABE2D2A7}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.Cli", "src\GameBoost.Cli\GameBoost.Cli.csproj", "{94138042-896D-4F31-BAED-E287520B18A7}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.Tests", "src\GameBoost.Tests\GameBoost.Tests.csproj", "{984E3716-662D-4E8C-8B6F-B81C33CDF790}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.App", "src\GameBoost.App\GameBoost.App.csproj", "{CAF682AC-B64C-483C-9C80-533990BC4F24}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x64.ActiveCfg = Debug|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x64.Build.0 = Debug|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x86.ActiveCfg = Debug|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x86.Build.0 = Debug|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|Any CPU.Build.0 = Release|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x64.ActiveCfg = Release|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x64.Build.0 = Release|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x86.ActiveCfg = Release|Any CPU + {67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x86.Build.0 = Release|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Debug|x64.ActiveCfg = Debug|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Debug|x64.Build.0 = Debug|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Debug|x86.ActiveCfg = Debug|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Debug|x86.Build.0 = Debug|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Release|Any CPU.Build.0 = Release|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Release|x64.ActiveCfg = Release|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Release|x64.Build.0 = Release|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Release|x86.ActiveCfg = Release|Any CPU + {94138042-896D-4F31-BAED-E287520B18A7}.Release|x86.Build.0 = Release|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|Any CPU.Build.0 = Debug|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x64.ActiveCfg = Debug|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x64.Build.0 = Debug|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x86.ActiveCfg = Debug|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x86.Build.0 = Debug|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|Any CPU.ActiveCfg = Release|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|Any CPU.Build.0 = Release|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x64.ActiveCfg = Release|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x64.Build.0 = Release|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x86.ActiveCfg = Release|Any CPU + {984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x86.Build.0 = Release|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x64.ActiveCfg = Debug|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x64.Build.0 = Debug|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x86.ActiveCfg = Debug|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x86.Build.0 = Debug|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|Any CPU.Build.0 = Release|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x64.ActiveCfg = Release|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x64.Build.0 = Release|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x86.ActiveCfg = Release|Any CPU + {CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x86.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {67F62495-3B0A-4309-BC87-D97EABE2D2A7} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {94138042-896D-4F31-BAED-E287520B18A7} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {984E3716-662D-4E8C-8B6F-B81C33CDF790} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + {CAF682AC-B64C-483C-9C80-533990BC4F24} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B} + EndGlobalSection +EndGlobal diff --git a/GameBoost/README.md b/GameBoost/README.md new file mode 100644 index 0000000..9a53716 --- /dev/null +++ b/GameBoost/README.md @@ -0,0 +1,120 @@ +# GameBoost + +**O booster que mostra o que faz e desfaz tudo.** + +Central de otimização e manutenção para PC gamer no Windows 10 e 11. Sem anúncio, sem conta, +sem telemetria, sem assinatura. PT-BR nativo. + +> **Estado:** v2.0.0 em desenvolvimento — Fase 0 (fundação) concluída. +> O Modo Game está funcional; os demais módulos chegam nas fases seguintes. + +--- + +## O que faz hoje + +**Modo Game.** Encerra os aplicativos que você confirmar, libera memória, aplica o plano de +energia de alto desempenho, sobe a prioridade do jogo e silencia notificações, gravação em +segundo plano e Windows Update. Ao desligar, devolve tudo ao estado anterior e reabre os +apps marcados com ★. + +Três coisas que ele não faz, por princípio: + +- **Não fecha o jogo nem o anti-cheat.** Vanguard, EasyAntiCheat, BattlEye e companhia nem + aparecem selecionáveis. +- **Não mata nada sem pedir.** Todo app recebe primeiro o pedido de fechamento normal, com + 3 segundos para salvar. A tela de confirmação aparece antes de qualquer coisa ser fechada. +- **Não inventa número.** O ganho mostrado é o medido: RAM livre antes e depois, apps + fechados, alterações aplicadas. + +## O que vem depois + +| Fase | Módulo | +|---|---| +| 1 | Diagnóstico de gargalos ("por que está lento?") e relatório de saúde | +| 2 | Limpeza de temporários e caches, ferramentas rápidas | +| 3 | Analisador de espaço em disco, biblioteca de jogos | +| 4 | Desinstalador (Win32 + Store + restos), gerenciador de inicialização | +| 5 | Tweaks de jogos, serviços, rede, drivers | +| 6 | Perfis por jogo com detecção automática, bandeja, onboarding | +| 7 | Distribuição: auto-update, CI completo, portátil, assinatura | + +--- + +## Reversibilidade + +Antes de alterar qualquer coisa, o GameBoost grava o valor anterior em +`state-backup.json`. Isso vale para registro, serviços e plano de energia. + +- O botão **Reverter tudo** está sempre visível. +- Se o app travar ou o PC reiniciar com o Modo Game ativo, a próxima abertura avisa e + oferece a restauração. +- O desinstalador roda a reversão antes de remover o app. + +Sem isso, um travamento com o Windows Update pausado deixaria a máquina sem atualizações +indefinidamente. + +--- + +## Linha de comando + +``` +GameBoost.exe abre a interface +GameBoost.exe --scan [arquivo] relatório de varredura, não encerra nada +GameBoost.exe --report saida.html relatório de saúde completo (Fase 1) +GameBoost.exe --clean --preset seguro limpeza (Fase 2) +GameBoost.exe --revert-all reverte tudo do state-backup +GameBoost.exe --gamemode on|off liga ou desliga o Modo Game +``` + +Modificadores: `--dry-run` (combina com qualquer comando, não altera nada), `--json`, +`--help`. + +## Onde ficam os dados + +`%LOCALAPPDATA%\GameBoost\` — `settings.json`, `session.json`, `state-backup.json`, +`gameboost.log` (rotacionado, 5 MB × 5). + +**Modo portátil:** criando um `portable.txt` ao lado do executável, tudo passa a ficar em +`.\data\`. + +--- + +## Compilar + +Requisitos: .NET 9 SDK e, para o instalador, Inno Setup 6. + +```powershell +dotnet build GameBoost.sln +dotnet test GameBoost.sln + +# Executável final (self-contained, arquivo único) +dotnet publish src\GameBoost.App\GameBoost.App.csproj -c Release -o publish + +# Instalador +& "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe" installer\GameBoost.iss +``` + +O app exige privilégios de administrador (encerrar processos, controlar serviços e purgar a +Standby List). Sem elevação ele abre em modo somente leitura: as varreduras funcionam e as +ações ficam desabilitadas. + +## Avisos conhecidos + +- **SmartScreen.** O instalador ainda não é assinado. Ver seção 10 do spec para o caminho de + assinatura (certificado OV; Azure Artifact Signing não atende o Brasil). +- **Antivírus.** Encerrar processos e elevar privilégios é o mesmo comportamento que um + malware teria — alguns antivírus reclamam de qualquer booster. + +## Documentação + +| Arquivo | Conteúdo | +|---|---| +| [CLAUDE.md](CLAUDE.md) | Regras obrigatórias para código novo | +| [docs/PROTECAO.md](docs/PROTECAO.md) | Listas de blindagem, documentadas | +| [docs/TWEAKS.md](docs/TWEAKS.md) | Catálogo de tweaks com efeito real e risco | +| [docs/DECISOES.md](docs/DECISOES.md) | Decisões que fugiram do spec, com motivo | +| [docs/QA.md](docs/QA.md) | Checklist de teste manual | + +--- + +Autor: Jonathan Vaz. diff --git a/GameBoost/docs/DECISOES.md b/GameBoost/docs/DECISOES.md new file mode 100644 index 0000000..f8bb170 --- /dev/null +++ b/GameBoost/docs/DECISOES.md @@ -0,0 +1,121 @@ +# Decisões de projeto + +Registro de toda decisão que fugiu do `GAMEBOOST_V2_SPEC.md`, com data e motivo. + +--- + +## 2026-09-13 — A Fase 0 virou reconstrução, não refatoração + +**Contexto.** A Fase 0 do spec diz "refatore o projeto para a estrutura da seção 4.1 **sem +alterar nenhum comportamento visível**". Isso pressupõe o código-fonte da v1.0.0. + +**O que existia.** Apenas o binário: `GameBoost.rar` com `GameBoost.exe` (68 MB, +self-contained, compilado em 03/09/2026), `LEIA-ME.txt` e o desinstalador Inno. Nenhum +`.csproj`, `.sln`, `.iss` ou repositório git da v1 em nenhum disco da máquina. + +**Decisão.** Reconstruir a v1 do zero já dentro da arquitetura alvo da seção 4.1, usando o +`LEIA-ME.txt` da v1 e a seção 1 do spec como especificação do comportamento a reproduzir. + +**Consequência.** Não há garantia de paridade byte-a-byte com a v1 — só de paridade +funcional com o que estava documentado. O checklist de QA (`docs/QA.md`) lista o que precisa +ser validado à mão contra o binário antigo. + +--- + +## 2026-09-13 — CLI é biblioteca, não executável separado + +**Spec.** A seção 4.1 lista `GameBoost.Cli/` como projeto; a seção 8 diz +"`GameBoost.Cli` ou argumentos no exe principal". + +**Decisão.** `GameBoost.Cli` é uma **biblioteca** (`CommandLineOptions` + `CommandRunner`) +consumida pelo `GameBoost.App`. O `App.OnStartup` faz o parse dos argumentos e, se for um +comando de linha, anexa ao console do processo pai (`AttachConsole(-1)`), executa e sai. + +**Motivo.** A v1 expunha `GameBoost.exe --scan relatorio.txt`. Dois executáveis quebrariam +esse contrato, dobrariam o tamanho do publish self-contained e obrigariam o instalador a +distribuir os dois. Uma biblioteca preserva o comando da v1 e ainda deixa a lógica testável +sem levantar processo. + +--- + +## 2026-09-13 — `AppSettings.SchemaVersion` começa em 0, não na versão atual + +**Decisão.** O inicializador do campo foi removido; a propriedade começa em `0` e o +`SettingsStore.Save` carimba `VersaoAtual` na gravação. + +**Motivo.** Com `= VersaoAtual` no campo, um `settings.json` da v1 — que não gravava +`schemaVersion` — desserializava como se já fosse da versão corrente, e o migrador **nunca +rodava**. O bug foi pego pelo teste +`Settings_da_v1_sem_schema_version_e_migrado_e_o_original_vira_bak`. + +--- + +## 2026-09-13 — Prioridade do jogo não gera ChangeRecord + +**Decisão.** Subir a prioridade do processo do jogo para Alta é registrado no log, mas não +gera entrada em `state-backup.json`. + +**Motivo.** Prioridade de processo é estado volátil: morre junto com o processo e não +sobrevive a reboot. Um `ChangeRecord` pendente apontando para um PID que não existe mais só +poluiria a lista de reversão. A regra 1 continua valendo para tudo que **persiste** +(registro, serviço, plano de energia). + +--- + +## 2026-09-13 — Processos críticos não aparecem na lista da UI + +**Spec.** A seção 4.2 prevê itens protegidos aparecendo bloqueados, não selecionáveis. + +**Decisão.** Itens protegidos por `ProcessoCritico`, `DentroDoWindows`, `OutraSessao` e +`ProprioApp` são **omitidos** da lista. Anti-cheats e antivírus **aparecem**, bloqueados, +com a explicação. + +**Motivo.** Incluir todos encheria a tela com dezenas de `svchost` que o usuário nunca deve +tocar, escondendo o que importa. Anti-cheat e antivírus continuam visíveis de propósito: é +informação útil ("o Vanguard está rodando"), e ver que o app se recusa a tocar neles é o que +constrói confiança. + +--- + +## 2026-09-13 — Escrita de arquivo com retry na troca atômica + +**Decisão.** `WindowsFileSystem.WriteAllText` grava `.tmp` e faz `File.Move(overwrite)` com +até 5 tentativas e espera progressiva. + +**Motivo.** O antivírus desta máquina segura o handle do `.tmp` por alguns milissegundos +depois da escrita, fazendo a troca atômica falhar com `IOException` de forma intermitente. +Sem o retry, `state-backup.json` poderia não ser gravado exatamente no momento mais crítico: +logo antes de alterar o sistema. + +--- + +## 2026-09-13 — ReadyToRun dobra o tamanho do executável + +**Medido.** O publish self-contained single-file da v2 saiu com **138 MB**, contra 68 MB do +`GameBoost.exe` da v1.0.0. + +**Causa.** `PublishReadyToRun=true`, pedido pela seção 10 do spec para reduzir o tempo de +abertura. Ele embute código nativo pré-compilado junto do IL. + +**Decisão.** Manter ligado, como o spec pede, e medir o tempo de abertura com e sem antes de +decidir de vez. Trimming continua proibido (quebra WPF), então não há como recuperar o +tamanho por esse caminho. + +**A conferir na Fase 7:** se o ganho de abertura não justificar +70 MB de download, desligar +ReadyToRun é a alternativa óbvia — o instalador comprimido sofre menos com isso que o +download do portátil. + +--- + +## Pendências conhecidas desta fase + +- `--report` (seção 5.12) e `--clean` (seção 5.2) respondem com "chega na Fase N" e código + de saída 3. Estão no parser porque a superfície da CLI da seção 8 precisa existir inteira + desde já. +- `Resources/Strings.pt-BR.resx` ainda não existe: as strings estão no código. A regra 7 diz + que devem sair para recurso; fica para quando houver a segunda tela, para não criar um + arquivo de recursos com meia dúzia de entradas. +- Detecção automática de jogo por `Win32_ProcessStartTrace` (seção 5.1) não foi feita: a + detecção atual é sob demanda, durante a varredura. Entra na Fase 6, junto com os perfis. +- Timer resolution: o P/Invoke existe (`NativeMethodsBridge.SetTimerResolution`) mas não é + chamado pelo Modo Game ainda. Entra na Fase 6. diff --git a/GameBoost/docs/PROTECAO.md b/GameBoost/docs/PROTECAO.md new file mode 100644 index 0000000..1e27692 --- /dev/null +++ b/GameBoost/docs/PROTECAO.md @@ -0,0 +1,140 @@ +# Blindagem + +Documentação das listas de proteção da seção 9 do spec. Toda lista aqui tem teste +correspondente em `SafetyGuardTests`. **Se algum desses testes cair, o app não pode ser +publicado.** + +Ponto único de consulta: `ISafetyGuard`, implementado por +[`SafetyGuard`](../src/GameBoost.Core/Safety/SafetyGuard.cs). Nenhum módulo decide sozinho o +que pode tocar. + +--- + +## 1. Processos + +### 1.1 Núcleo do Windows — omitidos da lista + +`ProtectedProcesses.Criticos`. Encerrar qualquer um derruba a sessão ou o sistema. + +`system`, `idle`, `registry`, `memory compression`, `secure system`, `smss`, `csrss`, +`wininit`, `winlogon`, `services`, `lsass`, `lsaiso`, `svchost`, `spoolsv`, `dwm`, +`explorer`, `fontdrvhost`, `sihost`, `taskhostw`, `ctfmon`, `runtimebroker`, +`shellexperiencehost`, `startmenuexperiencehost`, `searchhost`, `searchindexer`, `audiodg`, +`conhost`, `dllhost`, `wudfhost`, `wmiprvse`, `trustedinstaller`, `tiworker`, `logonui`, +`userinit`, `dashost`, `applicationframehost`, `textinputhost`, `systemsettings`, +`backgroundtaskhost` + +Além da lista: **qualquer PID ≤ 4** e **qualquer executável dentro de `C:\Windows`**. + +> A comparação de caminho é por segmento. `C:\WindowsApps` **não** conta como dentro de +> `C:\Windows` — há teste para isso. + +### 1.2 Anti-cheats — aparecem bloqueados + +`ProtectedProcesses.AntiCheats`. Fechar derruba o jogo e pode gerar banimento. + +`easyanticheat` (+ `_eos`, `_setup`), `beservice`, `bedaisy`, `battleye`, `vgc`, `vgtray`, +`vgk` (Vanguard), `faceitservice`, `faceit`, `pnkbstra/b/k` (PunkBuster), `xigncode`, +`xhunter1`, `gameguard`, `gamemon`, `npggnt`, `nprotect`, `ricochet`, `eaanticheat`, +`anticheatexpert`, `ace-base`, `ace-guard`, `mhyprot`, `sgguard`, `steamservice` + +### 1.3 Antivírus e EDR — aparecem bloqueados + +Detecção em duas camadas: + +1. **WMI** `root\SecurityCenter2` (`AntiVirusProduct`, `AntiSpywareProduct`, + `FirewallProduct`) → nome do executável assinado. É a fonte de verdade. +2. **Lista estática** `ProtectedProcesses.Seguranca`, rede de segurança para quando o WMI + falhar ou o produto não se registrar: Defender, Kaspersky, Avast/AVG, Bitdefender, + McAfee, Norton, ESET, Sophos, Carbon Black, CrowdStrike, SentinelOne, Cylance, Trend + Micro, Webroot, Malwarebytes. + +### 1.4 Nunca pré-marcados — aparecem desmarcados (regra 3) + +`ProtectedProcesses.NuncaPreMarcados`. O usuário pode marcar à mão; o app nunca marca por +ele. + +| Grupo | Exemplos | +|---|---| +| Launchers | Steam, Epic, Battle.net, Riot Client, GOG Galaxy, EA Desktop, Origin, Ubisoft Connect, Xbox | +| Overlay e monitoramento | RTSS, RivaTuner, MSI Afterburner | +| Gravação e streaming | OBS, Streamlabs, XSplit, NVIDIA Share, Radeon Software | +| IDEs e editores | Visual Studio, VS Code, Rider, IntelliJ, PyCharm, WebStorm | +| Criação | Photoshop, Illustrator, Premiere, After Effects | +| Office | Excel, Word, PowerPoint, Outlook | +| Virtualização | VMware, VirtualBox, Docker Desktop | + +Além da lista: **qualquer executável dentro de pasta de jogo** — +`\steamapps\common\`, `\Epic Games\`, `\Riot Games\`, `\Battle.net\`, +`\GOG Galaxy\Games\`, `\XboxGames\`, `\EA Games\`, `\Origin Games\`, `\Ubisoft\`. + +### 1.5 Listas do usuário + +`settings.json` aceita `NuncaEncerrar` e `SempreEncerrar`. + +**`SempreEncerrar` não vence a blindagem.** Colocar `lsass` nessa lista não libera nada — há +teste garantindo. Ela só supera a lista de "nunca pré-marcados": quem quer que a Steam venha +marcada pode pedir isso. + +--- + +## 2. Caminhos + +`CheckPath(caminho, whitelist)` só libera se o caminho estiver **dentro** de algum item da +whitelist do módulo. **Whitelist vazia não libera nada.** O caminho é normalizado com +`Path.GetFullPath` antes de qualquer comparação, então `..\` não escapa. + +Bloqueados mesmo dentro da whitelist — se o segmento aparecer em **qualquer nível**: + +`.git`, `onedrive`, `dropbox`, `google drive`, `icloud`, `saves`, `savegames`, +`saved games`, `savedgames`, `my games` + +Pastas pessoais (`Documentos`, `Imagens`, `Vídeos`, `Música`, `Área de Trabalho`, +`Favoritos`) são bloqueadas a menos que a própria whitelist do módulo aponte para dentro +delas — o que exige decisão explícita de quem escreveu o módulo. + +Pastas de sistema (`C:\Windows`, `Program Files`, `Program Files (x86)`, `System32`, +`SysWOW64`) só são alcançáveis pela whitelist explícita de limpeza da seção 5.2, e +`Program Files` só via Desinstalador. + +--- + +## 3. Serviços + +`ProtectedServices.Intocaveis` — não podem ser parados nem ter o `StartType` alterado: + +| Grupo | Serviços | +|---|---| +| Núcleo | `DcomLaunch`, `RpcSs`, `RpcEptMapper`, `Winmgmt`, `EventLog`, `Schedule`, `TrustedInstaller`, `CryptSvc`, `PlugPlay`, `Power`, `ProfSvc`, `SamSs`, `LSM`, `Themes`, `UserManager`, `gpsvc`, `BrokerInfrastructure`, `SystemEventsBroker` | +| Rede | `Dhcp`, `Dnscache`, `nsi`, `NlaSvc`, `netprofm`, `WlanSvc`, `LanmanWorkstation` | +| Áudio | `Audiosrv`, `AudioEndpointBuilder` | +| Segurança | `WinDefend`, `SecurityHealthService`, `wscsvc`, `Sense`, `mpssvc`, `BFE` | +| Update | `wuauserv` | + +`ProtectedServices.PausaveisTemporariamente` — podem ser **parados** durante o Modo Game, +nunca desabilitados: `wuauserv`, `UsoSvc`, `DoSvc`, `BITS`. + +A parada grava `ChangeRecord` com `estavaRodando=true`, então o serviço volta no +desligamento do Modo Game, no "Reverter tudo", na próxima abertura após um travamento e no +desinstalador. + +--- + +## 4. Registro + +- Nunca tocar em `HKLM\SYSTEM\CurrentControlSet\Services\*` além de `Start`. +- Nunca tocar em `Winlogon`, `Image File Execution Options`, `Policies`. +- Toda escrita passa por `ChangeRecord` com `root`, `kind` e `ValorAnteriorExistia`. Quando + o valor **não existia**, reverter significa **apagar**, não gravar zero — há teste. + +--- + +## 5. Tweaks proibidos + +Nunca alterados pelo GameBoost, em nenhuma fase: + +- **VBS / Core Isolation (Memory Integrity)** — só informar e medir, com link para as + Configurações do Windows. É segurança contra malware de kernel; a decisão é do usuário. +- **Mitigações de Spectre/Meltdown** +- **Windows Defender**, **UAC**, **SmartScreen**, **assinatura de drivers** +- **Limpeza de registro** — sem ganho mensurável, risco puro (regra 4) diff --git a/GameBoost/docs/QA.md b/GameBoost/docs/QA.md new file mode 100644 index 0000000..367c05b --- /dev/null +++ b/GameBoost/docs/QA.md @@ -0,0 +1,78 @@ +# Checklist de QA manual + +O que os testes automatizados não cobrem. Nenhuma release sai sem isto. + +Legenda: `[ ]` não testado · `[x]` passou · `[!]` falhou, ver observação. + +--- + +## Fase 0 — paridade com a v1.0.0 + +A v1 foi reconstruída a partir do `LEIA-ME.txt` (ver `DECISOES.md`), então a paridade +funcional precisa ser conferida à mão contra o binário antigo. + +- [ ] `GameBoost.exe --scan relatorio.txt` gera relatório e **não encerra nada** +- [ ] `GameBoost.exe --scan` sem argumento imprime no terminal que chamou +- [ ] Ativar o Modo Game abre a tela de confirmação com tudo pré-marcado **antes** de fechar + qualquer coisa +- [ ] Um app com trabalho não salvo (Bloco de Notas com texto) mostra o próprio diálogo de + salvar; só é finalizado à força depois dos 3 s +- [ ] Apps marcados com ★ reabrem sozinhos ao desligar +- [ ] Apps não marcados aparecem na lista de restauração com botão individual +- [ ] Plano de energia volta ao anterior ao desligar +- [ ] Windows Update volta a rodar ao desligar (`Get-Service wuauserv`) +- [ ] Game DVR e Game Bar voltam aos valores originais (conferir no `regedit`) + +## Reversão e recuperação + +- [ ] Ativar o Modo Game, **matar o GameBoost pelo Gerenciador de Tarefas**, reabrir: + aparece o aviso "foi fechado com o Modo Game ainda ativo" com o botão Restaurar agora +- [ ] Ativar o Modo Game, **reiniciar o PC**, abrir: mesmo aviso +- [ ] "Reverter tudo" funciona a qualquer momento, mesmo sem Modo Game ativo +- [ ] Rodar o desinstalador com o Modo Game ativo reverte antes de remover +- [ ] Reverter duas vezes seguidas não reaplica nada +- [ ] Ativar e desativar **10 vezes seguidas** sem vazar estado + (`state-backup.json` termina sem pendências) + +## Blindagem — o teste que não pode falhar + +- [ ] **Com Valorant aberto (Vanguard rodando)**: nem `vgc`, nem `vgtray`, nem `vgk` + aparecem selecionáveis. Ativar o Modo Game **não derruba o jogo** +- [ ] Com jogo da Steam aberto: o jogo aparece na categoria "Jogo", bloqueado +- [ ] Steam, Epic e Battle.net aparecem **desmarcados** +- [ ] OBS gravando aparece desmarcado +- [ ] Nenhum processo do antivírus aparece selecionável + +## Ambiente + +- [ ] **Usuário sem admin**: varreduras funcionam, botões de ação desabilitados com aviso + visível de modo somente leitura +- [ ] Windows 10 22H2 +- [ ] Windows 11 24H2 ou mais novo +- [ ] Máquina com 8 GB de RAM (é onde a limpeza de RAM rende de verdade) +- [ ] Notebook com iGPU + dGPU +- [ ] Dois usuários logados: processos da outra sessão não aparecem +- [ ] Monitor 4K e escala de 150% (DPI per-monitor v2) + +## Distribuição + +- [ ] SmartScreen: anotar exatamente o que aparece no primeiro download +- [ ] Windows Defender não bloqueia o instalador nem a execução +- [ ] Submeter ao Microsoft Security Intelligence se houver falso positivo +- [ ] Modo portátil: `portable.txt` ao lado do exe faz os dados irem para `.\data\` +- [ ] Instalação limpa em máquina sem .NET instalado (publish é self-contained) +- [ ] Desinstalação não deixa `%LOCALAPPDATA%\GameBoost` com dados do usuário sem avisar + +## Desempenho + +- [ ] Varredura completa em menos de 5 s numa máquina com ~250 processos +- [ ] A UI não congela durante a varredura (o botão Cancelar responde) +- [ ] O app ocioso consome menos de 60 MB de RAM + +--- + +## Observações de execução + +| Data | Item | Resultado | +|---|---|---| +| | | | diff --git a/GameBoost/docs/TWEAKS.md b/GameBoost/docs/TWEAKS.md new file mode 100644 index 0000000..358320b --- /dev/null +++ b/GameBoost/docs/TWEAKS.md @@ -0,0 +1,93 @@ +# Catálogo de tweaks + +Cada tweak: chave, valor, efeito real, evidência, risco e reversão. Todos desligados por +padrão, aplicados individualmente, sempre com snapshot em `state-backup.json`. + +**A coluna "efeito real" é honesta por obrigação (regra 4).** Se um tweak é marginal, está +escrito que é marginal. + +--- + +## Implementados na Fase 0 (Modo Game) + +Aplicados em bloco pelo Modo Game, revertidos no desligamento. Ver +[`SystemSilencer`](../src/GameBoost.Core/Modules/GameMode/SystemSilencer.cs). + +| Tweak | Chave | Valor | Efeito real | Risco | +|---|---|---|---|---| +| Notificações do Windows | `HKCU\Software\Microsoft\Windows\CurrentVersion\PushNotifications` → `ToastEnabled` | `0` | Impede notificação aparecendo sobre o jogo em tela cheia. Efeito de conforto, não de FPS | Baixo | +| Game DVR | `HKCU\System\GameConfigStore` → `GameDVR_Enabled` | `0` | Desliga gravação contínua em segundo plano. Ganho real em máquina fraca; em PC forte é pequeno | Baixo | +| Overlay da Game Bar | `HKCU\Software\Microsoft\GameBar` → `UseNexusForGameBarEnabled` | `0` | Evita a injeção do overlay em todo jogo aberto | Baixo | +| Painel da Game Bar | `HKCU\Software\Microsoft\GameBar` → `ShowStartupPanel` | `0` | Só evita o painel aparecer ao abrir o jogo | Baixo | + +**Reversão:** cada um grava o valor anterior e o flag `ValorAnteriorExistia`. Quando a chave +não existia, a reversão **apaga** o valor em vez de gravar zero. + +### Plano de energia + +Aplica **Desempenho Máximo** se existir, senão **Alto desempenho**; guarda o GUID do plano +anterior e restaura no desligamento. + +| Plano | GUID | +|---|---| +| Balanceado | `381b4222-f694-41f0-9685-ff5bb260df2e` | +| Alto desempenho | `8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c` | +| Desempenho Máximo | `e9a42b02-d5df-448d-aa00-03f14749eb61` | +| Economia de energia | `a1841308-3541-4fab-bc81-f71556f20b4a` | + +**Evidência:** é o item nº 1 do consenso técnico de 2026 (seção 3.4 do spec) — evita que a +CPU baixe o clock no meio do jogo. Junto com a poda da inicialização, é o ajuste de maior +valor e o mais fácil de reverter. + +### Pausa do Windows Update + +Para o serviço `wuauserv` (só para, nunca altera `StartType`). Grava `ChangeRecord` com +`estavaRodando=true`. + +**Por que importa reverter:** um travamento com o Update pausado deixaria a máquina sem +atualizações indefinidamente. Por isso a reversão acontece no desligamento, no "Reverter +tudo", na próxima abertura após travamento **e** no desinstalador. + +--- + +## Catálogo da Fase 5 (ainda não implementados) + +Listados aqui para que a pesquisa não se perca entre as fases. Nada disso está no código. + +| Tweak | Onde | Efeito real | Risco | +|---|---|---|---| +| HAGS | `HKLM\SYSTEM\CurrentControlSet\Control\GraphicsDrivers` → `HwSchMode = 2` (exige reboot) | **Obrigatório para DLSS Frame Generation.** Melhora frame pacing em RTX 30+/RX 6000+ com driver atual, **piora** em CPU antiga ou certas versões de driver. Custa até 1 GB de VRAM — atenção em placas de 8 GB. É o único ajuste que precisa ser **testado** em vez de só ligado: oferecer "Testar com/sem" | Médio | +| Game Mode do Windows | `HKCU\Software\Microsoft\GameBar` → `AutoGameModeEnabled` | Positivo no 22H2+; bloqueia Windows Update durante o jogo. Recomendar **ligado**; desligar só em conflito com streaming | Baixo | +| Fullscreen Optimizations por exe | `HKCU\System\GameConfigStore` → `GameDVR_FSEBehaviorMode` e `HKCU\...\AppCompatFlags\Layers` → `DISABLEDXMAXIMIZEDWINDOWEDMODE` | Depende do jogo. Oferecer por perfil, nunca global | Baixo | +| Multi-Plane Overlay (MPO) | `HKLM\SOFTWARE\Microsoft\Windows\Dwm` → `OverlayTestMode = 5` | Resolve stutter e flicker em alguns setups NVIDIA. Não faz nada na maioria | Médio | +| Nagle | `HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\` → `TcpAckFrequency`, `TCPNoDelay` | **Marginal.** Só ajuda em jogos com muitos pacotes TCP pequenos; a maioria usa UDP | Baixo | +| Network Throttling Index | `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Multimedia\SystemProfile` → `NetworkThrottlingIndex = 0xFFFFFFFF` | **Marginal** | Baixo | +| SystemResponsiveness | mesma chave → `SystemResponsiveness = 0` | Prioriza o processo em foreground. Efeito pequeno | Baixo | +| Games task priority | `...\SystemProfile\Tasks\Games` → `GPU Priority = 8`, `Priority = 6`, `Scheduling Category = High` | **Marginal** | Baixo | +| Aceleração do mouse | `HKCU\Control Panel\Mouse` → `MouseSpeed = 0`, `MouseThreshold1/2 = 0` | Consistência de mira. Não muda FPS | Baixo | +| Power throttling off | `powercfg /setacvalueindex … PERFBOOSTMODE` e `HKLM\…\Power\PowerThrottling` → `PowerThrottlingOff` | Evita clock baixo em notebook | Baixo | +| Desativar hibernação | `powercfg /h off` | Libera espaço igual ao tamanho da RAM. **Perde a Inicialização Rápida** | Médio | +| Efeitos visuais "melhor desempenho" | `HKCU\…\Explorer\VisualEffects` | Ajuda só em máquina muito fraca; piora a experiência de uso | Baixo | +| Timer resolution | `NtSetTimerResolution(0.5 ms)` enquanto o Modo Game estiver ativo | O Windows 11 já lida bem; ajuda mais no 10. P/Invoke já existe em `NativeMethodsBridge` | Baixo | + +### Nunca alterados + +| Item | Por quê | +|---|---| +| **VBS / Core Isolation (Memory Integrity)** | Custo medido pela comunidade de 5 a 15% em jogos CPU-bound (até 25% em casos extremos), mas é proteção contra malware de kernel. O GameBoost **informa e mede, não desliga**: mostra o estado via WMI `Win32_DeviceGuard`, o impacto estimado e o caminho nas Configurações do Windows. Trade-off de PC exclusivo de jogo vs. máquina de trabalho/banco é decisão do usuário | +| **Mitigações de Spectre/Meltdown** | Troca segurança real por poucos % | +| **Defender, UAC, SmartScreen, assinatura de drivers** | Fora de escopo, sempre | +| **Limpeza de registro** | Sem ganho mensurável. Risco puro (regra 4) | +| **Desfragmentação de SSD** | Placebo, desgasta a unidade | +| **Atualização automática de driver** | Instalar driver sozinho é risco. O GameBoost só detecta a idade e abre a página oficial | + +--- + +## Detector de reset pós-update + +Atualizações grandes do Windows (24H2, 26H2) **resetam** Game Mode, HAGS, plano de energia, +efeitos visuais e Game Bar. Nenhum concorrente avisa disso. + +Planejado para a Fase 1 como `Finding`: guardar a build do Windows junto do perfil aplicado +e, quando a build mudar e os valores não baterem mais, mostrar *"a atualização 26H2 desfez 4 +ajustes seus"* com o botão de reaplicar. diff --git a/GameBoost/installer/GameBoost.iss b/GameBoost/installer/GameBoost.iss new file mode 100644 index 0000000..e8f2c4c --- /dev/null +++ b/GameBoost/installer/GameBoost.iss @@ -0,0 +1,86 @@ +; Instalador do GameBoost (Inno Setup 6). +; Compilar com: ISCC.exe installer\GameBoost.iss +; Antes, publicar: dotnet publish src\GameBoost.App\GameBoost.App.csproj -c Release -o publish + +#define AppName "GameBoost" +#define AppVersion "2.0.0" +#define AppAutor "Jonathan Vaz" +#define AppExe "GameBoost.exe" + +[Setup] +AppId={{7C3F9A21-4E8B-4A6D-9F2C-8B1D5E7A3C90} +AppName={#AppName} +AppVersion={#AppVersion} +AppVerName={#AppName} {#AppVersion} +AppPublisher={#AppAutor} +DefaultDirName={autopf}\{#AppName} +DefaultGroupName={#AppName} +OutputDir=Output +OutputBaseFilename={#AppName}-Setup-{#AppVersion} +Compression=lzma2/max +SolidCompression=yes +WizardStyle=modern +ArchitecturesAllowed=x64compatible +ArchitecturesInstallIn64BitMode=x64compatible +; O app encerra processos, controla servicos e purga a Standby List. +PrivilegesRequired=admin +UninstallDisplayIcon={app}\{#AppExe} +MinVersion=10.0.17763 + +[Languages] +Name: "brazilianportuguese"; MessagesFile: "compiler:Languages\BrazilianPortuguese.isl" + +[Tasks] +Name: "desktopicon"; Description: "Criar atalho na area de trabalho"; GroupDescription: "Atalhos:" +Name: "startminimized"; Description: "Iniciar o GameBoost junto com o Windows, minimizado na bandeja"; GroupDescription: "Inicializacao:"; Flags: unchecked +; Desligada por padrao de proposito: agendamento so com escolha explicita do usuario. +Name: "limpezasemanal"; Description: "Agendar limpeza semanal com o preset seguro"; GroupDescription: "Manutencao:"; Flags: unchecked + +[Files] +Source: "..\publish\{#AppExe}"; DestDir: "{app}"; Flags: ignoreversion +Source: "..\README.md"; DestDir: "{app}"; DestName: "LEIA-ME.txt"; Flags: ignoreversion isreadme + +[Icons] +Name: "{group}\{#AppName}"; Filename: "{app}\{#AppExe}" +Name: "{group}\Desinstalar {#AppName}"; Filename: "{uninstallexe}" +Name: "{autodesktop}\{#AppName}"; Filename: "{app}\{#AppExe}"; Tasks: desktopicon + +[Registry] +Root: HKCU; Subkey: "Software\Microsoft\Windows\CurrentVersion\Run"; ValueType: string; \ + ValueName: "GameBoost"; ValueData: """{app}\{#AppExe}"" --minimizado"; \ + Flags: uninsdeletevalue; Tasks: startminimized + +[Run] +Filename: "{app}\{#AppExe}"; Description: "Abrir o {#AppName}"; Flags: nowait postinstall skipifsilent + +; Tarefa semanal opcional, aos domingos as 10h. +Filename: "{sys}\schtasks.exe"; \ + Parameters: "/Create /F /TN ""GameBoost - Limpeza semanal"" /SC WEEKLY /D SUN /ST 10:00 /RL HIGHEST /TR ""\""{app}\{#AppExe}\"" --clean --preset seguro"""; \ + Flags: runhidden; Tasks: limpezasemanal + +[UninstallRun] +; Regra 1: o desinstalador desfaz as alteracoes de sistema ANTES de remover o app. +; Sem isto, desinstalar com o Modo Game ativo deixaria o Windows Update pausado +; e o plano de energia trocado para sempre. +Filename: "{app}\{#AppExe}"; Parameters: "--revert-all"; Flags: runhidden waituntilterminated; RunOnceId: "ReverterTudo" +Filename: "{sys}\schtasks.exe"; Parameters: "/Delete /F /TN ""GameBoost - Limpeza semanal"""; Flags: runhidden; RunOnceId: "RemoverTarefa" + +[UninstallDelete] +Type: filesandordirs; Name: "{app}\data" + +[Code] +// Os dados do usuario (preferencias, historico, log) ficam fora de {app} e nao sao +// apagados sem pergunta. +procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep); +var + Dados: String; +begin + if CurUninstallStep = usPostUninstall then + begin + Dados := ExpandConstant('{localappdata}\GameBoost'); + if DirExists(Dados) then + if MsgBox('Remover tambem suas preferencias, historico e log?' + #13#10 + #13#10 + Dados, + mbConfirmation, MB_YESNO) = IDYES then + DelTree(Dados, True, True, True); + end; +end; diff --git a/GameBoost/src/GameBoost.App/App.xaml b/GameBoost/src/GameBoost.App/App.xaml new file mode 100644 index 0000000..dbb128e --- /dev/null +++ b/GameBoost/src/GameBoost.App/App.xaml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + diff --git a/GameBoost/src/GameBoost.App/App.xaml.cs b/GameBoost/src/GameBoost.App/App.xaml.cs new file mode 100644 index 0000000..6fd37dc --- /dev/null +++ b/GameBoost/src/GameBoost.App/App.xaml.cs @@ -0,0 +1,85 @@ +using System.IO; +using System.Runtime.InteropServices; +using System.Text; +using System.Windows; +using GameBoost.App.ViewModels; +using GameBoost.App.Views; +using GameBoost.Cli; +using GameBoost.Core; +using GameBoost.Core.Logging; +using Microsoft.Extensions.DependencyInjection; + +namespace GameBoost.App; + +public partial class App : Application +{ + private IServiceProvider? _services; + + public static IServiceProvider Services => + ((App)Current)._services ?? throw new InvalidOperationException("Container ainda nao inicializado."); + + protected override void OnStartup(StartupEventArgs e) + { + base.OnStartup(e); + + var colecao = new ServiceCollection(); + colecao.AddGameBoostCore(); + colecao.AddSingleton(); + _services = colecao.BuildServiceProvider(); + + var log = _services.GetRequiredService(); + log.Info("App", "Startup", null, + $"v{typeof(App).Assembly.GetName().Version} admin={CoreServices.RodandoComoAdministrador()}"); + + // Um unico GameBoost.exe atende UI e linha de comando, como na v1. + var opcoes = CommandLineOptions.Parse(e.Args); + if (opcoes.EhCli) + { + var codigo = ExecutarCli(opcoes); + Shutdown(codigo); + return; + } + + var janela = new MainWindow { DataContext = _services.GetRequiredService() }; + MainWindow = janela; + janela.Show(); + } + + private int ExecutarCli(CommandLineOptions opcoes) + { + // App WPF nao tem console proprio: anexa ao console do chamador para que + // GameBoost.exe --scan continue imprimindo no terminal, como na v1. + var anexou = AttachConsole(AttachParentProcess); + + try + { + using var saida = anexou + ? new StreamWriter(Console.OpenStandardOutput(), new UTF8Encoding(false)) { AutoFlush = true } + : TextWriter.Null; + + var runner = new CommandRunner(_services!, saida); + return runner.ExecutarAsync(opcoes).GetAwaiter().GetResult(); + } + catch (Exception ex) + { + _services!.GetRequiredService() + .Error("Cli", opcoes.Comando.ToString(), null, "falha nao tratada", ex); + return 1; + } + finally + { + if (anexou) + FreeConsole(); + } + } + + private const int AttachParentProcess = -1; + + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool AttachConsole(int processId); + + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool FreeConsole(); +} diff --git a/GameBoost/src/GameBoost.App/Converters/Converters.cs b/GameBoost/src/GameBoost.App/Converters/Converters.cs new file mode 100644 index 0000000..12c343f --- /dev/null +++ b/GameBoost/src/GameBoost.App/Converters/Converters.cs @@ -0,0 +1,60 @@ +using System.Globalization; +using System.Windows; +using System.Windows.Data; +using System.Windows.Media; +using GameBoost.Core.Modules; + +namespace GameBoost.App.Converters; + +/// Badge de risco: verde, amarelo, vermelho (secao 6 do spec). +public sealed class RiscoParaCorConverter : IValueConverter +{ + public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) + { + var chave = (value as RiskLevel?) switch + { + RiskLevel.Alto => "RiscoAlto", + RiskLevel.Medio => "RiscoMedio", + _ => "RiscoBaixo" + }; + + return Application.Current?.TryFindResource(chave) as Brush ?? Brushes.Gray; + } + + public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) + => throw new NotSupportedException(); +} + +public sealed class BoolParaVisibilidadeConverter : IValueConverter +{ + public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) + { + var visivel = value is true; + if (parameter as string == "inverter") + visivel = !visivel; + + return visivel ? Visibility.Visible : Visibility.Collapsed; + } + + public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) + => throw new NotSupportedException(); +} + +public sealed class InverterBoolConverter : IValueConverter +{ + public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) + => value is not true; + + public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) + => value is not true; +} + +/// Mostra o elemento apenas quando o texto existe e nao esta vazio. +public sealed class TextoParaVisibilidadeConverter : IValueConverter +{ + public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) + => string.IsNullOrWhiteSpace(value as string) ? Visibility.Collapsed : Visibility.Visible; + + public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) + => throw new NotSupportedException(); +} diff --git a/GameBoost/src/GameBoost.App/GameBoost.App.csproj b/GameBoost/src/GameBoost.App/GameBoost.App.csproj new file mode 100644 index 0000000..e56c9a4 --- /dev/null +++ b/GameBoost/src/GameBoost.App/GameBoost.App.csproj @@ -0,0 +1,25 @@ + + + WinExe + net9.0-windows + true + GameBoost.App + GameBoost + app.manifest + + true + true + win-x64 + true + true + pt-BR + + + + + + + + + + diff --git a/GameBoost/src/GameBoost.App/Themes/Dark.xaml b/GameBoost/src/GameBoost.App/Themes/Dark.xaml new file mode 100644 index 0000000..13c9af2 --- /dev/null +++ b/GameBoost/src/GameBoost.App/Themes/Dark.xaml @@ -0,0 +1,80 @@ + + + + #FF14161A + #FF1C1F26 + #FF242830 + #FF00C2A8 + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs new file mode 100644 index 0000000..94fbb70 --- /dev/null +++ b/GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs @@ -0,0 +1,45 @@ +using CommunityToolkit.Mvvm.ComponentModel; +using GameBoost.Core.Modules; + +namespace GameBoost.App.ViewModels; + +/// +/// Envolve um ActionItem com o estado de selecao da UI. A tela de lista e +/// generica: todo modulo produz ActionItem e reusa esta mesma view. +/// +public sealed partial class ActionItemViewModel : ObservableObject +{ + public ActionItemViewModel(ActionItem item) + { + Item = item; + _selecionado = item.PreMarcado && !item.Bloqueado; + } + + public ActionItem Item { get; } + + [ObservableProperty] + private bool _selecionado; + + public string Id => Item.Id; + public string Titulo => Item.Titulo; + public string Descricao => Item.Descricao; + public string Categoria => Item.Categoria; + public RiskLevel Risco => Item.Risco; + public string GanhoEstimado => Item.GanhoEstimado; + public bool Bloqueado => Item.Bloqueado; + public bool PodeSelecionar => !Item.Bloqueado; + + public string TextoDeRisco => Item.Risco switch + { + RiskLevel.Alto => "Risco alto", + RiskLevel.Medio => "Risco medio", + _ => "Risco baixo" + }; + + /// Conteudo do botao "?": o que faz, qual o risco, como desfazer. + public string Explicacao => + $"O que faz: {Item.Descricao}\n\n" + + $"Risco: {TextoDeRisco}\n\n" + + $"Como desfazer: {Item.ComoDesfazer}" + + (Item.MotivoBloqueio is null ? string.Empty : $"\n\nProtegido: {Item.MotivoBloqueio}"); +} diff --git a/GameBoost/src/GameBoost.App/ViewModels/MainViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/MainViewModel.cs new file mode 100644 index 0000000..1064d93 --- /dev/null +++ b/GameBoost/src/GameBoost.App/ViewModels/MainViewModel.cs @@ -0,0 +1,240 @@ +using System.Collections.ObjectModel; +using System.Windows; +using CommunityToolkit.Mvvm.ComponentModel; +using CommunityToolkit.Mvvm.Input; +using GameBoost.Core; +using GameBoost.Core.Logging; +using GameBoost.Core.Modules; +using GameBoost.Core.Modules.GameMode; +using GameBoost.Core.State; + +namespace GameBoost.App.ViewModels; + +public sealed partial class MainViewModel : ObservableObject +{ + private readonly GameModeModule _gameMode; + private readonly IStateBackup _backup; + private readonly IRollbackEngine _rollback; + private readonly ISessionStore _sessions; + private readonly IGameBoostLogger _log; + + private CancellationTokenSource? _cts; + + public MainViewModel( + GameModeModule gameMode, + IStateBackup backup, + IRollbackEngine rollback, + ISessionStore sessions, + IGameBoostLogger log) + { + _gameMode = gameMode; + _backup = backup; + _rollback = rollback; + _sessions = sessions; + _log = log; + + EhAdministrador = CoreServices.RodandoComoAdministrador(); + + // Aviso na abertura se o app morreu com o Modo Game ativo (secao 1). + var sessao = _sessions.Load(); + if (sessao.Ativo) + { + ModoGameAtivo = true; + AvisoDeRestauracao = + "O GameBoost foi fechado com o Modo Game ainda ativo. " + + "Clique em Restaurar agora para devolver o sistema ao estado anterior."; + } + else if (_backup.TemPendencias) + { + AvisoDeRestauracao = + $"Existem {_backup.Pendentes.Count} alteracoes de sistema pendentes de reversao."; + } + + Status = EhAdministrador + ? "Pronto. Clique em Varrer para ver o que esta aberto." + : "Modo somente leitura: sem privilegios de administrador as varreduras funcionam, mas nada pode ser alterado."; + } + + public ObservableCollection Itens { get; } = new(); + + [ObservableProperty] private string _status = string.Empty; + [ObservableProperty] private string _resumo = string.Empty; + [ObservableProperty] private string? _avisoDeRestauracao; + [ObservableProperty] private string? _ganhoMedido; + [ObservableProperty] private bool _ocupado; + [ObservableProperty] private int _progresso; + [ObservableProperty] private bool _modoGameAtivo; + [ObservableProperty] private bool _ehAdministrador; + [ObservableProperty] private bool _dryRun; + + public bool PodeAgir => !Ocupado && EhAdministrador; + public int Selecionados => Itens.Count(i => i.Selecionado); + + // ------------------------------------------------------------------ + + [RelayCommand] + private async Task VarrerAsync() + { + if (Ocupado) + return; + + _cts = new CancellationTokenSource(); + Ocupado = true; + Progresso = 0; + Itens.Clear(); + GanhoMedido = null; + + var progresso = new Progress(p => + { + Status = p.Etapa; + Progresso = p.Percentual; + }); + + try + { + var resultado = await _gameMode.ScanAsync(progresso, _cts.Token); + + foreach (var item in resultado.Itens) + Itens.Add(new ActionItemViewModel(item)); + + Resumo = resultado.Resumo; + Status = resultado.Avisos.Count > 0 + ? string.Join(" ", resultado.Avisos) + : "Varredura concluida. Revise a lista antes de confirmar."; + } + catch (OperationCanceledException) + { + Status = "Varredura cancelada."; + } + finally + { + Ocupado = false; + Progresso = 100; + OnPropertyChanged(nameof(Selecionados)); + } + } + + [RelayCommand] + private async Task AtivarAsync() + { + if (Ocupado || !EhAdministrador) + return; + + var selecionados = Itens.Where(i => i.Selecionado && i.PodeSelecionar).Select(i => i.Id).ToList(); + + if (selecionados.Count == 0 && !DryRun) + { + var resposta = MessageBox.Show( + "Nenhum app foi marcado. O Modo Game vai apenas ajustar o sistema (energia, gravacao, Windows Update). Continuar?", + "GameBoost", MessageBoxButton.YesNo, MessageBoxImage.Question); + + if (resposta != MessageBoxResult.Yes) + return; + } + else if (!DryRun) + { + // Tela de confirmacao unica: nada e encerrado antes do usuario confirmar. + var nomes = string.Join("\n ", Itens.Where(i => i.Selecionado).Take(12).Select(i => i.Titulo)); + var extra = selecionados.Count > 12 ? $"\n ... e mais {selecionados.Count - 12}" : string.Empty; + + var resposta = MessageBox.Show( + $"O GameBoost vai encerrar {selecionados.Count} app(s):\n\n {nomes}{extra}\n\n" + + "Cada um recebe primeiro o pedido de fechamento normal, com 3 segundos para salvar.\n\n" + + "Continuar?", + "Confirmar Modo Game", MessageBoxButton.YesNo, MessageBoxImage.Warning); + + if (resposta != MessageBoxResult.Yes) + return; + } + + _cts = new CancellationTokenSource(); + Ocupado = true; + + try + { + var resultado = await _gameMode.ApplyAsync(selecionados, DryRun, _cts.Token); + + Resumo = resultado.Resumo; + GanhoMedido = resultado.GanhoMedido; + ModoGameAtivo = !DryRun; + AvisoDeRestauracao = null; + + Status = resultado.Falhas > 0 + ? $"{resultado.Sucessos} acoes concluidas, {resultado.Falhas} falharam. Veja o log." + : "Modo Game ativo."; + } + catch (OperationCanceledException) + { + Status = "Ativacao cancelada."; + } + finally + { + Ocupado = false; + } + } + + [RelayCommand] + private async Task DesligarAsync() + { + if (Ocupado || !EhAdministrador) + return; + + _cts = new CancellationTokenSource(); + Ocupado = true; + + try + { + var resultado = await _gameMode.RevertAsync(Array.Empty(), DryRun, _cts.Token); + + Resumo = resultado.Resumo; + GanhoMedido = resultado.GanhoMedido; + ModoGameAtivo = DryRun && ModoGameAtivo; + AvisoDeRestauracao = null; + Status = "Sistema devolvido ao estado anterior."; + } + finally + { + Ocupado = false; + } + } + + /// Botao Reverter tudo: sempre visivel, desfaz qualquer alteracao pendente. + [RelayCommand] + private void ReverterTudo() + { + if (!EhAdministrador) + return; + + if (!_backup.TemPendencias) + { + Status = "Nada a reverter: nenhuma alteracao pendente."; + return; + } + + var pendentes = _backup.Pendentes.Count; + var resposta = MessageBox.Show( + $"Desfazer {pendentes} alteracao(oes) de sistema feitas pelo GameBoost?", + "Reverter tudo", MessageBoxButton.YesNo, MessageBoxImage.Question); + + if (resposta != MessageBoxResult.Yes) + return; + + var resultados = _rollback.ReverterTudo(DryRun); + var falhas = resultados.Count(r => !r.Sucesso); + + ModoGameAtivo = false; + AvisoDeRestauracao = null; + Status = falhas == 0 + ? $"{resultados.Count} alteracoes revertidas." + : $"{resultados.Count - falhas} revertidas, {falhas} falharam. Veja o log."; + + _log.Info("App", "ReverterTudo", null, Status); + } + + [RelayCommand] + private void Cancelar() => _cts?.Cancel(); + + partial void OnOcupadoChanged(bool value) => OnPropertyChanged(nameof(PodeAgir)); + + partial void OnEhAdministradorChanged(bool value) => OnPropertyChanged(nameof(PodeAgir)); +} diff --git a/GameBoost/src/GameBoost.App/Views/MainWindow.xaml b/GameBoost/src/GameBoost.App/Views/MainWindow.xaml new file mode 100644 index 0000000..da1b32a --- /dev/null +++ b/GameBoost/src/GameBoost.App/Views/MainWindow.xaml @@ -0,0 +1,144 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + +