464 lines
20 KiB
PowerShell
464 lines
20 KiB
PowerShell
#requires -Version 5.1
|
||
<#
|
||
.SYNOPSIS
|
||
Build the Motionity desktop installers with electron-builder.
|
||
|
||
.DESCRIPTION
|
||
Produces, in dist/:
|
||
|
||
motionity-<tag>-win-x64-setup.exe NSIS installer
|
||
motionity-<tag>-win-x64-portable.exe portable exe
|
||
motionity-<tag>-linux-x86_64.AppImage AppImage
|
||
motionity-<tag>-linux-x86_64.flatpak Flatpak bundle
|
||
SHA256SUMS.txt
|
||
|
||
The PowerShell equivalent of `npm run dist:win` / `npm run dist:linux`, with
|
||
two differences that matter for a release:
|
||
|
||
* every artifact name carries the tag, so publish.ps1 can glob exactly this
|
||
tag's files and never ship a stale one from an earlier build;
|
||
* NSIS and portable get distinct names. package.json's global artifactName
|
||
(`${productName}-${version}-${arch}.${ext}`) resolves to the same file for
|
||
both, so one silently overwrites the other.
|
||
|
||
The vendor step runs first: index.html references only src/vendor/, which is
|
||
gitignored, so a package built without it ships an app whose every script tag
|
||
404s.
|
||
|
||
Windows builds the .exe targets; AppImage and Flatpak need a Linux host or
|
||
WSL (see PACKAGING.md). Nothing here cross-builds.
|
||
|
||
-UseWsl makes that split automatic: the .exe targets run on Windows, and the
|
||
Linux ones are handed to a WSL distro over /mnt/c, against this same worktree.
|
||
The npm install, the vendor step and the icon all happen once on the Windows
|
||
side and the WSL build reads them through the mount, so the artifacts still
|
||
land in dist/ and the checksum step below sees every one of them.
|
||
|
||
.EXAMPLE
|
||
./scripts/build-release.ps1
|
||
Build every target at v<package.json version>.
|
||
|
||
.EXAMPLE
|
||
./scripts/build-release.ps1 -UseWsl
|
||
Same, with AppImage and Flatpak built in the first non-docker WSL distro.
|
||
|
||
.EXAMPLE
|
||
./scripts/build-release.ps1 -Targets win -Tag v1.1.0
|
||
Windows installers only, named v1.1.0.
|
||
|
||
.EXAMPLE
|
||
./scripts/build-release.ps1 -Targets win,linux-appimage
|
||
Windows installers plus the Linux AppImage — no Flatpak.
|
||
|
||
.EXAMPLE
|
||
./scripts/build-release.ps1 -Targets linux -UseWsl -WslDistro Ubuntu-24.04
|
||
Both Linux bundles, in a named distro.
|
||
|
||
.EXAMPLE
|
||
./scripts/build-release.ps1 -SkipVendor -SkipDeps
|
||
Reuse src/vendor/ and node_modules as they are — the fast rebuild.
|
||
#>
|
||
[CmdletBinding()]
|
||
param(
|
||
# Platforms to package. "win" is NSIS + portable; "linux-appimage" and
|
||
# "linux-flatpak" are the two Linux bundles, and "linux" is shorthand for both.
|
||
[ValidateSet("win", "linux", "linux-appimage", "linux-flatpak")]
|
||
[string[]]$Targets = @("win", "linux"),
|
||
|
||
# Version used in the artifact names. Defaults to v<package.json version>,
|
||
# because electron-builder stamps that same version into the app itself — a
|
||
# git-describe tag here would disagree with what the installed app reports.
|
||
[string]$Tag,
|
||
|
||
# Skip `npm run vendor` (the ~20 MB third-party download into src/vendor/).
|
||
[switch]$SkipVendor,
|
||
|
||
# Skip the npm install even when node_modules is missing.
|
||
[switch]$SkipDeps,
|
||
|
||
# Build the Linux targets inside WSL instead of warning that they cannot be
|
||
# built on Windows. Ignored on a Linux host, where they build natively.
|
||
[switch]$UseWsl,
|
||
|
||
# WSL distro to build in. Defaults to the first installed one that is not
|
||
# docker-desktop.
|
||
[string]$WslDistro,
|
||
|
||
# Remove dist/ before building.
|
||
[switch]$Clean
|
||
)
|
||
|
||
$ErrorActionPreference = "Stop"
|
||
|
||
function Invoke-Checked {
|
||
# NB: the param is $CmdArgs, not $Args. $Args is an automatic variable in
|
||
# PowerShell; a param of that name never binds the passed array (it stays the
|
||
# function's own empty $args), so `& $Exe @Args` would run the exe with no
|
||
# arguments — e.g. bare `npm`, which just prints usage and exits 1.
|
||
param([Parameter(Mandatory)][string]$Exe, [Parameter(Mandatory)][string[]]$CmdArgs)
|
||
Write-Host " > $Exe $($CmdArgs -join ' ')" -ForegroundColor DarkGray
|
||
& $Exe @CmdArgs
|
||
if ($LASTEXITCODE -ne 0) {
|
||
throw "'$Exe $($CmdArgs -join ' ')' failed with exit code $LASTEXITCODE."
|
||
}
|
||
}
|
||
|
||
function Get-ArtifactName {
|
||
<#
|
||
electron-builder rejects an artifactName that has no ${ext} macro, and
|
||
PowerShell would read `${ext}` inside a double-quoted string as a variable,
|
||
so the macro is appended from a single-quoted literal.
|
||
#>
|
||
param([Parameter(Mandatory)][string]$Stem)
|
||
return $Stem + '.${ext}'
|
||
}
|
||
|
||
# --- WSL plumbing -------------------------------------------------------------
|
||
|
||
function Invoke-Wsl {
|
||
param([Parameter(Mandatory)][string]$Distro, [Parameter(Mandatory)][string]$Command)
|
||
Write-Host " > wsl -d $Distro -- $Command" -ForegroundColor DarkGray
|
||
# bash -lc, so PATH matches an interactive shell: node installed through nvm
|
||
# or fnm is not on the default non-login PATH.
|
||
& wsl.exe -d $Distro -e bash -lc $Command
|
||
if ($LASTEXITCODE -ne 0) {
|
||
throw "the WSL build in '$Distro' failed with exit code $LASTEXITCODE."
|
||
}
|
||
}
|
||
|
||
function Test-WslCommand {
|
||
param([Parameter(Mandatory)][string]$Distro, [Parameter(Mandatory)][string]$Command)
|
||
& wsl.exe -d $Distro -e bash -lc $Command *> $null
|
||
return ($LASTEXITCODE -eq 0)
|
||
}
|
||
|
||
function ConvertTo-BashArg {
|
||
<#
|
||
Single quotes, always. The artifactName arguments carry a literal ${ext}
|
||
for electron-builder to expand, and bash would expand it to nothing first
|
||
inside double quotes; the repo path has a space in it.
|
||
#>
|
||
param([Parameter(Mandatory)][string]$Value)
|
||
return "'" + $Value.Replace("'", "'\''") + "'"
|
||
}
|
||
|
||
function Get-WslDistro {
|
||
<#
|
||
docker-desktop is excluded on purpose. It is Docker Desktop's own LinuxKit
|
||
VM: no apt, no user home to install the flatpak runtimes into — and it is
|
||
usually the *default* distro, so picking blind would land there.
|
||
#>
|
||
param([string]$Requested)
|
||
|
||
if (-not (Get-Command wsl.exe -ErrorAction SilentlyContinue)) {
|
||
throw "-UseWsl needs wsl.exe on PATH. Install a distro with 'wsl --install -d Ubuntu' (PACKAGING.md has the rest of the setup)."
|
||
}
|
||
|
||
# wsl.exe writes its own listings as UTF-16LE, which PowerShell 5.1 reads back
|
||
# as NUL-interleaved text. WSL_UTF8 fixes it at the source; the -replace is the
|
||
# fallback for WSL older than 0.64.
|
||
$previousUtf8 = $env:WSL_UTF8
|
||
$env:WSL_UTF8 = "1"
|
||
try { $listed = (& wsl.exe --list --quiet) -join "`n" }
|
||
finally { $env:WSL_UTF8 = $previousUtf8 }
|
||
|
||
$distros = @(($listed -replace "`0", "") -split "`r?`n" |
|
||
ForEach-Object { $_.Trim() } | Where-Object { $_ })
|
||
|
||
if ($Requested) {
|
||
if ($distros -notcontains $Requested) {
|
||
throw "WSL distro '$Requested' is not installed. Installed: $($distros -join ', ')."
|
||
}
|
||
return $Requested
|
||
}
|
||
|
||
$usable = @($distros | Where-Object { $_ -notlike "docker-desktop*" })
|
||
if (-not $usable.Count) {
|
||
throw "no WSL distro that can build here (installed: $($distros -join ', ')). Run 'wsl --install -d Ubuntu', then the package setup in PACKAGING.md."
|
||
}
|
||
return $usable[0]
|
||
}
|
||
|
||
function Get-WslPath {
|
||
param([Parameter(Mandatory)][string]$Distro, [Parameter(Mandatory)][string]$WindowsPath)
|
||
# -e wslpath rather than a shell: the backslashes and the space in the repo
|
||
# path then reach wslpath as one literal argv entry, unquoted and unmangled.
|
||
$out = (& wsl.exe -d $Distro -e wslpath -a -u $WindowsPath)
|
||
$path = (@($out) -join "").Replace("`0", "").Trim()
|
||
if ($LASTEXITCODE -ne 0 -or -not $path) {
|
||
throw "wslpath failed in '$Distro' for '$WindowsPath' — is the Windows drive mounted in that distro?"
|
||
}
|
||
return $path
|
||
}
|
||
|
||
function Get-WslStageDir {
|
||
<#
|
||
Where the Linux build actually happens. It cannot be dist/ on /mnt/c:
|
||
electron-builder chmods every file it unpacks out of the Electron zip, and
|
||
drvfs answers chmod with EPERM unless /mnt/c was mounted with the metadata
|
||
option — a global change to the distro needing sudo and a wsl --shutdown.
|
||
|
||
⨯ EPERM: operation not permitted, chmod '.../linux-unpacked.tmp/locales/de.pak'
|
||
|
||
Staging in the distro's own filesystem and copying the finished bundles back
|
||
needs none of that, and is faster besides. Reading src/ over the mount is
|
||
still fine — nothing chmods the input.
|
||
#>
|
||
param([Parameter(Mandatory)][string]$Distro)
|
||
# printf, not echo: no trailing newline to trim off the path.
|
||
$out = (& wsl.exe -d $Distro -e bash -lc 'printf %s "${XDG_CACHE_HOME:-$HOME/.cache}/motionity-build"')
|
||
$path = (@($out) -join "").Replace("`0", "").Trim()
|
||
if ($LASTEXITCODE -ne 0 -or $path -notlike "/*") {
|
||
throw "could not resolve a staging directory in '$Distro' (got '$path')."
|
||
}
|
||
return $path
|
||
}
|
||
|
||
function Assert-WslBuildEnv {
|
||
<#
|
||
Fail before the build rather than during it. electron-builder's own error
|
||
for a missing flatpak ref is a bare flatpak-builder exit code that names
|
||
neither the ref nor the remote.
|
||
#>
|
||
param(
|
||
[Parameter(Mandatory)][string]$Distro,
|
||
[Parameter(Mandatory)][string[]]$WslTargets,
|
||
[Parameter(Mandatory)]$Pkg
|
||
)
|
||
|
||
if (-not (Test-WslCommand $Distro 'command -v node')) {
|
||
throw "no node in WSL distro '$Distro'. Inside it: sudo apt update && sudo apt install -y nodejs npm"
|
||
}
|
||
|
||
# AppImage needs nothing else: electron-builder downloads its own appimage
|
||
# tooling and writes the squashfs itself. libfuse2 is only needed to *run* the
|
||
# result, which is not this script's job.
|
||
if ($WslTargets -notcontains "linux-flatpak") { return }
|
||
|
||
if (-not (Test-WslCommand $Distro 'command -v flatpak-builder')) {
|
||
throw "no flatpak-builder in WSL distro '$Distro'. Inside it: sudo apt install -y flatpak flatpak-builder elfutils"
|
||
}
|
||
|
||
$runtimeVersion = $Pkg.build.flatpak.runtimeVersion
|
||
$baseVersion = $Pkg.build.flatpak.baseVersion
|
||
if (-not $runtimeVersion) { $runtimeVersion = "23.08" }
|
||
if (-not $baseVersion) { $baseVersion = $runtimeVersion }
|
||
|
||
$refs = @(
|
||
"org.freedesktop.Platform//$runtimeVersion",
|
||
"org.freedesktop.Sdk//$runtimeVersion",
|
||
"org.electronjs.Electron2.BaseApp//$baseVersion"
|
||
)
|
||
$missing = @($refs | Where-Object { -not (Test-WslCommand $Distro "flatpak info $_") })
|
||
if ($missing.Count) {
|
||
throw @"
|
||
flatpak refs missing in '$Distro': $($missing -join ', ')
|
||
Inside the distro:
|
||
flatpak remote-add --if-not-exists --user flathub https://dl.flathub.org/repo/flathub.flatpakrepo
|
||
flatpak install --user -y flathub $($refs -join ' ')
|
||
"@
|
||
}
|
||
}
|
||
|
||
$repoRoot = Split-Path -Parent $PSScriptRoot
|
||
Push-Location $repoRoot
|
||
try {
|
||
$pkg = Get-Content (Join-Path $repoRoot "package.json") -Raw | ConvertFrom-Json
|
||
|
||
if (-not $Tag) { $Tag = "v$($pkg.version)" }
|
||
if ($Tag.TrimStart("v") -ne $pkg.version) {
|
||
Write-Warning "-Tag '$Tag' does not match package.json version '$($pkg.version)'. electron-builder stamps package.json into the app, so the file names and the app's own About version would disagree — bump package.json first."
|
||
}
|
||
|
||
$prefix = "motionity-$Tag"
|
||
$distDir = Join-Path $repoRoot "dist"
|
||
|
||
Write-Host "Motionity release build" -ForegroundColor Cyan
|
||
Write-Host " tag : $Tag"
|
||
Write-Host " targets : $($Targets -join ', ')"
|
||
Write-Host " output : $distDir"
|
||
Write-Host ""
|
||
|
||
# Expand "linux" to its two concrete bundles and drop duplicates, so the rest
|
||
# of the script only ever deals with win / linux-appimage / linux-flatpak.
|
||
$resolvedTargets = @()
|
||
foreach ($t in $Targets) {
|
||
if ($t -eq "linux") { $resolvedTargets += "linux-appimage", "linux-flatpak" }
|
||
else { $resolvedTargets += $t }
|
||
}
|
||
$resolvedTargets = @($resolvedTargets | Select-Object -Unique)
|
||
|
||
# electron-builder produces AppImage and Flatpak with Linux-only tooling (its
|
||
# downloaded appimage bundle, and flatpak-builder). -UseWsl hands those two
|
||
# targets to a WSL distro; without it they stay a warning rather than an error,
|
||
# because the other right answer is running this whole script under pwsh on a
|
||
# Linux box, where they build natively.
|
||
$onWindows = ($env:OS -eq "Windows_NT")
|
||
$wslTargets = @($resolvedTargets | Where-Object { $_ -like "linux-*" })
|
||
$useWslHere = $onWindows -and $UseWsl -and [bool]$wslTargets.Count
|
||
|
||
if ($onWindows -and $wslTargets.Count -and -not $UseWsl) {
|
||
Write-Warning "the Linux targets need a Linux host or WSL — electron-builder cannot produce AppImage or Flatpak on Windows. Add -UseWsl to build them in a WSL distro (PACKAGING.md has the setup)."
|
||
}
|
||
if ($UseWsl -and -not $onWindows) {
|
||
Write-Warning "-UseWsl ignored: this is already a Linux host, so the Linux targets build natively."
|
||
}
|
||
if ($UseWsl -and $onWindows -and -not $wslTargets.Count) {
|
||
Write-Warning "-UseWsl ignored: no Linux target was requested (-Targets $($Targets -join ', '))."
|
||
}
|
||
|
||
$wslRepo = $null
|
||
$wslStage = $null
|
||
if ($useWslHere) {
|
||
$WslDistro = Get-WslDistro -Requested $WslDistro
|
||
$wslRepo = Get-WslPath -Distro $WslDistro -WindowsPath $repoRoot
|
||
$wslStage = Get-WslStageDir -Distro $WslDistro
|
||
Write-Host "Linux targets go to WSL" -ForegroundColor Cyan
|
||
Write-Host " distro : $WslDistro"
|
||
Write-Host " worktree: $wslRepo"
|
||
Write-Host " staging : $wslStage (copied back into dist/)"
|
||
Assert-WslBuildEnv -Distro $WslDistro -WslTargets $wslTargets -Pkg $pkg
|
||
Write-Host ""
|
||
}
|
||
|
||
if ($Clean) {
|
||
Write-Host "Cleaning dist/..." -ForegroundColor Cyan
|
||
if (Test-Path $distDir) { Remove-Item -Recurse -Force $distDir }
|
||
}
|
||
New-Item -ItemType Directory -Force -Path $distDir | Out-Null
|
||
|
||
# --- Dependencies ---------------------------------------------------------
|
||
# Only when node_modules is absent: `npm ci` deletes the tree and re-extracts
|
||
# ~250 MB of Electron every time, which turns a 2-minute rebuild into a
|
||
# 10-minute one for no gain.
|
||
if (-not $SkipDeps -and -not (Test-Path (Join-Path $repoRoot "node_modules"))) {
|
||
Write-Host "Installing dependencies..." -ForegroundColor Cyan
|
||
if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
|
||
throw "npm not found — install Node 18+, or pass -SkipDeps if node_modules is provided some other way."
|
||
}
|
||
Invoke-Checked npm @("ci", "--no-audit", "--no-fund")
|
||
Write-Host ""
|
||
}
|
||
|
||
# --- Vendored assets ------------------------------------------------------
|
||
# index.html points only at src/vendor/, which is gitignored, so this has to
|
||
# run before electron-builder copies src/ into the package — not after.
|
||
if (-not $SkipVendor) {
|
||
Write-Host "Vendoring third-party assets..." -ForegroundColor Cyan
|
||
Invoke-Checked node @("scripts/vendor.mjs")
|
||
Write-Host ""
|
||
}
|
||
|
||
# A missing src/vendor/ yields an installer that opens to a blank editor and
|
||
# only fails at run time, so check one file that must be there.
|
||
$vendorProbe = Join-Path $repoRoot "src/vendor/fabric.min.js"
|
||
if (-not (Test-Path $vendorProbe)) {
|
||
throw "src/vendor/fabric.min.js is missing — the package would ship an app whose scripts all 404. Run without -SkipVendor."
|
||
}
|
||
|
||
# --- Icon -----------------------------------------------------------------
|
||
# build/icon.png is gitignored and generated; electron-builder derives the
|
||
# Windows .ico and the Linux icon set from it and fails without it.
|
||
Write-Host "Rendering icon..." -ForegroundColor Cyan
|
||
Invoke-Checked node @("scripts/make-icon.cjs")
|
||
Write-Host ""
|
||
|
||
# --- Package --------------------------------------------------------------
|
||
# The local binary rather than npx: npx renamed --no-install to --no in npm 10,
|
||
# and a version-dependent flag inside a release script is a trap.
|
||
$builder = Join-Path $repoRoot "node_modules/.bin/electron-builder.cmd"
|
||
if (-not (Test-Path $builder)) {
|
||
$builder = Join-Path $repoRoot "node_modules/.bin/electron-builder"
|
||
}
|
||
if (-not (Test-Path $builder)) {
|
||
throw 'electron-builder not found in node_modules — run "npm ci" (or drop -SkipDeps).'
|
||
}
|
||
|
||
foreach ($target in $resolvedTargets) {
|
||
Write-Host "Packaging $target..." -ForegroundColor Cyan
|
||
|
||
# --publish never: electron-builder otherwise tries to upload to whatever
|
||
# provider it infers from the repo URL as soon as the tag looks like a
|
||
# release. Publishing is publish.ps1's job, against Gitea.
|
||
switch ($target) {
|
||
"win" {
|
||
$builderArgs = @(
|
||
"--win", "--publish", "never",
|
||
"-c.nsis.artifactName=$(Get-ArtifactName "$prefix-win-x64-setup")",
|
||
"-c.portable.artifactName=$(Get-ArtifactName "$prefix-win-x64-portable")"
|
||
)
|
||
}
|
||
"linux-appimage" {
|
||
$builderArgs = @(
|
||
"--linux", "AppImage", "--publish", "never",
|
||
"-c.appImage.artifactName=$(Get-ArtifactName "$prefix-linux-x86_64")"
|
||
)
|
||
}
|
||
"linux-flatpak" {
|
||
$builderArgs = @(
|
||
"--linux", "flatpak", "--publish", "never",
|
||
"-c.flatpak.artifactName=$(Get-ArtifactName "$prefix-linux-x86_64")"
|
||
)
|
||
}
|
||
}
|
||
|
||
if ($useWslHere -and $target -like "linux-*") {
|
||
# `node cli.js` rather than node_modules/.bin/electron-builder: the
|
||
# extensionless shim npm writes on Windows is a sh script, and whether
|
||
# it is executable across the mount depends on the drvfs options.
|
||
#
|
||
# The output goes to the distro's filesystem (see Get-WslStageDir) and
|
||
# the bundles are copied back afterwards. `cp -f`, never `cp -p`:
|
||
# preserving modes means chmod, which is the EPERM this avoids.
|
||
#
|
||
# The rm clears this tag's previous bundles from the staging directory,
|
||
# so the copy back cannot pick up an artifact from an earlier build that
|
||
# electron-builder did not overwrite this time round.
|
||
$quotedArgs = @($builderArgs | ForEach-Object { ConvertTo-BashArg $_ }) -join " "
|
||
$stage = ConvertTo-BashArg $wslStage
|
||
$wslCommand = "cd $(ConvertTo-BashArg $wslRepo)" +
|
||
" && mkdir -p $stage" +
|
||
" && rm -f $stage/$prefix-*" +
|
||
" && USE_HARD_LINKS=false node node_modules/electron-builder/cli.js $quotedArgs $(ConvertTo-BashArg "-c.directories.output=$wslStage")" +
|
||
" && cp -f $stage/$prefix-* $(ConvertTo-BashArg "$wslRepo/dist")/"
|
||
Invoke-Wsl -Distro $WslDistro -Command $wslCommand
|
||
}
|
||
else {
|
||
Invoke-Checked $builder $builderArgs
|
||
}
|
||
Write-Host ""
|
||
}
|
||
|
||
# electron-builder drops auto-update metadata and the NSIS payload beside the
|
||
# installers. publish.ps1 uploads everything matching the tag prefix, so clear
|
||
# them out here instead of attaching 80 MB of intermediates to the release.
|
||
Get-ChildItem $distDir -File | Where-Object {
|
||
$_.Name -like "*.blockmap" -or $_.Name -like "latest*.yml" -or
|
||
$_.Name -like "*.nsis.7z" -or $_.Name -eq "builder-debug.yml"
|
||
} | Remove-Item -Force
|
||
|
||
$built = @(Get-ChildItem $distDir -Filter "$prefix-*" -File | Sort-Object Name)
|
||
if (-not $built.Count) {
|
||
throw "electron-builder reported success but no $prefix-* artifact landed in $distDir."
|
||
}
|
||
|
||
# --- Checksums ------------------------------------------------------------
|
||
Write-Host "Writing checksums..." -ForegroundColor Cyan
|
||
$sumsPath = Join-Path $distDir "SHA256SUMS.txt"
|
||
$lines = foreach ($f in $built) {
|
||
"$((Get-FileHash -Algorithm SHA256 $f.FullName).Hash.ToLower()) $($f.Name)"
|
||
}
|
||
# ASCII with LF: a BOM or CRLF makes `sha256sum -c` reject the first line.
|
||
[System.IO.File]::WriteAllText($sumsPath, ($lines -join "`n") + "`n", [System.Text.ASCIIEncoding]::new())
|
||
Write-Host ""
|
||
|
||
Write-Host "Done. Built:" -ForegroundColor Green
|
||
foreach ($f in $built) {
|
||
Write-Host " $($f.FullName) ($([math]::Round($f.Length / 1MB, 1)) MB)" -ForegroundColor Green
|
||
}
|
||
Write-Host " $sumsPath" -ForegroundColor Green
|
||
}
|
||
finally {
|
||
Pop-Location
|
||
}
|