@nativescript/windows 0.1.0-alpha.8 → 0.1.0-alpha.81

package/build.ps1

@@ -119,19 +119,61 @@ foreach ($t in $Targets) {
 
     if (-not $SkipRelease) {
         Write-Host "`n=== Release ($arch) ===" -ForegroundColor Cyan
-        Build-Crate -Profile "release" -Target $rustTarget
+        $releaseArgs = @()
+        Build-Crate -Profile "release" -Target $rustTarget -ExtraArgs $releaseArgs
         $dll = Join-Path $RepoRoot "target\$rustTarget\release\nativescript.dll"
         Copy-Dll -Src $dll -Dest (Join-Path $FrameworkLibs "$arch\nativescript.dll")
     }
 
     if (-not $SkipDevtools) {
         Write-Host "`n=== Release-with-devtools ($arch) ===" -ForegroundColor Cyan
-        Build-Crate -Profile "release-with-devtools" -Target $rustTarget -ExtraArgs @("--features", "devtools")
+        $devtoolsArgs = @("--features", "devtools")
+        Build-Crate -Profile "release-with-devtools" -Target $rustTarget -ExtraArgs $devtoolsArgs
         $dll = Join-Path $RepoRoot "target\$rustTarget\release-with-devtools\nativescript.dll"
         Copy-Dll -Src $dll -Dest (Join-Path $FrameworkLibs "devtools\$arch\nativescript.dll")
     }
 }
 
+# ── dotnet-tool prebuilt binaries ────────────────────────────────────────────
+Write-Host "`n=== Build dotnet-tool prebuilt binaries ===" -ForegroundColor Cyan
+# Place prebuilt tools into the framework folder so they are included in the
+# packaged framework (npm publish copies framework/* into the package root).
+$ToolsDir = Join-Path $ScriptDir "framework\tools"
+if (-not (Test-Path $ToolsDir)) { New-Item -ItemType Directory -Force -Path $ToolsDir | Out-Null }
+
+
+foreach ($t in $Targets) {
+    $arch = $t.Arch
+    $rustTarget = $t.RustTarget
+    Write-Host "Building dotnet-tool for $arch ($rustTarget)..."
+    Push-Location $RepoRoot
+    try {
+        & cargo build -p dotnet-tool --release --target $rustTarget
+        $buildExit = $LASTEXITCODE
+    } finally {
+        Pop-Location
+    }
+    if ($buildExit -ne 0) {
+        Write-Host "cargo build for dotnet-tool failed for target $rustTarget (exit $buildExit). Skipping copy for $arch." -ForegroundColor Yellow
+        continue
+    }
+    $candidate = Join-Path $RepoRoot "target\$rustTarget\release\dotnet-tool.exe"
+    if (Test-Path $candidate) {
+        $dest = Join-Path $ToolsDir "dotnet-tool-$arch.exe"
+        Copy-Item -Force $candidate $dest
+        Write-Host "  copied dotnet-tool -> $(Resolve-Path $dest -Relative)"
+    } else {
+        Write-Host "Expected build output not found: $candidate" -ForegroundColor Yellow
+    }
+}
+
+# Provide a generic `dotnet-tool.exe` fallback (copy x64 if available)
+$x64Path = Join-Path $ToolsDir "dotnet-tool-x64.exe"
+if (Test-Path $x64Path) {
+    Copy-Item -Force $x64Path (Join-Path $ToolsDir "dotnet-tool.exe")
+    Write-Host "  copied dotnet-tool-x64.exe -> dotnet-tool.exe"
+}
+
 Write-Host ""
 Write-Host "Done." -ForegroundColor Green
 Write-Host ""

package/framework/__PROJECT_NAME__/App.xaml.cs

@@ -19,46 +19,80 @@ namespace __PROJECT_NAME__
             this.UnhandledException += OnUnhandledException;
         }
 
