@lakutata/builder 3.0.0-beta.0

package/dist/esm/lib/NativeRuntime.js

@@ -0,0 +1,177 @@
+/**
+ * The global symbol of the packed applications giving the directory of their resources (resourcesPath of lakutata)
+ */
+export const PACKAGED = 'lakutata.packaged';
+/**
+ * The directory of the resources of the embedded trees
+ */
+export const EMBEDDED_RESOURCES = '.lakutata/resources';
+/**
+ * The asset of the executables holding the files of the native tree (gzipped), and the one of its index
+ */
+export const NATIVE_DATA_ASSET = 'lakutata-native';
+export const NATIVE_INDEX_ASSET = 'lakutata-native.json';
+/**
+ * The global symbol of the executables of Bun giving the files of the native tree they embed: {data, index}, their paths
+ * in the executable
+ */
+export const BUN_NATIVE_ASSETS = 'lakutata.native';
+/**
+ * The require of a bundle having native addons, which loads the native packages from the native tree: next to the bundle,
+ * or, in an executable, extracted from its assets once into the cache directory of the program (a directory named after
+ * the hash of the tree: the versions of the program do not share it). The assets are the ones of a single executable
+ * application of Node.js, or the files embedded in an executable of Bun. The other modules are loaded by the require of node.
+ * Its source is written at the top of the bundle: it uses nothing but its arguments and the modules of node
+ * @param nodeRequire
+ * @param config
+ */
+export function lakutataNativeRequire(nodeRequire, config) {
+    const path = nodeRequire('node:path');
+    const fs = nodeRequire('node:fs');
+    const os = nodeRequire('node:os');
+    const { createRequire } = nodeRequire('node:module');
+    let sea;
+    try {
+        sea = nodeRequire('node:sea');
+    }
+    catch {
+        sea = undefined;
+    }
+    //The files of the tree embedded in an executable of Bun (BUN_NATIVE_ASSETS)
+    const bun = globalThis[Symbol.for('lakutata.native')];
+    const asset = (name) => bun ? fs.readFileSync(bun[name]) : Buffer.from(sea.getAsset(name === 'data' ? 'lakutata-native' : 'lakutata-native.json'));
+    const modules = new Set(config.modules);
+    let root;
+    let treeRequire;
+    //The cache directory of the program: LAKUTATA_NATIVE_DIR, else the one of the platform
+    const cacheDirectory = () => {
+        if (process.env.LAKUTATA_NATIVE_DIR)
+            return process.env.LAKUTATA_NATIVE_DIR;
+        const home = os.homedir();
+        if (process.platform === 'darwin')
+            return path.join(home, 'Library', 'Caches', config.name);
+        if (process.platform === 'win32')
+            return path.join(process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), config.name, 'Cache');
+        return path.join(process.env.XDG_CACHE_HOME || path.join(home, '.cache'), config.name);
+    };
+    //Extract the tree into a directory named after its hash: written aside, then renamed (the processes starting together
+    //do not see a tree partly written)
+    const extract = (base) => {
+        const directory = path.join(base, 'native', config.hash);
+        if (fs.existsSync(path.join(directory, '.complete')))
+            return directory;
+        const index = JSON.parse(asset('index').toString('utf8'));
+        const data = nodeRequire('node:zlib').gunzipSync(asset('data'));
+        const temporary = `${directory}.${process.pid}.${Date.now()}`;
+        const local = (root, file) => path.join(root, ...file.split('/'));
+        try {
+            for (const file of index.files) {
+                const target = local(temporary, file.path);
+                fs.mkdirSync(path.dirname(target), { recursive: true });
+                fs.writeFileSync(target, data.subarray(file.offset, file.offset + file.size), { mode: file.mode });
+            }
+            for (const link of index.links) {
+                const at = local(temporary, link.path);
+                fs.mkdirSync(path.dirname(at), { recursive: true });
+                //A junction of Windows points to its absolute path, the one of the tree once renamed
+                if (process.platform === 'win32')
+                    fs.symlinkSync(local(directory, link.target), at, 'junction');
+                else
+                    fs.symlinkSync(path.relative(path.dirname(at), local(temporary, link.target)), at, 'dir');
+            }
+            fs.writeFileSync(path.join(temporary, '.complete'), '');
+            try {
+                fs.renameSync(temporary, directory);
+            }
+            catch (error) {
+                //Another process extracted it
+                if (!fs.existsSync(path.join(directory, '.complete')))
+                    throw error;
+            }
+        }
+        finally {
+            fs.rmSync(temporary, { recursive: true, force: true });
+        }
+        return directory;
+    };
+    const locate = () => {
+        if (root)
+            return root;
+        if (config.embedded) {
+            try {
+                root = extract(cacheDirectory());
+            }
+            catch (error) {
+                //The cache directory cannot be written: the temporary directory
+                if (process.env.LAKUTATA_NATIVE_DIR)
+                    throw error;
+                root = extract(path.join(os.tmpdir(), config.name));
+            }
+        }
+        else {
+            //Next to the bundle, or in the resources of a packaged Electron application (outside of its archive)
+            const resources = process.resourcesPath;
+            const local = path.join(__dirname, config.directory);
+            root = fs.existsSync(local) || !resources ? local : path.join(resources, config.directory);
+        }
+        return root;
+    };
+    const fromTree = (id) => {
+        const parts = id.split('/');
+        return modules.has(id.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]);
+    };
+    const tree = () => treeRequire ??= createRequire(path.join(locate(), 'index.js'));
+    const require = ((id) => fromTree(id) ? tree()(id) : nodeRequire(id));
+    require.resolve = ((id, options) => fromTree(id) ? tree().resolve(id, options) : nodeRequire.resolve(id, options));
+    require.cache = nodeRequire.cache;
+    require.main = nodeRequire.main;
+    require.extensions = nodeRequire.extensions;
+    //The addons of the application itself
+    require.lakutataNative = (key) => {
+        const addon = { exports: {} };
+        process.dlopen(addon, path.join(locate(), ...key.split('/')));
+        return addon.exports;
+    };
+    //The resources of an executable are extracted with the tree (PACKAGED, EMBEDDED_RESOURCES)
+    if (config.embedded)
+        globalThis[Symbol.for('lakutata.packaged')] = { resources: () => path.join(locate(), '.lakutata', 'resources') };
+    return require;
+}
+/**
+ * Load the environment file of the application into its environment, before it starts: the file given by
+ * LAKUTATA_ENV_FILE (the services of Windows, whose wrapper has none), its lines NAME=value or NAME="value" (the
+ * quoted values with their \\ escapes, as the installers write them), its comments (#). Its source is written at the top
+ * of the bundle: it uses nothing but its argument and the modules of node
+ * @param nodeRequire
+ */
+export function lakutataEnvironmentFile(nodeRequire) {
+    const file = process.env.LAKUTATA_ENV_FILE;
+    if (!file)
+        return;
+    const fs = nodeRequire('node:fs');
+    if (!fs.existsSync(file))
+        return;
+    for (const line of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+        const matched = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line);
+        if (!matched || line.trimStart().startsWith('#'))
+            continue;
+        const raw = matched[2];
+        process.env[matched[1]] = raw.startsWith('"') && raw.endsWith('"') && raw.length > 1 ? raw.slice(1, -1).replace(/\\(.)/g, '$1') : raw;
+    }
+}
+/**
+ * The source given to the top of every bundle: it is packed (isPackaged of lakutata), its resources are in a directory
+ * next to it, or in the resources of a packaged Electron application (outside of its archive); its environment file is
+ * loaded (LAKUTATA_ENV_FILE)
+ * @param directory the directory of the resources, relative to the bundle
+ */
+export function packagedBanner(directory) {
+    return `globalThis[Symbol.for(${JSON.stringify(PACKAGED)})]={resources:function(){var p=require('node:path'),l=p.join(__dirname,${JSON.stringify(directory)}),r=process.resourcesPath;return require('node:fs').existsSync(l)||!r?l:p.join(r,${JSON.stringify(directory)})}};(${lakutataEnvironmentFile.toString()})(require);\n`;
+}
+/**
+ * The source given to the top of a bundle: its require loads the native packages from the tree
+ * @param config
+ */
+export function nativeBanner(config) {
+    return `var require = (${lakutataNativeRequire.toString()})(require, ${JSON.stringify(config)});\n`;
+}

