Adding update command

src/D2L.Bmx/GithubRelease.cs

@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace D2L.Bmx;
+internal record GithubRelease {
+	[JsonPropertyName( "tag_name" )]
+	public string? TagName { get; set; }
+
+	[JsonPropertyName( "assets" )]
+	public List<Assets>? Assets { get; set; }
+}
+
+internal record Assets {
+	[JsonPropertyName( "url" )]
+	public string? Url { get; set; }
+
+	[JsonPropertyName( "name" )]
+	public string? Name { get; set; }
+
+	[JsonPropertyName( "browser_download_url" )]
+	public string? BrowserDownloadUrl { get; set; }
+}

src/D2L.Bmx/Program.cs

@@ -198,13 +198,20 @@
 	);
 } );
 
+var updateCommand = new Command( "update", "Updates BMX to the latest version" );
+updateCommand.SetHandler( ( InvocationContext context ) => {
+	var handler = new UpdateHandler();
+	return handler.HandleAsync();
+} );
+
 // root command
 var rootCommand = new RootCommand( "BMX grants you API access to your AWS accounts!" ) {
 	// put more frequently used commands first, as the order here affects help text
 	printCommand,
 	writeCommand,
 	loginCommand,
 	configureCommand,
+	updateCommand,
 };
 
 // start bmx
@@ -226,6 +233,7 @@
 				}
 			}
 
+			UpdateHandler.Cleanup();
 			await UpdateChecker.CheckForUpdatesAsync( configProvider.GetConfiguration() );
 
 			await next( context );

src/D2L.Bmx/UpdateChecker.cs

@@ -1,7 +1,6 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 
 namespace D2L.Bmx;
 
