chore(windows): polish

NativeScript · triniwiz · May 11, 2026 · May 12, 2026 · May 12, 2026 · May 14, 2026
commit 2fc8ca7d579946fe8ada00df7177d71a91aa655e
diff --git a/lib/common/mobile/windows/windows-application-manager.ts b/lib/common/mobile/windows/windows-application-manager.ts
@@ -1,12 +1,17 @@
 import * as fs from "fs";
 import * as path from "path";
+import { spawn } from "child_process";
 import { ApplicationManagerBase } from "../application-manager-base";
 import { IHooksService, IChildProcess, IDictionary } from "../../declarations";
 import { IBuildData } from "../../../definitions/build";
 
 export class WindowsApplicationManager extends ApplicationManagerBase {
-	private _runningPid: number = null;
-	private _packageFamilyName: string = null;
+	private _runningPid: number | null = null;
+	// Keyed by appId so multiple UWP apps don't stomp each other's cached PFN.
+	private _packageFamilyNames: Map<string, string> = new Map();
+	// Populated by installApplication for .exe builds; keyed by both appIdentifier
+	// and exe-basename so the two lookup paths in startApplication both work.
+	private _installedExePaths: IDictionary<string> = {};
 
 	constructor(
 		$logger: ILogger,
@@ -39,12 +44,43 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 		}
 	}
 