package/dist/esm/lib/Platform.js

@@ -0,0 +1,9 @@
+/**
+ * The C library of Linux: the executables made on it run on the systems of the same library (undefined out of Linux)
+ */
+export function detectLibc() {
+    if (process.platform !== 'linux')
+        return undefined;
+    const report = process.report?.getReport();
+    return report?.header?.glibcVersionRuntime ? 'glibc' : 'musl';
+}

package/dist/esm/lib/Processes.js

@@ -0,0 +1,42 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+/**
+ * An argument of a command run by cmd.exe (Windows): quoted as the programs read their arguments
+ * @param arg
+ */
+function quoted(arg) {
+    if (/^[\w\-.:/\\=@,+]+$/.test(arg))
+        return arg;
+    return `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1')}"`;
+}
+/**
+ * Spawn a command: on Windows, the commands found in the PATH by their names (the package managers, the commands of npm:
+ * npm.cmd, bun.cmd) are scripts, run by cmd.exe with their arguments quoted; the executables given by their paths (the
+ * ones of spaces: C:\Program Files\nodejs\node.exe) are run as they are
+ * @param command
+ * @param args
+ * @param options
+ */
+export function spawnCommand(command, args, options) {
+    if (process.platform === 'win32' && !path.isAbsolute(command))
+        return spawn([command, ...args].map(quoted).join(' '), { ...options, shell: true });
+    return spawn(command, args, options);
+}
+/**
+ * Run a command, its output is given back
+ * @param command
+ * @param args
+ * @param cwd
+ * @return the exit code and the output
+ */
+export function runCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawnCommand(command, args, { cwd: cwd });
+        let output = '';
+        //Piped (the default stdio)
+        child.stdout.on('data', (chunk) => output += chunk.toString());
+        child.stderr.on('data', (chunk) => output += chunk.toString());
+        child.once('error', reject);
+        child.once('close', (code) => resolve({ code: code ?? 1, output: output }));
+    });
+}

