@lakutata/builder 3.1.5 → 3.1.6

package/README.md

@@ -39,6 +39,19 @@ Node.js of NW.js), its resources and the manifest of NW.js. `buildNwjsApp()` put
 named after the application, and `buildInstaller()` makes its installers with `"runtime": "nwjs"` (the installers of a
 desktop application: dmg on macOS, nsis on Windows, deb on Linux by default).
 
+The mobile applications of React Native (Android, iOS, HarmonyOS) run in a libnode built from the sources of Node.js by
+lakutata/libnode. `downloadMobileNode()` downloads the libnode of a system from its releases once
+(`LAKUTATA_LIBNODE_MIRROR`: a mirror of them), checks it with their checksums and keeps it in the cache
+(`LAKUTATA_MOBILE_NODE_DIR`: a libnode of your own instead). `stageMobileApp()` makes the Node.js project of the
+application: the bundle for the Node.js of the libnode (Node.js 24.20.0, `MOBILE_NODE_VERSION`, without a libnode), the
+resources, the manifest and an entry that puts away `fetch()` without WebAssembly (HarmonyOS). It builds the native
+addons for the system from their sources, against the headers and the libraries of the libnode: a native tree per
+architecture of Android (node-gyp and the NDK), for iOS a framework per addon for each SDK (Xcode) in the directory the
+`frameworks` option gives, and for HarmonyOS a library per addon (the native SDK of DevEco Studio) in the libraries of
+the HAP the `libraries` option gives. The HAP of HarmonyOS leaves out of its resources the files whose names start with
+a dot: on HarmonyOS the native tree is packed into the project (`native.gz`, `native.json`) and extracted at its first
+run into the directory `LAKUTATA_NATIVE_DIR` gives.
+
 The Linux installers are tested in containers (Docker): `npm run test:installer` builds them on Debian and Alpine, then
 installs, upgrades and removes them on Debian and Fedora (systemd) and on Alpine (OpenRC). The macOS installers are
 installed in a macOS virtual machine (`npm run test:installer:mac`, with tart), and the Windows installers on Windows,

package/README.zh-CN.md

@@ -23,6 +23,8 @@ await buildNwjsApp({project: process.cwd()})
 
 NW.js 应用运行在它 `lakutata.nwjs` 中指定的 NW.js 版本里。`nwjsReleases()` 列出 NW.js 的发布版本，`downloadNwjs()` 把一个运行时下载到缓存目录（按其发布版本的校验和核对），`stageNwjsApp()` 为 NW.js 准备应用：为这个 NW.js 的 Node.js 打包的代码、处理成能在其中加载的原生插件（为它的架构重新构建，使用 V8 API 的插件用它的头文件重新构建；在 Windows 上让插件加载 NW.js 的 Node.js）、资源和 NW.js 的清单。`buildNwjsApp()` 把应用放进以应用命名的 NW.js normal 版本中，`buildInstaller()` 在 `"runtime": "nwjs"` 时制作它的安装包（桌面应用的安装包：默认 macOS 上是 dmg，Windows 上是 nsis，Linux 上是 deb）。
 
