fix(windows): logging

NativeScript · triniwiz · May 11, 2026 · May 12, 2026 · May 12, 2026 · May 14, 2026
commit 5bbe284ceda16b5094922971c0cf7eab4bebc438
diff --git a/lib/common/mobile/windows/windows-application-manager.ts b/lib/common/mobile/windows/windows-application-manager.ts
@@ -19,6 +19,7 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 		$hooksService: IHooksService,
 		$deviceLogProvider: Mobile.IDeviceLogProvider,
 		private $childProcess: IChildProcess,
+		private _restartLogStream?: () => Promise<void>,
 	) {
 		super($logger, $hooksService, $deviceLogProvider);
 	}
@@ -144,43 +145,67 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 
 	/**
 	 * Returns the path of the runtime's trace log for the most recently started app.
-	 * For UWP-packaged apps the runtime DLL writes inside the app container's TempState,
-	 * not the global system temp directory. Falls back to the system temp path used when
-	 * the app is launched as an unpackaged EXE.
+	 * Inside a UWP process, Win32 GetTempPathW() virtualises to AC\Temp (the app
+	 * container's isolated temp folder) — NOT the WinRT TemporaryFolder (TempState).
+	 * Rust's std::env::temp_dir() calls GetTempPathW(), so the DLL writes to AC\Temp.
+	 * Falls back to the system temp path when no PFN is known (unpackaged EXE).
 	 */
 	public getLogFilePath(): string {
 		const systemTempLog = path.join(os.tmpdir(), "ns_trace.log");
 		if (this._packageFamilyNames.size > 0) {
 			const pfn = this._packageFamilyNames.values().next().value as string;
 			const localAppData = process.env.LOCALAPPDATA;
 			if (localAppData && pfn) {
-				return path.join(localAppData, "Packages", pfn, "TempState", "ns_trace.log");
+				return path.join(localAppData, "Packages", pfn, "AC", "Temp", "ns_trace.log");
 			}
 		}
 		return systemTempLog;
 	}
 
+	/**
+	 * Returns the path of the C# crash/exception log written by CrashDiagnostics.
+	 * Lives in LocalState (persistent app data).
+	 * Returns null when no PFN is known (e.g. unpackaged EXE targets).
+	 */
+	public getCrashLogPath(): string | null {
+		if (this._packageFamilyNames.size > 0) {
+			const pfn = this._packageFamilyNames.values().next().value as string;
+			const localAppData = process.env.LOCALAPPDATA;
+			if (localAppData && pfn) {
+				return path.join(localAppData, "Packages", pfn, "LocalState", "nativescript-crash.log");
+			}
+		}
+		return null;
+	}
+
 	public async startApplication(
 		appData: Mobile.IStartApplicationData,
 	): Promise<void> {
-		// Truncate the trace log so the streamer starts from a clean state each run.
-		try {
-			const logPath = this.getLogFilePath();
-			fs.writeFileSync(logPath, "", "utf8");
-		} catch { /* ignore — log dir may not exist yet */ }
-
 		const exeCandidate =
 			(appData.appId && this._installedExePaths[appData.appId]) ||
 			(appData.projectName && this._installedExePaths[appData.projectName]);
+		const isExe = !!(exeCandidate && fs.existsSync(exeCandidate));
+
+		// For UWP, pre-populate the PFN cache before calling getLogFilePath() so
+		// that the truncation and the subsequent log stream restart both target the
+		// correct container TempState path instead of the system temp fallback.
+		if (!isExe) {
+			await this._resolvePackageFamilyName(appData.appId);
+		}
+
+		// Truncate the trace log so the streamer starts from a clean state each run.
+		try {
+			fs.writeFileSync(this.getLogFilePath(), "", "utf8");
+		} catch { /* ignore — log dir may not exist yet */ }
 
-		if (exeCandidate && fs.existsSync(exeCandidate)) {
+		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 = spawn(exeCandidate, [], { detached: true, stdio: "ignore" });
+			const proc = spawn(exeCandidate as string, [], { detached: true, stdio: "ignore" });
 			proc.unref();
 			this._runningPid = proc.pid ?? null;
 			// Clear stale PID when the process exits so stopApplication falls back to
@@ -190,22 +215,30 @@ export class WindowsApplicationManager extends ApplicationManagerBase {
 					this._runningPid = null;
 				}
 			});
