@lakutata/cli 3.1.4 → 3.1.6

package/dist/esm/controllers/MobileController.js

@@ -0,0 +1,677 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { spawn } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, statSync, watch } from 'node:fs';
+import { cp, mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { MobileDeployDTO } from '../dtos/MobileDeployDTO.js';
+import { MobileNodeDTO } from '../dtos/MobileNodeDTO.js';
+import { MobileRunDTO } from '../dtos/MobileRunDTO.js';
+import { MobileStageDTO } from '../dtos/MobileStageDTO.js';
+import { loadBuilder } from '../lib/Builder.js';
+import { done, step, warn } from '../lib/Output.js';
+import { runCommand, spawnCommand } from '../lib/Processes.js';
+/**
+ * Where the native module of Android runs the Node.js project (copied there from the assets), and the marker of a copy
+ * written while developing, which the native module keeps instead of copying the assets again
+ */
+const ANDROID_PROJECT = 'files/nodejs';
+const ANDROID_DEVELOPMENT = 'files/nodejs.dev';
+/**
+ * The port of Metro, which the debug builds of the user interface load it from
+ */
+const METRO_PORT = 8081;
+/**
+ * Run a command, its output given back; its input written to it (a stream of tar)
+ * @param command
+ * @param args
+ * @param input
+ */
+function run(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: [input ? 'pipe' : 'ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => stdout += chunk.toString());
+        child.stderr.on('data', (chunk) => stderr += chunk.toString());
+        child.once('error', reject);
+        child.once('close', (code) => resolve({ code: code ?? 1, stdout: stdout, stderr: stderr }));
+        if (input)
+            input.pipe(child.stdin);
+    });
+}
+/**
+ * Run a command, which must succeed
+ * @param what
+ * @param command
+ * @param args
+ * @param input
+ */
+async function must(what, command, args, input) {
+    const result = await run(command, args, input);
+    if (result.code !== 0)
+        throw new Error(`${what}: ${(result.stderr || result.stdout).trim() || `${command} exited with ${result.code}`}`);
+    return result.stdout;
+}
+/**
+ * Run a command whose output is shown as it runs (the builds of the native projects), which must succeed
+ * @param command
+ * @param args
+ * @param cwd
+ * @param env
+ */
+async function shown(command, args, cwd, env) {
+    step(`${path.basename(command)} ${args.join(' ')}`);
+    const code = await new Promise((resolve, reject) => {
+        const child = spawnCommand(command, args, { cwd: cwd, env: env, stdio: 'inherit' });
+        child.once('error', reject);
+        child.once('exit', resolve);
+    });
+    if (code !== 0)
+        throw new Error(`${path.basename(command)} ${args.join(' ')} failed (${code})`);
+}
+/**
+ * The project of a mobile application holding a directory: the first one up holding packages/ipc/native/NodeHost.cpp
+ * and packages/app
+ * @param directory
+ */
+function mobileProject(directory) {
+    for (let current = directory;; current = path.dirname(current)) {
+        const packages = path.join(current, 'packages');
+        if (existsSync(path.join(packages, 'ipc', 'native', 'NodeHost.cpp')) && existsSync(path.join(packages, 'app', 'package.json'))) {
+            return { root: current, app: path.join(packages, 'app'), native: path.join(packages, 'ipc', 'native') };
+        }
+        if (current === path.dirname(current))
+            throw new Error(`${directory} is in no project of a mobile application (packages/app and packages/ipc/native/NodeHost.cpp, as the mobile-react template lays them out)`);
+    }
+}
+/**
+ * The libnode of a system put into the project (packages/ipc/native/node/out/<platform>)
+ * @param project
+ * @param platform
+ */
+function nodeOf(project, platform) {
+    return path.join(project.native, 'node', 'out', platform);
+}
+/**
+ * Download the libnode of a system from the releases of lakutata/libnode (once: kept in the cache of lakutata) and put
+ * it into the project, where its native project takes it
+ * @param project
+ * @param platform
+ * @param abis the architectures of Android
+ * @returns where it is put
+ */
+async function putNode(project, platform, abis) {
+    const { downloadMobileNode } = await loadBuilder(project.app);
+    const downloaded = await downloadMobileNode({ platform: platform, abis: abis, progress: (line) => step(`Downloading ${line}`) });
+    const out = nodeOf(project, platform);
+    await rm(out, { recursive: true, force: true });
+    await mkdir(path.dirname(out), { recursive: true });
+    //The files themselves, not the links of an export given (LAKUTATA_MOBILE_NODE_DIR): CocoaPods does not follow them
+    await cp(downloaded, out, { recursive: true, dereference: true, filter: (file) => path.basename(file) !== '.complete' });
+    //The libraries of the HAP hold libnode.so, which the addons and the runtime of the native module load by its name
+    if (platform === 'harmony') {
+        await mkdir(harmonyLibraries(project), { recursive: true });
+        await cp(path.join(out, 'libs', 'arm64-v8a', 'libnode.so'), path.join(harmonyLibraries(project), 'libnode.so'));
+    }
+    return out;
+}
+/**
+ * Where the native project of a system takes the Node.js project of the application
+ * @param project
+ * @param platform
+ */
+function stageOf(project, platform) {
+    if (platform === 'android')
+        return path.join(project.root, 'android', 'app', 'src', 'main', 'assets', 'nodejs');
+    if (platform === 'ios')
+        return path.join(project.root, 'ios', 'nodejs');
+    return path.join(project.root, 'harmony', 'entry', 'src', 'main', 'resources', 'resfile', 'nodejs');
+}
+/**
+ * The libraries of the HAP of HarmonyOS (the libs/arm64-v8a of its module): libnode.so and the native addons
+ * @param project
+ */
+function harmonyLibraries(project) {
+    return path.join(project.root, 'harmony', 'entry', 'libs', 'arm64-v8a');
+}
+/**
+ * The id of the application on a system, as its native project gives it: the applicationId of Android, the bundle
+ * identifier of iOS, the bundleName of HarmonyOS
+ * @param project
+ * @param platform
+ */
+function appIdOf(project, platform) {
+    const read = (file, pattern, what) => {
+        const id = existsSync(file) ? pattern.exec(readFileSync(file, 'utf8'))?.[1] : undefined;
+        if (!id)
+            throw new Error(`The id of the application cannot be read (${what} of ${path.relative(project.root, file)})`);
+        return id;
+    };
+    if (platform === 'android')
+        return read(path.join(project.root, 'android', 'app', 'build.gradle'), /applicationId\s+["']([^"']+)["']/, 'applicationId');
+    if (platform === 'ios')
+        return read(path.join(project.root, 'ios', 'App.xcodeproj', 'project.pbxproj'), /PRODUCT_BUNDLE_IDENTIFIER = "?([^";]+)"?;/, 'PRODUCT_BUNDLE_IDENTIFIER');
+    return read(path.join(project.root, 'harmony', 'AppScope', 'app.json5'), /"bundleName"\s*:\s*"([^"]+)"/, 'bundleName');
+}
+/**
+ * The adb of the Android SDK (ANDROID_HOME), else the one of the PATH
+ */
+function adbProgram() {
+    const home = process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT;
+    return home ? path.join(home, 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb') : 'adb';
+}
+/**
+ * The emulator or the device of Android the command runs on: the one given, else the one running (adb devices)
+ * @param device
+ */
+async function androidDevice(device) {
+    if (device)
+        return device;
+    const serial = (await must('The devices of Android cannot be listed', adbProgram(), ['devices'])).split('\n').map((line) => line.trim().split(/\s+/)).find((parts) => parts[1] === 'device')?.[0];
+    if (!serial)
+        throw new Error('No emulator or device of Android is running (start one: emulator -avd <name>)');
+    return serial;
+}
+/**
+ * The architecture of an emulator or a device of Android (its ABI: arm64-v8a, x86_64…)
+ * @param serial
+ */
+async function androidAbi(serial) {
+    return (await must('The architecture of the device of Android cannot be read', adbProgram(), ['-s', serial, 'shell', 'getprop', 'ro.product.cpu.abi'])).trim();
+}
+/**
+ * Start the application installed on an emulator or a device of Android again (its launcher activity)
+ * @param serial
+ * @param appId
+ */
+async function restartAndroid(serial, appId) {
+    const adb = adbProgram();
+    const activity = (await must('The activity of the application cannot be found', adb, ['-s', serial, 'shell', 'cmd', 'package', 'resolve-activity', '--brief', '-c', 'android.intent.category.LAUNCHER', appId])).trim().split('\n').at(-1).trim();
+    await must('The application cannot be stopped', adb, ['-s', serial, 'shell', 'am', 'force-stop', appId]);
+    await must('The application cannot be started', adb, ['-s', serial, 'shell', 'am', 'start', '-n', activity]);
+}
+/**
+ * Put the Node.js project into the application installed on an emulator or a device of Android (a debug build:
+ * run-as), marked as written while developing (the native module keeps it instead of copying the assets again), and
+ * start the application again
+ * @param directory
+ * @param appId
+ * @param serial
+ */
+async function deployAndroid(directory, appId, serial) {
+    const adb = adbProgram();
+    const installed = await run(adb, ['-s', serial, 'shell', 'pm', 'path', appId]);
+    if (installed.code !== 0 || !installed.stdout.includes('package:'))
+        throw new Error(`The application ${appId} is not installed on ${serial} (npm run android)`);
+    const debuggable = await run(adb, ['-s', serial, 'shell', 'run-as', appId, 'ls']);
+    if (debuggable.code !== 0)
+        throw new Error(`The files of ${appId} cannot be written (run-as): a debug build of the application is deployed to (${(debuggable.stderr || debuggable.stdout).trim()})`);
+    await must('The application cannot be stopped', adb, ['-s', serial, 'shell', 'am', 'force-stop', appId]);
+    //The files of the project replaced by the ones made, through tar (the files of macOS without their extended attributes)
+    const tar = spawn('tar', ['-c', '-C', directory, '.'], { stdio: ['ignore', 'pipe', 'inherit'], env: { ...process.env, COPYFILE_DISABLE: '1' } });
+    await must('The Node.js project cannot be written into the application', adb, ['-s', serial, 'shell', 'run-as', appId, 'sh', '-c', `'rm -rf ${ANDROID_PROJECT} && mkdir -p ${ANDROID_PROJECT} && tar -x -f - -C ${ANDROID_PROJECT} && touch ${ANDROID_DEVELOPMENT}'`], tar.stdout);
+    await restartAndroid(serial, appId);
+}
+/**
+ * Build the debug application of Android (Gradle, for the architecture of the device), install it, make Metro reachable
+ * from the device (adb reverse) and start the application: the Node.js project of its assets replaces a copy deployed
+ * before
+ * @param project
+ * @param device
+ * @return the id of the application and the device
+ */
+async function runAndroid(project, device) {
+    const serial = await androidDevice(device);
+    const adb = adbProgram();
+    const appId = appIdOf(project, 'android');
+    await must('Metro cannot be made reachable from the device (adb reverse)', adb, ['-s', serial, 'reverse', `tcp:${METRO_PORT}`, `tcp:${METRO_PORT}`]);
+    const gradlew = path.join(project.root, 'android', process.platform === 'win32' ? 'gradlew.bat' : 'gradlew');
+    await shown(gradlew, ['installDebug', `-PreactNativeArchitectures=${await androidAbi(serial)}`], path.join(project.root, 'android'), { ...process.env, ANDROID_SERIAL: serial });
+    await run(adb, ['-s', serial, 'shell', 'run-as', appId, 'rm', '-f', ANDROID_DEVELOPMENT]);
+    await restartAndroid(serial, appId);
+    return { appId: appId, serial: serial };
+}
+/**
+ * The simulator of iOS the application runs on, booted (its UDID): the one given (its UDID or its name), else the one
+ * running, else the newest iPhone
+ * @param device
+ */
+async function iosSimulator(device) {
+    const listed = JSON.parse(await must('The simulators cannot be listed', 'xcrun', ['simctl', 'list', 'devices', 'available', '--json']));
+    //The ones of the runtimes of iOS, the newest first
+    const simulators = Object.entries(listed.devices)
+        .filter(([runtime]) => runtime.includes('SimRuntime.iOS-'))
+        .sort(([a], [b]) => b.localeCompare(a, undefined, { numeric: true }))
+        .flatMap(([, devices]) => devices);
+    const simulator = device
+        ? simulators.find((candidate) => candidate.udid === device || candidate.name === device)
+        : simulators.find((candidate) => candidate.state === 'Booted') ?? simulators.find((candidate) => candidate.name.startsWith('iPhone'));
+    if (!simulator)
+        throw new Error(device ? `No simulator of iOS is ${device} (xcrun simctl list devices)` : 'No simulator of iOS is available (the platform of iOS of Xcode)');
+    if (simulator.state !== 'Booted') {
+        step(`The simulator ${simulator.name} booted`);
+        await must(`The simulator ${simulator.name} cannot be booted`, 'xcrun', ['simctl', 'bootstatus', simulator.udid, '-b']);
+    }
+    return simulator.udid;
+}
+/**
+ * Show a simulator of iOS in the app of Xcode showing them: Simulator, Device Hub since Xcode 27. Not shown without it:
+ * the application runs all the same
+ * @param udid
+ */
+async function showSimulator(udid) {
+    const developer = (await run('xcode-select', ['-p'])).stdout.trim();
+    if (!developer)
+        return;
+    const simulator = path.join(developer, 'Applications', 'Simulator.app');
+    const hub = path.join(developer, '..', 'Applications', 'DeviceHub.app');
+    if (existsSync(simulator))
+        await run('open', [simulator, '--args', '-CurrentDeviceUDID', udid]);
+    else if (existsSync(hub))
+        await run('open', [hub]);
+}
+/**
+ * Whether the pods of the project of iOS are those of its Podfile and of the libnode exported: installed after the last
+ * change of the Podfile and the last export of the libnode (whose framework the pod of the native module vendors)
+ * @param ios
+ * @param node the export of the libnode of iOS
+ */
+function podsInstalled(ios, node) {
+    const lock = path.join(ios, 'Podfile.lock');
+    const manifest = path.join(ios, 'Pods', 'Manifest.lock');
+    if (!existsSync(path.join(ios, 'App.xcworkspace')) || !existsSync(lock) || !existsSync(manifest) || !existsSync(path.join(ios, 'Podfile')))
+        return false;
+    const installed = statSync(manifest).mtimeMs;
+    return readFileSync(lock, 'utf8') === readFileSync(manifest, 'utf8') && installed >= statSync(path.join(ios, 'Podfile')).mtimeMs && (!existsSync(node) || installed >= statSync(node).mtimeMs);
+}
+/**
+ * Build the debug application of iOS for a simulator (the pods installed first when needed, xcodebuild), install it and
+ * start it; a simulator shares localhost with the computer, so Metro is reachable
+ * @param project
+ * @param udid the simulator, booted
+ * @return the id of the application
+ */
+async function runIos(project, udid) {
+    const ios = path.join(project.root, 'ios');
+    if (!podsInstalled(ios, nodeOf(project, 'ios')))
+        await shown('pod', ['install'], ios);
+    const derived = path.join(ios, 'build');
+    await shown('xcrun', ['xcodebuild', '-workspace', 'App.xcworkspace', '-scheme', 'App', '-configuration', 'Debug', '-destination', `id=${udid}`, '-derivedDataPath', derived, 'build'], ios);
+    const application = path.join(derived, 'Build', 'Products', 'Debug-iphonesimulator', 'App.app');
+    const id = (await must('The id of the application cannot be read', 'plutil', ['-extract', 'CFBundleIdentifier', 'raw', path.join(application, 'Info.plist')])).trim();
+    await must('The application cannot be installed', 'xcrun', ['simctl', 'install', udid, application]);
+    await showSimulator(udid);
+    await run('xcrun', ['simctl', 'terminate', udid, id]);
+    await must('The application cannot be started', 'xcrun', ['simctl', 'launch', udid, id]);
+    return id;
+}
+/**
+ * Put the Node.js project into the application installed in a simulator of iOS (the directory of the application on
+ * the Mac), with the frameworks of its native addons, and start the application again
+ * @param directory
+ * @param appId
+ * @param udid
+ * @param frameworks the frameworks of the native addons for the simulators
+ */
+async function deployIos(directory, appId, udid, frameworks) {
+    const container = (await must(`The application ${appId} is not installed on the simulator ${udid} (npm run ios)`, 'xcrun', ['simctl', 'get_app_container', udid, appId, 'app'])).trim();
+    await run('xcrun', ['simctl', 'terminate', udid, appId]);
+    const project = path.join(container, 'nodejs');
+    await rm(project, { recursive: true, force: true });
+    await mkdir(project, { recursive: true });
+    for (const entry of await readdir(directory))
+        await cp(path.join(directory, entry), path.join(project, entry), { recursive: true });
+    //The frameworks of its native addons (signed ad hoc, which the simulators take) in place of the ones of the application
+    for (const entry of existsSync(frameworks) ? await readdir(frameworks) : []) {
+        if (!entry.endsWith('.framework'))
+            continue;
+        const target = path.join(container, 'Frameworks', entry);
+        await rm(target, { recursive: true, force: true });
+        await cp(path.join(frameworks, entry), target, { recursive: true });
+    }
+    await must('The application cannot be started', 'xcrun', ['simctl', 'launch', udid, appId]);
+}
+/**
+ * The tools of DevEco Studio building and installing the applications of HarmonyOS: ohpm and hvigor (run by the Node.js
+ * of DevEco Studio), its SDK and hdc. DEVECO_STUDIO_HOME gives the directory of DevEco Studio (its Contents on macOS) or
+ * of its command line tools, DEVECO_SDK_HOME its SDK
+ */
+function devEcoTools() {
+    const home = process.env.DEVECO_STUDIO_HOME ?? (process.platform === 'darwin' ? '/Applications/DevEco-Studio.app/Contents' : path.join(os.homedir(), 'command-line-tools'));
+    const sdk = process.env.DEVECO_SDK_HOME ?? path.join(home, 'sdk');
+    const hvigor = path.join(home, 'tools', 'hvigor', 'bin', 'hvigorw.js');
+    const node = path.join(home, 'tools', 'node', 'bin', process.platform === 'win32' ? 'node.exe' : 'node');
+    if (!existsSync(hvigor))
+        throw new Error(`DevEco Studio builds the application of HarmonyOS: install it, or give its directory (DEVECO_STUDIO_HOME; ${hvigor} missing)`);
+    return {
+        ohpm: path.join(home, 'tools', 'ohpm', 'bin', process.platform === 'win32' ? 'ohpm.bat' : 'ohpm'),
+        hvigor: hvigor,
+        node: existsSync(node) ? node : process.execPath,
+        sdk: sdk,
+        hdc: path.join(sdk, 'default', 'openharmony', 'toolchains', process.platform === 'win32' ? 'hdc.exe' : 'hdc')
+    };
+}
+/**
+ * Run a command of hdc, which must succeed: hdc exits with 0 when it fails too, telling the failure in its output (a
+ * line [Fail]…, or error: … from the device)
+ * @param what
+ * @param hdc
+ * @param args
+ */
+async function mustHdc(what, hdc, args) {
+    const output = await must(what, hdc, args);
+    if (/^\[Fail\]|error:/im.test(output))
+        throw new Error(`${what}: ${output.trim()}`);
+    return output;
+}
+/**
+ * The emulator or the device of HarmonyOS the command runs on: the one given, else the one connected (hdc list targets)
+ * @param hdc
+ * @param device
+ */
+async function harmonyTarget(hdc, device) {
+    if (device)
+        return device;
+    const target = (await must('The devices of HarmonyOS cannot be listed', hdc, ['list', 'targets'])).split('\n').map((line) => line.trim()).find((line) => !!line && line !== '[Empty]');
+    if (!target)
+        throw new Error('No emulator or device of HarmonyOS is connected (start one in the Device Manager of DevEco Studio)');
+    return target;
+}
+/**
+ * The files of the application of HarmonyOS, as it sees them (hdc file send -b writes there into a debug build), where
+ * the native module runs the copy of the Node.js project written while developing (nodejs-dev: the resources of the HAP
+ * cannot be written) while its .development says on. The files cannot be removed from the computer, only written: the
+ * copy is turned off instead
+ */
+const HARMONY_FILES = '/data/storage/el2/base/files';
+/**
+ * Write the state of the copy of the Node.js project written while developing on HarmonyOS (on: deployed, off: the
+ * project of the HAP runs), along with the files of a project to deploy
+ * @param hdc
+ * @param target
+ * @param bundle
+ * @param state
+ * @param project the Node.js project deployed with the state on
+ * @returns the output of hdc
+ */
+async function writeHarmonyDevelopment(hdc, target, bundle, state, project) {
+    const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-harmony-'));
+    try {
+        //Sent into the files as nodejs-dev, merged into the copy there (hdc copies a directory into the one of its name)
+        const development = path.join(work, 'nodejs-dev');
+        if (project)
+            await cp(project, development, { recursive: true });
+        else
+            await mkdir(development);
+        await writeFile(path.join(development, '.development'), `${state}\n`);
+        return project
+            ? await run(hdc, ['-t', target, 'file', 'send', '-b', bundle, development, HARMONY_FILES])
+            : await run(hdc, ['-t', target, 'file', 'send', '-b', bundle, path.join(development, '.development'), `${HARMONY_FILES}/nodejs-dev/.development`]);
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}
+/**
+ * Write the state of the copy of the Node.js project written while developing on HarmonyOS (writeHarmonyDevelopment),
+ * with the application stopped. Once the device has started, the files of an application are there after it has run:
+ * before, hdc refuses its name (E005101), and the application is started once, then stopped, and the files written
+ * again
+ * @param hdc
+ * @param target
+ * @param bundle
+ * @param state
+ * @param project the Node.js project deployed with the state on
+ * @returns the output of hdc
+ */
+async function sendHarmonyDevelopment(hdc, target, bundle, state, project) {
+    const refused = (sent) => /E005101|Invalid bundle name/i.test(sent.stdout);
+    await run(hdc, ['-t', target, 'shell', 'aa', 'force-stop', bundle]);
+    let sent = await writeHarmonyDevelopment(hdc, target, bundle, state, project);
+    if (refused(sent)) {
+        await restartHarmony(hdc, target, bundle);
+        for (let attempt = 0; attempt < 10 && refused(sent); attempt++) {
+            await new Promise((resolve) => setTimeout(resolve, attempt ? 500 : 0));
+            await run(hdc, ['-t', target, 'shell', 'aa', 'force-stop', bundle]);
+            sent = await writeHarmonyDevelopment(hdc, target, bundle, state, project);
+        }
+    }
+    return sent;
+}
+/**
+ * Start the application installed on an emulator or a device of HarmonyOS again
+ * @param hdc
+ * @param target
+ * @param bundle
+ */
+async function restartHarmony(hdc, target, bundle) {
+    await run(hdc, ['-t', target, 'shell', 'aa', 'force-stop', bundle]);
+    const started = await must('The application cannot be started', hdc, ['-t', target, 'shell', 'aa', 'start', '-a', 'EntryAbility', '-b', bundle]);
+    if (/error/i.test(started))
+        throw new Error(`The application cannot be started: ${started.trim()}`);
+}
+/**
+ * Build the debug HAP of HarmonyOS (the user interface bundled by RNOH, hvigor), install it, make Metro reachable from
+ * the device (hdc rport) and start the application: the Node.js project of its resources replaces a copy deployed before
+ * @param project
+ * @param device
+ * @return the bundle of the application and the device
+ */
+async function runHarmony(project, device) {
+    const tools = devEcoTools();
+    const target = await harmonyTarget(tools.hdc, device);
+    const bundle = appIdOf(project, 'harmony');
+    //The user interface in the HAP, which loads it when Metro does not run (RNOH: a bundle of JavaScript)
+    const reactNative = path.join(project.root, 'node_modules', '.bin', process.platform === 'win32' ? 'react-native.cmd' : 'react-native');
+    await shown(reactNative, ['bundle-harmony', '--dev', 'false', '--bundle-output', path.join('harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'bundle.harmony.js')], project.root);
+    const harmony = path.join(project.root, 'harmony');
+    const env = { ...process.env, DEVECO_SDK_HOME: tools.sdk, PATH: `${path.dirname(tools.node)}${path.delimiter}${process.env.PATH ?? ''}` };
+    //The libraries of React Native ported to HarmonyOS (RNOH autolinking): their HARs added to oh-package.json5 before
+    //ohpm installs them, as hvigor adds them only once ohpm ran
+    await shown(reactNative, ['link-harmony'], project.root);
+    //The packages of the HAP (RNOH and the libraries, from node_modules) in harmony/oh_modules, which its native build reads
+    await shown(tools.ohpm, ['install', '--all'], harmony, env);
+    await shown(tools.node, [tools.hvigor, '--mode', 'module', '-p', 'product=default', '-p', 'module=entry@default', 'assembleHap', '--no-daemon'], harmony, env);
+    const outputs = path.join(harmony, 'entry', 'build', 'default', 'outputs', 'default');
+    const haps = existsSync(outputs) ? readdirSync(outputs).filter((name) => name.endsWith('.hap')) : [];
+    const hap = haps.find((name) => name.includes('-signed')) ?? haps[0];
+    if (!hap)
+        throw new Error(`The build made no HAP (${path.relative(project.root, outputs)})`);
+    await mustHdc('The application cannot be installed', tools.hdc, ['-t', target, 'install', '-r', path.join(outputs, hap)]);
+    //The forward of a run before removed first: the server of hdc keeps it, setting it up again on an emulator started
+    //again, and rport fails on the port it takes (none to remove: hdc tells it, which is no failure)
+    await run(tools.hdc, ['-t', target, 'fport', 'rm', `tcp:${METRO_PORT}`, `tcp:${METRO_PORT}`]);
+    await mustHdc('Metro cannot be made reachable from the device (hdc rport)', tools.hdc, ['-t', target, 'rport', `tcp:${METRO_PORT}`, `tcp:${METRO_PORT}`]);
+    //A copy deployed before turned off (none deployed: nothing to write); after the device started again too, or the
+    //copy would run instead of the project installed
+    await sendHarmonyDevelopment(tools.hdc, target, bundle, 'off');
+    await restartHarmony(tools.hdc, target, bundle);
+    return { bundle: bundle, target: target };
+}
+/**
+ * Put the Node.js project into the debug application installed on an emulator or a device of HarmonyOS (files/nodejs-dev
+ * of the application, turned on: the native module runs it instead of the one of its resources), and start the
+ * application again
+ * @param directory
+ * @param bundle
+ * @param device
+ */
+async function deployHarmony(directory, bundle, device) {
+    const tools = devEcoTools();
+    const target = await harmonyTarget(tools.hdc, device);
+    const sent = await sendHarmonyDevelopment(tools.hdc, target, bundle, 'on', directory);
+    if (sent.code !== 0 || /fail|error/i.test(sent.stdout))
+        throw new Error(`The Node.js project cannot be written into the application ${bundle} (a debug build, hdc file send -b): ${(sent.stdout || sent.stderr).trim()}`);
+    await restartHarmony(tools.hdc, target, bundle);
+    return target;
+}
+/**
+ * The commands of the mobile applications of React Native laid out as the mobile-react template: their libnode, their
+ * Node.js project, the application run on an emulator or a simulator, the project deployed into the application
+ * installed during the development
+ */
+export class MobileController extends Controller {
+    async node(input) {
+        const project = mobileProject(process.cwd());
+        const abis = input.abis ? input.abis.split(',').map((abi) => abi.trim()).filter(Boolean) : undefined;
+        const out = await putNode(project, input.platform, abis);
+        done(`The libnode of ${input.platform}: ${path.relative(process.cwd(), out)}`);
+        return undefined;
+    }
+    async stage(input) {
+        const project = mobileProject(process.cwd());
+        const stage = await this.stageProject(project, input.platform, { minify: input.minify, abis: input.abis ? input.abis.split(',').map((abi) => abi.trim()).filter(Boolean) : undefined });
+        done(`The Node.js project for ${stage.platform} (Node.js ${stage.node}): ${path.relative(process.cwd(), stage.directory)}`);
+        return undefined;
+    }
+    async run(input) {
+        const project = mobileProject(process.cwd());
+        if (input.platform === 'android') {
+            const { appId, serial } = await runAndroid(project, input.device);
+            done(`${appId} runs on ${serial}`);
+        }
+        else if (input.platform === 'ios') {
+            const udid = await iosSimulator(input.device);
+            done(`${await runIos(project, udid)} runs on the simulator ${udid}`);
+        }
+        else {
+            const { bundle, target } = await runHarmony(project, input.device);
+            done(`${bundle} runs on ${target}`);
+        }
+        return undefined;
+    }
+    async deploy(input) {
+        const project = mobileProject(process.cwd());
+        await this.deployOnce(project, input);
+        if (!input.watch)
+            return undefined;
+        //The files of the application, without its dependencies and its compiled files: built and deployed again once
+        //they stop changing
+        const manifest = JSON.parse(readFileSync(path.join(project.app, 'package.json'), 'utf8'));
+        const ignored = ['node_modules', path.dirname(manifest.main ?? 'build/App.js')].map((directory) => directory.split(path.sep).join('/'));
+        const watched = (file) => {
+            if (!file)
+                return false;
+            const relative = file.split(path.sep).join('/');
+            return !relative.split('/').some((part) => part.startsWith('.')) && !ignored.some((directory) => relative === directory || relative.startsWith(`${directory}/`));
+        };
+        step('Watching the files of the application: built and deployed again when they change (Ctrl+C to stop)');
+        await new Promise((resolve) => {
+            let timer;
+            let deploying = Promise.resolve();
+            const watcher = watch(project.app, { recursive: true }, (_event, file) => {
+                if (!watched(file))
+                    return;
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    deploying = deploying.then(async () => {
+                        if (manifest.scripts?.build) {
+                            step('npm run build');
+                            const built = await runCommand('npm', ['run', 'build'], project.app);
+                            if (built.code !== 0)
+                                return warn(`The build failed:\n${built.output.trim().split('\n').slice(-15).join('\n')}`);
+                        }
+                        await this.deployOnce(project, input);
+                    }).catch((error) => warn(error.message));
+                }, 300);
+            });
+            const stop = () => {
+                clearTimeout(timer);
+                watcher.close();
+                resolve();
+            };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        return undefined;
+    }
+    /**
+     * Make the Node.js project of the application for a system, where its native project takes it
+     * @param project
+     * @param platform
+     * @param options
+     * @protected
+     */
+    async stageProject(project, platform, options) {
+        const { stageMobileApp } = await loadBuilder(project.app);
+        //The libnode of the system downloaded first when the project has none yet
+        if (!existsSync(path.join(nodeOf(project, platform), 'include', 'node', 'node_api.h')))
+            await putNode(project, platform);
+        return stageMobileApp({
+            platform: platform,
+            project: project.app,
+            outdir: stageOf(project, platform),
+            node: nodeOf(project, platform),
+            frameworks: platform === 'ios' ? path.join(project.root, 'ios', 'NodeAddons') : undefined,
+            libraries: platform === 'harmony' ? harmonyLibraries(project) : undefined,
+            minify: options.minify,
+            abis: options.abis,
+            sdks: options.sdks,
+            progress: step
+        });
+    }
+    /**
+     * Make the Node.js project, put it into the application and start the application again
+     * @param project
+     * @param input
+     * @protected
+     */
+    async deployOnce(project, input) {
+        if (input.platform === 'android') {
+            const serial = await androidDevice(input.device);
+            //The native addons built for the architecture of the device only
+            const stage = await this.stageProject(project, 'android', { minify: false, abis: [await androidAbi(serial)] });
+            await deployAndroid(stage.directory, appIdOf(project, 'android'), serial);
+            done(`Deployed to ${appIdOf(project, 'android')} (${serial}) and started`);
+        }
+        else if (input.platform === 'ios') {
+            const udid = await iosSimulator(input.device);
+            const stage = await this.stageProject(project, 'ios', { minify: false, sdks: ['iphonesimulator'] });
+            await deployIos(stage.directory, appIdOf(project, 'ios'), udid, path.join(project.root, 'ios', 'NodeAddons', 'iphonesimulator'));
+            done(`Deployed to ${appIdOf(project, 'ios')} (${udid}) and started`);
+        }
+        else {
+            const stage = await this.stageProject(project, 'harmony', { minify: false });
+            //The libraries of the native addons are in the HAP: installed again with it
+            if (stage.addons?.libraries.length)
+                warn(`The native addons of HarmonyOS are libraries of the HAP: npm run harmony installs them (${stage.addons.libraries.join(', ')})`);
+            const target = await deployHarmony(stage.directory, appIdOf(project, 'harmony'), input.device);
+            done(`Deployed to ${appIdOf(project, 'harmony')} (${target}) and started`);
+        }
+    }
+}
+__decorate([
+    CLIAction('mobile node <platform>', MobileNodeDTO, { description: 'Download the libnode of a system (android, ios, harmony) from the releases of lakutata/libnode (LAKUTATA_LIBNODE_MIRROR: a mirror of them), once: kept in the cache of lakutata, put into packages/ipc/native/node/out/<platform>' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MobileNodeDTO]),
+    __metadata("design:returntype", Promise)
+], MobileController.prototype, "node", null);
+__decorate([
+    CLIAction('mobile stage <platform>', MobileStageDTO, { description: 'Make the Node.js project of the mobile application (packages/app) for a system (android, ios, harmony), where its native project takes it, with its native addons built against the libnode of the system' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MobileStageDTO]),
+    __metadata("design:returntype", Promise)
+], MobileController.prototype, "stage", null);
+__decorate([
+    CLIAction('mobile run <platform>', MobileRunDTO, { description: 'Build the debug application of a system (android, ios, harmony) from its native project, install it on an emulator, a device or a simulator and start it, Metro (npm start) giving its user interface' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MobileRunDTO]),
+    __metadata("design:returntype", Promise)
+], MobileController.prototype, "run", null);
+__decorate([
+    CLIAction('mobile deploy <platform>', MobileDeployDTO, { description: 'Make the Node.js project of the mobile application, put it into the debug application installed on an emulator, a device or a simulator of a system (android, ios, harmony), and start the application again (the development, without installing it again)' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MobileDeployDTO]),
+    __metadata("design:returntype", Promise)
+], MobileController.prototype, "deploy", null);