+React Native 手机应用（Android、iOS、鸿蒙）运行在一个 libnode 中，它由 lakutata/libnode 从 Node.js 源码编译而成。`downloadMobileNode()` 从它的 Release 下载一个系统的 libnode，只下载一次（`LAKUTATA_LIBNODE_MIRROR` 指定镜像），用 Release 的校验和验证后保存在缓存中（设置 `LAKUTATA_MOBILE_NODE_DIR` 时改用自己编译的 libnode）。`stageMobileApp()` 生成应用的 Node.js 项目：面向 libnode 中的 Node.js 的单文件包（没有 libnode 时面向 Node.js 24.20.0，`MOBILE_NODE_VERSION`）、资源、清单，以及一个入口：没有 WebAssembly 时（鸿蒙）收起 `fetch()`。它还会用 libnode 的头文件和库，从源码为目标系统编译原生插件：Android 每种架构一棵原生树（node-gyp 和 NDK）；iOS 每个插件为每个 SDK 编成一个 framework（Xcode），放在 `frameworks` 指定的目录中；鸿蒙每个插件编成一个库（DevEco Studio 的原生 SDK），放在 `libraries` 指定的 HAP 库目录中。鸿蒙的 HAP 会把以点开头的文件从资源中去掉，所以鸿蒙上的原生树打包进项目（`native.gz`、`native.json`），第一次运行时解压到 `LAKUTATA_NATIVE_DIR` 指定的目录。
+
 Linux 安装包在容器（Docker）中测试：`npm run test:installer` 先在 Debian 和 Alpine 上制作安装包，再在 Debian、Fedora（systemd）和 Alpine（OpenRC）上安装、升级和卸载它们。macOS 安装包在 macOS 虚拟机中测试安装（`npm run test:installer:mac`，使用 tart），Windows 安装包则在 Windows 上以管理员身份测试安装（`LAKUTATA_WINDOWS_INSTALL=1 npm run test:installer:windows`）。
 
 ## 另见

package/dist/esm/index.js

@@ -14,3 +14,5 @@ export { MAC_TARGETS } from './lib/mac/Mac.js';
 export { downloadNwjs, nwjsPlatform, nwjsRelease, nwjsReleases } from './lib/nwjs/Runtime.js';
 export { stageNwjsApp } from './lib/nwjs/Stage.js';
 export { buildNwjsApp } from './lib/nwjs/Package.js';
+export { stageMobileApp } from './lib/mobile/Stage.js';
+export { downloadMobileNode, MOBILE_NODE_RELEASE, MOBILE_NODE_VERSION } from './lib/mobile/Node.js';

package/dist/esm/lib/Installer.js

@@ -114,7 +114,7 @@ export async function buildInstaller(options) {
             await writeFile(icon, icoFile(application.image));
         }
         //The executable and what it loads; or the application of NW.js (its runtime, its executable named after it)
