feat(cli): delegate to a project-local nativescript install

Invoking the (typically global) CLI inside a project that carries its
own nativescript install now hands off to that copy - the project pins
the version that actually runs, Angular/Nx style. The probe resolves
nativescript/package.json from cwd, realpath-compares against the
invoked copy so npm-linked installs are not mistaken for a different
one, and any probe failure falls through to the invoked copy. The
notice goes to stderr so scripts parsing stdout are unaffected.

Opt out per invocation with --no-local-cli (stripped before option
parsing) or NS_CLI_NO_LOCAL=1; NS_CLI_LOCAL_DELEGATED marks the
handed-off process so a local copy never delegates again.

Author: edusperoni

bin/tns

@@ -14,6 +14,63 @@ var path = require("path"),
 
 require(path.join(pathToCommon, "verify-node-version")).verifyNodeVersion();
 
+// Prefer a project-local CLI install when one is resolvable from the current
+// directory: the project pins its own nativescript version, and running the
+// invoked (typically global) copy against it means two CLI versions
+// disagreeing about one project. The probe must never break the CLI - any
+// failure falls through to the invoked copy. Opt out per invocation with
+// --no-local-cli or NS_CLI_NO_LOCAL=1; NS_CLI_LOCAL_DELEGATED marks the
+// handed-off process so the local copy never delegates again.
+var noLocalFlagIndex = process.argv.indexOf("--no-local-cli");
+if (noLocalFlagIndex !== -1) {
+	process.argv.splice(noLocalFlagIndex, 1);
+}
+
+if (
+	!process.env.NS_CLI_LOCAL_DELEGATED &&
+	!process.env.NS_CLI_NO_LOCAL &&
+	noLocalFlagIndex === -1
+) {
+	var localEntry = null;
+	var localVersion = null;
+	var localDir = null;
+	try {
+		var localPackageJsonPath = require.resolve("nativescript/package.json", {
+			paths: [process.cwd()],
+		});
+		var ownPackageJsonPath = path.join(__dirname, "..", "package.json");
+		// realpath both sides so an npm-linked or symlinked install of the
+		// same copy is not mistaken for a different one.
+		if (
+			fs.realpathSync(localPackageJsonPath) !==
+			fs.realpathSync(ownPackageJsonPath)
+		) {
+			localDir = path.dirname(localPackageJsonPath);
+			var candidate = path.join(localDir, "bin", "tns");
+			if (fs.existsSync(candidate)) {
+				localEntry = candidate;
+				localVersion = require(localPackageJsonPath).version;
+			}
+		}
+	} catch (err) {
+		// No local install resolvable from cwd - run the invoked copy.
+	}
+
+	if (localEntry) {
+		process.env.NS_CLI_LOCAL_DELEGATED = "1";
+		// stderr, so scripts parsing stdout (e.g. `ns --version`) are unaffected.
+		console.error(
+			"Using the project-local nativescript@" +
+				localVersion +
+				" (" +
+				localDir +
+				").",
+		);
+		require(localEntry);
+		return;
+	}
+}
+
 var pathToCliExecutable = path.join(pathToLib, "nativescript-cli.js");
 
 require(pathToCliExecutable);

test/local-cli-delegation.ts

