@lakutata/builder 3.0.0-beta.0

package/dist/esm/lib/linux/Linux.js

@@ -0,0 +1,361 @@
+import { copyFileSync, lstatSync, mkdirSync, readdirSync, readlinkSync } from 'node:fs';
+import { stat, mkdir, writeFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { archiveDirectory } from '../Archive.js';
+import { runCommand } from '../Processes.js';
+import { ensureTool } from '../Tools.js';
+import { embeddedShell, INSTALLER_HOOKS, NATIVE_HOOKS } from '../Scripts.js';
+/**
+ * The packages of Linux: the ones of nFPM, and the archive of the directory of the executable
+ */
+export const LINUX_TARGETS = ['deb', 'rpm', 'apk', 'archlinux', 'tar.gz'];
+/**
+ * The libraries of the system the executables load (Node.js and Bun are linked with the C++ library), by package
+ */
+const RUNTIME_DEPENDS = {
+    deb: ['libstdc++6', 'libgcc-s1'],
+    rpm: ['libstdc++', 'libgcc'],
+    apk: ['libstdc++', 'libgcc'],
+    archlinux: ['gcc-libs']
+};
+/**
+ * The architecture of the packages (the one of Go, which nFPM translates for each package)
+ */
+function packageArch() {
+    return { x64: 'amd64', arm64: 'arm64', ia32: '386', arm: 'arm7' }[process.arch] ?? process.arch;
+}
+/**
+ * The characters of the globs, which nFPM reads in the sources of the contents (the chunks of Turbopack are named
+ * [root-of-the-server]__…)
+ */
+const GLOB_CHARACTERS = /[*?[\]{}\\]/;
+/**
+ * The contents of a package installing a directory: its files, and its links as links (the links of the native tree,
+ * which may point to their parents: nFPM does not keep them in the trees it reads). The files named with the characters
+ * of the globs are given by copies named without them: nFPM reads its sources as globs, and installs the files their
+ * globs match into their destination as into a directory
+ * @param directory
+ * @param prefix where it is installed
+ * @param work where the copies are written
+ */
+function packageContents(directory, prefix, work) {
+    const contents = [];
+    let copies = 0;
+    const source = (file) => {
+        if (!GLOB_CHARACTERS.test(file))
+            return file;
+        const copy = path.join(work, 'literal', String(copies++));
+        mkdirSync(path.dirname(copy), { recursive: true });
+        copyFileSync(file, copy);
+        return copy;
+    };
+    const walk = (current, at) => {
+        for (const entry of readdirSync(current, { withFileTypes: true })) {
+            const file = path.join(current, entry.name);
+            const target = `${at}/${entry.name}`;
+            //The link to the installed path (nFPM makes directories of the links to their parents)
+            if (entry.isSymbolicLink())
+                contents.push({ src: path.posix.resolve(at, readlinkSync(file).split(path.sep).join('/')), dst: target, type: 'symlink' });
+            else if (entry.isDirectory()) {
+                //Owned by the package (rpm removes them with it)
+                contents.push({ dst: target, type: 'dir', file_info: { mode: lstatSync(file).mode & 0o777 } });
+                walk(file, target);
+            }
+            else
+                contents.push({ src: source(file), dst: target, file_info: { mode: lstatSync(file).mode & 0o777 } });
+        }
+    };
+    contents.push({ dst: prefix, type: 'dir', file_info: { mode: 0o755 } });
+    walk(directory, prefix);
+    return contents;
+}
+/**
+ * The file of a package, named as its system names them
+ * @param plan
+ * @param target
+ */
+function packageFile(plan, target) {
+    const arch = { x64: 'x86_64', arm64: 'aarch64' }[process.arch] ?? process.arch;
+    switch (target) {
+        case 'deb':
+            return `${plan.name}_${plan.version}_${packageArch()}.deb`;
+        case 'rpm':
+            return `${plan.name}-${plan.version}-1.${arch}.rpm`;
+        case 'apk':
+            return `${plan.name}-${plan.version}-r0.${arch}.apk`;
+        case 'archlinux':
+            return `${plan.name}-${plan.version}-1-${arch}.pkg.tar.zst`;
+    }
+}
+/**
+ * A value in double quotes, as systemd and sh read them
+ * @param value
+ */
+function doubleQuoted(value) {
+    return `"${value.replace(/[\\"$`]/g, '\\$&')}"`;
+}
+/**
+ * A value in single quotes, as sh reads them
+ * @param value
+ */
+function singleQuoted(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * The environment file of the service: its variables, which the administrators change (kept by the upgrades)
+ * @param service
+ */
+function environmentFile(service) {
+    return `# The environment of the service ${service.name}, read when it starts (systemctl restart ${service.name})\n${Object.entries(service.env).map(([name, value]) => `${name}=${doubleQuoted(value)}`).join('\n')}\n`;
+}
+/**
+ * The unit of systemd of the service
+ * @param plan
+ * @param service
+ */
+function systemdUnit(plan, service) {
+    const root = service.user === 'root';
+    return [
+        '[Unit]',
+        `Description=${service.description}`,
+        'After=network-online.target',
+        'Wants=network-online.target',
+        '',
+        '[Service]',
+        'Type=simple',
+        `ExecStart=${[`${plan.prefix}/${plan.program}`, ...service.args].map(doubleQuoted).join(' ')}`,
+        ...root ? [] : [`User=${service.user}`, `Group=${service.user}`],
+        `EnvironmentFile=-/etc/${plan.name}/${plan.name}.env`,
+        //Its data: /var/lib/<name>, owned by its user
+        `StateDirectory=${plan.name}`,
+        `WorkingDirectory=/var/lib/${plan.name}`,
+        `Restart=${service.restart}`,
+        'RestartSec=5',
+        //The application ends gracefully on SIGTERM
+        'KillSignal=SIGTERM',
+        'TimeoutStopSec=30',
+        '',
+        '[Install]',
+        'WantedBy=multi-user.target',
+        ''
+    ].join('\n');
+}
+/**
+ * The script of OpenRC of the service (Alpine)
+ * @param plan
+ * @param service
+ */
+function openRCScript(plan, service) {
+    const root = service.user === 'root';
+    const environment = `/etc/${plan.name}/${plan.name}.env`;
+    return [
+        '#!/sbin/openrc-run',
+        `description=${doubleQuoted(service.description)}`,
+        `command=${doubleQuoted(`${plan.prefix}/${plan.program}`)}`,
+        `command_args=${doubleQuoted(service.args.map(singleQuoted).join(' '))}`,
+        ...root ? [] : [`command_user="${service.user}:${service.user}"`],
+        `directory="/var/lib/${plan.name}"`,
+        ...service.restart === 'no' ? ['command_background="yes"', 'pidfile="/run/${RC_SVCNAME}.pid"'] : ['supervisor="supervise-daemon"', 'respawn_delay=5'],
+        `output_log="/var/log/${plan.name}.log"`,
+        `error_log="/var/log/${plan.name}.log"`,
+        '',
+        'depend() {',
+        '    need net',
+        '}',
+        '',
+        'start_pre() {',
+        `    checkpath --directory${root ? '' : ` --owner ${service.user}:${service.user}`} --mode 0750 /var/lib/${plan.name}`,
+        `    checkpath --file${root ? '' : ` --owner ${service.user}:${service.user}`} --mode 0640 /var/log/${plan.name}.log`,
+        `    if [ -f ${environment} ]; then set -a; . ${environment}; set +a; fi`,
+        '}',
+        ''
+    ].join('\n');
+}
+/**
+ * The parts of the scripts of a package managing the service: its user created before the installation; the service
+ * enabled and started after it, restarted by the upgrades, stopped and disabled before the removal. The ones run before
+ * the scripts of the application (its user, the service stopped), and the ones run after them (the service started)
+ * @param plan
+ * @param target
+ */
+function serviceScripts(plan, target) {
+    const service = plan.service;
+    const before = {};
+    const after = {};
+    if (!service)
+        return { before: before, after: after };
+    const unit = `${service.name}.service`;
+    if (service.user !== 'root') {
+        before.preinstall = [
+            `if ! id -u ${service.user} >/dev/null 2>&1; then`,
+            '    if command -v useradd >/dev/null 2>&1; then',
+            `        useradd --system --user-group --home-dir /var/lib/${plan.name} --no-create-home --shell "$(command -v nologin || echo /bin/false)" ${service.user}`,
+            '    else',
+            `        addgroup -S ${service.user} 2>/dev/null || true`,
+            `        adduser -S -D -H -h /var/lib/${plan.name} -s /sbin/nologin -G ${service.user} ${service.user}`,
+            '    fi',
+            'fi'
+        ];
+    }
+    if (target === 'apk') {
+        after.postinstall = [
+            'if command -v rc-update >/dev/null 2>&1; then',
+            ...service.autoStart ? [`    rc-update add ${service.name} default`, `    [ -d /run/openrc ] && rc-service ${service.name} start || true`] : ['    true'],
+            'fi'
+        ];
+        after.postupgrade = [`[ -d /run/openrc ] && rc-service --ifstarted ${service.name} restart || true`];
+        before.preremove = [
+            'if command -v rc-update >/dev/null 2>&1; then',
+            `    [ -d /run/openrc ] && rc-service --ifstarted ${service.name} stop || true`,
+            `    rc-update del ${service.name} default 2>/dev/null || true`,
+            'fi'
+        ];
+        return { before: before, after: after };
+    }
+    //systemd: the upgrades restart the service (deb: postinst configure, rpm: %post 2, pacman: post_upgrade)
+    after.postinstall = [
+        'if [ -d /run/systemd/system ]; then',
+        '    systemctl daemon-reload',
+        ...service.autoStart ? [`    systemctl enable ${unit}`, `    systemctl restart ${unit}`] : [`    systemctl try-restart ${unit}`],
+        'fi'
+    ];
+    //Not before an upgrade (deb: prerm upgrade, rpm: %preun 1)
+    before.preremove = [
+        'case "$1" in',
+        '    upgrade|failed-upgrade|1) ;;',
+        `    *) if [ -d /run/systemd/system ]; then systemctl disable --now ${unit} || true; fi ;;`,
+        'esac'
+    ];
+    before.postremove = ['if [ -d /run/systemd/system ]; then', '    systemctl daemon-reload || true', 'fi'];
+    if (target === 'archlinux')
+        after.postupgrade = after.postinstall;
+    return { before: before, after: after };
+}
+/**
+ * What a script of a package does, as the scripts of the application are given it (lakutata_action: install, upgrade,
+ * remove, or none), from the arguments of its package manager: the upgrades of deb and rpm run their scripts of the
+ * installation (deb: preinst upgrade, postinst configure <version replaced>; rpm: $1 > 1) and their scripts of the
+ * removal of the version replaced (which run none); the ones of apk and pacman run their own scripts
+ * @param target
+ * @param hook
+ */
+export function scriptAction(target, hook) {
+    switch (target) {
+        case 'deb':
+            return {
+                preinstall: 'case "$1" in install) lakutata_action=install ;; upgrade) lakutata_action=upgrade ;; *) lakutata_action= ;; esac',
+                postinstall: 'if [ "$1" = configure ]; then if [ -n "$2" ]; then lakutata_action=upgrade; else lakutata_action=install; fi; else lakutata_action=; fi',
+                preremove: 'if [ "$1" = remove ]; then lakutata_action=remove; else lakutata_action=; fi',
+                postremove: 'if [ "$1" = remove ]; then lakutata_action=remove; else lakutata_action=; fi'
+            }[hook];
+        case 'rpm':
+            return hook === 'preinstall' || hook === 'postinstall'
+                ? 'if [ "$1" -gt 1 ] 2>/dev/null; then lakutata_action=upgrade; else lakutata_action=install; fi'
+                : 'if [ "$1" = 0 ]; then lakutata_action=remove; else lakutata_action=; fi';
+        default:
+            return `lakutata_action=${hook.endsWith('upgrade') ? 'upgrade' : hook.endsWith('install') ? 'install' : 'remove'}`;
+    }
+}
+/**
+ * The scripts of a package: the parts managing the service, the scripts of the application (run before the service is
+ * started, after it is stopped), and its native ones, given the arguments of the package manager
+ * @param plan
+ * @param target
+ */
+function packageScripts(plan, target) {
+    const service = serviceScripts(plan, target);
+    const user = plan.scripts[target] ?? { hooks: {}, native: {} };
+    const hooks = target === 'apk' || target === 'archlinux' ? NATIVE_HOOKS : INSTALLER_HOOKS;
+    const scripts = {};
+    for (const hook of hooks) {
+        //The script of the application of the moment: the upgrades of apk and pacman run the ones of the installation
+        const application = user.hooks[(hook === 'preupgrade' ? 'preinstall' : hook === 'postupgrade' ? 'postinstall' : hook)];
+        const native = user.native[hook];
+        const lines = [
+            ...service.before[hook] ?? [],
+            //Not indented: the lines of the script are the ones of its file
+            ...application ? [scriptAction(target, hook), 'if [ -n "$lakutata_action" ]; then', ...embeddedShell(application, plan.prefix, '"$lakutata_action"'), 'fi'] : [],
+            ...native ? embeddedShell(native, plan.prefix, '"$@"') : [],
+            ...service.after[hook] ?? []
+        ];
+        if (lines.length)
+            scripts[hook] = ['#!/bin/sh', 'set -e', ...lines, ''].join('\n');
+    }
+    return scripts;
+}
+/**
+ * Make the packages of Linux of an application: nFPM makes the deb, rpm, apk and archlinux packages, the tar.gz archive
+ * is the directory of the executable
+ * @param plan
+ * @param targets
+ * @param work
+ * @param outdir
+ */
+export async function buildLinuxPackages(plan, targets, work, outdir) {
+    await mkdir(work, { recursive: true });
+    const files = [];
+    const service = plan.service;
+    for (const target of targets) {
+        if (target === 'tar.gz') {
+            files.push(await archiveDirectory(plan, packageArch(), work, outdir));
+            continue;
+        }
+        const directory = path.join(work, target);
+        await mkdir(directory, { recursive: true });
+        const contents = packageContents(plan.directory, plan.prefix, directory);
+        if (plan.addToPath)
+            contents.push({ src: `${plan.prefix}/${plan.program}`, dst: `/usr/bin/${plan.program}`, type: 'symlink' });
+        if (service) {
+            await writeFile(path.join(directory, 'environment'), environmentFile(service));
+            contents.push({ src: path.join(directory, 'environment'), dst: `/etc/${plan.name}/${plan.name}.env`, type: 'config|noreplace', file_info: { mode: 0o640 } });
+            if (target === 'apk') {
+                await writeFile(path.join(directory, 'openrc'), openRCScript(plan, service));
+                contents.push({ src: path.join(directory, 'openrc'), dst: `/etc/init.d/${service.name}`, file_info: { mode: 0o755 } });
+            }
+            else {
+                await writeFile(path.join(directory, 'unit'), systemdUnit(plan, service));
+                contents.push({ src: path.join(directory, 'unit'), dst: `/usr/lib/systemd/system/${service.name}.service`, file_info: { mode: 0o644 } });
+            }
+        }
+        const scripts = packageScripts(plan, target);
+        const common = {};
+        const specific = {};
+        for (const [name, content] of Object.entries(scripts)) {
+            const file = path.join(directory, name);
+            await writeFile(file, content, { mode: 0o755 });
+            //The upgrades of apk and pacman are their own scripts
+            if (name === 'preupgrade' || name === 'postupgrade')
+                specific[name] = file;
+            else
+                common[name] = file;
+        }
+        const config = {
+            name: plan.name,
+            arch: packageArch(),
+            platform: 'linux',
+            version: plan.version,
+            maintainer: plan.maintainer,
+            description: plan.description,
+            ...plan.vendor ? { vendor: plan.vendor } : {},
+            ...plan.homepage ? { homepage: plan.homepage } : {},
+            ...plan.license ? { license: plan.license } : {},
+            ...plan.section ? { section: plan.section } : {},
+            ...plan.priority ? { priority: plan.priority } : {},
+            depends: [...new Set([...RUNTIME_DEPENDS[target], ...plan.depends])],
+            ...plan.recommends.length ? { recommends: plan.recommends } : {},
+            contents: contents,
+            scripts: common,
+            ...Object.keys(specific).length ? { [target]: { scripts: specific } } : {}
+        };
+        //JSON is YAML
+        await writeFile(path.join(directory, 'nfpm.yaml'), JSON.stringify(config, null, 2));
+        const nfpm = await ensureTool('nfpm');
+        const file = path.join(outdir, packageFile(plan, target));
+        await rm(file, { force: true });
+        const packaged = await runCommand(nfpm, ['package', '--config', path.join(directory, 'nfpm.yaml'), '--packager', target, '--target', file], directory);
+        if (packaged.code !== 0)
+            throw new Error(`The ${target} package cannot be made: ${packaged.output.trim()}`);
+        files.push({ target: target, file: file, size: (await stat(file)).size });
+    }
+    return files;
+}

package/dist/esm/lib/mac/Mac.js

@@ -0,0 +1,270 @@
+import { chmod, cp, mkdir, rm, stat, symlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { archiveDirectory } from '../Archive.js';
+import { runCommand } from '../Processes.js';
+import { embeddedShell } from '../Scripts.js';
+/**
+ * The installers of macOS: the package of its installer, and the archive of the directory of the executable
+ */
+export const MAC_TARGETS = ['pkg', 'tar.gz'];
+/**
+ * The architecture of the packages
+ */
+function packageArch() {
+    return process.arch;
+}
+/**
+ * A text of a property list
+ * @param value
+ */
+function xml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/**
+ * A value in double quotes, as sh reads them
+ * @param value
+ */
+function doubleQuoted(value) {
+    return `"${value.replace(/[\\"$`]/g, '\\$&')}"`;
+}
+/**
+ * The paths of an application installed on macOS (the ones of Homebrew: /usr/local)
+ * @param plan
+ */
+function installPaths(plan) {
+    return {
+        environment: `/usr/local/etc/${plan.name}/${plan.name}.env`,
+        data: `/usr/local/var/lib/${plan.name}`,
+        log: `/usr/local/var/log/${plan.name}.log`,
+        daemon: `/Library/LaunchDaemons/${plan.appId}.plist`
+    };
+}
+/**
+ * The job of launchd of the service: the application run by sh, which reads its environment file first (launchd has
+ * none), as its user, in its directory
+ * @param plan
+ * @param service
+ */
+function launchDaemon(plan, service) {
+    const paths = installPaths(plan);
+    const keepAlive = service.restart === 'always' ? '<true/>' : service.restart === 'no' ? '<false/>' : '<dict>\n        <key>SuccessfulExit</key>\n        <false/>\n    </dict>';
+    const args = ['/bin/sh', '-c', `set -a; [ -f ${paths.environment} ] && . ${paths.environment}; set +a; exec "$0" "$@"`, `${plan.prefix}/${plan.program}`, ...service.args];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${xml(plan.appId)}</string>
+    <key>ProgramArguments</key>
+    <array>
+${args.map((arg) => `        <string>${xml(arg)}</string>`).join('\n')}
+    </array>
+${service.user === 'root' ? '' : `    <key>UserName</key>
+    <string>${xml(service.user)}</string>
+    <key>GroupName</key>
+    <string>${xml(service.user)}</string>
+`}    <key>WorkingDirectory</key>
+    <string>${xml(paths.data)}</string>
+    <key>RunAtLoad</key>
+    ${service.autoStart ? '<true/>' : '<false/>'}
+    <key>KeepAlive</key>
+    ${keepAlive}
+    <key>ThrottleInterval</key>
+    <integer>5</integer>
+    <key>ExitTimeOut</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>${xml(paths.log)}</string>
+    <key>StandardErrorPath</key>
+    <string>${xml(paths.log)}</string>
+</dict>
+</plist>
+`;
+}
+/**
+ * The scripts of the application the package runs
+ * @param plan
+ */
+function installerHooks(plan) {
+    return plan.scripts.pkg?.hooks ?? {};
+}
+/**
+ * The file the preinstall script writes what the installation does to (install or upgrade), read by the postinstall
+ * script: in the temporary directory of the installation (INSTALLER_TEMP), given to both
+ */
+const ACTION_FILE = '"$INSTALLER_TEMP/lakutata-action"';
+/**
+ * The script run before the installation (and the upgrades), when the application has scripts: what the installation
+ * does (an upgrade replaces the program installed), the preinstall script of the application
+ * @param plan
+ */
+function preInstall(plan) {
+    const hooks = installerHooks(plan);
+    return [
+        '#!/bin/sh',
+        'set -e',
+        `if [ -e ${doubleQuoted(`${plan.prefix}/${plan.program}`)} ]; then lakutata_action=upgrade; else lakutata_action=install; fi`,
+        `if [ -n "$INSTALLER_TEMP" ]; then echo "$lakutata_action" > ${ACTION_FILE}; fi`,
+        ...hooks.preinstall ? embeddedShell(hooks.preinstall, plan.prefix, '"$lakutata_action"') : [],
+        ''
+    ].join('\n');
+}
+/**
+ * The script run after the installation (and the upgrades): the user of the service created (hidden, its identifier a
+ * free one of the system users), its directories, its environment file written once (the administrators change it),
+ * the postinstall script of the application, the service loaded again
+ * @param plan
+ */
+function postInstall(plan) {
+    const service = plan.service;
+    const hooks = installerHooks(plan);
+    return [
+        '#!/bin/sh',
+        'set -e',
+        ...service ? serviceInstallation(plan, service) : [],
+        ...hooks.postinstall ? [
+            `lakutata_action="$(cat ${ACTION_FILE} 2>/dev/null || echo install)"`,
+            ...embeddedShell(hooks.postinstall, plan.prefix, '"$lakutata_action"')
+        ] : [],
+        ...service ? serviceStart(plan) : [],
+        ''
+    ].join('\n');
+}
+/**
+ * The installation of the service: its hidden user, its directories, its environment file
+ * @param plan
+ * @param service
+ */
+function serviceInstallation(plan, service) {
+    const paths = installPaths(plan);
+    const user = service.user;
+    const root = user === 'root';
+    return [
+        ...root ? [] : [
+            `if ! dscl . -read /Users/${user} >/dev/null 2>&1; then`,
+            '    taken="$(dscl . -list /Users UniqueID | awk \'{print $2}\') $(dscl . -list /Groups PrimaryGroupID | awk \'{print $2}\')"',
+            '    id=300',
+            '    while echo " $taken " | tr \'\\n\' \' \' | grep -q " $id "; do id=$((id + 1)); done',
+            `    dscl . -create /Groups/${user}`,
+            `    dscl . -create /Groups/${user} PrimaryGroupID "$id"`,
+            `    dscl . -create /Groups/${user} Password "*"`,
+            `    dscl . -create /Users/${user}`,
+            `    dscl . -create /Users/${user} UniqueID "$id"`,
+            `    dscl . -create /Users/${user} PrimaryGroupID "$id"`,
+            `    dscl . -create /Users/${user} UserShell /usr/bin/false`,
+            `    dscl . -create /Users/${user} NFSHomeDirectory /var/empty`,
+            `    dscl . -create /Users/${user} RealName ${doubleQuoted(service.description)}`,
+            `    dscl . -create /Users/${user} Password "*"`,
+            `    dscl . -create /Users/${user} IsHidden 1`,
+            'fi'
+        ],
+        `mkdir -p ${paths.data} ${path.posix.dirname(paths.log)} ${path.posix.dirname(paths.environment)}`,
+        `touch ${paths.log}`,
+        ...root ? [] : [`chown ${user}:${user} ${paths.data} ${paths.log}`],
+        `chmod 750 ${paths.data}`,
+        //Kept by the upgrades
+        `if [ ! -f ${paths.environment} ]; then`,
+        `    cat > ${paths.environment} <<'LAKUTATA_ENVIRONMENT'`,
+        `# The environment of the service ${plan.appId}, read when it starts (sudo launchctl kickstart -k system/${plan.appId})`,
+        ...Object.entries(service.env).map(([name, value]) => `${name}=${doubleQuoted(value)}`),
+        'LAKUTATA_ENVIRONMENT',
+        'fi',
+        //Read by the user of the service
+        `chown root:${root ? 'wheel' : user} ${paths.environment}`,
+        `chmod 640 ${paths.environment}`
+    ];
+}
+/**
+ * The service loaded again: started (RunAtLoad), or stopped by the upgrade
+ * @param plan
+ */
+function serviceStart(plan) {
+    const paths = installPaths(plan);
+    return [
+        //Loaded again: started (RunAtLoad), or stopped by the upgrade; bootout returns before the job of the version
+        //replaced is unloaded (the application ending gracefully, ExitTimeOut): bootstrap fails until it is
+        `launchctl bootout system/${plan.appId} 2>/dev/null || true`,
+        'waited=0',
+        `while launchctl print system/${plan.appId} >/dev/null 2>&1 && [ "$waited" -lt 70 ]; do sleep 0.5; waited=$((waited + 1)); done`,
+        `launchctl bootstrap system ${paths.daemon}`
+    ];
+}
+/**
+ * The script removing the application (the packages of macOS are not removed by the system): its service stopped, the
+ * preremove script of the application, its files removed, the postremove script of the application; its data, its
+ * environment and its user kept
+ * @param plan
+ */
+function uninstall(plan) {
+    const paths = installPaths(plan);
+    const hooks = installerHooks(plan);
+    return [
+        '#!/bin/sh',
+        'set -e',
+        `[ "$(id -u)" = 0 ] || { echo "Remove ${plan.name} as root: sudo $0"; exit 1; }`,
+        ...plan.service ? [`launchctl bootout system/${plan.appId} 2>/dev/null || true`, `rm -f ${paths.daemon}`] : [],
+        ...hooks.preremove ? embeddedShell(hooks.preremove, plan.prefix, 'remove') : [],
+        ...plan.addToPath ? [`rm -f /usr/local/bin/${plan.program}`] : [],
+        `rm -rf ${plan.prefix}`,
+        `pkgutil --forget ${plan.appId} >/dev/null 2>&1 || true`,
+        ...hooks.postremove ? embeddedShell(hooks.postremove, plan.prefix, 'remove') : [],
+        `echo "${plan.name} removed${plan.service ? `, its data (${paths.data}), its environment (${paths.environment}) and its user (${plan.service.user}) kept` : ''}"`,
+        ''
+    ].join('\n');
+}
+/**
+ * Make the installers of macOS of an application: the package installed by its installer (pkgbuild, productbuild), the
+ * tar.gz archive of the directory of the executable
+ * @param plan
+ * @param targets
+ * @param work
+ * @param outdir
+ */
+export async function buildMacPackages(plan, targets, work, outdir) {
+    await mkdir(work, { recursive: true });
+    const files = [];
+    for (const target of targets) {
+        if (target === 'tar.gz') {
+            files.push(await archiveDirectory(plan, packageArch(), work, outdir));
+            continue;
+        }
+        //The files installed, from the root of the system
+        const root = path.join(work, 'root');
+        const scripts = path.join(work, 'scripts');
+        await rm(root, { recursive: true, force: true });
+        await rm(scripts, { recursive: true, force: true });
+        const prefix = path.join(root, ...plan.prefix.split('/'));
+        await mkdir(path.dirname(prefix), { recursive: true });
+        await cp(plan.directory, prefix, { recursive: true, verbatimSymlinks: true });
+        await writeFile(path.join(prefix, 'uninstall'), uninstall(plan), { mode: 0o755 });
+        if (plan.addToPath) {
+            await mkdir(path.join(root, 'usr', 'local', 'bin'), { recursive: true });
+            await symlink(path.posix.relative('/usr/local/bin', `${plan.prefix}/${plan.program}`), path.join(root, 'usr', 'local', 'bin', plan.program));
+        }
+        await mkdir(scripts, { recursive: true });
+        if (plan.service) {
+            await mkdir(path.join(root, 'Library', 'LaunchDaemons'), { recursive: true });
+            await writeFile(path.join(root, 'Library', 'LaunchDaemons', `${plan.appId}.plist`), launchDaemon(plan, plan.service), { mode: 0o644 });
+        }
+        const hooks = installerHooks(plan);
+        if (hooks.preinstall || hooks.postinstall) {
+            await writeFile(path.join(scripts, 'preinstall'), preInstall(plan));
+            await chmod(path.join(scripts, 'preinstall'), 0o755);
+        }
+        if (plan.service || hooks.postinstall) {
+            await writeFile(path.join(scripts, 'postinstall'), postInstall(plan));
+            await chmod(path.join(scripts, 'postinstall'), 0o755);
+        }
+        const component = path.join(work, `${plan.name}-component.pkg`);
+        const built = await runCommand('pkgbuild', ['--root', root, '--identifier', plan.appId, '--version', plan.version, '--install-location', '/', '--scripts', scripts, '--ownership', 'recommended', component], work);
+        if (built.code !== 0)
+            throw new Error(`The pkg package cannot be made: ${built.output.trim()}`);
+        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch()}.pkg`);
+        await rm(file, { force: true });
+        const product = await runCommand('productbuild', ['--identifier', plan.appId, '--version', plan.version, '--package', component, file], work);
+        if (product.code !== 0)
+            throw new Error(`The pkg package cannot be made: ${product.output.trim()}`);
+        files.push({ target: target, file: file, size: (await stat(file)).size });
+    }
+    return files;
+}