arcane-os 0.59.1 → 0.60.0

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Drawing;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -20,6 +21,7 @@ namespace Arcane.Core.Hosts.Windows
         public string OriginHost { get; set; }
         public string ProfileDirectory { get; set; }
         public string Title { get; set; }
+        public string IconPath { get; set; }
         public string ClassicClientSource { get; set; }
         public string CoreExecutable { get; set; }
         public string CoreArguments { get; set; }
@@ -106,6 +108,8 @@ namespace Arcane.Core.Hosts.Windows
         private Task initialization;
         private Task coreLifetime;
         private Task shutdown;
+        private Task iconLoading;
+        private Icon applicationIcon;
         private string injectedScript;
         private Exception transportFailure;
         private long generation;
@@ -162,6 +166,8 @@ namespace Arcane.Core.Hosts.Windows
                 string profile = Path.GetFullPath(options.ProfileDirectory);
                 Uri origin = new UriBuilder(Uri.UriSchemeHttps, options.OriginHost).Uri;
                 Uri start = new Uri(origin, options.StartPath);
+                iconLoading = LoadApplicationIconAsync();
+                iconLoading.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
                 core = ArcaneCoreProcess.Start(options.CoreExecutable, options.CoreArguments,
                     options.CoreWorkingDirectory, ReceiveCoreMessage, DeliverDiagnostic, CoreFailed);
                 coreLifetime = ObserveCoreLifetimeAsync();
@@ -228,6 +234,18 @@ namespace Arcane.Core.Hosts.Windows
             {
                 if (documentGeneration != generation || closing)
                     throw new InvalidOperationException("The requesting document is no longer connected.");
+                if (requestId != null && EnvelopeString(envelope, "protocol") == "arcane/1"
+                    && EnvelopeString(envelope, "method") == "window.setTheme")
+                {
+                    // This method belongs to this exact window, not the Core
+                    // child or a machine-wide appearance service.
+                    string response = WindowThemeResponse(envelope, requestId);
+                    pending.Enqueue(
+                        new CoreDelivery(documentGeneration, response)
+                    );
+                    ScheduleDelivery();
+                    return Task.FromResult<object>(null);
+                }
                 Task accepted = core.SendAsync(json);
                 // Hold the same lock used by the reader so an immediate response
                 // cannot overtake its accepted transport correlation record.
@@ -237,6 +255,181 @@ namespace Arcane.Core.Hosts.Windows
             }
         }
 