@@ -12,7 +11,7 @@ public static async Task CheckForUpdatesAsync( BmxConfig config ) {
 			var localVersion = Assembly.GetExecutingAssembly().GetName().Version;
 			var latestVersion = new Version( cachedVersion?.VersionName ?? "0.0.0" );
 			if( ShouldFetchLatestVersion( cachedVersion ) ) {
-				latestVersion = new Version( await GetLatestReleaseVersionAsync() );
+				latestVersion = new Version( GetLatestReleaseVersion( await GetLatestReleaseDataAsync() ) );
 			}
 
 			string updateLocation = string.Equals( config.Org, "d2l", StringComparison.OrdinalIgnoreCase )
@@ -49,7 +48,13 @@ private static void DisplayUpdateMessage( string message ) {
 		Console.Error.WriteLine();
 	}
 
-	private static async Task<string> GetLatestReleaseVersionAsync() {
+	internal static string GetLatestReleaseVersion( GithubRelease? releaseData ) {
+		string version = releaseData?.TagName?.TrimStart( 'v' ) ?? string.Empty;
+		SaveLatestVersion( version );
+		return version;
+	}
+
+	internal static async Task<GithubRelease?> GetLatestReleaseDataAsync() {
 		using var httpClient = new HttpClient();
 		httpClient.BaseAddress = new Uri( "https://api.github.com" );
 		httpClient.Timeout = TimeSpan.FromSeconds( 2 );
@@ -62,9 +67,7 @@ private static async Task<string> GetLatestReleaseVersionAsync() {
 			responseStream,
 			SourceGenerationContext.Default.GithubRelease
 		);
-		string version = releaseData?.TagName?.TrimStart( 'v' ) ?? string.Empty;
-		SaveLatestVersion( version );
-		return version;
+		return releaseData;
 	}
 
 	private static void SaveLatestVersion( string version ) {
@@ -112,10 +115,6 @@ private static bool ShouldFetchLatestVersion( UpdateCheckCache? cache ) {
 	}
 }
 
-internal record GithubRelease {
-	[JsonPropertyName( "tag_name" )]
-	public string? TagName { get; set; }
-}
 
 internal record UpdateCheckCache {
 	public string? VersionName { get; set; }

src/D2L.Bmx/UpdateHandler.cs

@@ -0,0 +1,136 @@
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using System.Formats.Tar;
+using System.Reflection;
+
+namespace D2L.Bmx;
+
+internal class UpdateHandler {
+
+	public async Task HandleAsync() {
+		using var httpClient = new HttpClient();
+		var releaseData = await UpdateChecker.GetLatestReleaseDataAsync();
+		var localVersion = Assembly.GetExecutingAssembly().GetName().Version;
+		var latestVersion = new Version( UpdateChecker.GetLatestReleaseVersion( releaseData ) );
+		if ( latestVersion <= localVersion ) {
+			Console.WriteLine( $"Already own the latest version {latestVersion}" );
+			return;
+		}
+		string archiveName = GetOSFileName();
+		string downloadUrl = releaseData?.Assets?.FirstOrDefault( a => a.Name == archiveName )?.BrowserDownloadUrl
+			?? string.Empty;
+		if( string.IsNullOrWhiteSpace( downloadUrl ) ) {
+			return;
+		}
+
+		string? downloadPath = Path.GetTempFileName();
+
+		try {
+			var archiveRes = await httpClient.GetAsync( downloadUrl, HttpCompletionOption.ResponseHeadersRead );
+			using( var fs = new FileStream( downloadPath, FileMode.Create, FileAccess.Write, FileShare.None ) ) {
+				await archiveRes.Content.CopyToAsync( fs );
+				await fs.FlushAsync();
+				fs.Dispose();
+			}
+		} catch	( Exception ex ) {
+			throw new BmxException( "Failed to download the update", ex );
+		}
+
+
+		string? currentProcessPath = Environment.ProcessPath;
+		string? currentProcessFileName = Path.GetFileNameWithoutExtension( currentProcessPath );
+		string? currentProcessExtention = Path.GetExtension( currentProcessPath );
+		string backupPath = $"{currentProcessFileName}v{localVersion}{currentProcessExtention}";
+
+		if( !string.IsNullOrEmpty( currentProcessPath ) ) {
+			File.Move( currentProcessPath, backupPath );
+		} else {
+			currentProcessPath = "C:/bin";
+		}
+
+		try {
+			string extension = Path.GetExtension( downloadUrl ).ToLowerInvariant();
+			string? extractPath = Path.GetDirectoryName( currentProcessPath );
+
+			if( extension.Equals( ".zip" ) ) {
+				DecompressZipFile( downloadPath, extractPath! );
+			} else if( extension.Equals( ".gz" ) ) {
+				DecompressTarGzipFile( downloadPath, extractPath! );
+			} else {
+				Console.WriteLine( extension );
+				throw new Exception( "Unknown archive type" );
+			}
+
+			string newExecutablePath = Path.Combine(
+				extractPath!,
+				Path.GetFileName( currentProcessPath )!
+			);
+			File.Move( newExecutablePath, currentProcessPath, overwrite: true );
+		} catch( Exception ex ) {
+			if (currentProcessPath != "C:/bin") {
+				File.Move( backupPath, currentProcessPath );
+			}
+			throw new BmxException( "Failed to update", ex );
+		}
+	}
+
+	private static string GetOSFileName() {
+
+		if( RuntimeInformation.IsOSPlatform( OSPlatform.Windows ) ) {
+			return "bmx-win-x64.zip";
+		} else if( RuntimeInformation.IsOSPlatform( OSPlatform.OSX ) ) {
+			return "bmx-osx-x64.tar.gz";
+		} else if( RuntimeInformation.IsOSPlatform( OSPlatform.Linux ) ) {
+			return "bmx-linux-x64.tar.gz";
+		} else {
+			throw new Exception( "Unknown OS" );
+		}
+	}
+
+	public static void Cleanup() {
+		string processDirectory = Path.GetDirectoryName( Environment.ProcessPath ) ?? string.Empty;
+		if( string.IsNullOrEmpty( processDirectory ) ) {
+			return;
+		}
+
+		Console.WriteLine( $"Cleaning up old binaries in {processDirectory}" );
+		foreach( string file in Directory.GetFiles( processDirectory, "*.old.bak" ) ) {
+			try {
+				Console.WriteLine( $"Cleaning up {file}" );
+				File.Delete( file );
+			} catch( Exception ex ) {
+				Console.WriteLine( $"Failed to delete old binary {file}: {ex.Message}" );
+			}
+		}
+	}
+
+	private static void DecompressTarGzipFile( string compressedFilePath, string decompressedFilePath ) {
+		string? tarPath = Path.Combine(
+			Path.GetDirectoryName( decompressedFilePath )!,
+			Path.GetFileNameWithoutExtension( decompressedFilePath )! + ".tar" );
+
+		using( FileStream compressedFileStream = File.Open(
+			compressedFilePath,
+			FileMode.Open,
+			FileAccess.Read,
+			FileShare.Read )
+		) {
+			using FileStream outputFileStream = File.Create( tarPath );
+			using var decompressor = new GZipStream( compressedFileStream, CompressionMode.Decompress );
+			decompressor.CopyTo( outputFileStream );
+		}
+
+		TarFile.ExtractToDirectory( tarPath, decompressedFilePath, true );
+	}
+
+	private static void DecompressZipFile( string compressedFilePath, string decompressedFilePath ) {
+		using( ZipArchive archive = ZipFile.OpenRead( compressedFilePath ) ) {
+			foreach( ZipArchiveEntry entry in archive.Entries ) {
+				string? destinationPath = Path.GetFullPath( Path.Combine( decompressedFilePath!, entry.FullName ) );
+				if( destinationPath.StartsWith( decompressedFilePath!, StringComparison.Ordinal ) ) {
+					entry.ExtractToFile( destinationPath, overwrite: true );
+				}
+			}
+		}
+	}
+}