From 60d59af4698d6069299e918384c6842d821e05ea Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 19 Jan 2026 11:54:46 +0000
Subject: [PATCH 1/6] Initial plan


From 4f38ff52c1ff77db286e3fd499b5a8c6634c6e4e Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 19 Jan 2026 12:06:05 +0000
Subject: [PATCH 2/6] Add --log-for human|machine flag for LLM/agent-friendly
 output

Co-authored-by: waldekmastykarz <11164679+waldekmastykarz@users.noreply.github.com>
---
 .../Proxy/IProxyConfiguration.cs              |   9 +
 DevProxy/Commands/DevProxyCommand.cs          |  16 ++
 DevProxy/Commands/DevProxyConfigOptions.cs    |  24 +++
 .../Extensions/ILoggingBuilderExtensions.cs   |  36 +++-
 DevProxy/Logging/MachineConsoleFormatter.cs   | 193 ++++++++++++++++++
 .../Logging/ProxyConsoleFormatterOptions.cs   |   3 +
 DevProxy/Proxy/ProxyConfiguration.cs          |   2 +
 schemas/v2.1.0/rc.schema.json                 |   8 +
 8 files changed, 284 insertions(+), 7 deletions(-)
 create mode 100644 DevProxy/Logging/MachineConsoleFormatter.cs

diff --git a/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs b/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs
index ab6d084f..6171dccd 100644
--- a/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs
+++ b/DevProxy.Abstractions/Proxy/IProxyConfiguration.cs
@@ -18,6 +18,14 @@ public enum ReleaseType
     Beta
 }
 
+public enum LogFor
+{
+    [EnumMember(Value = "human")]
+    Human,
+    [EnumMember(Value = "machine")]
+    Machine
+}
+
 public interface IProxyConfiguration
 {
     int ApiPort { get; set; }
@@ -29,6 +37,7 @@ public interface IProxyConfiguration
     IEnumerable<MockRequestHeader>? FilterByHeaders { get; }
     bool InstallCert { get; set; }
     string? IPAddress { get; set; }
+    LogFor LogFor { get; }
     LogLevel LogLevel { get; }
     ReleaseType NewVersionNotification { get; }
     bool NoFirstRun { get; set; }
diff --git a/DevProxy/Commands/DevProxyCommand.cs b/DevProxy/Commands/DevProxyCommand.cs
index e3db039b..8d297373 100644
--- a/DevProxy/Commands/DevProxyCommand.cs
+++ b/DevProxy/Commands/DevProxyCommand.cs
@@ -37,6 +37,7 @@ sealed class DevProxyCommand : RootCommand
     internal const string TimeoutOptionName = "--timeout";
     internal const string DiscoverOptionName = "--discover";
     internal const string EnvOptionName = "--env";
+    internal const string LogForOptionName = "--log-for";
 
     private static readonly string[] globalOptions = ["--version"];
     private static readonly string[] helpOptions = ["--help", "-h", "/h", "-?", "/?"];
@@ -353,6 +354,20 @@ private void ConfigureCommand()
             }
         });
 
+        var logForOption = new Option<LogFor?>(LogForOptionName)
+        {
+            Description = $"Target audience for log output. Allowed values: {string.Join(", ", Enum.GetNames<LogFor>())}",
+            HelpName = "log-for",
+            Recursive = true
+        };
+        logForOption.Validators.Add(input =>
+        {
+            if (!Enum.TryParse<LogFor>(input.Tokens[0].Value, true, out _))
+            {
+                input.AddError($"{input.Tokens[0].Value} is not a valid log-for value. Allowed values are: {string.Join(", ", Enum.GetNames<LogFor>())}");
+            }
+        });
+
         var options = new List<Option>
         {
             apiPortOption,
@@ -362,6 +377,7 @@ private void ConfigureCommand()
             envOption,
             installCertOption,
             ipAddressOption,
+            logForOption,
             logLevelOption,
             noFirstRunOption,
             portOption,
diff --git a/DevProxy/Commands/DevProxyConfigOptions.cs b/DevProxy/Commands/DevProxyConfigOptions.cs
index 7b0264b3..e05fc1f3 100644
--- a/DevProxy/Commands/DevProxyConfigOptions.cs
+++ b/DevProxy/Commands/DevProxyConfigOptions.cs
@@ -1,3 +1,4 @@
+using DevProxy.Abstractions.Proxy;
 using DevProxy.Abstractions.Utils;
 using System.CommandLine;
 using System.CommandLine.Parsing;
@@ -20,6 +21,7 @@ public string? ConfigFile
     public int? ApiPort => _parseResult?.GetValueOrDefault<int?>(DevProxyCommand.ApiPortOptionName);
     public bool Discover => _parseResult?.GetValueOrDefault<bool?>(DevProxyCommand.DiscoverOptionName) ?? false;
     public string? IPAddress => _parseResult?.GetValueOrDefault<string?>(DevProxyCommand.IpAddressOptionName);
+    public LogFor? LogFor => _parseResult?.GetValueOrDefault<LogFor?>(DevProxyCommand.LogForOptionName);
     public LogLevel? LogLevel => _parseResult?.GetValueOrDefault<LogLevel?>(DevProxyCommand.LogLevelOptionName);
 
     public List<string>? UrlsToWatch
@@ -114,6 +116,27 @@ public DevProxyConfigOptions()
                 }
             }
         };
