arcane-os 0.91.0 → 0.93.0

package/src/core/hosts/windows/ArcaneHost.cs

@@ -24,6 +24,7 @@ namespace Arcane.Core.Hosts.Windows
         public string Title { get; set; }
         public string IconPath { get; set; }
         public string ClassicClientSource { get; set; }
+        public string NativeDiagnosticsSource { get; set; }
         public string AppControlEndpoint { get; set; }
         public string AppControlSource { get; set; }
         public string CoreExecutable { get; set; }
@@ -102,15 +103,20 @@ namespace Arcane.Core.Hosts.Windows
         private readonly Action<string> onDiagnostic;
         private readonly Action<Exception> onError;
         private readonly WebView2 webView;
+        private readonly ArcaneNativeDiagnostics nativeDiagnostics;
         private readonly object stateLock = new object();
         private readonly Queue<CoreDelivery> pending = new Queue<CoreDelivery>();
         private readonly Dictionary<string, long> requestGenerations = new Dictionary<string, long>();
+        private readonly Dictionary<string, DesktopNotificationRequest> desktopNotificationRequests =
+            new Dictionary<string, DesktopNotificationRequest>();
         private readonly List<Exception> failures = new List<Exception>();
         private readonly List<Task> failureNotifications = new List<Task>();
         private readonly TaskCompletionSource<object> ready = new TaskCompletionSource<object>();
         private readonly TaskCompletionSource<object> initialized = new TaskCompletionSource<object>();
         private readonly TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
         private ArcaneCoreProcess core;
+        private ArcaneNotifications desktopNotifications;
+        private Task desktopNotificationsClosing;
         private ArcaneBridge bridge;
         private ArcaneBridge activeBridge;
         private Task initialization;
@@ -119,6 +125,8 @@ namespace Arcane.Core.Hosts.Windows
         private Task iconLoading;
         private Icon applicationIcon;
         private string injectedScript;
+        private string nativeDiagnosticsScript;
+        private bool nativeDiagnosticsRegistered;
         private Exception transportFailure;
         private long generation;
         private long nextGeneration;
@@ -144,6 +152,7 @@ namespace Arcane.Core.Hosts.Windows
             this.options = options;
             this.onDiagnostic = onDiagnostic;
             this.onError = onError;
+            nativeDiagnostics = new ArcaneNativeDiagnostics(Report);
             ready.Task.ContinueWith(ObserveReportedFailure, TaskContinuationOptions.OnlyOnFaulted);
             completion.Task.ContinueWith(ObserveReportedFailure, TaskContinuationOptions.OnlyOnFaulted);
             Text = options.Title;
@@ -494,6 +503,10 @@ namespace Arcane.Core.Hosts.Windows
                 browser.SetVirtualHostNameToFolderMapping(options.OriginHost, applicationRoot,
                     CoreWebView2HostResourceAccessKind.Allow);
                 InstallDocumentBridge(generation);
+                // Register the diagnostic observer first so failures in the
+                // ordinary client itself use an ingress independent of Core.
+                await InstallNativeDiagnosticsAsync(browser);
+                if (closing) return;
                 // The selected generator uses replayRuntimeState:true. Both RPC
                 // installation and the shared event owner remain SDK-owned.
                 Task scripts = Task.WhenAll(InstallClassicClientAsync(browser), InstallAppControlAsync(browser));
@@ -523,6 +536,15 @@ namespace Arcane.Core.Hosts.Windows
             injectedScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(options.ClassicClientSource);
         }
 
