nativescript 9.1.0-alpha.3 → 9.1.0-alpha.5

package/lib/controllers/run-controller.js

@@ -285,7 +285,7 @@ class RunController extends events_1.EventEmitter {
             // spawns the Vite bundler that inherits `process.env`) so the
             // bundler trusts the tunnel instead of racing us to spawn its
             // own adb during config-load. See packages/vite hardening.
-            await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo);
+            await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-build");
             const prepareResultData = await this.$prepareController.prepare(prepareData);
             const buildData = {
                 ...deviceDescriptor.buildData,
@@ -336,6 +336,11 @@ class RunController extends events_1.EventEmitter {
                     watch: !skipWatcher,
                     liveSyncDeviceData: deviceDescriptor,
                 });
+                // Re-establish the adb reverse on the CURRENT transport right
+                // before launch — the transport can change during build/install
+                // and drop the mapping set in `pre-build`, which would leave the
+                // app unable to reach the Vite dev server at 127.0.0.1.
+                await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-launch");
                 await this.refreshApplication(projectData, liveSyncResultInfo, null, deviceDescriptor);
                 this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceStarted, {
@@ -382,7 +387,7 @@ class RunController extends events_1.EventEmitter {
      * The bundler then falls back to its own (now hardened) adb path, or
      * ultimately to `10.0.2.2`, so a reverse hiccup never fails the run.
      */
-    async setupAndroidViteHmrReverse(device, projectData, liveSyncInfo) {
+    async setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, phase) {
         try {
             if (!this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
                 return;
@@ -408,30 +413,73 @@ class RunController extends events_1.EventEmitter {
             }
             const serial = device.deviceInfo.identifier;
             const port = this.getViteHmrPort();
-            // Safe after the `isAndroidPlatform` guard above — only Android
-            // devices carry the `adb` bridge.
-            const adb = device.adb;
-            // Don't `reverse` against a device whose adbd isn't accepting
-            // yet (emulators report a `device` transport before adbd is
-            // fully up). `wait-for-device` returns immediately once ready.
-            await adb.executeCommand(["wait-for-device"], {
-                deviceIdentifier: serial,
-            });
-            await adb.executeCommand(["reverse", `tcp:${port}`, `tcp:${port}`], {
-                deviceIdentifier: serial,
-            });
-            // Hand the exact adb the CLI used to the bundler so, in any
-            // fallback path, it drives the same version-matched client and
-            // can't trigger a server-version-mismatch daemon kill.
-            const adbPath = await this.$staticConfig.getAdbFilePath();
-            process.env.NS_ADB_PATH = adbPath;
-            process.env.NS_DEVICE_SERIAL = serial;
-            process.env.NS_ADB_REVERSE_READY = "1";
-            this.$logger.info(`Set up adb reverse tcp:${port} tcp:${port} for ${serial} (Vite HMR routes device-side 127.0.0.1:${port} through ADB).`);
+            if (phase === "pre-build") {
+                // Decide the origin baked into bundle.mjs. Hand the bundler our
+                // exact adb (so any self-managed fallback can't version-mismatch
+                // the daemon) and, if the tunnel comes up, tell it to emit
+                // `127.0.0.1` and skip adb entirely.
+                process.env.NS_ADB_PATH = await this.$staticConfig.getAdbFilePath();
+                process.env.NS_DEVICE_SERIAL = serial;
+                const ok = await this.ensureAndroidReverse(device, serial, port);
+                if (ok) {
+                    process.env.NS_ADB_REVERSE_READY = "1";
+                    this.$logger.info(`Set up adb reverse tcp:${port} tcp:${port} for ${serial} (Vite HMR routes device-side 127.0.0.1:${port} through ADB).`);
+                }
+                else {
+                    this.$logger.warn(`Could not confirm 'adb reverse tcp:${port}' on ${serial} (device adbd slow/unresponsive). Vite HMR will fall back to 10.0.2.2. If this persists, cold-boot/wipe the emulator, or set NS_HMR_NO_ADB_REVERSE=1.`);
+                }
+                return;
+            }
+            // phase === "pre-launch": re-establish the mapping right before the
+            // app boots. `adb reverse` mappings are bound to the device's adb
+            // transport, and that transport can change during the (long) build
+            // + install (fresh emulators reconnect as they settle), silently
+            // dropping the early mapping. We only bother when we actually told
+            // the bundle to use `127.0.0.1` (READY set during pre-build).
+            if (!this.isTruthyEnvFlag(process.env.NS_ADB_REVERSE_READY)) {
+                return;
+            }
+            const ok = await this.ensureAndroidReverse(device, serial, port);
+            if (!ok) {
+                this.$logger.warn(`adb reverse tcp:${port} was not active before launch on ${serial}; the app may fail to reach the Vite dev server at 127.0.0.1:${port}.`);
+            }
         }
         catch (err) {
-            this.$logger.trace(`Setting up adb reverse for Vite HMR failed; leaving it to the bundler fallback. Error: ${err}`);
+            this.$logger.trace(`Setting up adb reverse for Vite HMR (${phase}) failed; leaving it to the bundler fallback. Error: ${err}`);
+        }
+    }
+    /**
+     * Apply `adb reverse tcp:<port> tcp:<port>` to the device and confirm
+     * via `adb reverse --list` that it actually landed, retrying a few
+     * times. Every device-side call is bounded with a Node `spawn` timeout
+     * + `SIGKILL` so a wedged/slow adbd (observed blocking 90s+ on some
+     * fresh-boot / API-36 arm64 emulators) can never hang the run — the
+     * hung adb child is reaped, not orphaned. Returns whether the mapping
+     * is confirmed present.
+     */
+    async ensureAndroidReverse(device, serial, port) {
+        var _a, _b, _c;
+        const adb = device.adb;
+        const ADB_WAIT_MS = 15000;
+        const ADB_REVERSE_MS = 20000;
+        const bounded = (timeout) => ({
+            deviceIdentifier: serial,
+            treatErrorsAsWarnings: true,
+            childProcessOptions: { timeout, killSignal: "SIGKILL" },
+        });
+        // `wait-for-device` only blocks until the transport is up; bounded so a
+        // never-ready device can't stall us.
+        await adb.executeCommand(["wait-for-device"], bounded(ADB_WAIT_MS));
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            await adb.executeCommand(["reverse", `tcp:${port}`, `tcp:${port}`], bounded(ADB_REVERSE_MS));
+            // Verify it landed (a SIGKILL'd-on-timeout reverse resolves rather
+            // than throws, so success of the call isn't proof).
+            const list = (_c = (_b = (_a = (await adb.executeCommand(["reverse", "--list"], bounded(ADB_WAIT_MS)))) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : "";
+            if (list.includes(`tcp:${port}`)) {
+                return true;
+            }
         }
+        return false;
     }
     getViteHmrPort() {
         // The Vite dev server defaults to 5173; the bundler reads the same

package/lib/services/bundler/bundler-compiler-service.js

@@ -8,6 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BundlerCompilerService = void 0;
 const path = require("path");
+const net = require("net");
 const semver = require("semver");
 const _ = require("lodash");
 const events_1 = require("events");
@@ -34,6 +35,10 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$packageInstallationManager = $packageInstallationManager;
         this.$projectConfigService = $projectConfigService;
         this.bundlerProcesses = {};
+        // Vite-only: the long-lived `vite serve` dev server the device fetches
+        // modules and HMR updates from. Keyed by platform, managed by this CLI
+        // so users no longer need a separate `concurrently`/`wait-on` process.
+        this.viteServeProcesses = {};
         this.expectedHashes = {};
     }
     getViteDistOutputPath(projectDir) {
@@ -47,6 +52,14 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
             let isFirstBundlerWatchCompilation = true;
             prepareData.watch = true;
+            // Bring up the Vite HMR dev server the device fetches modules /
+            // HMR updates from. No-op unless bundler is vite + hmr + watch.
+            // Fired in parallel with the build watcher; both child processes
+            // inherit the adb-reverse env the run-controller set before
+            // prepare, so neither one spawns adb on its own. Intentionally not
+            // awaited — the device only connects to it at app launch, well
+            // after the first build.
+            this.startViteDevServer(platformData, projectData, prepareData);
             try {
                 const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
                 // Handle Vite differently from webpack
@@ -346,6 +359,141 @@ class BundlerCompilerService extends events_1.EventEmitter {
         await this.$cleanupService.addKillProcess(childProcess.pid.toString());
         return childProcess;
     }
+    getViteHmrPort() {
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    /**
+     * Spawn and manage the Vite dev server (`vite serve`) for HMR.
+     *
+     * Why the CLI owns this. With Vite, HMR needs a long-lived dev server
+     * (HTTP + the `/ns-hmr` websocket on port 5173) that the device fetches
+     * modules and hot updates from — it is SEPARATE from the
+     * `vite build --watch` process that emits the `bundle.mjs` bootstrap
+     * baked into the app. Historically users wired this up themselves with
+     * `concurrently`/`wait-on`, which left two uncoordinated processes both
+     * touching adb during cold start (the source of the Android
+     * "Searching for devices…" freeze). By spawning it here as a child of
+     * the CLI, the dev server inherits the CLI's environment — crucially
+     * `NS_ADB_REVERSE_READY`/`NS_DEVICE_SERIAL`/`NS_ADB_PATH` set by the
+     * run-controller — so the CLI is the single adb owner and the dev
+     * server never spawns adb itself.
+     *
+     * No-op unless bundler is vite, HMR is on, watch mode, and not release.
+     * Best-effort: failures are logged, never thrown — a dev-server hiccup
+     * must not fail the run.
+     */
+    async startViteDevServer(platformData, projectData, prepareData) {
+        try {
+            if (this.getBundler() !== "vite") {
+                return;
+            }
+            if (!prepareData.watch || !prepareData.hmr || prepareData.release) {
+                return;
+            }
+            const key = platformData.platformNameLowerCase;
+            if (this.viteServeProcesses[key]) {
+                return;
+            }
+            const port = this.getViteHmrPort();
+            // One dev server per port. Simultaneous multi-platform HMR in a
+            // single CLI invocation would collide on 5173 — that case still
+            // needs a distinct NS_HMR_PORT per platform, so skip + warn rather
+            // than fail to bind.
+            const collidingPlatform = Object.keys(this.viteServeProcesses)[0];
+            if (collidingPlatform) {
+                this.$logger.warn(`Vite dev server already running for '${collidingPlatform}' on port ${port}; skipping a second server for '${key}'. For simultaneous multi-platform HMR, set a distinct NS_HMR_PORT per platform.`);
+                return;
+            }
+            const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
+            const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+            const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
+            if (await this.shouldUsePreserveSymlinksOption()) {
+                additionalNodeArgs.push("--preserve-symlinks");
+            }
+            // `vite serve` (not `build`): runs the dev server and watches on
+            // its own — no `--watch`. Env flags (`--env.android --env.hmr …`)
+            // go after `--` so vite's CLI doesn't choke on unknown options.
+            const args = [
+                ...additionalNodeArgs,
+                this.getBundlerExecutablePath(projectData),
+                "serve",
+                `--config=${projectData.bundlerConfigPath}`,
+                `--mode=development`,
+                "--",
+                ...cliArgs,
+            ].filter(Boolean);
+            const options = {
+                cwd: projectData.projectDir,
+                // Inherit so the dev server's URLs/logs stream to the user as
+                // before. No IPC needed here — the build watcher provides the
+                // bundle-complete IPC; the dev server is fetched over HTTP/ws.
+                stdio: "inherit",
+                env: {
+                    ...process.env,
+                    NATIVESCRIPT_BUNDLER_ENV: JSON.stringify(envData),
+                },
+            };
+            if (this.$hostInfo.isWindows) {
+                Object.assign(options.env, { APPDATA: process.env.appData });
+            }
+            this.$logger.info(`Starting Vite dev server (HMR) for ${key} on port ${port}…`);
+            const childProcess = this.$childProcess.spawn(process.execPath, args, options);
+            this.viteServeProcesses[key] = childProcess;
+            await this.$cleanupService.addKillProcess(childProcess.pid.toString());
+            childProcess.once("exit", (code) => {
+                delete this.viteServeProcesses[key];
+                if (code) {
+                    this.$logger.warn(`Vite dev server for ${key} exited with code ${code}.`);
+                }
+            });
+            // Bounded readiness probe so we can surface a clear log once the
+            // device can actually reach modules.
+            const ready = await this.waitForPort(port, 30000);
+            if (ready) {
+                this.$logger.info(`Vite dev server ready on port ${port} (HMR for ${key}).`);
+            }
+            else {
+                this.$logger.trace(`Vite dev server port ${port} not observed open within the readiness probe window; continuing (it may bind shortly).`);
+            }
+        }
+        catch (err) {
+            this.$logger.warn(`Failed to start the Vite dev server: ${err}. HMR may be unavailable.`);
+        }
+    }
+    /**
+     * Resolve true once `127.0.0.1:<port>` accepts a TCP connection, or
+     * false after `timeoutMs`. Used to detect the Vite dev server is up.
+     */
+    waitForPort(port, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        return new Promise((resolve) => {
+            const attempt = () => {
+                const socket = net.connect({ port, host: "127.0.0.1" });
+                let settled = false;
+                const done = (ok) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    socket.destroy();
+                    if (ok) {
+                        resolve(true);
+                    }
+                    else if (Date.now() >= deadline) {
+                        resolve(false);
+                    }
+                    else {
+                        setTimeout(attempt, 250);
+                    }
+                };
+                socket.once("connect", () => done(true));
+                socket.once("error", () => done(false));
+                socket.setTimeout(1000, () => done(false));
+            };
+            attempt();
+        });
+    }
     buildEnvData(platform, projectData, prepareData) {
         var _a, _b, _c;
         const { env } = prepareData;
@@ -477,6 +625,13 @@ class BundlerCompilerService extends events_1.EventEmitter {
             bundlerProcess.kill("SIGINT");
             delete this.bundlerProcesses[platform];
         }
+        // Tear down the Vite dev server we manage alongside the build watcher.
+        const viteServeProcess = this.viteServeProcesses[platform];
+        if (viteServeProcess) {
+            await this.$cleanupService.removeKillProcess(viteServeProcess.pid.toString());
+            viteServeProcess.kill("SIGINT");
+            delete this.viteServeProcesses[platform];
+        }
     }
     handleHMRMessage(message, platformData, projectData, prepareData) {
         // handle new bundler hmr packets

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "main": "./lib/nativescript-cli-lib.js",
-  "version": "9.1.0-alpha.3",
+  "version": "9.1.0-alpha.5",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {