Validate MXC SDK 0.7.0 on Windows build 26200.8728

src/OpenClaw.Shared/Capabilities/SystemCapability.cs

@@ -275,11 +275,15 @@ private NodeInvokeResponse HandleRunPrepare(NodeInvokeRequest request)
 
         var command = argv[0];
         var rawCommand = GetStringArg(request.Args, "rawCommand");
+        var requestedShell = GetStringArg(request.Args, "shell");
+        var effectiveShell = _commandRunner?.ResolveEffectiveShell(requestedShell)
+            ?? ResolveDefaultEffectiveShell(requestedShell);
         var cwd = GetStringArg(request.Args, "cwd");
         var agentId = GetStringArg(request.Args, "agentId");
         var sessionKey = request.SessionKey ?? GetStringArg(request.Args, "sessionKey");
 
-        Logger.Info($"system.run.prepare: {rawCommand} (cwd={cwd ?? "default"})");
+        Logger.Info(
+            $"system.run.prepare: {rawCommand} (shell={effectiveShell}, requestedShell={requestedShell ?? "auto"}, cwd={cwd ?? "default"})");
 
         return Success(new
         {
@@ -289,11 +293,27 @@ private NodeInvokeResponse HandleRunPrepare(NodeInvokeRequest request)
                 argv,
                 cwd,
                 rawCommand,
+                requestedShell = string.IsNullOrWhiteSpace(requestedShell) ? null : requestedShell.Trim(),
+                effectiveShell,
                 agentId,
                 sessionKey
             }
         });
     }
