farmcontrol-server/scripts/finalize-desktop-artifacts.mjs

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";

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 CREATE_DMG_PATH = "/usr/local/bin/create-dmg";

function buildMacDmgWithCreateDmg(
  createDmg,
  appBundlePath,
  dmgPath,
  stagingDir,
) {
  const appName = path.basename(appBundlePath);
  cpSync(appBundlePath, path.join(stagingDir, appName), {
    recursive: true,
    dereference: true,
  });

  rmSync(dmgPath, { force: true });

  const result = spawnSync(
    createDmg,
    [
      "--volname",
      "Farm Control Server",
      "--app-drop-link",
      "480",
      "170",
      "--format",
      "UDZO",
      dmgPath,
      stagingDir,
    ],
    { 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 buildMacDmg(appBundlePath, arch) {
  if (!existsSync(CREATE_DMG_PATH)) {
    throw new Error(`create-dmg not found at ${CREATE_DMG_PATH}`);
  }

  const dmgPath = path.join(
    artifactDir,
    getReleaseArtifactName(version, arch, "dmg"),
  );

  mkdirSync(artifactDir, { recursive: true });

  const stagingDir = path.join(
    path.dirname(appBundlePath),
    ".finalize-dmg-staging",
  );
  rmSync(stagingDir, { recursive: true, force: true });
  mkdirSync(stagingDir, { recursive: true });

  let builtDmgPath;

  try {
    builtDmgPath = buildMacDmgWithCreateDmg(
      CREATE_DMG_PATH,
      appBundlePath,
      dmgPath,
      stagingDir,
    );
  } finally {
    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;
}

if (buildEnv === "dev") {
  console.log("finalize-desktop-artifacts: skipping dev build");
  process.exit(0);
}

if (targetOs === "macos") {
  const appBundle = findMacAppBundle(buildArch);

  if (!appBundle) {
    console.log(
      `finalize-desktop-artifacts: no macOS ${buildArch} app bundle found, skipping`,
    );
    process.exit(0);
  }

  const existingDmg = findMacDmgSource(buildArch);
  const dmgPath = existingDmg
    ? publishArtifact(existingDmg, buildArch, "dmg")
    : buildMacDmg(appBundle, buildArch);

  const published = [dmgPath, buildMacPkg(appBundle, buildArch)];

  cleanStagingArtifacts(published.map((filePath) => path.basename(filePath)));
  cleanMacBuildDir(buildArch);
} else 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 {
    published = [buildWindowsNsis(appDir, arch)];

    if (installerFiles.setupZip) {
      published.push(publishArtifact(installerFiles.setupZip, arch, "zip"));
    }
  } finally {
    cleanExpandedWindowsApp(platformDir);
  }

  cleanStagingArtifacts(published.map((filePath) => path.basename(filePath)));
  cleanWinBuildDir(arch);
} else {
  console.log(
    "finalize-desktop-artifacts: no desktop packaging configured for",
    targetOs ?? "unknown target",
  );
  process.exit(0);
}