improve: add GetStringArrayArg helper and expand test coverage

- Add GetStringArrayArg protected helper to NodeCapabilityBase that
  extracts a string array from JsonElement args, filtering out null
  and whitespace-only strings; returns Array.Empty when absent or
  wrong type.

- Simplify SystemCapability.HandleWhich to use GetStringArrayArg
  instead of 22 lines of manual JSON array parsing with fully-qualified
  System.Text.Json.JsonValueKind references.

- Add 6 GetStringArrayArg tests to NodeCapabilitiesTests covering:
  present array, missing property, non-array type, whitespace filtering,
  default JsonElement, and mixed element types.

- Add 8 new WindowsNodeClient tests covering: SetPermission (set/
  overwrite), DisconnectAsync raises Disconnected status,
  ProcessMessageAsync edge cases (invalid JSON, no type field, unknown
  type), GatewayUrl, NodeId null before connection.

Test results: 573 passed, 20 skipped (Shared.Tests); 122 passed (Tray.Tests).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

src/OpenClaw.Shared/Capabilities/SystemCapability.cs

@@ -91,34 +91,19 @@ private Task<NodeInvokeResponse> HandleNotifyAsync(NodeInvokeRequest request)
 
     private NodeInvokeResponse HandleWhich(NodeInvokeRequest request)
     {
-        var bins = new List<string>();
-        if (request.Args.ValueKind != System.Text.Json.JsonValueKind.Undefined &&
-            request.Args.TryGetProperty("bins", out var binsEl) &&
-            binsEl.ValueKind == System.Text.Json.JsonValueKind.Array)
-        {
-            foreach (var item in binsEl.EnumerateArray())
-            {
-                if (item.ValueKind == System.Text.Json.JsonValueKind.String)
-                {
-                    var bin = item.GetString()?.Trim();
-                    if (!string.IsNullOrEmpty(bin))
-                        bins.Add(bin);
-                }
-            }
-        }
-        
-        if (bins.Count == 0)
+        var bins = GetStringArrayArg(request.Args, "bins");
+        if (bins.Length == 0)
             return Error("Missing bins parameter");
-        
+
         var found = new Dictionary<string, string>();
         foreach (var bin in bins)
         {
             var resolved = ResolveExecutable(bin);
             if (resolved != null)
                 found[bin] = resolved;
         }
-        
-        Logger.Info($"system.which: queried {bins.Count} bins, found {found.Count}");
+
+        Logger.Info($"system.which: queried {bins.Length} bins, found {found.Count}");
         return Success(new { bins = found });
     }
 

src/OpenClaw.Shared/NodeCapabilities.cs

@@ -138,6 +138,31 @@ protected bool GetBoolArg(JsonElement args, string name, bool defaultValue = fal
         }
         return defaultValue;
     }
+
+    /// <summary>
+    /// Get a string array from a JSON array property. Elements that are not strings or are
+    /// whitespace-only are excluded. Returns an empty array if the property is absent,
+    /// not an array, or the args element is missing.
+    /// </summary>
+    protected string[] GetStringArrayArg(JsonElement args, string name)
+    {
+        if (args.ValueKind == JsonValueKind.Undefined || args.ValueKind == JsonValueKind.Null)
+            return Array.Empty<string>();
+        if (!args.TryGetProperty(name, out var prop) || prop.ValueKind != JsonValueKind.Array)
+            return Array.Empty<string>();
+
+        var list = new List<string>();
+        foreach (var item in prop.EnumerateArray())
+        {
+            if (item.ValueKind == JsonValueKind.String)
+            {
+                var s = item.GetString();
+                if (!string.IsNullOrWhiteSpace(s))
+                    list.Add(s);
+            }
+        }
+        return list.Count > 0 ? list.ToArray() : Array.Empty<string>();
+    }
 }
 
 /// <summary>

tests/OpenClaw.Shared.Tests/NodeCapabilitiesTests.cs

@@ -26,6 +26,7 @@ public override Task<NodeInvokeResponse> ExecuteAsync(NodeInvokeRequest request)
         public string? PubGetStringArg(JsonElement args, string name, string? def = null) => GetStringArg(args, name, def);
         public int PubGetIntArg(JsonElement args, string name, int def = 0) => GetIntArg(args, name, def);
         public bool PubGetBoolArg(JsonElement args, string name, bool def = false) => GetBoolArg(args, name, def);
+        public string[] PubGetStringArrayArg(JsonElement args, string name) => GetStringArrayArg(args, name);
     }
 
     private static JsonElement Parse(string json)
@@ -161,6 +162,57 @@ public void GetStringArg_HandlesDefaultJsonElement()
         Assert.Null(cap.PubGetStringArg(args, "url"));
         Assert.Equal("def", cap.PubGetStringArg(args, "url", "def"));
     }