+
+    private static string ResolveDefaultEffectiveShell(string? requestedShell)
+    {
+        if (string.IsNullOrWhiteSpace(requestedShell))
+            return "powershell";
+
+        return requestedShell.Trim().ToLowerInvariant() switch
+        {
+            "cmd" => "cmd",
+            "pwsh" => "pwsh",
+            "powershell" => "powershell",
+            _ => "powershell",
+        };
+    }
 
     private async Task<NodeInvokeResponse> HandleRunAsync(NodeInvokeRequest request)
     {
@@ -400,50 +420,35 @@ private async Task<NodeInvokeResponse> HandleRunAsync(NodeInvokeRequest request)
         var fullCommand = args != null
             ? FormatExecCommand([command!, ..args])
             : command;
+        var requestedShell = string.IsNullOrWhiteSpace(shell) ? null : shell.Trim();
+        var effectiveShell = _commandRunner.ResolveEffectiveShell(requestedShell);
+        var approvedHostFallbackShell = _commandRunner is IHostFallbackAwareCommandRunner fallbackAwareRunner
+            ? fallbackAwareRunner.ResolveHostFallbackShellForApproval(requestedShell, effectiveShell)
+            : null;
 
-        Logger.Info($"system.run: {fullCommand} (shell={shell ?? "auto"}, timeout={timeoutMs}ms)");
+        Logger.Info($"system.run: {fullCommand} (shell={effectiveShell}, requestedShell={shell ?? "auto"}, timeout={timeoutMs}ms)");
 
         // Check exec approval policy
         if (_approvalPolicy != null)
         {
-            var approval = _approvalPolicy.Evaluate(fullCommand, shell);
-            var approvalCheck = await EnsureApprovedAsync(fullCommand, shell, approval, sessionKey, correlationId);
-            if (!approvalCheck.Allowed)
-            {
-                Logger.Warn($"system.run DENIED: {fullCommand} ({approval.Reason})");
-                return Error($"Command denied by exec policy: {approval.Reason}");
-            }
-
-            var outerApprovalCoversNestedTargets =
-                approvalCheck.PromptDecisionKind != null ||
-                IsExactAllowRuleForCommand(approval, fullCommand);
-
-            var parseResult = ExecShellWrapperParser.Expand(fullCommand, shell);
-            if (!string.IsNullOrWhiteSpace(parseResult.Error))
-            {
-                Logger.Warn($"system.run DENIED: {fullCommand} ({parseResult.Error})");
-                return Error($"Command denied by exec policy: {parseResult.Error}");
-            }
+            var approvalError = await EnsureCommandAndNestedTargetsApprovedAsync(
+                fullCommand,
+                effectiveShell,
+                sessionKey,
+                correlationId);
+            if (approvalError != null)
+                return approvalError;
 
-            foreach (var target in parseResult.Targets)
+            if (!string.IsNullOrWhiteSpace(approvedHostFallbackShell)
+                && !string.Equals(approvedHostFallbackShell, effectiveShell, StringComparison.OrdinalIgnoreCase))
             {
-                var innerApproval = _approvalPolicy.Evaluate(target.Command, target.Shell);
-                if (outerApprovalCoversNestedTargets && !IsExplicitDeny(innerApproval))
-                {
-                    if (!innerApproval.Allowed)
-                    {
-                        Logger.Info(
-                            $"system.run nested approval covered by approved wrapper: {target.Command} ({innerApproval.Reason})");
-                    }
-                    continue;
-                }
-
-                var innerApprovalCheck = await EnsureApprovedAsync(target.Command, target.Shell, innerApproval, sessionKey, correlationId);
-                if (!innerApprovalCheck.Allowed)
-                {
-                    Logger.Warn($"system.run DENIED: {target.Command} ({innerApproval.Reason})");
-                    return Error($"Command denied by exec policy: {innerApproval.Reason}");
-                }
+                approvalError = await EnsureCommandAndNestedTargetsApprovedAsync(
+                    fullCommand,
+                    approvedHostFallbackShell,
+                    sessionKey,
+                    correlationId);
+                if (approvalError != null)
+                    return approvalError;
             }
         }
 
@@ -453,10 +458,12 @@ private async Task<NodeInvokeResponse> HandleRunAsync(NodeInvokeRequest request)
             {
                 Command = command,
                 Args = args,
-                Shell = shell,
+                Shell = requestedShell,
                 Cwd = cwd,
                 TimeoutMs = timeoutMs,
-                Env = env
+                Env = env,
+                ApprovedEffectiveShell = effectiveShell,
+                ApprovedHostFallbackShell = approvedHostFallbackShell
             });
 
             return Success(new
@@ -531,6 +538,63 @@ private async Task<ExecApprovalCheckResult> EnsureApprovedAsync(
         return new ExecApprovalCheckResult(true, decision.Kind);
     }
 
+    private async Task<NodeInvokeResponse?> EnsureCommandAndNestedTargetsApprovedAsync(
+        string fullCommand,
+        string? shell,
+        string? sessionKey,
+        string correlationId)
+    {
+        if (_approvalPolicy == null)
+            return null;
+
+        var approval = _approvalPolicy.Evaluate(fullCommand, shell);
+        var approvalCheck = await EnsureApprovedAsync(fullCommand, shell, approval, sessionKey, correlationId);
+        if (!approvalCheck.Allowed)
+        {
+            Logger.Warn($"system.run DENIED: {fullCommand} ({approval.Reason})");
+            return Error($"Command denied by exec policy: {approval.Reason}");
+        }
+
+        var outerApprovalCoversNestedTargets =
+            approvalCheck.PromptDecisionKind != null ||
+            IsExactAllowRuleForCommand(approval, fullCommand);
+
+        var parseResult = ExecShellWrapperParser.Expand(fullCommand, shell);
+        if (!string.IsNullOrWhiteSpace(parseResult.Error))
+        {
+            Logger.Warn($"system.run DENIED: {fullCommand} ({parseResult.Error})");
+            return Error($"Command denied by exec policy: {parseResult.Error}");
+        }
+
+        foreach (var target in parseResult.Targets)
+        {
+            var innerApproval = _approvalPolicy.Evaluate(target.Command, target.Shell);
+            if (outerApprovalCoversNestedTargets && !IsExplicitDeny(innerApproval))
+            {
+                if (!innerApproval.Allowed)
+                {
+                    Logger.Info(
+                        $"system.run nested approval covered by approved wrapper: {target.Command} ({innerApproval.Reason})");
+                }
+                continue;
+            }
+
+            var innerApprovalCheck = await EnsureApprovedAsync(
+                target.Command,
+                target.Shell,
+                innerApproval,
+                sessionKey,
+                correlationId);
+            if (!innerApprovalCheck.Allowed)
+            {
+                Logger.Warn($"system.run DENIED: {target.Command} ({innerApproval.Reason})");
+                return Error($"Command denied by exec policy: {innerApproval.Reason}");
+            }
+        }
+
+        return null;
+    }
+
     private static bool CanPersistExactAllowRule(string command) =>
         !string.IsNullOrWhiteSpace(command) &&
         command.IndexOfAny(['*', '?']) < 0;

src/OpenClaw.Shared/ICommandRunner.cs

@@ -35,6 +35,20 @@ public class CommandRequest
 
     /// <summary>Additional environment variables</summary>
     public Dictionary<string, string>? Env { get; set; }
+
+    /// <summary>
+    /// Optional effective shell that already passed shell-scoped approval.
+    /// Dynamic runners must execute this shell, or a separately approved host
+    /// fallback shell, so live settings cannot change the approved boundary.
+    /// </summary>
+    public string? ApprovedEffectiveShell { get; set; }
+
+    /// <summary>
+    /// Optional host fallback shell that has already passed shell-scoped approval.
+    /// Sandboxed runners use this only when a compatibility fallback would execute
+    /// a different host shell than the sandbox effective shell.
+    /// </summary>
+    public string? ApprovedHostFallbackShell { get; set; }
 }
 
 /// <summary>
@@ -57,7 +71,39 @@ public interface ICommandRunner
 {
     /// <summary>Human-readable name of this runner (e.g., "local", "docker", "wsl")</summary>
     string Name { get; }
+
+    /// <summary>
+    /// Resolve the shell that will actually execute the request. Approval checks
+    /// must use this value so shell-scoped rules cannot approve one shell while
+    /// the runner executes another.
+    /// </summary>
+    string ResolveEffectiveShell(string? requestedShell)
+    {
+        if (string.IsNullOrWhiteSpace(requestedShell))
+            return "powershell";
+
+        return requestedShell.Trim().ToLowerInvariant() switch
+        {
+            "cmd" => "cmd",
+            "pwsh" => "pwsh",
+            "powershell" => "powershell",
+            _ => "powershell",
+        };
+    }
 
     /// <summary>Execute a command and return the result.</summary>
     Task<CommandResult> RunAsync(CommandRequest request, CancellationToken ct = default);
 }
