Tom Butcher
f63b1fbc37
- Added functionality to ensure the presence of DMG assets, including a volume icon and background image, using Jimp for image creation. - Refactored the DMG building process to incorporate these assets, improving the visual presentation of the generated DMG. - Updated the buildMacDmgWithCreateDmg function to accept additional parameters for app bundle name and DMG assets, enhancing flexibility.
597 lines
14 KiB
JavaScript
597 lines
14 KiB
JavaScript
import {
|
|
cpSync,
|
|
existsSync,
|
|
mkdirSync,
|
|
readdirSync,
|
|
readFileSync,
|
|
rmSync,
|
|
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";
|
|
import {
|
|
cleanExpandedWindowsApp,
|
|
expandWindowsAppFromArchive,
|
|
} from "./expand-windows-installer.mjs";
|
|
import { codesignMacAppBundle } from "./codesign-macos-app.mjs";
|
|
|
|
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";
|
|
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,
|
|
);
|
|
const version =
|
|
process.env.ELECTROBUN_APP_VERSION || getReleaseVersion(packageJson);
|
|
const artifactDir =
|
|
process.env.ELECTROBUN_ARTIFACT_DIR || path.join(rootDir, "app_dist");
|
|
const identifier =
|
|
process.env.ELECTROBUN_APP_IDENTIFIER || "com.tombutcher.farmcontrolserver";
|
|
const artifactPrefix = `farmcontrol-server-${version}-`;
|
|
|
|
function getBuildRoot() {
|
|
const electrobunBuildDir = process.env.ELECTROBUN_BUILD_DIR;
|
|
if (!electrobunBuildDir) {
|
|
return path.join(rootDir, "build");
|
|
}
|
|
|
|
const baseName = path.basename(electrobunBuildDir);
|
|
if (baseName.startsWith("stable-")) {
|
|
return path.dirname(electrobunBuildDir);
|
|
}
|
|
|
|
return electrobunBuildDir;
|
|
}
|
|
|
|
function walkFiles(dir) {
|
|
const files = [];
|
|
if (!existsSync(dir)) {
|
|
return files;
|
|
}
|
|
|
|
for (const entry of readdirSync(dir)) {
|
|
const fullPath = path.join(dir, entry);
|
|
const stats = statSync(fullPath);
|
|
if (stats.isDirectory()) {
|
|
files.push(...walkFiles(fullPath));
|
|
} else {
|
|
files.push(fullPath);
|
|
}
|
|
}
|
|
|
|
return files;
|
|
}
|
|
|
|
function findByExtension(root, extension) {
|
|
return walkFiles(root).find((filePath) =>
|
|
filePath.toLowerCase().endsWith(extension.toLowerCase()),
|
|
);
|
|
}
|
|
|
|
function findMacAppBundle(arch) {
|
|
const platformDir = path.join(getBuildRoot(), `stable-macos-${arch}`);
|
|
if (!existsSync(platformDir)) {
|
|
return null;
|
|
}
|
|
|
|
for (const child of readdirSync(platformDir)) {
|
|
if (child.endsWith(".app")) {
|
|
return path.join(platformDir, child);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function findMacDmgSource(arch) {
|
|
const prefixedArtifact = walkFiles(artifactDir).find(
|
|
(filePath) =>
|
|
filePath.includes(`stable-macos-${arch}`) &&
|
|
filePath.toLowerCase().endsWith(".dmg"),
|
|
);
|
|
if (prefixedArtifact) {
|
|
return prefixedArtifact;
|
|
}
|
|
|
|
const buildDmg = findByExtension(
|
|
path.join(getBuildRoot(), `stable-macos-${arch}`),
|
|
".dmg",
|
|
);
|
|
if (buildDmg) {
|
|
return buildDmg;
|
|
}
|
|
|
|
return findByExtension(artifactDir, ".dmg");
|
|
}
|
|
|
|
function findWindowsInstallerFiles() {
|
|
const buildRoot = getBuildRoot();
|
|
if (!existsSync(buildRoot)) {
|
|
return null;
|
|
}
|
|
|
|
for (const entry of readdirSync(buildRoot)) {
|
|
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 setupArchive = files.find((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));
|
|
|
|
if (setupExe && setupArchive && setupMetadata) {
|
|
return { setupExe, setupArchive, setupMetadata, setupZip };
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function publishArtifact(sourcePath, arch, ext) {
|
|
if (!sourcePath || !existsSync(sourcePath)) {
|
|
throw new Error(
|
|
`Missing source artifact for ${arch}.${ext}: ${sourcePath ?? "not found"}`,
|
|
);
|
|
}
|
|
|
|
mkdirSync(artifactDir, { recursive: true });
|
|
const destination = path.join(
|
|
artifactDir,
|
|
getReleaseArtifactName(version, arch, ext),
|
|
);
|
|
cpSync(sourcePath, destination);
|
|
console.log(`Published ${destination}`);
|
|
return destination;
|
|
}
|
|
|
|
function cleanStagingArtifacts(keepNames) {
|
|
if (!existsSync(artifactDir)) {
|
|
return;
|
|
}
|
|
|
|
for (const entry of readdirSync(artifactDir)) {
|
|
if (keepNames.includes(entry) || entry.startsWith(artifactPrefix)) {
|
|
continue;
|
|
}
|
|
|
|
if (
|
|
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 });
|
|
}
|
|
}
|
|
}
|
|
|
|
const MAC_DMG_ASSETS_DIR = path.join(rootDir, "packaging/macos/dmg");
|
|
const MAC_DMG_APP_NAME = "Farm Control Server.app";
|
|
|
|
async function ensureMacDmgAssets() {
|
|
mkdirSync(MAC_DMG_ASSETS_DIR, { recursive: true });
|
|
|
|
const voliconPath = path.join(MAC_DMG_ASSETS_DIR, "volicon.icns");
|
|
const backgroundPath = path.join(MAC_DMG_ASSETS_DIR, "background.png");
|
|
const iconsetPath = path.join(rootDir, "assets/icon.iconset");
|
|
|
|
if (!existsSync(voliconPath) && existsSync(iconsetPath)) {
|
|
const iconutil = spawnSync(
|
|
"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}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!existsSync(backgroundPath)) {
|
|
const { Jimp } = await import("jimp");
|
|
const background = new Jimp({ width: 700, height: 450, color: "#1f1f1f" });
|
|
await background.write(backgroundPath);
|
|
console.log(`finalize-desktop-artifacts: generated DMG background at ${backgroundPath}`);
|
|
}
|
|
|
|
return {
|
|
volicon: existsSync(voliconPath) ? voliconPath : null,
|
|
background: existsSync(backgroundPath) ? backgroundPath : null,
|
|
};
|
|
}
|
|
|
|
function findCreateDmgCommand() {
|
|
const which = spawnSync("which", ["create-dmg"], { encoding: "utf8" });
|
|
if (which.status === 0 && which.stdout.trim()) {
|
|
return which.stdout.trim();
|
|
}
|
|
|
|
for (const candidate of [
|
|
"/opt/homebrew/bin/create-dmg",
|
|
"/usr/local/bin/create-dmg",
|
|
]) {
|
|
if (existsSync(candidate)) {
|
|
return candidate;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function buildMacDmgWithCreateDmg(
|
|
createDmg,
|
|
dmgPath,
|
|
sourceFolder,
|
|
appBundleName,
|
|
dmgAssets,
|
|
) {
|
|
rmSync(dmgPath, { force: true });
|
|
|
|
const args = [
|
|
"--volname",
|
|
"Farm Control Server",
|
|
"--window-pos",
|
|
"200",
|
|
"120",
|
|
"--window-size",
|
|
"700",
|
|
"450",
|
|
"--icon-size",
|
|
"120",
|
|
"--icon",
|
|
appBundleName,
|
|
"180",
|
|
"200",
|
|
"--hide-extension",
|
|
appBundleName,
|
|
"--app-drop-link",
|
|
"520",
|
|
"200",
|
|
"--format",
|
|
"UDZO",
|
|
];
|
|
|
|
if (dmgAssets.volicon) {
|
|
args.push("--volicon", dmgAssets.volicon);
|
|
}
|
|
|
|
if (dmgAssets.background) {
|
|
args.push("--background", dmgAssets.background);
|
|
}
|
|
|
|
args.push(dmgPath, sourceFolder);
|
|
|
|
const result = spawnSync(createDmg, args, { stdio: "inherit" });
|
|
|
|
if (result.status !== 0) {
|
|
throw new Error(`create-dmg failed with exit code ${result.status ?? 1}`);
|
|
}
|
|
|
|
if (!existsSync(dmgPath)) {
|
|
throw new Error(`create-dmg did not produce ${dmgPath}`);
|
|
}
|
|
|
|
return dmgPath;
|
|
}
|
|
|
|
function copyMacAppBundle(sourcePath, destinationPath) {
|
|
rmSync(destinationPath, { recursive: true, force: true });
|
|
mkdirSync(path.dirname(destinationPath), { recursive: true });
|
|
|
|
const result = spawnSync("ditto", [sourcePath, destinationPath], {
|
|
stdio: "inherit",
|
|
});
|
|
|
|
if (result.status !== 0) {
|
|
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 entries = readdirSync(platformDir).filter(
|
|
(entry) =>
|
|
!entry.startsWith(".") && entry !== ".finalize-dmg-staging",
|
|
);
|
|
|
|
return entries.length === 1 && entries[0] === appName;
|
|
}
|
|
|
|
async function buildMacDmg(appBundlePath, arch) {
|
|
const createDmg = findCreateDmgCommand();
|
|
if (!createDmg) {
|
|
throw new Error(
|
|
"create-dmg not found. Install with: brew install create-dmg",
|
|
);
|
|
}
|
|
|
|
const appBundleName = path.basename(appBundlePath);
|
|
if (appBundleName !== MAC_DMG_APP_NAME) {
|
|
console.warn(
|
|
`finalize-desktop-artifacts: expected ${MAC_DMG_APP_NAME}, found ${appBundleName}`,
|
|
);
|
|
}
|
|
|
|
const dmgPath = path.join(
|
|
artifactDir,
|
|
getReleaseArtifactName(version, arch, "dmg"),
|
|
);
|
|
|
|
mkdirSync(artifactDir, { recursive: true });
|
|
|
|
const stagingDir = path.join(
|
|
path.dirname(appBundlePath),
|
|
".finalize-dmg-staging",
|
|
);
|
|
const useDirectSource = canUseDirectDmgSourceFolder(appBundlePath);
|
|
const sourceFolder = useDirectSource
|
|
? path.dirname(appBundlePath)
|
|
: 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);
|
|
}
|
|
|
|
let builtDmgPath;
|
|
const dmgAssets = await ensureMacDmgAssets();
|
|
|
|
try {
|
|
builtDmgPath = buildMacDmgWithCreateDmg(
|
|
createDmg,
|
|
dmgPath,
|
|
sourceFolder,
|
|
appBundleName,
|
|
dmgAssets,
|
|
);
|
|
} finally {
|
|
if (!useDirectSource) {
|
|
rmSync(stagingDir, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
console.log(`Published ${builtDmgPath}`);
|
|
return builtDmgPath;
|
|
}
|
|
|
|
function cleanMacBuildDir(arch) {
|
|
const platformDir = path.join(getBuildRoot(), `stable-macos-${arch}`);
|
|
if (existsSync(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"),
|
|
);
|
|
|
|
const result = spawnSync(
|
|
"pkgbuild",
|
|
[
|
|
"--component",
|
|
appBundlePath,
|
|
"--install-location",
|
|
"/Applications",
|
|
"--identifier",
|
|
identifier,
|
|
"--version",
|
|
version,
|
|
pkgPath,
|
|
],
|
|
{ stdio: "inherit" },
|
|
);
|
|
|
|
if (result.status !== 0) {
|
|
throw new Error(`pkgbuild failed with exit code ${result.status ?? 1}`);
|
|
}
|
|
|
|
console.log(`Published ${pkgPath}`);
|
|
return pkgPath;
|
|
}
|
|
|
|
function cleanWinBuildDir(arch) {
|
|
const platformDir = path.join(getBuildRoot(), `stable-win-${arch}`);
|
|
if (existsSync(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 exePath = path.join(
|
|
artifactDir,
|
|
getReleaseArtifactName(version, arch, "exe"),
|
|
);
|
|
const powershell =
|
|
process.env.SystemRoot
|
|
? path.join(
|
|
process.env.SystemRoot,
|
|
"System32",
|
|
"WindowsPowerShell",
|
|
"v1.0",
|
|
"powershell.exe",
|
|
)
|
|
: "powershell.exe";
|
|
|
|
const result = spawnSync(
|
|
powershell,
|
|
[
|
|
"-NoProfile",
|
|
"-ExecutionPolicy",
|
|
"Bypass",
|
|
"-File",
|
|
scriptPath,
|
|
"-AppDir",
|
|
appDir,
|
|
"-OutputExe",
|
|
exePath,
|
|
"-Version",
|
|
version,
|
|
],
|
|
{ stdio: "inherit" },
|
|
);
|
|
|
|
if (result.status !== 0) {
|
|
throw new Error(
|
|
`build-windows-nsis.ps1 failed with exit code ${result.status ?? 1}`,
|
|
);
|
|
}
|
|
|
|
console.log(`Published ${exePath}`);
|
|
return exePath;
|
|
}
|
|
|
|
function buildWindowsMsi(setupExePath, arch) {
|
|
const scriptPath = path.join(rootDir, "scripts/build-windows-msi.ps1");
|
|
const msiPath = path.join(
|
|
artifactDir,
|
|
getReleaseArtifactName(version, arch, "msi"),
|
|
);
|
|
const powershell =
|
|
process.env.SystemRoot
|
|
? path.join(
|
|
process.env.SystemRoot,
|
|
"System32",
|
|
"WindowsPowerShell",
|
|
"v1.0",
|
|
"powershell.exe",
|
|
)
|
|
: "powershell.exe";
|
|
|
|
const result = spawnSync(
|
|
powershell,
|
|
[
|
|
"-NoProfile",
|
|
"-ExecutionPolicy",
|
|
"Bypass",
|
|
"-File",
|
|
scriptPath,
|
|
"-SetupExe",
|
|
setupExePath,
|
|
"-OutputMsi",
|
|
msiPath,
|
|
"-Version",
|
|
version,
|
|
],
|
|
{ stdio: "inherit" },
|
|
);
|
|
|
|
if (result.status !== 0) {
|
|
throw new Error(
|
|
`build-windows-msi.ps1 failed with exit code ${result.status ?? 1}`,
|
|
);
|
|
}
|
|
|
|
console.log(`Published ${msiPath}`);
|
|
return msiPath;
|
|
}
|
|
|
|
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 (!appBundle) {
|
|
console.log(
|
|
`finalize-desktop-artifacts: no macOS ${buildArch} app bundle found, skipping`,
|
|
);
|
|
process.exit(0);
|
|
}
|
|
|
|
codesignMacAppBundle(appBundle);
|
|
|
|
const existingDmg = findMacDmgSource(buildArch);
|
|
const dmgPath = existingDmg
|
|
? publishArtifact(existingDmg, buildArch, "dmg")
|
|
: await buildMacDmg(appBundle, buildArch);
|
|
|
|
const published = [dmgPath, buildMacPkg(appBundle, buildArch)];
|
|
|
|
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 (!installerFiles?.setupArchive) {
|
|
throw new Error(
|
|
"Could not find the Windows setup archive (.tar.zst) to expand",
|
|
);
|
|
}
|
|
|
|
const platformDir = path.dirname(installerFiles.setupArchive);
|
|
const appDir = expandWindowsAppFromArchive(
|
|
installerFiles.setupArchive,
|
|
platformDir,
|
|
);
|
|
|
|
let published;
|
|
try {
|
|
const setupExe = buildWindowsNsis(appDir, arch);
|
|
published = [setupExe, buildWindowsMsi(setupExe, arch)];
|
|
|
|
if (installerFiles.setupZip) {
|
|
published.push(publishArtifact(installerFiles.setupZip, arch, "zip"));
|
|
}
|
|
} finally {
|
|
cleanExpandedWindowsApp(platformDir);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
await main();
|