[WIP] selfcontained.

Author: azchohfi

src/winsdk-CLI/Winsdk.Cli/Commands/MsixPackageCommand.cs

@@ -52,6 +52,10 @@ public MsixPackageCommand()
         {
             Description = "Publisher name for certificate generation"
         };
+        var selfContainedOption = new Option<bool>("--self-contained")
+        {
+            Description = "Bundle Windows App SDK runtime for self-contained deployment"
+        };
 
         Options.Add(nameOption);
         Options.Add(skipPriOption);
@@ -60,6 +64,7 @@ public MsixPackageCommand()
         Options.Add(generateCertOption);
         Options.Add(installCertOption);
         Options.Add(publisherOption);
+        Options.Add(selfContainedOption);
         Options.Add(Program.VerboseOption);
 
         SetAction(async (parseResult, ct) =>
@@ -73,6 +78,7 @@ public MsixPackageCommand()
             var generateCert = parseResult.GetValue(generateCertOption);
             var installCert = parseResult.GetValue(installCertOption);
             var publisher = parseResult.GetValue(publisherOption);
+            var selfContained = parseResult.GetValue(selfContainedOption);
             var verbose = parseResult.GetValue(Program.VerboseOption);
 
             try
@@ -82,7 +88,7 @@ public MsixPackageCommand()
 
                 var msix = new MsixService();
 
-                var result = await msix.CreateMsixPackageAsync(inputFolder, outputFolder, name, skipPri, autoSign, certPath, certPassword, generateCert, installCert, publisher, verbose, ct);
+                var result = await msix.CreateMsixPackageAsync(inputFolder, outputFolder, name, skipPri, autoSign, certPath, certPassword, generateCert, installCert, publisher, selfContained, verbose, ct);
 
                 Console.WriteLine("✅ MSIX package created successfully!");
 

src/winsdk-CLI/Winsdk.Cli/Services/MsixService.cs

@@ -1,3 +1,4 @@
+using System.IO.Compression;
 using System.Reflection;
 using System.Security;
 using System.Text;
@@ -8,6 +9,75 @@ namespace Winsdk.Cli;
 
 internal sealed class MsixService
 {
+    /// <summary>
+    /// Sets up Windows App SDK for self-contained deployment by extracting MSIX content
+    /// and preparing the necessary files for embedding in applications.
+    /// </summary>
+    public async Task SetupSelfContainedAsync(string winsdkDir, string packagesDir, string wasdkVersion, string architecture, bool verbose, CancellationToken cancellationToken = default)
+    {
+        // Look for the Runtime package which contains the MSIX files
+        var runtimePackageDir = Path.Combine(packagesDir, $"Microsoft.WindowsAppSDK.Runtime.{wasdkVersion}");
+        if (!Directory.Exists(runtimePackageDir))
+        {
+            throw new DirectoryNotFoundException($"Windows App SDK Runtime package directory not found: {runtimePackageDir}");
+        }
+
+        var selfContainedDir = Path.Combine(winsdkDir, "self-contained");
+        Directory.CreateDirectory(selfContainedDir);
+
+        var archSelfContainedDir = Path.Combine(selfContainedDir, architecture);
+        Directory.CreateDirectory(archSelfContainedDir);
+
+        // Look for the MSIX file in the tools/MSIX folder
+        var msixToolsDir = Path.Combine(runtimePackageDir, "tools", "MSIX", $"win10-{architecture}");
+        if (!Directory.Exists(msixToolsDir))
+        {
+            throw new DirectoryNotFoundException($"MSIX tools directory not found: {msixToolsDir}");
+        }
+
+        var msixFiles = Directory.GetFiles(msixToolsDir, "Microsoft.WindowsAppRuntime.*.msix");
+        if (msixFiles.Length == 0)
+        {
+            throw new FileNotFoundException($"No MSIX files found in {msixToolsDir}");
+        }
+
+        // Use the main MSIX file (not DDLM or Singleton)
+        var msixPath = msixFiles.FirstOrDefault(f => Path.GetFileName(f).Contains("Main")) ?? msixFiles[0];
+
+        if (verbose)
+        {
+            Console.WriteLine($"  {UiSymbols.Package} Extracting MSIX: {Path.GetFileName(msixPath)}");
+        }
+
+        // Extract MSIX content
+        var extractedDir = Path.Combine(archSelfContainedDir, "extracted");
+        if (Directory.Exists(extractedDir))
+        {
+            Directory.Delete(extractedDir, true);
+        }
+        Directory.CreateDirectory(extractedDir);
+
+        using (var archive = ZipFile.OpenRead(msixPath))
+        {
+            archive.ExtractToDirectory(extractedDir);
+        }
+
+        // Copy relevant files to deployment directory
+        var deploymentDir = Path.Combine(archSelfContainedDir, "deployment");
+        Directory.CreateDirectory(deploymentDir);
+
+        // Copy DLLs, WinMD files, and other runtime assets
+        await CopyRuntimeFilesAsync(extractedDir, deploymentDir, verbose);
+
+        // Generate self-contained manifest template using embedded template
+        await GenerateSelfContainedManifestTemplateAsync(archSelfContainedDir, verbose, cancellationToken);
+
+        if (verbose)
+        {
+            Console.WriteLine($"  {UiSymbols.Check} Self-contained files prepared in: {archSelfContainedDir}");
+        }
+    }
+
     public async Task GenerateMsixAssetsAsync(bool isSparse, string outputDir, string? packageName, string? publisherName, string description, string version, string? executable, CancellationToken cancellationToken = default)
     {
         var defaults = new SystemDefaultsService();
@@ -349,6 +419,7 @@ public async Task<CreateMsixPackageResult> CreateMsixPackageAsync(
         bool generateDevCert = false, 
         bool installDevCert = false, 
         string? publisher = null, 
+        bool selfContained = false,
         bool verbose = true,
         CancellationToken cancellationToken = default)
     {
@@ -419,6 +490,17 @@ public async Task<CreateMsixPackageResult> CreateMsixPackageAsync(
                 await GeneratePriFileAsync(inputFolder, verbose: verbose, cancellationToken: cancellationToken);
             }
 
+            // Handle self-contained deployment if requested
+            if (selfContained)
+            {
+                if (verbose)
+                {
+                    Console.WriteLine($"{UiSymbols.Package} Preparing self-contained Windows App SDK runtime...");
+                }
+
+                await PrepareRuntimeForPackagingAsync(inputFolder, verbose, cancellationToken);
+            }
+
             // Create MSIX package
             var makeappxArguments = $@"pack /o /d ""{inputFolder}"" /nv /p ""{outputMsixPath}""";
 
@@ -541,6 +623,201 @@ private static string ToCamelCase(string name)
         return sb.ToString();
     }
 
+    private Task CopyRuntimeFilesAsync(string extractedDir, string deploymentDir, bool verbose)
+    {
+        var patterns = new[] { "*.dll", "*.winmd", "*.mui", "*.pri" };
+
+        foreach (var pattern in patterns)
+        {
+            var files = Directory.GetFiles(extractedDir, pattern, SearchOption.AllDirectories);
+            foreach (var file in files)
+            {
+                var relativePath = Path.GetRelativePath(extractedDir, file);
+                var destPath = Path.Combine(deploymentDir, relativePath);
+
+                // Create destination directory if needed
+                var destDir = Path.GetDirectoryName(destPath);
+                if (!string.IsNullOrEmpty(destDir))
+                {
+                    Directory.CreateDirectory(destDir);
+                }
+
+                File.Copy(file, destPath, overwrite: true);
+                
+                if (verbose)
+                {
+                    Console.WriteLine($"    {UiSymbols.Files} {relativePath}");
+                }
+            }
+        }
+        return Task.CompletedTask;
+    }
+
+    private async Task GenerateSelfContainedManifestTemplateAsync(string outputDir, bool verbose, CancellationToken cancellationToken)
+    {
+        var templateResName = FindResourceEnding(".Templates.app.manifest.selfcontained.xml")
+                              ?? throw new FileNotFoundException("Self-contained manifest template not found in embedded resources");
+        
+        // Use embedded template
+        var asm = Assembly.GetExecutingAssembly();
+        string template;
+        await using (var s = asm.GetManifestResourceStream(templateResName) ?? throw new FileNotFoundException(templateResName))
+        using (var sr = new StreamReader(s, Encoding.UTF8))
+        {
+            template = await sr.ReadToEndAsync(cancellationToken);
+        }
+
+        var manifestTemplatePath = Path.Combine(outputDir, "app.manifest.template");
+        await File.WriteAllTextAsync(manifestTemplatePath, template, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false), cancellationToken);
+        
+        if (verbose)
+        {
+            Console.WriteLine($"  {UiSymbols.Files} Generated manifest template: {Path.GetFileName(manifestTemplatePath)}");
+        }
+    }
+
+    /// <summary>
+    /// Prepares Windows App SDK runtime files for packaging into an MSIX by extracting them to the input folder
+    /// </summary>
+    private async Task PrepareRuntimeForPackagingAsync(string inputFolder, bool verbose, CancellationToken cancellationToken)
+    {
+        // Find .winsdk directory to determine where packages are installed
+        var currentDir = Directory.GetCurrentDirectory();
+        var winsdkDir = BuildToolsService.FindWinsdkDirectory(currentDir);
+        var pkgsDir = Path.Combine(winsdkDir, "packages");
+
+        if (!Directory.Exists(pkgsDir))
+        {
+            throw new DirectoryNotFoundException($"Packages directory not found: {pkgsDir}. Please run 'winsdk setup' first.");
+        }
+
+        // Find Windows App SDK package
+        var wasdkPattern = "Microsoft.WindowsAppSDK.*";
+        var wasdkDirs = Directory.GetDirectories(pkgsDir, wasdkPattern);
+        
+        if (wasdkDirs.Length == 0)
+        {
+            throw new DirectoryNotFoundException($"Windows App SDK package not found in {pkgsDir}. Please run 'winsdk setup' first.");
+        }
+
+        var wasdkDir = wasdkDirs.OrderByDescending(d => d).First(); // Get the latest version
+        var wasdkVersion = Path.GetFileName(wasdkDir).Replace("Microsoft.WindowsAppSDK.", "");
+        
+        // Check if there's a specific Runtime package - use that version instead
+        var runtimePattern = "Microsoft.WindowsAppSDK.Runtime.*";
+        var runtimeDirs = Directory.GetDirectories(pkgsDir, runtimePattern);
+        if (runtimeDirs.Length > 0)
+        {
+            var runtimeDir = runtimeDirs.OrderByDescending(d => d).First();
+            wasdkVersion = Path.GetFileName(runtimeDir).Replace("Microsoft.WindowsAppSDK.Runtime.", "");
+        }
+
+        if (verbose)
+        {
+            Console.WriteLine($"{UiSymbols.Package} Found Windows App SDK {wasdkVersion}");
+        }
+
+        // Determine target architecture - for now use x64, but this could be made configurable
+        var arch = "x64";
+        
+        // Create temporary directory for runtime files
+        var tempRuntimeDir = Path.Combine(Path.GetTempPath(), "winsdk-runtime-temp", Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempRuntimeDir);
+
+        try
+        {
+            // Extract runtime files using the existing method
+            await SetupSelfContainedAsync(winsdkDir, pkgsDir, wasdkVersion, arch, verbose, cancellationToken);
+
+            // Copy runtime files from .winsdk/self-contained to input folder
+            var runtimeSourceDir = Path.Combine(winsdkDir, "self-contained", arch, "deployment");
+            var runtimeDestDir = Path.Combine(inputFolder, "WinAppSDK");
+
+            if (Directory.Exists(runtimeSourceDir))
+            {
+                Directory.CreateDirectory(runtimeDestDir);
+                
+                foreach (var file in Directory.GetFiles(runtimeSourceDir))
+                {
+                    var destFile = Path.Combine(runtimeDestDir, Path.GetFileName(file));
+                    File.Copy(file, destFile, overwrite: true);
+                    
+                    if (verbose)
+                    {
+                        Console.WriteLine($"{UiSymbols.Folder} Bundled runtime: {Path.GetFileName(file)}");
+                    }
+                }
+
+                if (verbose)
+                {
+                    Console.WriteLine($"{UiSymbols.Check} Windows App SDK runtime bundled into package");
+                }
+            }
+            else
+            {
+                throw new DirectoryNotFoundException($"Runtime files not found at {runtimeSourceDir}");
+            }
+        }
+        finally
+        {
+            // Clean up temp directory
+            if (Directory.Exists(tempRuntimeDir))
+            {
+                Directory.Delete(tempRuntimeDir, recursive: true);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Cleans and sanitizes a package name to meet MSIX AppxManifest schema requirements.
+    /// Based on ST_PackageName type which restricts ST_AsciiIdentifier.
+    /// </summary>
+    /// <param name="packageName">The package name to clean</param>
+    /// <returns>A cleaned package name that meets MSIX schema requirements</returns>
+    private static string CleanPackageName(string packageName)
+    {
+        if (string.IsNullOrWhiteSpace(packageName))
+        {
+            return "DefaultPackage";
+        }
+
+        // Trim whitespace
+        var cleaned = packageName.Trim();
+
+        // Remove invalid characters (keep only letters, numbers, hyphens, underscores, periods, and spaces)
+        // ST_AllowedAsciiCharSet pattern="[-_. A-Za-z0-9]+"
+        cleaned = Regex.Replace(cleaned, @"[^A-Za-z0-9\-_. ]", "");
+
+        // Remove leading underscores (ST_AsciiIdentifier restriction)
+        cleaned = cleaned.TrimStart('_');
+
+        // If still empty or whitespace after cleaning, use default
+        if (string.IsNullOrWhiteSpace(cleaned))
+        {
+            cleaned = "DefaultPackage";
+        }
+
+        // Ensure minimum length of 3 characters
+        if (cleaned.Length < 3)
+        {
+            cleaned = cleaned.PadRight(3, '1'); // Pad with '1' to reach minimum length
+        }
+
+        // Truncate to maximum length of 50 characters
+        if (cleaned.Length > 50)
+        {
+            cleaned = cleaned.Substring(0, 50).TrimEnd(); // Trim end in case we cut off mid-word
+        }
+
+        // Final check: ensure it doesn't start with underscore after all transformations
+        if (cleaned.StartsWith('_'))
+        {
+            cleaned = string.Concat("App", cleaned.AsSpan(1));
+        }
+
+        return cleaned;
+    }
+
     private static string? FindResourceEnding(string endsWith)
     {
         var asm = Assembly.GetExecutingAssembly();

src/winsdk-CLI/Winsdk.Cli/Templates/app.manifest.selfcontained.xml

@@ -0,0 +1,28 @@
+<?xml version='1.0' encoding='utf-8' standalone='yes'?>
+<assembly manifestVersion='1.0'
+    xmlns:asmv3='urn:schemas-microsoft-com:asm.v3'
+    xmlns:winrtv1='urn:schemas-microsoft-com:winrt.v1'
+    xmlns='urn:schemas-microsoft-com:asm.v1'>
+    
+    <!-- 
+    This is a template for Windows App SDK self-contained deployment.
+    
+    To use this template:
+    1. Copy this file to your project as app.manifest
+    2. Update the assembly identity information as needed
+    3. Add references to your WinRT components if any
+    4. Include the deployment files from the deployment/ folder in your application
+    
+    For complete setup, see the Microsoft.WindowsAppSDK.SelfContained.targets file.
+    -->
+    
+    <assemblyIdentity version="1.0.0.0" name="YourApp.exe" type="win32"/>
+    
+    <!-- Windows App SDK Runtime Files -->
+    <!-- Add asmv3:file entries for each DLL in the deployment folder -->
+    <!-- Example:
+    <asmv3:file name='Microsoft.WindowsAppRuntime.dll'/>
+    <asmv3:file name='Microsoft.WindowsAppRuntime.Bootstrap.dll'/>
+    -->
+    
+</assembly>