-        protected override void OnLaunched(LaunchActivatedEventArgs e)
+        protected override async void OnLaunched(LaunchActivatedEventArgs e)
         {
             _runtimeHost.Initialize();
+
+            // Capture before any await — continuations may resume on a thread pool thread.
+            var dispatcher = Window.Current.Dispatcher;
+
+            // Show crash report from the previous run if one exists.
+            try
+            {
+                var panicLogPath = System.IO.Path.Combine(
+                    ApplicationData.Current.LocalFolder.Path, "nativescript-panic.log");
+                if (System.IO.File.Exists(panicLogPath))
+                {
+                    var content = System.IO.File.ReadAllText(panicLogPath);
+                    System.IO.File.Delete(panicLogPath);
+                    if (!string.IsNullOrWhiteSpace(content))
+                        await CrashDiagnostics.ShowCrashDialogAsync("Crash from previous run", content);
+                }
+            }
+            catch { }
+
+            string jsError = null;
             try
             {
                 _runtimeHost.RunMainScript();
+                jsError = _runtimeHost.GetLastJsError();
+                if (!string.IsNullOrEmpty(jsError))
+                {
+                    CrashDiagnostics.WriteMessage("JS Error", jsError);
+                    var report = CrashDiagnostics.BuildErrorReport(null, jsError);
+                    CrashDiagnostics.WriteToTraceLog(report);
+                    await CrashDiagnostics.ShowCrashDialogAsync("JavaScript Error", report);
+                }
             }
             catch (Exception scriptEx)
             {
+                jsError = _runtimeHost.GetLastJsError();
                 System.Diagnostics.Debug.WriteLine($"[NativeScript] Script exception: {scriptEx.Message}");
+                CrashDiagnostics.WriteExceptionReport("RunMainScript", scriptEx, null);
+                var report = CrashDiagnostics.BuildErrorReport(scriptEx, jsError);
+                CrashDiagnostics.WriteToTraceLog(report);
+                await CrashDiagnostics.ShowCrashDialogAsync("Script Execution Error", report);
             }
 
-#if DEBUG
-            Windows.UI.Xaml.Media.CompositionTarget.Rendering += OnRenderFrame;
-#endif
-
-            if (Window.Current.Content == null)
+            // After any await, the continuation may run on a thread pool thread.
+            // Schedule all UI-thread-required operations through the dispatcher.
+            _ = dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
             {
-                Window.Current.Content = new Windows.UI.Xaml.Controls.TextBlock
+                Windows.UI.Xaml.Media.CompositionTarget.Rendering += OnRenderFrame;
+
+                if (Window.Current.Content == null)
                 {
-                    Text = "NativeScript runtime initialized but no UI was rendered.\n" +
-                           "Check the Output window for JS errors.",
-                    Margin = new Windows.UI.Xaml.Thickness(20),
-                    TextWrapping = Windows.UI.Xaml.TextWrapping.Wrap,
-                    FontSize = 16,
-                };
-            }
+                    Window.Current.Content = new Windows.UI.Xaml.Controls.TextBlock
+                    {
+                        Text = "NativeScript runtime initialized but no UI was rendered.\n" +
+                               "Check the Output window for JS errors.",
+                        Margin = new Windows.UI.Xaml.Thickness(20),
+                        TextWrapping = Windows.UI.Xaml.TextWrapping.Wrap,
+                        FontSize = 16,
+                    };
+                }
 
-            if (!e.PrelaunchActivated)
-            {
-                Window.Current.Activate();
-            }
+                if (!e.PrelaunchActivated)
+                {
+                    Window.Current.Activate();
+                }
+            });
         }
 
         private void OnSuspending(object sender, SuspendingEventArgs e)
         {
             var deferral = e.SuspendingOperation.GetDeferral();
-#if DEBUG
             Windows.UI.Xaml.Media.CompositionTarget.Rendering -= OnRenderFrame;
-#endif
             ApplicationData.Current.LocalSettings.Values[LastLaunchArgsKey] = string.Empty;
             _runtimeHost.Dispose();
             deferral.Complete();
@@ -66,14 +100,25 @@ namespace __PROJECT_NAME__
 
         private void OnUnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e)
         {
+            e.Handled = true;
+            var jsError = _runtimeHost.GetLastJsError();
             CrashDiagnostics.WriteExceptionReport(
                 "Xaml.UnhandledException",
                 e.Exception,
-                "Message=" + e.Message + "; Handled=" + e.Handled);
+                "JsError=" + (jsError ?? "<none>"));
+
+            var report = CrashDiagnostics.BuildErrorReport(e.Exception, jsError);
+            CrashDiagnostics.WriteToTraceLog(report);
+            var _ = CrashDiagnostics.ShowCrashDialogAsync(
+                e.Message ?? "Unhandled exception", report);
         }
 