+        private async Task LoadApplicationIconAsync()
+        {
+            if (String.IsNullOrEmpty(options.IconPath)) return;
+            try
+            {
+                Icon loaded = await Task.Run(new Func<Icon>(ReadApplicationIcon));
+                if (closing)
+                {
+                    loaded.Dispose();
+                    return;
+                }
+                applicationIcon = loaded;
+                Icon = loaded;
+            }
+            catch (Exception error)
+            {
+                // Image codec availability is separate from application
+                // execution. Preserve ordinary startup and complete diagnostics.
+                object record = ArcaneHost.ErrorRecord(error, "ARCANE_WINDOW_ICON_UNAVAILABLE");
+                string diagnostic = ArcaneHost.Serializer().Serialize(record);
+                DeliverDiagnostic(diagnostic + Environment.NewLine);
+            }
+        }
+
+        private Icon ReadApplicationIcon()
+        {
+            string extension = Path.GetExtension(options.IconPath);
+            if (String.Equals(extension, ".ico", StringComparison.OrdinalIgnoreCase))
+                return new Icon(options.IconPath);
+            using (Bitmap bitmap = new Bitmap(options.IconPath))
+            {
+                IntPtr handle = bitmap.GetHicon();
+                try
+                {
+                    using (Icon borrowed = System.Drawing.Icon.FromHandle(handle))
+                    {
+                        return (Icon)borrowed.Clone();
+                    }
+                }
+                finally
+                {
+                    DestroyIcon(handle);
+                }
+            }
+        }
+
+        private string WindowThemeResponse(Dictionary<string, object> request, string id)
+        {
+            Dictionary<string, object> applied = new Dictionary<string, object>();
+            List<string> unsupported = new List<string>();
+            Dictionary<string, object> response = new Dictionary<string, object>
+            {
+                { "protocol", "arcane/1" },
+                { "type", "response" },
+                { "id", id }
+            };
+            try
+            {
+                object parameters;
+                Dictionary<string, object> presentation = request.TryGetValue("parameters", out parameters)
+                    ? parameters as Dictionary<string, object> : null;
+                if (presentation == null) throw new ArgumentException("Window presentation must be an object.");
+                ApplyWindowColor(presentation, "backgroundColor", 35, applied, unsupported);
+                ApplyWindowColor(presentation, "textColor", 36, applied, unsupported);
+                response["ok"] = true;
+                response["result"] = new Dictionary<string, object>
+                {
+                    { "platform", "windows" },
+                    { "supported", applied.Count != 0 },
+                    { "applied", applied },
+                    { "unsupported", unsupported }
+                };
+            }
+            catch (Exception error)
+            {
+                Dictionary<string, object> record = (Dictionary<string, object>)ArcaneHost.ErrorRecord(error,
+                    error is ArgumentException ? "INVALID_ARGUMENT" : "ARCANE_WINDOW_THEME_FAILED");
+                record["details"] = new Dictionary<string, object>
+                {
+                    { "applied", applied },
+                    { "unsupported", unsupported }
+                };
+                response["ok"] = false;
+                response["error"] = record;
+            }
+            return ArcaneHost.Serializer().Serialize(response);
+        }
+
+        private void ApplyWindowColor(Dictionary<string, object> presentation, string field, int attribute,
+            Dictionary<string, object> applied, List<string> unsupported)
+        {
+            object supplied;
+            if (!presentation.TryGetValue(field, out supplied)) return;
+            uint nativeColor = UInt32.MaxValue;
+            object accepted = null;
+            double alpha = 1;
+            if (supplied != null)
+            {
+                Dictionary<string, object> color = supplied as Dictionary<string, object>;
+                if (color == null) throw new ArgumentException(field + " must be an RGBA record or null.");
+                int red = (int)Math.Round(
+                    ColorChannel(color, "red", 255),
+                    MidpointRounding.AwayFromZero
+                );
+                int green = (int)Math.Round(
+                    ColorChannel(color, "green", 255),
+                    MidpointRounding.AwayFromZero
+                );
+                int blue = (int)Math.Round(
+                    ColorChannel(color, "blue", 255),
+                    MidpointRounding.AwayFromZero
+                );
+                alpha = ColorChannel(color, "alpha", 1);
+                nativeColor = (uint)(red | green << 8 | blue << 16);
+                accepted = new Dictionary<string, object>
+                {
+                    { "red", red },
+                    { "green", green },
+                    { "blue", blue },
+                    { "alpha", alpha }
+                };
+            }
+            if (alpha != 1 || !WindowColorsSupported())
+            {
+                unsupported.Add(field);
+                return;
+            }
+            int result = DwmSetWindowAttribute(Handle, attribute, ref nativeColor, sizeof(uint));
+            if (result < 0) throw new COMException("Applying window " + field + " failed.", result);
+            applied[field] = accepted;
+        }
+
+        private static double ColorChannel(Dictionary<string, object> color, string name, double maximum)
+        {
+            object value;
+            if (!color.TryGetValue(name, out value)
+                || !(value is int || value is long || value is double || value is decimal))
+                throw new ArgumentException("Window color " + name + " must be numeric.");
+            double number = Convert.ToDouble(value);
+            if (Double.IsNaN(number) || Double.IsInfinity(number) || number < 0 || number > maximum)
+                throw new ArgumentException("Window color " + name + " is outside its color-channel range.");
+            return number;
+        }
+
+        private static bool WindowColorsSupported()
+        {
+            WindowsVersion version = new WindowsVersion();
+            version.StructureSize = (uint)Marshal.SizeOf(typeof(WindowsVersion));
+            int result = RtlGetVersion(ref version);
+            if (result != 0) throw new ExternalException("Reading the Windows version failed.", result);
+            return version.Major > 10 || (version.Major == 10 && version.Build >= 22000);
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct WindowsVersion
+        {
+            internal uint StructureSize;
+            internal uint Major;
+            internal uint Minor;
+            internal uint Build;
+            internal uint Platform;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            internal string ServicePack;
+        }
+
+        [DllImport("ntdll.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        private static extern int RtlGetVersion(ref WindowsVersion version);
+
+        [DllImport("dwmapi.dll")]
+        private static extern int DwmSetWindowAttribute(IntPtr window, int attribute, ref uint value, int valueSize);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool DestroyIcon(IntPtr icon);
+
         private void DocumentConnected(long documentGeneration)
         {
             ArcaneBridge previous;
@@ -498,6 +691,19 @@ namespace Arcane.Core.Hosts.Windows
                     catch (Exception error) { ReportTaskFailure(coreLifetime, error); }
                 }
             }
+            // Joining the independent image owner belongs after Core input has
+            // closed; image I/O must never delay accepted service work draining.
+            if (iconLoading != null)
+            {
+                try
+                {
+                    await iconLoading;
+                }
+                catch (Exception error)
+                {
+                    ReportTaskFailure(iconLoading, error);
+                }
+            }
             Task notifications = Task.WhenAll(failureNotifications);
             try { await notifications; }
             catch (Exception error) { ReportTaskFailure(notifications, error); }
@@ -546,6 +752,11 @@ namespace Arcane.Core.Hosts.Windows
         protected override void OnFormClosed(FormClosedEventArgs args)
         {
             base.OnFormClosed(args);
+            if (applicationIcon != null)
+            {
+                applicationIcon.Dispose();
+                applicationIcon = null;
+            }
             CompleteWindow();
         }
 

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

@@ -51,6 +51,10 @@ namespace Arcane.Core.Hosts.Windows
                 string appId = RequiredString(app, "id");
                 object title;
                 string name = app.TryGetValue("displayName", out title) && title is string ? (string)title : appId;
+                object hostValue;
+                object iconValue;
+                Dictionary<string, object> host = manifest.TryGetValue("host", out hostValue) ? hostValue as Dictionary<string, object> : null;
+                string icon = host != null && host.TryGetValue("icon", out iconValue) ? iconValue as string : null;
 
                 // Core rereads this exact selected file. Do not normalize,
                 // rewrite, filter or copy the application's launch record.
@@ -67,6 +71,7 @@ namespace Arcane.Core.Hosts.Windows
                     OriginHost = "arcane.local",
                     ProfileDirectory = Path.Combine(profileParent, "WebView2"),
                     Title = name,
+                    IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),
                     // Forward the actual host selection separately; Core keeps

package/src/core/services/model-assets.mjs

@@ -0,0 +1,267 @@
+import {mkdir, mkdtemp, open, rm} from 'node:fs/promises';
+import {Buffer} from 'node:buffer';
+import path from 'node:path';
+import Is from 'strong-type';
+import {CoreError, serializeCoreError} from '../../../browser-runtime/core/contracts.mjs';
+
+const is = new Is(false);
+
+function failure(code, message) {
+    return new CoreError({code, message});
+}
+
+/** Working files for native engines. The browser's stored assets stay authoritative. */
+export function createModelAssetService({appRoot = process.cwd()} = {}) {
+    const projections = new Map();
+    let context;
+    let closing;
+
+    function snapshot(record) {
+        return {
+            id: record.id, directory: record.directory, state: record.state,
+            members: record.members.map(function memberLocation(member) {
+                return {path: member.path, nativePath: member.nativePath};
+            }),
+            preparationOwned: record.preparationOwned, uses: record.uses.size,
+            error: record.error ? serializeCoreError(record.error) : null
+        };
+    }
+
+    function current() {
+        return {closing: Boolean(closing), projections: [...projections.values()].map(snapshot)};
+    }
+
+    function publish(record) {
+        context?.emit('modelAssets.state', snapshot(record));
+    }
+
+    function requireProjection(id) {
+        const record = projections.get(id);
+        if (!record) throw failure('MODEL_ASSET_PROJECTION_UNAVAILABLE', `Model asset projection ${id} is unavailable.`);
+        return record;
+    }
+
+    async function closeMembers(record) {
+        const results = await Promise.allSettled(record.members.map(async function closeMember(member) {
+            await member.tail;
+            if (!member.handle) return;
+            const handle = member.handle;
+            await handle.close();
+            member.handle = null;
+        }));
+        const errors = results.filter(function rejected(result) { return result.status === 'rejected'; })
+            .map(function reason(result) { return result.reason; });
+        if (errors.length) throw new AggregateError(errors, 'Closing model asset files failed.');
+    }
+
+    function cleanup(record) {
+        if (record.preparationOwned || record.uses.size) return Promise.resolve(snapshot(record));
+        if (record.cleanup) return record.cleanup;
+        record.state = 'releasing';
+        // Retain the cleanup task before events can trigger another release.
+        record.cleanup = Promise.resolve().then(async function removeWorkingProjection() {
+            const errors = [];
+            let filesClosed = false;
+            try { await record.opening; } catch (error) { record.error ??= error; }
+            try { await record.finishing; } catch (error) { record.error ??= error; }
+            try { await closeMembers(record); filesClosed = true; } catch (error) { errors.push(error); }
+            if (record.directory && filesClosed) {
+                try { await rm(record.directory, {recursive: true}); }
+                catch (error) { if (error.code !== 'ENOENT') errors.push(error); }
+            }
+            if (errors.length) throw new AggregateError(errors, 'Releasing model asset working files failed.');
+            record.state = 'released';
+            projections.delete(record.id);
+            publish(record);
+            return snapshot(record);
+        });
+        record.cleanup.then(record.resolveReleased, function cleanupFailed(error) {
+            record.error = error;
+            record.state = 'error';
+            publish(record);
+            record.rejectReleased(error);
+        });
+        publish(record);
+        return record.cleanup;
+    }
+
+    function releasePreparation(record) {
+        record.preparationOwned = false;
+        publish(record);
+        return cleanup(record);
+    }
+
+    async function failedOperation(record, error) {
+        record.error = error;
+        record.state = 'error';
+        publish(record);
+        try { await releasePreparation(record); }
+        catch (cleanupError) { throw new AggregateError([error, cleanupError], 'Preparing model assets failed and cleanup failed.'); }
+        throw error;
+    }
+
+    async function openProjection({id, workingDirectory, members}, request) {
+        request.signal.throwIfAborted();
+        if (closing) throw failure('MODEL_ASSETS_CLOSING', 'Model asset preparation is closing.');
+        if (!is.string(id) || !id) throw new TypeError('A model asset projection needs an operation id.');
+        if (!is.string(workingDirectory) || !workingDirectory) {
+            throw new TypeError('Model asset preparation needs an explicit working directory.');
+        }
+        if (!is.array(members) || !members.length) throw new TypeError('Select the complete model asset members.');
+        if (projections.has(id)) throw failure('MODEL_ASSET_PROJECTION_ACTIVE', `Model asset projection ${id} already exists.`);
+        const record = {
+            id, state: 'preparing', directory: null, members: [], uses: new Set(),
+            preparationOwned: true, error: null, opening: null, finishing: null, cleanup: null
+        };
+        record.released = new Promise(function projectionReleased(resolve, reject) {
+            record.resolveReleased = resolve;
+            record.rejectReleased = reject;
+        });
+        record.released.catch(function observeReleaseFailure() {});
+        projections.set(id, record);
+        record.opening = Promise.resolve().then(async function createWorkingFiles() {
+            const selectedDirectory = path.resolve(appRoot, workingDirectory);
+            await mkdir(selectedDirectory, {recursive: true});
+            request.signal.throwIfAborted();
+            record.directory = await mkdtemp(path.join(selectedDirectory, 'arcane-model-'));
+            record.members = members.map(function memberRecord(member) {
+                const nativePath = path.resolve(record.directory, member.path);
+                const relative = path.relative(record.directory, nativePath);
+                // A projection consists of files under its one owned directory.
+                // Absolute or escaping members cannot participate in that lifetime.
+                if (path.isAbsolute(member.path) || !relative || relative === '..'
+                    || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+                    throw new TypeError('Model asset member paths must be relative files within their projection.');
+                }
+                return {path: member.path, nativePath, handle: null, tail: Promise.resolve()};
+            });
+            const results = await Promise.allSettled(record.members.map(async function createMember(member) {
+                request.signal.throwIfAborted();
+                await mkdir(path.dirname(member.nativePath), {recursive: true});
+                request.signal.throwIfAborted();
+                member.handle = await open(member.nativePath, 'wx');
+                request.signal.throwIfAborted();
+            }));
+            const errors = results.filter(function rejected(result) { return result.status === 'rejected'; })
+                .map(function reason(result) { return result.reason; });
+            if (errors.length) throw new AggregateError(errors, 'Opening model asset working files failed.');
+        });
+        publish(record);
+        try {
+            await record.opening;
+            request.signal.throwIfAborted();
+            if (!record.preparationOwned) throw failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.');
+            return snapshot(record);
+        } catch (error) { return failedOperation(record, error); }
+    }
+
+    async function writeMember({id, memberIndex, contentBase64}, request) {
+        const record = requireProjection(id);
+        await record.opening;
+        request.signal.throwIfAborted();
+        if (record.state !== 'preparing' || !record.preparationOwned) {
+            throw failure('MODEL_ASSET_PROJECTION_NOT_WRITABLE', 'Model asset preparation is no longer accepting content.');
+        }
+        const member = record.members[memberIndex];
+        if (!member) throw new TypeError('Select an existing model asset member.');
+        try {
+            const task = member.tail.then(async function appendOriginalContent() {
+                request.signal.throwIfAborted();
+                if (!record.preparationOwned) throw failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.');
+                await member.handle.appendFile(Buffer.from(contentBase64, 'base64'));
+                request.signal.throwIfAborted();
+            });
+            // File writes remain ordered; unrelated member files write independently.
+            member.tail = task.catch(function observeWriteFailure() {});
+            await task;
+            return {id, memberIndex, written: true};
+        } catch (error) { return failedOperation(record, error); }
+    }
+
+    async function completeProjection({id}, request) {
+        const record = requireProjection(id);
+        await record.opening;
+        request.signal.throwIfAborted();
+        if (record.state === 'completing') {
+            await record.finishing;
+            request.signal.throwIfAborted();
+        }
+        if (record.state === 'ready') return snapshot(record);
+        if (record.state !== 'preparing' || !record.preparationOwned) {
+            throw failure('MODEL_ASSET_PROJECTION_NOT_WRITABLE', 'Model asset preparation cannot be completed in its current state.');
+        }
+        record.state = 'completing';
+        record.finishing = Promise.resolve().then(async function finishProjection() {
+            await closeMembers(record);
+            request.signal.throwIfAborted();
+            if (!record.preparationOwned || record.error) {
+                throw record.error ?? failure('MODEL_ASSET_PROJECTION_RELEASED', 'Model asset preparation was released.');
+            }
+            record.state = 'ready';
+            publish(record);
+            return snapshot(record);
+        });
+        try { return await record.finishing; }
+        catch (error) { return failedOperation(record, error); }
+    }
+
+    function retain(id) {
+        const record = requireProjection(id);
+        if (closing || record.state !== 'ready') {
+            throw failure('MODEL_ASSET_PROJECTION_NOT_READY', 'The complete native model asset projection is not ready.');
+        }
+        const use = {};
+        record.uses.add(use);
+        let released;
+        publish(record);
+        return {
+            id: record.id, directory: record.directory, members: snapshot(record).members,
+            release() {
+                if (released) return released;
+                record.uses.delete(use);
+                // Assign before publishing so reentrant release remains idempotent.
+                released = Promise.resolve().then(function releaseEngineUse() { return cleanup(record); });
+                publish(record);
+                return released;
+            }
+        };
+    }
+
+    function dispose() {
+        if (closing) return closing;
+        closing = Promise.resolve().then(async function releaseAllProjections() {
+            const records = [...projections.values()];
+            for (const record of records) {
+                releasePreparation(record).catch(function observeCleanupFailure() {});
+            }
+            // Core closes services concurrently. Engine retain handles keep files
+            // alive until those owners finish actual native unload/worker exit.
+            const results = await Promise.allSettled(records.map(function awaitRelease(record) { return record.released; }));
+            const errors = results.filter(function rejected(result) { return result.status === 'rejected'; })
+                .map(function reason(result) { return result.reason; });
+            if (errors.length) throw new AggregateError(errors, 'Closing model asset preparation failed.');
+        });
+        return closing;
+    }
+
+    return {
+        name: 'model-assets', current, retain,
+        start(serviceContext) { context = serviceContext; },
+        methods: {
+            'modelAssets.open': openProjection,
+            'modelAssets.write': writeMember,
+            'modelAssets.complete': completeProjection,
+            'modelAssets.status': function status() { return current(); },
+            'modelAssets.release': {
+                lifetime: 'service',
+                handle({id}) {
+                    const record = projections.get(id);
+                    return record ? releasePreparation(record) : {id, state: 'released'};
+                }
+            }
+        },
+        dispose
+    };
+}
+
+export default createModelAssetService;