GameProfile Sharing via genhub:// Protocol & Rich Import Inspection UI

[undead2146]

[Feature] GameProfile Sharing via genhub:// Protocol & Rich Import Inspection UI

1. Problem Statement & Context

GenHub provides modular workspace isolation and Content-Addressable Storage (CAS) deduplication for Command & Conquer Generals and Zero Hour game configurations. With full system disaster recovery tracked in #387 (.ghbak archives containing full offline CAS blobs), there is an equally critical, complementary requirement: lightweight, one-click GameProfile sharing between players.

Currently:

• Players who create customized mod, patch, map, or tool configurations (e.g. ShockWave 1.2 + SuperHackers 60Hz Patch + GenPatcher Addons) have no streamlined way to share that exact setup with friends, tournament organizers, or community members.
• Past issue Feature: GameProfile Import & Automatic Content Acquisition #93 outlined generic JSON clipboard/file import concepts, but did not define the genhub:// protocol specification, OS deep-link registration, or a detailed inspection/preview workflow.
• The Blind Import Risk: Importing a profile without inspecting it creates major usability and security risks. Recipients must have full visibility into the exact game client version, included mods/patches, missing CAS objects requiring download, required disk space, and any altered game settings (resolution, camera, arguments) before confirming.

---

Architectural Clarification: Disaster Recovery Backup vs. GameProfile Sharing

