Refactor finalize-desktop-artifacts script for improved readability and consistency
All checks were successful
farmcontrol/farmcontrol-ui/pipeline/head This commit looks good

- Standardized import statements and formatting for better code clarity.
- Simplified logic in functions for determining build environment and artifact paths.
- Enhanced error handling in artifact publishing and cleaning functions.
- Streamlined file walking and searching functions to improve maintainability.
This commit is contained in:
Tom Butcher 2026-08-02 00:38:34 +01:00
parent 47c97a1771
commit 613cb7712d

View File

@ -5,253 +5,250 @@ import {
readdirSync,
readFileSync,
rmSync,
statSync,
} from "node:fs";
import path from "node:path";
import { spawnSync } from "node:child_process";
import { fileURLToPath } from "node:url";
statSync
} from 'node:fs'
import path from 'node:path'
import { spawnSync } from 'node:child_process'
import { fileURLToPath } from 'node:url'
import {
getReleaseArch,
getReleaseArtifactName,
getReleaseVersion,
} from "./release-artifact-utils.mjs";
getReleaseVersion
} from './release-artifact-utils.mjs'
import {
cleanExpandedWindowsApp,
expandWindowsAppFromArchive,
} from "./expand-windows-installer.mjs";
import { codesignMacAppBundle } from "./codesign-macos-app.mjs";
expandWindowsAppFromArchive
} from './expand-windows-installer.mjs'
import { codesignMacAppBundle } from './codesign-macos-app.mjs'
const rootDir = path.resolve(
path.dirname(fileURLToPath(import.meta.url)),
"..",
);
const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
const packageJson = JSON.parse(
readFileSync(path.join(rootDir, "package.json"), "utf8"),
);
const buildEnv = process.env.ELECTROBUN_BUILD_ENV || "stable";
readFileSync(path.join(rootDir, 'package.json'), 'utf8')
)
const buildEnv = process.env.ELECTROBUN_BUILD_ENV || 'stable'
const targetOs =
process.env.ELECTROBUN_OS ||
(process.platform === "darwin"
? "macos"
: process.platform === "win32"
? "win"
: process.platform === "linux"
? "linux"
: null);
const buildArch = getReleaseArch(process.env.ELECTROBUN_ARCH || process.arch);
(process.platform === 'darwin'
? 'macos'
: process.platform === 'win32'
? 'win'
: process.platform === 'linux'
? 'linux'
: null)
const buildArch = getReleaseArch(process.env.ELECTROBUN_ARCH || process.arch)
const version =
process.env.ELECTROBUN_APP_VERSION || getReleaseVersion(packageJson);
process.env.ELECTROBUN_APP_VERSION || getReleaseVersion(packageJson)
const artifactDir =
process.env.ELECTROBUN_ARTIFACT_DIR || path.join(rootDir, "app_dist");
process.env.ELECTROBUN_ARTIFACT_DIR || path.join(rootDir, 'app_dist')
const identifier =
process.env.ELECTROBUN_APP_IDENTIFIER || "com.tombutcher.farmcontrol";
const artifactPrefix = `farmcontrol-${version}-`;
process.env.ELECTROBUN_APP_IDENTIFIER || 'com.tombutcher.farmcontrol'
const artifactPrefix = `farmcontrol-${version}-`
function getBuildRoot() {
const electrobunBuildDir = process.env.ELECTROBUN_BUILD_DIR;
const electrobunBuildDir = process.env.ELECTROBUN_BUILD_DIR
if (!electrobunBuildDir) {
return path.join(rootDir, "build");
return path.join(rootDir, 'build')
}
const baseName = path.basename(electrobunBuildDir);
if (baseName.startsWith("stable-")) {
return path.dirname(electrobunBuildDir);
const baseName = path.basename(electrobunBuildDir)
if (baseName.startsWith('stable-')) {
return path.dirname(electrobunBuildDir)
}
return electrobunBuildDir;
return electrobunBuildDir
}
function walkFiles(dir) {
const files = [];
const files = []
if (!existsSync(dir)) {
return files;
return files
}
for (const entry of readdirSync(dir)) {
const fullPath = path.join(dir, entry);
const stats = statSync(fullPath);
const fullPath = path.join(dir, entry)
const stats = statSync(fullPath)
if (stats.isDirectory()) {
files.push(...walkFiles(fullPath));
files.push(...walkFiles(fullPath))
} else {
files.push(fullPath);
files.push(fullPath)
}
}
return files;
return files
}
function findByExtension(root, extension) {
return walkFiles(root).find((filePath) =>
filePath.toLowerCase().endsWith(extension.toLowerCase()),
);
filePath.toLowerCase().endsWith(extension.toLowerCase())
)
}
function findMacAppBundle(arch) {
const platformDir = path.join(getBuildRoot(), `stable-macos-${arch}`);
const platformDir = path.join(getBuildRoot(), `stable-macos-${arch}`)
if (!existsSync(platformDir)) {
return null;
return null
}
for (const child of readdirSync(platformDir)) {
if (child.endsWith(".app")) {
return path.join(platformDir, child);
if (child.endsWith('.app')) {
return path.join(platformDir, child)
}
}
return null;
return null
}
function findMacDmgSource(arch) {
const prefixedArtifact = walkFiles(artifactDir).find(
(filePath) =>
filePath.includes(`stable-macos-${arch}`) &&
filePath.toLowerCase().endsWith(".dmg"),
);
filePath.toLowerCase().endsWith('.dmg')
)
if (prefixedArtifact) {
return prefixedArtifact;
return prefixedArtifact
}
const buildDmg = findByExtension(
path.join(getBuildRoot(), `stable-macos-${arch}`),
".dmg",
);
'.dmg'
)
if (buildDmg) {
return buildDmg;
return buildDmg
}
return findByExtension(artifactDir, ".dmg");
return findByExtension(artifactDir, '.dmg')
}
function findWindowsInstallerFiles() {
const buildRoot = getBuildRoot();
const buildRoot = getBuildRoot()
if (!existsSync(buildRoot)) {
return null;
return null
}
for (const entry of readdirSync(buildRoot)) {
if (!entry.startsWith("stable-win-")) {
continue;
if (!entry.startsWith('stable-win-')) {
continue
}
const platformDir = path.join(buildRoot, entry);
const files = walkFiles(platformDir);
const setupExe = files.find((filePath) => /-setup\.exe$/i.test(filePath));
const platformDir = path.join(buildRoot, entry)
const files = walkFiles(platformDir)
const setupExe = files.find((filePath) => /-setup\.exe$/i.test(filePath))
const setupArchive = files.find((filePath) =>
/-setup\.tar\.zst$/i.test(filePath),
);
/-setup\.tar\.zst$/i.test(filePath)
)
const setupMetadata = files.find((filePath) =>
/-setup\.metadata\.json$/i.test(filePath),
);
const setupZip = files.find((filePath) => /-setup\.zip$/i.test(filePath));
/-setup\.metadata\.json$/i.test(filePath)
)
const setupZip = files.find((filePath) => /-setup\.zip$/i.test(filePath))
if (setupExe && setupArchive && setupMetadata) {
return { setupExe, setupArchive, setupMetadata, setupZip };
return { setupExe, setupArchive, setupMetadata, setupZip }
}
}
return null;
return null
}
function publishArtifact(sourcePath, arch, ext) {
if (!sourcePath || !existsSync(sourcePath)) {
throw new Error(
`Missing source artifact for ${arch}.${ext}: ${sourcePath ?? "not found"}`,
);
`Missing source artifact for ${arch}.${ext}: ${sourcePath ?? 'not found'}`
)
}
mkdirSync(artifactDir, { recursive: true });
mkdirSync(artifactDir, { recursive: true })
const destination = path.join(
artifactDir,
getReleaseArtifactName(version, arch, ext),
);
cpSync(sourcePath, destination);
console.log(`Published ${destination}`);
return destination;
getReleaseArtifactName(version, arch, ext)
)
cpSync(sourcePath, destination)
console.log(`Published ${destination}`)
return destination
}
function cleanStagingArtifacts(keepNames) {
if (!existsSync(artifactDir)) {
return;
return
}
for (const entry of readdirSync(artifactDir)) {
if (keepNames.includes(entry) || entry.startsWith(artifactPrefix)) {
continue;
continue
}
if (
entry.includes("stable-macos-") ||
entry.includes("stable-win-") ||
entry.endsWith("-update.json") ||
entry.endsWith(".tar.gz")
entry.includes('stable-macos-') ||
entry.includes('stable-win-') ||
entry.endsWith('-update.json') ||
entry.endsWith('.tar.gz')
) {
rmSync(path.join(artifactDir, entry), { recursive: true, force: true });
rmSync(path.join(artifactDir, entry), { recursive: true, force: true })
}
}
}
const MAC_DMG_ASSETS_DIR = path.join(rootDir, "packaging/macos/dmg");
const MAC_DMG_BACKGROUND_PATH = path.join(rootDir, "assets/dmg/background.png");
const MAC_DMG_ASSETS_DIR = path.join(rootDir, 'packaging/macos/dmg')
const MAC_DMG_BACKGROUND_PATH = path.join(rootDir, 'assets/dmg/background.png')
const MAC_DMG_BACKGROUND_RETINA_PATH = path.join(
rootDir,
"assets/dmg/background@2x.png",
);
const MAC_DMG_APP_NAME = "Farm Control.app";
const MAC_DMG_WINDOW_WIDTH = 540;
const MAC_DMG_WINDOW_HEIGHT = 380;
'assets/dmg/background@2x.png'
)
const MAC_DMG_APP_NAME = 'Farm Control.app'
const MAC_DMG_WINDOW_WIDTH = 540
const MAC_DMG_WINDOW_HEIGHT = 380
function ensureMacDmgAssets() {
mkdirSync(MAC_DMG_ASSETS_DIR, { recursive: true });
mkdirSync(MAC_DMG_ASSETS_DIR, { recursive: true })
const voliconPath = path.join(MAC_DMG_ASSETS_DIR, "volicon.icns");
const iconsetPath = path.join(rootDir, "assets/icon.iconset");
const voliconPath = path.join(MAC_DMG_ASSETS_DIR, 'volicon.icns')
const iconsetPath = path.join(rootDir, 'assets/icon.iconset')
if (!existsSync(voliconPath) && existsSync(iconsetPath)) {
const iconutil = spawnSync(
"iconutil",
["-c", "icns", "-o", voliconPath, iconsetPath],
{ stdio: "inherit" },
);
'iconutil',
['-c', 'icns', '-o', voliconPath, iconsetPath],
{ stdio: 'inherit' }
)
if (iconutil.status !== 0) {
throw new Error(
`iconutil failed to create DMG volicon with exit code ${iconutil.status ?? 1}`,
);
`iconutil failed to create DMG volicon with exit code ${iconutil.status ?? 1}`
)
}
}
if (!existsSync(MAC_DMG_BACKGROUND_PATH)) {
throw new Error(`DMG background not found at ${MAC_DMG_BACKGROUND_PATH}`);
throw new Error(`DMG background not found at ${MAC_DMG_BACKGROUND_PATH}`)
}
if (!existsSync(MAC_DMG_BACKGROUND_RETINA_PATH)) {
console.warn(
`finalize-desktop-artifacts: retina DMG background not found at ${MAC_DMG_BACKGROUND_RETINA_PATH}`,
);
`finalize-desktop-artifacts: retina DMG background not found at ${MAC_DMG_BACKGROUND_RETINA_PATH}`
)
}
return {
volicon: existsSync(voliconPath) ? voliconPath : null,
background: MAC_DMG_BACKGROUND_PATH,
};
background: MAC_DMG_BACKGROUND_PATH
}
}
function findCreateDmgCommand() {
const which = spawnSync("which", ["create-dmg"], { encoding: "utf8" });
const which = spawnSync('which', ['create-dmg'], { encoding: 'utf8' })
if (which.status === 0 && which.stdout.trim()) {
return which.stdout.trim();
return which.stdout.trim()
}
for (const candidate of [
"/opt/homebrew/bin/create-dmg",
"/usr/local/bin/create-dmg",
'/opt/homebrew/bin/create-dmg',
'/usr/local/bin/create-dmg'
]) {
if (existsSync(candidate)) {
return candidate;
return candidate
}
}
return null;
return null
}
function buildMacDmgWithCreateDmg(
@ -259,121 +256,121 @@ function buildMacDmgWithCreateDmg(
dmgPath,
sourceFolder,
appBundleName,
dmgAssets,
dmgAssets
) {
rmSync(dmgPath, { force: true });
rmSync(dmgPath, { force: true })
const args = [
"--volname",
"Farm Control",
"--window-pos",
"200",
"120",
"--window-size",
'--volname',
'Farm Control',
'--window-pos',
'200',
'120',
'--window-size',
String(MAC_DMG_WINDOW_WIDTH),
String(MAC_DMG_WINDOW_HEIGHT),
"--icon-size",
"100",
"--icon",
'--icon-size',
'100',
'--icon',
appBundleName,
"130",
"220",
"--hide-extension",
'130',
'212',
'--hide-extension',
appBundleName,
"--app-drop-link",
"410",
"220",
"--format",
"UDZO",
];
'--app-drop-link',
'410',
'212',
'--format',
'UDZO'
]
if (dmgAssets.volicon) {
args.push("--volicon", dmgAssets.volicon);
args.push('--volicon', dmgAssets.volicon)
}
if (dmgAssets.background) {
args.push("--background", dmgAssets.background);
args.push('--background', dmgAssets.background)
}
args.push(dmgPath, sourceFolder);
args.push(dmgPath, sourceFolder)
const result = spawnSync(createDmg, args, { stdio: "inherit" });
const result = spawnSync(createDmg, args, { stdio: 'inherit' })
if (result.status !== 0) {
throw new Error(`create-dmg failed with exit code ${result.status ?? 1}`);
throw new Error(`create-dmg failed with exit code ${result.status ?? 1}`)
}
if (!existsSync(dmgPath)) {
throw new Error(`create-dmg did not produce ${dmgPath}`);
throw new Error(`create-dmg did not produce ${dmgPath}`)
}
return dmgPath;
return dmgPath
}
function copyMacAppBundle(sourcePath, destinationPath) {
rmSync(destinationPath, { recursive: true, force: true });
mkdirSync(path.dirname(destinationPath), { recursive: true });
rmSync(destinationPath, { recursive: true, force: true })
mkdirSync(path.dirname(destinationPath), { recursive: true })
const result = spawnSync("ditto", [sourcePath, destinationPath], {
stdio: "inherit",
});
const result = spawnSync('ditto', [sourcePath, destinationPath], {
stdio: 'inherit'
})
if (result.status !== 0) {
throw new Error(`ditto failed with exit code ${result.status ?? 1}`);
throw new Error(`ditto failed with exit code ${result.status ?? 1}`)
}
}
function canUseDirectDmgSourceFolder(appBundlePath) {
const platformDir = path.dirname(appBundlePath);
const appName = path.basename(appBundlePath);
const platformDir = path.dirname(appBundlePath)
const appName = path.basename(appBundlePath)
const entries = readdirSync(platformDir).filter(
(entry) => !entry.startsWith(".") && entry !== ".finalize-dmg-staging",
);
(entry) => !entry.startsWith('.') && entry !== '.finalize-dmg-staging'
)
return entries.length === 1 && entries[0] === appName;
return entries.length === 1 && entries[0] === appName
}
async function buildMacDmg(appBundlePath, arch) {
const createDmg = findCreateDmgCommand();
const createDmg = findCreateDmgCommand()
if (!createDmg) {
throw new Error(
"create-dmg not found. Install with: brew install create-dmg",
);
'create-dmg not found. Install with: brew install create-dmg'
)
}
const appBundleName = path.basename(appBundlePath);
const appBundleName = path.basename(appBundlePath)
if (appBundleName !== MAC_DMG_APP_NAME) {
console.warn(
`finalize-desktop-artifacts: expected ${MAC_DMG_APP_NAME}, found ${appBundleName}`,
);
`finalize-desktop-artifacts: expected ${MAC_DMG_APP_NAME}, found ${appBundleName}`
)
}
const dmgPath = path.join(
artifactDir,
getReleaseArtifactName(version, arch, "dmg"),
);
getReleaseArtifactName(version, arch, 'dmg')
)
mkdirSync(artifactDir, { recursive: true });
mkdirSync(artifactDir, { recursive: true })
const stagingDir = path.join(
path.dirname(appBundlePath),
".finalize-dmg-staging",
);
const useDirectSource = canUseDirectDmgSourceFolder(appBundlePath);
'.finalize-dmg-staging'
)
const useDirectSource = canUseDirectDmgSourceFolder(appBundlePath)
const sourceFolder = useDirectSource
? path.dirname(appBundlePath)
: stagingDir;
: stagingDir
if (!useDirectSource) {
rmSync(stagingDir, { recursive: true, force: true });
mkdirSync(stagingDir, { recursive: true });
const stagedAppPath = path.join(stagingDir, path.basename(appBundlePath));
copyMacAppBundle(appBundlePath, stagedAppPath);
codesignMacAppBundle(stagedAppPath);
rmSync(stagingDir, { recursive: true, force: true })
mkdirSync(stagingDir, { recursive: true })
const stagedAppPath = path.join(stagingDir, path.basename(appBundlePath))
copyMacAppBundle(appBundlePath, stagedAppPath)
codesignMacAppBundle(stagedAppPath)
}
let builtDmgPath;
const dmgAssets = ensureMacDmgAssets();
let builtDmgPath
const dmgAssets = ensureMacDmgAssets()
try {
builtDmgPath = buildMacDmgWithCreateDmg(
@ -381,228 +378,228 @@ async function buildMacDmg(appBundlePath, arch) {
dmgPath,
sourceFolder,
appBundleName,
dmgAssets,
);
dmgAssets
)
} finally {
if (!useDirectSource) {
rmSync(stagingDir, { recursive: true, force: true });
rmSync(stagingDir, { recursive: true, force: true })
}
}
console.log(`Published ${builtDmgPath}`);
return builtDmgPath;
console.log(`Published ${builtDmgPath}`)
return builtDmgPath
}
function cleanMacBuildDir(arch) {
const platformDir = path.join(getBuildRoot(), `stable-macos-${arch}`);
const platformDir = path.join(getBuildRoot(), `stable-macos-${arch}`)
if (existsSync(platformDir)) {
rmSync(platformDir, { recursive: true, force: true });
console.log(`Removed build output ${platformDir}`);
rmSync(platformDir, { recursive: true, force: true })
console.log(`Removed build output ${platformDir}`)
}
}
function buildMacPkg(appBundlePath, arch) {
const pkgPath = path.join(
artifactDir,
getReleaseArtifactName(version, arch, "pkg"),
);
getReleaseArtifactName(version, arch, 'pkg')
)
const result = spawnSync(
"pkgbuild",
'pkgbuild',
[
"--component",
'--component',
appBundlePath,
"--install-location",
"/Applications",
"--identifier",
'--install-location',
'/Applications',
'--identifier',
identifier,
"--version",
'--version',
version,
pkgPath,
pkgPath
],
{ stdio: "inherit" },
);
{ stdio: 'inherit' }
)
if (result.status !== 0) {
throw new Error(`pkgbuild failed with exit code ${result.status ?? 1}`);
throw new Error(`pkgbuild failed with exit code ${result.status ?? 1}`)
}
console.log(`Published ${pkgPath}`);
return pkgPath;
console.log(`Published ${pkgPath}`)
return pkgPath
}
function cleanWinBuildDir(arch) {
const platformDir = path.join(getBuildRoot(), `stable-win-${arch}`);
const platformDir = path.join(getBuildRoot(), `stable-win-${arch}`)
if (existsSync(platformDir)) {
rmSync(platformDir, { recursive: true, force: true });
console.log(`Removed build output ${platformDir}`);
rmSync(platformDir, { recursive: true, force: true })
console.log(`Removed build output ${platformDir}`)
}
}
function buildWindowsNsis(appDir, arch) {
const scriptPath = path.join(rootDir, "scripts/build-windows-nsis.ps1");
const scriptPath = path.join(rootDir, 'scripts/build-windows-nsis.ps1')
const exePath = path.join(
artifactDir,
getReleaseArtifactName(version, arch, "exe"),
);
getReleaseArtifactName(version, arch, 'exe')
)
const powershell = process.env.SystemRoot
? path.join(
process.env.SystemRoot,
"System32",
"WindowsPowerShell",
"v1.0",
"powershell.exe",
'System32',
'WindowsPowerShell',
'v1.0',
'powershell.exe'
)
: "powershell.exe";
: 'powershell.exe'
const result = spawnSync(
powershell,
[
"-NoProfile",
"-ExecutionPolicy",
"Bypass",
"-File",
'-NoProfile',
'-ExecutionPolicy',
'Bypass',
'-File',
scriptPath,
"-AppDir",
'-AppDir',
appDir,
"-OutputExe",
'-OutputExe',
exePath,
"-Version",
version,
'-Version',
version
],
{ stdio: "inherit" },
);
{ stdio: 'inherit' }
)
if (result.status !== 0) {
throw new Error(
`build-windows-nsis.ps1 failed with exit code ${result.status ?? 1}`,
);
`build-windows-nsis.ps1 failed with exit code ${result.status ?? 1}`
)
}
const minInstallerBytes = 10 * 1024 * 1024;
const installerSize = statSync(exePath).size;
const minInstallerBytes = 10 * 1024 * 1024
const installerSize = statSync(exePath).size
if (installerSize < minInstallerBytes) {
throw new Error(
`Windows installer ${path.basename(exePath)} is only ${(installerSize / 1024).toFixed(1)} KiB; expected at least ${minInstallerBytes / (1024 * 1024)} MiB`,
);
`Windows installer ${path.basename(exePath)} is only ${(installerSize / 1024).toFixed(1)} KiB; expected at least ${minInstallerBytes / (1024 * 1024)} MiB`
)
}
console.log(`Published ${exePath}`);
return exePath;
console.log(`Published ${exePath}`)
return exePath
}
function buildWindowsMsi(setupExePath, arch) {
const scriptPath = path.join(rootDir, "scripts/build-windows-msi.ps1");
const scriptPath = path.join(rootDir, 'scripts/build-windows-msi.ps1')
const msiPath = path.join(
artifactDir,
getReleaseArtifactName(version, arch, "msi"),
);
getReleaseArtifactName(version, arch, 'msi')
)
const powershell = process.env.SystemRoot
? path.join(
process.env.SystemRoot,
"System32",
"WindowsPowerShell",
"v1.0",
"powershell.exe",
'System32',
'WindowsPowerShell',
'v1.0',
'powershell.exe'
)
: "powershell.exe";
: 'powershell.exe'
const result = spawnSync(
powershell,
[
"-NoProfile",
"-ExecutionPolicy",
"Bypass",
"-File",
'-NoProfile',
'-ExecutionPolicy',
'Bypass',
'-File',
scriptPath,
"-SetupExe",
'-SetupExe',
setupExePath,
"-OutputMsi",
'-OutputMsi',
msiPath,
"-Version",
version,
'-Version',
version
],
{ stdio: "inherit" },
);
{ stdio: 'inherit' }
)
if (result.status !== 0) {
throw new Error(
`build-windows-msi.ps1 failed with exit code ${result.status ?? 1}`,
);
`build-windows-msi.ps1 failed with exit code ${result.status ?? 1}`
)
}
console.log(`Published ${msiPath}`);
return msiPath;
console.log(`Published ${msiPath}`)
return msiPath
}
if (buildEnv === "dev") {
console.log("finalize-desktop-artifacts: skipping dev build");
process.exit(0);
if (buildEnv === 'dev') {
console.log('finalize-desktop-artifacts: skipping dev build')
process.exit(0)
}
async function main() {
if (targetOs === "macos") {
const appBundle = findMacAppBundle(buildArch);
if (targetOs === 'macos') {
const appBundle = findMacAppBundle(buildArch)
if (!appBundle) {
console.log(
`finalize-desktop-artifacts: no macOS ${buildArch} app bundle found, skipping`,
);
process.exit(0);
`finalize-desktop-artifacts: no macOS ${buildArch} app bundle found, skipping`
)
process.exit(0)
}
codesignMacAppBundle(appBundle);
codesignMacAppBundle(appBundle)
const existingDmg = findMacDmgSource(buildArch);
const existingDmg = findMacDmgSource(buildArch)
const dmgPath = existingDmg
? publishArtifact(existingDmg, buildArch, "dmg")
: await buildMacDmg(appBundle, buildArch);
? publishArtifact(existingDmg, buildArch, 'dmg')
: await buildMacDmg(appBundle, buildArch)
const published = [dmgPath, buildMacPkg(appBundle, buildArch)];
const published = [dmgPath, buildMacPkg(appBundle, buildArch)]
cleanStagingArtifacts(published.map((filePath) => path.basename(filePath)));
cleanMacBuildDir(buildArch);
return;
cleanStagingArtifacts(published.map((filePath) => path.basename(filePath)))
cleanMacBuildDir(buildArch)
return
}
if (targetOs === "win") {
const arch = getReleaseArch(process.env.ELECTROBUN_ARCH || "x64");
const installerFiles = findWindowsInstallerFiles();
if (targetOs === 'win') {
const arch = getReleaseArch(process.env.ELECTROBUN_ARCH || 'x64')
const installerFiles = findWindowsInstallerFiles()
if (!installerFiles?.setupArchive) {
throw new Error(
"Could not find the Windows setup archive (.tar.zst) to expand",
);
'Could not find the Windows setup archive (.tar.zst) to expand'
)
}
const platformDir = path.dirname(installerFiles.setupArchive);
const platformDir = path.dirname(installerFiles.setupArchive)
const appDir = expandWindowsAppFromArchive(
installerFiles.setupArchive,
platformDir,
);
platformDir
)
let published;
let published
try {
const setupExe = buildWindowsNsis(appDir, arch);
published = [setupExe, buildWindowsMsi(setupExe, arch)];
const setupExe = buildWindowsNsis(appDir, arch)
published = [setupExe, buildWindowsMsi(setupExe, arch)]
if (installerFiles.setupZip) {
published.push(publishArtifact(installerFiles.setupZip, arch, "zip"));
published.push(publishArtifact(installerFiles.setupZip, arch, 'zip'))
}
} finally {
cleanExpandedWindowsApp(platformDir);
cleanExpandedWindowsApp(platformDir)
}
cleanStagingArtifacts(published.map((filePath) => path.basename(filePath)));
cleanWinBuildDir(arch);
return;
cleanStagingArtifacts(published.map((filePath) => path.basename(filePath)))
cleanWinBuildDir(arch)
return
}
console.log(
"finalize-desktop-artifacts: no desktop packaging configured for",
targetOs ?? "unknown target",
);
process.exit(0);
'finalize-desktop-artifacts: no desktop packaging configured for',
targetOs ?? 'unknown target'
)
process.exit(0)
}
await main();
await main()