-        const nwjs = desktop ? await buildNwjsApp({ project: project, entry: options.entry, minify: options.minify, external: options.external, arch: options.arch, outdir: path.join(work, 'stage') }) : undefined;
+        const nwjs = desktop ? await buildNwjsApp({ project: project, entry: options.entry, minify: options.minify, external: options.external, arch: options.arch, outdir: path.join(work, 'stage'), progress: options.progress }) : undefined;
         const executable = nwjs ? undefined : await buildExecutable({
             project: project,
             entry: options.entry,
@@ -166,8 +166,8 @@ export async function buildInstaller(options) {
         const outdir = path.resolve(project, options.outdir ?? path.join('dist', 'installer'));
         await mkdir(outdir, { recursive: true });
         const files = mac ? await buildMacPackages(plan, targets, path.join(work, 'mac'), outdir)
-            : windows ? await buildWindowsPackages(plan, targets, path.join(work, 'win'), outdir)
-                : await buildLinuxPackages(plan, targets, path.join(work, 'linux'), outdir);
+            : windows ? await buildWindowsPackages(plan, targets, path.join(work, 'win'), outdir, options.progress)
+                : await buildLinuxPackages(plan, targets, path.join(work, 'linux'), outdir, options.progress);
         return { name: name, version: version, files: files, ...executable ? { executable: executable } : {}, ...nwjs ? { nwjs: nwjs } : {}, warnings: warnings };
     }
     finally {

package/dist/esm/lib/NativeRuntime.js

@@ -82,13 +82,33 @@ export function lakutataNativeRequire(nodeRequire, config) {
                     fs.symlinkSync(path.relative(path.dirname(at), local(temporary, link.target)), at, 'dir');
             }
             fs.writeFileSync(path.join(temporary, '.complete'), '');
+            const complete = () => fs.existsSync(path.join(directory, '.complete'));
             try {
                 fs.renameSync(temporary, directory);
             }
             catch (error) {
                 //Another process extracted it
-                if (!fs.existsSync(path.join(directory, '.complete')))
+                if (complete())
+                    return directory;
+                if (!fs.existsSync(directory))
                     throw error;
+                //A tree left incomplete (a process stopped, a cleaning of the temporary files that keeps the directories):
+                //moved aside, removed, replaced
+                const stale = `${directory}.stale.${process.pid}.${Date.now()}`;
+                try {
+                    fs.renameSync(directory, stale);
+                }
+                catch {
+                    //Moved by another process
+                }
+                fs.rmSync(stale, { recursive: true, force: true });
+                try {
+                    fs.renameSync(temporary, directory);
+                }
+                catch (retry) {
+                    if (!complete())
+                        throw retry;
+                }
             }
         }
         finally {
@@ -114,10 +134,12 @@ export function lakutataNativeRequire(nodeRequire, config) {
             }
         }
         else {
-            //Next to the bundle, or in the resources of a packaged Electron application (outside of its archive)
+            //Next to the bundle, the tree of the architecture first (<directory>-arm64: a mobile application of Android holds
+            //one tree per architecture), 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);
+            const own = `${local}-${process.arch}`;
+            root = fs.existsSync(own) ? own : fs.existsSync(local) || !resources ? local : path.join(resources, config.directory);
         }
         return root;
     };

package/dist/esm/lib/Processes.js

@@ -27,11 +27,12 @@ export function spawnCommand(command, args, options) {
  * @param command
  * @param args
  * @param cwd
+ * @param env its environment, the one of the process by default
  * @return the exit code and the output
  */
-export function runCommand(command, args, cwd) {
+export function runCommand(command, args, cwd, env) {
     return new Promise((resolve, reject) => {
-        const child = spawnCommand(command, args, { cwd: cwd });
+        const child = spawnCommand(command, args, { cwd: cwd, env: env });
         let output = '';
         //Piped (the default stdio)
         child.stdout.on('data', (chunk) => output += chunk.toString());

package/dist/esm/lib/Tools.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { chmod, mkdir, mkdtemp, rename, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, mkdtemp, open, rename, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { runCommand } from './Processes.js';
@@ -54,13 +54,100 @@ const TOOLS = {
 export function cacheDirectory() {
     return process.env.LAKUTATA_CACHE_DIR ?? path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache'), 'lakutata');
 }
+/**
+ * Download a file, its sha256 computed while it is written. A connection receiving too little (one of the releases of
+ * GitHub can stay at some kilobytes a second while another one downloads the file at once) or broken is left for
+ * another one, which downloads the file again from its start
+ * @param url
+ * @param file
+ * @param options
+ */
+export async function downloadFile(url, file, options = {}) {
+    const interval = options.interval ?? 30000;
+    const minimum = options.minimum ?? 100 * 1024;
+    const attempts = options.attempts ?? 3;
+    const slow = `under ${minimum % 1024 === 0 ? `${minimum / 1024} KB` : `${minimum} bytes`} received in ${interval / 1000} s`;
+    for (let attempt = 1;; attempt++) {
+        const controller = new AbortController();
+        let received = 0;
+        let checked = 0;
+        //From the request: a connection waiting for its response receives nothing too
+        const timer = setInterval(() => {
+            if (received - checked < minimum)
+                controller.abort();
+            checked = received;
+        }, interval);
+        try {
+            const response = await fetch(url, { headers: options.headers, signal: controller.signal });
+            if (!response.ok || !response.body)
+                throw new Error(`${url} cannot be downloaded (${response.status})`);
+            const hash = createHash('sha256');
+            const handle = await open(file, 'w');
+            try {
+                for await (const chunk of response.body) {
+                    received += chunk.length;
+                    hash.update(chunk);
+                    await handle.write(chunk);
+                }
+            }
+            finally {
+                await handle.close();
+            }
+            return hash.digest('hex');
+        }
+        catch (error) {
+            //The connections broken fail with a TypeError (fetch failed, terminated); a file refused by the server, or
+            //which cannot be written, is not downloaded again
+            const cause = error.cause?.code;
+            const reason = controller.signal.aborted ? slow : error instanceof TypeError ? `${error.message}${cause ? ` (${cause})` : ''}` : undefined;
+            if (reason === undefined)
+                throw error;
+            if (attempt === attempts)
+                throw new Error(`${url} cannot be downloaded, ${attempts} connections tried: ${reason}`, { cause: error });
+            options.progress?.(`${path.basename(file)} again (${attempt + 1}/${attempts}): ${reason}`);
+        }
+        finally {
+            clearInterval(timer);
+        }
+    }
+}
+/**
+ * Move a directory written aside into its place in the cache. The one already there is kept when it is complete (put
+ * there by another build running at the same time), and replaced when it is not: left by a build that was stopped, or
+ * emptied by a cleaning of the temporary files that removes the files and keeps the directories (macOS cleans its
+ * temporary directory so)
+ * @param temporary The directory written, removed by the caller.
+ * @param target Its place in the cache.
+ * @param complete Whether the directory in its place is complete.
+ */
+export async function moveIntoCache(temporary, target, complete) {
+    try {
+        await rename(temporary, target);
+    }
+    catch (error) {
+        if (complete())
+            return;
+        if (!existsSync(target))
+            throw error;
+        //Moved aside before being removed: its place is free at once for this build and the others
+        const stale = `${target}.stale-${process.pid}-${Date.now()}`;
+        await rename(target, stale).catch(() => undefined);
+        await rm(stale, { recursive: true, force: true });
+        await rename(temporary, target).catch((retry) => {
+            //Put there by another build meanwhile
+            if (!complete())
+                throw retry;
+        });
+    }
+}
 /**
  * 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
+ * @param progress Called with what is being downloaded
  */
-export async function ensureTool(name) {
+export async function ensureTool(name, progress) {
     const given = process.env[`LAKUTATA_${name.toUpperCase()}`];
     if (given)
         return given;
@@ -73,21 +160,17 @@ export async function ensureTool(name) {
     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
+    progress?.(`${release.archive} (${name} ${tool.version})`);
+    //Downloaded and 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);
+        //SourceForge answers the browsers with its page, the tools with the file
+        const sha256 = await downloadFile(tool.url(release.archive), path.join(temporary, release.archive), { headers: { 'user-agent': 'Wget' }, progress: progress }).catch((error) => {
+            throw new Error(`${error.message}: give the executable of ${name} (LAKUTATA_${name.toUpperCase()})`);
+        });
+        if (sha256 !== release.sha256)
+            throw new Error(`The archive of ${name} ${tool.version} downloaded is not the one of its release (sha256 ${sha256})`);
         //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);
@@ -96,11 +179,7 @@ export async function ensureTool(name) {
             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;
-        });
+        await moveIntoCache(temporary, directory, () => existsSync(executable));
     }
     finally {
         await rm(temporary, { recursive: true, force: true });

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

@@ -328,8 +328,9 @@ function packageScripts(plan, target) {
  * @param targets
  * @param work
  * @param outdir
+ * @param progress Called with what is being downloaded (nFPM)
  */
-export async function buildLinuxPackages(plan, targets, work, outdir) {
+export async function buildLinuxPackages(plan, targets, work, outdir, progress) {
     await mkdir(work, { recursive: true });
     const files = [];
     const service = plan.service;
@@ -398,7 +399,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
         };
         //JSON is YAML
         await writeFile(path.join(directory, 'nfpm.yaml'), JSON.stringify(config, null, 2));
-        const nfpm = await ensureTool('nfpm');
+        const nfpm = await ensureTool('nfpm', progress);
         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);