+
+        var logForOption = new Option<LogFor?>(DevProxyCommand.LogForOptionName)
+        {
+            CustomParser = result =>
+            {
+                if (!result.Tokens.Any())
+                {
+                    return null;
+                }
+
+                if (Enum.TryParse<LogFor>(result.Tokens[0].Value, true, out var logFor))
+                {
+                    return logFor;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        };
+
         var apiPortOption = new Option<int?>(DevProxyCommand.ApiPortOptionName);
 
         var discoverOption = new Option<bool>(DevProxyCommand.DiscoverOptionName, "--discover")
@@ -127,6 +150,7 @@ public DevProxyConfigOptions()
             ipAddressOption,
             configFileOption,
             urlsToWatchOption,
+            logForOption,
             logLevelOption,
             discoverOption
         };
diff --git a/DevProxy/Extensions/ILoggingBuilderExtensions.cs b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
index 00735f24..499306c9 100644
--- a/DevProxy/Extensions/ILoggingBuilderExtensions.cs
+++ b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using DevProxy.Abstractions.Proxy;
 using DevProxy.Commands;
 using DevProxy.Logging;
 
@@ -26,6 +27,10 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
         var configuredLogLevel = options.LogLevel ??
             configuration.GetValue("logLevel", LogLevel.Information);
 
+        // Determine the log target audience (human or machine)
+        var configuredLogFor = options.LogFor ??
+            configuration.GetValue("logFor", LogFor.Human);
+
         // For stdio command, log to file instead of console to avoid interfering with proxied streams
         if (DevProxyCommand.IsStdioCommand)
         {
@@ -39,6 +44,14 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             return builder;
         }
 
+        var showSkipMessages = configuration.GetValue("showSkipMessages", true);
+        var showTimestamps = configuration.GetValue("showTimestamps", true);
+
+        // Select the appropriate formatter based on logFor setting
+        var formatterName = configuredLogFor == LogFor.Machine
+            ? MachineConsoleFormatter.FormatterName
+            : ProxyConsoleFormatter.DefaultCategoryName;
+
         _ = builder
             .AddFilter("Microsoft.Hosting.*", LogLevel.Error)
             .AddFilter("Microsoft.AspNetCore.*", LogLevel.Error)
@@ -48,17 +61,26 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             .AddFilter("DevProxy.Plugins.*", level =>
                 level >= configuredLogLevel &&
                 !DevProxyCommand.HasGlobalOptions)
-            .AddConsole(options =>
+            .AddConsole(consoleOptions =>
+                {
+                    consoleOptions.FormatterName = formatterName;
+                    consoleOptions.LogToStandardErrorThreshold = LogLevel.Warning;
+                }
+            )
+            .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                 {
-                    options.FormatterName = ProxyConsoleFormatter.DefaultCategoryName;
-                    options.LogToStandardErrorThreshold = LogLevel.Warning;
+                    formatterOptions.IncludeScopes = true;
+                    formatterOptions.LogFor = configuredLogFor;
+                    formatterOptions.ShowSkipMessages = showSkipMessages;
+                    formatterOptions.ShowTimestamps = showTimestamps;
                 }
             )
-            .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(options =>
+            .AddConsoleFormatter<MachineConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                 {
-                    options.IncludeScopes = true;
-                    options.ShowSkipMessages = configuration.GetValue("showSkipMessages", true);
-                    options.ShowTimestamps = configuration.GetValue("showTimestamps", true);
+                    formatterOptions.IncludeScopes = true;
+                    formatterOptions.LogFor = configuredLogFor;
+                    formatterOptions.ShowSkipMessages = showSkipMessages;
+                    formatterOptions.ShowTimestamps = showTimestamps;
                 }
             )
             .AddRequestLogger()
diff --git a/DevProxy/Logging/MachineConsoleFormatter.cs b/DevProxy/Logging/MachineConsoleFormatter.cs
new file mode 100644
index 00000000..ea36cc9a
--- /dev/null
+++ b/DevProxy/Logging/MachineConsoleFormatter.cs
@@ -0,0 +1,193 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Logging.Console;
+using Microsoft.Extensions.Options;
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace DevProxy.Logging;
+
+sealed class MachineConsoleFormatter : ConsoleFormatter
+{
+    public const string FormatterName = "devproxy-machine";
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    // Mapping from MessageType to semantic type strings for machine output
+    private static readonly Dictionary<MessageType, string> _messageTypeStrings = new()
+    {
+        [MessageType.InterceptedRequest] = "request",
+        [MessageType.InterceptedResponse] = "response",
+        [MessageType.PassedThrough] = "passthrough",
+        [MessageType.Chaos] = "chaos",
+        [MessageType.Warning] = "warning",
+        [MessageType.Mocked] = "mock",
+        [MessageType.Failed] = "error",
+        [MessageType.Tip] = "tip",
+        [MessageType.Skipped] = "skip",
+        [MessageType.Processed] = "processed",
+        [MessageType.Timestamp] = "timestamp",
+        [MessageType.FinishedProcessingRequest] = "finished",
+        [MessageType.Normal] = "info"
+    };
+
+    // Mapping from LogLevel to semantic level strings for machine output
+    private static readonly Dictionary<LogLevel, string> _logLevelStrings = new()
+    {
+        [LogLevel.Trace] = "trace",
+        [LogLevel.Debug] = "debug",
+        [LogLevel.Information] = "info",
+        [LogLevel.Warning] = "warning",
+        [LogLevel.Error] = "error",
+        [LogLevel.Critical] = "critical"
+    };
+
+    private readonly ProxyConsoleFormatterOptions _options;
+    private readonly HashSet<MessageType> _filteredMessageTypes;
+
+    public MachineConsoleFormatter(IOptions<ProxyConsoleFormatterOptions> options) : base(FormatterName)
+    {
+        Console.OutputEncoding = Encoding.UTF8;
+        _options = options.Value;
+
+        _filteredMessageTypes = [MessageType.InterceptedResponse, MessageType.FinishedProcessingRequest];
+        if (!_options.ShowSkipMessages)
+        {
+            _ = _filteredMessageTypes.Add(MessageType.Skipped);
+        }
+        if (!_options.ShowTimestamps)
+        {
+            _ = _filteredMessageTypes.Add(MessageType.Timestamp);
+        }
+    }
+
+    public override void Write<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        if (logEntry.State is RequestLog requestLog)
+        {
+            WriteRequestLog(requestLog, logEntry.Category, scopeProvider, textWriter);
+        }
+        else
+        {
+            WriteRegularLogMessage(logEntry, scopeProvider, textWriter);
+        }
+    }
+
+    private void WriteRequestLog(RequestLog requestLog, string category, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        var messageType = requestLog.MessageType;
+
+        if (_filteredMessageTypes.Contains(messageType))
+        {
+            return;
+        }
+
+        var requestId = GetRequestIdScope(scopeProvider);
+        var pluginName = category == ProxyConsoleFormatter.DefaultCategoryName ? null : category;
+
+        // Extract short plugin name from full category
+        if (pluginName is not null)
+        {
+            pluginName = pluginName[(pluginName.LastIndexOf('.') + 1)..];
+        }
+
+        var logObject = new MachineRequestLogEntry
+        {
+            Type = GetMessageTypeString(messageType),
+            Message = requestLog.Message,
+            Method = requestLog.Method,
+            Url = requestLog.Url,
+            Plugin = pluginName,
+            RequestId = requestId?.ToString(CultureInfo.InvariantCulture),
+            Timestamp = DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture)
+        };
+
+        var json = JsonSerializer.Serialize(logObject, _jsonOptions);
+        textWriter.WriteLine(json);
+    }
+
+    private static void WriteRegularLogMessage<TState>(in LogEntry<TState> logEntry, IExternalScopeProvider? scopeProvider, TextWriter textWriter)
+    {
+        var message = logEntry.Formatter(logEntry.State, logEntry.Exception);
+        if (string.IsNullOrEmpty(message))
+        {
+            return;
+        }
+
+        var requestId = GetRequestIdScope(scopeProvider);
+        var category = logEntry.Category;
+
+        // Extract short category name
+        if (category is not null)
+        {
+            category = category[(category.LastIndexOf('.') + 1)..];
+        }
+
+        var logObject = new MachineLogEntry
+        {
+            Type = "log",
+            Level = GetLogLevelString(logEntry.LogLevel),
+            Message = message,
+            Category = category,
+            RequestId = requestId?.ToString(CultureInfo.InvariantCulture),
+            Timestamp = DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture),
+            Exception = logEntry.Exception?.ToString()
+        };
+
+        var json = JsonSerializer.Serialize(logObject, _jsonOptions);
+        textWriter.WriteLine(json);
+    }
+
+    private static string GetMessageTypeString(MessageType messageType) =>
+        _messageTypeStrings.TryGetValue(messageType, out var str) ? str : "unknown";
+
+    private static string GetLogLevelString(LogLevel logLevel) =>
+        _logLevelStrings.TryGetValue(logLevel, out var str) ? str : "unknown";
+
+    private static int? GetRequestIdScope(IExternalScopeProvider? scopeProvider)
+    {
+        int? requestId = null;
+        scopeProvider?.ForEachScope((scope, _) =>
+        {
+            if (scope is Dictionary<string, object> dictionary &&
+                dictionary.TryGetValue(nameof(requestId), out var req))
+            {
+                requestId = (int)req;
+            }
+        }, "");
+        return requestId;
+    }
+
+    // JSON serialization models for machine output
+    private sealed class MachineRequestLogEntry
+    {
+        public string? Type { get; set; }
+        public string? Message { get; set; }
+        public string? Method { get; set; }
+        public string? Url { get; set; }
+        public string? Plugin { get; set; }
+        public string? RequestId { get; set; }
+        public string? Timestamp { get; set; }
+    }
+
+    private sealed class MachineLogEntry
+    {
+        public string? Type { get; set; }
+        public string? Level { get; set; }
+        public string? Message { get; set; }
+        public string? Category { get; set; }
+        public string? RequestId { get; set; }
+        public string? Timestamp { get; set; }
+        public string? Exception { get; set; }
+    }
+}
diff --git a/DevProxy/Logging/ProxyConsoleFormatterOptions.cs b/DevProxy/Logging/ProxyConsoleFormatterOptions.cs
index 0b6f959f..1cb6c2f2 100644
--- a/DevProxy/Logging/ProxyConsoleFormatterOptions.cs
+++ b/DevProxy/Logging/ProxyConsoleFormatterOptions.cs
@@ -2,12 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using DevProxy.Abstractions.Proxy;
 using Microsoft.Extensions.Logging.Console;
 
 namespace DevProxy.Logging;
 
 sealed class ProxyConsoleFormatterOptions : ConsoleFormatterOptions
 {
+    public LogFor LogFor { get; set; } = LogFor.Human;
+
     public bool ShowSkipMessages { get; set; } = true;
 
     public bool ShowTimestamps { get; set; } = true;
diff --git a/DevProxy/Proxy/ProxyConfiguration.cs b/DevProxy/Proxy/ProxyConfiguration.cs
index d22b58da..381fcc83 100755
--- a/DevProxy/Proxy/ProxyConfiguration.cs
+++ b/DevProxy/Proxy/ProxyConfiguration.cs
@@ -34,6 +34,8 @@ public string ConfigFile
     public string? IPAddress { get; set; } = "127.0.0.1";
     public bool InstallCert { get; set; } = true;
     [JsonConverter(typeof(JsonStringEnumConverter))]
+    public LogFor LogFor { get; set; } = LogFor.Human;
+    [JsonConverter(typeof(JsonStringEnumConverter))]
     public LogLevel LogLevel { get; set; } = LogLevel.Information;
     public bool NoFirstRun { get; set; }
     [JsonConverter(typeof(JsonStringEnumConverter))]
diff --git a/schemas/v2.1.0/rc.schema.json b/schemas/v2.1.0/rc.schema.json
index 369a19a0..e67f092a 100644
--- a/schemas/v2.1.0/rc.schema.json
+++ b/schemas/v2.1.0/rc.schema.json
@@ -85,6 +85,14 @@
       ],
       "description": "The minimum log level for Dev Proxy output."
     },
