Deploy GeneralsOnline data patch to user data directory with backup tracking and hotswap guard

[undead2146]

Problem

Generals Online requires data patch BIG files (such as 500_900_CommunityPatch_CoreINI.big, or patch archives distributed for the client / launcher updates like patch3.zip) to reside in the user's Documents data directory:
%USERPROFILE%\Documents\Command and Conquer Generals Zero Hour Data\GeneralsOnlineGameData\

To support this:

1. User Data Deployment: GenHub must deploy and link files with ContentInstallTarget.UserDataDirectory preserving the GeneralsOnlineGameData/... subdirectory hierarchy.
2. Conflict & Backup Management: Overwriting existing user data files or updating/replacing executables (e.g. original GeneralsOnlineZH_60.exe or custom user data) requires automated backup to %APPDATA%\UserData\backups so uninstallation or profile switching restores previous states cleanly without data loss.
3. Hotswapping & Runtime Safety (Allow live content hotswapping on running game profiles for non-binary content types #370 Alignment): While Map content in User Data can be hot-swapped dynamically during an active game session, .big archives in GeneralsOnlineGameData are opened and locked by the engine on boot. Modifying or replacing data patches while the game process is running risks file lock collisions and engine crashes.

Proposed Approach

1. User Data Directory Materialisation

• Ensure UserDataTrackerService.ResolveUserDataTargetPath correctly maps files targeted to ContentInstallTarget.UserDataDirectory preserving relative subdirectories (such as GeneralsOnlineGameData\500_900_CommunityPatch_CoreINI.big).
• Support hard-linking from CAS (with fallback to copy) for .big files in user data.

2. Backup & Lifecycle Tracking

• Leverage UserDataTrackerService backup mechanism (BackupExistingFileAsync) before overwriting any existing files in Documents\Command and Conquer Generals Zero Hour Data\GeneralsOnlineGameData\.
• Ensure UninstallUserDataAsync and SwitchProfileUserDataAsync cleanly remove deployed patch files and restore original backed-up files.
• If launcher/patch deployment involves replacing client executables (e.g. GeneralsOnlineZH_60.exe), ensure original executables are backed up and restorable.

3. Runtime Guard & Hotswap Classification (#370 Compatibility)

• Clarify ContentHotswapClassification: ContentType.Patch (even when deployed to UserDataDirectory) is classified as Locked during active profile sessions (ILaunchRegistry.IsRunning == true).
• In GameProfileSettingsViewModel, disable toggling of Data Patch items when in Hotswap Mode.

Acceptance Criteria

• Data patch files targeting ContentInstallTarget.UserDataDirectory are materialized to %USERPROFILE%\Documents\Command and Conquer Generals Zero Hour Data\GeneralsOnlineGameData\.
• Pre-existing user data files in GeneralsOnlineGameData are safely backed up before overwrite and restored upon uninstallation.
• Profile switching cleanly deactivates/unlinks old profile data patches and activates new profile data patches.
• Data Patch (ContentType.Patch) remains locked and non-modifiable in the profile editor while the target game profile is running.
• Unit tests cover path resolution for UserDataDirectory, backup creation and restoration on uninstall, and hotswap locking behavior.

Related

• GeneralsOnlineManifestFactory: create distinct ContentManifest for GeneralsOnlineGameData data patch #371 — GeneralsOnlineManifestFactory: create distinct ContentManifest for GeneralsOnlineGameData data patch
• Allow live content hotswapping on running game profiles for non-binary content types #370 — Allow live content hotswapping on running game profiles for non-binary content types
• GeneralsOnline Easy Anti-Cheat update breaks launch: wrong executable, missing EAC install step #336 — GeneralsOnline Easy Anti-Cheat update breaks launch

[coderabbitai]

Coding Plan

Summary

• Extend the existing authoritative UserDataTrackerService pipeline to deploy, back up, restore, and set permissions for GeneralsOnlineGameData BIG files and client executables. The nested-path and CAS hard-link behavior already exists and is verified.
• Add a minimal workspace filter so only Workspace-target files reach the workspace strategies. This removes the duplicate write and the SymlinkOnly race for user data files.
• Introduce a new ContentHotswapClassification, an ILaunchRegistry.IsProfileRunningAsync query, and an IsLocked state to lock ContentType.Patch items in GameProfileSettingsViewModel while the profile runs.
• Add the first unit tests for the user data services and the hotswap guard.

Design Choices

Design Choice 1: Scope of workspace filtering for UserData-target files

Options Considered:

1. Leave workspace filtering unchanged. UserDataTrackerService stays authoritative. Workspace duplicates are harmless for non-SymlinkOnly strategies.
2. Add a filter in WorkspaceManager/GetAllUniqueFiles to exclude files with InstallTarget != Workspace before workspace strategies run.

Chosen Option: 2

Rationale: The filter removes the duplicate write and the SymlinkOnly race. It directly supports safe GeneralsOnlineGameData deployment. It is in scope as a minimal correctness fix.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Deploy and back up GeneralsOnlineGameData user data files

This phase makes UserDataTrackerService deploy GeneralsOnlineGameData/... files correctly. It backs up pre-existing files and executables before overwrite. It restores these files on uninstall and profile switch. It also stops the workspace strategies from double-processing these files.

Task 1: Add folder and filename constants

Introduce named constants for the deployment folder and patch files.

• Add a GeneralsOnlineGameData constant (value "GeneralsOnlineGameData", PascalCase "GameData") to GenHub/GenHub.Core/Constants/GeneralsOnlineConstants.cs.
• Add filename constants for the community patch BIG file (500_900_CommunityPatch_CoreINI.big) and any patch archive names (patch3.zip) referenced by the deployment logic.
• Replace the existing raw literal "GeneralsOnlineGameData" in GenHub/GenHub/Features/Manifest/ManifestGenerationService.cs with the new constant.
• Keep this folder distinct from GameSettingsConstants.FolderNames.GeneralsOnlineData ("GeneralsOnlineData"), which is unrelated.

Task 2: Confirm nested path resolution and CAS hard-link fallback for user data files

Verify that UserDataDirectory files preserve their nested RelativePath and use hard-link-with-copy fallback.

• Confirm ResolveUserDataTargetPath in GenHub/GenHub/Features/UserData/Services/UserDataTrackerService.cs maps ContentInstallTarget.UserDataDirectory to Path.Combine(userDataBasePath, relativePath). This already preserves GeneralsOnlineGameData/500_900_CommunityPatch_CoreINI.big.
• Confirm InstallUserDataAsync and ActivateProfileUserDataAsync already use the LinkFromCasAsync(..., useHardLink: true) then CopyFromCasAsync fallback pattern for these files.
• No code change is expected here unless the verification shows a gap. The value of this task is to confirm the acceptance criteria for .big deployment.

Task 3: Propagate executable permissions through install, activate, and restore

Handle client executables (for example GeneralsOnlineZH_60.exe) so their permission bits are applied after deployment and after backup restore.

• Update InstallUserDataAsync and ActivateProfileUserDataAsync in UserDataTrackerService.cs to read ManifestFile.IsExecutable and ManifestFile.Permissions and apply the executable bit after the file is linked or copied.
• Follow the existing executable-detection approach used in WorkspaceStrategyBase for consistency.
• In the backup restore path inside UninstallUserDataAsync, reapply the executable permission after File.Move restores a backed-up executable.

Task 4: Confirm backup, uninstall, and profile-switch restore for nested user data files

Ensure backup and restore work for GeneralsOnlineGameData files and executables.

• Confirm BackupExistingFileAsync computes relativeDirPath relative to GetUserDataBasePath(gameType). Because GeneralsOnlineGameData files live under that base, the backup path layout is correct.
• Confirm UninstallUserDataAsync restores BackupPath files and removes deployed patch files.
• Confirm SwitchProfileUserDataAsync deactivates old-profile files and activates new-profile files.
• No code change is expected here beyond Task 1.3 unless verification shows a gap.

Task 5: Exclude non-Workspace files from workspace strategies

Prevent workspace strategies from also writing UserData*-target files.

• Update GenHub/GenHub/Features/Workspace/WorkspaceManager.cs (or the shared GetAllUniqueFiles in WorkspaceConfigurationExtensions) to filter out files whose InstallTarget is not Workspace before passing manifests to IWorkspaceStrategy.PrepareAsync.
• This removes the duplicate write and the SymlinkOnly race. UserDataTrackerService remains the single authoritative deployer for GeneralsOnlineGameData files.

🤖 Prompt for AI agents

Implement Phase 1: deploy and back up GeneralsOnlineGameData user data files,
and stop the workspace strategies from double-processing these files.

1. Add constants: In `GenHub/GenHub.Core/Constants/GeneralsOnlineConstants.cs`,
add a `GeneralsOnlineGameData` constant with value `"GeneralsOnlineGameData"`
(PascalCase "GameData"). Add filename constants for
`500_900_CommunityPatch_CoreINI.big` and any patch archive names (`patch3.zip`)
used by the deployment logic. Replace the raw string literal
`"GeneralsOnlineGameData"` in
`GenHub/GenHub/Features/Manifest/ManifestGenerationService.cs` with this new
constant. Keep this constant distinct from
`GameSettingsConstants.FolderNames.GeneralsOnlineData`, which refers to an
unrelated folder.

2. Verify nested path resolution and CAS behavior (no code change expected
unless a gap is found): In
`GenHub/GenHub/Features/UserData/Services/UserDataTrackerService.cs`, confirm
`ResolveUserDataTargetPath` maps `ContentInstallTarget.UserDataDirectory` to
`Path.Combine(userDataBasePath, relativePath)`, preserving the nested
`GeneralsOnlineGameData/500_900_CommunityPatch_CoreINI.big` path. Confirm
`InstallUserDataAsync` and `ActivateProfileUserDataAsync` use the
`LinkFromCasAsync(..., useHardLink: true)` then `CopyFromCasAsync` fallback
pattern.

3. Propagate executable permissions: In `InstallUserDataAsync` and
`ActivateProfileUserDataAsync`, read `ManifestFile.IsExecutable` and
`ManifestFile.Permissions`, and apply the executable bit after the file is
linked or copied. Use the same executable-detection approach as
`WorkspaceStrategyBase` for consistency. In `UninstallUserDataAsync`, reapply
the executable permission after `File.Move` restores a backed-up executable.

4. Verify backup and restore behavior (no code change expected beyond step 3
unless a gap is found): Confirm `BackupExistingFileAsync` computes
`relativeDirPath` relative to `GetUserDataBasePath(gameType)`. Confirm
`UninstallUserDataAsync` restores `BackupPath` files and removes deployed patch
files. Confirm `SwitchProfileUserDataAsync` deactivates old-profile files and
activates new-profile files.

5. Filter workspace strategy input: In
`GenHub/GenHub/Features/Workspace/WorkspaceManager.cs` (or the shared
`GetAllUniqueFiles` in `WorkspaceConfigurationExtensions`), filter out manifest
files whose `InstallTarget` is not `Workspace` before calling
`IWorkspaceStrategy.PrepareAsync`. This makes `UserDataTrackerService` the
single authoritative deployer for `GeneralsOnlineGameData` files and removes the
`SymlinkOnly` race condition.

Phase 2: Hotswap classification and runtime guard (#370 alignment)

This phase introduces a hotswap classification, adds a per-profile running-state query, and locks ContentType.Patch items in the profile editor while the target profile runs.

Task 1: Add ContentHotswapClassification

Define which content types are safe to change during an active session.

• Create a ContentHotswapClassification type in GenHub/GenHub.Core/Models/Enums/ (or a small static helper in Core) keyed on ContentType.
• Classify ContentType.Patch, GameInstallation, and GameClient as Locked while a profile runs.
• Classify cosmetic and additive types (Mod, MapPack, Addon, Map, Skin, and similar) as Hotswappable.
• Expose a simple query such as IsLockedWhileRunning(ContentType).

Task 2: Add per-profile running-state query to ILaunchRegistry

Provide a cheap way to check whether a profile is running.

• Add Task<bool> IsProfileRunningAsync(string profileId) to GenHub/GenHub.Core/Interfaces/Launching/ILaunchRegistry.cs.
• Implement it in GenHub/GenHub/Features/Launching/LaunchRegistry.cs using the existing GetAllActiveLaunchesAsync().FirstOrDefault(l => l.ProfileId == profileId) pattern.

Task 3: Add lock state to the profile editor content item

Give the editor a way to mark items as non-toggleable.

• Add an IsLocked (or IsToggleable) observable property to the ViewModel ContentDisplayItem in GenHub/GenHub/Features/GameProfiles/ViewModels/ContentDisplayItem.cs.
• Bind the toggle control enabled-state to this property in the settings view so locked items cannot be toggled.

Task 4: Wire the hotswap guard into GameProfileSettingsViewModel

Lock Patch items when the target profile runs.

• Add ILaunchRegistry as a new nullable constructor parameter on GenHub/GenHub/Features/GameProfiles/ViewModels/GameProfileSettingsViewModel.cs and store it as a field.
• When the editor loads content for a profile, call IsProfileRunningAsync(profileId).
• If the profile runs, set IsLocked on each ContentDisplayItem whose ContentType is classified as Locked by ContentHotswapClassification.
• Update EnableContent to ignore toggle requests for locked items.

🤖 Prompt for AI agents

Implement Phase 2: add a hotswap classification for content types, a per-profile
running-state query, and a runtime guard that locks `ContentType.Patch` items in
the profile editor while the target profile runs.

1. Add `ContentHotswapClassification`: create this type in
`GenHub/GenHub.Core/Models/Enums/` (or a small static helper in Core), keyed on
`ContentType`. Classify `ContentType.Patch`, `GameInstallation`, and
`GameClient` as `Locked` while a profile runs. Classify cosmetic and additive
types (`Mod`, `MapPack`, `Addon`, `Map`, `Skin`, and similar) as `Hotswappable`.
Expose a query method such as `IsLockedWhileRunning(ContentType)`.

2. Add a running-state query to `ILaunchRegistry`: add `Task<bool>
IsProfileRunningAsync(string profileId)` to
`GenHub/GenHub.Core/Interfaces/Launching/ILaunchRegistry.cs`. Implement it in
`GenHub/GenHub/Features/Launching/LaunchRegistry.cs` using the existing
`GetAllActiveLaunchesAsync().FirstOrDefault(l => l.ProfileId == profileId)`
pattern.

3. Add lock state to the content item: add an `IsLocked` (or `IsToggleable`)
observable property to `ContentDisplayItem` in
`GenHub/GenHub/Features/GameProfiles/ViewModels/ContentDisplayItem.cs`. Bind the
toggle control's enabled-state to this property in the settings view so locked
items cannot be toggled.

4. Wire the guard into the view model: add `ILaunchRegistry` as a new nullable
constructor parameter on `GameProfileSettingsViewModel` and store it as a field.
When the editor loads content for a profile, call
`IsProfileRunningAsync(profileId)`. If the profile runs, set `IsLocked` on each
`ContentDisplayItem` whose `ContentType` is classified as `Locked` by
`ContentHotswapClassification`. Update `EnableContent` to ignore toggle requests
for locked items.

Phase 3: Unit tests

This phase adds the tests required by the acceptance criteria for the user data services and the hotswap guard.

Task 1: Add UserDataTrackerService tests

Cover path resolution and backup/restore.

• Create a new test folder GenHub/GenHub.Tests/GenHub.Tests.Core/Features/UserData/.
• Follow the file-operations test convention: mock IConfigurationProviderService.GetApplicationDataPath() and use a temp directory with IDisposable cleanup for real file I/O.
• Test that a UserDataDirectory file with RelativePath GeneralsOnlineGameData/500_900_CommunityPatch_CoreINI.big resolves under the ZeroHour Documents base path with the nested folder preserved.
• Test that BackupExistingFileAsync backs up a pre-existing file and that UninstallUserDataAsync restores it.
• Test that executable permission handling from Task 1.3 runs on install and restore.

Task 2: Add hotswap locking tests

Cover the editor guard.

• Extend GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/ViewModels/GameProfileSettingsViewModelTests.cs.
• Mock ILaunchRegistry and stub IsProfileRunningAsync to return true and false.
• Assert that ContentType.Patch items are IsLocked when the profile runs and are toggleable when it does not.
• Update existing test constructors to pass the new ILaunchRegistry parameter.

🤖 Prompt for AI agents

Implement Phase 3: add unit tests for the user data services and the hotswap
guard, as required by the acceptance criteria.

1. Add `UserDataTrackerService` tests: create a new test folder
`GenHub/GenHub.Tests/GenHub.Tests.Core/Features/UserData/`. Follow the existing
file-operations test convention: mock
`IConfigurationProviderService.GetApplicationDataPath()` and use a temp
directory with `IDisposable` cleanup for real file I/O. Write a test that a
`UserDataDirectory` file with `RelativePath`
`GeneralsOnlineGameData/500_900_CommunityPatch_CoreINI.big` resolves under the
ZeroHour Documents base path with the nested folder preserved. Write a test that
`BackupExistingFileAsync` backs up a pre-existing file and that
`UninstallUserDataAsync` restores it. Write a test that the executable
permission handling added in Phase 1 runs on install and on restore.

2. Add hotswap locking tests: extend
`GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/ViewModels/GameProfileSettingsViewModelTests.cs`.
Mock `ILaunchRegistry` and stub `IsProfileRunningAsync` to return `true` in one
test case and `false` in another. Assert that `ContentType.Patch` items are
`IsLocked` when the profile runs and are toggleable when it does not run. Update
existing test constructors to pass the new `ILaunchRegistry` parameter.

Research

GenHub materializes profile content through two separate pipelines.

• WorkspaceManager and its strategies build the ephemeral game workspace.
• UserDataTrackerService (wrapped by ProfileContentLinkerService) deploys files whose ContentInstallTarget is a UserData* value into the real Documents data folders. This service handles CAS hard-linking, backup, conflict detection, and per-profile activation.
• GameLauncher.LaunchProfileAsync calls ProfileContentLinker.SwitchProfileUserDataAsync at launch time.
• GameProfileSettingsViewModel handles content toggling in the profile editor.
• ContentType already includes a Patch value.

The codebase does not have a hotswap concept, does not have an ILaunchRegistry.IsRunning API, and does not have unit tests for the user data services.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement Phase 1: deploy and back up GeneralsOnlineGameData user data files,
and stop the workspace strategies from double-processing these files.

1. Add constants: In `GenHub/GenHub.Core/Constants/GeneralsOnlineConstants.cs`,
add a `GeneralsOnlineGameData` constant with value `"GeneralsOnlineGameData"`
(PascalCase "GameData"). Add filename constants for
`500_900_CommunityPatch_CoreINI.big` and any patch archive names (`patch3.zip`)
used by the deployment logic. Replace the raw string literal
`"GeneralsOnlineGameData"` in
`GenHub/GenHub/Features/Manifest/ManifestGenerationService.cs` with this new
constant. Keep this constant distinct from
`GameSettingsConstants.FolderNames.GeneralsOnlineData`, which refers to an
unrelated folder.

2. Verify nested path resolution and CAS behavior (no code change expected
unless a gap is found): In
`GenHub/GenHub/Features/UserData/Services/UserDataTrackerService.cs`, confirm
`ResolveUserDataTargetPath` maps `ContentInstallTarget.UserDataDirectory` to
`Path.Combine(userDataBasePath, relativePath)`, preserving the nested
`GeneralsOnlineGameData/500_900_CommunityPatch_CoreINI.big` path. Confirm
`InstallUserDataAsync` and `ActivateProfileUserDataAsync` use the
`LinkFromCasAsync(..., useHardLink: true)` then `CopyFromCasAsync` fallback
pattern.

3. Propagate executable permissions: In `InstallUserDataAsync` and
`ActivateProfileUserDataAsync`, read `ManifestFile.IsExecutable` and
`ManifestFile.Permissions`, and apply the executable bit after the file is
linked or copied. Use the same executable-detection approach as
`WorkspaceStrategyBase` for consistency. In `UninstallUserDataAsync`, reapply
the executable permission after `File.Move` restores a backed-up executable.

4. Verify backup and restore behavior (no code change expected beyond step 3
unless a gap is found): Confirm `BackupExistingFileAsync` computes
`relativeDirPath` relative to `GetUserDataBasePath(gameType)`. Confirm
`UninstallUserDataAsync` restores `BackupPath` files and removes deployed patch
files. Confirm `SwitchProfileUserDataAsync` deactivates old-profile files and
activates new-profile files.

5. Filter workspace strategy input: In
`GenHub/GenHub/Features/Workspace/WorkspaceManager.cs` (or the shared
`GetAllUniqueFiles` in `WorkspaceConfigurationExtensions`), filter out manifest
files whose `InstallTarget` is not `Workspace` before calling
`IWorkspaceStrategy.PrepareAsync`. This makes `UserDataTrackerService` the
single authoritative deployer for `GeneralsOnlineGameData` files and removes the
`SymlinkOnly` race condition.
===============================================================================

Task: 2

Implement Phase 2: add a hotswap classification for content types, a per-profile
running-state query, and a runtime guard that locks `ContentType.Patch` items in
the profile editor while the target profile runs.

1. Add `ContentHotswapClassification`: create this type in
`GenHub/GenHub.Core/Models/Enums/` (or a small static helper in Core), keyed on
`ContentType`. Classify `ContentType.Patch`, `GameInstallation`, and
`GameClient` as `Locked` while a profile runs. Classify cosmetic and additive
types (`Mod`, `MapPack`, `Addon`, `Map`, `Skin`, and similar) as `Hotswappable`.
Expose a query method such as `IsLockedWhileRunning(ContentType)`.

2. Add a running-state query to `ILaunchRegistry`: add `Task<bool>
IsProfileRunningAsync(string profileId)` to
`GenHub/GenHub.Core/Interfaces/Launching/ILaunchRegistry.cs`. Implement it in
`GenHub/GenHub/Features/Launching/LaunchRegistry.cs` using the existing
`GetAllActiveLaunchesAsync().FirstOrDefault(l => l.ProfileId == profileId)`
pattern.

3. Add lock state to the content item: add an `IsLocked` (or `IsToggleable`)
observable property to `ContentDisplayItem` in
`GenHub/GenHub/Features/GameProfiles/ViewModels/ContentDisplayItem.cs`. Bind the
toggle control's enabled-state to this property in the settings view so locked
items cannot be toggled.

4. Wire the guard into the view model: add `ILaunchRegistry` as a new nullable
constructor parameter on `GameProfileSettingsViewModel` and store it as a field.
When the editor loads content for a profile, call
`IsProfileRunningAsync(profileId)`. If the profile runs, set `IsLocked` on each
`ContentDisplayItem` whose `ContentType` is classified as `Locked` by
`ContentHotswapClassification`. Update `EnableContent` to ignore toggle requests
for locked items.
===============================================================================

Task: 3

Implement Phase 3: add unit tests for the user data services and the hotswap
guard, as required by the acceptance criteria.

1. Add `UserDataTrackerService` tests: create a new test folder
`GenHub/GenHub.Tests/GenHub.Tests.Core/Features/UserData/`. Follow the existing
file-operations test convention: mock
`IConfigurationProviderService.GetApplicationDataPath()` and use a temp
directory with `IDisposable` cleanup for real file I/O. Write a test that a
`UserDataDirectory` file with `RelativePath`
`GeneralsOnlineGameData/500_900_CommunityPatch_CoreINI.big` resolves under the
ZeroHour Documents base path with the nested folder preserved. Write a test that
`BackupExistingFileAsync` backs up a pre-existing file and that
`UninstallUserDataAsync` restores it. Write a test that the executable
permission handling added in Phase 1 runs on install and on restore.

2. Add hotswap locking tests: extend
`GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/ViewModels/GameProfileSettingsViewModelTests.cs`.
Mock `ILaunchRegistry` and stub `IsProfileRunningAsync` to return `true` in one
test case and `false` in another. Assert that `ContentType.Patch` items are
`IsLocked` when the profile runs and are toggleable when it does not run. Update
existing test constructors to pass the new `ILaunchRegistry` parameter.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

🔗 Related PRs

#332 - feat(launching): launch the native BGFX client against retail archives [merged]
#343 - fix(generalsonline): launch and track through the Easy Anti-Cheat bootstrapper [merged]
#349 - fix(cas): fall back from unwritable installation pools [merged]
#352 - feat(installations): detect retail installations by archive presence [open]
#366 - fix(generalsonline): forward-port Easy Anti-Cheat launch support from alpha 4 [open]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[undead2146]

Closed by #374