-			return;
+		} else {
+			// PFN already cached from the pre-resolve above; no extra round-trip.
+			const pfn = this._packageFamilyNames.get(appData.appId) ?? appData.appId;
+			if (appData.waitForDebugger) {
+				this._writeDebugBreakMarker(pfn);
+			}
+			// UWP apps are launched via shell:AppsFolder\<PFN>!<ApplicationId>.
+			// The ApplicationId comes from the <Application Id="..."> attribute in the manifest.
+			const appId = "App";
+			this.$logger.info(`[Windows] Launching UWP: ${pfn}!${appId}`);
+			const proc = spawn("explorer.exe", [`shell:AppsFolder\\${pfn}!${appId}`], {
+				detached: true,
+				stdio: "ignore",
+			});
+			proc.unref();
 		}
 
-		const pfn = await this._resolvePackageFamilyName(appData.appId);
-		if (appData.waitForDebugger) {
-			this._writeDebugBreakMarker(pfn);
+		// Restart the log stream so the tailer picks up the correct path (UWP
+		// container TempState vs. system temp) and resets its offset to 0. Without
+		// this the tailer keeps the stale offset from device-discovery time and
+		// skips every log line written after the file was truncated above.
+		if (this._restartLogStream) {
+			await this._restartLogStream();
 		}
-		// UWP apps are launched via shell:AppsFolder\<PFN>!<ApplicationId>.
-		// The ApplicationId comes from the <Application Id="..."> attribute in the manifest.
-		const appId = "App";
-		this.$logger.info(`[Windows] Launching UWP: ${pfn}!${appId}`);
-		const proc = spawn("explorer.exe", [`shell:AppsFolder\\${pfn}!${appId}`], {
-			detached: true,
-			stdio: "ignore",
-		});
-		proc.unref();
 	}
 
 	public async stopApplication(

diff --git a/lib/common/mobile/windows/windows-device.ts b/lib/common/mobile/windows/windows-device.ts
@@ -27,6 +27,7 @@ export class WindowsDevice implements Mobile.IDevice {
 	};
 
 	private _logTailInterval: ReturnType<typeof setInterval> | null = null;
+	private _crashLogTailInterval: ReturnType<typeof setInterval> | null = null;
 
 	constructor(
 		$logger: ILogger,
@@ -39,6 +40,7 @@ export class WindowsDevice implements Mobile.IDevice {
 			$hooksService,
 			$deviceLogProvider,
 			$childProcess,
+			() => this.openDeviceLogStream(),
 		);
 		this.fileSystem = new WindowsDeviceFileSystem();
 	}
@@ -48,21 +50,40 @@ export class WindowsDevice implements Mobile.IDevice {
 			clearInterval(this._logTailInterval);
 			this._logTailInterval = null;
 		}
+		if (this._crashLogTailInterval) {
+			clearInterval(this._crashLogTailInterval);
+			this._crashLogTailInterval = null;
+		}
 
 		// For packaged UWP apps, GetTempPath() inside the app container resolves to
 		// %LOCALAPPDATA%\Packages\<PFN>\TempState — not the system temp dir.
 		// Ask the application manager for the correct path based on the known PFN.
 		const manager = this.applicationManager as WindowsApplicationManager;
 		const logPath = manager.getLogFilePath();
+		const crashLogPath = manager.getCrashLogPath();
 		const deviceId = this.deviceInfo.identifier;
 
-		// Start from the current end of the file so stale output is not replayed.
+		// startApplication() truncates the trace log before calling this method, so the
+		// file is either empty (size 0) or absent. Start from 0 to capture all
+		// output from the new process. The initial call from DeviceEmitter (before
+		// any app starts) also starts at 0; the truncation in startApplication()
+		// is what prevents stale output from being replayed.
 		let offset = 0;
-		try { offset = fs.statSync(logPath).size; } catch { /* file not yet created */ }
 
 		// Rotate the log if it exceeds 10 MB to prevent unbounded disk growth.
 		const MAX_LOG_BYTES = 10 * 1024 * 1024;
 
+		// Internal Rust runtime diagnostics written via debug_output() — useful in
+		// VS Output / DebugView but noisy in the CLI. Suppress them; errors/exceptions
+		// are kept because their prefix contains "error", "exception", or "PANIC".
+		const INTERNAL_PREFIXES = [
+			"[NativeScript] init_console:",
+			"[NativeScript] log file:",
+			"[NativeScript] delegate ctor:",
+		];
+		const isInternalTrace = (line: string) =>
+			INTERNAL_PREFIXES.some((p) => line.startsWith(p));
+
 		this._logTailInterval = setInterval(() => {
 			try {
 				const stat = fs.statSync(logPath);
@@ -77,7 +98,7 @@ export class WindowsDevice implements Mobile.IDevice {
 
 				const lines = buf.toString("utf8").split(/\r?\n/);
 				for (const line of lines) {
-					if (line.trim()) {
+					if (line.trim() && !isInternalTrace(line)) {
 						this.$deviceLogProvider.logData(line, "Windows", deviceId);
 					}
 				}
@@ -86,6 +107,35 @@ export class WindowsDevice implements Mobile.IDevice {
 					try { fs.writeFileSync(logPath, "", "utf8"); offset = 0; } catch { /* ignore */ }
 				}
 			} catch { /* ignore — file may not exist between app restarts */ }
-		}, 250);
+		}, 50);
+
+		// Also tail nativescript-crash.log from LocalState so C# exception reports
+		// and JS errors caught by the host surface in the CLI — same as Android/iOS
+		// crash log streaming. Truncate on each run so only errors from this session appear.
+		if (crashLogPath) {
+			try { fs.writeFileSync(crashLogPath, "", "utf8"); } catch { /* may not exist yet */ }
+			let crashOffset = 0;
+
+			this._crashLogTailInterval = setInterval(() => {
+				try {
+					const stat = fs.statSync(crashLogPath);
+					if (stat.size <= crashOffset) return;
+
+					const toRead = stat.size - crashOffset;
+					const buf = Buffer.alloc(toRead);
+					const fd = fs.openSync(crashLogPath, "r");
+					fs.readSync(fd, buf, 0, toRead, crashOffset);
+					fs.closeSync(fd);
+					crashOffset = stat.size;
+
+					const lines = buf.toString("utf8").split(/\r?\n/);
+					for (const line of lines) {
+						if (line.trim()) {
+							this.$deviceLogProvider.logData(`[crash] ${line}`, "Windows", deviceId);
+						}
+					}
+				} catch { /* ignore — file may not exist until first crash */ }
+			}, 50);
+		}
 	}
 }
diff --git a/lib/services/project-cleanup-service.ts b/lib/services/project-cleanup-service.ts
@@ -147,7 +147,7 @@ export class ProjectCleanupService implements IProjectCleanupService {
 		// Collect exe names from the directory that might be running.
 		const exeNames: string[] = [];
 		try {
-			for (const entry of fs.readdirSync(dirPath, { withFileTypes: true, recursive: true } as any)) {
+			for (const entry of fs.readdirSync(dirPath, { withFileTypes: true, recursive: true } as any) as unknown as fs.Dirent[]) {
 				if (!entry.isFile()) continue;
 				const name: string = (entry as any).name ?? "";
 				if (name.toLowerCase().endsWith(".exe")) {