+	// The base class checks getInstalledApplications(), which only knows about UWP
+	// packages. Override so that EXE-based apps registered via installApplication()
+	// are also considered "installed" without a PowerShell round-trip.
+	public async isApplicationInstalled(appIdentifier: string): Promise<boolean> {
+		if (
+			appIdentifier &&
+			Object.prototype.hasOwnProperty.call(
+				this._installedExePaths,
+				appIdentifier,
+			)
+		) {
+			return true;
+		}
+		return super.isApplicationInstalled(appIdentifier);
+	}
+
 	public async installApplication(
 		packageFilePath: string,
 		appIdentifier?: string,
 		_buildData?: IBuildData,
 	): Promise<void> {
-		this.$logger.info(`[Windows] Installing from: ${packageFilePath}`);
+		if (packageFilePath?.toLowerCase().endsWith(".exe")) {
+			this.$logger.info(`[Windows] Registering EXE: ${packageFilePath}`);
+			const exeBase = path.basename(
+				packageFilePath,
+				path.extname(packageFilePath),
+			);
+			if (appIdentifier) {
+				this._installedExePaths[appIdentifier] = packageFilePath;
+			}
+			// Secondary key so the projectName-based lookup in startApplication works
+			// even when appIdentifier differs from the exe filename.
+			this._installedExePaths[exeBase] = packageFilePath;
+			return;
+		}
+
+		this.$logger.info(`[Windows] Installing MSIX/APPX from: ${packageFilePath}`);
 		await this.$childProcess.spawnFromEvent(
 			"powershell.exe",
 			[
@@ -58,13 +94,17 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 			{},
 			{ throwError: true },
 		);
-		// Cache the PFN immediately after install so startApplication can use it.
+		// Pre-warm the PFN cache so startApplication does not need to resolve it.
 		if (appIdentifier) {
 			await this._resolvePackageFamilyName(appIdentifier);
 		}
 	}
 
 	public async uninstallApplication(appIdentifier: string): Promise<void> {
+		// Clean up EXE registration so isApplicationInstalled returns false.
+		delete this._installedExePaths[appIdentifier];
+		this._packageFamilyNames.delete(appIdentifier);
+
 		await this.$childProcess.spawnFromEvent(
 			"powershell.exe",
 			[
@@ -76,78 +116,65 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 			{},
 			{ throwError: false },
 		);
-		this._packageFamilyName = null;
+	}
+
+	// Explicit override matching the interface contract (IStartApplicationData)
+	// rather than relying on the base-class forwarding appData typed as the
+	// narrower IApplicationData, which would silently drop waitForDebugger.
+	public async restartApplication(
+		appData: Mobile.IStartApplicationData,
+	): Promise<void> {
+		await this.stopApplication(appData);
+		await this.startApplication(appData);
 	}
 
 	public async startApplication(
 		appData: Mobile.IStartApplicationData,
 	): Promise<void> {
-		const pfn = await this._resolvePackageFamilyName(appData.appId);
+		const exeCandidate =
+			(appData.appId && this._installedExePaths[appData.appId]) ||
+			(appData.projectName && this._installedExePaths[appData.projectName]);
+
+		if (exeCandidate && fs.existsSync(exeCandidate)) {
+			if (appData.waitForDebugger) {
+				this.$logger.info(
+					`[Windows] --debug-brk is not supported for EXE targets.`,
+				);
+			}
+			this.$logger.info(`[Windows] Launching EXE: ${exeCandidate}`);
+			const proc = spawn(exeCandidate, [], { detached: true, stdio: "ignore" });
+			proc.unref();
+			this._runningPid = proc.pid ?? null;
+			// Clear stale PID when the process exits so stopApplication falls back to
+			// the Stop-Process path on the next restart instead of killing a reused PID.
+			proc.on("exit", () => {
+				if (this._runningPid === proc.pid) {
+					this._runningPid = null;
+				}
+			});
+			return;
+		}
 
-		// Mirror the Android sentinel-file pattern: write ns-debugbreak to the
-		// app's LocalFolder before launch so the runtime knows to open DevTools.
+		const pfn = await this._resolvePackageFamilyName(appData.appId);
 		if (appData.waitForDebugger) {
 			this._writeDebugBreakMarker(pfn);
 		}
-
-		this.$logger.info(`[Windows] Launching: ${pfn}`);
-		const proc = require("child_process").spawn(
-			"explorer.exe",
-			[`ms-windows-app://${pfn}`],
-			{ detached: true, stdio: "ignore" },
-		);
+		this.$logger.info(`[Windows] Launching UWP: ${pfn}`);
+		const proc = spawn("explorer.exe", [`ms-windows-app://${pfn}`], {
+			detached: true,
+			stdio: "ignore",
+		});
 		proc.unref();
 	}
 
-	private async _resolvePackageFamilyName(appId: string): Promise<string> {
-		if (this._packageFamilyName) return this._packageFamilyName;
-		try {
-			const result = await this.$childProcess.spawnFromEvent(
-				"powershell.exe",
-				[
-					"-NoProfile",
-					"-Command",
-					`(Get-AppxPackage | Where-Object { $_.Name -eq "${appId}" -or $_.PackageFullName -like "*${appId}*" } | Select-Object -First 1).PackageFamilyName`,
-				],
-				"close",
-				{},
-				{ throwError: false },
-			);
-			const pfn = (result.stdout || "").trim();
-			if (pfn) this._packageFamilyName = pfn;
-		} catch {
-			/* ignore, fall back to appId */
-		}
-		return this._packageFamilyName ?? appId;
-	}
-
-	private _writeDebugBreakMarker(pfn: string): void {
-		const localAppData = process.env.LOCALAPPDATA;
-		if (!localAppData) return;
-		const markerPath = path.join(
-			localAppData,
-			"Packages",
-			pfn,
-			"LocalState",
-			"ns-debugbreak",
-		);
-		try {
-			fs.mkdirSync(path.dirname(markerPath), { recursive: true });
-			fs.writeFileSync(markerPath, "", "utf8");
-			this.$logger.info(`[Windows] Debug break marker: ${markerPath}`);
-		} catch (e) {
-			this.$logger.warn(`[Windows] Could not write debug break marker: ${e}`);
-		}
-	}
-
 	public async stopApplication(
 		appData: Mobile.IApplicationData,
 	): Promise<void> {
 		if (this._runningPid) {
 			try {
 				process.kill(this._runningPid);
 			} catch {
-				/* already dead */
+				/* already gone */
 			}
 			this._runningPid = null;
 		} else {
@@ -186,4 +213,49 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 	): Promise<IDictionary<Mobile.IDebugWebViewInfo[]>> {
 		return {} as IDictionary<Mobile.IDebugWebViewInfo[]>;
 	}
+
+	private async _resolvePackageFamilyName(appId: string): Promise<string> {
+		const cached = this._packageFamilyNames.get(appId);
+		if (cached) return cached;
+
+		try {
+			const result = await this.$childProcess.spawnFromEvent(
+				"powershell.exe",
+				[
+					"-NoProfile",
+					"-Command",
+					`(Get-AppxPackage | Where-Object { $_.Name -eq "${appId}" -or $_.PackageFullName -like "*${appId}*" } | Select-Object -First 1).PackageFamilyName`,
+				],
+				"close",
+				{},
+				{ throwError: false },
+			);
+			const pfn = (result.stdout || "").trim();
+			if (pfn) {
+				this._packageFamilyNames.set(appId, pfn);
+			}
+		} catch {
+			/* fall back to appId as the protocol target */
+		}
+		return this._packageFamilyNames.get(appId) ?? appId;
+	}
+
+	private _writeDebugBreakMarker(pfn: string): void {
+		const localAppData = process.env.LOCALAPPDATA;
+		if (!localAppData) return;
+		const markerPath = path.join(
+			localAppData,
+			"Packages",
+			pfn,
+			"LocalState",
+			"ns-debugbreak",
+		);
+		try {
+			fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+			fs.writeFileSync(markerPath, "", "utf8");
+			this.$logger.info(`[Windows] Debug break marker: ${markerPath}`);
+		} catch (e) {
+			this.$logger.warn(`[Windows] Could not write debug break marker: ${e}`);
+		}
+	}
 }
diff --git a/lib/services/livesync/windows-device-livesync-service.ts b/lib/services/livesync/windows-device-livesync-service.ts
@@ -1,3 +1,4 @@
+import * as fs from "fs";
 import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
 import { IPlatformsDataService } from "../../definitions/platform";
 import { IProjectData } from "../../definitions/project";
@@ -18,10 +19,19 @@ export class WindowsDeviceLiveSyncService
 		projectData: IProjectData,
 		_liveSyncInfo: ILiveSyncResultInfo,
 	): Promise<void> {
-		// TODO: kill the running Windows app process and relaunch it
 		this.$logger.info(
-			`[Windows LiveSync] Restart required for ${projectData.projectName}`,
+			`[Windows LiveSync] Restarting application ${projectData.projectName}`,
 		);
+
+		const appId =
+			projectData.projectIdentifiers?.["windows"] ?? projectData.projectId;
+
+		await this.device.applicationManager.restartApplication({
+			appId,
+			projectName: projectData.projectName,
+			projectDir: projectData.projectDir,
+			waitForDebugger: _liveSyncInfo?.waitForDebugger,
+		} as Mobile.IStartApplicationData);
 	}
 
 	public async shouldRestart(
@@ -45,8 +55,8 @@ export class WindowsDeviceLiveSyncService
 	): Promise<void> {
 		for (const localToDevicePathData of localToDevicePaths) {
 			const devicePath = localToDevicePathData.getDevicePath();
-			if (require("fs").existsSync(devicePath)) {
-				require("fs").unlinkSync(devicePath);
+			if (fs.existsSync(devicePath)) {
+				fs.unlinkSync(devicePath);
 			}
 		}
 	}
-	public async removeFiles(
-		_deviceAppData: Mobile.IDeviceAppData,
-		localToDevicePaths: Mobile.ILocalToDevicePathData[],
-	): Promise<void> {
-		for (const localToDevicePathData of localToDevicePaths) {
-			const devicePath = localToDevicePathData.getDevicePath();
-			if (fs.existsSync(devicePath)) {
-				fs.unlinkSync(devicePath);
-			}
-		}
-	}
+	public async removeFiles(
+		_deviceAppData: Mobile.IDeviceAppData,
+		localToDevicePaths: Mobile.ILocalToDevicePathData[],
+	): Promise<void> {
+		for (const localToDevicePathData of localToDevicePaths) {
+			const devicePath = localToDevicePathData.getDevicePath();
+			try {
+				if (fs.existsSync(devicePath)) {
+					fs.unlinkSync(devicePath);
+				}
+			} catch (err) {
+				this.$logger.trace(
+					`[Windows LiveSync] Failed to remove ${devicePath}: ${err}`,
+				);
+			}
+		}
+	}
-	public async removeFiles(
-		_deviceAppData: Mobile.IDeviceAppData,
-		localToDevicePaths: Mobile.ILocalToDevicePathData[],
-	): Promise<void> {
-		for (const localToDevicePathData of localToDevicePaths) {
-			const devicePath = localToDevicePathData.getDevicePath();
-			if (fs.existsSync(devicePath)) {
-				fs.unlinkSync(devicePath);
-			}
-		}
-	}
+	public async removeFiles(
+		_deviceAppData: Mobile.IDeviceAppData,
+		localToDevicePaths: Mobile.ILocalToDevicePathData[],
+	): Promise<void> {
+		for (const localToDevicePathData of localToDevicePaths) {
+			const devicePath = localToDevicePathData.getDevicePath();
+			try {
+				if (fs.existsSync(devicePath)) {
+					fs.unlinkSync(devicePath);
+				}
+			} catch (err) {
+				this.$logger.trace(
+					`[Windows LiveSync] Failed to remove ${devicePath}: ${err}`,
+				);
+			}
+		}
+	}

diff --git a/lib/services/windows-project-service.ts b/lib/services/windows-project-service.ts
@@ -42,7 +42,7 @@ export class WindowsProjectService
 		super($fs, $projectDataService);
 	}
 
-	private _platformData: IPlatformData = null;
+	private _platformData: IPlatformData | null = null;
 
 	public getPlatformData(projectData: IProjectData): IPlatformData {
 		if (!projectData && !this._platformData) {
@@ -86,6 +86,7 @@ export class WindowsProjectService
 						packageNames: [
 							`${projectData.projectName}.msix`,
 							`${projectData.projectName}.appx`,
+							`${projectData.projectName}.exe`,
 						],
 					};
 				},
@@ -97,7 +98,7 @@ export class WindowsProjectService
 			};
 		}
 
