// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using Semver;
#if CLI
using NuGetPackage = Aspire.Shared.NuGetPackageCli;
#else
using NuGetPackage = Aspire.Shared.NuGetPackage;
#endif
namespace Aspire.Shared;
#if CLI
internal class NuGetPackageCli
#else
internal class NuGetPackage
#endif
{
public string Id { get; set; } = string.Empty;
public string Version { get; set; } = string.Empty;
public string Source { get; set; } = string.Empty;
}
internal static class PackageUpdateHelpers
{
public static SemVersion? GetCurrentPackageVersion()
{
try
{
var versionString = GetCurrentAssemblyVersion();
if (versionString == null)
{
return null;
}
// Remove any build metadata (e.g., +sha.12345) for comparison
var cleanVersionString = versionString.Split('+')[0];
return SemVersion.Parse(cleanVersionString, SemVersionStyles.Strict);
}
catch
{
return null;
}
}
public static string? GetCurrentAssemblyVersion()
{
// Write some code that gets the informational assembly version of the current assembly and returns it as a string.
var assembly = typeof(PackageUpdateHelpers).Assembly;
var informationalVersion = assembly
.GetCustomAttributes(typeof(System.Reflection.AssemblyInformationalVersionAttribute), false)
.OfType<System.Reflection.AssemblyInformationalVersionAttribute>()
.FirstOrDefault()?.InformationalVersion;
return informationalVersion;
}
public static SemVersion? GetNewerVersion(ILogger logger, SemVersion currentVersion, IEnumerable<NuGetPackage> availablePackages, SemVersion? storedVersion = null)
{
SemVersion? newestStable = null;
SemVersion? newestPrerelease = null;
foreach (var package in availablePackages)
{
if (SemVersion.TryParse(package.Version, SemVersionStyles.Strict, out var version))
{
ProcessNewVersion(version);
}
}
if (storedVersion != null)
{
ProcessNewVersion(storedVersion);
}
logger.LogDebug(
"""
Current version: {CurrentVersion}
Newest stable version: {NewestStableVersion}
Newest prerelease version: {NewestPrereleaseVersion}
""", currentVersion, newestStable, newestPrerelease);
// Apply notification rules
if (currentVersion.IsPrerelease)
{
// Rule 1: If using a prerelease version where the version is lower than the latest stable version, prompt to upgrade
if (newestStable is not null && SemVersion.PrecedenceComparer.Compare(currentVersion, newestStable) < 0)
{
logger.LogDebug("Current version {CurrentVersion} is prerelease and older than newest stable version {NewestStableVersion}.", currentVersion, newestStable);
return newestStable;
}
// Rule 2: If using a prerelease version and there is a newer prerelease version, prompt to upgrade
if (newestPrerelease is not null && SemVersion.PrecedenceComparer.Compare(currentVersion, newestPrerelease) < 0)
{
logger.LogDebug("Current version {CurrentVersion} is prerelease and older than newest prerelease version {NewestPrereleaseVersion}.", currentVersion, newestPrerelease);
return newestPrerelease;
}
}
else
{
// Rule 3: If using a stable version and there is a newer stable version, prompt to upgrade
if (newestStable is not null && SemVersion.PrecedenceComparer.Compare(currentVersion, newestStable) < 0)
{
logger.LogDebug("Current version {CurrentVersion} is stable and older than newest stable version {NewestStableVersion}.", currentVersion, newestStable);
return newestStable;
}
}
logger.LogDebug("No newer version for the current version {CurrentVersion}.", currentVersion);
return null;
void ProcessNewVersion(SemVersion version)
{
if (version.IsPrerelease)
{
newestPrerelease = newestPrerelease is null || SemVersion.PrecedenceComparer.Compare(version, newestPrerelease) > 0 ? version : newestPrerelease;
}
else
{
newestStable = newestStable is null || SemVersion.PrecedenceComparer.Compare(version, newestStable) > 0 ? version : newestStable;
}
}
}
public static List<NuGetPackage> ParsePackageSearchResults(string stdout, string? packageId = null)
=> ParsePackageSearchResults(stdout, out _, packageId);
public static List<NuGetPackage> ParsePackageSearchResults(string stdout, out IReadOnlyList<string> failedSources, string? packageId)
{
var foundPackages = new List<NuGetPackage>();
var sourceFailures = new List<string>();
failedSources = sourceFailures;
using var document = JsonDocument.Parse(ExtractJsonPayload(stdout, IsPackageSearchPayload));
if (!document.RootElement.TryGetProperty("searchResult", out var searchResultsArray))
{
return [];
}
foreach (var sourceResult in searchResultsArray.EnumerateArray())
{
var source = sourceResult.GetProperty("sourceName").GetString()!;
// SDK search can exit successfully with partial results:
// {"sourceName":"team","problems":[{"problemType":"Error","text":"..."}],"packages":[]}
// Keep the source identity, not diagnostic text that can contain credentials.
if (sourceResult.TryGetProperty("problems", out var problems) &&
problems.EnumerateArray().Any(problem =>
problem.TryGetProperty("problemType", out var problemType) && problemType.GetString() == "Error"))
{
sourceFailures.Add(source);
}
var sourcePackagesArray = sourceResult.GetProperty("packages");
foreach (var packageResult in sourcePackagesArray.EnumerateArray())
{
var id = packageResult.GetProperty("id").GetString()!;
var version = packageResult.TryGetProperty("latestVersion", out var latestVersionProp)
? latestVersionProp.GetString()!
: packageResult.GetProperty("version").GetString()!;
if (packageId == null || id == packageId)
{
foundPackages.Add(new NuGetPackage
{
Id = id,
Version = version,
Source = source
});
}
}
}
return foundPackages;
}
// `dotnet package search <id> --format json` is expected to write a single JSON object to stdout, but NuGet
// credential providers use an inherited stdout handle. Their diagnostics can therefore appear before or after
// the payload while the command still exits 0, and can themselves contain braces or complete JSON objects:
//
// [CredentialProvider]Acquiring token for request {42}
// {"error":{"packages":[]}}
// {"version":2,"problems":[],"searchResult":[{"sourceName":"azure-default","packages":[ ... ]}]}
// [CredentialProvider]VstsCredentialProvider - Acquired bearer token using 'MSAL Silent'
//
// Parse each complete object candidate and validate the expected payload shape so a diagnostic object cannot be
// mistaken for the payload. Return only the consumed object so trailing provider output is excluded.
// See https://github.com/microsoft/aspire/issues/19339.
internal static string ExtractJsonPayload(string stdout, Func<JsonElement, bool> isExpectedPayload)
{
var utf8 = Encoding.UTF8.GetBytes(stdout);
var searchOffset = 0;
while (searchOffset < utf8.Length)
{
var relativeCandidateOffset = utf8.AsSpan(searchOffset).IndexOf((byte)'{');
if (relativeCandidateOffset < 0)
{
break;
}
var candidateOffset = searchOffset + relativeCandidateOffset;
var candidate = utf8.AsSpan(candidateOffset);
var reader = new Utf8JsonReader(candidate);
try
{
if (JsonDocument.TryParseValue(ref reader, out var document) && document is not null)
{
var consumed = checked((int)reader.BytesConsumed);
using (document)
{
if (isExpectedPayload(document.RootElement))
{
return Encoding.UTF8.GetString(candidate[..consumed]);
}
}
// Do not inspect nested objects inside a complete diagnostic object. A nested object could
// coincidentally have the expected shape even though its containing diagnostic is not the payload.
searchOffset = candidateOffset + consumed;
continue;
}
}
catch (JsonException)
{
// A diagnostic can contain an unmatched brace or other non-JSON fragment. Advance past this brace
// and keep looking for the package-search payload.
}
searchOffset = candidateOffset + 1;
}
// Preserve the existing behavior when no expected payload is present: callers parse the original output
// and surface the same JsonException (or handle a valid object with no results) as before.
return stdout;
}
private static bool IsPackageSearchPayload(JsonElement root)
{
if (root.ValueKind != JsonValueKind.Object ||
!root.TryGetProperty("version", out var version) ||
version.ValueKind != JsonValueKind.Number ||
!root.TryGetProperty("searchResult", out var searchResults) ||
searchResults.ValueKind != JsonValueKind.Array)
{
return false;
}
foreach (var sourceResult in searchResults.EnumerateArray())
{
if (sourceResult.ValueKind != JsonValueKind.Object ||
!sourceResult.TryGetProperty("sourceName", out var sourceName) ||
sourceName.ValueKind != JsonValueKind.String ||
!sourceResult.TryGetProperty("packages", out var packages) ||
packages.ValueKind != JsonValueKind.Array)
{
return false;
}
}
return true;
}
}