QWQLwToo
1445 lines
53 KiB
PowerShell
1445 lines
53 KiB
PowerShell
param()
|
|
|
|
$ErrorActionPreference = 'Stop'
|
|
|
|
$Target = 'both'
|
|
$Configuration = 'Release'
|
|
$Platform = 'x64'
|
|
$SkipTests = $false
|
|
$SkipExe = $false
|
|
|
|
foreach ($arg in $args) {
|
|
switch -Regex ($arg) {
|
|
'^--?target=(.+)$' { $Target = $Matches[1].ToLowerInvariant(); continue }
|
|
'^--?configuration=(.+)$' { $Configuration = $Matches[1]; continue }
|
|
'^--?platform=(.+)$' { $Platform = $Matches[1]; continue }
|
|
'^--?skip-tests$' { $SkipTests = $true; continue }
|
|
'^--?skip-msix$' { if ($Target -eq 'both') { $Target = 'exe' }; continue }
|
|
'^--?skip-exe$' { $SkipExe = $true; continue }
|
|
'^--?no-pause$' { continue }
|
|
default { throw "Unknown build argument: $arg" }
|
|
}
|
|
}
|
|
|
|
if (@('publish', 'exe', 'msix', 'both') -notcontains $Target) {
|
|
throw "Invalid target '$Target'. Use --target=publish|exe|msix|both."
|
|
}
|
|
|
|
$Root = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
|
|
$Solution = Join-Path $Root 'YMhut.Box.Native.sln'
|
|
$Project = Join-Path $Root 'src\box-winUI\YMhut.Box.WinUI.csproj'
|
|
$ProjectAssets = Join-Path $Root 'src\box-winUI\Assets'
|
|
$NuGetConfig = Join-Path $Root 'NuGet.Config'
|
|
$PublishRoot = Join-Path $Root 'build\winui\publish'
|
|
$MsixStageRoot = Join-Path $Root 'build\winui\msix-stage'
|
|
$BuildLogRoot = Join-Path $Root 'build\winui\logs'
|
|
$LatestRoot = Join-Path $Root 'latest'
|
|
$OutputRoot = Join-Path $Root 'installer_output'
|
|
$OutputUpdateInfoRoot = Join-Path $OutputRoot 'update-info'
|
|
$ServerPublicRoot = Join-Path $Root 'server\update\public'
|
|
$ServerDownloadRoot = Join-Path $ServerPublicRoot 'downloads'
|
|
$ToolStateRoot = Join-Path $Root '.cache\tool_state'
|
|
$NuGetRoot = Join-Path $Root '.cache\nuget'
|
|
$LocalNuGetFeedRoot = Join-Path $NuGetRoot 'feed'
|
|
$AppDataRoot = Join-Path $ToolStateRoot 'appdata'
|
|
$HomeRoot = Join-Path $ToolStateRoot 'home'
|
|
|
|
$PackageIdentityName = 'YMhut.Box'
|
|
$PackagePublisher = 'CN=YMhut'
|
|
$AppName = 'YMhut Box'
|
|
$AppExecutable = 'YMhutBox.exe'
|
|
$PfxPassword = 'ymhut-box-local'
|
|
$PfxPath = Join-Path $OutputRoot 'certs\YMhutBox.pfx'
|
|
$CerPath = Join-Path $OutputRoot 'YMhutBox.cer'
|
|
|
|
$DownloadBaseUri = if ($env:YMHUT_DOWNLOAD_BASE_URI) { $env:YMHUT_DOWNLOAD_BASE_URI.TrimEnd('/') + '/' } else { 'https://update.ymhut.cn/downloads/' }
|
|
$UpdateBaseUri = if ($env:YMHUT_UPDATE_BASE_URI) { $env:YMHUT_UPDATE_BASE_URI.TrimEnd('/') + '/' } else { 'https://update.ymhut.cn/update-info/' }
|
|
|
|
function New-Directory([string] $Path) {
|
|
New-Item -ItemType Directory -Force -Path $Path | Out-Null
|
|
}
|
|
|
|
function Write-Utf8NoBomFile([string] $Path, [string] $Value) {
|
|
$parent = Split-Path -Parent $Path
|
|
if ($parent) {
|
|
New-Directory $parent
|
|
}
|
|
|
|
$encoding = New-Object System.Text.UTF8Encoding -ArgumentList $false
|
|
[IO.File]::WriteAllText($Path, $Value, $encoding)
|
|
}
|
|
|
|
function Reset-DirectoryInsideRepo([string] $Path) {
|
|
$resolvedRoot = [IO.Path]::GetFullPath($Root)
|
|
$resolvedPath = [IO.Path]::GetFullPath($Path)
|
|
if (-not $resolvedPath.StartsWith($resolvedRoot, [StringComparison]::OrdinalIgnoreCase)) {
|
|
throw "Refusing to reset a directory outside the repository: $resolvedPath"
|
|
}
|
|
|
|
if (Test-Path -LiteralPath $resolvedPath) {
|
|
Remove-Item -LiteralPath $resolvedPath -Recurse -Force
|
|
}
|
|
New-Directory $resolvedPath
|
|
}
|
|
|
|
function Remove-DirectoryInsideRepo([string] $Path) {
|
|
$resolvedRoot = [IO.Path]::GetFullPath($Root)
|
|
$resolvedPath = [IO.Path]::GetFullPath($Path)
|
|
if (-not $resolvedPath.StartsWith($resolvedRoot, [StringComparison]::OrdinalIgnoreCase)) {
|
|
throw "Refusing to remove a directory outside the repository: $resolvedPath"
|
|
}
|
|
|
|
if (Test-Path -LiteralPath $resolvedPath) {
|
|
Remove-Item -LiteralPath $resolvedPath -Recurse -Force
|
|
}
|
|
}
|
|
|
|
function Stop-ProcessesFromDirectory([string] $Directory) {
|
|
if (-not (Test-Path -LiteralPath $Directory)) {
|
|
return
|
|
}
|
|
|
|
$resolvedDirectory = [IO.Path]::GetFullPath($Directory).TrimEnd('\', '/') + [IO.Path]::DirectorySeparatorChar
|
|
$stopped = 0
|
|
foreach ($process in Get-Process -ErrorAction SilentlyContinue) {
|
|
$processPath = $null
|
|
try {
|
|
$processPath = $process.Path
|
|
} catch {
|
|
continue
|
|
}
|
|
|
|
if ([string]::IsNullOrWhiteSpace($processPath)) {
|
|
continue
|
|
}
|
|
|
|
$resolvedProcessPath = [IO.Path]::GetFullPath($processPath)
|
|
if (-not $resolvedProcessPath.StartsWith($resolvedDirectory, [StringComparison]::OrdinalIgnoreCase)) {
|
|
continue
|
|
}
|
|
|
|
Write-Host " Stopping running payload process: $($process.ProcessName) ($($process.Id))"
|
|
Stop-Process -Id $process.Id -Force -ErrorAction SilentlyContinue
|
|
$stopped++
|
|
}
|
|
|
|
if ($stopped -gt 0) {
|
|
Start-Sleep -Seconds 2
|
|
}
|
|
}
|
|
|
|
function Invoke-Tool([string] $FilePath, [string[]] $Arguments, [string] $FailureMessage) {
|
|
& $FilePath @Arguments
|
|
if ($LASTEXITCODE -ne 0) {
|
|
throw "$FailureMessage (exit code $LASTEXITCODE)"
|
|
}
|
|
}
|
|
|
|
function Join-ProcessArguments([string[]] $Arguments) {
|
|
$quotedArguments = [Collections.Generic.List[string]]::new()
|
|
foreach ($item in $Arguments) {
|
|
$argument = [string]$item
|
|
if ($argument.Length -eq 0) {
|
|
$quotedArguments.Add('""')
|
|
continue
|
|
}
|
|
|
|
if ($argument -notmatch '[\s"]') {
|
|
$quotedArguments.Add($argument)
|
|
continue
|
|
}
|
|
|
|
$builder = [Text.StringBuilder]::new()
|
|
[void]$builder.Append('"')
|
|
$backslashes = 0
|
|
foreach ($character in $argument.ToCharArray()) {
|
|
if ($character -eq '\') {
|
|
$backslashes++
|
|
continue
|
|
}
|
|
|
|
if ($character -eq '"') {
|
|
[void]$builder.Append(('\' * (($backslashes * 2) + 1)))
|
|
[void]$builder.Append('"')
|
|
$backslashes = 0
|
|
continue
|
|
}
|
|
|
|
if ($backslashes -gt 0) {
|
|
[void]$builder.Append(('\' * $backslashes))
|
|
$backslashes = 0
|
|
}
|
|
[void]$builder.Append($character)
|
|
}
|
|
|
|
if ($backslashes -gt 0) {
|
|
[void]$builder.Append(('\' * ($backslashes * 2)))
|
|
}
|
|
[void]$builder.Append('"')
|
|
$quotedArguments.Add($builder.ToString())
|
|
}
|
|
|
|
$quotedArguments -join ' '
|
|
}
|
|
|
|
function Get-LogTail([string] $Path, [int] $Lines = 24) {
|
|
if (-not (Test-Path -LiteralPath $Path)) {
|
|
return ''
|
|
}
|
|
|
|
$text = (Get-Content -LiteralPath $Path -Tail $Lines -ErrorAction SilentlyContinue) -join [Environment]::NewLine
|
|
if ([string]::IsNullOrWhiteSpace($text)) { return '' }
|
|
$text.Trim()
|
|
}
|
|
|
|
function Invoke-ToolQuiet([string] $FilePath, [string[]] $Arguments, [string] $FailureMessage, [string] $SuccessMessage = '') {
|
|
New-Directory $BuildLogRoot
|
|
$toolName = [IO.Path]::GetFileNameWithoutExtension($FilePath)
|
|
if ([string]::IsNullOrWhiteSpace($toolName)) {
|
|
$toolName = ($FilePath -replace '[^A-Za-z0-9_.-]', '_')
|
|
}
|
|
|
|
$stamp = [DateTimeOffset]::Now.ToString('yyyyMMdd-HHmmss-fff')
|
|
$stdoutPath = Join-Path $BuildLogRoot "$toolName-$stamp.out.log"
|
|
$stderrPath = Join-Path $BuildLogRoot "$toolName-$stamp.err.log"
|
|
$process = Start-Process `
|
|
-FilePath $FilePath `
|
|
-ArgumentList (Join-ProcessArguments $Arguments) `
|
|
-NoNewWindow `
|
|
-Wait `
|
|
-PassThru `
|
|
-RedirectStandardOutput $stdoutPath `
|
|
-RedirectStandardError $stderrPath
|
|
$exitCode = $process.ExitCode
|
|
|
|
if ($exitCode -ne 0) {
|
|
$stdoutTail = Get-LogTail $stdoutPath
|
|
$stderrTail = Get-LogTail $stderrPath
|
|
if ($stdoutTail) {
|
|
Write-Host $stdoutTail
|
|
}
|
|
if ($stderrTail) {
|
|
Write-Host $stderrTail
|
|
}
|
|
throw "$FailureMessage (exit code $exitCode). Logs: $stdoutPath $stderrPath"
|
|
}
|
|
|
|
if (-not [string]::IsNullOrWhiteSpace($SuccessMessage)) {
|
|
Write-Host $SuccessMessage
|
|
}
|
|
}
|
|
|
|
function Invoke-DotNet([string[]] $Arguments) {
|
|
Invoke-Tool 'dotnet' $Arguments 'dotnet command failed'
|
|
}
|
|
|
|
function Get-VersionInfo {
|
|
$versionFile = Join-Path $Root 'version.json'
|
|
if (-not (Test-Path -LiteralPath $versionFile)) {
|
|
return [pscustomobject]@{
|
|
Version = '2.0.0'
|
|
Build = '1'
|
|
Channel = 'stable'
|
|
PackageVersion = '2.0.0.1'
|
|
}
|
|
}
|
|
|
|
$json = Get-Content -LiteralPath $versionFile -Raw -Encoding UTF8 | ConvertFrom-Json
|
|
$version = if ($json.version) { [string]$json.version } else { '2.0.0' }
|
|
$build = if ($json.build) { ([string]$json.build -replace '[^0-9]', '') } else { '1' }
|
|
if ([string]::IsNullOrWhiteSpace($build)) { $build = '1' }
|
|
$channel = if ($json.channel) { [string]$json.channel } else { 'stable' }
|
|
|
|
$parts = @()
|
|
foreach ($part in ($version -split '\.')) {
|
|
$digits = ($part -replace '[^0-9]', '')
|
|
if ($digits) { $parts += [int]$digits }
|
|
}
|
|
while ($parts.Count -lt 3) { $parts += 0 }
|
|
$parts = $parts | Select-Object -First 3
|
|
$packageVersion = (($parts + [int]$build) | ForEach-Object { [Math]::Min($_, 65535) }) -join '.'
|
|
|
|
[pscustomobject]@{
|
|
Version = $version
|
|
Build = $build
|
|
Channel = $channel
|
|
PackageVersion = $packageVersion
|
|
}
|
|
}
|
|
|
|
function Find-Executable([string] $Name, [string[]] $Candidates = @(), [string[]] $SearchRoots = @()) {
|
|
$fromPath = Get-Command $Name -ErrorAction SilentlyContinue
|
|
if ($fromPath) { return $fromPath.Source }
|
|
|
|
foreach ($candidate in $Candidates) {
|
|
if ($candidate -and (Test-Path -LiteralPath $candidate)) {
|
|
return (Resolve-Path -LiteralPath $candidate).Path
|
|
}
|
|
}
|
|
|
|
foreach ($rootPath in ($SearchRoots | Where-Object { $_ } | Select-Object -Unique)) {
|
|
if (-not (Test-Path -LiteralPath $rootPath)) {
|
|
continue
|
|
}
|
|
|
|
$tool = Get-ChildItem -LiteralPath $rootPath -Recurse -Filter $Name -File -ErrorAction SilentlyContinue |
|
|
Sort-Object FullName -Descending |
|
|
Select-Object -First 1 -ExpandProperty FullName
|
|
if ($tool) { return $tool }
|
|
}
|
|
|
|
return $null
|
|
}
|
|
|
|
function Find-WindowsSdkTool([string] $Name) {
|
|
$roots = @(
|
|
(Join-Path $NuGetRoot 'microsoft.windows.sdk.buildtools'),
|
|
(Join-Path ${env:ProgramFiles(x86)} 'Windows Kits\10\bin'),
|
|
(Join-Path $env:ProgramFiles 'Windows Kits\10\bin'),
|
|
(Join-Path ${env:ProgramFiles(x86)} 'Microsoft SDKs\ClickOnce'),
|
|
(Join-Path $env:ProgramFiles 'Microsoft SDKs\ClickOnce')
|
|
)
|
|
if ($env:WindowsSdkDir) {
|
|
$roots += Join-Path $env:WindowsSdkDir 'bin'
|
|
}
|
|
|
|
$candidates = @()
|
|
foreach ($rootPath in ($roots | Where-Object { $_ } | Select-Object -Unique)) {
|
|
if (Test-Path -LiteralPath $rootPath) {
|
|
$candidates += Get-ChildItem -LiteralPath $rootPath -Recurse -Filter $Name -File -ErrorAction SilentlyContinue
|
|
}
|
|
}
|
|
if ($candidates.Count -eq 0) {
|
|
return Find-Executable $Name
|
|
}
|
|
|
|
$architecturePreference = switch ($Platform.ToLowerInvariant()) {
|
|
'arm64' { @('\arm64\', '\x64\', '\x86\') }
|
|
'x86' { @('\x86\', '\x64\', '\arm64\') }
|
|
default { @('\x64\', '\amd64\', '\x86\', '\arm64\') }
|
|
}
|
|
foreach ($architecture in $architecturePreference) {
|
|
$tool = $candidates |
|
|
Where-Object { $_.FullName.IndexOf($architecture, [StringComparison]::OrdinalIgnoreCase) -ge 0 } |
|
|
Sort-Object FullName -Descending |
|
|
Select-Object -First 1
|
|
if ($tool) {
|
|
return $tool.FullName
|
|
}
|
|
}
|
|
|
|
($candidates | Sort-Object FullName -Descending | Select-Object -First 1).FullName
|
|
}
|
|
|
|
function Find-InnoSetupCompiler {
|
|
$envCandidates = @()
|
|
if ($env:YMHUT_INNO_SETUP) {
|
|
$envCandidates += if ((Split-Path -Leaf $env:YMHUT_INNO_SETUP) -ieq 'ISCC.exe') {
|
|
$env:YMHUT_INNO_SETUP
|
|
} else {
|
|
Join-Path $env:YMHUT_INNO_SETUP 'ISCC.exe'
|
|
}
|
|
}
|
|
if ($env:INNO_SETUP_HOME) {
|
|
$envCandidates += Join-Path $env:INNO_SETUP_HOME 'ISCC.exe'
|
|
}
|
|
|
|
$candidates = @(
|
|
$envCandidates,
|
|
'E:\Inno Setup 7\ISCC.exe',
|
|
(Join-Path ${env:ProgramFiles(x86)} 'Inno Setup 7\ISCC.exe'),
|
|
(Join-Path ${env:ProgramFiles(x86)} 'Inno Setup 6\ISCC.exe'),
|
|
(Join-Path $env:ProgramFiles 'Inno Setup 7\ISCC.exe'),
|
|
(Join-Path $env:ProgramFiles 'Inno Setup 6\ISCC.exe')
|
|
) | ForEach-Object { $_ }
|
|
Find-Executable 'ISCC.exe' -Candidates $candidates
|
|
}
|
|
|
|
function Resolve-InnoLanguageFile([string] $IsccPath) {
|
|
$compilerRoot = Split-Path -Parent $IsccPath
|
|
$chineseLanguageFile = Join-Path $compilerRoot 'Languages\ChineseSimplified.isl'
|
|
if (Test-Path -LiteralPath $chineseLanguageFile) {
|
|
return (Resolve-Path -LiteralPath $chineseLanguageFile).Path
|
|
}
|
|
|
|
$repoLanguageFile = Join-Path $Root 'installer\Languages\ChineseSimplified.isl'
|
|
if (Test-Path -LiteralPath $repoLanguageFile) {
|
|
return (Resolve-Path -LiteralPath $repoLanguageFile).Path
|
|
}
|
|
|
|
Write-Warning "ChineseSimplified.isl was not found under '$compilerRoot\Languages'. Falling back to compiler:Default.isl; custom Chinese task/runtime messages remain active."
|
|
return 'compiler:Default.isl'
|
|
}
|
|
|
|
function Save-ScaledLogo {
|
|
param(
|
|
[string] $SourcePath,
|
|
[string] $DestinationPath,
|
|
[int] $Width,
|
|
[int] $Height,
|
|
[int] $Padding,
|
|
[string] $BackgroundHex = '#00FFFFFF',
|
|
[switch] $Wordmark
|
|
)
|
|
|
|
Add-Type -AssemblyName System.Drawing
|
|
$source = [Drawing.Image]::FromFile($SourcePath)
|
|
$bitmap = New-Object Drawing.Bitmap($Width, $Height, [Drawing.Imaging.PixelFormat]::Format32bppArgb)
|
|
$graphics = [Drawing.Graphics]::FromImage($bitmap)
|
|
try {
|
|
$graphics.SmoothingMode = [Drawing.Drawing2D.SmoothingMode]::HighQuality
|
|
$graphics.InterpolationMode = [Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
|
|
$graphics.CompositingQuality = [Drawing.Drawing2D.CompositingQuality]::HighQuality
|
|
$graphics.TextRenderingHint = [Drawing.Text.TextRenderingHint]::ClearTypeGridFit
|
|
$graphics.Clear([Drawing.ColorTranslator]::FromHtml($BackgroundHex))
|
|
|
|
if ($Wordmark) {
|
|
$iconSize = [Math]::Min($Height - ($Padding * 2), [Math]::Min(112, $Width / 3))
|
|
$iconX = $Padding + [Math]::Max(0, ($Height - $iconSize) / 5)
|
|
$iconY = ($Height - $iconSize) / 2
|
|
$graphics.DrawImage($source, [Drawing.RectangleF]::new($iconX, $iconY, $iconSize, $iconSize))
|
|
|
|
$titleFont = New-Object Drawing.Font('Segoe UI Semibold', [Math]::Max(18, [Math]::Min(34, $Height / 6)))
|
|
$subFont = New-Object Drawing.Font('Segoe UI', [Math]::Max(10, [Math]::Min(16, $Height / 12)))
|
|
$titleBrush = New-Object Drawing.SolidBrush([Drawing.ColorTranslator]::FromHtml('#111827'))
|
|
$subBrush = New-Object Drawing.SolidBrush([Drawing.ColorTranslator]::FromHtml('#56616A'))
|
|
try {
|
|
$textX = $iconX + $iconSize + $Padding
|
|
$titleY = ($Height / 2) - ($titleFont.Size * 1.15)
|
|
$graphics.DrawString('YMhut Box', $titleFont, $titleBrush, [Drawing.PointF]::new($textX, $titleY))
|
|
$graphics.DrawString('WinUI 3 toolbox', $subFont, $subBrush, [Drawing.PointF]::new($textX + 2, $titleY + ($titleFont.Size * 1.6)))
|
|
} finally {
|
|
$titleFont.Dispose()
|
|
$subFont.Dispose()
|
|
$titleBrush.Dispose()
|
|
$subBrush.Dispose()
|
|
}
|
|
} else {
|
|
$maxWidth = $Width - ($Padding * 2)
|
|
$maxHeight = $Height - ($Padding * 2)
|
|
$scale = [Math]::Min($maxWidth / $source.Width, $maxHeight / $source.Height)
|
|
$drawWidth = $source.Width * $scale
|
|
$drawHeight = $source.Height * $scale
|
|
$drawX = ($Width - $drawWidth) / 2
|
|
$drawY = ($Height - $drawHeight) / 2
|
|
$graphics.DrawImage($source, [Drawing.RectangleF]::new($drawX, $drawY, $drawWidth, $drawHeight))
|
|
}
|
|
|
|
New-Directory (Split-Path -Parent $DestinationPath)
|
|
$bitmap.Save($DestinationPath, [Drawing.Imaging.ImageFormat]::Png)
|
|
} finally {
|
|
$graphics.Dispose()
|
|
$bitmap.Dispose()
|
|
$source.Dispose()
|
|
}
|
|
}
|
|
|
|
function Ensure-MsixAssets {
|
|
$sourceIcon = Join-Path $Root 'assets\icons\app_icon.png'
|
|
if (-not (Test-Path -LiteralPath $sourceIcon)) {
|
|
throw "MSIX source icon was not found: $sourceIcon"
|
|
}
|
|
|
|
New-Directory $ProjectAssets
|
|
Save-ScaledLogo $sourceIcon (Join-Path $ProjectAssets 'StoreLogo.png') 50 50 5 '#00FFFFFF'
|
|
Save-ScaledLogo $sourceIcon (Join-Path $ProjectAssets 'Square44x44Logo.png') 44 44 4 '#00FFFFFF'
|
|
Save-ScaledLogo $sourceIcon (Join-Path $ProjectAssets 'Square150x150Logo.png') 150 150 16 '#00FFFFFF'
|
|
Save-ScaledLogo $sourceIcon (Join-Path $ProjectAssets 'LockScreenLogo.png') 70 70 8 '#00FFFFFF'
|
|
Save-ScaledLogo $sourceIcon (Join-Path $ProjectAssets 'Wide310x150Logo.png') 310 150 24 '#F5F6F7' -Wordmark
|
|
}
|
|
|
|
function Ensure-LocalDeveloperCertificate {
|
|
New-Directory (Split-Path -Parent $PfxPath)
|
|
if ((Test-Path -LiteralPath $PfxPath) -and (Test-Path -LiteralPath $CerPath)) {
|
|
$secure = ConvertTo-SecureString -String $PfxPassword -AsPlainText -Force
|
|
$pfxCert = [Security.Cryptography.X509Certificates.X509Certificate2]::new($PfxPath, $secure)
|
|
$cerCert = [Security.Cryptography.X509Certificates.X509Certificate2]::new($CerPath)
|
|
if ($pfxCert.Thumbprint -ne $cerCert.Thumbprint) {
|
|
Export-Certificate -Cert $pfxCert -FilePath $CerPath -Force | Out-Null
|
|
}
|
|
|
|
Import-Certificate -FilePath $CerPath -CertStoreLocation 'Cert:\CurrentUser\Root' | Out-Null
|
|
Import-Certificate -FilePath $CerPath -CertStoreLocation 'Cert:\CurrentUser\TrustedPeople' | Out-Null
|
|
return
|
|
}
|
|
|
|
$secure = ConvertTo-SecureString -String $PfxPassword -AsPlainText -Force
|
|
$cert = New-SelfSignedCertificate `
|
|
-Type CodeSigningCert `
|
|
-Subject $PackagePublisher `
|
|
-CertStoreLocation 'Cert:\CurrentUser\My' `
|
|
-KeyExportPolicy Exportable `
|
|
-KeyUsage DigitalSignature `
|
|
-FriendlyName 'YMhut Box WinUI local signing'
|
|
|
|
Export-PfxCertificate -Cert $cert -FilePath $PfxPath -Password $secure | Out-Null
|
|
Export-Certificate -Cert $cert -FilePath $CerPath | Out-Null
|
|
Import-Certificate -FilePath $CerPath -CertStoreLocation 'Cert:\CurrentUser\Root' | Out-Null
|
|
Import-Certificate -FilePath $CerPath -CertStoreLocation 'Cert:\CurrentUser\TrustedPeople' | Out-Null
|
|
}
|
|
|
|
function Assert-ArtifactSignatureMatchesCertificate([string] $Path) {
|
|
$cerCert = [Security.Cryptography.X509Certificates.X509Certificate2]::new($CerPath)
|
|
$signature = Get-AuthenticodeSignature -FilePath $Path
|
|
if (-not $signature.SignerCertificate) {
|
|
throw "Signed artifact does not expose a signer certificate: $Path"
|
|
}
|
|
|
|
if ($signature.SignerCertificate.Thumbprint -ne $cerCert.Thumbprint) {
|
|
throw "Signed artifact certificate thumbprint '$($signature.SignerCertificate.Thumbprint)' does not match exported certificate '$($cerCert.Thumbprint)'. Rebuild the package and keep the matching YMhutBox.cer next to it."
|
|
}
|
|
}
|
|
|
|
function Get-WindowsAppRuntimePackageExtensions {
|
|
$projectRoot = Split-Path -Parent $Project
|
|
$objRoot = Join-Path $projectRoot 'obj'
|
|
if (-not (Test-Path -LiteralPath $objRoot)) {
|
|
return ''
|
|
}
|
|
|
|
$manifest = Get-ChildItem -LiteralPath $objRoot -Filter 'AppxManifest.xml' -Recurse -ErrorAction SilentlyContinue |
|
|
Where-Object { $_.FullName -like '*\MsixContent\AppxManifest.xml' } |
|
|
Sort-Object LastWriteTime -Descending |
|
|
Select-Object -First 1
|
|
if (-not $manifest) {
|
|
return ''
|
|
}
|
|
|
|
[xml]$xml = Get-Content -LiteralPath $manifest.FullName -Raw -Encoding UTF8
|
|
$namespace = [System.Xml.XmlNamespaceManager]::new($xml.NameTable)
|
|
$namespace.AddNamespace('m', 'http://schemas.microsoft.com/appx/manifest/foundation/windows10')
|
|
$extensions = $xml.SelectSingleNode('/m:Package/m:Extensions', $namespace)
|
|
if (-not $extensions) {
|
|
return ''
|
|
}
|
|
|
|
$extensions.OuterXml
|
|
}
|
|
|
|
function Write-AppxManifest([string] $TargetDir, [string] $PackageVersion) {
|
|
$packageExtensions = Get-WindowsAppRuntimePackageExtensions
|
|
if ([string]::IsNullOrWhiteSpace($packageExtensions)) {
|
|
throw 'Windows App SDK package extensions were not found. Build output must include MsixContent\AppxManifest.xml so WinUI activatable classes are registered in the MSIX.'
|
|
}
|
|
|
|
$manifest = @"
|
|
<?xml version="1.0" encoding="utf-8"?>
|
|
<Package
|
|
xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
|
|
xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
|
|
xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
|
|
xmlns:uap10="http://schemas.microsoft.com/appx/manifest/uap/windows10/10"
|
|
xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
|
|
IgnorableNamespaces="uap uap5 uap10 rescap">
|
|
|
|
<Identity
|
|
Name="$PackageIdentityName"
|
|
Publisher="$PackagePublisher"
|
|
Version="$PackageVersion"
|
|
ProcessorArchitecture="x64" />
|
|
|
|
<Properties>
|
|
<DisplayName>$AppName</DisplayName>
|
|
<PublisherDisplayName>YMhut</PublisherDisplayName>
|
|
<Logo>Assets\StoreLogo.png</Logo>
|
|
</Properties>
|
|
|
|
<Dependencies>
|
|
<TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
|
|
</Dependencies>
|
|
|
|
<Resources>
|
|
<Resource Language="zh-CN" />
|
|
<Resource Language="en-US" />
|
|
</Resources>
|
|
|
|
<Applications>
|
|
<Application Id="App" Executable="$AppExecutable" EntryPoint="Windows.FullTrustApplication" uap10:RuntimeBehavior="packagedClassicApp" uap10:TrustLevel="mediumIL">
|
|
<uap:VisualElements
|
|
DisplayName="$AppName"
|
|
Description="YMhut Box - A multi-functional toolbox"
|
|
Square150x150Logo="Assets\Square150x150Logo.png"
|
|
Square44x44Logo="Assets\Square44x44Logo.png"
|
|
BackgroundColor="transparent">
|
|
<uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" />
|
|
</uap:VisualElements>
|
|
<Extensions>
|
|
<uap5:Extension Category="windows.startupTask">
|
|
<uap5:StartupTask TaskId="YMhutBoxStartupTask" Enabled="false" DisplayName="$AppName" />
|
|
</uap5:Extension>
|
|
</Extensions>
|
|
</Application>
|
|
</Applications>
|
|
|
|
<Capabilities>
|
|
<rescap:Capability Name="runFullTrust" />
|
|
</Capabilities>
|
|
|
|
$packageExtensions
|
|
</Package>
|
|
"@
|
|
Set-Content -LiteralPath (Join-Path $TargetDir 'AppxManifest.xml') -Value $manifest -Encoding UTF8
|
|
}
|
|
|
|
function Write-AppInstaller([object] $VersionInfo, [string] $MsixFileName) {
|
|
New-Directory $OutputUpdateInfoRoot
|
|
$appInstallerUri = $UpdateBaseUri + 'winui.appinstaller'
|
|
$msixUri = $DownloadBaseUri + $MsixFileName
|
|
$appInstallerPath = Join-Path $OutputUpdateInfoRoot 'winui.appinstaller'
|
|
|
|
$content = @"
|
|
<?xml version="1.0" encoding="utf-8"?>
|
|
<AppInstaller
|
|
xmlns="http://schemas.microsoft.com/appx/appinstaller/2018"
|
|
Version="$($VersionInfo.PackageVersion)"
|
|
Uri="$appInstallerUri">
|
|
<MainPackage
|
|
Name="$PackageIdentityName"
|
|
Publisher="$PackagePublisher"
|
|
Version="$($VersionInfo.PackageVersion)"
|
|
ProcessorArchitecture="x64"
|
|
Uri="$msixUri" />
|
|
<UpdateSettings>
|
|
<OnLaunch HoursBetweenUpdateChecks="12" ShowPrompt="true" UpdateBlocksActivation="false" />
|
|
</UpdateSettings>
|
|
</AppInstaller>
|
|
"@
|
|
Set-Content -LiteralPath $appInstallerPath -Value $content -Encoding UTF8
|
|
Copy-Item -LiteralPath $appInstallerPath -Destination (Join-Path $OutputRoot 'winui.appinstaller') -Force
|
|
|
|
$localAppInstallerPath = Join-Path $OutputRoot 'winui-local.appinstaller'
|
|
$localAppInstallerUri = [Uri]::new([IO.Path]::GetFullPath($localAppInstallerPath)).AbsoluteUri
|
|
$localMsixUri = [Uri]::new([IO.Path]::GetFullPath((Join-Path $OutputRoot $MsixFileName))).AbsoluteUri
|
|
$localContent = @"
|
|
<?xml version="1.0" encoding="utf-8"?>
|
|
<AppInstaller
|
|
xmlns="http://schemas.microsoft.com/appx/appinstaller/2018"
|
|
Version="$($VersionInfo.PackageVersion)"
|
|
Uri="$localAppInstallerUri">
|
|
<MainPackage
|
|
Name="$PackageIdentityName"
|
|
Publisher="$PackagePublisher"
|
|
Version="$($VersionInfo.PackageVersion)"
|
|
ProcessorArchitecture="x64"
|
|
Uri="$localMsixUri" />
|
|
<UpdateSettings>
|
|
<OnLaunch HoursBetweenUpdateChecks="0" ShowPrompt="false" UpdateBlocksActivation="false" />
|
|
</UpdateSettings>
|
|
</AppInstaller>
|
|
"@
|
|
Set-Content -LiteralPath $localAppInstallerPath -Value $localContent -Encoding UTF8
|
|
}
|
|
|
|
function Write-LayoutManifests([string] $Directory) {
|
|
$files = Get-ChildItem -LiteralPath $Directory -Recurse -File |
|
|
ForEach-Object { $_.FullName.Substring($Directory.Length).TrimStart('\', '/') -replace '\\', '/' } |
|
|
Sort-Object
|
|
|
|
$configDir = Join-Path $Directory 'config'
|
|
New-Directory $configDir
|
|
|
|
$required = @($files | Where-Object { $_ -in @('YMhutBox.exe', 'YMhutBox.dll', 'WebView2Loader.dll') })
|
|
if ($required.Count -eq 0) {
|
|
$required = @('YMhutBox.exe')
|
|
}
|
|
|
|
$manifest = [System.Collections.Generic.List[string]]::new()
|
|
if ($versionInfo) {
|
|
$manifest.Add('[Release]')
|
|
$manifest.Add("Version=$($versionInfo.Version)")
|
|
$manifest.Add("Build=$($versionInfo.Build)")
|
|
$manifest.Add("Channel=$($versionInfo.Channel)")
|
|
$manifest.Add("PackageVersion=$($versionInfo.PackageVersion)")
|
|
$manifest.Add('')
|
|
}
|
|
$manifest.Add('[RequiredFiles]')
|
|
foreach ($file in $required) {
|
|
$manifest.Add($file)
|
|
}
|
|
$manifest.Add('')
|
|
$manifest.Add('[Files]')
|
|
foreach ($file in $files) {
|
|
if ($file -ine 'config/install-manifest.ini') {
|
|
$manifest.Add($file)
|
|
}
|
|
}
|
|
|
|
Set-Content -LiteralPath (Join-Path $configDir 'install-manifest.ini') -Value $manifest -Encoding UTF8
|
|
}
|
|
|
|
function Get-FileSha256([string] $Path) {
|
|
return (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant()
|
|
}
|
|
|
|
function Sync-UpdateServerPackages {
|
|
if (-not (Test-Path -LiteralPath $ServerPublicRoot)) {
|
|
return
|
|
}
|
|
|
|
New-Directory $ServerDownloadRoot
|
|
foreach ($legacyFile in @('manifest.json', 'latest-version.json', 'package-manifest.json', 'incremental-manifest.json', 'modules.json')) {
|
|
$legacyPath = Join-Path $ServerPublicRoot $legacyFile
|
|
if (Test-Path -LiteralPath $legacyPath) {
|
|
Remove-Item -LiteralPath $legacyPath -Force
|
|
}
|
|
}
|
|
|
|
foreach ($legacyRoot in @(
|
|
(Join-Path $ServerPublicRoot 'packages'),
|
|
(Join-Path $ServerPublicRoot 'tool-packages'),
|
|
(Join-Path $ServerPublicRoot 'incremental'),
|
|
(Join-Path $ServerDownloadRoot 'incremental')
|
|
)) {
|
|
if (Test-Path -LiteralPath $legacyRoot) {
|
|
Remove-Item -LiteralPath $legacyRoot -Recurse -Force
|
|
}
|
|
}
|
|
|
|
foreach ($sourceRoot in @($OutputRoot, $OutputUpdateInfoRoot)) {
|
|
if (-not (Test-Path -LiteralPath $sourceRoot)) {
|
|
continue
|
|
}
|
|
|
|
Get-ChildItem -LiteralPath $sourceRoot -File -ErrorAction SilentlyContinue |
|
|
Where-Object {
|
|
$_.Name -notmatch '_Light\.' -and (
|
|
$_.Name -match '^YMhut_Box_(WinUI_)?Setup_.+\.(exe|msi)$' -or
|
|
$_.Name -match '^YMhutBox_.+_x64\.msix$' -or
|
|
$_.Name -ieq 'winui.appinstaller'
|
|
)
|
|
} |
|
|
ForEach-Object {
|
|
Copy-Item -LiteralPath $_.FullName -Destination (Join-Path $ServerDownloadRoot $_.Name) -Force
|
|
}
|
|
}
|
|
|
|
$updateInfoSource = Join-Path $OutputRoot 'update-info.json'
|
|
if (Test-Path -LiteralPath $updateInfoSource) {
|
|
Copy-Item -LiteralPath $updateInfoSource -Destination (Join-Path $ServerPublicRoot 'update-info.json') -Force
|
|
}
|
|
|
|
Write-Host " Server downloads: $(Join-Path $ServerPublicRoot 'downloads')"
|
|
Write-Host " Server update info: $(Join-Path $ServerPublicRoot 'update-info.json')"
|
|
}
|
|
function Write-UpdateCatalogs([object] $VersionInfo) {
|
|
$fullExeName = "YMhut_Box_WinUI_Setup_$($VersionInfo.PackageVersion).exe"
|
|
$msixName = "YMhutBox_$($VersionInfo.PackageVersion)_x64.msix"
|
|
$appInstallerName = 'winui.appinstaller'
|
|
|
|
$fullInstallerPath = Join-Path $OutputRoot $fullExeName
|
|
$msixOutputPath = Join-Path $OutputUpdateInfoRoot $msixName
|
|
if (-not (Test-Path -LiteralPath $msixOutputPath)) {
|
|
$msixOutputPath = Join-Path $OutputRoot $msixName
|
|
}
|
|
$appInstallerPath = Join-Path $OutputRoot $appInstallerName
|
|
|
|
$fullInstaller = [ordered]@{
|
|
fileName = $fullExeName
|
|
url = $DownloadBaseUri + $fullExeName
|
|
sha256 = if (Test-Path -LiteralPath $fullInstallerPath) { Get-FileSha256 $fullInstallerPath } else { '' }
|
|
size = if (Test-Path -LiteralPath $fullInstallerPath) { (Get-Item -LiteralPath $fullInstallerPath).Length } else { 0 }
|
|
version = $VersionInfo.PackageVersion
|
|
}
|
|
$msix = [ordered]@{
|
|
fileName = $msixName
|
|
url = $DownloadBaseUri + $msixName
|
|
sha256 = if (Test-Path -LiteralPath $msixOutputPath) { Get-FileSha256 $msixOutputPath } else { '' }
|
|
size = if (Test-Path -LiteralPath $msixOutputPath) { (Get-Item -LiteralPath $msixOutputPath).Length } else { 0 }
|
|
version = $VersionInfo.PackageVersion
|
|
}
|
|
$appInstaller = [ordered]@{
|
|
fileName = $appInstallerName
|
|
url = $DownloadBaseUri + $appInstallerName
|
|
sha256 = if (Test-Path -LiteralPath $appInstallerPath) { Get-FileSha256 $appInstallerPath } else { '' }
|
|
size = if (Test-Path -LiteralPath $appInstallerPath) { (Get-Item -LiteralPath $appInstallerPath).Length } else { 0 }
|
|
version = $VersionInfo.PackageVersion
|
|
}
|
|
|
|
$manifest = [ordered]@{
|
|
manifestVersion = 5
|
|
latestVersion = $VersionInfo.PackageVersion
|
|
appVersion = $VersionInfo.PackageVersion
|
|
version = $VersionInfo.Version
|
|
build = $VersionInfo.Build
|
|
channel = $VersionInfo.Channel
|
|
latest = [ordered]@{
|
|
version = $VersionInfo.PackageVersion
|
|
fullInstaller = $fullInstaller
|
|
msix = $msix
|
|
appInstaller = $appInstaller
|
|
files = [ordered]@{
|
|
fullInstaller = $fullInstaller
|
|
msix = $msix
|
|
appInstaller = $appInstaller
|
|
}
|
|
}
|
|
messages = [ordered]@{
|
|
updateInfo = 'The official update-info catalog only describes the full offline installer, MSIX, and appinstaller artifacts.'
|
|
distribution = 'The update channel publishes the full offline installer, MSIX, and appinstaller artifacts.'
|
|
}
|
|
createdAt = (Get-Date).ToUniversalTime().ToString('o')
|
|
}
|
|
|
|
foreach ($legacyFile in @('manifest.json', 'latest-version.json', 'package-manifest.json', 'incremental-manifest.json')) {
|
|
$legacyPath = Join-Path $OutputRoot $legacyFile
|
|
if (Test-Path -LiteralPath $legacyPath) {
|
|
Remove-Item -LiteralPath $legacyPath -Force
|
|
}
|
|
}
|
|
|
|
Write-Utf8NoBomFile (Join-Path $OutputRoot 'update-info.json') ($manifest | ConvertTo-Json -Depth 10)
|
|
}
|
|
function Compress-ReferenceData([string] $Directory) {
|
|
$assetsRoot = Join-Path $Directory 'Assets'
|
|
$dataRoot = Join-Path $assetsRoot 'data'
|
|
if (-not (Test-Path -LiteralPath $dataRoot)) {
|
|
return
|
|
}
|
|
|
|
$jsonFiles = @(Get-ChildItem -LiteralPath $dataRoot -Recurse -Filter '*.json' -File -ErrorAction SilentlyContinue)
|
|
if ($jsonFiles.Count -eq 0) {
|
|
return
|
|
}
|
|
|
|
Add-Type -AssemblyName System.IO.Compression
|
|
Add-Type -AssemblyName System.IO.Compression.FileSystem
|
|
Add-Type -AssemblyName System.Security
|
|
$ybinPath = Join-Path $dataRoot 'ymhut-data.ybin'
|
|
if (Test-Path -LiteralPath $ybinPath) {
|
|
Remove-Item -LiteralPath $ybinPath -Force
|
|
}
|
|
|
|
$memory = [System.IO.MemoryStream]::new()
|
|
$archive = [System.IO.Compression.ZipArchive]::new($memory, [System.IO.Compression.ZipArchiveMode]::Create, $true)
|
|
try {
|
|
foreach ($file in $jsonFiles) {
|
|
$entryName = $file.FullName.Substring($assetsRoot.Length).TrimStart('\', '/') -replace '\\', '/'
|
|
[System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile($archive, $file.FullName, $entryName, [System.IO.Compression.CompressionLevel]::Optimal) | Out-Null
|
|
}
|
|
} finally {
|
|
$archive.Dispose()
|
|
}
|
|
|
|
$plain = $memory.ToArray()
|
|
$memory.Dispose()
|
|
$sha = [System.Security.Cryptography.SHA256]::Create()
|
|
try {
|
|
$key = $sha.ComputeHash([Text.Encoding]::UTF8.GetBytes('YMhut.Box.ReferenceData.YBin.v1'))
|
|
} finally {
|
|
$sha.Dispose()
|
|
}
|
|
$aes = [System.Security.Cryptography.Aes]::Create()
|
|
try {
|
|
$aes.Key = $key
|
|
$aes.GenerateIV()
|
|
$aes.Mode = [System.Security.Cryptography.CipherMode]::CBC
|
|
$aes.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7
|
|
$encryptor = $aes.CreateEncryptor()
|
|
try {
|
|
$cipher = $encryptor.TransformFinalBlock($plain, 0, $plain.Length)
|
|
} finally {
|
|
$encryptor.Dispose()
|
|
}
|
|
$magic = [Text.Encoding]::ASCII.GetBytes('YMHUTYBIN1')
|
|
$output = [byte[]]::new($magic.Length + $aes.IV.Length + $cipher.Length)
|
|
[Array]::Copy($magic, 0, $output, 0, $magic.Length)
|
|
[Array]::Copy($aes.IV, 0, $output, $magic.Length, $aes.IV.Length)
|
|
[Array]::Copy($cipher, 0, $output, $magic.Length + $aes.IV.Length, $cipher.Length)
|
|
[IO.File]::WriteAllBytes($ybinPath, $output)
|
|
} finally {
|
|
$aes.Dispose()
|
|
}
|
|
|
|
foreach ($file in $jsonFiles) {
|
|
Remove-Item -LiteralPath $file.FullName -Force
|
|
}
|
|
}
|
|
|
|
function Compress-SatelliteResourceFolders([string] $Directory) {
|
|
Add-Type -AssemblyName System.IO.Compression
|
|
Add-Type -AssemblyName System.IO.Compression.FileSystem
|
|
$langRoot = Join-Path $Directory 'resources\lang'
|
|
New-Directory $langRoot
|
|
$culturePattern = '^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8}){0,3}$'
|
|
foreach ($folder in Get-ChildItem -LiteralPath $Directory -Directory -ErrorAction SilentlyContinue) {
|
|
if ($folder.Name -match $culturePattern -and
|
|
(Test-Path -LiteralPath (Join-Path $folder.FullName 'Microsoft.ui.xaml.dll.mui'))) {
|
|
$binPath = Join-Path $langRoot "$($folder.Name).bin"
|
|
if (Test-Path -LiteralPath $binPath) {
|
|
Remove-Item -LiteralPath $binPath -Force
|
|
}
|
|
|
|
$archive = [System.IO.Compression.ZipFile]::Open($binPath, [System.IO.Compression.ZipArchiveMode]::Create)
|
|
try {
|
|
foreach ($file in Get-ChildItem -LiteralPath $folder.FullName -Recurse -File) {
|
|
$entryName = $file.FullName.Substring($folder.FullName.Length).TrimStart('\', '/') -replace '\\', '/'
|
|
[System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile($archive, $file.FullName, $entryName, [System.IO.Compression.CompressionLevel]::Optimal) | Out-Null
|
|
}
|
|
} finally {
|
|
$archive.Dispose()
|
|
}
|
|
|
|
Remove-Item -LiteralPath $folder.FullName -Recurse -Force
|
|
}
|
|
}
|
|
}
|
|
|
|
function Expand-SatelliteResourcePackages([string] $Directory, [switch] $RemovePackages) {
|
|
Add-Type -AssemblyName System.IO.Compression
|
|
Add-Type -AssemblyName System.IO.Compression.FileSystem
|
|
$langRoot = Join-Path $Directory 'resources\lang'
|
|
if (-not (Test-Path -LiteralPath $langRoot)) {
|
|
return
|
|
}
|
|
|
|
$culturePattern = '^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8}){0,3}$'
|
|
foreach ($package in Get-ChildItem -LiteralPath $langRoot -Filter '*.bin' -File -ErrorAction SilentlyContinue) {
|
|
$culture = [IO.Path]::GetFileNameWithoutExtension($package.Name)
|
|
if ($culture -notmatch $culturePattern) {
|
|
continue
|
|
}
|
|
|
|
$target = Join-Path $Directory $culture
|
|
$targetFull = [IO.Path]::GetFullPath($target)
|
|
New-Directory $targetFull
|
|
|
|
$archive = [System.IO.Compression.ZipFile]::OpenRead($package.FullName)
|
|
try {
|
|
foreach ($entry in $archive.Entries) {
|
|
$destination = [IO.Path]::GetFullPath((Join-Path $targetFull $entry.FullName))
|
|
if (-not $destination.StartsWith($targetFull, [StringComparison]::OrdinalIgnoreCase)) {
|
|
throw "Refusing to extract language package entry outside target directory: $($entry.FullName)"
|
|
}
|
|
|
|
if ($entry.FullName.EndsWith('/') -or $entry.FullName.EndsWith('\')) {
|
|
New-Directory $destination
|
|
continue
|
|
}
|
|
|
|
New-Directory (Split-Path -Parent $destination)
|
|
[System.IO.Compression.ZipFileExtensions]::ExtractToFile($entry, $destination, $true)
|
|
}
|
|
} finally {
|
|
$archive.Dispose()
|
|
}
|
|
}
|
|
|
|
if ($RemovePackages) {
|
|
Remove-Item -LiteralPath $langRoot -Recurse -Force
|
|
}
|
|
}
|
|
|
|
function Get-CanonicalCultureName([string] $Name) {
|
|
if ($Name -match '^(?i)zh-cn$') { return 'zh-CN' }
|
|
if ($Name -match '^(?i)en-us$') { return 'en-US' }
|
|
return $Name
|
|
}
|
|
|
|
function Test-CultureDirectoryName([string] $Name) {
|
|
return $Name -match '^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8}){0,3}$'
|
|
}
|
|
|
|
function Normalize-LanguageResourceLayout([string] $Directory) {
|
|
$allowedCultures = @('zh-CN', 'en-US')
|
|
$langRoot = Join-Path $Directory 'lang'
|
|
New-Directory $langRoot
|
|
|
|
$legacyLangRoot = Join-Path $Directory 'resources\lang'
|
|
if (Test-Path -LiteralPath $legacyLangRoot) {
|
|
Remove-Item -LiteralPath $legacyLangRoot -Recurse -Force
|
|
}
|
|
|
|
foreach ($folder in Get-ChildItem -LiteralPath $Directory -Directory -ErrorAction SilentlyContinue) {
|
|
if (-not (Test-CultureDirectoryName $folder.Name)) {
|
|
continue
|
|
}
|
|
|
|
$canonical = Get-CanonicalCultureName $folder.Name
|
|
if ($allowedCultures -contains $canonical) {
|
|
$target = Join-Path $langRoot $canonical
|
|
if (Test-Path -LiteralPath $target) {
|
|
Remove-Item -LiteralPath $target -Recurse -Force
|
|
}
|
|
|
|
Move-Item -LiteralPath $folder.FullName -Destination $target -Force
|
|
continue
|
|
}
|
|
|
|
Remove-Item -LiteralPath $folder.FullName -Recurse -Force
|
|
}
|
|
|
|
foreach ($folder in Get-ChildItem -LiteralPath $langRoot -Directory -ErrorAction SilentlyContinue) {
|
|
$canonical = Get-CanonicalCultureName $folder.Name
|
|
if ($allowedCultures -notcontains $canonical) {
|
|
Remove-Item -LiteralPath $folder.FullName -Recurse -Force
|
|
continue
|
|
}
|
|
|
|
if ($folder.Name -cne $canonical) {
|
|
$target = Join-Path $langRoot $canonical
|
|
if (Test-Path -LiteralPath $target) {
|
|
Remove-Item -LiteralPath $target -Recurse -Force
|
|
}
|
|
Move-Item -LiteralPath $folder.FullName -Destination $target -Force
|
|
}
|
|
}
|
|
}
|
|
|
|
function Restore-LangResourceLayoutForMsix([string] $Directory) {
|
|
$langRoot = Join-Path $Directory 'lang'
|
|
if (-not (Test-Path -LiteralPath $langRoot)) {
|
|
return
|
|
}
|
|
|
|
foreach ($culture in @('zh-CN', 'en-US')) {
|
|
$source = Join-Path $langRoot $culture
|
|
if (-not (Test-Path -LiteralPath $source)) {
|
|
continue
|
|
}
|
|
|
|
$target = Join-Path $Directory $culture
|
|
if (Test-Path -LiteralPath $target) {
|
|
Remove-Item -LiteralPath $target -Recurse -Force
|
|
}
|
|
Move-Item -LiteralPath $source -Destination $target -Force
|
|
}
|
|
|
|
Remove-Item -LiteralPath $langRoot -Recurse -Force
|
|
}
|
|
|
|
function Normalize-PublishLayout([string] $Directory) {
|
|
Compress-ReferenceData $Directory
|
|
Normalize-AppResourcePri $Directory
|
|
Normalize-LanguageResourceLayout $Directory
|
|
Remove-DevelopmentArtifacts $Directory
|
|
Remove-OldLayoutManifests $Directory
|
|
Remove-RootHelperDuplicates $Directory
|
|
Assert-UnpackagedLanguageResourcesInLang $Directory
|
|
Assert-NoDevelopmentArtifacts $Directory
|
|
}
|
|
|
|
function Assert-UnpackagedLanguageResourcesInLang([string] $Directory) {
|
|
$langRoot = Join-Path $Directory 'resources\lang'
|
|
$languagePackages = @()
|
|
if (Test-Path -LiteralPath $langRoot) {
|
|
$languagePackages = @(Get-ChildItem -LiteralPath $langRoot -Filter '*.bin' -File -ErrorAction SilentlyContinue)
|
|
}
|
|
|
|
if ($languagePackages.Count -gt 0) {
|
|
throw "Unpackaged EXE/latest layout must keep WinUI satellite resources expanded; found compressed resources\lang packages in $Directory"
|
|
}
|
|
|
|
if (Test-Path -LiteralPath $langRoot) {
|
|
throw "Unpackaged EXE/latest layout must not contain resources\lang; use lang\zh-CN and lang\en-US in $Directory"
|
|
}
|
|
|
|
$rootCultureFolders = @(Get-ChildItem -LiteralPath $Directory -Directory -ErrorAction SilentlyContinue |
|
|
Where-Object { Test-CultureDirectoryName $_.Name })
|
|
if ($rootCultureFolders.Count -gt 0) {
|
|
$relativeList = $rootCultureFolders | Select-Object -ExpandProperty Name
|
|
throw "Unpackaged EXE/latest layout must not contain root culture folders: $($relativeList -join ', ')"
|
|
}
|
|
|
|
$canonicalLangRoot = Join-Path $Directory 'lang'
|
|
foreach ($culture in @('zh-CN', 'en-US')) {
|
|
$cultureRoot = Join-Path $canonicalLangRoot $culture
|
|
if (-not (Test-Path -LiteralPath $cultureRoot)) {
|
|
throw "Unpackaged EXE/latest layout is missing lang\$culture in $Directory"
|
|
}
|
|
|
|
$muiFiles = @(Get-ChildItem -LiteralPath $cultureRoot -Recurse -File -Filter '*.mui' -ErrorAction SilentlyContinue)
|
|
$resourceFiles = @(Get-ChildItem -LiteralPath $cultureRoot -Recurse -File -Filter '*.resources.dll' -ErrorAction SilentlyContinue)
|
|
if (($muiFiles.Count + $resourceFiles.Count) -eq 0) {
|
|
throw "Unpackaged EXE/latest layout lang\$culture contains no satellite resource files in $Directory"
|
|
}
|
|
}
|
|
|
|
$unexpectedLangFolders = @(Get-ChildItem -LiteralPath $canonicalLangRoot -Directory -ErrorAction SilentlyContinue |
|
|
Where-Object { @('zh-CN', 'en-US') -notcontains $_.Name })
|
|
if ($unexpectedLangFolders.Count -gt 0) {
|
|
$relativeList = $unexpectedLangFolders | Select-Object -ExpandProperty Name
|
|
throw "Unpackaged EXE/latest layout contains unsupported lang cultures: $($relativeList -join ', ')"
|
|
}
|
|
}
|
|
|
|
function Ensure-RootResourcePri([string] $Directory) {
|
|
$appPriPath = Join-Path $Directory ([IO.Path]::ChangeExtension($AppExecutable, '.pri'))
|
|
if (Test-Path -LiteralPath $appPriPath) {
|
|
Copy-Item -LiteralPath $appPriPath -Destination (Join-Path $Directory 'resources.pri') -Force
|
|
}
|
|
}
|
|
|
|
function Normalize-AppResourcePri([string] $Directory) {
|
|
$appPriPath = Join-Path $Directory ([IO.Path]::ChangeExtension($AppExecutable, '.pri'))
|
|
if (-not (Test-Path -LiteralPath $appPriPath)) {
|
|
return
|
|
}
|
|
|
|
$resourcePriPath = Join-Path $Directory 'resources.pri'
|
|
if (Test-Path -LiteralPath $resourcePriPath) {
|
|
Remove-Item -LiteralPath $resourcePriPath -Force
|
|
}
|
|
Move-Item -LiteralPath $appPriPath -Destination $resourcePriPath -Force
|
|
}
|
|
|
|
function Remove-DevelopmentArtifacts([string] $Directory) {
|
|
$patterns = @('*.pdb', '*.winmd', '*.ilk', '*.iobj', '*.ipdb', 'workloads*.json')
|
|
foreach ($pattern in $patterns) {
|
|
Get-ChildItem -LiteralPath $Directory -Recurse -File -Filter $pattern -ErrorAction SilentlyContinue |
|
|
ForEach-Object { Remove-Item -LiteralPath $_.FullName -Force }
|
|
}
|
|
}
|
|
|
|
function Remove-OldLayoutManifests([string] $Directory) {
|
|
$oldFiles = @(
|
|
'installer-layout.txt',
|
|
'config\installer-layout.dat',
|
|
'config\installer-required-files.dat',
|
|
'Assets\data\reference-data.dat',
|
|
'release-manifest.json',
|
|
'version.json',
|
|
'Assets\home-globe\textures\solar\solar-texture-manifest.json'
|
|
)
|
|
foreach ($relative in $oldFiles) {
|
|
$path = Join-Path $Directory $relative
|
|
if (Test-Path -LiteralPath $path) {
|
|
Remove-Item -LiteralPath $path -Force
|
|
}
|
|
}
|
|
}
|
|
|
|
function Assert-NoDevelopmentArtifacts([string] $Directory) {
|
|
$blocked = @()
|
|
foreach ($pattern in @('*.pdb', '*.winmd', '*.ilk', '*.iobj', '*.ipdb', 'workloads*.json')) {
|
|
$blocked += @(Get-ChildItem -LiteralPath $Directory -Recurse -File -Filter $pattern -ErrorAction SilentlyContinue)
|
|
}
|
|
|
|
$appPriPath = Join-Path $Directory ([IO.Path]::ChangeExtension($AppExecutable, '.pri'))
|
|
if (Test-Path -LiteralPath $appPriPath) {
|
|
$blocked += @(Get-Item -LiteralPath $appPriPath)
|
|
}
|
|
|
|
foreach ($relative in @(
|
|
'installer-layout.txt',
|
|
'config\installer-layout.dat',
|
|
'config\installer-required-files.dat',
|
|
'Assets\data\reference-data.dat',
|
|
'release-manifest.json',
|
|
'version.json',
|
|
'Assets\home-globe\textures\solar\solar-texture-manifest.json'
|
|
)) {
|
|
$path = Join-Path $Directory $relative
|
|
if (Test-Path -LiteralPath $path) {
|
|
$blocked += @(Get-Item -LiteralPath $path)
|
|
}
|
|
}
|
|
|
|
if ($blocked.Count -gt 0) {
|
|
$relativeList = $blocked |
|
|
Select-Object -ExpandProperty FullName -Unique |
|
|
ForEach-Object { $_.Substring($Directory.Length).TrimStart('\', '/') -replace '\\', '/' }
|
|
throw "Publish layout contains development artifacts: $($relativeList -join ', ')"
|
|
}
|
|
}
|
|
|
|
function Remove-RootHelperDuplicates([string] $Directory) {
|
|
$helperFolders = @(
|
|
@{ Root = 'worker'; Prefix = 'YMhut.Box.Worker' },
|
|
@{ Root = 'plugin-host'; Prefix = 'YMhut.Box.PluginHost' },
|
|
@{ Root = 'download-host'; Prefix = 'YMhut.Box.DownloadHost' }
|
|
)
|
|
|
|
foreach ($helper in $helperFolders) {
|
|
$folder = Join-Path $Directory $helper.Root
|
|
if (-not (Test-Path -LiteralPath $folder)) {
|
|
continue
|
|
}
|
|
|
|
foreach ($extension in @('.exe', '.dll', '.deps.json', '.runtimeconfig.json')) {
|
|
$path = Join-Path $Directory "$($helper.Prefix)$extension"
|
|
if (Test-Path -LiteralPath $path) {
|
|
Remove-Item -LiteralPath $path -Force
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function Copy-PublishToLatest {
|
|
Stop-ProcessesFromDirectory $LatestRoot
|
|
Reset-DirectoryInsideRepo $LatestRoot
|
|
Copy-Item -Path (Join-Path $PublishRoot '*') -Destination $LatestRoot -Recurse -Force
|
|
Normalize-PublishLayout $LatestRoot
|
|
Write-LayoutManifests $LatestRoot
|
|
}
|
|
|
|
function Publish-UnpackagedApp([object] $VersionInfo) {
|
|
Reset-DirectoryInsideRepo $PublishRoot
|
|
Invoke-DotNet @(
|
|
'publish', $Project,
|
|
'-c', $Configuration,
|
|
'-r', 'win-x64',
|
|
'--self-contained', 'true',
|
|
'-p:WindowsPackageType=None',
|
|
'-p:PublishSingleFile=false',
|
|
"-p:AssemblyVersion=$($VersionInfo.PackageVersion)",
|
|
"-p:FileVersion=$($VersionInfo.PackageVersion)",
|
|
"-p:InformationalVersion=$($VersionInfo.PackageVersion)",
|
|
'-o', $PublishRoot
|
|
)
|
|
Normalize-PublishLayout $PublishRoot
|
|
Write-LayoutManifests $PublishRoot
|
|
Copy-PublishToLatest
|
|
}
|
|
|
|
function Build-InnoInstaller([object] $VersionInfo, [string] $SignTool, [switch] $AllowMissingCompiler, [string] $PayloadDirectory = $LatestRoot) {
|
|
$iscc = Find-InnoSetupCompiler
|
|
if (-not $iscc) {
|
|
if ($AllowMissingCompiler) {
|
|
Write-Warning 'Inno Setup compiler (ISCC.exe) was not found. Skipping EXE installer generation for this run.'
|
|
return $false
|
|
}
|
|
|
|
throw 'Inno Setup compiler (ISCC.exe) was not found. Install Inno Setup 7, then rerun build.bat --target=exe or build.bat --target=both.'
|
|
}
|
|
|
|
$iss = Join-Path $Root 'installer\ymhut_box_winui.iss'
|
|
$chineseMessagesFile = Resolve-InnoLanguageFile $iscc
|
|
Invoke-Tool $iscc @(
|
|
"/DMyAppVersion=$($VersionInfo.PackageVersion)",
|
|
"/DMyAppBuild=$($VersionInfo.Build)",
|
|
"/DMyAppChannel=$($VersionInfo.Channel)",
|
|
"/DChineseMessagesFile=$chineseMessagesFile",
|
|
"/DPayloadDir=$PayloadDirectory",
|
|
$iss
|
|
) 'Inno Setup build failed'
|
|
|
|
$setupPath = Join-Path $OutputRoot "YMhut_Box_WinUI_Setup_$($VersionInfo.PackageVersion).exe"
|
|
if ((Test-Path -LiteralPath $setupPath) -and $SignTool) {
|
|
Sign-Artifact $SignTool $setupPath
|
|
}
|
|
|
|
return $true
|
|
}
|
|
function Sign-Artifact([string] $SignTool, [string] $Path) {
|
|
Ensure-LocalDeveloperCertificate
|
|
Invoke-ToolQuiet $SignTool @('sign', '/fd', 'SHA256', '/f', $PfxPath, '/p', $PfxPassword, $Path) "Signing failed for $Path" " Signed: $Path"
|
|
Assert-ArtifactSignatureMatchesCertificate $Path
|
|
}
|
|
|
|
function Clear-PeCertificateDirectory([string] $Path) {
|
|
if (-not (Test-Path -LiteralPath $Path)) {
|
|
return $false
|
|
}
|
|
|
|
$bytes = [IO.File]::ReadAllBytes($Path)
|
|
if ($bytes.Length -lt 0x200 -or
|
|
$bytes[0] -ne 0x4D -or
|
|
$bytes[1] -ne 0x5A) {
|
|
return $false
|
|
}
|
|
|
|
$peOffset = [BitConverter]::ToInt32($bytes, 0x3C)
|
|
if ($peOffset -lt 0 -or $peOffset + 0x18 -ge $bytes.Length) {
|
|
return $false
|
|
}
|
|
|
|
if ($bytes[$peOffset] -ne 0x50 -or
|
|
$bytes[$peOffset + 1] -ne 0x45 -or
|
|
$bytes[$peOffset + 2] -ne 0 -or
|
|
$bytes[$peOffset + 3] -ne 0) {
|
|
return $false
|
|
}
|
|
|
|
$optionalHeaderSize = [BitConverter]::ToUInt16($bytes, $peOffset + 20)
|
|
$optionalHeaderOffset = $peOffset + 24
|
|
if ($optionalHeaderOffset + $optionalHeaderSize -gt $bytes.Length) {
|
|
return $false
|
|
}
|
|
|
|
$optionalMagic = [BitConverter]::ToUInt16($bytes, $optionalHeaderOffset)
|
|
$dataDirectoryOffset = switch ($optionalMagic) {
|
|
0x10B { $optionalHeaderOffset + 96 }
|
|
0x20B { $optionalHeaderOffset + 112 }
|
|
default { return $false }
|
|
}
|
|
|
|
$certificateDirectoryOffset = $dataDirectoryOffset + (4 * 8)
|
|
if ($certificateDirectoryOffset + 8 -gt $optionalHeaderOffset + $optionalHeaderSize) {
|
|
return $false
|
|
}
|
|
|
|
$certificateTableOffset = [BitConverter]::ToUInt32($bytes, $certificateDirectoryOffset)
|
|
$certificateTableSize = [BitConverter]::ToUInt32($bytes, $certificateDirectoryOffset + 4)
|
|
if ($certificateTableOffset -eq 0 -and $certificateTableSize -eq 0) {
|
|
return $false
|
|
}
|
|
|
|
for ($i = 0; $i -lt 8; $i++) {
|
|
$bytes[$certificateDirectoryOffset + $i] = 0
|
|
}
|
|
[IO.File]::WriteAllBytes($Path, $bytes)
|
|
return $true
|
|
}
|
|
|
|
function Repair-MsixStageThirdPartyPayloads {
|
|
$knownInvalidPe = Get-ChildItem -LiteralPath (Join-Path $MsixStageRoot 'Tools') -Recurse -Filter 'xiangqi.exe' -File -ErrorAction SilentlyContinue |
|
|
Where-Object { $_.FullName.IndexOf('\XIANGQI\', [StringComparison]::OrdinalIgnoreCase) -ge 0 } |
|
|
Select-Object -First 1
|
|
if ($knownInvalidPe -and (Clear-PeCertificateDirectory $knownInvalidPe.FullName)) {
|
|
Write-Host ' MSIX payload normalized: Tools\...\XIANGQI\xiangqi.exe'
|
|
}
|
|
}
|
|
|
|
function Build-MsixPackage([object] $VersionInfo, [string] $MakeAppx, [string] $SignTool) {
|
|
if (-not $MakeAppx) { throw 'Windows SDK MakeAppx.exe was not found. Install Windows 10/11 SDK.' }
|
|
if (-not $SignTool) { throw 'Windows SDK SignTool.exe was not found. Install Windows 10/11 SDK.' }
|
|
|
|
$msixFileName = "YMhutBox_$($VersionInfo.PackageVersion)_x64.msix"
|
|
$msixPath = Join-Path $OutputRoot $msixFileName
|
|
|
|
Reset-DirectoryInsideRepo $MsixStageRoot
|
|
Copy-Item -Path (Join-Path $PublishRoot '*') -Destination $MsixStageRoot -Recurse -Force
|
|
Expand-SatelliteResourcePackages $MsixStageRoot -RemovePackages
|
|
Restore-LangResourceLayoutForMsix $MsixStageRoot
|
|
Write-AppxManifest $MsixStageRoot $VersionInfo.PackageVersion
|
|
|
|
$appPriPath = Join-Path $MsixStageRoot ([IO.Path]::ChangeExtension($AppExecutable, '.pri'))
|
|
if (Test-Path -LiteralPath $appPriPath) {
|
|
Copy-Item -LiteralPath $appPriPath -Destination (Join-Path $MsixStageRoot 'resources.pri') -Force
|
|
Remove-Item -LiteralPath $appPriPath -Force
|
|
}
|
|
|
|
$stageAssets = Join-Path $MsixStageRoot 'Assets'
|
|
New-Directory $stageAssets
|
|
Copy-Item -LiteralPath (Join-Path $ProjectAssets '*') -Destination $stageAssets -Recurse -Force
|
|
|
|
Repair-MsixStageThirdPartyPayloads
|
|
Invoke-ToolQuiet $MakeAppx @('pack', '/d', $MsixStageRoot, '/p', $msixPath, '/o') 'MakeAppx packaging failed' " MSIX package: $msixPath"
|
|
Sign-Artifact $SignTool $msixPath
|
|
|
|
New-Directory $OutputUpdateInfoRoot
|
|
Copy-Item -LiteralPath $msixPath -Destination (Join-Path $OutputUpdateInfoRoot $msixFileName) -Force
|
|
Write-AppInstaller $VersionInfo $msixFileName
|
|
Write-MsixInstallHelpers $msixFileName
|
|
}
|
|
|
|
function Write-MsixInstallHelpers([string] $MsixFileName) {
|
|
$psPath = Join-Path $OutputRoot 'Install-YMhutBoxMsix.ps1'
|
|
$cmdPath = Join-Path $OutputRoot 'Install-YMhutBoxMsix.cmd'
|
|
$ps = @"
|
|
`$ErrorActionPreference = 'Stop'
|
|
`$root = Split-Path -Parent `$MyInvocation.MyCommand.Path
|
|
`$certPath = Join-Path `$root 'YMhutBox.cer'
|
|
`$msixPath = Join-Path `$root '$MsixFileName'
|
|
|
|
function Test-Administrator {
|
|
`$identity = [Security.Principal.WindowsIdentity]::GetCurrent()
|
|
`$principal = [Security.Principal.WindowsPrincipal]::new(`$identity)
|
|
return `$principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
|
|
}
|
|
|
|
if (-not (Test-Path -LiteralPath `$certPath)) {
|
|
throw "Certificate file was not found: `$certPath"
|
|
}
|
|
if (-not (Test-Path -LiteralPath `$msixPath)) {
|
|
throw "MSIX package was not found: `$msixPath"
|
|
}
|
|
|
|
`$cert = [Security.Cryptography.X509Certificates.X509Certificate2]::new(`$certPath)
|
|
`$signature = Get-AuthenticodeSignature -FilePath `$msixPath
|
|
if (-not `$signature.SignerCertificate) {
|
|
throw "MSIX signer certificate could not be read: `$msixPath"
|
|
}
|
|
if (`$signature.SignerCertificate.Thumbprint -ne `$cert.Thumbprint) {
|
|
throw "The MSIX package is signed with `$(`$signature.SignerCertificate.Thumbprint), but YMhutBox.cer is `$(`$cert.Thumbprint). Rebuild the MSIX and install the matching certificate."
|
|
}
|
|
|
|
if (-not (Test-Administrator)) {
|
|
Write-Host 'Administrator permission is required once to trust the local MSIX signing certificate.'
|
|
`$arguments = "-NoProfile -ExecutionPolicy Bypass -File ```"`$PSCommandPath```""
|
|
Start-Process -FilePath powershell.exe -ArgumentList `$arguments -Verb RunAs
|
|
exit
|
|
}
|
|
|
|
Write-Host 'Trusting YMhut Box local signing certificate for this computer...'
|
|
foreach (`$store in @('Cert:\LocalMachine\Root', 'Cert:\LocalMachine\TrustedPeople', 'Cert:\CurrentUser\Root', 'Cert:\CurrentUser\TrustedPeople')) {
|
|
Import-Certificate -FilePath `$certPath -CertStoreLocation `$store | Out-Null
|
|
if (-not (Get-ChildItem -Path `$store | Where-Object Thumbprint -eq `$cert.Thumbprint)) {
|
|
throw "Certificate was not found in `$store after import. Run this script from an elevated PowerShell window."
|
|
}
|
|
}
|
|
|
|
Write-Host 'Installing YMhut Box MSIX package...'
|
|
Add-AppxPackage -Path `$msixPath -ForceUpdateFromAnyVersion
|
|
Write-Host 'Done.'
|
|
"@
|
|
Set-Content -LiteralPath $psPath -Value $ps -Encoding UTF8
|
|
|
|
$cmd = @"
|
|
@echo off
|
|
setlocal
|
|
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0Install-YMhutBoxMsix.ps1"
|
|
if errorlevel 1 (
|
|
echo.
|
|
echo YMhut Box MSIX installation failed.
|
|
pause
|
|
exit /b 1
|
|
)
|
|
echo.
|
|
echo YMhut Box MSIX installation completed.
|
|
pause
|
|
"@
|
|
Set-Content -LiteralPath $cmdPath -Value $cmd -Encoding ASCII
|
|
}
|
|
|
|
New-Directory $AppDataRoot
|
|
New-Directory $HomeRoot
|
|
New-Directory $NuGetRoot
|
|
New-Directory $LocalNuGetFeedRoot
|
|
New-Directory $OutputRoot
|
|
$env:APPDATA = $AppDataRoot
|
|
$env:LOCALAPPDATA = $AppDataRoot
|
|
$env:HOME = $HomeRoot
|
|
$env:DOTNET_CLI_HOME = Join-Path $ToolStateRoot 'dotnet'
|
|
$env:NUGET_PACKAGES = $NuGetRoot
|
|
$env:DOTNET_CLI_TELEMETRY_OPTOUT = '1'
|
|
New-Directory $env:DOTNET_CLI_HOME
|
|
|
|
$versionInfo = Get-VersionInfo
|
|
$makeAppx = Find-WindowsSdkTool 'MakeAppx.exe'
|
|
$signTool = Find-WindowsSdkTool 'SignTool.exe'
|
|
|
|
Write-Host "YMhut Box WinUI build"
|
|
Write-Host " Target: $Target"
|
|
Write-Host " Version: $($versionInfo.Version) build $($versionInfo.Build) ($($versionInfo.PackageVersion))"
|
|
|
|
Ensure-MsixAssets
|
|
Invoke-DotNet @('restore', $Solution, '--configfile', $NuGetConfig, '--ignore-failed-sources')
|
|
if (-not $SkipTests) {
|
|
Invoke-DotNet @('test', $Solution, '-c', $Configuration, '--no-restore')
|
|
}
|
|
|
|
Publish-UnpackagedApp $versionInfo
|
|
|
|
if (($Target -in @('exe', 'both')) -and -not $SkipExe) {
|
|
$exeBuilt = Build-InnoInstaller $versionInfo $signTool -AllowMissingCompiler:($Target -eq 'both')
|
|
if (-not $exeBuilt -and $Target -eq 'exe') {
|
|
throw 'EXE installer generation was requested but Inno Setup compiler was not found.'
|
|
}
|
|
}
|
|
if ($Target -in @('msix', 'both')) {
|
|
Build-MsixPackage $versionInfo $makeAppx $signTool
|
|
}
|
|
|
|
Write-UpdateCatalogs $versionInfo
|
|
Sync-UpdateServerPackages
|
|
|
|
Write-Host ''
|
|
Write-Host 'Build complete.'
|
|
Write-Host " Publish payload: $PublishRoot"
|
|
Write-Host " Latest mirror: $LatestRoot"
|
|
Write-Host " Update info JSON:$(Join-Path $OutputRoot 'update-info.json')"
|
|
Write-Host " Server downloads:$ServerDownloadRoot"
|
|
Write-Host " Server update info: $(Join-Path $ServerPublicRoot 'update-info.json')"
|
|
Write-Host " Output: $OutputRoot"
|