nativescript 9.1.1-dev.1 → 9.1.2-dev.2026-09-24-36031892256

package/lib/commands/typings.js

@@ -28,6 +28,9 @@ class TypingsCommand {
         else if (this.$mobileHelper.isiOSPlatform(platform)) {
             result = await this.handleiOSTypings();
         }
+        else if (this.$mobileHelper.isWindowsPlatform(platform)) {
+            result = await this.handleWindowsTypings();
+        }
         let typingsFolder = "./typings";
         if (this.$options.copyTo) {
             this.$fs.copyFile(path.resolve(this.$projectData.projectDir, "typings"), this.$options.copyTo);
@@ -146,6 +149,58 @@ class TypingsCommand {
             path.resolve(this.$projectData.projectDir, "typings", "android"),
         ], "exit", { stdio: "inherit" });
     }
+    async handleWindowsTypings() {
+        if (!this.$hostInfo.isWindows) {
+            this.$logger.warn("Windows typings can only be generated on Windows.");
+            return false;
+        }
+        const outDir = path.resolve(this.$projectData.projectDir, "typings", "windows");
+        this.$fs.ensureDirectoryExists(outDir);
+        const toolsDir = path.resolve(this.$projectData.projectDir, "platforms", "windows", "tools");
+        const arch = process.arch === "arm64" ? "arm64" : "x64";
+        const resolveGenerator = () => [
+            path.join(toolsDir, `typings-generator-${arch}.exe`),
+            path.join(toolsDir, "typings-generator.exe"),
+        ].find((p) => this.$fs.exists(p));
+        let generatorPath = resolveGenerator();
+        if (!generatorPath) {
+            this.$logger.warn("No platforms folder found, preparing project now...");
+            await this.$childProcess.spawnFromEvent(this.$hostInfo.isWindows ? "ns.cmd" : "ns", ["prepare", "windows"], "exit", { stdio: "inherit", shell: this.$hostInfo.isWindows });
+            generatorPath = resolveGenerator();
+        }
+        if (!generatorPath) {
+            this.$logger.warn([
+                `Could not find the Windows typings generator under ${toolsDir}.`,
+                "Ensure @nativescript/windows is installed and the project has been prepared.",
+            ].join("\n"));
+            return false;
+        }
+        const asArray = (input) => {
+            if (!input) {
+                return [];
+            }
+            return typeof input === "string" ? [input] : input;
+        };
+        const generatorArgs = ["--out-dir", outDir];
+        if (this.$options.root) {
+            generatorArgs.push("--root", this.$options.root);
+        }
+        if (this.$options.roots) {
+            generatorArgs.push("--roots", this.$options.roots);
+        }
+        if (this.$options.input) {
+            generatorArgs.push("--input", this.$options.input);
+        }
+        for (const lib of asArray(this.$options.lib)) {
+            generatorArgs.push("--lib", lib);
+        }
+        if (this.$options.libs) {
+            generatorArgs.push("--libs", this.$options.libs);
+        }
+        await this.$childProcess.spawnFromEvent(generatorPath, generatorArgs, "exit", {
+            stdio: "inherit",
+        });
+    }
     async handleiOSTypings() {
         if (this.$options.filter !== undefined) {
             this.$logger.warn("--filter flag is not supported yet.");

package/lib/common/bootstrap.js

@@ -45,6 +45,7 @@ yok_1.injector.require("deviceDiscovery", "./mobile/mobile-core/device-discovery
 yok_1.injector.require("iOSDeviceDiscovery", "./mobile/mobile-core/ios-device-discovery");
 yok_1.injector.require("iOSSimulatorDiscovery", "./mobile/mobile-core/ios-simulator-discovery");
 yok_1.injector.require("androidDeviceDiscovery", "./mobile/mobile-core/android-device-discovery");
+yok_1.injector.require("windowsDeviceDiscovery", "./mobile/windows/windows-device-discovery");
 yok_1.injector.require("androidEmulatorDiscovery", "./mobile/mobile-core/android-emulator-discovery");
 yok_1.injector.require("iOSDevice", "./mobile/ios/device/ios-device");
 yok_1.injector.require("iOSDeviceProductNameMapper", "./mobile/ios/ios-device-product-name-mapper");

package/lib/common/commands/doctor.d.ts

@@ -21,3 +21,10 @@ export declare class DoctorAndroidCommand implements ICommand {
     allowedParameters: ICommandParameter[];
     execute(args: string[]): Promise<void>;
 }
+export declare class DoctorWindowsCommand implements ICommand {
+    private $doctorService;
+    private $projectHelper;
+    constructor($doctorService: IDoctorService, $projectHelper: IProjectHelper);
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+}

package/lib/common/commands/doctor.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoctorAndroidCommand = exports.DoctorIosCommand = exports.DoctorCommand = void 0;
+exports.DoctorWindowsCommand = exports.DoctorAndroidCommand = exports.DoctorIosCommand = exports.DoctorCommand = void 0;
 const yok_1 = require("../yok");
 const constants_1 = require("../../constants");
 class DoctorCommand {
@@ -53,3 +53,20 @@ class DoctorAndroidCommand {
 }
 exports.DoctorAndroidCommand = DoctorAndroidCommand;
 yok_1.injector.registerCommand("doctor|android", DoctorAndroidCommand);
+class DoctorWindowsCommand {
+    constructor($doctorService, $projectHelper) {
+        this.$doctorService = $doctorService;
+        this.$projectHelper = $projectHelper;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return this.$doctorService.printWarnings({
+            trackResult: false,
+            projectDir: this.$projectHelper.projectDir,
+            forceCheck: true,
+            platform: constants_1.PlatformTypes.windows,
+        });
+    }
+}
+exports.DoctorWindowsCommand = DoctorWindowsCommand;
+yok_1.injector.registerCommand("doctor|windows", DoctorWindowsCommand);

package/lib/common/definitions/mobile.d.ts

@@ -367,6 +367,12 @@ declare global {
 
 		interface IStartApplicationData extends IApplicationData {
 			waitForDebugger?: boolean;
+			/**
+			 * True when launching as part of a debug session (`ns debug`), regardless of --debug-brk.
+			 * Windows uses this to signal the host to start the inspector (via a sentinel file);
+			 * a plain `ns run` leaves it unset so the inspector/devtools server is never created.
+			 */
+			debugMode?: boolean;
 		}
 
 		interface IInstallAppData extends IApplicationData {
@@ -1106,6 +1112,7 @@ declare global {
 			isAndroidPlatform(platform: string): boolean;
 			isiOSPlatform(platform: string): boolean;
 			isvisionOSPlatform(platform: string): boolean;
+			isWindowsPlatform(platform: string): boolean;
 			isApplePlatform(platform: string): boolean;
 			normalizePlatformName(platform: string): string;
 			validatePlatformName(platform: string): string;
@@ -1150,10 +1157,12 @@ declare global {
 			iOS: string;
 			Android: string;
 			visionOS: string;
+			Windows: string;
 
 			isiOS(value: string): boolean;
 			isAndroid(value: string): boolean;
 			isvisionOS(value: string): boolean;
+			isWindows(value: string): boolean;
 		}
 
 		interface IDeviceApplication {

package/lib/common/file-system.js

@@ -107,10 +107,16 @@ let FileSystem = FileSystem_1 = class FileSystem {
         }
     }
     deleteDirectory(directory) {
-        shelljs.rm("-rf", directory);
-        const err = shelljs.error();
-        if (err !== null) {
-            throw new Error(err);
+        var _a;
+        try {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+        catch (e) {
+            shelljs.rm("-rf", directory);
+            const err = shelljs.error();
+            if (err !== null) {
+                throw new Error((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : err);
+            }
         }
     }
     deleteDirectorySafe(directory) {
@@ -242,7 +248,10 @@ let FileSystem = FileSystem_1 = class FileSystem {
             return;
         }
         this.createDirectory((0, path_1.dirname)(destinationFileName));
-        shelljs.cp("-rf", sourceFileName, destinationFileName);
+        const normalizedSource = process.platform === "win32"
+            ? sourceFileName.replace(/\\/g, "/")
+            : sourceFileName;
+        shelljs.cp("-rf", normalizedSource, destinationFileName);
         const err = shelljs.error();
         if (err) {
             throw new Error(err);
@@ -291,7 +300,26 @@ let FileSystem = FileSystem_1 = class FileSystem {
         }
     }
     rename(oldPath, newPath) {
-        fs.renameSync(oldPath, newPath);
+        const maxAttempts = 5;
+        const delayMs = 200;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                fs.renameSync(oldPath, newPath);
+                return;
+            }
+            catch (e) {
+                if (e.code === "EPERM" && attempt < maxAttempts) {
+                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs * attempt);
+                    continue;
+                }
+                if (e.code === "EPERM" && process.platform === "win32") {
+                    fs.cpSync(oldPath, newPath, { recursive: true });
+                    this.deleteDirectory(oldPath);
+                    return;
+                }
+                throw e;
+            }
+        }
     }
     renameIfExists(oldPath, newPath) {
         try {

package/lib/common/http-client.js

@@ -70,7 +70,7 @@ class HttpClient {
                 },
             });
         }
-        const result = await (0, axios_1.default)({
+        let httpOptions = {
             url: options.url,
             headers: options.headers,
             method: options.method,
@@ -80,7 +80,14 @@ class HttpClient {
             data: options.body,
             responseType: options.pipeTo ? "stream" : undefined,
             onDownloadProgress: options.onDownloadProgress,
-        }).catch((err) => {
+        };
+        if (Number.isFinite(options.maxRedirects)) {
+            httpOptions.maxRedirects = options.maxRedirects;
+        }
+        if (options.validateStatus !== undefined) {
+            httpOptions.validateStatus = options.validateStatus;
+        }
+        const result = await (0, axios_1.default)(httpOptions).catch((err) => {
             this.$logger.trace("An error occurred while sending the request:", err);
             if (err.response) {
                 const errorMessage = this.getErrorMessage(err.response.status, null);

package/lib/common/mobile/device-platforms-constants.d.ts

@@ -2,7 +2,9 @@ export declare class DevicePlatformsConstants implements Mobile.IDevicePlatforms
     iOS: string;
     Android: string;
     visionOS: string;
+    Windows: string;
     isiOS(value: string): boolean;
     isAndroid(value: string): boolean;
     isvisionOS(value: string): boolean;
+    isWindows(value: string): boolean;
 }

package/lib/common/mobile/device-platforms-constants.js

@@ -7,6 +7,7 @@ class DevicePlatformsConstants {
         this.iOS = "iOS";
         this.Android = "Android";
         this.visionOS = "visionOS";
+        this.Windows = "Windows";
     }
     isiOS(value) {
         return value.toLowerCase() === this.iOS.toLowerCase();
@@ -17,6 +18,9 @@ class DevicePlatformsConstants {
     isvisionOS(value) {
         return value.toLowerCase() === this.visionOS.toLowerCase();
     }
+    isWindows(value) {
+        return value.toLowerCase() === this.Windows.toLowerCase();
+    }
 }
 exports.DevicePlatformsConstants = DevicePlatformsConstants;
 yok_1.injector.register("devicePlatformsConstants", DevicePlatformsConstants);

package/lib/common/mobile/mobile-core/devices-service.d.ts

@@ -8,6 +8,7 @@ export declare class DevicesService extends EventEmitter implements Mobile.IDevi
     private $iOSSimulatorDiscovery;
     private $iOSDeviceDiscovery;
     private $androidDeviceDiscovery;
+    private $windowsDeviceDiscovery;
     private $staticConfig;
     private $messages;
     private $mobileHelper;
@@ -34,7 +35,7 @@ export declare class DevicesService extends EventEmitter implements Mobile.IDevi
     private _allDeviceDiscoveries;
     private deviceDetectionInterval;
     private emulatorDetectionInterval;
-    constructor($logger: ILogger, $errors: IErrors, $iOSSimulatorDiscovery: Mobile.IiOSSimulatorDiscovery, $iOSDeviceDiscovery: Mobile.IDeviceDiscovery, $androidDeviceDiscovery: Mobile.IDeviceDiscovery, $staticConfig: Config.IStaticConfig, $messages: IMessages, $mobileHelper: Mobile.IMobileHelper, $deviceLogProvider: Mobile.IDeviceLogProvider, $hostInfo: IHostInfo, $injector: IInjector, $options: IOptions, $androidProcessService: Mobile.IAndroidProcessService, $iOSEmulatorServices: Mobile.IiOSSimulatorService, $androidEmulatorServices: Mobile.IEmulatorPlatformService, $androidEmulatorDiscovery: Mobile.IDeviceDiscovery, $emulatorHelper: Mobile.IEmulatorHelper, $prompter: IPrompter, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
+    constructor($logger: ILogger, $errors: IErrors, $iOSSimulatorDiscovery: Mobile.IiOSSimulatorDiscovery, $iOSDeviceDiscovery: Mobile.IDeviceDiscovery, $androidDeviceDiscovery: Mobile.IDeviceDiscovery, $windowsDeviceDiscovery: Mobile.IDeviceDiscovery, $staticConfig: Config.IStaticConfig, $messages: IMessages, $mobileHelper: Mobile.IMobileHelper, $deviceLogProvider: Mobile.IDeviceLogProvider, $hostInfo: IHostInfo, $injector: IInjector, $options: IOptions, $androidProcessService: Mobile.IAndroidProcessService, $iOSEmulatorServices: Mobile.IiOSSimulatorService, $androidEmulatorServices: Mobile.IEmulatorPlatformService, $androidEmulatorDiscovery: Mobile.IDeviceDiscovery, $emulatorHelper: Mobile.IEmulatorHelper, $prompter: IPrompter, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
     pickSingleDevice(options: Mobile.IPickSingleDeviceOptions): Promise<Mobile.IDevice>;
     getEmulatorImages(options?: Mobile.IListEmulatorsOptions): Promise<Mobile.IListEmulatorsOutput>;
     startEmulator(options: Mobile.IStartEmulatorOptions): Promise<string[]>;

package/lib/common/mobile/mobile-core/devices-service.js

@@ -20,13 +20,14 @@ const helpers = require("../../helpers");
 const helpers_1 = require("../../helpers");
 const yok_1 = require("../../yok");
 class DevicesService extends events_1.EventEmitter {
-    constructor($logger, $errors, $iOSSimulatorDiscovery, $iOSDeviceDiscovery, $androidDeviceDiscovery, $staticConfig, $messages, $mobileHelper, $deviceLogProvider, $hostInfo, $injector, $options, $androidProcessService, $iOSEmulatorServices, $androidEmulatorServices, $androidEmulatorDiscovery, $emulatorHelper, $prompter, $devicePlatformsConstants) {
+    constructor($logger, $errors, $iOSSimulatorDiscovery, $iOSDeviceDiscovery, $androidDeviceDiscovery, $windowsDeviceDiscovery, $staticConfig, $messages, $mobileHelper, $deviceLogProvider, $hostInfo, $injector, $options, $androidProcessService, $iOSEmulatorServices, $androidEmulatorServices, $androidEmulatorDiscovery, $emulatorHelper, $prompter, $devicePlatformsConstants) {
         super();
         this.$logger = $logger;
         this.$errors = $errors;
         this.$iOSSimulatorDiscovery = $iOSSimulatorDiscovery;
         this.$iOSDeviceDiscovery = $iOSDeviceDiscovery;
         this.$androidDeviceDiscovery = $androidDeviceDiscovery;
+        this.$windowsDeviceDiscovery = $windowsDeviceDiscovery;
         this.$staticConfig = $staticConfig;
         this.$messages = $messages;
         this.$mobileHelper = $mobileHelper;
@@ -52,6 +53,7 @@ class DevicesService extends events_1.EventEmitter {
             this.$iOSDeviceDiscovery,
             this.$androidDeviceDiscovery,
             this.$iOSSimulatorDiscovery,
+            this.$windowsDeviceDiscovery,
         ];
     }
     async pickSingleDevice(options) {
@@ -206,6 +208,7 @@ class DevicesService extends events_1.EventEmitter {
             this.$iOSSimulatorDiscovery,
             this.$iOSDeviceDiscovery,
             this.$androidDeviceDiscovery,
+            this.$windowsDeviceDiscovery,
         ].forEach(this.attachToDeviceDiscoveryEvents.bind(this));
     }
     attachToKnownEmulatorDiscoveryEvents() {
@@ -703,6 +706,9 @@ class DevicesService extends events_1.EventEmitter {
             this.$hostInfo.isDarwin) {
             await this.$iOSSimulatorDiscovery.startLookingForDevices(deviceLookingOptions);
         }
+        else if (this.$mobileHelper.isWindowsPlatform(platform)) {
+            await this.$windowsDeviceDiscovery.startLookingForDevices(deviceLookingOptions);
+        }
     }
     async executeCore(action, canExecute) {
         if (this._device) {

package/lib/common/mobile/mobile-helper.d.ts

@@ -12,6 +12,7 @@ export declare class MobileHelper implements Mobile.IMobileHelper {
     isAndroidPlatform(platform: string): boolean;
     isiOSPlatform(platform: string): boolean;
     isvisionOSPlatform(platform: string): boolean;
+    isWindowsPlatform(platform: string): boolean;
     isApplePlatform(platform: string): boolean;
     normalizePlatformName(platform: string): string;
     validatePlatformName(platform: string): string;

package/lib/common/mobile/mobile-helper.js

@@ -17,6 +17,7 @@ class MobileHelper {
             this.$devicePlatformsConstants.iOS,
             this.$devicePlatformsConstants.Android,
             this.$devicePlatformsConstants.visionOS,
+            this.$devicePlatformsConstants.Windows,
         ];
     }
     isAndroidPlatform(platform) {
@@ -34,6 +35,11 @@ class MobileHelper {
             this.$devicePlatformsConstants.visionOS.toLowerCase() ===
                 platform.toLowerCase());
     }
+    isWindowsPlatform(platform) {
+        return !!(platform &&
+            this.$devicePlatformsConstants.Windows.toLowerCase() ===
+                platform.toLowerCase());
+    }
     isApplePlatform(platform) {
         return this.isiOSPlatform(platform) || this.isvisionOSPlatform(platform);
     }
@@ -47,6 +53,9 @@ class MobileHelper {
         else if (this.isvisionOSPlatform(platform)) {
             return "visionOS";
         }
+        else if (this.isWindowsPlatform(platform)) {
+            return "Windows";
+        }
         return undefined;
     }
     validatePlatformName(platform) {

package/lib/common/mobile/windows/windows-application-manager.d.ts

@@ -0,0 +1,25 @@
+import { ApplicationManagerBase } from "../application-manager-base";
+import { IHooksService, IChildProcess, IDictionary } from "../../declarations";
+import { IBuildData } from "../../../definitions/build";
+export declare class WindowsApplicationManager extends ApplicationManagerBase {
+    private $childProcess;
+    private _restartLogStream?;
+    private _runningPid;
+    private _packageFamilyNames;
+    private _installedExePaths;
+    constructor($logger: ILogger, $hooksService: IHooksService, $deviceLogProvider: Mobile.IDeviceLogProvider, $childProcess: IChildProcess, _restartLogStream?: () => Promise<void>);
+    getInstalledApplications(): Promise<string[]>;
+    isApplicationInstalled(appIdentifier: string): Promise<boolean>;
+    installApplication(packageFilePath: string, appIdentifier?: string, _buildData?: IBuildData): Promise<void>;
+    uninstallApplication(appIdentifier: string): Promise<void>;
+    restartApplication(appData: Mobile.IStartApplicationData): Promise<void>;
+    getLogFilePath(): string;
+    getCrashLogPath(): string | null;
+    startApplication(appData: Mobile.IStartApplicationData): Promise<void>;
+    stopApplication(appData: Mobile.IApplicationData): Promise<void>;
+    tryStartApplication(appData: Mobile.IApplicationData): Promise<void>;
+    getDebuggableApps(): Promise<Mobile.IDeviceApplicationInformation[]>;
+    getDebuggableAppViews(_appIdentifiers: string[]): Promise<IDictionary<Mobile.IDebugWebViewInfo[]>>;
+    private _resolvePackageFamilyName;
+    private _writeMarker;
+}

package/lib/common/mobile/windows/windows-application-manager.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsApplicationManager = void 0;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const child_process_1 = require("child_process");
+const application_manager_base_1 = require("../application-manager-base");
+class WindowsApplicationManager extends application_manager_base_1.ApplicationManagerBase {
+    constructor($logger, $hooksService, $deviceLogProvider, $childProcess, _restartLogStream) {
+        super($logger, $hooksService, $deviceLogProvider);
+        this.$childProcess = $childProcess;
+        this._restartLogStream = _restartLogStream;
+        this._runningPid = null;
+        this._packageFamilyNames = new Map();
+        this._installedExePaths = {};
+    }
+    async getInstalledApplications() {
+        try {
+            const result = await this.$childProcess.spawnFromEvent("powershell.exe", [
+                "-NoProfile",
+                "-Command",
+                "Get-AppxPackage | Select-Object -ExpandProperty PackageFamilyName",
+            ], "close", {}, { throwError: false });
+            return (result.stdout || "")
+                .split(/\r?\n/)
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    async isApplicationInstalled(appIdentifier) {
+        if (appIdentifier &&
+            Object.prototype.hasOwnProperty.call(this._installedExePaths, appIdentifier)) {
+            return true;
+        }
+        return super.isApplicationInstalled(appIdentifier);
+    }
+    async installApplication(packageFilePath, appIdentifier, _buildData) {
+        if (packageFilePath === null || packageFilePath === void 0 ? void 0 : 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;
+            }
+            this._installedExePaths[exeBase] = packageFilePath;
+            return;
+        }
+        this.$logger.info(`[Windows] Installing MSIX/APPX from: ${packageFilePath}`);
+        if (appIdentifier) {
+            try {
+                this.$logger.info(`[Windows] Attempting to remove existing package: ${appIdentifier}`);
+                await this.uninstallApplication(appIdentifier);
+            }
+            catch (err) {
+                this.$logger.warn(`[Windows] Pre-install uninstall failed: ${err}`);
+            }
+        }
+        const isLooseManifest = packageFilePath.toLowerCase().endsWith("appxmanifest.xml");
+        let addAppxCommand;
+        if (isLooseManifest) {
+            addAppxCommand = `Add-AppxPackage -ForceApplicationShutdown -Register -Path "${packageFilePath}"`;
+        }
+        else {
+            const arch = process.arch === "arm64" ? "arm64" : "x64";
+            const dependencyDir = path.join(path.dirname(packageFilePath), "Dependencies", arch);
+            const dependencyGlob = path.join(dependencyDir, "*.msix");
+            addAppxCommand = fs.existsSync(dependencyDir)
+                ? `$deps = Get-ChildItem -Path "${dependencyGlob}" -ErrorAction SilentlyContinue; ` +
+                    `if ($deps) { Add-AppxPackage -Path "${packageFilePath}" -DependencyPath $deps.FullName -ForceApplicationShutdown } ` +
+                    `else { Add-AppxPackage -Path "${packageFilePath}" -ForceApplicationShutdown }`
+                : `Add-AppxPackage -Path "${packageFilePath}" -ForceApplicationShutdown`;
+        }
+        await this.$childProcess.spawnFromEvent("powershell.exe", [
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            addAppxCommand,
+        ], "close", {}, { throwError: true });
+        if (appIdentifier) {
+            await this._resolvePackageFamilyName(appIdentifier);
+        }
+    }
+    async uninstallApplication(appIdentifier) {
+        delete this._installedExePaths[appIdentifier];
+        this._packageFamilyNames.delete(appIdentifier);
+        await this.$childProcess.spawnFromEvent("powershell.exe", [
+            "-NoProfile",
+            "-Command",
+            `Get-AppxPackage -Name "${appIdentifier}" | Remove-AppxPackage`,
+        ], "close", {}, { throwError: false });
+    }
+    async restartApplication(appData) {
+        await this.stopApplication(appData);
+        await this.startApplication(appData);
+    }
+    getLogFilePath() {
+        if (this._packageFamilyNames.size > 0) {
+            const pfn = this._packageFamilyNames.values().next().value;
+            const localAppData = process.env.LOCALAPPDATA;
+            if (localAppData && pfn) {
+                return path.join(localAppData, "Packages", pfn, "LocalState", "console.log");
+            }
+        }
+        const systemConsoleLog = path.join(os.tmpdir(), "console.log");
+        const systemLegacyLog = path.join(os.tmpdir(), "ns_trace.log");
+        if (fs.existsSync(systemConsoleLog))
+            return systemConsoleLog;
+        if (fs.existsSync(systemLegacyLog))
+            return systemLegacyLog;
+        return systemConsoleLog;
+    }
+    getCrashLogPath() {
+        if (this._packageFamilyNames.size > 0) {
+            const pfn = this._packageFamilyNames.values().next().value;
+            const localAppData = process.env.LOCALAPPDATA;
+            if (localAppData && pfn) {
+                return path.join(localAppData, "Packages", pfn, "LocalState", "nativescript-crash.log");
+            }
+        }
+        return null;
+    }
+    async startApplication(appData) {
+        var _a, _b;
+        const exeCandidate = (appData.appId && this._installedExePaths[appData.appId]) ||
+            (appData.projectName && this._installedExePaths[appData.projectName]);
+        const isExe = !!(exeCandidate && fs.existsSync(exeCandidate));
+        if (!isExe) {
+            await this._resolvePackageFamilyName(appData.appId);
+        }
+        try {
+            fs.writeFileSync(this.getLogFilePath(), "", "utf8");
+        }
+        catch (_c) { }
+        if (isExe) {
+            if (appData.waitForDebugger) {
+                this.$logger.info(`[Windows] --debug-brk is not supported for EXE targets.`);
+            }
+            this.$logger.info(`[Windows] Launching EXE: ${exeCandidate}`);
+            const proc = (0, child_process_1.spawn)(exeCandidate, [], { detached: true, stdio: "ignore" });
+            proc.unref();
+            this._runningPid = (_a = proc.pid) !== null && _a !== void 0 ? _a : null;
+            proc.on("exit", () => {
+                if (this._runningPid === proc.pid) {
+                    this._runningPid = null;
+                }
+            });
+        }
+        else {
+            const pfn = (_b = this._packageFamilyNames.get(appData.appId)) !== null && _b !== void 0 ? _b : appData.appId;
+            if (appData.debugMode) {
+                this._writeMarker(pfn, "ns-inspector");
+            }
+            if (appData.waitForDebugger) {
+                this._writeMarker(pfn, "ns-debugbreak");
+            }
+            const appId = "App";
+            this.$logger.info(`[Windows] Launching UWP: ${pfn}!${appId}`);
+            const proc = (0, child_process_1.spawn)("explorer.exe", [`shell:AppsFolder\\${pfn}!${appId}`], {
+                detached: true,
+                stdio: "ignore",
+            });
+            proc.unref();
+        }
+        if (this._restartLogStream) {
+            await this._restartLogStream();
+        }
+    }
+    async stopApplication(appData) {
+        if (this._runningPid) {
+            try {
+                process.kill(this._runningPid);
+            }
+            catch (_a) {
+            }
+            this._runningPid = null;
+        }
+        else {
+            await this.$childProcess.spawnFromEvent("powershell.exe", [
+                "-NoProfile",
+                "-Command",
+                `Stop-Process -Name "${appData.projectName}" -ErrorAction SilentlyContinue`,
+            ], "close", {}, { throwError: false });
+        }
+    }
+    async tryStartApplication(appData) {
+        try {
+            await this.startApplication(appData);
+        }
+        catch (_a) {
+        }
+    }
+    async getDebuggableApps() {
+        return [];
+    }
+    async getDebuggableAppViews(_appIdentifiers) {
+        return {};
+    }
+    async _resolvePackageFamilyName(appId) {
+        var _a;
+        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 (_b) {
+        }
+        return (_a = this._packageFamilyNames.get(appId)) !== null && _a !== void 0 ? _a : appId;
+    }
+    _writeMarker(pfn, name) {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (!localAppData)
+            return;
+        const markerPath = path.join(localAppData, "Packages", pfn, "LocalState", name);
+        try {
+            fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+            fs.writeFileSync(markerPath, "", "utf8");
+            this.$logger.info(`[Windows] Wrote ${name} marker: ${markerPath}`);
+        }
+        catch (e) {
+            this.$logger.warn(`[Windows] Could not write ${name} marker: ${e}`);
+        }
+    }
+}
+exports.WindowsApplicationManager = WindowsApplicationManager;

package/lib/common/mobile/windows/windows-device-discovery.d.ts

@@ -0,0 +1,9 @@
+import { DeviceDiscovery } from "../mobile-core/device-discovery";
+import { IInjector } from "../../definitions/yok";
+export declare class WindowsDeviceDiscovery extends DeviceDiscovery implements Mobile.IDeviceDiscovery {
+    private $injector;
+    private $mobileHelper;
+    private _deviceAdded;
+    constructor($injector: IInjector, $mobileHelper: Mobile.IMobileHelper);
+    startLookingForDevices(options?: Mobile.IDeviceLookingOptions): Promise<void>;
+}