fix(ios): verify livesync payload delivery on physical devices and stop swallowing upload errors

On physical iOS devices a full sync transfers the app as a single
sync.zip over AFC (house_arrest) which the runtime's TKLiveSync
extracts at next boot. When that delivery failed, nothing noticed:
upload errors whose deviceId didn't exactly match the target device
(including errors with no deviceId at all) were silently dropped,
there was no post-transfer verification, and "Successfully synced"
printed regardless — leaving the app running the stale JavaScript
baked into the installed .app payload with no indication anywhere.

- After transferring sync.zip, list the LiveSync directory on the
  device and confirm the zip actually landed; retry the transfer once,
  then fail the sync loudly (with a --clean remediation hint) instead
  of reporting success over stale code. Note: the listing targets the
  LiveSync ROOT — getDeviceProjectRootPath() returns .../LiveSync/app,
  one level below where the zip is uploaded.
- uploadFilesCore now rethrows unattributed upload errors and logs
  errors attributed to other devices instead of ignoring them.
- New optional IDeviceFileSystem.getDirectoryEntries(), implemented
  for physical iOS devices (AFC), backs the verification.

Author: NathanWalker

lib/common/definitions/mobile.d.ts

@@ -258,8 +258,7 @@ declare global {
 		 * Describes different options for filtering device logs.
 		 */
 		interface IDeviceLogOptions
-			extends IDictionary<string | boolean>,
-				Partial<IProjectDir> {
+			extends IDictionary<string | boolean>, Partial<IProjectDir> {
 			/**
 			 * Process id of the application on the device.
 			 */
@@ -284,8 +283,7 @@ declare global {
 		 * Describes required methods for getting iOS Simulator's logs.
 		 */
 		interface IiOSSimulatorLogProvider
-			extends NodeJS.EventEmitter,
-				IShouldDispose {
+			extends NodeJS.EventEmitter, IShouldDispose {
 			/**
 			 * Starts the process for getting simulator logs and emits and DEVICE_LOG_EVENT_NAME event.
 			 * @param {string} deviceId The unique identifier of the device.
@@ -429,6 +427,16 @@ declare global {
 
 		interface IDeviceFileSystem {
 			listFiles(devicePath: string, appIdentifier?: string): Promise<any>;
+			/**
+			 * Returns the entries of a directory inside the application's
+			 * sandbox, or null when the directory cannot be read. Currently
+			 * implemented only for physical iOS devices (AFC), where it backs
+			 * the post-transfer livesync verification.
+			 */
+			getDirectoryEntries?(
+				devicePath: string,
+				appIdentifier: string,
+			): Promise<string[] | null>;
 			getFile(
 				deviceFilePath: string,
 				appIdentifier: string,
@@ -533,8 +541,7 @@ declare global {
 		/**
 		 * Describes options that can be passed to devices service's initialization method.
 		 */
-		interface IDevicesServicesInitializationOptions
-			extends Partial<IDeviceLookingOptions> {
+		interface IDevicesServicesInitializationOptions extends Partial<IDeviceLookingOptions> {
 			/**
 			 * If passed will start an emulator if necesasry.
 			 */
@@ -1261,8 +1268,7 @@ declare global {
 		}
 
 		interface IDeviceLookingOptions
-			extends IHasEmulatorOption,
-				IHasDetectionInterval {
+			extends IHasEmulatorOption, IHasDetectionInterval {
 			shouldReturnImmediateResult: boolean;
 			platform: string;
 			fullDiscovery?: boolean;
@@ -1388,8 +1394,7 @@ declare global {
 		/**
 		 * Describes information about application on device.
 		 */
-		interface IDeviceApplicationInformation
-			extends IDeviceApplicationInformationBase {
+		interface IDeviceApplicationInformation extends IDeviceApplicationInformationBase {
 			/**
 			 * The framework of the project (Cordova or NativeScript).
 			 */

lib/common/mobile/ios/device/ios-device-file-system.ts

@@ -9,12 +9,12 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 		private device: Mobile.IDevice,
 		private $logger: ILogger,
 		private $iosDeviceOperations: IIOSDeviceOperations,
-		private $fs: IFileSystem
+		private $fs: IFileSystem,
 	) {}
 
 	public async listFiles(
 		devicePath: string,
-		appIdentifier: string
+		appIdentifier: string,
 	): Promise<void> {
 		if (!devicePath) {
 			devicePath = ".";
@@ -31,10 +31,33 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 		this.$logger.info(children.join(EOL));
 	}
 
+	public async getDirectoryEntries(
+		devicePath: string,
+		appIdentifier: string,
+	): Promise<string[] | null> {
+		try {
+			const result = await this.$iosDeviceOperations.listDirectory([
+				{
+					deviceId: this.device.deviceInfo.identifier,
+					path: devicePath,
+					appId: appIdentifier,
+				},
+			]);
+			const entries =
+				result?.[this.device.deviceInfo.identifier]?.[0]?.response;
+			return Array.isArray(entries) ? entries : null;
+		} catch (err) {
+			this.$logger.trace(
+				`Unable to list directory '${devicePath}' for application ${appIdentifier}: ${err.message}`,
+			);
+			return null;
+		}
+	}
+
 	public async getFile(
 		deviceFilePath: string,
 		appIdentifier: string,
-		outputFilePath?: string
+		outputFilePath?: string,
 	): Promise<void> {
 		if (outputFilePath) {
 			await this.$iosDeviceOperations.downloadFiles([
@@ -50,14 +73,14 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 
 		const fileContent = await this.getFileContent(
 			deviceFilePath,
-			appIdentifier
+			appIdentifier,
 		);
 		this.$logger.info(fileContent);
 	}
 
 	public async getFileContent(
 		deviceFilePath: string,
-		appIdentifier: string
+		appIdentifier: string,
 	): Promise<string> {
 		const result = await this.$iosDeviceOperations.readFiles([
 			{
@@ -73,7 +96,7 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 	public async putFile(
 		localFilePath: string,
 		deviceFilePath: string,
-		appIdentifier: string
+		appIdentifier: string,
 	): Promise<void> {
 		await this.uploadFilesCore([
 			{
@@ -86,7 +109,7 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 
 	public async deleteFile(
 		deviceFilePath: string,
-		appIdentifier: string
+		appIdentifier: string,
 	): Promise<void> {
 		await this.$iosDeviceOperations.deleteFiles(
 			[
@@ -98,25 +121,25 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 			],
 			(err: IOSDeviceLib.IDeviceError) => {
 				this.$logger.trace(
-					`Error while deleting file: ${deviceFilePath}: ${err.message} with code: ${err.code}`
+					`Error while deleting file: ${deviceFilePath}: ${err.message} with code: ${err.code}`,
 				);
 
 				if (err.code !== IOSDeviceFileSystem.AFC_DELETE_FILE_NOT_FOUND_ERROR) {
 					this.$logger.warn(
-						`Cannot delete file: ${deviceFilePath}. Reason: ${err.message}`
+						`Cannot delete file: ${deviceFilePath}. Reason: ${err.message}`,
 					);
 				}
-			}
+			},
 		);
 	}
 
 	public async transferFiles(
 		deviceAppData: Mobile.IDeviceAppData,
-		localToDevicePaths: Mobile.ILocalToDevicePathData[]
+		localToDevicePaths: Mobile.ILocalToDevicePathData[],
 	): Promise<Mobile.ILocalToDevicePathData[]> {
 		const filesToUpload: Mobile.ILocalToDevicePathData[] = _.filter(
 			localToDevicePaths,
-			(l) => this.$fs.getFsStats(l.getLocalPath()).isFile()
+			(l) => this.$fs.getFsStats(l.getLocalPath()).isFile(),
 		);
 		const files: IOSDeviceLib.IFileData[] = filesToUpload.map((l) => ({
 			source: l.getLocalPath(),
@@ -137,29 +160,43 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 	public async transferDirectory(
 		deviceAppData: Mobile.IDeviceAppData,
 		localToDevicePaths: Mobile.ILocalToDevicePathData[],
-		projectFilesPath: string
+		projectFilesPath: string,
 	): Promise<Mobile.ILocalToDevicePathData[]> {
 		await this.transferFiles(deviceAppData, localToDevicePaths);
 		return localToDevicePaths;
 	}
 
 	public async updateHashesOnDevice(
 		hashes: IStringDictionary,
-		appIdentifier: string
+		appIdentifier: string,
 	): Promise<void> {
 		return;
 	}
 
 	private async uploadFilesCore(
-		filesToUpload: IOSDeviceLib.IUploadFilesData[]
+		filesToUpload: IOSDeviceLib.IUploadFilesData[],
 	): Promise<void> {
 		await this.$iosDeviceOperations.uploadFiles(
 			filesToUpload,
 			(err: IOSDeviceLib.IDeviceError) => {
-				if (err.deviceId === this.device.deviceInfo.identifier) {
+				// Previously an error whose deviceId did not exactly match was
+				// dropped on the floor — including errors with NO deviceId at
+				// all (some ios-device-lib error paths don't attribute one).
+				// That left "Successfully synced" printed over a failed
+				// transfer and the app silently running stale JavaScript.
+				// Rethrow unless the error is positively attributed to a
+				// DIFFERENT device; surface even those at warn level so a
+				// failed upload is never invisible.
+				if (
+					!err.deviceId ||
+					err.deviceId === this.device.deviceInfo.identifier
+				) {
 					throw err;
 				}
-			}
+				this.$logger.warn(
+					`File upload error reported for another device (${err.deviceId}): ${err.message}`,
+				);
+			},
 		);
 	}
 }