fix: popup is shown when searching for iOS Simulators

When Xcode Command Line tools are not installed, calling `xcrun` leads to a popup with suggestion to install Xcode Command Line Tools. Prevent this by checking if Xcode is installed and if not - do not spawn `xcrun`.
Fix incorrect interfaces and remove unused method.

Author: rosen-vladimirov

lib/child-process.ts

@@ -1,8 +1,8 @@
 import * as child_process from "child_process";
 
-export function execSync(command: string, opts?: any): any {
+export function execSync(command: string, execSyncOptions?: child_process.ExecSyncOptions, opts?: ISkipErrorComposition): any {
 	try {
-		return child_process.execSync(command, opts);
+		return child_process.execSync(command, execSyncOptions);
 	} catch (err) {
 		if (opts && opts.skipError) {
 			return err;
@@ -12,9 +12,9 @@ export function execSync(command: string, opts?: any): any {
 	}
 }
 
-export function spawnSync(command: string, args: string[], opts?: any): any {
+export function spawnSync(command: string, args: string[], spawnSyncOpts?: child_process.SpawnSyncOptions, opts?: ISkipErrorComposition): any {
 	try {
-		return child_process.spawnSync(command, args, opts);
+		return child_process.spawnSync(command, args, spawnSyncOpts);
 	} catch (err) {
 		if (opts && opts.skipError) {
 			return err;
@@ -24,12 +24,12 @@ export function spawnSync(command: string, args: string[], opts?: any): any {
 	}
 }
 
-export function spawn(command: string, args: string[], opts?: any): Promise<string> {
+export function spawn(command: string, args: string[], spawnOpts?: child_process.SpawnOptions, opts?: ISkipErrorComposition): Promise<string> {
 	return new Promise<string>((resolve, reject) => {
 		let capturedOut = "";
 		let capturedErr = "";
 
-		let childProcess = child_process.spawn(command, args);
+		let childProcess = child_process.spawn(command, args, spawnOpts);
 
 		if (childProcess.stdout) {
 			childProcess.stdout.on("data", (data: string) => {
@@ -60,4 +60,4 @@ export function spawn(command: string, args: string[], opts?: any): Promise<stri
 			reject(err);
 		});
 	});
-}
+}

lib/declarations.ts

@@ -26,12 +26,16 @@ interface IDevice {
 	rawDevice?: any; // NodObjC wrapper to device
 }
 
+interface ISkipErrorComposition {
+	skipError: boolean;
+}
+
 interface ISimctl {
 	launch(deviceId: string, applicationIdentifier: string, options: IOptions): Promise<string>;
 	boot(deviceId: string): Promise<void>;
 	terminate(deviceId: string, appIdentifier: string): Promise<string>;
 	install(deviceId: string, applicationPath: string): Promise<void>;
-	uninstall(deviceId: string, applicationIdentifier: string, opts?: any): Promise<void>;
+	uninstall(deviceId: string, applicationIdentifier: string, opts?: ISkipErrorComposition): Promise<void>;
 	notifyPost(deviceId: string, notification: string): Promise<void>;
 	getDevices(): Promise<IDevice[]>;
 	getLog(deviceId: string, predicate?: string): any;

lib/iphone-simulator-xcode-simctl.ts

@@ -97,7 +97,7 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		try {
 			let pid = this.getPid(deviceId, bundleExecutable);
 			while (pid) {
-				childProcess.execSync(`kill -9 ${pid}`, { skipError: true });
+				childProcess.execSync(`kill -9 ${pid}`, null, { skipError: true });
 				pid = this.getPid(deviceId, bundleExecutable);
 				if (pid) {
 					utils.sleep(0.1);
@@ -117,7 +117,7 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		// The process, that is execed by Node.js is also returned, so we need to exclude it from the result.
 		// To achieve this, remove the command we've executed from the ps result.
 		const grepAppProcessCommand = `ps -ef | grep ${bundleExecutable} | grep \/${deviceId}\/`;
-		return childProcess.execSync(`${grepAppProcessCommand} | grep -v "${grepAppProcessCommand}" | awk '{print $2}'`, { skipError: true }).toString().trim();
+		return childProcess.execSync(`${grepAppProcessCommand} | grep -v "${grepAppProcessCommand}" | awk '{print $2}'`, null, { skipError: true }).toString().trim();
 }
 
 	public async getDeviceLogProcess(deviceId: string, predicate?: string): Promise<child_process.ChildProcess> {

lib/simctl.ts

@@ -33,15 +33,15 @@ export class Simctl implements ISimctl {
 		return this.spawnAsync("boot", [deviceId]);
 	}
 
-	public terminate(deviceId: string, appIdentifier: string):  Promise<string> {
+	public terminate(deviceId: string, appIdentifier: string): Promise<string> {
 		return this.spawnAsync("terminate", [deviceId, appIdentifier]);
 	}
 
-	public install(deviceId: string, applicationPath: string):  Promise<void> {
+	public install(deviceId: string, applicationPath: string): Promise<void> {
 		return this.spawnAsync("install", [deviceId, applicationPath]);
 	}
 
-	public uninstall(deviceId: string, appIdentifier: string, opts?: any):  Promise<void> {
+	public uninstall(deviceId: string, appIdentifier: string, opts?: any): Promise<void> {
 		return this.spawnAsync("uninstall", [deviceId, appIdentifier], opts);
 	}
 
@@ -138,31 +138,37 @@ export class Simctl implements ISimctl {
 		return this.simctlSpawn("spawn", [deviceId, "log", "stream", "--style", "syslog"].concat(predicateArgs));
 	}
 
-	private simctlExec(command: string, args: string[], opts?: any): string {
-		const result = childProcess.spawnSync("xcrun", ["simctl", command].concat(args), opts);
-		if (result && result.stderr && !_.isEmpty(result.stderr)) {
-            		throw new Error(`Error while executing command '${["xcrun", "simctl", command].concat(args).join(" ")}'. Please ensure your tools are configured correctly. More info: ${result.stderr.toString()}`);
-        	}
-		if (result) {
-			if (result.signal) {
-				// In some cases, sending Ctrl + C (SIGINT) is handled by the simctl itself and spawnSync finishes, but the SIGINT does not stop current process.
-				// In order to ensure the same signal is sent to the caller (CLI for example), send the signal manually:
-				process.send(result.signal);
-			}
-
-			if (result.stdout) {
-				return result.stdout.toString().trim();
+	private async spawnAsync(command: string, args: string[], spawnOpts?: child_process.SpawnOptions, opts?: ISkipErrorComposition): Promise<any> {
+		const { canExecuteXcrun, xcodeToolsError } = this.verifyXcodeCommandLineToolsAreInstalled();
+		if (!canExecuteXcrun) {
+			if (opts.skipError) {
+				return null;
+			} else {
+				throw xcodeToolsError;
 			}
 		}
 
-		return '';
+		return childProcess.spawn("xcrun", ["simctl", command].concat(args), spawnOpts, opts);
 	}
 
-	private simctlSpawn(command: string, args: string[], opts?: child_process.SpawnOptions): child_process.ChildProcess {
-		return child_process.spawn("xcrun", ["simctl", command].concat(args), opts);
+	private verifyXcodeCommandLineToolsAreInstalled(): { canExecuteXcrun: boolean, xcodeToolsError: Error } {
+		let canExecuteXcrun = false;
+		let xcodeToolsError: Error = null;
+
+		try {
+			const result = childProcess.execSync("xcode-select -p", { stdio: "pipe" });
+			canExecuteXcrun = !!(result && result.toString().trim());
+			if (!canExecuteXcrun) {
+				xcodeToolsError = new Error("Unable to work with iOS Simulator as Xcode Command Line Tools cannot be found.");
+			}
+		} catch (err) {
+			xcodeToolsError = err
+		}
+
+		return { canExecuteXcrun, xcodeToolsError };
 	}
 
-	private spawnAsync(command: string, args: string[], opts?: child_process.SpawnOptions): Promise<any> {
-		return childProcess.spawn("xcrun", ["simctl", command].concat(args), opts);
+	private simctlSpawn(command: string, args: string[], spawnOpts?: child_process.SpawnOptions): child_process.ChildProcess {
+		return child_process.spawn("xcrun", ["simctl", command].concat(args), spawnOpts);
 	}
 }