+        private async Task InstallNativeDiagnosticsAsync(CoreWebView2 browser)
+        {
+            if (String.IsNullOrEmpty(options.NativeDiagnosticsSource)) return;
+            browser.AddHostObjectToScript("arcaneDiagnostics", nativeDiagnostics);
+            nativeDiagnosticsRegistered = true;
+            nativeDiagnosticsScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(options.NativeDiagnosticsSource);
+            nativeDiagnostics.Installed();
+        }
+
         private void NavigationStarting(object sender, CoreWebView2NavigationStartingEventArgs args)
         {
             if (nextGeneration != 0 && navigationId == args.NavigationId) return;
@@ -561,6 +583,33 @@ namespace Arcane.Core.Hosts.Windows
                 if (documentGeneration != generation || closing)
                     throw new InvalidOperationException("The requesting document is no longer connected.");
                 string method = EnvelopeString(envelope, "method");
+                if (EnvelopeString(envelope, "protocol") == "arcane/1")
+                {
+                    if (requestId != null && (method == "notifications.status" || method == "notifications.show"
+                        || method == "notifications.state" || method == "notifications.close"))
+                    {
+                        DesktopNotificationRequest operation = new DesktopNotificationRequest(documentGeneration);
+                        desktopNotificationRequests.Add(requestId, operation);
+                        operation.Completion = CompleteDesktopNotificationAsync(envelope, requestId, method, operation);
+                        operation.Completion.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
+                        // Bridge acceptance means this host owns the request;
+                        // the correlated response carries its native outcome.
+                        return Task.FromResult<object>(null);
+                    }
+                    if (EnvelopeString(envelope, "type") == "control")
+                    {
+                        string control = EnvelopeString(envelope, "control");
+                        DesktopNotificationRequest selected;
+                        if (control == "request.cancel" && desktopNotificationRequests.TryGetValue(
+                            EnvelopeString(envelope, "requestId") ?? String.Empty, out selected)
+                            && selected.Generation == documentGeneration)
+                        {
+                            selected.Cancellation.Cancel();
+                            return Task.FromResult<object>(null);
+                        }
+                        if (control == "requests.cancelAll") CancelDesktopNotificationRequests(documentGeneration);
+                    }
+                }
                 if (requestId != null && EnvelopeString(envelope, "protocol") == "arcane/1"
                     && (method == "window.setTheme" || method == "window.state" || method == "window.setState"))
                 {
@@ -584,6 +633,115 @@ namespace Arcane.Core.Hosts.Windows
             }
         }
 