+
+/// <summary>
+/// Optional contract for runners that may preserve compatibility through an
+/// uncontained host fallback with a shell different from their sandbox shell.
+/// </summary>
+public interface IHostFallbackAwareCommandRunner : ICommandRunner
+{
+    /// <summary>
+    /// Returns the host fallback shell that needs separate approval, or null when
+    /// fallback cannot change the already-approved effective shell.
+    /// </summary>
+    string? ResolveHostFallbackShellForApproval(string? requestedShell, string effectiveShell);
+}

src/OpenClaw.Shared/LocalCommandRunner.cs

@@ -7,7 +7,7 @@
 namespace OpenClaw.Shared;
 
 /// <summary>
-/// Executes commands locally via Process.Start (pwsh.exe / cmd.exe).
+/// Executes commands locally via Process.Start (pwsh.exe / powershell.exe / cmd.exe).
 /// This is the default runner. Swap with DockerCommandRunner, WslCommandRunner, etc.
 /// </summary>
 public class LocalCommandRunner : ICommandRunner
@@ -22,6 +22,8 @@ public LocalCommandRunner(IOpenClawLogger? logger = null)
     {
         _logger = logger ?? NullLogger.Instance;
     }
+
+    public string ResolveEffectiveShell(string? requestedShell) => ResolveEffectiveShellName(requestedShell);
 
     public async Task<CommandResult> RunAsync(CommandRequest request, CancellationToken ct = default)
     {
@@ -232,9 +234,10 @@ private static void ValidateDirectExecutable(string executable)
                 $"Direct-argv mode cannot guarantee argv fidelity for batch scripts: {executable}", nameof(executable));
     }
 
-    private static (string fileName, string arguments) BuildProcessArgs(CommandRequest request)
+    internal static (string fileName, string arguments) BuildProcessArgs(CommandRequest request, string? pathEnvVar = null)
     {
-        var shell = request.Shell ?? "powershell";
+        var defaultShell = string.IsNullOrWhiteSpace(request.Shell);
+        var shell = ResolveEffectiveShellName(request.Shell, pathEnvVar);
         var command = request.Command;
         var isCmd = shell.Equals("cmd", StringComparison.OrdinalIgnoreCase);
 
@@ -249,8 +252,66 @@ private static (string fileName, string arguments) BuildProcessArgs(CommandReque
         if (isCmd)
             return ("cmd.exe", $"/C {command}");
         if (shell.Equals("pwsh", StringComparison.OrdinalIgnoreCase))
-            return ("pwsh.exe", $"-NoProfile -NonInteractive -Command {command}");
-        return ("powershell.exe", $"-NoProfile -NonInteractive -Command {command}");
+        {
+            var pwshPath = ResolveOnPath("pwsh.exe", pathEnvVar);
+            if (pwshPath is not null || !defaultShell)
+                return (pwshPath ?? "pwsh.exe", $"-NoProfile -NonInteractive -Command {command}");
+        }
+
+        return (ResolveWindowsPowerShellExe(), $"-NoProfile -NonInteractive -Command {command}");
+    }
+
+    internal static string ResolveEffectiveShellName(string? requestedShell)
+        => ResolveEffectiveShellName(requestedShell, pathEnvVar: null);
+
+    private static string ResolveEffectiveShellName(string? requestedShell, string? pathEnvVar)
+    {
+        if (!string.IsNullOrWhiteSpace(requestedShell))
+        {
+            return requestedShell.Trim().ToLowerInvariant() switch
+            {
+                "cmd" => "cmd",
+                "pwsh" => "pwsh",
+                "powershell" => "powershell",
+                _ => "powershell",
+            };
+        }
+
+        return "powershell";
+    }
+
+    private static string? ResolveOnPath(string executableName, string? pathEnvVar = null)
+    {
+        var path = pathEnvVar
+            ?? Environment.GetEnvironmentVariable("PATH")
+            ?? Environment.GetEnvironmentVariable("Path");
+        if (string.IsNullOrWhiteSpace(path))
+            return null;
+
+        foreach (var dir in path.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+        {
+            try
+            {
+                var candidate = Path.Combine(dir, executableName);
+                if (File.Exists(candidate))
+                    return candidate;
+            }
+            catch
+            {
+                // Ignore malformed PATH entries.
+            }
+        }
+
+        return null;
+    }
+
+    private static string ResolveWindowsPowerShellExe()
+    {
+        var systemRoot = Environment.GetEnvironmentVariable("SystemRoot")
+            ?? Environment.GetEnvironmentVariable("windir");
+        return string.IsNullOrWhiteSpace(systemRoot)
+            ? "powershell.exe"
+            : Path.Combine(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
     }
 
     /// <summary>