arcane-os 0.88.0 → 0.89.0

package/src/app-descriptor.mjs

@@ -237,7 +237,7 @@ function validateDocumentCatalog(value){
 
 function validateNativeWindow(value){
     if(value===undefined)return undefined;
-    assertOnlyKeys(value,new Set(['width','height','resizable']),'descriptor.native.window');
+    assertOnlyKeys(value,new Set(['width','height','resizable','state']),'descriptor.native.window');
     for(const dimension of ['width','height']){
         if(value[dimension]!==undefined&&(!is.integer(value[dimension])||value[dimension]<=0)){
             fail(`descriptor.native.window.${dimension} must be a positive integer.`);
@@ -246,10 +246,14 @@ function validateNativeWindow(value){
     if(value.resizable!==undefined&&!is.boolean(value.resizable)){
         fail('descriptor.native.window.resizable must be a boolean.');
     }
+    if(value.state!==undefined&&!['normal','maximized','fullscreen'].includes(value.state)){
+        fail('descriptor.native.window.state must be normal, maximized, or fullscreen.');
+    }
     return completeValue({
         ...(value.width===undefined?{}:{width:value.width}),
         ...(value.height===undefined?{}:{height:value.height}),
-        ...(value.resizable===undefined?{}:{resizable:value.resizable})
+        ...(value.resizable===undefined?{}:{resizable:value.resizable}),
+        ...(value.state===undefined?{}:{state:value.state})
     });
 }
 

package/src/cli/app-control.mjs

@@ -18,7 +18,7 @@ an application or change its profile. --output selects the capture filename;
 the other Arcane commands retain their existing output-format option.
 Inspect --request reads the complete parameter object, including shadowPath and
 optional documentGeneration. It cannot be combined with --selector.
-Key --request selects Tab (optionally shiftKey:true), Enter, or Space and the
+Key --request selects Tab (optionally shiftKey:true), Enter, Space, or Escape and the
 observed documentGeneration. Resize --request supplies native client width and
 height for a Normal window; its result includes the previous dimensions.
 `;

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

@@ -33,6 +33,7 @@ namespace Arcane.Core.Hosts.Windows
         public double? InitialClientWidth { get; set; }
         public double? InitialClientHeight { get; set; }
         public bool? Resizable { get; set; }
+        public string InitialWindowState { get; set; }
     }
 
     public static class ArcaneHost
@@ -130,6 +131,7 @@ namespace Arcane.Core.Hosts.Windows
         private bool browserProcessExited;
         private bool closing;
         private bool closeAllowed;
+        private WindowRestoreSnapshot fullscreenRestore;
 
         public ArcaneHostForm(ArcaneHostOptions options, Action<string> onDiagnostic,
             Action<Exception> onError = null)
@@ -138,6 +140,7 @@ namespace Arcane.Core.Hosts.Windows
             if (onDiagnostic == null) throw new ArgumentNullException("onDiagnostic");
             ValidateInitialDimension(options.InitialClientWidth, "InitialClientWidth");
             ValidateInitialDimension(options.InitialClientHeight, "InitialClientHeight");
+            if (options.InitialWindowState != null) ValidateWindowState(options.InitialWindowState);
             this.options = options;
             this.onDiagnostic = onDiagnostic;
             this.onError = onError;
@@ -160,9 +163,13 @@ namespace Arcane.Core.Hosts.Windows
 
         protected override void OnLoad(EventArgs args)
         {
-            // Apply the initial choice once. A composing launcher's Load handler
-            // can then restore its own saved state; later user sizing is untouched.
-            if (!started && !closing) ApplyInitialWindowSize();
+            // Apply the initial choices before the composing launcher's Load
+            // handler. Later app/user sizing remains application-owned.
+            if (!started && !closing)
+            {
+                ApplyInitialWindowSize();
+                if (options.InitialWindowState != null) ApplyWindowState(options.InitialWindowState);
+            }
             base.OnLoad(args);
             if (started || closing) return;
             started = true;
@@ -202,6 +209,263 @@ namespace Arcane.Core.Hosts.Windows
                 Math.Max(workArea.Top, Math.Min(Top, workArea.Bottom - Height)));
         }
 
+        private static void ValidateWindowState(string state)
+        {
+            if (state != "normal" && state != "maximized" && state != "fullscreen")
+                throw new ArgumentException("Select window state normal, maximized, or fullscreen.");
+        }
+
+        private FormWindowState CurrentWindowState()
+        {
+            if (!IsHandleCreated) return WindowState;
+            if (IsIconic(Handle)) return FormWindowState.Minimized;
+            return IsZoomed(Handle) ? FormWindowState.Maximized : FormWindowState.Normal;
+        }
+
+        private string WindowStateName()
+        {
+            FormWindowState state = CurrentWindowState();
+            if (state != FormWindowState.Normal) return state.ToString();
+            return fullscreenRestore != null && FormBorderStyle == FormBorderStyle.None
+                ? "Fullscreen" : "Normal";
+        }
+
+        private Dictionary<string, object> WindowStateRecord()
+        {
+            return new Dictionary<string, object>
+            {
+                { "platform", "windows" }, { "supported", true },
+                { "state", WindowStateName().ToLowerInvariant() }
+            };
+        }
+
+        private void ApplyWindowState(string state)
+        {
+            ValidateWindowState(state);
+            bool visible = IsHandleCreated && IsWindowVisible(Handle);
+            if (visible && state == WindowStateName().ToLowerInvariant()
+                && (state == "fullscreen" || fullscreenRestore == null)) return;
+            // Initial hidden configuration keeps ordinary startup behavior. A
+            // visible WinForms state setter can activate through ShowWindow.
+            WindowStateTransition transition = visible ? new WindowStateTransition(this) : null;
+            Exception mutationError = null;
+            try { ChangeWindowState(state); }
+            catch (Exception error)
+            {
+                mutationError = error;
+                throw;
+            }
+            finally
+            {
+                Exception cleanupError = transition == null ? null : transition.Release();
+                if (cleanupError != null)
+                {
+                    if (mutationError != null)
+                        throw new AggregateException("Window state change and activation-hook cleanup failed.",
+                            mutationError, cleanupError);
+                    throw cleanupError;
+                }
+            }
+        }
+
+        private void ChangeWindowState(string state)
+        {
+            if (state == "fullscreen")
+            {
+                Rectangle screen = Screen.FromControl(this).Bounds;
+                if (fullscreenRestore == null)
+                {
+                    fullscreenRestore = new WindowRestoreSnapshot(
+                        CurrentWindowState() == FormWindowState.Normal ? Bounds : RestoreBounds,
+                        FormBorderStyle, MinimizeBox, MaximizeBox, ControlBox);
+                }
+                // Retain the normal frame and bounds before removing chrome.
+                // This affects this window only: no activation or TopMost.
+                WindowState = FormWindowState.Normal;
+                FormBorderStyle = FormBorderStyle.None;
+                Bounds = screen;
+                return;
+            }
+
+            if (fullscreenRestore != null)
+            {
+                // Restore normal geometry before maximizing so WinForms keeps
+                // the same restore bounds for a later Normal selection.
+                WindowState = FormWindowState.Normal;
+                FormBorderStyle = fullscreenRestore.BorderStyle;
+                MinimizeBox = fullscreenRestore.MinimizeBox;
+                MaximizeBox = fullscreenRestore.MaximizeBox;
+                ControlBox = fullscreenRestore.ControlBox;
+                Bounds = fullscreenRestore.Bounds;
+                fullscreenRestore = null;
+            }
+            WindowState = state == "maximized" ? FormWindowState.Maximized : FormWindowState.Normal;
+        }
+
+        private string WindowStateResponse(Dictionary<string, object> request, string id, bool apply)
+        {
+            Dictionary<string, object> previous = WindowStateRecord();
+            object parameters;
+            request.TryGetValue("parameters", out parameters);
+            Dictionary<string, object> response = new Dictionary<string, object>
+            {
+                { "protocol", "arcane/1" }, { "type", "response" }, { "id", id }
+            };
+            try
+            {
+                if (apply)
+                {
+                    Dictionary<string, object> selection = parameters as Dictionary<string, object>;
+                    object state;
+                    if (selection == null || !selection.TryGetValue("state", out state) || !(state is string))
+                        throw new ArgumentException("Supply a window state selection.");
+                    ApplyWindowState((string)state);
+                }
+                response["ok"] = true;
+                response["result"] = WindowStateRecord();
+            }
+            catch (Exception error)
+            {
+                Dictionary<string, object> record = (Dictionary<string, object>)ArcaneHost.ErrorRecord(error,
+                    error is ArgumentException ? "INVALID_ARGUMENT" : "ARCANE_WINDOW_STATE_FAILED");
+                record["details"] = new Dictionary<string, object>
+                {
+                    { "requested", parameters }, { "previous", previous }, { "actual", WindowStateRecord() }
+                };
+                response["ok"] = false;
+                response["error"] = record;
+            }
+            return ArcaneHost.Serializer().Serialize(response);
+        }
+
+        private sealed class WindowRestoreSnapshot
+        {
+            internal readonly Rectangle Bounds;
+            internal readonly FormBorderStyle BorderStyle;
+            internal readonly bool MinimizeBox;
+            internal readonly bool MaximizeBox;
+            internal readonly bool ControlBox;
+
+            internal WindowRestoreSnapshot(Rectangle bounds, FormBorderStyle borderStyle,
+                bool minimizeBox, bool maximizeBox, bool controlBox)
+            {
+                Bounds = bounds;
+                BorderStyle = borderStyle;
+                MinimizeBox = minimizeBox;
+                MaximizeBox = maximizeBox;
+                ControlBox = controlBox;
+            }
+        }
+
+        private sealed class WindowStateTransition
+        {
+            private const int WhCbt = 5;
+            private const int HcbtActivate = 5;
+            private const int HcbtSetFocus = 9;
+            private delegate IntPtr HookProcedure(int code, IntPtr target, IntPtr details);
+            // A failed native unhook must never retain a collected delegate.
+            private static readonly HookProcedure callback = BeforeWindowChange;
+            [ThreadStatic] private static WindowStateTransition current;
+            [ThreadStatic] private static List<WindowStateTransition> pendingCleanup;
+            private readonly ArcaneHostForm owner;
+            private readonly WindowStateTransition previous;
+            private IntPtr hook;
+            private bool active;
+
+            internal WindowStateTransition(ArcaneHostForm owner)
+            {
+                this.owner = owner;
+                previous = current;
+                hook = SetWindowsHookEx(WhCbt, callback, IntPtr.Zero, GetCurrentThreadId());
+                if (hook == IntPtr.Zero)
+                {
+                    int code = Marshal.GetLastWin32Error();
+                    System.ComponentModel.Win32Exception error = new System.ComponentModel.Win32Exception(code);
+                    error.Data["operation"] = "SetWindowsHookExW";
+                    error.Data["nativeErrorCode"] = code;
+                    throw error;
+                }
+                active = true;
+                current = this;
+            }
+
+            private static IntPtr BeforeWindowChange(int code, IntPtr target, IntPtr details)
+            {
+                if (code == HcbtActivate || code == HcbtSetFocus)
+                {
+                    for (WindowStateTransition transition = current; transition != null; transition = transition.previous)
+                    {
+                        if (!transition.active || !transition.owner.IsHandleCreated) continue;
+                        IntPtr window = transition.owner.Handle;
+                        if (target == window || (code == HcbtSetFocus && IsChild(window, target)))
+                            return new IntPtr(1);
+                    }
+                }
+                return CallNextHookEx(IntPtr.Zero, code, target, details);
+            }
+
+            internal Exception Release()
+            {
+                // Stop vetoing immediately, even if the native unhook fails.
+                active = false;
+                if (current == this) current = previous;
+                if (hook == IntPtr.Zero) return null;
+                if (UnhookWindowsHookEx(hook))
+                {
+                    hook = IntPtr.Zero;
+                    if (pendingCleanup != null) pendingCleanup.Remove(this);
+                    return null;
+                }
+                int code = Marshal.GetLastWin32Error();
+                if (pendingCleanup == null) pendingCleanup = new List<WindowStateTransition>();
+                if (!pendingCleanup.Contains(this)) pendingCleanup.Add(this);
+                System.ComponentModel.Win32Exception error = new System.ComponentModel.Win32Exception(code);
+                error.Data["operation"] = "UnhookWindowsHookEx";
+                error.Data["nativeErrorCode"] = code;
+                return error;
+            }
+
+            internal static void ReleasePending(ArcaneHostForm owner)
+            {
+                if (pendingCleanup == null) return;
+                foreach (WindowStateTransition transition in pendingCleanup.ToArray())
+                {
+                    if (transition.owner != owner) continue;
+                    Exception error = transition.Release();
+                    if (error != null) owner.Report(error);
+                }
+            }
+
+            [DllImport("user32.dll", EntryPoint = "SetWindowsHookExW", SetLastError = true)]
+            private static extern IntPtr SetWindowsHookEx(int kind, HookProcedure procedure, IntPtr module, uint threadId);
+
+            [DllImport("user32.dll", SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            private static extern bool UnhookWindowsHookEx(IntPtr hook);
+
+            [DllImport("user32.dll")]
+            private static extern IntPtr CallNextHookEx(IntPtr hook, int code, IntPtr target, IntPtr details);
+
+            [DllImport("user32.dll")]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            private static extern bool IsChild(IntPtr parent, IntPtr child);
+
+            [DllImport("kernel32.dll")]
+            private static extern uint GetCurrentThreadId();
+        }
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool IsWindowVisible(IntPtr window);
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool IsIconic(IntPtr window);
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool IsZoomed(IntPtr window);
+
         private async Task InitializeAsync()
         {
             try
@@ -296,12 +560,15 @@ 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 (requestId != null && EnvelopeString(envelope, "protocol") == "arcane/1"
-                    && EnvelopeString(envelope, "method") == "window.setTheme")
+                    && (method == "window.setTheme" || method == "window.state" || method == "window.setState"))
                 {
                     // This method belongs to this exact window, not the Core
                     // child or a machine-wide appearance service.
-                    string response = WindowThemeResponse(envelope, requestId);
+                    string response = method == "window.setTheme"
+                        ? WindowThemeResponse(envelope, requestId)
+                        : WindowStateResponse(envelope, requestId, method == "window.setState");
                     pending.Enqueue(
                         new CoreDelivery(documentGeneration, response)
                     );
@@ -747,6 +1014,7 @@ namespace Arcane.Core.Hosts.Windows
             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();
+            WindowStateTransition.ReleasePending(this);
             shutdown = DrainAndCloseAsync();
             shutdown.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
         }

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

@@ -98,6 +98,7 @@ namespace Arcane.Core.Hosts.Windows
                     InitialClientWidth = OptionalWindowDimension(windowOptions, "width"),
                     InitialClientHeight = OptionalWindowDimension(windowOptions, "height"),
                     Resizable = OptionalWindowResizable(windowOptions),
+                    InitialWindowState = OptionalWindowState(windowOptions),
                     IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
                     AppControlEndpoint = appControl == null ? null : RequiredString(appControl, "endpoint"),
@@ -210,6 +211,14 @@ namespace Arcane.Core.Hosts.Windows
             throw new FormatException("The native manifest needs a boolean at window.resizable.");
         }
 
+        private static string OptionalWindowState(Dictionary<string, object> window)
+        {
+            object value;
+            if (window == null || !window.TryGetValue("state", out value)) return null;
+            if (value is string) return (string)value;
+            throw new FormatException("The native manifest needs a string at window.state.");
+        }
+
         private static string QuoteArgument(string value)
         {
             // Windows command-line escaping is transport-local. The child

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

@@ -148,7 +148,7 @@ namespace Arcane.Core.Hosts.Windows
         {
             return new Dictionary<string, object>
             {
-                { "title", Text }, { "state", WindowState.ToString() },
+                { "title", Text }, { "state", WindowStateName() },
                 { "width", ClientSize.Width }, { "height", ClientSize.Height }
             };
         }
@@ -252,8 +252,8 @@ namespace Arcane.Core.Hosts.Windows
         {
             object value;
             string key = parameters.TryGetValue("key", out value) ? value as string : null;
-            if (key != "Tab" && key != "Enter" && key != "Space")
-                throw new ArgumentException("key must be Tab, Enter, or Space.");
+            if (key != "Tab" && key != "Enter" && key != "Space" && key != "Escape")
+                throw new ArgumentException("key must be Tab, Enter, Space, or Escape.");
             bool shiftKey = false;
             if (parameters.TryGetValue("shiftKey", out value))
             {
@@ -263,14 +263,14 @@ namespace Arcane.Core.Hosts.Windows
             if (shiftKey && key != "Tab") throw new ArgumentException("shiftKey is supported only with Tab.");
             Dictionary<string, object> down = new Dictionary<string, object>
             {
-                { "type", key == "Tab" ? "rawKeyDown" : "keyDown" },
+                { "type", key == "Tab" || key == "Escape" ? "rawKeyDown" : "keyDown" },
                 { "key", key == "Space" ? " " : key }, { "code", key },
-                { "windowsVirtualKeyCode", key == "Tab" ? 9 : key == "Enter" ? 13 : 32 },
+                { "windowsVirtualKeyCode", key == "Tab" ? 9 : key == "Enter" ? 13 : key == "Escape" ? 27 : 32 },
                 { "modifiers", shiftKey ? 8 : 0 }
             };
             Dictionary<string, object> up = new Dictionary<string, object>(down);
             up["type"] = "keyUp";
-            if (key != "Tab")
+            if (key == "Enter" || key == "Space")
             {
                 down["text"] = key == "Enter" ? "\r" : " ";
                 down["unmodifiedText"] = down["text"];
@@ -345,7 +345,7 @@ namespace Arcane.Core.Hosts.Windows
 
         private void RequireAppControlNormalWindow()
         {
-            if (WindowState == FormWindowState.Normal) return;
+            if (WindowStateName() == "Normal") return;
             InvalidOperationException error = new InvalidOperationException("App-control resize requires a Normal window.");
             error.Data["reason"] = "unsupported-window-state";
             error.Data["supportedWindowState"] = "Normal";

package/src/core/repositories.mjs

@@ -45,7 +45,7 @@ export function resolveArcaneDataPaths({dataRoot} = {}) {
 
 /** One connected checkout, composed into an application's own Core service. */
 export function createRepositoryWorkspace(
-    {name, directory, dataRoot, remote, branch, longPaths, gitIdentity, onEvent, run = runProcess} = {}
+    {name, directory, dataRoot, remote, branch, longPaths, cloneIdentity = {}, gitIdentity, onEvent, run = runProcess} = {}
 ) {
     let selected = directory;
     if (selected === undefined) {
@@ -62,6 +62,15 @@ export function createRepositoryWorkspace(
         throw new TypeError('longPaths must be a boolean when supplied.');
     }
     if (!is.function(run)) throw new TypeError('run must implement the SDK process adapter.');
+    const {name: cloneName, email: cloneEmail} = cloneIdentity;
+    const cloneConfiguration = [];
+    for (const [field, value] of Object.entries({name: cloneName, email: cloneEmail})) {
+        if (value === undefined) continue;
+        if (!is.string(value) || !value.isWellFormed() || value.includes('\0')) {
+            throw new TypeError(`cloneIdentity.${field} must be text representable as a native process argument.`);
+        }
+        cloneConfiguration.push('--config', `user.${field}=${value}`);
+    }
     const execute = createGitIdentityRunner(run, gitIdentity);
     const repositoryDirectory = path.resolve(selected);
     const pending = new Set();
@@ -108,6 +117,7 @@ export function createRepositoryWorkspace(
         if (process.platform === 'win32' && longPaths !== undefined) {
             arguments_.push('--config', `core.longpaths=${longPaths}`);
         }
+        arguments_.push(...cloneConfiguration);
         if (branch !== undefined) arguments_.push('--branch', branch);
         arguments_.push('--', remote, repositoryDirectory);
         const result = await prepareRun(