+        private async Task CompleteDesktopNotificationAsync(Dictionary<string, object> request,
+            string id, string method, DesktopNotificationRequest operation)
+        {
+            try
+            {
+                Dictionary<string, object> response = new Dictionary<string, object>
+                {
+                    { "protocol", "arcane/1" }, { "type", "response" }, { "id", id }
+                };
+                try
+                {
+                    object value;
+                    Dictionary<string, object> parameters = request.TryGetValue("parameters", out value)
+                        ? value as Dictionary<string, object> : new Dictionary<string, object>();
+                    if (parameters == null) throw new ArgumentException("Supply a notification request object.");
+                    if (desktopNotifications == null)
+                        desktopNotifications = new ArcaneNotifications(options.ApplicationId, options.ProfileDirectory,
+                            options.Title, options.IconPath, DesktopNotificationChanged);
+                    Dictionary<string, object> result = await desktopNotifications.InvokeAsync(
+                        method, parameters, operation.Cancellation.Token).ConfigureAwait(false);
+                    // Cancellation after native submission does not rewrite an
+                    // accepted result. Its record also remains in host state.
+                    response["ok"] = true;
+                    response["result"] = result;
+                }
+                catch (Exception error)
+                {
+                    string code = error.Data["code"] as string;
+                    if (code == null) code = error is OperationCanceledException ? "CANCELLED"
+                        : error is ArgumentException ? "INVALID_ARGUMENT" : "ARCANE_NOTIFICATION_FAILED";
+                    response["ok"] = false;
+                    response["error"] = ArcaneHost.ErrorRecord(error, code);
+                }
+                response["time"] = DateTime.UtcNow.ToString("o");
+                string json = ArcaneHost.Serializer().Serialize(response);
+                lock (stateLock) pending.Enqueue(new CoreDelivery(operation.Generation, json));
+                ScheduleDelivery();
+            }
+            catch (Exception error)
+            {
+                // A bridge-accepted request must receive its response or the
+                // owning transport failure, including serialization failures.
+                CoreFailed(error);
+            }
+            finally
+            {
+                lock (stateLock)
+                {
+                    desktopNotificationRequests.Remove(id);
+                    operation.Cancellation.Dispose();
+                }
+            }
+        }
+
+        private void DesktopNotificationChanged(Dictionary<string, object> record)
+        {
+            string json = ArcaneHost.Serializer().Serialize(new Dictionary<string, object>
+            {
+                { "protocol", "arcane/1" }, { "type", "event" },
+                { "event", "notifications.state" }, { "data", record }, { "time", DateTime.UtcNow.ToString("o") }
+            });
+            lock (stateLock) pending.Enqueue(new CoreDelivery(generation, json));
+            ScheduleDelivery();
+        }
+
+        private void CancelDesktopNotificationRequests(long? documentGeneration)
+        {
+            lock (stateLock)
+            {
+                // Cancellation can settle a queued operation synchronously;
+                // iterate a snapshot while its completion removes correlation.
+                foreach (DesktopNotificationRequest operation in
+                    new List<DesktopNotificationRequest>(desktopNotificationRequests.Values))
+                    if (!documentGeneration.HasValue || operation.Generation == documentGeneration.Value)
+                        operation.Cancellation.Cancel();
+            }
+        }
+
+        private void StopDesktopNotifications()
+        {
+            CancelDesktopNotificationRequests(null);
+            if (desktopNotifications == null || desktopNotificationsClosing != null) return;
+            try { desktopNotificationsClosing = desktopNotifications.CloseAsync(); }
+            catch (Exception error) { Report(error); }
+        }
+
+        private async Task DrainDesktopNotificationsAsync()
+        {
+            List<Task> operations = new List<Task>();
+            lock (stateLock)
+            {
+                foreach (DesktopNotificationRequest operation in desktopNotificationRequests.Values)
+                    operations.Add(operation.Completion);
+            }
+            if (desktopNotificationsClosing != null) operations.Add(desktopNotificationsClosing);
+            Task settled = Task.WhenAll(operations);
+            try { await settled; }
+            catch (Exception error) { ReportTaskFailure(settled, error); }
+        }
+
+        private sealed class DesktopNotificationRequest
+        {
+            internal readonly long Generation;
+            internal readonly CancellationTokenSource Cancellation = new CancellationTokenSource();
+            internal Task Completion;
+
+            internal DesktopNotificationRequest(long generation) { Generation = generation; }
+        }
+
         private async Task LoadApplicationIconAsync()
         {
             if (String.IsNullOrEmpty(options.IconPath)) return;
@@ -762,12 +920,14 @@ namespace Arcane.Core.Hosts.Windows
         private void DocumentConnected(long documentGeneration)
         {
             ArcaneBridge previous;
+            long previousGeneration;
             lock (stateLock)
             {
                 if (closing) return;
                 if (documentGeneration == generation && documentReady) return;
                 if (documentGeneration != registeredGeneration) return;
                 previous = activeBridge;
+                previousGeneration = generation;
                 generation = documentGeneration;
                 activeBridge = bridge;
                 documentReady = true;
@@ -775,6 +935,7 @@ namespace Arcane.Core.Hosts.Windows
             if (previous != null && previous != activeBridge)
             {
                 previous.Stop(new OperationCanceledException("The previous document has navigated away."));
+                CancelDesktopNotificationRequests(previousGeneration);
                 if (transportFailure == null)
                 {
                     try { ObserveSend(core.SendAsync(CancelRendererRequests)); }
@@ -960,6 +1121,7 @@ namespace Arcane.Core.Hosts.Windows
             if (IsDisposed) return;
             if (bridge != null) bridge.Stop(transportFailure);
             if (activeBridge != null) activeBridge.Stop(transportFailure);
+            CancelDesktopNotificationRequests(null);
             NotifyTransportFailure();
             if (core != null) core.CloseAsync();
             ScheduleDelivery();
@@ -1010,10 +1172,12 @@ namespace Arcane.Core.Hosts.Windows
         {
             if (closing) return;
             lock (stateLock) closing = true;
+            nativeDiagnostics.Stop();
             if (!started) initialized.TrySetResult(null);
             if (bridge != null) bridge.Stop(new InvalidOperationException("The application window is closing."));
             if (activeBridge != null) activeBridge.Stop(new InvalidOperationException("The application window is closing."));
             StopAppControl();
+            StopDesktopNotifications();
             WindowStateTransition.ReleasePending(this);
             shutdown = DrainAndCloseAsync();
             shutdown.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
@@ -1042,6 +1206,7 @@ namespace Arcane.Core.Hosts.Windows
                 }
             }
             await DrainAppControlAsync();
+            await DrainDesktopNotificationsAsync();
             // Joining the independent image owner belongs after Core input has
             // closed; image I/O must never delay accepted service work draining.
             if (iconLoading != null)
@@ -1069,6 +1234,8 @@ namespace Arcane.Core.Hosts.Windows
                 if (!browserProcessExited && webView.CoreWebView2 != null)
                 {
                     webView.CoreWebView2.RemoveHostObjectFromScript("arcaneBridge");
+                    if (nativeDiagnosticsRegistered) webView.CoreWebView2.RemoveHostObjectFromScript("arcaneDiagnostics");
+                    if (nativeDiagnosticsScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(nativeDiagnosticsScript);
                     if (injectedScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(injectedScript);
                     if (appControlScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(appControlScript);
                 }

package/src/core/hosts/windows/ArcaneLauncher.cs

@@ -101,6 +101,7 @@ namespace Arcane.Core.Hosts.Windows
                     InitialWindowState = OptionalWindowState(windowOptions),
                     IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
+                    NativeDiagnosticsSource = File.ReadAllText(Path.Combine(directory, "arcane-native-diagnostics.js")),
                     AppControlEndpoint = appControl == null ? null : RequiredString(appControl, "endpoint"),
                     AppControlSource = appControl == null ? null : File.ReadAllText(Path.Combine(directory, "arcane-app-control.js")),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),

package/src/core/hosts/windows/ArcaneNativeDiagnostics.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Arcane.Core.Hosts.Windows
+{
+    /// <summary>
+    /// One host-session ledger, independent of Core and renderer readiness.
+    /// The dedicated document-start ingress acknowledges only retained records.
+    /// Diagnostic property graphs are data; the host never evaluates their fields.
+    /// </summary>
+    [ComVisible(true)]
+    [ClassInterface(ClassInterfaceType.AutoDual)]
+    public sealed class ArcaneNativeDiagnostics
+    {
+        private readonly object stateLock = new object();
+        private readonly string sessionId = Guid.NewGuid().ToString();
+        private readonly string captureStartedAt = DateTime.UtcNow.ToString("o");
+        private readonly List<Dictionary<string, object>> records = new List<Dictionary<string, object>>();
+        private readonly Dictionary<string, Dictionary<string, object>> documents =
+            new Dictionary<string, Dictionary<string, object>>();
+        private readonly Action<Exception> onFailure;
+        private long sequence;
+        private bool captureInstalled;
+        private bool stopped;
+
+        internal ArcaneNativeDiagnostics(Action<Exception> onFailure) { this.onFailure = onFailure; }
+
+        public string Send(string json)
+        {
+            try
+            {
+                Dictionary<string, object> frame = ArcaneHost.Serializer().DeserializeObject(json) as Dictionary<string, object>;
+                if (frame == null || Text(frame, "protocol") != "arcane.native-diagnostics/1")
+                    throw new InvalidDataException("Expected an Arcane native diagnostic envelope.");
+                string type = Text(frame, "type");
+                string documentId = Text(frame, "documentId");
+                string documentUrl = Text(frame, "documentUrl");
+                string time = Text(frame, "time");
+                if (documentId == null || documentUrl == null || time == null)
+                    throw new InvalidDataException("The diagnostic envelope needs its document identity, URL and time.");
+                object value;
+                Dictionary<string, object> record = frame.TryGetValue("record", out value)
+                    ? value as Dictionary<string, object> : null;
+                if (type != "document" && (type != "error" || record == null))
+                    throw new InvalidDataException("Expected a document announcement or an error record.");
+
+                Dictionary<string, object> result = new Dictionary<string, object>
+                {
+                    { "accepted", true }, { "sessionId", sessionId }
+                };
+                lock (stateLock)
+                {
+                    if (stopped) throw new InvalidOperationException("The native diagnostic session is closing.");
+                    string receivedAt = DateTime.UtcNow.ToString("o");
+                    if (!documents.ContainsKey(documentId))
+                        documents.Add(documentId, new Dictionary<string, object>
+                        {
+                            { "documentId", documentId }, { "documentUrl", documentUrl },
+                            { "time", time }, { "receivedAt", receivedAt }
+                        });
+                    if (type == "error")
+                    {
+                        Dictionary<string, object> retained = new Dictionary<string, object>(record);
+                        retained["sequence"] = ++sequence;
+                        retained["receivedAt"] = receivedAt;
+                        retained["documentId"] = documentId;
+                        retained["documentUrl"] = documentUrl;
+                        retained["time"] = time;
+                        records.Add(retained);
+                        result["sequence"] = sequence;
+                    }
+                }
+                return ArcaneHost.Serializer().Serialize(result);
+            }
+            catch (Exception error)
+            {
+                onFailure(error);
+                return ArcaneHost.Serializer().Serialize(new Dictionary<string, object>
+                {
+                    { "accepted", false },
+                    { "error", ArcaneHost.ErrorRecord(error, "ARCANE_NATIVE_DIAGNOSTIC_CAPTURE_FAILED") }
+                });
+            }
+        }
+
+        internal object Snapshot(Dictionary<string, object> parameters)
+        {
+            object selected;
+            long afterSequence = 0;
+            if (parameters.TryGetValue("afterSequence", out selected))
+            {
+                if (!(selected is int || selected is long || selected is decimal || selected is double))
+                    throw new ArgumentException("afterSequence must be a nonnegative integer.");
+                afterSequence = Convert.ToInt64(selected);
+                if (afterSequence < 0 || Convert.ToDouble(selected) != afterSequence)
+                    throw new ArgumentException("afterSequence must be a nonnegative integer.");
+            }
+            string documentId = null;
+            if (parameters.TryGetValue("documentId", out selected))
+            {
+                documentId = selected as string;
+                if (documentId == null) throw new ArgumentException("documentId must be a string.");
+            }
+            lock (stateLock)
+            {
+                List<object> found = new List<object>();
+                foreach (Dictionary<string, object> record in records)
+                {
+                    if ((long)record["sequence"] <= afterSequence) continue;
+                    if (documentId != null && (string)record["documentId"] != documentId) continue;
+                    found.Add(record);
+                }
+                List<object> observedDocuments = new List<object>();
+                foreach (KeyValuePair<string, Dictionary<string, object>> document in documents)
+                    if (documentId == null || document.Key == documentId) observedDocuments.Add(document.Value);
+                return new Dictionary<string, object>
+                {
+                    { "sessionId", sessionId }, { "captureStartedAt", captureStartedAt },
+                    { "captureInstalled", captureInstalled }, { "latestSequence", sequence },
+                    { "documents", observedDocuments }, { "records", found }
+                };
+            }
+        }
+
+        internal void Installed() { lock (stateLock) captureInstalled = true; }
+
+        internal void Stop() { lock (stateLock) stopped = true; }
+
+        private static string Text(Dictionary<string, object> record, string key)
+        {
+            object value;
+            return record.TryGetValue(key, out value) ? value as string : null;
+        }
+    }
+}