+        private void OnRenderFrame(object sender, object e)
+        {
+            _runtimeHost.PumpTimers();
 #if DEBUG
-        private void OnRenderFrame(object sender, object e) => _runtimeHost.PumpDevtools();
+            _runtimeHost.PumpDevtools();
 #endif
+        }
     }
 }

package/framework/__PROJECT_NAME__/CrashDiagnostics.cs

@@ -1,66 +1,262 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Threading.Tasks;
-using Windows.Storage;
-
-namespace __PROJECT_NAME__
-{
-    internal static class CrashDiagnostics
-    {
-        private static bool _installed;
-
-        public static void InstallGlobalHandlers()
-        {
-            if (_installed) return;
-            _installed = true;
-
-            AppDomain.CurrentDomain.UnhandledException += (_, args) =>
-            {
-                var ex = args.ExceptionObject as Exception;
-                WriteExceptionReport("AppDomain.UnhandledException", ex, "IsTerminating=" + args.IsTerminating);
-            };
-
-            TaskScheduler.UnobservedTaskException += (_, args) =>
-            {
-                WriteExceptionReport("TaskScheduler.UnobservedTaskException", args.Exception, null);
-            };
-        }
-
-        public static void WriteExceptionReport(string source, Exception ex, string details)
-        {
-            var sb = new StringBuilder();
-            sb.AppendLine("============================================================");
-            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
-            sb.AppendLine("Source: " + source);
-            if (!string.IsNullOrWhiteSpace(details)) sb.AppendLine("Details: " + details);
-            if (ex != null) { sb.AppendLine("Exception:"); sb.AppendLine(ex.ToString()); }
-            else sb.AppendLine("Exception: <null>");
-            sb.AppendLine("Managed stack snapshot:");
-            sb.AppendLine(Environment.StackTrace);
-            sb.AppendLine();
-            AppendToLog(sb.ToString());
-        }
-
-        public static void WriteMessage(string source, string message)
-        {
-            var sb = new StringBuilder();
-            sb.AppendLine("============================================================");
-            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
-            sb.AppendLine("Source: " + source);
-            sb.AppendLine("Message: " + message);
-            sb.AppendLine();
-            AppendToLog(sb.ToString());
-        }
-
-        private static void AppendToLog(string content)
-        {
-            try
-            {
-                var logPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log");
-                File.AppendAllText(logPath, content, Encoding.UTF8);
-            }
-            catch { }
-        }
-    }
-}
+using System;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Storage;
+using Windows.System;
+using Windows.UI.Popups;
+
+namespace __PROJECT_NAME__
+{
+    internal static class CrashDiagnostics
+    {
+        private static bool _installed;
+
+        public static void InstallGlobalHandlers()
+        {
+            if (_installed) return;
+            _installed = true;
+
+            AppDomain.CurrentDomain.UnhandledException += (_, args) =>
+            {
+                var ex = args.ExceptionObject as Exception;
+                WriteExceptionReport("AppDomain.UnhandledException", ex, "IsTerminating=" + args.IsTerminating);
+            };
+
+            TaskScheduler.UnobservedTaskException += (_, args) =>
+            {
+                // Always mark the exception as observed to prevent the finalizer
+                // from rethrowing it on the finalizer thread.
+                try { args.SetObserved(); } catch { }
+
+                // Log the exception but never allow logging failures to propagate
+                // (this handler runs on the finalizer thread in some cases).
+                try
+                {
+                    WriteExceptionReport("TaskScheduler.UnobservedTaskException", args.Exception, null);
+                }
+                catch (Exception logEx)
+                {
+                    try { WriteToTraceLog("[CrashDiagnostics] Failed to write unobserved exception: " + logEx); } catch { }
+                }
+            };
+        }
+
+        public static void WriteExceptionReport(string source, Exception ex, string details)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("============================================================");
+            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
+            sb.AppendLine("Source: " + source);
+            if (!string.IsNullOrWhiteSpace(details)) sb.AppendLine("Details: " + details);
+            if (ex != null) { sb.AppendLine("Exception:"); sb.AppendLine(ex.ToString()); }
+            else sb.AppendLine("Exception: <null>");
+            sb.AppendLine("Managed stack snapshot:");
+            sb.AppendLine(Environment.StackTrace);
+            sb.AppendLine();
+            AppendToLog(sb.ToString());
+        }
+
+        public static void WriteMessage(string source, string message)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("============================================================");
+            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
+            sb.AppendLine("Source: " + source);
+            sb.AppendLine("Message: " + message);
+            sb.AppendLine();
+            AppendToLog(sb.ToString());
+        }
+
+        public static string BuildErrorReport(Exception ex, string jsError = null, string extraDetails = null)
+        {
+            var sb = new StringBuilder();
+
+            if (!string.IsNullOrWhiteSpace(jsError))
+            {
+                sb.AppendLine("── JavaScript Error ──────────────────────────────────────");
+                sb.AppendLine(jsError.Trim());
+                sb.AppendLine();
+            }
+
+            if (ex != null)
+            {
+                sb.AppendLine("── Native Exception ──────────────────────────────────────");
+                sb.AppendLine(ex.GetType().Name + ": " + ex.Message);
+                if (ex.StackTrace != null) sb.AppendLine(ex.StackTrace);
+                var inner = ex.InnerException;
+                while (inner != null)
+                {
+                    sb.AppendLine("Caused by: " + inner.GetType().Name + ": " + inner.Message);
+                    if (inner.StackTrace != null) sb.AppendLine(inner.StackTrace);
+                    inner = inner.InnerException;
+                }
+                sb.AppendLine();
+            }
+
+            // Include panic log from previous or current run
+            try
+            {
+                var panicLog = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-panic.log");
+                if (File.Exists(panicLog))
+                {
+                    var content = File.ReadAllText(panicLog, Encoding.UTF8).Trim();
+                    if (!string.IsNullOrEmpty(content))
+                    {
+                        sb.AppendLine("── Rust Panic Log ────────────────────────────────────────");
+                        sb.AppendLine(content);
+                        sb.AppendLine();
+                    }
+                }
+            }
+            catch { }
+
+            if (!string.IsNullOrWhiteSpace(extraDetails))
+            {
+                sb.AppendLine("── Additional Info ───────────────────────────────────────");
+                sb.AppendLine(extraDetails);
+                sb.AppendLine();
+            }
+
+            sb.AppendLine("──────────────────────────────────────────────────────────");
+            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
+
+            return sb.ToString();
+        }
+
+        public static string CrashLogPath()
+        {
+            try { return Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log"); }
+            catch { return null; }
+        }
+
+        /// Parses the first "path:line:col" source location from a JS stack trace.
+        /// Returns null if none found. Handles Windows drive-letter paths (C:\...).
+        public static (string file, int line, int col)? TryExtractSourceLocation(string errorReport)
+        {
+            if (string.IsNullOrEmpty(errorReport)) return null;
+
+            // Match the contents of the first (path:line:col) group in the stack trace.
+            var m = Regex.Match(errorReport, @"\(([^)]+)\)");
+            if (!m.Success) return null;
+
+            var inner = m.Groups[1].Value; // e.g. "C:\app\bundle.js:42:13"
+
+            // Parse col from the right (last :digits).
+            var lastColon = inner.LastIndexOf(':');
+            if (lastColon < 0 || !int.TryParse(inner.Substring(lastColon + 1), out int col)) return null;
+            inner = inner.Substring(0, lastColon);
+
+            // Parse line from the right (second-to-last :digits).
+            lastColon = inner.LastIndexOf(':');
+            if (lastColon < 0 || !int.TryParse(inner.Substring(lastColon + 1), out int line)) return null;
+            var file = inner.Substring(0, lastColon);
+
+            return string.IsNullOrEmpty(file) ? null : (file, line, col);
+        }
+
+        public static async Task ShowCrashDialogAsync(string heading, string errorReport)
+        {
+            try
+            {
+                // Write full details to log so developer can access them even if the
+                // dialog summary is truncated.
+                var logPath = CrashLogPath();
+                if (logPath != null)
+                    File.WriteAllText(logPath, errorReport, Encoding.UTF8);
+
+                // Truncate for the dialog (MessageDialog has practical limits).
+                const int MaxLen = 800;
+                var summary = errorReport.Length > MaxLen
+                    ? errorReport.Substring(0, MaxLen) + "\n\n[truncated — see log for full details]"
+                    : errorReport;
+
+                if (logPath != null)
+                    summary += "\n\nFull log: " + logPath;
+
+                var dialog = new MessageDialog(summary, "NativeScript Runtime Error");
+
+                // MessageDialog supports at most 3 commands. When a source location is
+                // available, swap "Copy Details" for "Open in VS Code" so the user can
+                // choose between jumping to the error or restarting. Full details are
+                // always written to the log file shown in the dialog text.
+                var srcLocation = TryExtractSourceLocation(errorReport);
+                if (srcLocation.HasValue)
+                {
+                    var (srcFile, srcLine, srcCol) = srcLocation.Value;
+                    dialog.Commands.Add(new UICommand("Open Source File", async _ =>
+                    {
+                        try
+                        {
+                            var normalizedPath = srcFile.Replace('\\', '/');
+                            var uriStr = $"file:///{normalizedPath}";
+                            if (Uri.TryCreate(uriStr, UriKind.Absolute, out var fileUri))
+                                await Launcher.LaunchUriAsync(fileUri,
+                                    new LauncherOptions { DisplayApplicationPicker = true });
+                        }
+                        catch { }
+                    }));
+                }
+                else
+                {
+                    dialog.Commands.Add(new UICommand("Copy Details", _ =>
+                    {
+                        try
+                        {
+                            var dp = new DataPackage();
+                            dp.SetText(errorReport);
+                            Clipboard.SetContent(dp);
+                        }
+                        catch { }
+                    }));
+                }
+
+                dialog.Commands.Add(new UICommand("Restart App", async _ =>
+                {
+                    try { await CoreApplication.RequestRestartAsync("crash-restart"); }
+                    catch { }
+                }));
+
+                dialog.Commands.Add(new UICommand("Dismiss"));
+                dialog.DefaultCommandIndex = 0;
+                dialog.CancelCommandIndex = 2;
+
+                await dialog.ShowAsync();
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine("[NativeScript] Failed to show crash dialog: " + ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Appends <paramref name="message"/> to ns_trace.log using the Win32 temp path.
+        /// Inside UWP, GetTempPath() virtualises to AC\Temp — the same folder Rust's
+        /// std::env::temp_dir() uses — so this write appears in the CLI's log stream.
+        /// </summary>
+        public static void WriteToTraceLog(string message)
+        {
+            try
+            {
+                // System.IO.Path.GetTempPath() calls Win32 GetTempPathW() which inside a
+                // UWP process returns the container's AC\Temp folder, matching Rust.
+                var tracePath = Path.Combine(System.IO.Path.GetTempPath(), "ns_trace.log");
+                File.AppendAllText(tracePath, message, Encoding.UTF8);
+            }
+            catch { }
+        }
+
+        private static void AppendToLog(string content)
+        {
+            try
+            {
+                var logPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log");
+                File.AppendAllText(logPath, content, Encoding.UTF8);
+            }
+            catch { }
+        }
+    }
+}

package/framework/__PROJECT_NAME__/Directory.Build.props

@@ -0,0 +1,15 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!-- Default property values for manifest overrides.
+       Override these in Directory.Build.props or via /p: properties. -->
+  <PropertyGroup>
+  <AppDisplayName Condition=" '$(AppDisplayName)' == '' ">$(MSBuildProjectName)</AppDisplayName>
+    <AppDescription Condition=" '$(AppDescription)' == '' ">A NativeScript Windows application</AppDescription>
+    <Square150x150Logo Condition=" '$(Square150x150Logo)' == '' ">Assets\Square150x150Logo.png</Square150x150Logo>
+    <Square44x44Logo Condition=" '$(Square44x44Logo)' == '' ">Assets\Square44x44Logo.png</Square44x44Logo>
+    <Wide310x150Logo Condition=" '$(Wide310x150Logo)' == '' ">Assets\Wide310x150Logo.png</Wide310x150Logo>
+    <StoreLogo Condition=" '$(StoreLogo)' == '' ">Assets\StoreLogo.png</StoreLogo>
+    <LockScreenLogo Condition=" '$(LockScreenLogo)' == '' ">Assets\LockScreenLogo.png</LockScreenLogo>
+    <SplashBackgroundColor Condition=" '$(SplashBackgroundColor)' == '' ">#65ADF1</SplashBackgroundColor>
+    <SplashImage Condition=" '$(SplashImage)' == '' ">Assets\SplashScreen.png</SplashImage>
+  </PropertyGroup>
+</Project>