Merge pull request #58 from microsoft/main

Pulling in .net fixes for fusion manifest

Author: hamza-usmani

README.md

@@ -60,6 +60,39 @@ This command will:
 
 > **Tip:** Modify `winsdk.yaml` to change SDK versions, then run `winsdk init` or `winsdk restore` to update your project.
 
+### Hosted Apps (Python/Node.js scripts)
+
+The CLI supports packaging Python and Node.js scripts as MSIX packages using the [Hosted App model](https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/hosted-apps). This allows your scripts to gain Windows app identity and capabilities without bundling a full runtime.
+
+#### Generate a Hosted App manifest
+
+```bash
+winsdk manifest generate --template hostedapp --entrypoint app.py
+```
+
+This command will:
+* ✅ Create an `appxmanifest.xml` configured for hosted apps
+* ✅ Auto-detect the script type (Python `.py` or JavaScript `.js`)
+* ✅ Configure the appropriate host runtime dependency (Python314 or Nodejs22)
+* ✅ Generate required assets in the `Assets` folder
+
+**Supported script types:**
+- **Python scripts** (`.py`) - Uses Python314 host runtime
+- **JavaScript/Node.js scripts** (`.js`) - Uses Nodejs22 host runtime
+
+#### Debug identity for hosted apps
+
+You can also create debug identity for hosted apps to test them without full MSIX packaging:
+
+```bash
+# Generate hosted app manifest
+winsdk manifest generate --template hostedapp --entrypoint app.py
+
+# Create debug identity (registers as a sparse package)
+winsdk create-debug-identity
+```
+
+> **Note:** The hosted app model requires the appropriate runtime (Python 3.14+ or Node.js 22+) to be installed on the target system. The manifest specifies this as a runtime dependency.
 
 ### Generate app identity
 

src/winsdk-CLI/Winsdk.Cli.Tests/ManifestCommandTests.cs

@@ -106,7 +106,7 @@ public async Task ManifestGenerateCommandWithCustomOptionsShouldUseThoseValues()
             "--publisher-name", "CN=TestPublisher",
             "--version", "2.0.0.0",
             "--description", "Test Application",
-            "--executable", "TestApp.exe",
+            "--entrypoint", "TestApp.exe",
             "--yes" // Skip interactive prompts
         };
 
@@ -138,7 +138,7 @@ public async Task ManifestGenerateCommandWithSparseOptionShouldCreateSparseManif
         var args = new[]
         {
             _tempDirectory,
-            "--sparse",
+            "--template", "sparse",
             "--yes" // Skip interactive prompts
         };
 
@@ -222,8 +222,8 @@ public void ManifestGenerateCommandParseArgumentsShouldHandleAllOptions()
             "--publisher-name", "CN=TestPub",
             "--version", "1.2.3.4",
             "--description", "Test Description",
-            "--executable", "test.exe",
-            "--sparse",
+            "--entrypoint", "test.exe",
+            "--template", "sparse",
             "--logo-path", "/test/logo.png",
             "--yes",
             "--verbose"
@@ -356,4 +356,153 @@ public void ManifestGenerateCommandHelpShouldDisplayCorrectInformation()
         Assert.IsNotNull(parseResult, "Parse result should not be null");
         // The help option should be recognized and not produce errors
     }
