@flare-desktop/cli 0.0.0-stage → 0.1.1

package/src/lib/packaging/common.js

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+
+import { FlareError } from "../errors.js";
+
+export function numericVersion(version) {
+  const match = String(version).match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) throw new FlareError(`'${version}' is not a numeric semantic version`);
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+export function msiVersion(version) {
+  const [major, minor, patch] = numericVersion(version);
+  if (major > 255 || minor > 255 || patch > 65535) {
+    throw new FlareError(`'${version}' cannot be represented as an msi version`);
+  }
+  return `${major}.${minor}.${patch}`;
+}
+
+export function fourPartVersion(version) {
+  const [major, minor, patch] = numericVersion(version);
+  return `${major}.${minor}.${patch}.0`;
+}
+
+export function debVersion(version) {
+  return String(version).replace(/-/g, "~");
+}
+
+export function rpmVersion(version) {
+  return String(version).replace(/-/g, "~");
+}
+
+export function safeName(value) {
+  const name = String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9+.-]+/g, "-")
+    .replace(/^[^a-z0-9]+/, "")
+    .replace(/-{2,}/g, "-")
+    .replace(/[.-]+$/, "");
+  return name || "flare-app";
+}
+
+export function artifactName(value) {
+  return String(value)
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/-{2,}/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+export function windowsArchitecture(architecture = process.arch) {
+  if (architecture === "x64") return "x64";
+  if (architecture === "arm64") return "arm64";
+  if (architecture === "ia32") return "x86";
+  return architecture;
+}
+
+export function debArchitecture(architecture = process.arch) {
+  if (architecture === "x64") return "amd64";
+  if (architecture === "arm64") return "arm64";
+  if (architecture === "ia32") return "i386";
+  if (architecture === "arm") return "armhf";
+  return architecture;
+}
+
+export function rpmArchitecture(architecture = process.arch) {
+  if (architecture === "x64") return "x86_64";
+  if (architecture === "arm64") return "aarch64";
+  if (architecture === "ia32") return "i686";
+  return architecture;
+}
+
+export function appImageArchitecture(architecture = process.arch) {
+  if (architecture === "x64") return "x86_64";
+  if (architecture === "arm64") return "aarch64";
+  if (architecture === "ia32") return "i686";
+  return architecture;
+}
+
+export function stableGuid(seed) {
+  const bytes = createHash("sha1").update(String(seed)).digest().subarray(0, 16);
+  bytes[6] = (bytes[6] & 0x0f) | 0x50;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = bytes.toString("hex").toUpperCase();
+  return `{${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}}`;
+}
+
+export function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+export function escapeNsis(value) {
+  return String(value).replace(/\$/g, "$$").replace(/"/g, '$\\"');
+}
+
+export function escapeDesktop(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+
+export function desktopCategory(category) {
+  const categories = {
+    DeveloperTool: "Development;",
+    Development: "Development;",
+    Utility: "Utility;",
+    Productivity: "Office;",
+    Graphics: "Graphics;",
+    Music: "Audio;",
+    Video: "AudioVideo;",
+    Network: "Network;",
+    Game: "Game;",
+    Education: "Education;",
+    Science: "Science;"
+  };
+  return categories[category] || "Utility;";
+}
+
+export function maintainer(config) {
+  const value = config.bundle?.publisher || config.app?.authors?.[0] || "flare-desktop";
+  return value.includes("@") ? value : `${value} <noreply@flare-desktop.dev>`;
+}
+
+export function description(config) {
+  return config.bundle?.shortDescription || config.app?.description || `${config.app?.productName || "flare"} built with flare`;
+}
+
+export function longDescription(config) {
+  return config.bundle?.longDescription || description(config);
+}

package/src/lib/packaging/index.js

@@ -0,0 +1,228 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+
+import { FlareError } from "../errors.js";
+import { formatsForPlatform, platformDisplayName } from "../project.js";
+import {
+  appImageArchitecture,
+  debArchitecture,
+  rpmArchitecture,
+  windowsArchitecture
+} from "./common.js";
+import { buildNsis } from "./nsis.js";
+import { buildMsi } from "./msi.js";
+import { buildAppBundle, buildDmg, signApp } from "./macos.js";
+import { buildAppImage, buildDeb, buildRpm } from "./linux.js";
+import { cleanStage, stageIcons, stagePayload } from "./staging.js";
+import { requireTool } from "./tools.js";
+
+const HOST_TARGETS = {
+  win32: ["msi", "nsis"],
+  darwin: ["app", "dmg"],
+  linux: ["deb", "rpm", "appimage"]
+};
+
+const TOOL_HINTS = {
+  makensis: "install NSIS 3 from https://nsis.sourceforge.io",
+  candle: "install WiX Toolset 3.14 and put candle.exe on PATH",
+  light: "install WiX Toolset 3.14 and put light.exe on PATH",
+  "dpkg-deb": "install dpkg-dev on Debian/Ubuntu",
+  rpmbuild: "install rpm-build on Fedora/RHEL or rpm on Debian/Ubuntu",
+  appimagetool: "download appimagetool from https://github.com/AppImage/appimagetool",
+  hdiutil: "run packaging on macOS",
+  codesign: "install Xcode command line tools"
+};
+
+export function bundleTargets(config, requested, platform = process.platform) {
+  if (!config.bundle?.active) throw new FlareError("bundle.active is false for this project");
+
+  const available = HOST_TARGETS[platform] ?? [];
+  const source =
+    requested === undefined ||
+    requested === null ||
+    requested === "" ||
+    (Array.isArray(requested) && requested.length === 0)
+      ? config.bundle.targets ?? []
+      : requested;
+  const values = (Array.isArray(source) ? source : String(source).split(","))
+    .map((value) => String(value).trim().toLowerCase())
+    .filter(Boolean);
+  const selected = values.length === 0 || values.includes("all") ? formatsForPlatform(platform) : values;
+
+  if (selected.length === 0) {
+    throw new FlareError(`no bundle targets are available for ${platformDisplayName(platform)}`);
+  }
+
+  const unsupported = selected.filter((target) => !available.includes(target));
+  if (unsupported.length > 0) {
+    throw new FlareError(
+      `bundle target${unsupported.length === 1 ? "" : "s"} ${unsupported.map((target) => `'${target}'`).join(", ")} ` +
+        `not available on ${platformDisplayName(platform)}; available: ${available.join(", ")}`
+    );
+  }
+
+  return [...new Set(selected)];
+}
+
+export function bundleTools(targets, config, platform = process.platform) {
+  const tools = [];
+  for (const target of targets) {
+    if (target === "nsis") tools.push("makensis");
+    if (target === "msi") tools.push("candle", "light");
+    if (target === "deb") tools.push("dpkg-deb");
+    if (target === "rpm") tools.push("rpmbuild");
+    if (target === "appimage") tools.push("appimagetool");
+    if (target === "dmg") tools.push("hdiutil");
+    if (target === "app" && config.bundle?.macos?.signingIdentity) tools.push("codesign");
+  }
+  return [...new Set(tools)];
+}
+
+export function assertBundleTools(targets, config, platform = process.platform) {
+  for (const tool of bundleTools(targets, config, platform)) {
+    requireTool(tool, TOOL_HINTS[tool]);
+  }
+}
+
+export function bundleArchitecture(platform = process.platform) {
+  if (platform === "win32") return windowsArchitecture();
+  if (platform === "darwin") return process.arch === "arm64" ? "arm64" : "x64";
+  if (platform === "linux") return debArchitecture();
+  return process.arch;
+}
+
+export async function createBundles({
+  config,
+  projectDirectory,
+  binary,
+  targets,
+  output,
+  logger
+}) {
+  const outputRoot = path.resolve(projectDirectory, output || path.join("target", "bundle"));
+  const stageRoot = path.join(outputRoot, ".stage");
+  const icons = stageIcons({ config, projectDirectory, stageDirectory: stageRoot });
+  const payload = stagePayload({ config, projectDirectory, binary, stageDirectory: stageRoot, logger });
+  const platform = process.platform;
+  const artifacts = [];
+  let macApp = null;
+
+  mkdirSync(outputRoot, { recursive: true });
+  logger.info(`bundling '${config.app.productName}' ${config.app.version} for ${platformDisplayName(platform)}`);
+
+  try {
+    for (const target of targets) {
+      const outputDirectory = path.join(outputRoot, target);
+      const stageDirectory = path.join(stageRoot, target);
+      mkdirSync(stageDirectory, { recursive: true });
+      mkdirSync(outputDirectory, { recursive: true });
+
+      let artifact = null;
+      if (target === "nsis") {
+        artifact = await buildNsis({
+          config,
+          productName: config.app.productName,
+          version: config.app.version,
+          payload: payload.directory,
+          binaryName: payload.binaryName,
+          icons,
+          licenseSource: payload.licenseSource,
+          outputDirectory,
+          stageDirectory,
+          logger
+        });
+      } else if (target === "msi") {
+        artifact = await buildMsi({
+          config,
+          productName: config.app.productName,
+          version: config.app.version,
+          payload: payload.directory,
+          binaryName: payload.binaryName,
+          icons,
+          outputDirectory,
+          stageDirectory,
+          logger
+        });
+      } else if (target === "deb") {
+        artifact = await buildDeb({
+          config,
+          productName: config.app.productName,
+          version: config.app.version,
+          payload: payload.directory,
+          binaryName: payload.binaryName,
+          icons,
+          licenseSource: payload.licenseSource,
+          outputDirectory,
+          stageDirectory,
+          logger
+        });
+      } else if (target === "rpm") {
+        artifact = await buildRpm({
+          config,
+          productName: config.app.productName,
+          version: config.app.version,
+          payload: payload.directory,
+          binaryName: payload.binaryName,
+          icons,
+          licenseSource: payload.licenseSource,
+          outputDirectory,
+          stageDirectory,
+          logger
+        });
+      } else if (target === "appimage") {
+        artifact = await buildAppImage({
+          config,
+          productName: config.app.productName,
+          version: config.app.version,
+          payload: payload.directory,
+          binaryName: payload.binaryName,
+          icons,
+          licenseSource: payload.licenseSource,
+          outputDirectory,
+          stageDirectory,
+          logger
+        });
+      } else if (target === "app" || target === "dmg") {
+        if (!macApp) {
+          macApp = buildAppBundle({
+            config,
+            productName: config.app.productName,
+            version: config.app.version,
+            payload: payload.directory,
+            binaryName: payload.binaryName,
+            icons,
+            licenseSource: payload.licenseSource,
+            outputDirectory: path.join(outputRoot, "app"),
+            logger
+          });
+          if (config.bundle.macos?.signingIdentity) {
+            await signApp({
+              app: macApp,
+              identity: config.bundle.macos.signingIdentity,
+              logger
+            });
+          }
+        }
+        artifact =
+          target === "app"
+            ? macApp
+            : await buildDmg({
+                app: macApp,
+                productName: config.app.productName,
+                outputDirectory,
+                logger
+              });
+      }
+
+      artifacts.push({ target, path: artifact });
+      logger.step(`prepared ${target}: ${artifact}`);
+    }
+  } finally {
+    if (artifacts.length === targets.length) cleanStage(stageRoot);
+  }
+
+  logger.info(`artifacts written to '${outputRoot}'`);
+  return artifacts;
+}
+
+export { appImageArchitecture, debArchitecture, rpmArchitecture, windowsArchitecture };

package/src/lib/packaging/linux.js

@@ -0,0 +1,283 @@
+import { chmodSync, cpSync, mkdirSync, readdirSync, symlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+import {
+  appImageArchitecture,
+  debArchitecture,
+  debVersion,
+  description,
+  desktopCategory,
+  escapeDesktop,
+  longDescription,
+  maintainer,
+  rpmArchitecture,
+  rpmVersion,
+  safeName
+} from "./common.js";
+import { requireTool, runTool } from "./tools.js";
+import { directorySize } from "./staging.js";
+
+function copyContents(source, destination) {
+  mkdirSync(destination, { recursive: true });
+  for (const entry of readdirSync(source)) {
+    cpSync(path.join(source, entry), path.join(destination, entry), { recursive: true, force: true });
+  }
+}
+
+function desktopEntry({ config, packageName, binaryName, exec }) {
+  return [
+    "[Desktop Entry]",
+    "Type=Application",
+    `Name=${escapeDesktop(config.app.productName)}`,
+    `Comment=${escapeDesktop(description(config))}`,
+    `Exec=${escapeDesktop(exec)}`,
+    `Icon=${packageName}`,
+    "Terminal=false",
+    `Categories=${desktopCategory(config.bundle.category)}`,
+    ""
+  ].join("\n");
+}
+
+function rpmSafe(value) {
+  return String(value).replace(/%/g, "%%").replace(/\n/g, " ");
+}
+
+export async function buildDeb({
+  config,
+  productName,
+  version,
+  payload,
+  binaryName,
+  icons,
+  licenseSource,
+  outputDirectory,
+  stageDirectory,
+  logger
+}) {
+  const dpkgDeb = requireTool("dpkg-deb", "install dpkg-dev on Debian/Ubuntu");
+  const packageName = safeName(productName);
+  const architecture = debArchitecture();
+  const root = path.join(stageDirectory, "deb");
+  const packageRoot = path.join(root, "package");
+  const installRoot = path.join(packageRoot, "opt", packageName);
+  const artifact = path.join(outputDirectory, `${packageName}_${debVersion(version)}_${architecture}.deb`);
+
+  mkdirSync(installRoot, { recursive: true });
+  copyContents(payload, installRoot);
+
+  mkdirSync(path.join(packageRoot, "usr", "bin"), { recursive: true });
+  symlinkSync(path.join("..", "..", "opt", packageName, binaryName), path.join(packageRoot, "usr", "bin", packageName));
+
+  const applications = path.join(packageRoot, "usr", "share", "applications");
+  mkdirSync(applications, { recursive: true });
+  writeFileSync(
+    path.join(applications, `${packageName}.desktop`),
+    desktopEntry({ config, packageName, binaryName, exec: path.join("/opt", packageName, binaryName) })
+  );
+
+  const iconDirectory = path.join(packageRoot, "usr", "share", "icons", "hicolor", "512x512", "apps");
+  mkdirSync(iconDirectory, { recursive: true });
+  cpSync(icons.png, path.join(iconDirectory, `${packageName}.png`));
+
+  const docDirectory = path.join(packageRoot, "usr", "share", "doc", packageName);
+  mkdirSync(docDirectory, { recursive: true });
+  if (licenseSource) cpSync(licenseSource, path.join(docDirectory, "copyright"));
+
+  const size = Math.ceil(directorySize(packageRoot) / 1024);
+  const descriptionLines = String(longDescription(config)).split(/\r?\n/);
+  const control = [
+    `Package: ${packageName}`,
+    `Version: ${debVersion(version)}`,
+    `Architecture: ${architecture}`,
+    `Maintainer: ${maintainer(config)}`,
+    `Installed-Size: ${size}`,
+    "Section: utils",
+    "Priority: optional",
+    ...(config.bundle.homepage ? [`Homepage: ${config.bundle.homepage}`] : []),
+    `Description: ${description(config)}`,
+    ...descriptionLines.slice(1).map((line) => ` ${line || "."}`),
+    ""
+  ].join("\n");
+
+  mkdirSync(path.join(packageRoot, "DEBIAN"), { recursive: true });
+  writeFileSync(path.join(packageRoot, "DEBIAN", "control"), control);
+
+  if (logger) logger.info(`[deb] compiling ${path.basename(artifact)}`);
+  await runTool(dpkgDeb, ["--build", "--root-owner-group", packageRoot, artifact], {
+    cwd: stageDirectory,
+    logger
+  });
+  return artifact;
+}
+
+function findRpm(directory) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const target = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      const found = findRpm(target);
+      if (found) return found;
+    } else if (entry.isFile() && entry.name.endsWith(".rpm")) {
+      return target;
+    }
+  }
+  return null;
+}
+
+export async function buildRpm({
+  config,
+  productName,
+  version,
+  payload,
+  binaryName,
+  icons,
+  licenseSource,
+  outputDirectory,
+  stageDirectory,
+  logger
+}) {
+  const rpmbuild = requireTool("rpmbuild", "install rpm-build on Fedora/RHEL or rpm on Debian/Ubuntu");
+  const packageName = safeName(productName);
+  const architecture = rpmArchitecture();
+  const root = path.join(stageDirectory, "rpm");
+  const top = path.join(root, "rpmbuild");
+  const specDirectory = path.join(top, "SPECS");
+  const buildDirectory = path.join(top, "BUILD");
+  const rpmDirectory = path.join(outputDirectory, "rpms");
+  const spec = path.join(specDirectory, `${packageName}.spec`);
+  const docLine = licenseSource ? `/usr/share/doc/${packageName}/LICENSE` : "";
+  const size = Math.ceil(directorySize(payload) / 1024);
+
+  for (const directory of [specDirectory, buildDirectory, path.join(top, "SOURCES"), path.join(top, "BUILDROOT"), path.join(top, "SRPMS"), rpmDirectory]) {
+    mkdirSync(directory, { recursive: true });
+  }
+
+  const lines = [
+    `%define _binary_payload w9.gzdio`,
+    `%define _unpackaged_files_terminate_build 1`,
+    `Name: ${packageName}`,
+    `Version: ${rpmVersion(version)}`,
+    "Release: 1",
+    `Summary: ${rpmSafe(description(config))}`,
+    "License: MIT",
+    ...(config.bundle.homepage ? [`URL: ${config.bundle.homepage}`] : []),
+    `BuildArch: ${architecture}`,
+    "AutoReqProv: no",
+    "Group: Applications/Development",
+    "",
+    "%description",
+    rpmSafe(longDescription(config)),
+    "",
+    "%install",
+    `mkdir -p "%{buildroot}/opt/${packageName}"`,
+    `cp -R "${payload}/." "%{buildroot}/opt/${packageName}/"`,
+    `mkdir -p "%{buildroot}/usr/bin"`,
+    `ln -sf "../../opt/${packageName}/${binaryName}" "%{buildroot}/usr/bin/${packageName}"`,
+    `mkdir -p "%{buildroot}/usr/share/applications"`,
+    `cat > "%{buildroot}/usr/share/applications/${packageName}.desktop" <<'FLARE_DESKTOP_EOF'`,
+    desktopEntry({ config, packageName, binaryName, exec: path.join("/opt", packageName, binaryName) }),
+    "FLARE_DESKTOP_EOF",
+    `mkdir -p "%{buildroot}/usr/share/icons/hicolor/512x512/apps"`,
+    `cp "${icons.png}" "%{buildroot}/usr/share/icons/hicolor/512x512/apps/${packageName}.png"`,
+    ...(licenseSource
+      ? [
+          `mkdir -p "%{buildroot}/usr/share/doc/${packageName}"`,
+          `cp "${licenseSource}" "%{buildroot}/usr/share/doc/${packageName}/LICENSE"`
+        ]
+      : []),
+    "",
+    "%files",
+    `/opt/${packageName}`,
+    `/usr/bin/${packageName}`,
+    `/usr/share/applications/${packageName}.desktop`,
+    `/usr/share/icons/hicolor/512x512/apps/${packageName}.png`,
+    ...(docLine ? [docLine] : []),
+    "",
+    `# installed size: ${size} KiB`
+  ];
+
+  writeFileSync(spec, `${lines.join("\n")}\n`, "utf8");
+
+  if (logger) logger.info(`[rpm] compiling ${packageName}-${rpmVersion(version)}-1.${architecture}.rpm`);
+  await runTool(
+    rpmbuild,
+    [
+      "-bb",
+      "--define",
+      `_topdir ${top}`,
+      "--define",
+      `_builddir ${buildDirectory}`,
+      "--define",
+      `_rpmdir ${rpmDirectory}`,
+      "--define",
+      `_srcrpmdir ${path.join(top, "SRPMS")}`,
+      "--define",
+      `_specdir ${specDirectory}`,
+      "--define",
+      `_sourcedir ${path.join(top, "SOURCES")}`,
+      "--define",
+      `_buildrootdir ${path.join(top, "BUILDROOT")}`,
+      spec
+    ],
+    { cwd: stageDirectory, logger }
+  );
+
+  const artifact = findRpm(rpmDirectory);
+  if (!artifact) throw new Error(`rpmbuild did not produce an rpm in '${rpmDirectory}'`);
+  return artifact;
+}
+
+export async function buildAppImage({
+  config,
+  productName,
+  version,
+  payload,
+  binaryName,
+  icons,
+  licenseSource,
+  outputDirectory,
+  stageDirectory,
+  logger
+}) {
+  const appimagetool = requireTool("appimagetool", "download appimagetool from https://github.com/AppImage/appimagetool");
+  const packageName = safeName(productName);
+  const architecture = appImageArchitecture();
+  const appDir = path.join(stageDirectory, "appimage", "AppDir");
+  const binaryDirectory = path.join(appDir, "usr", "bin");
+  const applications = path.join(appDir, "usr", "share", "applications");
+  const iconDirectory = path.join(appDir, "usr", "share", "icons", "hicolor", "512x512", "apps");
+  const artifact = path.join(outputDirectory, `${packageName}_${version}_${architecture}.AppImage`);
+
+  copyContents(payload, binaryDirectory);
+  mkdirSync(applications, { recursive: true });
+  mkdirSync(iconDirectory, { recursive: true });
+
+  const desktop = desktopEntry({ config, packageName, binaryName, exec: packageName });
+  writeFileSync(path.join(applications, `${packageName}.desktop`), desktop);
+  writeFileSync(path.join(appDir, `${packageName}.desktop`), desktop);
+  cpSync(icons.png, path.join(iconDirectory, `${packageName}.png`));
+  cpSync(icons.png, path.join(appDir, `${packageName}.png`));
+  symlinkSync(`${packageName}.png`, path.join(appDir, ".DirIcon"));
+
+  if (licenseSource) {
+    const doc = path.join(appDir, "usr", "share", "doc", packageName);
+    mkdirSync(doc, { recursive: true });
+    cpSync(licenseSource, path.join(doc, "LICENSE"));
+  }
+
+  const appRun = path.join(appDir, "AppRun");
+  writeFileSync(
+    appRun,
+    `#!/bin/sh\nHERE="$(dirname "$(readlink -f "$0")")"\nexec "$HERE/usr/bin/${binaryName}" "$@"\n`
+  );
+  chmodSync(appRun, 0o755);
+  chmodSync(path.join(binaryDirectory, binaryName), 0o755);
+
+  mkdirSync(outputDirectory, { recursive: true });
+  if (logger) logger.info(`[appimage] compiling ${path.basename(artifact)}`);
+  await runTool(appimagetool, [appDir, artifact], {
+    cwd: stageDirectory,
+    env: { ARCH: architecture },
+    logger
+  });
+  return artifact;
+}