package/dist/esm/lib/Scripts.js

@@ -0,0 +1,161 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * The moments of the installers the scripts of the applications are run at, the same on every system: before and after
+ * the installation (and the upgrades), before and after the removal (not the one of an upgrade)
+ */
+export const INSTALLER_HOOKS = ['preinstall', 'postinstall', 'preremove', 'postremove'];
+/**
+ * The scripts of the packages of Linux, as nFPM runs them: the ones of each package, given its own arguments (the ones
+ * of dpkg, of rpm, of apk, of pacman); the upgrades of apk and pacman have their own ones
+ */
+export const NATIVE_HOOKS = ['preinstall', 'postinstall', 'preremove', 'postremove', 'preupgrade', 'postupgrade'];
+/**
+ * The installers which run no script (archives, copied by their users)
+ */
+const ARCHIVES = ['tar.gz', 'zip'];
+/**
+ * The moments the installers of lakutata run the scripts at: all of them, but the archives
+ * @param target
+ */
+function lakutataHooks(target) {
+    return ARCHIVES.includes(target) ? [] : INSTALLER_HOOKS;
+}
+/**
+ * A script of the project, read
+ * @param project
+ * @param file
+ * @param where its place in the configuration
+ */
+function read(project, file, where) {
+    if (typeof file !== 'string' || !file)
+        throw new Error(`The script ${where} must be a file of the project`);
+    const absolute = path.resolve(project, file);
+    if (!existsSync(absolute) || !statSync(absolute).isFile())
+        throw new Error(`The script ${where} (${file}) does not exist`);
+    //Without the mark of UTF-8, which the scripts are given with when they need it
+    return { file: file, content: readFileSync(absolute, 'utf8').replace(/^\ufeff/, '') };
+}
+/**
+ * The scripts of a moment, checked
+ * @param project
+ * @param scripts
+ * @param where
+ * @param windows
+ */
+function installerHooks(project, scripts, where, windows) {
+    if (scripts === undefined)
+        return {};
+    if (!scripts || typeof scripts !== 'object' || Array.isArray(scripts))
+        throw new Error(`The scripts ${where} must be {"preinstall": "<file>", "postinstall": "<file>", "preremove": "<file>", "postremove": "<file>"}`);
+    const hooks = {};
+    for (const [hook, file] of Object.entries(scripts)) {
+        if (!INSTALLER_HOOKS.includes(hook))
+            throw new Error(`The script ${where}.${hook} is not one of ${INSTALLER_HOOKS.join(', ')}`);
+        if (windows && typeof file === 'string' && !/\.ps1$/i.test(file))
+            throw new Error(`The script ${where}.${hook} (${file}) must be a script of PowerShell (.ps1)`);
+        hooks[hook] = read(project, file, `${where}.${hook}`);
+    }
+    return hooks;
+}
+/**
+ * The scripts of the installers made on a platform: the ones of the platform (lakutata.installer.<platform>.scripts),
+ * replaced by the ones of each installer (lakutata.installer.<platform>.<installer>.scripts), the native ones of the
+ * packages of Linux (nativeScripts), the file of NSIS included by its installer (win.nsis.include). The ones an
+ * installer does not run are told (warnings)
+ * @param project
+ * @param platform its name in the configuration: linux, mac or win
+ * @param config its configuration
+ * @param targets the installers made
+ * @param warnings
+ * @param hooks the moments each installer runs the scripts at (the installers of lakutata by default)
+ * @param native whether the packages of Linux run native scripts (the ones of lakutata)
+ */
+export function resolveScripts(project, platform, config, targets, warnings, hooks = lakutataHooks, native = true) {
+    const windows = platform === 'win';
+    const where = `lakutata.installer.${platform}`;
+    const common = installerHooks(project, config?.scripts, `${where}.scripts`, windows);
+    const resolved = {};
+    const unrun = [];
+    for (const target of targets) {
+        const options = config?.[target];
+        if (options !== undefined && (!options || typeof options !== 'object' || Array.isArray(options)))
+            throw new Error(`${where}.${target} must be an object`);
+        const own = (options ?? {});
+        const scripts = { hooks: { ...common, ...installerHooks(project, own.scripts, `${where}.${target}.scripts`, windows) }, native: {} };
+        if (own.nativeScripts !== undefined) {
+            if (!native || platform !== 'linux' || ARCHIVES.includes(target))
+                throw new Error(`${where}.${target}.nativeScripts: the native scripts are the ones of the packages of Linux lakutata makes (deb, rpm, apk, archlinux), not the ones of Electron`);
+            if (!own.nativeScripts || typeof own.nativeScripts !== 'object' || Array.isArray(own.nativeScripts))
+                throw new Error(`${where}.${target}.nativeScripts must be {"<script>": "<file>"}`);
+            //The upgrades of deb and rpm run their scripts of the installation and of the removal
+            const names = target === 'apk' || target === 'archlinux' ? NATIVE_HOOKS : INSTALLER_HOOKS;
+            for (const [hook, file] of Object.entries(own.nativeScripts)) {
+                if (!names.includes(hook))
+                    throw new Error(`${where}.${target}.nativeScripts.${hook} is not a script of ${target} (${names.join(', ')})`);
+                scripts.native[hook] = read(project, file, `${where}.${target}.nativeScripts.${hook}`);
+            }
+        }
+        if (own.include !== undefined) {
+            if (!windows || target !== 'nsis')
+                throw new Error(`${where}.${target}.include: the file of NSIS is included by the installer of NSIS (win.nsis.include)`);
+            if (typeof own.include === 'string' && !/\.nsh$/i.test(own.include))
+                throw new Error(`${where}.nsis.include (${own.include}) must be a file of NSIS (.nsh)`);
+            scripts.include = read(project, own.include, `${where}.nsis.include`);
+        }
+        //The ones the installer does not run
+        const run = hooks(target);
+        const skipped = INSTALLER_HOOKS.filter((hook) => !!scripts.hooks[hook] && !run.includes(hook));
+        for (const hook of skipped)
+            delete scripts.hooks[hook];
+        if (skipped.length)
+            unrun.push(`${target} (${skipped.join(', ')})`);
+        resolved[target] = scripts;
+    }
+    if (unrun.length)
+        warnings.push(`Some scripts of the application are not run by their installers: ${unrun.join(', ')}`);
+    return resolved;
+}
+/**
+ * The lines of sh running a script embedded in them (the scripts run before the files of the application are installed,
+ * or after they are removed): written to a temporary file, run by the interpreter of its first line (a temporary file
+ * system may not run its files), its failure the one of the script running it
+ * @param script
+ * @param prefix the directory of the application (LAKUTATA_INSTALL_DIR)
+ * @param args the arguments given to it (sh)
+ */
+export function embeddedShell(script, prefix, args) {
+    const first = script.content.split('\n', 1)[0];
+    const interpreter = first.startsWith('#!') ? first.slice(2).trim() : '/bin/sh';
+    //Not a line of the script
+    const tag = `LAKUTATA_SCRIPT_${createHash('sha1').update(script.content).digest('hex').slice(0, 12).toUpperCase()}`;
+    const content = script.content.replace(/\r\n/g, '\n');
+    return [
+        `# ${script.file}`,
+        'lakutata_script="$(mktemp)"',
+        `cat > "$lakutata_script" <<'${tag}'`,
+        ...content.endsWith('\n') ? content.slice(0, -1).split('\n') : content.split('\n'),
+        tag,
+        `LAKUTATA_INSTALL_DIR='${prefix.replace(/'/g, `'\\''`)}' ${interpreter} "$lakutata_script" ${args} || { lakutata_status=$?; rm -f "$lakutata_script"; exit $lakutata_status; }`,
+        'rm -f "$lakutata_script"'
+    ];
+}
+/**
+ * The lines of sh running a script encoded in them (base64): the scripts of the packages of electron-builder are
+ * templates, which replace their ${...}
+ * @param script
+ * @param prefix the directory of the application (LAKUTATA_INSTALL_DIR)
+ * @param args the arguments given to it (sh)
+ */
+export function encodedShell(script, prefix, args) {
+    const first = script.content.split('\n', 1)[0];
+    const interpreter = first.startsWith('#!') ? first.slice(2).trim() : '/bin/sh';
+    return [
+        `# ${script.file}`,
+        'lakutata_script="$(mktemp)"',
+        `printf '%s' '${Buffer.from(script.content.replace(/\r\n/g, '\n'), 'utf8').toString('base64')}' | base64 -d > "$lakutata_script"`,
+        `LAKUTATA_INSTALL_DIR='${prefix.replace(/'/g, `'\\''`)}' ${interpreter} "$lakutata_script" ${args} || { lakutata_status=$?; rm -f "$lakutata_script"; exit $lakutata_status; }`,
+        'rm -f "$lakutata_script"'
+    ];
+}

package/dist/esm/lib/Tools.js

@@ -0,0 +1,109 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, mkdtemp, rename, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runCommand } from './Processes.js';
+/**
+ * The tools of Windows: the same files on x64 and arm64 (x86 and .NET, emulated or AnyCPU)
+ * @param archive
+ * @param sha256
+ */
+function windows(archive, sha256) {
+    return { 'win32-x64': { archive: archive, sha256: sha256 }, 'win32-arm64': { archive: archive, sha256: sha256 } };
+}
+/**
+ * The tools of the builder
+ */
+const TOOLS = {
+    //The packages of Linux (deb, rpm, apk, archlinux), made on Linux: https://nfpm.goreleaser.com
+    nfpm: {
+        version: '2.47.0',
+        executable: 'nfpm',
+        url: (archive) => `https://github.com/goreleaser/nfpm/releases/download/v2.47.0/${archive}`,
+        archives: {
+            'linux-x64': { archive: 'nfpm_2.47.0_Linux_x86_64.tar.gz', sha256: '0660ca602b2d2d2ae4781a06c692b3eeb9d437ffea05b831d76e41f4a3188783' },
+            'linux-arm64': { archive: 'nfpm_2.47.0_Linux_arm64.tar.gz', sha256: '1c0f5f2999b9a974bfb04fdb0cc3306096de530ac5dbb25d739cc5f5219c919c' }
+        }
+    },
+    //The wrapper of the services of Windows (.NET Framework, AnyCPU): https://github.com/winsw/winsw
+    winsw: {
+        version: '2.12.0',
+        executable: 'WinSW.NET461.exe',
+        url: (archive) => `https://github.com/winsw/winsw/releases/download/v2.12.0/${archive}`,
+        archives: windows('WinSW.NET461.exe', 'b5066b7bbdfba1293e5d15cda3caaea88fbeab35bd5b38c41c913d492aadfc4f')
+    },
+    //The installers of Windows (.exe): https://nsis.sourceforge.io
+    nsis: {
+        version: '3.13',
+        executable: 'nsis-3.13/makensis.exe',
+        url: (archive) => `https://sourceforge.net/projects/nsis/files/NSIS%203/3.13/${archive}/download`,
+        archives: windows('nsis-3.13.zip', 'ba63dffc4410ee89193e1cb5a41989991bd77c61068da17e3156d136b7b0b3d8')
+    },
+    //The packages of Windows Installer (.msi), candle and light: https://github.com/wixtoolset/wix3
+    wix: {
+        version: '3.14.1',
+        executable: 'candle.exe',
+        url: (archive) => `https://github.com/wixtoolset/wix3/releases/download/wix3141rtm/${archive}`,
+        archives: windows('wix314-binaries.zip', '6ac824e1642d6f7277d0ed7ea09411a508f6116ba6fae0aa5f2c7daa2ff43d31')
+    }
+};
+/**
+ * The directory of the cache of lakutata (the one of its tool): LAKUTATA_CACHE_DIR, else ~/.cache/lakutata
+ */
+export function cacheDirectory() {
+    return process.env.LAKUTATA_CACHE_DIR ?? path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache'), 'lakutata');
+}
+/**
+ * A tool of the builder: the one given by its environment variable (LAKUTATA_NFPM, LAKUTATA_WINSW, LAKUTATA_NSIS:
+ * makensis.exe, LAKUTATA_WIX: candle.exe, next to light.exe), else the version of the builder, downloaded once into the
+ * cache and checked with its sha256
+ * @param name
+ */
+export async function ensureTool(name) {
+    const given = process.env[`LAKUTATA_${name.toUpperCase()}`];
+    if (given)
+        return given;
+    const tool = TOOLS[name];
+    const platform = `${process.platform}-${process.arch}`;
+    const release = tool.archives[platform];
+    if (!release)
+        throw new Error(`${name} ${tool.version} has no release for ${platform}: give its executable (LAKUTATA_${name.toUpperCase()})`);
+    const directory = path.join(cacheDirectory(), 'tools', `${name}-${tool.version}-${platform}`);
+    const executable = path.join(directory, ...tool.executable.split('/'));
+    if (existsSync(executable))
+        return executable;
+    //SourceForge answers the browsers with its page, the tools with the file
+    const response = await fetch(tool.url(release.archive), { headers: { 'user-agent': 'Wget' } }).catch((error) => {
+        throw new Error(`${name} cannot be downloaded (${error.message}): give its executable (LAKUTATA_${name.toUpperCase()})`);
+    });
+    if (!response.ok)
+        throw new Error(`${name} cannot be downloaded (${tool.url(release.archive)}: ${response.status}): give its executable (LAKUTATA_${name.toUpperCase()})`);
+    const archive = Buffer.from(await response.arrayBuffer());
+    const sha256 = createHash('sha256').update(archive).digest('hex');
+    if (sha256 !== release.sha256)
+        throw new Error(`The archive of ${name} ${tool.version} downloaded is not the one of its release (sha256 ${sha256})`);
+    //Extracted aside, then renamed: the builds running together do not see it partly written
+    await mkdir(path.dirname(directory), { recursive: true });
+    const temporary = await mkdtemp(`${directory}.`);
+    try {
+        await writeFile(path.join(temporary, release.archive), archive);
+        //An archive (tar.gz, zip: the tar of Windows reads them), or the executable itself
+        if (/\.(tar\.gz|zip)$/.test(release.archive)) {
+            const extracted = await runCommand('tar', ['-xf', release.archive], temporary);
+            if (extracted.code !== 0)
+                throw new Error(`The archive of ${name} cannot be extracted: ${extracted.output.trim()}`);
+            await rm(path.join(temporary, release.archive));
+        }
+        await chmod(path.join(temporary, ...tool.executable.split('/')), 0o755);
+        await rename(temporary, directory).catch((error) => {
+            //Extracted by another build
+            if (!existsSync(executable))
+                throw error;
+        });
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+    return executable;
+}