+
+    [TestMethod]
+    public async Task ManifestGenerateCommandWithHostedAppTemplateShouldCreateHostedAppManifest()
+    {
+        // Arrange - Create a Python script file
+        var pythonScriptPath = Path.Combine(_tempDirectory, "app.py");
+        await File.WriteAllTextAsync(pythonScriptPath, "# Python script\nprint('Hello, World!')");
+
+        var generateCommand = GetRequiredService<ManifestGenerateCommand>();
+        var args = new[]
+        {
+            _tempDirectory,
+            "--template", "hostedapp",
+            "--entrypoint", "app.py"
+        };
+
+        // Act
+        var parseResult = generateCommand.Parse(args);
+        var exitCode = await parseResult.InvokeAsync();
+
+        // Assert
+        Assert.AreEqual(0, exitCode, "Generate command should complete successfully");
+
+        // Verify manifest was created
+        var manifestPath = Path.Combine(_tempDirectory, "appxmanifest.xml");
+        Assert.IsTrue(File.Exists(manifestPath), "AppxManifest.xml should be created");
+
+        // Verify hosted app specific content
+        var manifestContent = await File.ReadAllTextAsync(manifestPath);
+        Assert.Contains("uap10:HostId", manifestContent, "HostedApp manifest should contain HostId");
+        Assert.Contains("uap10:Parameters", manifestContent, "HostedApp manifest should contain Parameters");
+        Assert.Contains("uap10:HostRuntimeDependency", manifestContent, "HostedApp manifest should contain HostRuntimeDependency");
+        Assert.Contains("Python314", manifestContent, "HostedApp manifest should reference Python314 host");
+        Assert.Contains("app.py", manifestContent, "HostedApp manifest should reference the Python script");
+    }
+
+    [TestMethod]
+    public async Task CreateDebugIdentityForHostedAppShouldSucceed()
+    {
+        // Arrange - Create a Python script file and manifest
+        var pythonScriptPath = Path.Combine(_tempDirectory, "app.py");
+        await File.WriteAllTextAsync(pythonScriptPath, "# Python script\nprint('Hello, World!')");
+
+        // First, generate a hosted app manifest
+        var generateCommand = GetRequiredService<ManifestGenerateCommand>();
+        var generateArgs = new[]
+        {
+            _tempDirectory,
+            "--template", "hostedapp",
+            "--entrypoint", "app.py"
+        };
+
+        var generateParseResult = generateCommand.Parse(generateArgs);
+        var generateExitCode = await generateParseResult.InvokeAsync();
+        Assert.AreEqual(0, generateExitCode, "Manifest generation should succeed");
+
+        var manifestPath = Path.Combine(_tempDirectory, "appxmanifest.xml");
+        Assert.IsTrue(File.Exists(manifestPath), "Manifest should exist");
+
+        // Act - Create debug identity
+        var debugIdentityCommand = GetRequiredService<CreateDebugIdentityCommand>();
+        var debugArgs = new[]
+        {
+            pythonScriptPath,
+            "--manifest", manifestPath,
+            "--no-install" // Skip actual installation in test
+        };
+
+        var debugParseResult = debugIdentityCommand.Parse(debugArgs);
+        var debugExitCode = await debugParseResult.InvokeAsync();
+
+        // Assert
+        Assert.AreEqual(0, debugExitCode, "Create debug identity should complete successfully");
+    }
+
+    [TestMethod]
+    public async Task ManifestGenerateCommandWithHostedAppTemplateAndJavaScriptShouldSucceed()
+    {
+        // Arrange - Create a JavaScript file
+        var jsScriptPath = Path.Combine(_tempDirectory, "app.js");
+        await File.WriteAllTextAsync(jsScriptPath, "// JavaScript\nconsole.log('Hello, World!');");
+
+        var generateCommand = GetRequiredService<ManifestGenerateCommand>();
+        var args = new[]
+        {
+            _tempDirectory,
+            "--template", "hostedapp",
+            "--entrypoint", "app.js"
+        };
+
+        // Act
+        var parseResult = generateCommand.Parse(args);
+        var exitCode = await parseResult.InvokeAsync();
+
+        // Assert
+        Assert.AreEqual(0, exitCode, "Generate command should complete successfully");
+
+        // Verify manifest was created
+        var manifestPath = Path.Combine(_tempDirectory, "appxmanifest.xml");
+        Assert.IsTrue(File.Exists(manifestPath), "AppxManifest.xml should be created");
+
+        // Verify hosted app specific content for Node.js
+        var manifestContent = await File.ReadAllTextAsync(manifestPath);
+        Assert.Contains("Nodejs22", manifestContent, "HostedApp manifest should reference Nodejs22 host");
+        Assert.Contains("app.js", manifestContent, "HostedApp manifest should reference the JavaScript file");
+    }
+
+    [TestMethod]
+    public async Task ManifestGenerateCommandWithHostedAppTemplateAndNonExistentEntryShouldFail()
+    {
+        // Arrange - Don't create the Python file
+        var generateCommand = GetRequiredService<ManifestGenerateCommand>();
+        var args = new[]
+        {
+            _tempDirectory,
+            "--template", "hostedapp",
+            "--entrypoint", "nonexistent.py"
+        };
+
+        // Act
+        var parseResult = generateCommand.Parse(args);
+        var exitCode = await parseResult.InvokeAsync();
+
+        // Assert
+        Assert.AreNotEqual(0, exitCode, "Generate command should fail when entry point file doesn't exist");
+    }
+
+    [TestMethod]
+    public async Task ManifestGenerateCommandWithHostedAppTemplateAndUnsupportedTypeShouldFail()
+    {
+        // Arrange - Create a file with unsupported extension
+        var unsupportedFilePath = Path.Combine(_tempDirectory, "app.exe");
+        await File.WriteAllTextAsync(unsupportedFilePath, "fake exe content");
+
+        var generateCommand = GetRequiredService<ManifestGenerateCommand>();
+        var args = new[]
+        {
+            _tempDirectory,
+            "--template", "hostedapp",
+            "--entrypoint", "app.exe"
+        };
+
+        // Act
+        var parseResult = generateCommand.Parse(args);
+        var exitCode = await parseResult.InvokeAsync();
+
+        // Assert
+        Assert.AreNotEqual(0, exitCode, "Generate command should fail for unsupported hosted app entry point type");
+    }
 }

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

