@nwutils/packager 0.4.0 → 0.6.0

package/src/util.js

@@ -1,3 +1,4 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
 
 /**
@@ -71,16 +72,215 @@ function parseDesktopEntry(contents) {
 function stringifyDesktopEntry(entries) {
   let fileContent = "[Desktop Entry]\n";
   for (const key of Object.keys(entries)) {
-    if (entries[key] !== undefined) {
-      fileContent += `${key}=${entries[key]}\n`;
+    const value = entries[key];
+    if (value !== undefined) {
+      /* A line break would let the key or value inject further entries, eg. a second `Exec`. */
+      if (/[\r\n]/.test(key) || /[\r\n]/.test(value)) {
+        throw new Error(
+          `Desktop entry keys and values must not contain line breaks. Received: ${JSON.stringify(`${key}=${value}`)}`,
+        );
+      }
+      fileContent += `${key}=${value}\n`;
     }
   }
   return fileContent;
 }
 
+/**
+ * Quote `value` as a single POSIX shell word. Inside single quotes nothing is
+ * expanded, so only single quotes themselves need escaping.
+ * @param {string} value
+ * @returns {string}
+ */
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+/**
+ * Quote `value` as a single argument of a desktop entry's `Exec` key, per the
+ * Desktop Entry Specification: `%` is doubled so it isn't read as a field
+ * code, an argument with reserved characters is double quoted with `"`, `` ` ``,
+ * `$` and `\` backslash-escaped, and finally backslashes are escaped again as
+ * required for every string value.
+ * @param {string} value
+ * @returns {string}
+ */
+function desktopExecArg(value) {
+  let arg = value.replaceAll("%", "%%");
+  if (/[\s"'\\><~|&;$*?#()`]/.test(arg)) {
+    arg = `"${arg.replace(/["`$\\]/g, "\\$&")}"`;
+  }
+  return arg.replaceAll("\\", "\\\\");
+}
+
+/**
+ * Name of the update info file `@nwutils/updater` downloads to find the
+ * latest release, following electron-builder's naming: `x64` gets the bare
+ * `latest-linux.yml`, every other architecture gets an `-<arch>` suffix.
+ * @param {"ia32" | "x64" | "arm64"} arch
+ * @returns {string}
+ */
+function updateInfoFileName(arch) {
+  return arch === "x64" ? "latest-linux.yml" : `latest-linux-${arch}.yml`;
+}
+
+/**
+ * Serialise `value` as a YAML scalar. Strings are written double-quoted via
+ * `JSON.stringify` - a JSON string literal is also a valid YAML double-quoted
+ * scalar, so this never needs YAML-specific escaping rules.
+ * @param {string | number | boolean} value
+ * @returns {string}
+ */
+function stringifyYamlScalar(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+
+/**
+ * Serialise a map of scalars, and lists of maps of scalars, as YAML. This is
+ * the only shape the update info and `app-update.yml` files use, so it avoids
+ * pulling in a YAML library for a handful of lines.
+ * @param {Record<string, string | number | boolean | Record<string, string | number | boolean>[] | undefined>} entries
+ * @returns {string}
+ */
+function stringifyYaml(entries) {
+  let fileContent = "";
+  for (const [key, value] of Object.entries(entries)) {
+    if (value === undefined) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      fileContent += `${key}:\n`;
+      for (const item of value) {
+        let prefix = "  - ";
+        for (const [itemKey, itemValue] of Object.entries(item)) {
+          fileContent += `${prefix}${itemKey}: ${stringifyYamlScalar(itemValue)}\n`;
+          prefix = "    ";
+        }
+      }
+    } else {
+      fileContent += `${key}: ${stringifyYamlScalar(value)}\n`;
+    }
+  }
+  return fileContent;
+}
+
+/**
+ * Compute the base64 encoded SHA-512 digest of the file at `filePath`, the
+ * same encoding electron-builder writes into its update info files.
+ * @async
+ * @function
+ * @param {string} filePath
+ * @returns {Promise<string>}
+ */
+async function sha512(filePath) {
+  const hash = crypto.createHash("sha512");
+  for await (const chunk of fs.createReadStream(filePath)) {
+    hash.update(chunk);
+  }
+  return hash.digest("base64");
+}
+
+/**
+ * Escape `value` for use inside a double quoted NSIS string. NSIS expands `$`
+ * variables and `$\` escapes there, so `$` is doubled and `"` is escaped.
+ * Line breaks are rejected rather than escaped: a raw one would end the
+ * command and let the value inject further script lines. The result is not
+ * quoted, so it can be joined with NSIS variables, eg. `"$INSTDIR\<value>"`.
+ * @param {string} value
+ * @returns {string}
+ */
+function nsisEscape(value) {
+  if (/[\r\n]/.test(value)) {
+    throw new Error(
+      `NSIS strings must not contain line breaks. Received: ${JSON.stringify(value)}`,
+    );
+  }
+  /* In a replacement string `$$` is a literal `$`, so "$$$$" writes "$$". */
+  return value.replaceAll("$", "$$$$").replaceAll('"', '$\\"');
+}
+
+/**
+ * Check a path on the host for use inside a double quoted NSIS string that
+ * `makensis` reads at compile time, eg. a `File` source or `OutFile`. Unlike
+ * runtime strings, those keep `$` literally, so nothing is escaped. Instead,
+ * the sequences `makensis` would still interpret are rejected: `${define}`
+ * expansions and `$\` escapes, and `"` - an escaped `$\"` doesn't survive
+ * being passed through a `!define`, as the icon and license paths are.
+ * @param {string} value
+ * @returns {string}  `value`, unchanged.
+ */
+function nsisPath(value) {
+  if (/[\r\n"]/.test(value) || value.includes("${") || value.includes("$\\")) {
+    throw new Error(
+      `Paths passed to NSIS must not contain line breaks, '"', "\${" or "$\\". Received: ${JSON.stringify(value)}`,
+    );
+  }
+  return value;
+}
+
+/**
+ * Names Windows reserves for devices, with or without an extension.
+ * @type {RegExp}
+ */
+const WINDOWS_RESERVED_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+
+/**
+ * Check that `value` can be used as a single Windows file name: no path
+ * separators, characters Windows forbids in file names, control characters,
+ * trailing dots or spaces, or reserved device names.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isWindowsFileName(value) {
+  const hasControlCharacter = [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code < 0x20 || code === 0x7f;
+  });
+  return (
+    value !== "" &&
+    /[<>:"/\\|?*]/.test(value) === false &&
+    hasControlCharacter === false &&
+    /[. ]$/.test(value) === false &&
+    WINDOWS_RESERVED_NAME.test(value) === false
+  );
+}
+
+/**
+ * Convert a version such as `"1.2.3"` or `"1.2.3-beta.1"` into the
+ * `X.X.X.X` form Windows version resources (and NSIS' `VIProductVersion`)
+ * require. Up to four leading numeric parts are kept, missing ones are
+ * filled with `0`, and any prerelease or build suffix is dropped.
+ * @param {string} version
+ * @returns {string}
+ */
+function windowsVersion(version) {
+  const match = version.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?/);
+  if (match === null) {
+    throw new Error(
+      `Expected a version starting with a number, eg. "1.2.3". Received: ${JSON.stringify(version)}`,
+    );
+  }
+  const parts = match.slice(1).map((part) => Number(part ?? 0));
+  if (parts.some((part) => part > 65535)) {
+    throw new Error(
+      `Expected each part of the version to be at most 65535. Received: ${JSON.stringify(version)}`,
+    );
+  }
+  return parts.join(".");
+}
+
 export default {
   APPIMAGE_ARCH_KV,
+  desktopExecArg,
   fileExists,
+  isWindowsFileName,
+  nsisEscape,
+  nsisPath,
   parseDesktopEntry,
+  sha512,
+  shellQuote,
   stringifyDesktopEntry,
+  stringifyYaml,
+  updateInfoFileName,
+  windowsVersion,
 };

package/types/appImage.d.ts

@@ -1,47 +1,120 @@
+export default appImage;
 export type AppImageOptions = {
     /**
      * Path to a built NW.js Linux application, ie. the `outDir` produced by `@nwutils/builder` for `platform: "linux"`.
      */
     appDir: string;
     /**
-     * Name of the application. Must match the `app.name` value used to build `appDir` - the executable and desktop entry are expected at `<appDir>/<appName>` and `<appDir>/<appName>.desktop`.
+     * Name of the application. Must match the `app.name` value used to build `appDir` - the executable and desktop entry are expected at `<appDir>/<appName>` and `<appDir>/<appName>.desktop`. Must not contain `/` or control characters.
      */
     appName: string;
     /**
      * Path to a `.png` or `.svg` icon. Defaults to the `Icon` value read from `<appDir>/<appName>.desktop`.
      */
-    icon?: string;
+    icon?: string | undefined;
     /**
      * Target architecture. Defaults to the host architecture. `appimagetool` runs as a native binary, so this must match the host unless the host has emulation (eg. QEMU/binfmt) configured for the target architecture.
      */
-    arch?: "ia32" | "x64" | "arm64";
+    arch?: "ia32" | "x64" | "arm64" | undefined;
     /**
      * Directory the resulting `.AppImage` file is written to. Defaults to the parent directory of `appDir`.
      */
-    outDir?: string;
+    outDir?: string | undefined;
     /**
      * Directory used to cache the downloaded `appimagetool` binary.
      */
-    cacheDir?: string;
+    cacheDir?: string | undefined;
     /**
      * If true, reuse a cached `appimagetool` binary. Otherwise redownload it.
      */
-    cache?: boolean;
+    cache?: boolean | undefined;
+    /**
+     * Base URL `appimagetool-<arch>.AppImage` is downloaded from. Defaults to the `AppImage/appimagetool` "continuous" GitHub release. Must be https, except for localhost.
+     */
+    appImageToolUrl?: string | undefined;
+    /**
+     * If true, embed a GPG signature in the AppImage. Requires `gpg` and a usable secret key on the host. A passphrase-protected key reads its passphrase from the `APPIMAGETOOL_SIGN_PASSPHRASE` environment variable.
+     */
+    sign?: boolean | undefined;
+    /**
+     * ID of the GPG key to sign with. Defaults to `gpg`'s default secret key. Requires `sign` to be true.
+     */
+    signKey?: string | undefined;
+    /**
+     * Version of the application, eg. `"1.2.0"`. Required when `publish` is set: it is written to the update info file `@nwutils/updater` compares against.
+     */
+    version?: string | undefined;
+    /**
+     * Where releases are published. When set, an `app-update.yml` pointing at it is embedded in the AppImage and a `latest-linux[-<arch>].yml` update info file is written next to it, for `@nwutils/updater` to self update from.
+     */
+    publish?: PublishOptions | undefined;
+    /**
+     * AppImage update information for zsync based updaters (eg. AppImageUpdate, `appimageupdatetool`, AppImage managers). `true` derives it from `publish`. A string is embedded as-is, eg. `"gh-releases-zsync|owner|repo|latest|Demo-x86_64.AppImage.zsync"`. Requires `zsyncmake` on the host to produce the `.zsync` file.
+     */
+    updateInformation?: string | boolean | undefined;
+};
+/**
+ * Publish to a GitHub repository's releases. The AppImage and update info
+ * file must be uploaded as assets of the latest (non draft, non prerelease)
+ * release.
+ */
+export type GitHubPublishOptions = {
+    provider: "github";
+    /**
+     * Owner of the GitHub repository.
+     */
+    owner: string;
+    /**
+     * Name of the GitHub repository.
+     */
+    repo: string;
+};
+/**
+ * Publish to any static file server. The AppImage and update info file must
+ * be served from `url`.
+ */
+export type GenericPublishOptions = {
+    provider: "generic";
     /**
-     * Base URL `appimagetool-<arch>.AppImage` is downloaded from. Defaults to the `AppImage/appimagetool` "continuous" GitHub release.
+     * Base URL the latest release's files are served from.
      */
-    appImageToolUrl?: string;
+    url: string;
 };
+export type PublishOptions = GitHubPublishOptions | GenericPublishOptions;
 /**
  * @typedef  {object}                       AppImageOptions
  * @property {string}                       appDir             Path to a built NW.js Linux application, ie. the `outDir` produced by `@nwutils/builder` for `platform: "linux"`.
- * @property {string}                       appName            Name of the application. Must match the `app.name` value used to build `appDir` - the executable and desktop entry are expected at `<appDir>/<appName>` and `<appDir>/<appName>.desktop`.
+ * @property {string}                       appName            Name of the application. Must match the `app.name` value used to build `appDir` - the executable and desktop entry are expected at `<appDir>/<appName>` and `<appDir>/<appName>.desktop`. Must not contain `/` or control characters.
  * @property {string}                       [icon]             Path to a `.png` or `.svg` icon. Defaults to the `Icon` value read from `<appDir>/<appName>.desktop`.
  * @property {"ia32" | "x64" | "arm64"}     [arch]             Target architecture. Defaults to the host architecture. `appimagetool` runs as a native binary, so this must match the host unless the host has emulation (eg. QEMU/binfmt) configured for the target architecture.
  * @property {string}                       [outDir]           Directory the resulting `.AppImage` file is written to. Defaults to the parent directory of `appDir`.
  * @property {string}                       [cacheDir="./cache"] Directory used to cache the downloaded `appimagetool` binary.
  * @property {boolean}                      [cache=true]       If true, reuse a cached `appimagetool` binary. Otherwise redownload it.
- * @property {string}                       [appImageToolUrl]  Base URL `appimagetool-<arch>.AppImage` is downloaded from. Defaults to the `AppImage/appimagetool` "continuous" GitHub release.
+ * @property {string}                       [appImageToolUrl]  Base URL `appimagetool-<arch>.AppImage` is downloaded from. Defaults to the `AppImage/appimagetool` "continuous" GitHub release. Must be https, except for localhost.
+ * @property {boolean}                      [sign=false]       If true, embed a GPG signature in the AppImage. Requires `gpg` and a usable secret key on the host. A passphrase-protected key reads its passphrase from the `APPIMAGETOOL_SIGN_PASSPHRASE` environment variable.
+ * @property {string}                       [signKey]          ID of the GPG key to sign with. Defaults to `gpg`'s default secret key. Requires `sign` to be true.
+ * @property {string}                       [version]          Version of the application, eg. `"1.2.0"`. Required when `publish` is set: it is written to the update info file `@nwutils/updater` compares against.
+ * @property {PublishOptions}               [publish]          Where releases are published. When set, an `app-update.yml` pointing at it is embedded in the AppImage and a `latest-linux[-<arch>].yml` update info file is written next to it, for `@nwutils/updater` to self update from.
+ * @property {string | boolean}             [updateInformation] AppImage update information for zsync based updaters (eg. AppImageUpdate, `appimageupdatetool`, AppImage managers). `true` derives it from `publish`. A string is embedded as-is, eg. `"gh-releases-zsync|owner|repo|latest|Demo-x86_64.AppImage.zsync"`. Requires `zsyncmake` on the host to produce the `.zsync` file.
+ */
+/**
+ * Publish to a GitHub repository's releases. The AppImage and update info
+ * file must be uploaded as assets of the latest (non draft, non prerelease)
+ * release.
+ * @typedef  {object}   GitHubPublishOptions
+ * @property {"github"} provider
+ * @property {string}   owner     Owner of the GitHub repository.
+ * @property {string}   repo      Name of the GitHub repository.
+ */
+/**
+ * Publish to any static file server. The AppImage and update info file must
+ * be served from `url`.
+ * @typedef  {object}    GenericPublishOptions
+ * @property {"generic"} provider
+ * @property {string}    url       Base URL the latest release's files are served from.
+ */
+/**
+ * @typedef {GitHubPublishOptions | GenericPublishOptions} PublishOptions
  */
 /**
  * Package a built NW.js Linux application as an AppImage.
@@ -53,7 +126,7 @@ export type AppImageOptions = {
  * @param  {AppImageOptions}  options
  * @returns {Promise<string>}  Path to the resulting `.AppImage` file.
  */
-declare function appImage({ appDir, appName, icon, arch, outDir, cacheDir, cache, appImageToolUrl, }: AppImageOptions): Promise<string>;
+declare function appImage({ appDir, appName, icon, arch, outDir, cacheDir, cache, appImageToolUrl, sign, signKey, version, publish, updateInformation, }: AppImageOptions): Promise<string>;
 /**
  * Download (or reuse a cached) `appimagetool` binary for `appImageToolArch`.
  * @async
@@ -65,11 +138,9 @@ declare function appImage({ appDir, appName, icon, arch, outDir, cacheDir, cache
  * @param  {boolean} options.cache             If true, reuse a cached binary. Otherwise redownload it.
  * @returns {Promise<string>}  Path to an executable `appimagetool` binary.
  */
-declare function getAppImageTool({ appImageToolArch, appImageToolUrl, cacheDir, cache, }: {
+export function getAppImageTool({ appImageToolArch, appImageToolUrl, cacheDir, cache, }: {
     appImageToolArch: string;
     appImageToolUrl: string;
     cacheDir: string;
     cache: boolean;
 }): Promise<string>;
-export default appImage;
-export { getAppImageTool };

package/types/index.d.ts

@@ -1,21 +1,37 @@
+export default packager;
+/**
+ * Supported packaged output formats.
+ *
+ * `AppImage`, `deb` and `rpm` package a Linux build. `MSIX` and `NSIS`
+ * package a Windows build. `"AppImage"` and `"nsis"` are implemented today -
+ * the others are reserved so this option doesn't need to change shape once
+ * they land.
+ */
 export type PackageFormat = "AppImage" | "deb" | "rpm" | "msix" | "nsis" | "dmg";
+/**
+ * Where releases are published, for packagers that support self updating.
+ */
+export type PublishOptions = import("./appImage.js").PublishOptions;
 /**
  * Supported packaged output formats.
  *
  * `AppImage`, `deb` and `rpm` package a Linux build. `MSIX` and `NSIS`
- * package a Windows build. Only `"AppImage"` is implemented today - the
- * others are reserved so this option doesn't need to change shape once they
- * land.
+ * package a Windows build. `"AppImage"` and `"nsis"` are implemented today -
+ * the others are reserved so this option doesn't need to change shape once
+ * they land.
  * @typedef {"AppImage" | "deb" | "rpm" | "msix" | "nsis" | "dmg"} PackageFormat
  */
+/**
+ * Where releases are published, for packagers that support self updating.
+ * @typedef {import("./appImage.js").PublishOptions} PublishOptions
+ */
 /**
  * Package a built NW.js application.
  * @async
  * @function
- * @param  {{format: PackageFormat} & Record<string, any>}  options  `format`, plus the options the matching packager (eg. `appImage`) expects.
+ * @param  {{format: PackageFormat} & Record<string, any>}  options  `format`, plus the options the matching packager (eg. `appImage` or `nsis`) expects.
  * @returns {Promise<string>}  Path to the resulting packaged artifact.
  */
 declare function packager({ format, ...options }: {
     format: PackageFormat;
 } & Record<string, any>): Promise<string>;
-export default packager;

package/types/nsis.d.ts

@@ -0,0 +1,140 @@
+export default nsis;
+export type NsisOptions = {
+    /**
+     * Path to a built NW.js Windows application, ie. the `outDir` produced by `@nwutils/builder` for `platform: "win"`.
+     */
+    appDir: string;
+    /**
+     * Name of the application. Must match the `app.name` value used to build `appDir` - the executable is expected at `<appDir>/<appName>.exe`. Must be a valid Windows file name.
+     */
+    appName: string;
+    /**
+     * Version of the application, eg. `"1.2.0"`. Shown in Windows' installed apps list, and converted to `X.X.X.X` for the installer's own version resource.
+     */
+    version: string;
+    /**
+     * Architecture `appDir` was built for. Defaults to the host architecture. The installer refuses to run on Windows machines that can't run that architecture.
+     */
+    arch?: "ia32" | "x64" | "arm64" | undefined;
+    /**
+     * Directory the resulting `<appName>-<arch>-Setup.exe` file is written to. Defaults to the parent directory of `appDir`.
+     */
+    outDir?: string | undefined;
+    /**
+     * Path to a `.ico` icon for the installer and uninstaller. Defaults to NSIS' own icon.
+     */
+    icon?: string | undefined;
+    /**
+     * Name of the registry key the installation is recorded under. Defaults to `appName`. Keep it the same across releases, so installing a new version replaces the previous one.
+     */
+    appId?: string | undefined;
+    /**
+     * Publisher shown in Windows' installed apps list.
+     */
+    publisher?: string | undefined;
+    /**
+     * Copyright notice written into the installer's version information.
+     */
+    copyright?: string | undefined;
+    /**
+     * Path to a `.txt` or `.rtf` license file. When set, the installer shows it on a page the user has to accept.
+     */
+    license?: string | undefined;
+    /**
+     * If true, create a desktop shortcut.
+     */
+    desktopShortcut?: boolean | undefined;
+    /**
+     * If true, create a Start Menu shortcut.
+     */
+    startMenuShortcut?: boolean | undefined;
+    /**
+     * Path to the NSIS compiler. Defaults to `makensis` on the `PATH`.
+     */
+    makensisPath?: string | undefined;
+};
+/**
+ * The files and directories of a built application, relative to its root.
+ */
+export type AppFiles = {
+    /**
+     * Relative file paths, using the host's path separator.
+     */
+    files: string[];
+    /**
+     * Relative directory paths, parents before children.
+     */
+    dirs: string[];
+    /**
+     * Total size of `files` in bytes.
+     */
+    size: number;
+};
+/**
+ * Package a built NW.js Windows application as an NSIS installer.
+ *
+ * The installer installs for the current user only, into
+ * `%LOCALAPPDATA%\Programs\<appName>`, so it never asks for administrator
+ * rights. It registers an uninstaller in Windows' installed apps list, and
+ * installing a new version first uninstalls the previous one. Both wait for
+ * the application to be closed before touching its files.
+ *
+ * This composes with `@nwutils/builder`: run it against the `outDir` (and
+ * `app.name`) that `@nwutils/builder` produced for `platform: "win"`.
+ * `makensis` runs on Linux and macOS too, so the installer can be built on
+ * any host.
+ * @async
+ * @function
+ * @param  {NsisOptions}  options
+ * @returns {Promise<string>}  Path to the resulting installer `.exe` file.
+ */
+declare function nsis({ appDir, appName, version, arch, outDir, icon, appId, publisher, copyright, license, desktopShortcut, startMenuShortcut, makensisPath, }: NsisOptions): Promise<string>;
+/**
+ * List the files and directories under `appDir`. Symbolic links are followed,
+ * since NSIS copies what they point at.
+ * @async
+ * @function
+ * @param  {string}  appDir  Absolute path to the built application.
+ * @returns {Promise<AppFiles>}
+ */
+export function listAppFiles(appDir: string): Promise<AppFiles>;
+/**
+ * Generate the NSIS script for an installer.
+ *
+ * Every file is listed explicitly rather than copied with `File /r`, so the
+ * uninstaller deletes exactly the files that were installed. The user can
+ * choose any install directory - including one such as `C:\` that holds
+ * other files - so the uninstaller never deletes directories recursively.
+ * @param  {object}                    options
+ * @param  {string}                    options.appDir             Absolute path to the built application.
+ * @param  {AppFiles}                  options.appFiles           Files and directories under `appDir`.
+ * @param  {string}                    options.appName
+ * @param  {string}                    options.appId
+ * @param  {string}                    options.version
+ * @param  {string}                    options.fileVersion        `version` in `X.X.X.X` form.
+ * @param  {"ia32" | "x64" | "arm64"}  options.arch
+ * @param  {string}                    options.installerPath      Absolute path the installer is written to.
+ * @param  {string}                    [options.iconPath]         Absolute path to a `.ico` file.
+ * @param  {string}                    [options.licensePath]      Absolute path to a `.txt` or `.rtf` file.
+ * @param  {string}                    [options.publisher]
+ * @param  {string}                    options.copyright
+ * @param  {boolean}                   options.desktopShortcut
+ * @param  {boolean}                   options.startMenuShortcut
+ * @returns {string}
+ */
+export function nsisScript({ appDir, appFiles, appName, appId, version, fileVersion, arch, installerPath, iconPath, licensePath, publisher, copyright, desktopShortcut, startMenuShortcut, }: {
+    appDir: string;
+    appFiles: AppFiles;
+    appName: string;
+    appId: string;
+    version: string;
+    fileVersion: string;
+    arch: "ia32" | "x64" | "arm64";
+    installerPath: string;
+    iconPath?: string | undefined;
+    licensePath?: string | undefined;
+    publisher?: string | undefined;
+    copyright: string;
+    desktopShortcut: boolean;
+    startMenuShortcut: boolean;
+}): string;