+    "logFor": {
+      "type": "string",
+      "enum": [
+        "human",
+        "machine"
+      ],
+      "description": "Target audience for log output. Use 'human' for readable console output (default), or 'machine' for structured JSON Lines output suitable for LLMs and agents."
+    },
     "newVersionNotification": {
       "type": "string",
       "enum": [

From 4b00ab7607e856ecdac9262d90f1601efdfc561b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 19 Jan 2026 12:11:13 +0000
Subject: [PATCH 3/6] Fix code review feedback: add token count check and
 remove unnecessary else

Co-authored-by: waldekmastykarz <11164679+waldekmastykarz@users.noreply.github.com>
---
 DevProxy/Commands/DevProxyCommand.cs       | 4 ++++
 DevProxy/Commands/DevProxyConfigOptions.cs | 6 ++----
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/DevProxy/Commands/DevProxyCommand.cs b/DevProxy/Commands/DevProxyCommand.cs
index 8d297373..190cc46f 100644
--- a/DevProxy/Commands/DevProxyCommand.cs
+++ b/DevProxy/Commands/DevProxyCommand.cs
@@ -362,6 +362,10 @@ private void ConfigureCommand()
         };
         logForOption.Validators.Add(input =>
         {
+            if (input.Tokens.Count == 0)
+            {
+                return;
+            }
             if (!Enum.TryParse<LogFor>(input.Tokens[0].Value, true, out _))
             {
                 input.AddError($"{input.Tokens[0].Value} is not a valid log-for value. Allowed values are: {string.Join(", ", Enum.GetNames<LogFor>())}");
diff --git a/DevProxy/Commands/DevProxyConfigOptions.cs b/DevProxy/Commands/DevProxyConfigOptions.cs
index e05fc1f3..658ddba5 100644
--- a/DevProxy/Commands/DevProxyConfigOptions.cs
+++ b/DevProxy/Commands/DevProxyConfigOptions.cs
@@ -130,10 +130,8 @@ public DevProxyConfigOptions()
                 {
                     return logFor;
                 }
-                else
-                {
-                    return null;
-                }
+
+                return null;
             }
         };
 

From dcdc8c79bc60a5d646456b20957c61b68297c81e Mon Sep 17 00:00:00 2001
From: Waldek Mastykarz <waldek@mastykarz.nl>
Date: Wed, 21 Jan 2026 15:16:45 +0100
Subject: [PATCH 4/6] Update DevProxy/Logging/ProxyConsoleFormatterOptions.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 DevProxy/Logging/ProxyConsoleFormatterOptions.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/DevProxy/Logging/ProxyConsoleFormatterOptions.cs b/DevProxy/Logging/ProxyConsoleFormatterOptions.cs
index 1cb6c2f2..0b6f959f 100644
--- a/DevProxy/Logging/ProxyConsoleFormatterOptions.cs
+++ b/DevProxy/Logging/ProxyConsoleFormatterOptions.cs
@@ -2,15 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using DevProxy.Abstractions.Proxy;
 using Microsoft.Extensions.Logging.Console;
 
 namespace DevProxy.Logging;
 
 sealed class ProxyConsoleFormatterOptions : ConsoleFormatterOptions
 {
-    public LogFor LogFor { get; set; } = LogFor.Human;
-
     public bool ShowSkipMessages { get; set; } = true;
 
     public bool ShowTimestamps { get; set; } = true;

From 9bb097808bdca4dce5b3708b8bc94bb7dcde53d3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 21 Jan 2026 14:28:52 +0000
Subject: [PATCH 5/6] Merge changes from main: add IsJwtCommand and
 IsRootCommand properties

Co-authored-by: waldekmastykarz <11164679+waldekmastykarz@users.noreply.github.com>
---
 DevProxy/Commands/DevProxyCommand.cs          | 43 ++++++++++++++
 .../Extensions/ILoggingBuilderExtensions.cs   | 56 ++++++++++++++++---
 2 files changed, 92 insertions(+), 7 deletions(-)

diff --git a/DevProxy/Commands/DevProxyCommand.cs b/DevProxy/Commands/DevProxyCommand.cs
index 190cc46f..032e0e2b 100644
--- a/DevProxy/Commands/DevProxyCommand.cs
+++ b/DevProxy/Commands/DevProxyCommand.cs
@@ -44,6 +44,8 @@ sealed class DevProxyCommand : RootCommand
 
     private static bool _hasGlobalOptionsResolved;
     private static bool _isStdioCommandResolved;
+    private static bool _isJwtCommandResolved;
+    private static bool _isRootCommandResolved;
     private static bool _stdioLogFilePathResolved;
 
     public static bool HasGlobalOptions
@@ -79,6 +81,47 @@ public static bool IsStdioCommand
         }
     }
 
+    public static bool IsJwtCommand
+    {
+        get
+        {
+            if (_isJwtCommandResolved)
+            {
+                return field;
+            }
+
+            var args = Environment.GetCommandLineArgs();
+            field = args.Length > 1 && string.Equals(args[1], "jwt", StringComparison.OrdinalIgnoreCase);
+            _isJwtCommandResolved = true;
+            return field;
+        }
+    }
+
+    /// <summary>
+    /// Determines if the root command (proxy itself) is being invoked.
+    /// Returns true when no subcommand is specified (only options or no args).
+    /// A subcommand is detected when the first non-program argument doesn't start with '-'.
+    /// </summary>
+    public static bool IsRootCommand
+    {
+        get
+        {
+            if (_isRootCommandResolved)
+            {
+                return field;
+            }
+
+            var args = Environment.GetCommandLineArgs();
+            // Skip the first argument which is the program name
+            // If there are no more arguments, it's the root command
+            // If the first argument starts with '-', it's an option (root command)
+            // Otherwise, it's a subcommand name
+            field = args.Length <= 1 || args[1].StartsWith('-');
+            _isRootCommandResolved = true;
+            return field;
+        }
+    }
+
     public static string StdioLogFilePath
     {
         get
diff --git a/DevProxy/Extensions/ILoggingBuilderExtensions.cs b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
index 499306c9..7e3e6a20 100644
--- a/DevProxy/Extensions/ILoggingBuilderExtensions.cs
+++ b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
@@ -44,6 +44,15 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             return builder;
         }
 
+        // For jwt command, suppress all logging to console to avoid interfering with token output
+        if (DevProxyCommand.IsJwtCommand)
+        {
+            _ = builder
+                .ClearProviders()
+                .SetMinimumLevel(LogLevel.None);
+            return builder;
+        }
+
         var showSkipMessages = configuration.GetValue("showSkipMessages", true);
         var showTimestamps = configuration.GetValue("showTimestamps", true);
 
@@ -52,15 +61,51 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             ? MachineConsoleFormatter.FormatterName
             : ProxyConsoleFormatter.DefaultCategoryName;
 
+        // For root command (proxy itself), use rich logging
+        if (DevProxyCommand.IsRootCommand)
+        {
+            _ = builder
+                .AddFilter("Microsoft.Hosting.*", LogLevel.Error)
+                .AddFilter("Microsoft.AspNetCore.*", LogLevel.Error)
+                .AddFilter("Microsoft.Extensions.*", LogLevel.Error)
+                .AddFilter("System.*", LogLevel.Error)
+                // Only show plugin messages when no global options are set
+                .AddFilter("DevProxy.Plugins.*", level =>
+                    level >= configuredLogLevel &&
+                    !DevProxyCommand.HasGlobalOptions)
+                .AddConsole(consoleOptions =>
+                    {
+                        consoleOptions.FormatterName = formatterName;
+                        consoleOptions.LogToStandardErrorThreshold = LogLevel.Warning;
+                    }
+                )
+                .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
+                    {
+                        formatterOptions.IncludeScopes = true;
+                        formatterOptions.ShowSkipMessages = showSkipMessages;
+                        formatterOptions.ShowTimestamps = showTimestamps;
+                    }
+                )
+                .AddConsoleFormatter<MachineConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
+                    {
+                        formatterOptions.IncludeScopes = true;
+                        formatterOptions.ShowSkipMessages = showSkipMessages;
+                        formatterOptions.ShowTimestamps = showTimestamps;
+                    }
+                )
+                .AddRequestLogger()
+                .SetMinimumLevel(configuredLogLevel);
+            return builder;
+        }
+
+        // For other subcommands (cert, config, outdated, msgraphdb), use rich logging
+        // but with plugin messages filtered out
         _ = builder
             .AddFilter("Microsoft.Hosting.*", LogLevel.Error)
             .AddFilter("Microsoft.AspNetCore.*", LogLevel.Error)
             .AddFilter("Microsoft.Extensions.*", LogLevel.Error)
             .AddFilter("System.*", LogLevel.Error)