@@ -11,16 +11,17 @@ namespace Winsdk.Cli.Commands;
 
 internal class CreateDebugIdentityCommand : Command
 {
-    public static Argument<string> ExecutableArgument { get; }
+    public static Argument<string> EntryPointArgument { get; }
     public static Option<string> ManifestOption { get; }
     public static Option<bool> NoInstallOption { get; }
     public static Option<string> LocationOption { get; }
 
     static CreateDebugIdentityCommand()
     {
-        ExecutableArgument = new Argument<string>("executable")
+        EntryPointArgument = new Argument<string>("entrypoint")
         {
-            Description = "Path to the .exe that will need to run with identity"
+            Description = "Path to the .exe that will need to run with identity, or entrypoint script.",
+            Arity = ArgumentArity.ZeroOrOne
         };
         ManifestOption = new Option<string>("--manifest")
         {
@@ -39,7 +40,7 @@ static CreateDebugIdentityCommand()
 
     public CreateDebugIdentityCommand() : base("create-debug-identity", "Create and install a temporary package for debugging. Must be called every time the appxmanifest.xml is modified for changes to take effect.")
     {
-        Arguments.Add(ExecutableArgument);
+        Arguments.Add(EntryPointArgument);
         Options.Add(ManifestOption);
         Options.Add(NoInstallOption);
         Options.Add(LocationOption);
@@ -49,20 +50,20 @@ public class Handler(IMsixService msixService, ILogger<CreateDebugIdentityComman
     {
         public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
         {
-            var executablePath = parseResult.GetRequiredValue(ExecutableArgument);
+            var entryPointPath = parseResult.GetValue(EntryPointArgument);
             var manifest = parseResult.GetRequiredValue(ManifestOption);
             var noInstall = parseResult.GetValue(NoInstallOption);
             var location = parseResult.GetValue(LocationOption);
 
-            if (!File.Exists(executablePath))
+            if (entryPointPath != null && !File.Exists(entryPointPath))
             {
-                logger.LogError("Executable not found: {ExecutablePath}", executablePath);
+                logger.LogError("EntryPoint/Executable not found: {EntryPointPath}", entryPointPath);
                 return 1;
             }
 
             try
             {
-                var result = await msixService.AddMsixIdentityToExeAsync(executablePath, manifest, noInstall, location, cancellationToken);
+                var result = await msixService.AddMsixIdentityAsync(entryPointPath, manifest, noInstall, location, cancellationToken);
 
                 logger.LogInformation("{UISymbol} MSIX identity added successfully!", UiSymbols.Check);
                 logger.LogInformation("{UISymbol} Package: {PackageName}", UiSymbols.Package, result.PackageName);

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

@@ -5,6 +5,7 @@
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using Winsdk.Cli.Helpers;
+using Winsdk.Cli.Models;
 using Winsdk.Cli.Services;
 
 namespace Winsdk.Cli.Commands;
@@ -16,8 +17,8 @@ internal class ManifestGenerateCommand : Command
     public static Option<string> PublisherNameOption { get; }
     public static Option<string> VersionOption { get; }
     public static Option<string> DescriptionOption { get; }
-    public static Option<string?> ExecutableOption { get; }
-    public static Option<bool> SparseOption { get; }
+    public static Option<string?> EntryPointOption { get; }
+    public static Option<ManifestTemplates> TemplateOption { get; }
     public static Option<string?> LogoPathOption { get; }
     public static Option<bool> YesOption { get; }
 
@@ -52,14 +53,15 @@ static ManifestGenerateCommand()
             DefaultValueFactory = (argumentResult) => "My Application"
         };
 
-        ExecutableOption = new Option<string?>("--executable")
+        EntryPointOption = new Option<string?>("--entrypoint", "--executable")
         {
-            Description = "Executable path/name (default: <package-name>.exe)"
+            Description = "Entry point of the application (e.g., executable path / name, or .py/.js script if template is HostedApp). Default: <package-name>.exe"
         };
 
-        SparseOption = new Option<bool>("--sparse")
+        TemplateOption = new Option<ManifestTemplates>("--template")
         {
-            Description = "Generate sparse package manifest"
+            Description = "Generate manifest using specified template",
+            DefaultValueFactory = (argumentResult) => ManifestTemplates.Packaged
         };
 
         LogoPathOption = new Option<string?>("--logo-path")
@@ -80,8 +82,8 @@ public ManifestGenerateCommand() : base("generate", "Generate a manifest in dire
         Options.Add(PublisherNameOption);
         Options.Add(VersionOption);
         Options.Add(DescriptionOption);
-        Options.Add(ExecutableOption);
-        Options.Add(SparseOption);
+        Options.Add(EntryPointOption);
+        Options.Add(TemplateOption);
         Options.Add(LogoPathOption);
         Options.Add(YesOption);
     }
@@ -95,8 +97,8 @@ public override async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
             var publisherName = parseResult.GetValue(PublisherNameOption);
             var version = parseResult.GetRequiredValue(VersionOption);
             var description = parseResult.GetRequiredValue(DescriptionOption);
-            var executable = parseResult.GetValue(ExecutableOption);
-            var sparse = parseResult.GetValue(SparseOption);
+            var entryPoint = parseResult.GetValue(EntryPointOption);
+            var template = parseResult.GetValue(TemplateOption);
             var logoPath = parseResult.GetValue(LogoPathOption);
             var yes = parseResult.GetValue(YesOption);
             try
@@ -107,8 +109,8 @@ await manifestService.GenerateManifestAsync(
                     publisherName,
                     version,
                     description,
-                    executable,
-                    sparse,
+                    entryPoint,
+                    template,
                     logoPath,
                     yes,
                     cancellationToken);

src/winsdk-CLI/Winsdk.Cli/Models/ManifestTemplates.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace Winsdk.Cli.Models;
+
+public enum ManifestTemplates
+{
+    Packaged,
+    Sparse,
+    HostedApp
+}

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

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Winsdk.Cli.Models;
+
 namespace Winsdk.Cli.Services;
 
 internal interface IManifestService
@@ -11,8 +13,8 @@ public Task GenerateManifestAsync(
         string? publisherName,
         string version,
         string description,
-        string? executable,
-        bool sparse,
+        string? entryPoint,
+        ManifestTemplates manifestTemplate,
         string? logoPath,
         bool yes,
         CancellationToken cancellationToken = default);