@@ -0,0 +1,130 @@
+import { assert } from "chai";
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+// Drives the real bin entry in a child process: delegation must happen before
+// any of lib/ loads, so it can only be observed from the outside.
+const repoRoot = path.join(__dirname, "..", "..");
+const cliEntry = path.join(repoRoot, "bin", "nativescript.js");
+const ownVersion = JSON.parse(
+	fs.readFileSync(path.join(repoRoot, "package.json")).toString(),
+).version;
+
+const LOCAL_MARKER = "LOCAL_CLI_RAN";
+
+describe("project-local CLI delegation", () => {
+	let projectDir: string;
+
+	const makeProject = (options?: {
+		localCli?: boolean;
+		symlinkToOwnCopy?: boolean;
+	}): void => {
+		projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "ns-localcli-"));
+		fs.writeFileSync(
+			path.join(projectDir, "package.json"),
+			JSON.stringify({ name: "test-app", version: "1.0.0" }),
+		);
+
+		if (options && options.symlinkToOwnCopy) {
+			fs.mkdirSync(path.join(projectDir, "node_modules"), { recursive: true });
+			fs.symlinkSync(
+				repoRoot,
+				path.join(projectDir, "node_modules", "nativescript"),
+				"junction",
+			);
+			return;
+		}
+
+		if (options && options.localCli) {
+			const packageDir = path.join(projectDir, "node_modules", "nativescript");
+			fs.mkdirSync(path.join(packageDir, "bin"), { recursive: true });
+			fs.writeFileSync(
+				path.join(packageDir, "package.json"),
+				JSON.stringify({ name: "nativescript", version: "99.0.0-local" }),
+			);
+			fs.writeFileSync(
+				path.join(packageDir, "bin", "tns"),
+				`console.log("${LOCAL_MARKER} delegated=" + process.env.NS_CLI_LOCAL_DELEGATED);`,
+			);
+		}
+	};
+
+	afterEach(() => {
+		fs.rmSync(projectDir, { recursive: true, force: true });
+	});
+
+	const runCli = (
+		args: string[] = ["--version"],
+		envOverrides: { [key: string]: string } = {},
+	) => {
+		const env: any = { ...process.env, ...envOverrides };
+		delete env.NS_CLI_LOCAL_DELEGATED;
+		delete env.NS_CLI_NO_LOCAL;
+		for (const key of Object.keys(envOverrides)) {
+			env[key] = envOverrides[key];
+		}
+		return spawnSync(process.execPath, [cliEntry, ...args], {
+			cwd: projectDir,
+			encoding: "utf8",
+			env,
+		});
+	};
+
+	it("hands off to a project-local install, marking the delegated process", () => {
+		makeProject({ localCli: true });
+
+		const result = runCli();
+
+		assert.include(result.stdout, `${LOCAL_MARKER} delegated=1`);
+		assert.include(result.stderr, "project-local nativescript@99.0.0-local");
+		assert.notInclude(result.stdout, ownVersion);
+	});
+
+	it("runs the invoked copy when the project has no local install", () => {
+		makeProject();
+
+		const result = runCli();
+
+		assert.include(result.stdout, ownVersion);
+		assert.notInclude(result.stdout, LOCAL_MARKER);
+		assert.notInclude(result.stderr, "project-local");
+	});
+
+	it("does not delegate to a symlink of the same copy (npm link)", () => {
+		makeProject({ symlinkToOwnCopy: true });
+
+		const result = runCli();
+
+		assert.include(result.stdout, ownVersion);
+		assert.notInclude(result.stderr, "project-local");
+	});
+
+	it("--no-local-cli opts out and is stripped before option parsing", () => {
+		makeProject({ localCli: true });
+
+		const result = runCli(["--version", "--no-local-cli"]);
+
+		assert.include(result.stdout, ownVersion);
+		assert.notInclude(result.stdout, LOCAL_MARKER);
+	});
+
+	it("NS_CLI_NO_LOCAL opts out", () => {
+		makeProject({ localCli: true });
+
+		const result = runCli(["--version"], { NS_CLI_NO_LOCAL: "1" });
+
+		assert.include(result.stdout, ownVersion);
+		assert.notInclude(result.stdout, LOCAL_MARKER);
+	});
+
+	it("a delegated process never delegates again", () => {
+		makeProject({ localCli: true });
+
+		const result = runCli(["--version"], { NS_CLI_LOCAL_DELEGATED: "1" });
+
+		assert.include(result.stdout, ownVersion);
+		assert.notInclude(result.stdout, LOCAL_MARKER);
+	});
+});