-            // Only show plugin messages when no global options are set
-            .AddFilter("DevProxy.Plugins.*", level =>
-                level >= configuredLogLevel &&
-                !DevProxyCommand.HasGlobalOptions)
+            .AddFilter("DevProxy.Plugins.*", LogLevel.None)
             .AddConsole(consoleOptions =>
                 {
                     consoleOptions.FormatterName = formatterName;
@@ -70,7 +115,6 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             .AddConsoleFormatter<ProxyConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                 {
                     formatterOptions.IncludeScopes = true;
-                    formatterOptions.LogFor = configuredLogFor;
                     formatterOptions.ShowSkipMessages = showSkipMessages;
                     formatterOptions.ShowTimestamps = showTimestamps;
                 }
@@ -78,12 +122,10 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
             .AddConsoleFormatter<MachineConsoleFormatter, ProxyConsoleFormatterOptions>(formatterOptions =>
                 {
                     formatterOptions.IncludeScopes = true;
-                    formatterOptions.LogFor = configuredLogFor;
                     formatterOptions.ShowSkipMessages = showSkipMessages;
                     formatterOptions.ShowTimestamps = showTimestamps;
                 }
             )
-            .AddRequestLogger()
             .SetMinimumLevel(configuredLogLevel);
 
         return builder;

From 1b5763b0d4381b0cb5d47eba6e6411a44babd99d Mon Sep 17 00:00:00 2001
From: waldekmastykarz <waldek@mastykarz.nl>
Date: Sat, 24 Jan 2026 10:56:52 +0100
Subject: [PATCH 6/6] Improve error handling in CsomParser and adjust logging
 conditions in ProxyEngine

---
 DevProxy.Plugins/SharePoint/CsomParser.cs | 2 +-
 DevProxy/Proxy/ProxyEngine.cs             | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/DevProxy.Plugins/SharePoint/CsomParser.cs b/DevProxy.Plugins/SharePoint/CsomParser.cs
index 9557d985..262aac1b 100644
--- a/DevProxy.Plugins/SharePoint/CsomParser.cs
+++ b/DevProxy.Plugins/SharePoint/CsomParser.cs
@@ -80,7 +80,7 @@ public static (IEnumerable<string> Actions, IEnumerable<string> Errors) GetActio
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Error parsing XML: {ex.Message}");
+            errors.Add($"Error parsing XML: {ex.Message}");
         }
 
         return (actions, errors);
diff --git a/DevProxy/Proxy/ProxyEngine.cs b/DevProxy/Proxy/ProxyEngine.cs
index bba35c90..599800f1 100755
--- a/DevProxy/Proxy/ProxyEngine.cs
+++ b/DevProxy/Proxy/ProxyEngine.cs
@@ -139,7 +139,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         var isInteractive = !Console.IsInputRedirected &&
             Environment.GetEnvironmentVariable("CI") is null;
 
-        if (isInteractive)
+        if (isInteractive && _config.LogFor != LogFor.Machine)
         {
             // only print hotkeys when they can be used
             PrintHotkeys();
@@ -217,7 +217,10 @@ private async Task ReadKeysAsync(CancellationToken cancellationToken)
                 break;
             case ConsoleKey.C:
                 Console.Clear();
-                PrintHotkeys();
+                if (_config.LogFor != LogFor.Machine)
+                {
+                    PrintHotkeys();
+                }
                 break;
             case ConsoleKey.W:
                 await _proxyController.MockRequestAsync(cancellationToken);