feat(windows): release

Author: triniwiz

lib/commands/build.ts

@@ -1,6 +1,8 @@
 import {
 	ANDROID_RELEASE_BUILD_ERROR_MESSAGE,
 	AndroidAppBundleMessages,
+	WINDOWS_RELEASE_UNSIGNED_MESSAGE,
+	WindowsAppPackageMessages,
 } from "../constants";
 import { ValidatePlatformCommandBase } from "./command-base";
 import { hasValidAndroidSigning } from "../common/helpers";
@@ -310,6 +312,10 @@ export class BuildWindowsCommand extends BuildCommandBase implements ICommand {
 		await this.executeCore([
 			this.$devicePlatformsConstants.Windows.toLowerCase(),
 		]);
+
+		if (this.$options.release && this.$options.storeUpload) {
+			this.$logger.info(WindowsAppPackageMessages.STORE_UPLOAD_DOCS_MESSAGE);
+		}
 	}
 
 	public async canExecute(args: string[]): Promise<boolean> {
@@ -323,6 +329,17 @@ export class BuildWindowsCommand extends BuildCommandBase implements ICommand {
 
 		let canExecute = await super.canExecuteCommandBase(platform);
 		if (canExecute) {
+			// A sideload release package without signing material can be produced,
+			// but it won't be installable until signed — warn rather than fail.
+			if (
+				this.$options.release &&
+				!this.$options.storeUpload &&
+				!this.$options.certificate &&
+				!this.$options.certificateThumbprint
+			) {
+				this.$logger.warn(WINDOWS_RELEASE_UNSIGNED_MESSAGE);
+			}
+
 			canExecute = await super.validateArgs(args, platform);
 		}
 

lib/constants.ts

@@ -218,6 +218,12 @@ const ANDROID_SIGNING_REQUIRED_MESSAGE =
 	"you need to specify all --key-store-* options.";
 export const ANDROID_RELEASE_BUILD_ERROR_MESSAGE = `When producing a release build, ${ANDROID_SIGNING_REQUIRED_MESSAGE}`;
 export const ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE = `When producing Android App Bundle, ${ANDROID_SIGNING_REQUIRED_MESSAGE}`;
+export const WINDOWS_RELEASE_UNSIGNED_MESSAGE =
+	"Producing an unsigned Windows release package. The resulting .msix cannot be installed directly until it is signed. Pass --certificate (and --certificate-password) or --certificate-thumbprint to produce a signed, sideloadable package, or use --store-upload to produce a package for submission to the Microsoft Store.";
+export class WindowsAppPackageMessages {
+	public static STORE_UPLOAD_DOCS_MESSAGE =
+		"Built a Microsoft Store upload package (.msixupload). Submit it to your app via Partner Center: https://partner.microsoft.com/dashboard";
+}
 export const CACACHE_DIRECTORY_NAME = "_cacache";
 
 export const FILES_CHANGE_EVENT_NAME = "filesChangeEvent";

lib/data/build-data.ts

@@ -45,6 +45,28 @@ export class IOSBuildData extends BuildData implements IiOSBuildData {
 	}
 }
 
+export class WindowsBuildData extends BuildData {
+	public certificate: string;
+	public certificatePassword: string;
+	public certificateThumbprint: string;
+	public storeUpload: boolean;
+	public msixBundle: boolean;
+	public architectures: string[];
+
+	constructor(projectDir: string, platform: string, data: any) {
+		super(projectDir, platform, data);
+
+		this.certificate = data.certificate;
+		this.certificatePassword = data.certificatePassword;
+		this.certificateThumbprint = data.certificateThumbprint;
+		this.storeUpload = data.storeUpload;
+		this.msixBundle = data.msixBundle || data.msixbundle;
+		this.architectures = data.arch
+			? [data.arch]
+			: data.architectures ?? ["x64"];
+	}
+}
+
 export class AndroidBuildData extends BuildData {
 	public keyStoreAlias: string;
 	public keyStorePath: string;

lib/declarations.d.ts

@@ -661,6 +661,10 @@ interface IOptions
 	template: string;
 	certificate: string;
 	certificatePassword: string;
+	certificateThumbprint: string;
+	storeUpload: boolean;
+	msixbundle: boolean;
+	arch: string;
 	var: Object;
 	default: Boolean;
 	count: number;

lib/options.ts

@@ -204,6 +204,13 @@ export class Options {
 			template: { type: OptionType.String, hasSensitiveValue: true },
 			certificate: { type: OptionType.String, hasSensitiveValue: true },
 			certificatePassword: { type: OptionType.String, hasSensitiveValue: true },
+			certificateThumbprint: {
+				type: OptionType.String,
+				hasSensitiveValue: true,
+			},
+			storeUpload: { type: OptionType.Boolean, hasSensitiveValue: false },
+			msixbundle: { type: OptionType.Boolean, hasSensitiveValue: false },
+			arch: { type: OptionType.String, hasSensitiveValue: false },
 			release: {
 				type: OptionType.Boolean,
 				alias: "r",

lib/services/build-data-service.ts

@@ -1,4 +1,8 @@
-import { AndroidBuildData, BuildData, IOSBuildData } from "../data/build-data";
+import {
+	AndroidBuildData,
+	IOSBuildData,
+	WindowsBuildData,
+} from "../data/build-data";
 import { IBuildDataService } from "../definitions/build";
 import { injector } from "../common/yok";
 
@@ -11,7 +15,7 @@ export class BuildDataService implements IBuildDataService {
 		} else if (this.$mobileHelper.isAndroidPlatform(platform)) {
 			return new AndroidBuildData(projectDir, platform, data);
 		} else if (this.$mobileHelper.isWindowsPlatform(platform)) {
-			return new BuildData(projectDir, platform, data);
+			return new WindowsBuildData(projectDir, platform, data);
 		}
 	}
 }

lib/services/windows-project-service.ts

@@ -114,18 +114,40 @@ export class WindowsProjectService
 				),
 				platformProjectService: <any>this,
 				projectRoot: projectRoot,
-				getBuildOutputPath: (_options?: any): string => {
+				getBuildOutputPath: (options?: any): string => {
+					// Release builds are packaged into AppPackages/ (.msix/.msixupload),
+					// while debug builds run from the plain `dotnet build` output in bin/.
+					if (options?.release) {
+						return path.join(
+							projectRoot,
+							projectData.projectName,
+							"AppPackages",
+						);
+					}
 					return path.join(projectRoot, projectData.projectName, "bin");
 				},
-				getValidBuildOutputData: (): IValidBuildOutputData => {
+				getValidBuildOutputData: (
+					options?: any,
+				): IValidBuildOutputData => {
+					if (options?.release) {
+						// Packaged artifacts live in versioned subfolders of AppPackages/
+						// (e.g. App_1.0.0.0_x64_Test/App_1.0.0.0_x64.msix), so match by
+						// extension rather than an exact file name. A representative
+						// package name is kept so callers that read packageNames[0]
+						// (e.g. for error messages) have a valid value.
+						return {
+							packageNames: [
+								`${projectData.projectName}.msixupload`,
+								`${projectData.projectName}.msix`,
+							],
+							regexes: [
+								/\.(msixupload|appxupload|msixbundle|appxbundle|msix|appx)$/i,
+							],
+						};
+					}
+					// AppxManifest.xml triggers Add-AppxPackage -Register (dev flow).
 					return {
-						// AppxManifest.xml triggers Add-AppxPackage -Register (dev flow).
-						// msix/appx handle release builds.
-						packageNames: [
-							"AppxManifest.xml",
-							`${projectData.projectName}.msix`,
-							`${projectData.projectName}.appx`,
-						],
+						packageNames: ["AppxManifest.xml"],
 					};
 				},
 				configurationFileName: "Package.appxmanifest",
@@ -275,19 +297,25 @@ export class WindowsProjectService
 		projectData: IProjectData,
 		buildConfig: any,
 	): Promise<void> {
-		const config = buildConfig?.release
-			? Configurations.Release
-			: Configurations.Debug;
+		const isRelease = !!buildConfig?.release;
+		const config = isRelease ? Configurations.Release : Configurations.Debug;
 		const arch = buildConfig?.architectures?.[0] ?? "x64";
 		const csproj = path.join(
 			projectRoot,
 			projectData.projectName,
 			`${projectData.projectName}.csproj`,
 		);
 		const outputPath = path.join(projectRoot, projectData.projectName, "bin");
+		const appPackagesDir = path.join(
+			projectRoot,
+			projectData.projectName,
+			"AppPackages",
+		);
 
 		this.$logger.info(
-			`Building Windows project: ${csproj} [${config}|${arch}]`,
+			`Building Windows project: ${csproj} [${config}|${arch}]${
+				isRelease ? " (release package)" : ""
+			}`,
 		);
 
 		// If the app project provides an App_Resources/Windows/Package.appxmanifest,
@@ -323,15 +351,61 @@ export class WindowsProjectService
 			}
 		}
 
-		const dotnetArgs = [
-			"build",
-			csproj,
-			"-c",
-			config,
-			`-p:Platform=${arch}`,
-			"--output",
-			outputPath,
-		];
+		const dotnetArgs = ["build", csproj, "-c", config, `-p:Platform=${arch}`];
+
+		if (isRelease) {
+			// Produce an MSIX package (sideload-signed by default) or a Microsoft
+			// Store upload bundle when --store-upload is passed, instead of a plain
+			// run-from-bin build.
+			const storeUpload = !!buildConfig?.storeUpload;
+			const bundle = !!buildConfig?.msixBundle || storeUpload;
+			const certificate: string = buildConfig?.certificate;
+			const certificatePassword: string = buildConfig?.certificatePassword;
+			const certificateThumbprint: string =
+				buildConfig?.certificateThumbprint;
+
+			dotnetArgs.push(
+				"-p:GenerateAppxPackageOnBuild=true",
+				`-p:AppxPackageDir=${appPackagesDir}${path.sep}`,
+				`-p:UapAppxPackageBuildMode=${
+					storeUpload ? "StoreUpload" : "SideloadOnly"
+				}`,
+				`-p:AppxBundle=${bundle ? "Always" : "Never"}`,
+			);
+
+			if (bundle) {
+				dotnetArgs.push(`-p:AppxBundlePlatforms=${arch}`);
+			}
+
+			if (storeUpload) {
+				// The Store re-signs the package on submission, so don't sign locally.
+				dotnetArgs.push("-p:AppxPackageSigningEnabled=false");
+			} else if (certificateThumbprint) {
+				dotnetArgs.push(
+					"-p:AppxPackageSigningEnabled=true",
+					`-p:PackageCertificateThumbprint=${certificateThumbprint}`,
+				);
+			} else if (certificate) {
+				const certPath = path.isAbsolute(certificate)
+					? certificate
+					: path.join(projectData.projectDir, certificate);
+				dotnetArgs.push(
+					"-p:AppxPackageSigningEnabled=true",
+					`-p:PackageCertificateKeyFile=\"${certPath}\"`,
+				);
+				if (certificatePassword) {
+					dotnetArgs.push(
+						`-p:PackageCertificatePassword=${certificatePassword}`,
+					);
+				}
+			} else {
+				// No signing material provided — emit an unsigned package.
+				dotnetArgs.push("-p:AppxPackageSigningEnabled=false");
+			}
+		} else {
+			dotnetArgs.push("--output", outputPath);
+		}
+
 		if (appResourcesManifestArg) {
 			dotnetArgs.push(appResourcesManifestArg);
 		}
@@ -354,14 +428,15 @@ export class WindowsProjectService
 		}
 
 		// Add-AppxPackage -Register requires the manifest to be named AppxManifest.xml
-		// with $targetnametoken$ expanded to the actual EXE name.
+		// with $targetnametoken$ expanded to the actual EXE name. This is only used by
+		// the dev (debug) register flow; release builds produce a packaged .msix.
 		const manifestSrc = path.join(
 			projectRoot,
 			projectData.projectName,
 			"Package.appxmanifest",
 		);
 		const manifestDest = path.join(outputPath, "AppxManifest.xml");
-		if (this.$fs.exists(manifestSrc)) {
+		if (!isRelease && this.$fs.exists(manifestSrc)) {
 			const raw = fs.readFileSync(manifestSrc, "utf8");
 			const expanded = raw.split("$targetnametoken$").join(projectData.projectName);
 			fs.writeFileSync(manifestDest, expanded, "utf8");