-		return this._platformData;
+		return this._platformData as IPlatformData;
 	}
 
 	public async validateOptions(
@@ -434,12 +435,11 @@ export class WindowsProjectService
 	}
 
 	public async preparePluginNativeCode(
-		_pluginData: IPluginData,
-		_options?: any,
+		pluginData: IPluginData,
+		projectData: IProjectData,
 	): Promise<void> {
-		const pluginData = _pluginData;
-
-		// stage native files found under plugin's platforms/windows folder into the app's plugins dir
+		// Stage native files found under the plugin's platforms/windows folder into
+		// the app's plugins directory so the csproj can import them.
 		const platformFolder = path.join(
 			pluginData.fullPath,
 			"platforms",
@@ -452,13 +452,10 @@ export class WindowsProjectService
 				? fallbackFolder
 				: null;
 		if (!sourcesFolder) {
-			// Nothing to stage for this plugin
 			return;
 		}
 
-		const projectData = arguments.length >= 2 ? arguments[1] : null;
 		if (!projectData) {
-			// attempt to find a projectData by walking up (best-effort); otherwise skip
 			return;
 		}
 
@@ -471,15 +468,15 @@ export class WindowsProjectService
 		this.$fs.ensureDirectoryExists(pluginStageDir);
 
 		// recursively copy native files (exclude JS/TS/JSON)
-		const walk = (dir: string, out: string) => {
+		const walk = (dir: string) => {
 			const entries = fs.readdirSync(dir, { withFileTypes: true });
 			for (const e of entries) {
 				const src = path.join(dir, e.name);
 				const rel = path.relative(sourcesFolder, src);
 				const dest = path.join(pluginStageDir, rel);
 				if (e.isDirectory()) {
 					this.$fs.ensureDirectoryExists(dest);
-					walk(src, dest);
+					walk(src);
 				} else if (e.isFile()) {
 					const ext = path.extname(e.name).toLowerCase();
 					if (
@@ -496,7 +493,7 @@ export class WindowsProjectService
 			}
 		};
 
-		walk(sourcesFolder, pluginStageDir);
+		walk(sourcesFolder);
 
 		// copy provided plugin.props/targets if present in plugin root
 		const providedProps = path.join(pluginData.fullPath, "plugin.props");