+
+    [Fact]
+    public void GetStringArrayArg_ReturnsValues_WhenPresent()
+    {
+        var cap = new TestCapability();
+        var args = Parse("""{"bins":["echo","hostname","curl"]}""");
+        var result = cap.PubGetStringArrayArg(args, "bins");
+        Assert.Equal(new[] { "echo", "hostname", "curl" }, result);
+    }
+
+    [Fact]
+    public void GetStringArrayArg_ReturnsEmpty_WhenPropertyMissing()
+    {
+        var cap = new TestCapability();
+        var args = Parse("""{}""");
+        Assert.Empty(cap.PubGetStringArrayArg(args, "bins"));
+    }
+
+    [Fact]
+    public void GetStringArrayArg_ReturnsEmpty_WhenNotAnArray()
+    {
+        var cap = new TestCapability();
+        var args = Parse("""{"bins":"echo"}""");
+        Assert.Empty(cap.PubGetStringArrayArg(args, "bins"));
+    }
+
+    [Fact]
+    public void GetStringArrayArg_ExcludesWhitespaceOnlyElements()
+    {
+        var cap = new TestCapability();
+        var args = Parse("""{"bins":["echo","  ","hostname",""]}""");
+        var result = cap.PubGetStringArrayArg(args, "bins");
+        Assert.Equal(new[] { "echo", "hostname" }, result);
+    }
+
+    [Fact]
+    public void GetStringArrayArg_ReturnsEmpty_WhenArgsIsDefaultElement()
+    {
+        var cap = new TestCapability();
+        JsonElement args = default;
+        Assert.Empty(cap.PubGetStringArrayArg(args, "bins"));
+    }
+
+    [Fact]
+    public void GetStringArrayArg_IgnoresNonStringArrayElements()
+    {
+        var cap = new TestCapability();
+        var args = Parse("""{"bins":["echo",42,true,"hostname",null]}""");
+        var result = cap.PubGetStringArrayArg(args, "bins");
+        Assert.Equal(new[] { "echo", "hostname" }, result);
+    }
 }
 
 public class NodeInvokeResponseTests

tests/OpenClaw.Shared.Tests/WindowsNodeClientTests.cs

@@ -438,4 +438,197 @@ public void FullDeviceId_IsNonEmpty()
                 Directory.Delete(dataPath, true);
         }
     }
+
+    [Fact]
+    public void SetPermission_UpdatesRegistrationPermissions()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+
+            client.SetPermission("camera.capture", true);
+            client.SetPermission("screen.record", false);
+
+            var registrationField = typeof(WindowsNodeClient).GetField(
+                "_registration",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            var reg = (NodeRegistration)registrationField!.GetValue(client)!;
+
+            Assert.True(reg.Permissions.ContainsKey("camera.capture"));
+            Assert.True(reg.Permissions["camera.capture"]);
+            Assert.True(reg.Permissions.ContainsKey("screen.record"));
+            Assert.False(reg.Permissions["screen.record"]);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public void SetPermission_OverwritesPreviousValue()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+
+            client.SetPermission("camera.capture", true);
+            client.SetPermission("camera.capture", false);
+
+            var registrationField = typeof(WindowsNodeClient).GetField(
+                "_registration",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            var reg = (NodeRegistration)registrationField!.GetValue(client)!;
+
+            Assert.False(reg.Permissions["camera.capture"]);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public async Task DisconnectAsync_RaisesDisconnectedStatus()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+
+            var statusChanges = new List<ConnectionStatus>();
+            client.StatusChanged += (_, s) => statusChanges.Add(s);
+
+            await client.DisconnectAsync();
+
+            Assert.Contains(ConnectionStatus.Disconnected, statusChanges);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public async Task ProcessMessageAsync_InvalidJson_DoesNotThrow()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+
+            var processMethod = typeof(WindowsNodeClient).GetMethod(
+                "ProcessMessageAsync",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(processMethod);
+
+            var task = (Task)processMethod!.Invoke(client, ["not-valid-json!!"])!;
+            var ex = await Record.ExceptionAsync(() => task);
+            Assert.Null(ex);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public async Task ProcessMessageAsync_NoTypeField_DoesNotThrow()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+
+            var processMethod = typeof(WindowsNodeClient).GetMethod(
+                "ProcessMessageAsync",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+
+            var task = (Task)processMethod!.Invoke(client, ["""{"ok":true}"""])!;
+            var ex = await Record.ExceptionAsync(() => task);
+            Assert.Null(ex);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public async Task ProcessMessageAsync_UnknownMessageType_DoesNotThrow()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+
+            var processMethod = typeof(WindowsNodeClient).GetMethod(
+                "ProcessMessageAsync",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+
+            var task = (Task)processMethod!.Invoke(client, ["""{"type":"unknown_msg_type"}"""])!;
+            var ex = await Record.ExceptionAsync(() => task);
+            Assert.Null(ex);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public void GatewayUrl_ReturnsDisplayUrl()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+            Assert.Equal("ws://localhost:18789", client.GatewayUrl);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
+
+    [Fact]
+    public void NodeId_IsNullBeforeConnection()
+    {
+        var dataPath = Path.Combine(Path.GetTempPath(), $"openclaw-node-test-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dataPath);
+
+        try
+        {
+            using var client = new WindowsNodeClient("ws://localhost:18789", "test-token", dataPath);
+            Assert.Null(client.NodeId);
+        }
+        finally
+        {
+            if (Directory.Exists(dataPath))
+                Directory.Delete(dataPath, true);
+        }
+    }
 }