Dimension	Full System Backup (#387 .ghbak)	GameProfile Sharing (genhub:// / .ghprofile)
Primary Goal	Complete offline disaster recovery / machine migration.	Frictionless modpack & setup distribution between players.
Binary Assets	Includes physical CAS blobs inside the archive.	Excludes binary blobs; includes manifest IDs, hashes, and acquisition URLs.
Payload Size	Multi-Gigabyte container (ZIP/ZSTD).	Lightweight string/file (Kilobytes to low Megabytes).
Resolution	100% Offline / Air-gapped restore.	On-demand dynamic download via ContentDeliveryService.
Transport	File explorer / USB / Cloud backup.	genhub:// deep links (Discord/browser/chat), text snippet, or .ghprofile.

---

2. User Stories & Use Cases

• UC-1 (One-Click Profile Export & Link Generation): As a player or streamer, I want to click "Share Profile" on any GameProfile card to generate a compact genhub://profile/import?... link, copy a formatted Discord/forum invite snippet, or save a .ghprofile file.
• UC-2 (Deep-Link Protocol Activation): As a recipient clicking a genhub://profile/import?... link in Discord, Reddit, or a web browser, I want GenHub to automatically focus/open and launch the "Import Shared Profile" inspection modal.
• UC-3 (Detailed Pre-Import Inspection & Diff): As a recipient, before any content is acquired or applied to my system, I want to see a rich breakdown showing:
  • Base Game Client & Engine Version (e.g. C&C Generals: Zero Hour v1.04).
  • Target Game Installation compatibility (e.g. Steam / EA App / Retail).
  • Itemized Content Manifests (Mods, Patches, Add-ons, Maps) with publisher, version, and status tags (✅ Already Cached vs ⬇️ Download Required).
  • Total download size and disk footprint.
  • Game configuration & launch argument overrides.
  • Duplicate profile name detection with inline rename capability.
• UC-4 (Automated Content Acquisition & Activation): As a recipient clicking "Accept & Acquire", I want GenHub to fetch missing manifests and CAS objects via the ContentDeliveryService, construct the workspace, create the profile, and highlight it on the launcher dashboard.
• UC-5 (Safety & Guardrails): As a user receiving a link from an unknown community member, I want GenHub to validate manifest hashes, sanitize launch arguments, and reject arbitrary executable paths.

---

3. Protocol Specification & Architecture

A. URI Scheme Format (genhub://)

# Format 1: Inline compressed payload (for lightweight profiles with public manifests)
genhub://profile/import?data=<Base64Url(BrotliCompressed(JSON))>

# Format 2: Remote reference payload (for extensive bundles or hosted manifests)
genhub://profile/import?url=<https://manifests.community-outpost.com/profiles/shockwave-cup-2026.json>

# Format 3: Hub Catalog reference (pre-indexed catalog profile)
genhub://profile/view?id=<catalog-profile-id>&publisher=<publisher-slug>

B. Data Model: SharedGameProfilePackage

{
  "$schemaVersion": 1,
  "generatorVersion": "0.0.1282",
  "exportedAt": "2026-08-19T14:30:00Z",
  "profile": {
    "name": "ShockWave Chaos Tourney Edition",
    "description": "Standardized competitive ShockWave build with 60Hz and camera patches.",
    "themeColor": "#00CCFF",
    "gameType": "ZeroHour",
    "gameVersion": "1.04",
    "useSteamLaunch": false,
    "commandLineArguments": "-win -quickstart",
    "gameSettingsOverrides": {
      "videoResolutionWidth": 1920,
      "videoResolutionHeight": 1080,
      "videoWindowed": true,
      "tshRenderFpsFontSize": 12,
      "goShowFps": true
    }
  },
  "requiredManifests": [
    {
      "manifestId": "zero-hour-1.04-patch",
      "name": "Zero Hour Community Patch 1.04",
      "contentType": "Patch",
      "version": "1.04.1",
      "publisher": "TheSuperHackers",
      "manifestUrl": "https://cdn.community-outpost.com/manifests/zh-104-patch.json",
      "totalBytes": 18454912
    },
    {
      "manifestId": "shockwave-mod-v1.2",
      "name": "ShockWave Mod",
      "contentType": "Mod",
      "version": "1.20",
      "publisher": "SWR Productions",
      "manifestUrl": "https://cdn.community-outpost.com/manifests/shockwave-120.json",
      "totalBytes": 782194810
    }
  ]
}

C. Cross-Platform Protocol Registration & IPC Forwarding

1. Windows: Registry key HKCU\Software\Classes\genhub\shell\open\command -> GenHub.Windows.exe "%1".
2. macOS: CFBundleURLTypes -> URL Scheme genhub in Info.plist.
3. Linux: .desktop file containing MimeType=x-scheme-handler/genhub;.
4. IPC Forwarding: Program.cs parses incoming genhub://profile/... arguments via CommandLineParser.ExtractProfileShareUri(args) and forwards import-profile:<uri> through SingleInstanceManager named pipe to the active instance.

---

4. Proposed Interfaces & Data Models

namespace GenHub.Core.Interfaces.GameProfiles;

public interface IProfileSharingService
{
    /// <summary>Generates a compact genhub:// sharing URI for a given profile.</summary>
    Task<OperationResult<string>> ExportProfileToUriAsync(string profileId, CancellationToken cancellationToken = default);

    /// <summary>Exports a self-contained .ghprofile JSON container file.</summary>
    Task<OperationResult<string>> ExportProfileToFileAsync(string profileId, string destinationPath, CancellationToken cancellationToken = default);

    /// <summary>Parses and inspects a share URI or package, performing local CAS/manifest diffing without modifying state.</summary>
    Task<OperationResult<SharedProfileInspectionResult>> InspectSharedProfileAsync(string shareUriOrJson, CancellationToken cancellationToken = default);

    /// <summary>Acquires missing dependencies and installs the shared profile.</summary>
    Task<OperationResult<GameProfile>> ImportSharedProfileAsync(
        SharedProfileImportRequest request,
        IProgress<ContentAcquisitionProgress>? progress = null,
        CancellationToken cancellationToken = default);
}

public sealed class SharedProfileInspectionResult
{
    public required GameProfile ProfileMetadata { get; init; }
    public required IReadOnlyList<SharedManifestDependency> Manifests { get; init; }
    public required bool HasValidGameInstallation { get; init; }
    public required string? MatchedGameInstallationId { get; init; }
    public required long TotalDownloadBytesRequired { get; init; }
    public required int CachedManifestCount { get; init; }
    public required int MissingManifestCount { get; init; }
    public required bool HasNameConflict { get; init; }
    public required string SuggestedProfileName { get; init; }
    public required IReadOnlyList<string> SecurityWarnings { get; init; }
}

public sealed class SharedManifestDependency
{
    public required string ManifestId { get; init; }
    public required string DisplayName { get; init; }
    public required string Version { get; init; }
    public required ContentType ContentType { get; init; }
    public required string? Publisher { get; init; }
    public required bool IsCachedLocally { get; init; }
    public required long DownloadSize { get; init; }
}

---

5. UI/UX Specification & Wireframes (Conforming to GenHub Dark Theme)

A. Profile Card & Context Menu Share Action

• Add a Share button (Classes="tool-button", share icon) to GameProfileCardView.axaml alongside Steam toggle, Edit, Copy, Shortcut, and Delete.
• Add "Share Profile..." to Border.ContextMenu in GameProfileCardView.axaml.

B. Share Profile Dialog (ShareProfileDialogWindow.axaml)

+-------------------------------------------------------------------------+
|  SHARE GAME PROFILE: ShockWave Chaos                             [ X ]  |
+-------------------------------------------------------------------------+
| Share Link (Protocol URI):                                              |
| +---------------------------------------------------------+  [ COPY ]   |
| | genhub://profile/import?data=eJy1V11v2zYQ...             |            |
| +---------------------------------------------------------+             |
|                                                                         |
| [  Copy Discord Markdown Message  ]      [  Export .ghprofile File  ]   |
+-------------------------------------------------------------------------+

C. Rich Import & Inspection Modal (ImportProfileInspectionWindow.axaml)

Designed to strictly follow GenHub's Avalonia design language (#1F1F1F background, frosted glass cards, colored accent borders, and badge tags):

+------------------------------------------------------------------------------------+
|  IMPORT SHARED PROFILE                                                       [ X ]  |
+------------------------------------------------------------------------------------+
|  +-------------------+  ShockWave Chaos Tourney Edition                             |
|  |   [COVER IMAGE]   |  Target Client: Command & Conquer: Zero Hour (v1.04)        |
|  |     300x180       |  Publisher / Author: SWR Productions                        |
|  +-------------------+  Profile Name: [ ShockWave Chaos Tourney Edition        ]   |
+------------------------------------------------------------------------------------+
|  CONTENT & MOD MANIFESTS BREAKDOWN (2 items)                                       |
|  +------------------------------------------------------------------------------+  |
|  | [Patch] Zero Hour Patch 1.04    v1.04.1    TheSuperHackers    [ ✅ CACHED ]   |  |
|  | [Mod]   ShockWave Mod           v1.20      SWR Productions    [ ⬇️ 745 MB ]   |  |
|  +------------------------------------------------------------------------------+  |
+------------------------------------------------------------------------------------+
|  GAME SETTINGS & LAUNCH OPTIONS OVERRIDES                                           |
|  • Display: 1920x1080 (Windowed)    • Fast-Start: Enabled (-quickstart)             |
|  • GeneralsOnline / TSH Settings: 60 FPS Lock, Latency Overlay, In-Game Rank Badges|
+------------------------------------------------------------------------------------+
|  Target Installation: [ Steam (C:\Games\Steam\steamapps\common\Command & Conquer) ▼]|
|  Acquisition Requirements: 1 download required (745 MB total download)            |
+------------------------------------------------------------------------------------+
|                                      [ Cancel ]   [  ⬇️ Import & Download (745 MB)  ] |
+------------------------------------------------------------------------------------+

D. Content Acquisition & Download Overlay

• Displays real-time progress (Acquiring ShockWave Mod... 45% (335 MB / 745 MB)) reusing DownloadItemProgressView and IContentDeliveryService pipeline.
• Automatically selects and highlights the profile upon completion with a toast notification.

---

6. Security & Validation Guardrails

1. Executable Path Isolation: Shared profiles cannot define arbitrary executable paths (ExecutablePath / CustomExecutablePath / WorkingDirectory). GenHub will bind executables strictly through local IGameInstallation resolution or verified tool manifests.
2. Launch Argument Sanitization: Disallow command injection characters (|, &, ;, > , <) in CommandLineArguments.
3. Payload Size Guard: Inline genhub:// data payloads capped at 64 KB to prevent buffer overflows or browser URI truncation. Payloads exceeding limit prompt export to .ghprofile file or remote URL.
4. Manifest Integrity: Every referenced manifest is validated against its cryptographic SHA-256 hash in the CAS pool before workspace creation.

---

7. Implementation Plan & Acceptance Criteria

• Protocol & IPC:
  • Add genhub://profile/import and genhub://profile/view routing to CommandLineConstants and CommandLineParser.
  • Add IpcCommands.ImportProfilePrefix handling to Windows, macOS, and Linux startup / SingleInstance listeners.
• Core Services & Serialization:
  • Implement IProfileSharingService with Brotli/Base64Url compression and .ghprofile file packaging.
  • Implement InspectSharedProfileAsync calculating CAS diffs, missing manifest lists, download sizes, and installation validation.
  • Implement ImportSharedProfileAsync orchestrating manifest acquisition, CAS asset download, and profile creation.
• UI & UX:
  • Add Share button and context menu item to GameProfileCardView.axaml.
  • Implement ShareProfileDialogWindow.axaml (URI copy, Discord markdown copy, file export).
  • Implement ImportProfileInspectionWindow.axaml conforming to GenHub UI styling (dark theme, glass cards, badges, diff table, settings summary).
  • Integrate download progress display during multi-manifest acquisition.
• Security & Validation:
  • Sanitize command line arguments and forbid arbitrary absolute binary paths in imported profiles.
  • Handle missing remote resolvers, 404s, and corrupted payloads with clear user-facing error dialogs.
• Testing:
  • Add unit tests for payload serialization, Brotli compression/decompression, and URL decoding in GenHub.Tests.Core.
  • Add integration tests for IProfileSharingService verifying CAS cache hits vs missing download estimations.

[coderabbitai]

Coding Plan

Summary

• Add portable sharing contracts and a ProfileSharingService that exports Brotli/Base64Url genhub:// URIs and .ghprofile files, inspects packages by diffing referenced manifests against IContentManifestPool and CAS, and imports through the existing content-acquisition and profile-creation services.
• Extend the existing Windows mutex plus named-pipe IPC and add a Linux single-instance substrate to forward genhub:// deep links to a running instance, with OS scheme registration on each platform.
• Add a Share dialog and a rich Import inspection modal that reuse existing clipboard, file-picker, notification, and download-progress patterns, and highlight the imported profile on the dashboard.
• Enforce security guardrails by excluding executable/path fields, sanitizing launch arguments through a shared helper, capping inline payloads at 64 KB, and validating manifest hashes in CAS before workspace creation.

Design Choices

Design Choice 1: Fetch method for a ContentManifest from an arbitrary HTTPS URL

Options Considered:

1. Add a small remote-manifest fetcher service that uses IDownloadService.DownloadFileAsync to a temp file, then deserializes with System.Text.Json, then runs the same manifest security/ID checks used in ManifestProvider.
2. Add a new IContentResolver implementation (HttpManifestResolver) registered in the content pipeline that resolves a ContentSearchResult.SourceUrl to a ContentManifest.

Chosen Option: 1

Rationale: A dedicated fetcher reuses the existing verified download transport and JSON pattern. It stays scoped to the sharing feature. It does not change the search-result-driven content pipeline contract.

Design Choice 2: Sharing of launch-argument sanitization between the launcher and the importer

Options Considered:

1. Extract the argument-validation and path-containment checks into a shared helper in GenHub.Core/Helpers/ and reuse it in the sharing service.
2. Re-implement the checks inside the sharing service.

Chosen Option: 1

Rationale: A shared helper removes duplication. It keeps one source of truth for security rules. The ticket requires these rules across launch and import.

Design Choice 3: Cross-platform scope for protocol registration and IPC forwarding

Options Considered:

1. Implement Windows end-to-end (registry registration + pipe forwarding). Add Linux .desktop scheme registration plus a new lockfile/Unix-socket single-instance substrate for forwarding. Document macOS Info.plist registration but treat it as best-effort because no macOS head exists.
2. Implement Windows only and defer Linux/macOS.

Chosen Option: 1

Rationale: The ticket explicitly requires cross-platform registration. Windows is the primary target. Linux needs a new IPC substrate to forward deep links. macOS registration is documented without a build head.

💡 User Tips

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

Implementation Steps

Phase 1: Shared Data Models, Constants, and Settings Overrides

This phase adds the serializable contracts and safe settings-application logic that all later phases use. It defines the package format, the inspection result shape, the security limits, and validated application of untrusted setting overrides.

Task 1: Add shared package and inspection models

Create the portable data contracts for sharing and inspection.

• Create SharedGameProfilePackage, SharedProfilePackageProfile (the portable profile subset), and SharedManifestReference (the requiredManifests[] entry with manifestId, name, contentType, version, publisher, manifestUrl, totalBytes) in GenHub/GenHub.Core/Models/GameProfile/.
• Include package envelope fields $schemaVersion, generatorVersion, and exportedAt. Stamp generatorVersion from AppConstants.AppVersion on export.
• Restrict the portable profile subset to shareable fields: name, description, themeColor, gameType, gameVersion, useSteamLaunch, commandLineArguments, and a gameSettingsOverrides block that mirrors the nullable Video*/Audio*/Tsh*/Go*/GameSpyIPAddress fields of GameProfile.
• Exclude ExecutablePath, CustomExecutablePath, WorkingDirectory, GameInstallationId, ActiveWorkspaceId, and the embedded GameClient from the portable subset per the security requirement.
• Create SharedProfileInspectionResult, SharedManifestDependency, and SharedProfileImportRequest in GenHub/GenHub.Core/Models/GameProfile/, matching the interface signatures in the ticket.

Task 2: Add security and payload constants

Add limits used by the payload guard and sanitization logic.

• Add MaxSharedProfilePayloadSizeBytes = 65536 // 64KB and a MaxSharedProfileManifestCount limit to GenHub/GenHub.Core/Constants/ValidationLimits.cs, following the existing Min*/Max* byte-comment convention.
• Add the genhub scheme string and the profile/import and profile/view route constants to a new or existing constants type in GenHub/GenHub.Core/Constants/ (for example CommandLineConstants).

Task 3: Add validated settings-override application

Provide a safe path to apply untrusted overrides onto a new profile.

• Extend GenHub/GenHub.Core/Helpers/GameSettingsMapper.cs (or add a sibling helper) with a method that applies a gameSettingsOverrides block onto a GameProfile/CreateProfileRequest, using the HasValue-gated, range-checked, skip-and-log pattern already used in ApplyToOptions.
• Reuse GameSettingsConstants ranges for Video/Audio/Network fields.
• Add validation for Tsh* fields using GameSettingsTheSuperHackersConstants (font sizes, resolution font adjustment) and a 0–100 clamp for MoneyTransactionVolume.
• Use GameSettingsGeneralsOnlineConstants for GoChatFontSize. Pass through boolean Go* toggles unchanged. Never throw on invalid values.

🤖 Prompt for AI agents

Implement the shared data models, constants, and settings-override logic that
later phases depend on.

- In `GenHub/GenHub.Core/Models/GameProfile/`, create
`SharedGameProfilePackage`, `SharedProfilePackageProfile`, and
`SharedManifestReference`. `SharedManifestReference` must have fields
`manifestId`, `name`, `contentType`, `version`, `publisher`, `manifestUrl`, and
`totalBytes`. Add package envelope fields `$schemaVersion`, `generatorVersion`,
and `exportedAt` to `SharedGameProfilePackage`; stamp `generatorVersion` from
`AppConstants.AppVersion` during export.
- Restrict `SharedProfilePackageProfile` to `name`, `description`, `themeColor`,
`gameType`, `gameVersion`, `useSteamLaunch`, `commandLineArguments`, and a
`gameSettingsOverrides` block mirroring the nullable
`Video*/Audio*/Tsh*/Go*/GameSpyIPAddress` fields of `GameProfile`. Exclude
`ExecutablePath`, `CustomExecutablePath`, `WorkingDirectory`,
`GameInstallationId`, `ActiveWorkspaceId`, and the embedded `GameClient`.
- In the same models directory, create `SharedProfileInspectionResult`,
`SharedManifestDependency`, and `SharedProfileImportRequest`, matching the
interface signatures given in the ticket.
- In `GenHub/GenHub.Core/Constants/ValidationLimits.cs`, add
`MaxSharedProfilePayloadSizeBytes = 65536 // 64KB` and
`MaxSharedProfileManifestCount`, following the existing `Min*`/`Max*`
byte-comment convention.
- Add the `genhub` scheme string and the `profile/import` and `profile/view`
route constants to a constants type in `GenHub/GenHub.Core/Constants/` (for
example `CommandLineConstants`).
- Extend `GenHub/GenHub.Core/Helpers/GameSettingsMapper.cs` (or add a sibling
helper) with a method that applies a `gameSettingsOverrides` block onto a
`GameProfile`/`CreateProfileRequest`. Use the `HasValue`-gated, range-checked,
skip-and-log pattern already used in `ApplyToOptions`. Reuse
`GameSettingsConstants` ranges for Video/Audio/Network fields. Validate `Tsh*`
fields using `GameSettingsTheSuperHackersConstants` (font sizes, resolution font
adjustment) and clamp `MoneyTransactionVolume` to 0–100. Use
`GameSettingsGeneralsOnlineConstants` for `GoChatFontSize`. Pass boolean `Go*`
toggles through unchanged. The method must never throw on invalid values.

Phase 2: Profile Sharing Service

This phase implements the core export, inspect, and import logic. It performs Brotli/Base64Url payload encoding, remote manifest fetching, CAS/manifest diffing, installation matching, security validation, and profile creation through existing profile services.

Task 1: Define the sharing service interface

Add the service contract.

• Add IProfileSharingService to GenHub/GenHub.Core/Interfaces/GameProfiles/ with the four methods from the ticket (ExportProfileToUriAsync, ExportProfileToFileAsync, InspectSharedProfileAsync, ImportSharedProfileAsync), all returning OperationResult<T>.

Task 2: Implement export and payload encoding

Build the export paths and the URI/file writers.

• Create ProfileSharingService in GenHub/GenHub/Features/GameProfiles/Services/.
• Load the source profile through IGameProfileManager, resolve each EnabledContentIds manifest through IContentManifestPool, and build SharedGameProfilePackage with the portable profile subset and a requiredManifests[] entry per resolved manifest (skip machine-local GameInstallation/GameClient bindings, keep portable manifest IDs, sizes, and publisher).
• For ExportProfileToUriAsync: serialize the package to JSON, Brotli-compress, Base64Url-encode, and build genhub://profile/import?data=.... If the encoded payload exceeds MaxSharedProfilePayloadSizeBytes, return a failure that instructs the caller to use file or remote-URL export.
• For ExportProfileToFileAsync: write the package JSON to the given .ghprofile destination path.

Task 3: Implement inspection with CAS diffing and security checks

Build the read-only inspection that never mutates state.

• Parse the input in InspectSharedProfileAsync: accept a genhub://profile/import?data=... URI (Base64Url → Brotli-decompress → JSON), a ?url=... URI (fetch remote JSON, see Task 2.5), or raw .ghprofile JSON.
• Enforce the 64 KB payload guard on inline data= input before decompression, and reject packages exceeding MaxSharedProfileManifestCount.
• For each requiredManifests[] entry, resolve the manifest locally through IContentManifestPool.GetManifestAsync. When present, diff its ContentAddressable files against CAS through ICasService.ExistsAsync(hash, contentType) to classify IsCachedLocally and accumulate DownloadSize/TotalDownloadBytesRequired.
• Match a local installation by gameType using the ProfileLauncherFacade.ResolveOrRebindInstallationAsync pattern (exact then single-candidate fallback through IGameInstallationService). Set HasValidGameInstallation and MatchedGameInstallationId.
• Detect profile-name conflicts against existing profiles and produce SuggestedProfileName.
• Build SecurityWarnings: reject any executable/working-directory fields present in the package, and validate commandLineArguments with the shared sanitization helper (see Task 2.6).
• Return a populated SharedProfileInspectionResult without changing any stored state.

Task 4: Implement import, acquisition, and profile creation

Build the state-changing import path.

• In ImportSharedProfileAsync, re-run inspection to get the current diff, then for each missing manifest trigger acquisition through the existing search-result-driven pattern (IContentOrchestrator.SearchAsync scoped by provider/content-type/name, pick the matching ContentSearchResult, then AcquireContentAsync), forwarding the IProgress<ContentAcquisitionProgress>.
• For manifests supplied only by manifestUrl, fetch and store the manifest through the remote fetcher (Task 2.5) before acquisition.
• Resolve the target installation and GameClient locally (never from the package) and build the local EnabledContentIds set, reusing IDependencyResolver and the ProfileContentService exclusive-content rules to guarantee exactly one GameInstallation and one GameClient.
• Create the profile through IGameProfileManager.CreateProfileAsync/IProfileEditorFacade, apply the validated gameSettingsOverrides (Task 1.3), and honor the imported name or the caller-supplied rename in SharedProfileImportRequest.
• Validate manifest file hashes in CAS before completion, and return the created GameProfile.

Task 5: Add remote manifest fetching

Add the ability to load a manifest from an HTTPS URL.

• Add a small remote-manifest fetcher in GenHub/GenHub/Features/GameProfiles/Services/ (or Features/Manifest/) that downloads a manifest JSON with IDownloadService.DownloadFileAsync to a temp file, deserializes it to ContentManifest, and runs the manifest security/ID checks used in ManifestProvider.
• Return OperationResult<ContentManifest> and surface clear failures for 404s, network errors, and corrupted JSON.

Task 6: Add shared argument-sanitization helper

Centralize the command-argument and path guardrails.

• Extract the IsValidCommandArgument logic from GenHub/GenHub/Features/Launching/GameLauncher.cs and the duplicated logic in ProfileLauncherFacade.cs into a shared helper in GenHub/GenHub.Core/Helpers/.
• Reuse this helper in ProfileSharingService to sanitize imported commandLineArguments and reject command-injection characters (|, &, ;, >, <) and traversal patterns.
• Update GameLauncher and ProfileLauncherFacade to call the shared helper to avoid divergent rules.

🤖 Prompt for AI agents

Implement the core profile sharing service: export, inspection, import, remote
manifest fetching, and shared argument sanitization.

- Add `IProfileSharingService` to `GenHub/GenHub.Core/Interfaces/GameProfiles/`
with four methods: `ExportProfileToUriAsync`, `ExportProfileToFileAsync`,
`InspectSharedProfileAsync`, `ImportSharedProfileAsync`. All methods must return
`OperationResult<T>`.
- Create `ProfileSharingService` in
`GenHub/GenHub/Features/GameProfiles/Services/`. Load the source profile through
`IGameProfileManager`, resolve each `EnabledContentIds` manifest through
`IContentManifestPool`, and build a `SharedGameProfilePackage` with the portable
profile subset and one `requiredManifests[]` entry per resolved manifest. Skip
machine-local GameInstallation/GameClient bindings; keep portable manifest IDs,
sizes, and publisher.
- For `ExportProfileToUriAsync`: serialize the package to JSON, Brotli-compress
it, Base64Url-encode it, and build a `genhub://profile/import?data=...` URI. If
the encoded payload exceeds `MaxSharedProfilePayloadSizeBytes`, return a failure
that instructs the caller to use file or remote-URL export instead.
- For `ExportProfileToFileAsync`: write the package JSON to the given
`.ghprofile` destination path.
- For `InspectSharedProfileAsync`: parse three input forms — a
`genhub://profile/import?data=...` URI (Base64Url decode, Brotli-decompress,
then JSON parse), a `?url=...` URI (fetch remote JSON through the remote
fetcher), or raw `.ghprofile` JSON. Enforce the 64 KB payload guard on inline
`data=` input before decompression. Reject packages exceeding
`MaxSharedProfileManifestCount`. For each `requiredManifests[]` entry, resolve
the manifest locally through `IContentManifestPool.GetManifestAsync`; when
present, diff its `ContentAddressable` files against CAS through
`ICasService.ExistsAsync(hash, contentType)` to classify `IsCachedLocally` and
accumulate `DownloadSize`/`TotalDownloadBytesRequired`. Match a local
installation by `gameType` using the
`ProfileLauncherFacade.ResolveOrRebindInstallationAsync` pattern (exact match,
then single-candidate fallback through `IGameInstallationService`); set
`HasValidGameInstallation` and `MatchedGameInstallationId`. Detect profile-name
conflicts against existing profiles and produce `SuggestedProfileName`. Build
`SecurityWarnings` by rejecting any executable/working-directory fields present
in the package and validating `commandLineArguments` with the shared
sanitization helper. This method must never mutate stored state; return a
populated `SharedProfileInspectionResult`.
- For `ImportSharedProfileAsync`: re-run inspection to get the current diff. For
each missing manifest, trigger acquisition through the existing
search-result-driven pattern (`IContentOrchestrator.SearchAsync` scoped by
provider/content-type/name, select the matching `ContentSearchResult`, then call
`AcquireContentAsync`), forwarding the `IProgress<ContentAcquisitionProgress>`.
For manifests supplied only by `manifestUrl`, fetch and store the manifest
through the remote fetcher before acquisition. Resolve the target installation
and GameClient locally, never from the package, and build the local
`EnabledContentIds` set by reusing `IDependencyResolver` and the
`ProfileContentService` exclusive-content rules to guarantee exactly one
GameInstallation and one GameClient. Create the profile through
`IGameProfileManager.CreateProfileAsync`/`IProfileEditorFacade`, apply the
validated `gameSettingsOverrides`, and honor the imported name or the
caller-supplied rename in `SharedProfileImportRequest`. Validate manifest file
hashes in CAS before completion, and return the created `GameProfile`.
- Add a small remote-manifest fetcher in
`GenHub/GenHub/Features/GameProfiles/Services/` (or `Features/Manifest/`) that
downloads a manifest JSON with `IDownloadService.DownloadFileAsync` to a temp
file, deserializes it to `ContentManifest`, and runs the manifest security/ID
checks used in `ManifestProvider`. Return `OperationResult<ContentManifest>` and
surface clear failures for 404s, network errors, and corrupted JSON.
- Extract the `IsValidCommandArgument` logic from
`GenHub/GenHub/Features/Launching/GameLauncher.cs` and the duplicated logic in
`ProfileLauncherFacade.cs` into a shared helper in
`GenHub/GenHub.Core/Helpers/`. Reuse this helper in `ProfileSharingService` to
sanitize imported `commandLineArguments`, rejecting command-injection characters
(`|`, `&`, `;`, `>`, `<`) and traversal patterns. Update `GameLauncher` and
`ProfileLauncherFacade` to call the shared helper instead of their own logic.

Phase 3: Protocol Activation and IPC Forwarding

This phase adds genhub:// URI parsing, IPC forwarding to a running instance, in-app routing to the import flow, and OS scheme registration on each platform.

Task 1: Extend command-line parsing and IPC commands

Add parsing and a new IPC command prefix.

• Add ExtractProfileShareUri(string[] args) to GenHub/GenHub.Core/Helpers/CommandLineParser.cs to detect a genhub://profile/... argument (positional or flagged) and return the raw URI.
• Add ImportProfilePrefix = "import-profile:" to GenHub/GenHub.Core/Constants/IpcCommands.cs.

Task 2: Route deep links through single-instance and the app

Forward the URI to the active instance and open the import modal.

• Update GenHub.Windows/Program.cs to extract a share URI, and when the process is a secondary instance, forward IpcCommands.ImportProfilePrefix + uri through SingleInstanceManager.SendCommandToPrimaryInstance and focus the primary instance.
• Update GenHub/App.axaml.cs HandleSingleInstanceCommand to recognize ImportProfilePrefix and start the import inspection flow (Phase 4) on the UI thread.
• Update App.axaml.cs first-launch argument handling to also route a genhub://profile/... startup argument to the import flow.
• Add a Linux single-instance substrate (lockfile plus Unix domain socket) in GenHub.Linux/ that mirrors the Windows primary/secondary + forwarding pattern, and assign it to AppLocator.SingleInstanceManager so App.axaml.cs receives forwarded commands.

Task 3: Register the OS URL scheme

Register genhub:// on each platform.

• Windows: add a registrar (alongside WindowsShortcutService/WindowsServicesModule) that writes HKCU\Software\Classes\genhub\shell\open\command pointing at the executable with "%1".
• Linux: extend LinuxShortcutService or add a registrar that writes a .desktop file with MimeType=x-scheme-handler/genhub; and runs xdg-mime default.
• macOS: document the CFBundleURLTypes genhub entry for Info.plist. Treat activation as best-effort because no macOS build head exists in the repository.

🤖 Prompt for AI agents

Implement `genhub://` deep-link parsing, IPC forwarding, in-app routing, and OS
scheme registration.

- Add `ExtractProfileShareUri(string[] args)` to
`GenHub/GenHub.Core/Helpers/CommandLineParser.cs`. It must detect a
`genhub://profile/...` argument, whether positional or flagged, and return the
raw URI.
- Add `ImportProfilePrefix = "import-profile:"` to
`GenHub/GenHub.Core/Constants/IpcCommands.cs`.
- Update `GenHub.Windows/Program.cs` to extract a share URI from arguments. When
the process is a secondary instance, forward `IpcCommands.ImportProfilePrefix +
uri` through `SingleInstanceManager.SendCommandToPrimaryInstance` and focus the
primary instance.
- Update `GenHub/App.axaml.cs` `HandleSingleInstanceCommand` to recognize
`ImportProfilePrefix` and start the import inspection flow on the UI thread.
- Update `App.axaml.cs` first-launch argument handling so a
`genhub://profile/...` startup argument also routes to the import flow.
- Add a Linux single-instance substrate (lockfile plus Unix domain socket) in
`GenHub.Linux/` that mirrors the Windows primary/secondary plus forwarding
pattern. Assign it to `AppLocator.SingleInstanceManager` so `App.axaml.cs`
receives forwarded commands.
- On Windows, add a registrar alongside
`WindowsShortcutService`/`WindowsServicesModule` that writes
`HKCU\Software\Classes\genhub\shell\open\command` pointing at the executable
with `"%1"`.
- On Linux, extend `LinuxShortcutService` or add a registrar that writes a
`.desktop` file with `MimeType=x-scheme-handler/genhub;` and runs `xdg-mime
default`.
- For macOS, document the `CFBundleURLTypes` `genhub` entry for `Info.plist`.
Treat this as best-effort documentation only, since no macOS build head exists
in the repository.

Phase 4: Sharing and Import UI

This phase adds the card entry points, the share dialog, the inspection modal with the diff table and setting summary, the acquisition progress overlay, and post-import selection.

Task 1: Add Share entry points on the profile card

Expose the share action.

• Add a Share button (Classes="tool-button", share icon) to the action row in GenHub/GenHub/Features/GameProfiles/Views/GameProfileCardView.axaml and a "Share Profile..." MenuItem to the card Border.ContextMenu.
• Add a ShareProfileAction delegate plus [RelayCommand] ShareProfile to GameProfileItemViewModel.cs, and wire the delegate in GameProfileLauncherViewModel (following the existing action-delegate pattern), so the launcher VM opens the share dialog.

Task 2: Implement the Share Profile dialog

Add the export dialog window and ViewModel.

• Create ShareProfileDialogWindow.axaml/.axaml.cs and ShareProfileDialogViewModel under GenHub/GenHub/Features/GameProfiles/, following the Pattern C modal convention (owner VM constructs the window, sets DataContext, WindowStartupLocation=CenterOwner, ShowDialog, VM raises a CloseRequested event).
• Call IProfileSharingService.ExportProfileToUriAsync and show the URI with a Copy action using TopLevel.Clipboard.SetTextAsync and INotificationService.ShowSuccess feedback (the existing SettingsViewModel clipboard pattern).
• Add a "Copy Discord Markdown" action that copies a formatted snippet, and an "Export .ghprofile File" action using StorageProvider.SaveFilePickerAsync (the existing SettingsViewModel save-picker pattern) that calls ExportProfileToFileAsync.

Task 3: Implement the Import inspection modal

Add the inspection window and ViewModel.

• Create ImportProfileInspectionWindow.axaml/.axaml.cs and ImportProfileInspectionViewModel under GenHub/GenHub/Features/GameProfiles/, conforming to the GenHub dark theme (glass cards, accent borders, badge tags).
• Call IProfileSharingService.InspectSharedProfileAsync and bind the result: cover/name/target client header, editable profile name with conflict indication, the manifest diff table with per-item status badges (✅ CACHED vs ⬇️ <size>), the settings/launch-options summary, the target-installation selector, and the total download requirement.
• Add a target-installation dropdown populated from IGameInstallationService, defaulting to MatchedGameInstallationId, and disable Import when HasValidGameInstallation is false.
• Surface SecurityWarnings visibly, and handle inspection failures (bad payload, 404, corrupted JSON) with a clear error state.

Task 4: Add acquisition progress and post-import selection

Show download progress and highlight the new profile.

• On "Import & Download", call IProfileSharingService.ImportSharedProfileAsync with an IProgress<ContentAcquisitionProgress> that updates per-manifest progress in the modal, reusing the FormatProgressStatus phase-formatting approach from PublisherCardViewModel (promote it to a shared helper if reused).
• Factor the inline ProgressBar + status TextBlock block from PublisherCardView.axaml into a reusable DownloadItemProgressView control and use it for per-manifest rows.
• On success, send ProfileCreatedMessage (already handled by GameProfileLauncherViewModel.Receive) and call INotificationService.ShowSuccess.
• Add a SelectedProfileId/IsHighlighted mechanism to GameProfileLauncherViewModel/GameProfileItemViewModel and scroll-into-view handling so the imported profile is highlighted on the dashboard.

🤖 Prompt for AI agents

Implement the sharing and import UI: card entry points, the share dialog, the
inspection modal, and acquisition progress.

- Add a Share button (`Classes="tool-button"`, share icon) to the action row in
`GenHub/GenHub/Features/GameProfiles/Views/GameProfileCardView.axaml`, plus a
"Share Profile..." `MenuItem` in the card `Border.ContextMenu`.
- Add a `ShareProfileAction` delegate and a `[RelayCommand] ShareProfile` to
`GameProfileItemViewModel.cs`. Wire the delegate in
`GameProfileLauncherViewModel` following the existing action-delegate pattern,
so the launcher VM opens the share dialog.
- Create `ShareProfileDialogWindow.axaml`/`.axaml.cs` and
`ShareProfileDialogViewModel` under `GenHub/GenHub/Features/GameProfiles/`,
following the Pattern C modal convention: the owner VM constructs the window,
sets `DataContext`, sets `WindowStartupLocation=CenterOwner`, calls
`ShowDialog`, and the VM raises a `CloseRequested` event.
- In the share dialog, call `IProfileSharingService.ExportProfileToUriAsync` and
display the URI with a Copy action using `TopLevel.Clipboard.SetTextAsync` and
`INotificationService.ShowSuccess` feedback, matching the existing
`SettingsViewModel` clipboard pattern. Add a "Copy Discord Markdown" action that
copies a formatted snippet. Add an "Export .ghprofile File" action using
`StorageProvider.SaveFilePickerAsync` (matching the existing `SettingsViewModel`
save-picker pattern) that calls `ExportProfileToFileAsync`.
- Create `ImportProfileInspectionWindow.axaml`/`.axaml.cs` and
`ImportProfileInspectionViewModel` under `GenHub/GenHub/Features/GameProfiles/`,
conforming to the GenHub dark theme (glass cards, accent borders, badge tags).
Call `IProfileSharingService.InspectSharedProfileAsync` and bind the result to:
a header showing cover/name/target client, an editable profile name with
conflict indication, a manifest diff table with per-item status badges (`✅
CACHED` vs `⬇️ <size>`), a settings/launch-options summary, a
target-installation selector, and the total download requirement. Populate the
target-installation dropdown from `IGameInstallationService`, default it to
`MatchedGameInstallationId`, and disable the Import action when
`HasValidGameInstallation` is false. Show `SecurityWarnings` visibly. Handle
inspection failures (bad payload, 404, corrupted JSON) with a clear error state.
- On the "Import & Download" action, call
`IProfileSharingService.ImportSharedProfileAsync` with an
`IProgress<ContentAcquisitionProgress>` that updates per-manifest progress in
the modal. Reuse the `FormatProgressStatus` phase-formatting approach from
`PublisherCardViewModel`; promote it to a shared helper if it is reused
elsewhere. Factor the inline `ProgressBar` plus status `TextBlock` block from
`PublisherCardView.axaml` into a reusable `DownloadItemProgressView` control,
and use it for each per-manifest row.
- On successful import, send `ProfileCreatedMessage` (already handled by
`GameProfileLauncherViewModel.Receive`) and call
`INotificationService.ShowSuccess`. Add a `SelectedProfileId`/`IsHighlighted`
mechanism to `GameProfileLauncherViewModel`/`GameProfileItemViewModel` with
scroll-into-view handling, so the imported profile is highlighted on the
dashboard.

Phase 5: Dependency Injection and Tests

This phase registers the new services and ViewModels and adds the required tests.

Task 1: Register services and ViewModels

Wire the new components into DI.

• Register IProfileSharingService → ProfileSharingService and the remote-manifest fetcher in GenHub/GenHub/Infrastructure/DependencyInjection/GameProfileModule.cs, after the other IProfileXxx registrations.
• Register ShareProfileDialogViewModel and ImportProfileInspectionViewModel as transient in the same module (mirroring AppUpdateModule).
• Register the Windows and Linux protocol registrars in their platform service modules, and register the Linux single-instance substrate.

Task 2: Add unit tests

Cover serialization, compression, and parsing.

• Add tests in GenHub.Tests.Core for SharedGameProfilePackage serialization/round-trip, Brotli compression/decompression, Base64Url encode/decode, the 64 KB payload guard, CommandLineParser.ExtractProfileShareUri, and the shared argument-sanitization helper (accept safe args, reject injection characters and traversal).

Task 3: Add integration tests

Cover inspection diffing and import.

• Add tests for IProfileSharingService.InspectSharedProfileAsync that verify cached-vs-missing manifest classification, TotalDownloadBytesRequired accumulation, installation matching, and name-conflict detection.
• Add a test that verifies the executable-path exclusion and command-argument sanitization produce SecurityWarnings and safe imported profiles.

🤖 Prompt for AI agents

Register the new services and ViewModels in the dependency injection setup, and
add the required test coverage.

- In `GenHub/GenHub/Infrastructure/DependencyInjection/GameProfileModule.cs`,
register `IProfileSharingService → ProfileSharingService` and the
remote-manifest fetcher, placed after the other `IProfileXxx` registrations.
- In the same module, register `ShareProfileDialogViewModel` and
`ImportProfileInspectionViewModel` as transient services, mirroring the pattern
used in `AppUpdateModule`.
- Register the Windows and Linux protocol registrars in their respective
platform service modules, and register the Linux single-instance substrate.
- In `GenHub.Tests.Core`, add unit tests for: `SharedGameProfilePackage`
serialization and round-trip, Brotli compression and decompression, Base64Url
encode and decode, the 64 KB payload guard,
`CommandLineParser.ExtractProfileShareUri`, and the shared argument-sanitization
helper (verify it accepts safe arguments and rejects injection characters and
traversal patterns).
- Add integration tests for `IProfileSharingService.InspectSharedProfileAsync`
that verify cached-vs-missing manifest classification,
`TotalDownloadBytesRequired` accumulation, installation matching, and
name-conflict detection.
- Add an integration test that verifies the executable-path exclusion and
command-argument sanitization produce `SecurityWarnings` and result in safe
imported profiles.

Research

GenHub is an Avalonia MVVM application. It has these parts:

• A shared GenHub.Core library. It contains models, interfaces, helpers, and constants.
• A shared GenHub app project. It contains feature services and views.
• Platform heads GenHub.Windows and GenHub.Linux.

GameProfiles persist as per-profile JSON files through GameProfileRepository. GameProfileManager and ProfileEditorFacade create and update profiles. Profiles reference content only as manifest-ID strings in EnabledContentIds.

Content acquisition runs through IContentOrchestrator. The flow is: search, then resolve, then deliver, then store into IContentManifestPool. ICasService.ExistsAsync checks CAS blob presence.

Single-instance IPC exists on Windows only. It uses a named Mutex plus a named pipe in SingleInstanceManager. Commands are defined in IpcCommands and parsed by CommandLineParser.

Modal windows follow an MVVM code-behind pattern. The owner ViewModel constructs the window, sets DataContext, and shows it with ShowDialog.

DI registration is grouped into static module extension methods. AppServices.cs composes these modules.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement the shared data models, constants, and settings-override logic that
later phases depend on.

- In `GenHub/GenHub.Core/Models/GameProfile/`, create
`SharedGameProfilePackage`, `SharedProfilePackageProfile`, and
`SharedManifestReference`. `SharedManifestReference` must have fields
`manifestId`, `name`, `contentType`, `version`, `publisher`, `manifestUrl`, and
`totalBytes`. Add package envelope fields `$schemaVersion`, `generatorVersion`,
and `exportedAt` to `SharedGameProfilePackage`; stamp `generatorVersion` from
`AppConstants.AppVersion` during export.
- Restrict `SharedProfilePackageProfile` to `name`, `description`, `themeColor`,
`gameType`, `gameVersion`, `useSteamLaunch`, `commandLineArguments`, and a
`gameSettingsOverrides` block mirroring the nullable
`Video*/Audio*/Tsh*/Go*/GameSpyIPAddress` fields of `GameProfile`. Exclude
`ExecutablePath`, `CustomExecutablePath`, `WorkingDirectory`,
`GameInstallationId`, `ActiveWorkspaceId`, and the embedded `GameClient`.
- In the same models directory, create `SharedProfileInspectionResult`,
`SharedManifestDependency`, and `SharedProfileImportRequest`, matching the
interface signatures given in the ticket.
- In `GenHub/GenHub.Core/Constants/ValidationLimits.cs`, add
`MaxSharedProfilePayloadSizeBytes = 65536 // 64KB` and
`MaxSharedProfileManifestCount`, following the existing `Min*`/`Max*`
byte-comment convention.
- Add the `genhub` scheme string and the `profile/import` and `profile/view`
route constants to a constants type in `GenHub/GenHub.Core/Constants/` (for
example `CommandLineConstants`).
- Extend `GenHub/GenHub.Core/Helpers/GameSettingsMapper.cs` (or add a sibling
helper) with a method that applies a `gameSettingsOverrides` block onto a
`GameProfile`/`CreateProfileRequest`. Use the `HasValue`-gated, range-checked,
skip-and-log pattern already used in `ApplyToOptions`. Reuse
`GameSettingsConstants` ranges for Video/Audio/Network fields. Validate `Tsh*`
fields using `GameSettingsTheSuperHackersConstants` (font sizes, resolution font
adjustment) and clamp `MoneyTransactionVolume` to 0–100. Use
`GameSettingsGeneralsOnlineConstants` for `GoChatFontSize`. Pass boolean `Go*`
toggles through unchanged. The method must never throw on invalid values.
===============================================================================

Task: 2

Implement the core profile sharing service: export, inspection, import, remote
manifest fetching, and shared argument sanitization.

- Add `IProfileSharingService` to `GenHub/GenHub.Core/Interfaces/GameProfiles/`
with four methods: `ExportProfileToUriAsync`, `ExportProfileToFileAsync`,
`InspectSharedProfileAsync`, `ImportSharedProfileAsync`. All methods must return
`OperationResult<T>`.
- Create `ProfileSharingService` in
`GenHub/GenHub/Features/GameProfiles/Services/`. Load the source profile through
`IGameProfileManager`, resolve each `EnabledContentIds` manifest through
`IContentManifestPool`, and build a `SharedGameProfilePackage` with the portable
profile subset and one `requiredManifests[]` entry per resolved manifest. Skip
machine-local GameInstallation/GameClient bindings; keep portable manifest IDs,
sizes, and publisher.
- For `ExportProfileToUriAsync`: serialize the package to JSON, Brotli-compress
it, Base64Url-encode it, and build a `genhub://profile/import?data=...` URI. If
the encoded payload exceeds `MaxSharedProfilePayloadSizeBytes`, return a failure
that instructs the caller to use file or remote-URL export instead.
- For `ExportProfileToFileAsync`: write the package JSON to the given
`.ghprofile` destination path.
- For `InspectSharedProfileAsync`: parse three input forms — a
`genhub://profile/import?data=...` URI (Base64Url decode, Brotli-decompress,
then JSON parse), a `?url=...` URI (fetch remote JSON through the remote
fetcher), or raw `.ghprofile` JSON. Enforce the 64 KB payload guard on inline
`data=` input before decompression. Reject packages exceeding
`MaxSharedProfileManifestCount`. For each `requiredManifests[]` entry, resolve
the manifest locally through `IContentManifestPool.GetManifestAsync`; when
present, diff its `ContentAddressable` files against CAS through
`ICasService.ExistsAsync(hash, contentType)` to classify `IsCachedLocally` and
accumulate `DownloadSize`/`TotalDownloadBytesRequired`. Match a local
installation by `gameType` using the
`ProfileLauncherFacade.ResolveOrRebindInstallationAsync` pattern (exact match,
then single-candidate fallback through `IGameInstallationService`); set
`HasValidGameInstallation` and `MatchedGameInstallationId`. Detect profile-name
conflicts against existing profiles and produce `SuggestedProfileName`. Build
`SecurityWarnings` by rejecting any executable/working-directory fields present
in the package and validating `commandLineArguments` with the shared
sanitization helper. This method must never mutate stored state; return a
populated `SharedProfileInspectionResult`.
- For `ImportSharedProfileAsync`: re-run inspection to get the current diff. For
each missing manifest, trigger acquisition through the existing
search-result-driven pattern (`IContentOrchestrator.SearchAsync` scoped by
provider/content-type/name, select the matching `ContentSearchResult`, then call
`AcquireContentAsync`), forwarding the `IProgress<ContentAcquisitionProgress>`.
For manifests supplied only by `manifestUrl`, fetch and store the manifest
through the remote fetcher before acquisition. Resolve the target installation
and GameClient locally, never from the package, and build the local
`EnabledContentIds` set by reusing `IDependencyResolver` and the
`ProfileContentService` exclusive-content rules to guarantee exactly one
GameInstallation and one GameClient. Create the profile through
`IGameProfileManager.CreateProfileAsync`/`IProfileEditorFacade`, apply the
validated `gameSettingsOverrides`, and honor the imported name or the
caller-supplied rename in `SharedProfileImportRequest`. Validate manifest file
hashes in CAS before completion, and return the created `GameProfile`.
- Add a small remote-manifest fetcher in
`GenHub/GenHub/Features/GameProfiles/Services/` (or `Features/Manifest/`) that
downloads a manifest JSON with `IDownloadService.DownloadFileAsync` to a temp
file, deserializes it to `ContentManifest`, and runs the manifest security/ID
checks used in `ManifestProvider`. Return `OperationResult<ContentManifest>` and
surface clear failures for 404s, network errors, and corrupted JSON.
- Extract the `IsValidCommandArgument` logic from
`GenHub/GenHub/Features/Launching/GameLauncher.cs` and the duplicated logic in
`ProfileLauncherFacade.cs` into a shared helper in
`GenHub/GenHub.Core/Helpers/`. Reuse this helper in `ProfileSharingService` to
sanitize imported `commandLineArguments`, rejecting command-injection characters
(`|`, `&`, `;`, `>`, `<`) and traversal patterns. Update `GameLauncher` and
`ProfileLauncherFacade` to call the shared helper instead of their own logic.
===============================================================================

Task: 3

Implement `genhub://` deep-link parsing, IPC forwarding, in-app routing, and OS
scheme registration.

- Add `ExtractProfileShareUri(string[] args)` to
`GenHub/GenHub.Core/Helpers/CommandLineParser.cs`. It must detect a
`genhub://profile/...` argument, whether positional or flagged, and return the
raw URI.
- Add `ImportProfilePrefix = "import-profile:"` to
`GenHub/GenHub.Core/Constants/IpcCommands.cs`.
- Update `GenHub.Windows/Program.cs` to extract a share URI from arguments. When
the process is a secondary instance, forward `IpcCommands.ImportProfilePrefix +
uri` through `SingleInstanceManager.SendCommandToPrimaryInstance` and focus the
primary instance.
- Update `GenHub/App.axaml.cs` `HandleSingleInstanceCommand` to recognize
`ImportProfilePrefix` and start the import inspection flow on the UI thread.
- Update `App.axaml.cs` first-launch argument handling so a
`genhub://profile/...` startup argument also routes to the import flow.
- Add a Linux single-instance substrate (lockfile plus Unix domain socket) in
`GenHub.Linux/` that mirrors the Windows primary/secondary plus forwarding
pattern. Assign it to `AppLocator.SingleInstanceManager` so `App.axaml.cs`
receives forwarded commands.
- On Windows, add a registrar alongside
`WindowsShortcutService`/`WindowsServicesModule` that writes
`HKCU\Software\Classes\genhub\shell\open\command` pointing at the executable
with `"%1"`.
- On Linux, extend `LinuxShortcutService` or add a registrar that writes a
`.desktop` file with `MimeType=x-scheme-handler/genhub;` and runs `xdg-mime
default`.
- For macOS, document the `CFBundleURLTypes` `genhub` entry for `Info.plist`.
Treat this as best-effort documentation only, since no macOS build head exists
in the repository.
===============================================================================

Task: 4

Implement the sharing and import UI: card entry points, the share dialog, the
inspection modal, and acquisition progress.

- Add a Share button (`Classes="tool-button"`, share icon) to the action row in
`GenHub/GenHub/Features/GameProfiles/Views/GameProfileCardView.axaml`, plus a
"Share Profile..." `MenuItem` in the card `Border.ContextMenu`.
- Add a `ShareProfileAction` delegate and a `[RelayCommand] ShareProfile` to
`GameProfileItemViewModel.cs`. Wire the delegate in
`GameProfileLauncherViewModel` following the existing action-delegate pattern,
so the launcher VM opens the share dialog.
- Create `ShareProfileDialogWindow.axaml`/`.axaml.cs` and
`ShareProfileDialogViewModel` under `GenHub/GenHub/Features/GameProfiles/`,
following the Pattern C modal convention: the owner VM constructs the window,
sets `DataContext`, sets `WindowStartupLocation=CenterOwner`, calls
`ShowDialog`, and the VM raises a `CloseRequested` event.
- In the share dialog, call `IProfileSharingService.ExportProfileToUriAsync` and
display the URI with a Copy action using `TopLevel.Clipboard.SetTextAsync` and
`INotificationService.ShowSuccess` feedback, matching the existing
`SettingsViewModel` clipboard pattern. Add a "Copy Discord Markdown" action that
copies a formatted snippet. Add an "Export .ghprofile File" action using
`StorageProvider.SaveFilePickerAsync` (matching the existing `SettingsViewModel`
save-picker pattern) that calls `ExportProfileToFileAsync`.
- Create `ImportProfileInspectionWindow.axaml`/`.axaml.cs` and
`ImportProfileInspectionViewModel` under `GenHub/GenHub/Features/GameProfiles/`,
conforming to the GenHub dark theme (glass cards, accent borders, badge tags).
Call `IProfileSharingService.InspectSharedProfileAsync` and bind the result to:
a header showing cover/name/target client, an editable profile name with
conflict indication, a manifest diff table with per-item status badges (`✅
CACHED` vs `⬇️ <size>`), a settings/launch-options summary, a
target-installation selector, and the total download requirement. Populate the
target-installation dropdown from `IGameInstallationService`, default it to
`MatchedGameInstallationId`, and disable the Import action when
`HasValidGameInstallation` is false. Show `SecurityWarnings` visibly. Handle
inspection failures (bad payload, 404, corrupted JSON) with a clear error state.
- On the "Import & Download" action, call
`IProfileSharingService.ImportSharedProfileAsync` with an
`IProgress<ContentAcquisitionProgress>` that updates per-manifest progress in
the modal. Reuse the `FormatProgressStatus` phase-formatting approach from
`PublisherCardViewModel`; promote it to a shared helper if it is reused
elsewhere. Factor the inline `ProgressBar` plus status `TextBlock` block from
`PublisherCardView.axaml` into a reusable `DownloadItemProgressView` control,
and use it for each per-manifest row.
- On successful import, send `ProfileCreatedMessage` (already handled by
`GameProfileLauncherViewModel.Receive`) and call
`INotificationService.ShowSuccess`. Add a `SelectedProfileId`/`IsHighlighted`
mechanism to `GameProfileLauncherViewModel`/`GameProfileItemViewModel` with
scroll-into-view handling, so the imported profile is highlighted on the
dashboard.
===============================================================================

Task: 5

Register the new services and ViewModels in the dependency injection setup, and
add the required test coverage.

- In `GenHub/GenHub/Infrastructure/DependencyInjection/GameProfileModule.cs`,
register `IProfileSharingService → ProfileSharingService` and the
remote-manifest fetcher, placed after the other `IProfileXxx` registrations.
- In the same module, register `ShareProfileDialogViewModel` and
`ImportProfileInspectionViewModel` as transient services, mirroring the pattern
used in `AppUpdateModule`.
- Register the Windows and Linux protocol registrars in their respective
platform service modules, and register the Linux single-instance substrate.
- In `GenHub.Tests.Core`, add unit tests for: `SharedGameProfilePackage`
serialization and round-trip, Brotli compression and decompression, Base64Url
encode and decode, the 64 KB payload guard,
`CommandLineParser.ExtractProfileShareUri`, and the shared argument-sanitization
helper (verify it accepts safe arguments and rejects injection characters and
traversal patterns).
- Add integration tests for `IProfileSharingService.InspectSharedProfileAsync`
that verify cached-vs-missing manifest classification,
`TotalDownloadBytesRequired` accumulation, installation matching, and
name-conflict detection.
- Add an integration test that verifies the executable-path exclusion and
command-argument sanitization produce `SecurityWarnings` and result in safe
imported profiles.

💡 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]

⚠️ Possible Duplicate Issue(s)

• Feature: GameProfile Import & Automatic Content Acquisition #93

🔗 Related PRs

#267 - feat: Implement copy profile functionality [merged]
#328 - feat(platform): make paths, manifests, and Unix workspaces platform-aware [merged]
#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]
#352 - feat(installations): detect retail installations by archive presence [open]
#374 - feat(userdata): deploy GeneralsOnline game data patch to user documents with safe backup and restore [merged]
#375 - feat(gameprofiles): enable runtime content hot-swapping for active game sessions [open]
#382 - fix(launching): only rewrite GeneralsOnline settings for GeneralsOnline profiles [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!