From 162a69c2315255ac63a35146b0fa89a54f0677aa Mon Sep 17 00:00:00 2001
From: waldekmastykarz <waldek@mastykarz.nl>
Date: Sun, 25 Jan 2026 12:46:57 +0100
Subject: [PATCH 1/2] Adds detached support. Closes #1511

---
 DevProxy/ApiControllers/ProxyController.cs    | 272 +++++++++++++++++-
 DevProxy/Commands/DevProxyCommand.cs          |  70 ++++-
 DevProxy/Commands/DevProxyConfigOptions.cs    |   3 +
 DevProxy/Commands/LogsCommand.cs              | 227 +++++++++++++++
 DevProxy/Commands/StatusCommand.cs            |  82 ++++++
 DevProxy/Commands/StopCommand.cs              | 139 +++++++++
 .../Extensions/ILoggingBuilderExtensions.cs   |   3 +-
 DevProxy/Program.cs                           | 187 +++++++++++-
 DevProxy/Proxy/ProxyEngine.cs                 |   2 +
 DevProxy/State/ProxyInstanceState.cs          |  32 +++
 DevProxy/State/StateManager.cs                | 232 +++++++++++++++
 11 files changed, 1241 insertions(+), 8 deletions(-)
 create mode 100644 DevProxy/Commands/LogsCommand.cs
 create mode 100644 DevProxy/Commands/StatusCommand.cs
 create mode 100644 DevProxy/Commands/StopCommand.cs
 create mode 100644 DevProxy/State/ProxyInstanceState.cs
 create mode 100644 DevProxy/State/StateManager.cs

diff --git a/DevProxy/ApiControllers/ProxyController.cs b/DevProxy/ApiControllers/ProxyController.cs
index 01aa9c5e..d5dd36ee 100644
--- a/DevProxy/ApiControllers/ProxyController.cs
+++ b/DevProxy/ApiControllers/ProxyController.cs
@@ -2,12 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.AspNetCore.Mvc;
+using DevProxy.Abstractions.Proxy;
+using DevProxy.Commands;
 using DevProxy.Jwt;
-using System.Security.Cryptography.X509Certificates;
-using System.ComponentModel.DataAnnotations;
 using DevProxy.Proxy;
-using DevProxy.Abstractions.Proxy;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using System.Security.Cryptography.X509Certificates;
 
 namespace DevProxy.ApiControllers;
 
@@ -137,4 +138,265 @@ public IActionResult GetRootCertificate([FromQuery][Required] string format)
 
         return File(pemBytes, "application/x-x509-ca-cert", "devProxy.pem");
     }
-}
+
+    [HttpGet("logs")]
+    public async Task GetLogsAsync(
+        [FromQuery] int? lines,
+        [FromQuery] bool follow = false,
+        [FromQuery] string? since = null,
+        CancellationToken cancellationToken = default)
+    {
+        // Only available in detached/daemon mode
+        if (!DevProxyCommand.IsInternalDaemon)
+        {
+            Response.StatusCode = StatusCodes.Status404NotFound;
+            await Response.WriteAsync("Logs endpoint is only available in detached mode.", cancellationToken);
+            return;
+        }
+
+        var logFile = DevProxyCommand.DetachedLogFilePath;
+        if (string.IsNullOrEmpty(logFile) || !System.IO.File.Exists(logFile))
+        {
+            Response.StatusCode = StatusCodes.Status404NotFound;
+            await Response.WriteAsync("Log file not found.", cancellationToken);
+            return;
+        }
+
+        var acceptHeader = Request.Headers.Accept.ToString();
+        var useJson = acceptHeader.Contains("application/json", StringComparison.OrdinalIgnoreCase);
+        var useSse = acceptHeader.Contains("text/event-stream", StringComparison.OrdinalIgnoreCase) || follow;
+
+        if (useSse)
+        {
+            Response.ContentType = "text/event-stream";
+            Response.Headers.CacheControl = "no-cache";
+            Response.Headers.Connection = "keep-alive";
+
+            await StreamLogsAsync(logFile, lines ?? 50, since, useJson, cancellationToken);
+        }
+        else
+        {
+            Response.ContentType = useJson ? "application/json" : "text/plain";
+            await WriteLogsAsync(logFile, lines ?? 50, since, useJson, cancellationToken);
+        }
+    }
+
+    private async Task WriteLogsAsync(string logFile, int lineCount, string? since, bool useJson, CancellationToken cancellationToken)
+    {
+        var allLines = await ReadAllLinesAsync(logFile, cancellationToken);
+        var filteredLines = FilterLines(allLines, since).TakeLast(lineCount).ToList();
+
+        if (useJson)
+        {
+            var logEntries = filteredLines.Select(ParseLogLine).ToList();
+            var json = System.Text.Json.JsonSerializer.Serialize(logEntries);
+            await Response.WriteAsync(json, cancellationToken);
+        }
+        else
+        {
+            foreach (var line in filteredLines)
+            {
+                await Response.WriteAsync(line + Environment.NewLine, cancellationToken);
+            }
+        }
+    }
+
+    private async Task StreamLogsAsync(string logFile, int initialLines, string? since, bool useJson, CancellationToken cancellationToken)
+    {
+        // Write initial lines
+        var allLines = await ReadAllLinesAsync(logFile, cancellationToken);
+        var filteredLines = FilterLines(allLines, since).TakeLast(initialLines).ToList();
+
+        foreach (var line in filteredLines)
+        {
+            await WriteSseEventAsync(line, useJson, cancellationToken);
+        }
+
+        // Follow new lines
+        var lastPosition = new FileInfo(logFile).Length;
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            await Task.Delay(500, cancellationToken);
+
+            try
+            {
+                using var fs = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+                if (fs.Length > lastPosition)
+                {
+                    _ = fs.Seek(lastPosition, SeekOrigin.Begin);
+                    using var reader = new StreamReader(fs);
+
+                    string? line;
+                    while ((line = await reader.ReadLineAsync(cancellationToken)) != null)
+                    {
+                        await WriteSseEventAsync(line, useJson, cancellationToken);
+                    }
+
+                    lastPosition = fs.Length;
+                }
+            }
+            catch (IOException)
+            {
+                // File might be temporarily locked
+            }
+        }
+    }
+
+    private async Task WriteSseEventAsync(string line, bool useJson, CancellationToken cancellationToken)
+    {
+        if (useJson)
+        {
+            var logEntry = ParseLogLine(line);
+            var json = System.Text.Json.JsonSerializer.Serialize(logEntry);
+            await Response.WriteAsync($"event: log\ndata: {json}\n\n", cancellationToken);
+        }
+        else
+        {
+            await Response.WriteAsync($"data: {line}\n\n", cancellationToken);
+        }
+
+        await Response.Body.FlushAsync(cancellationToken);
+    }
+
+    private static IEnumerable<string> FilterLines(IList<string> lines, string? since)
+    {
+        if (string.IsNullOrEmpty(since))
+        {
+            return lines;
+        }
+
+        var sinceTime = ParseSinceOption(since);
+        if (sinceTime == null)
+        {
+            return lines;
+        }
+
+        return lines.Where(line => LineMatchesSince(line, sinceTime.Value));
+    }
+
+    private static DateTime? ParseSinceOption(string? since)
+    {
+        if (string.IsNullOrEmpty(since))
+        {
+            return null;
+        }
+
+        // Try parsing as a duration (e.g., "5m", "1h", "30s")
+        if (since.Length >= 2)
+        {
+            var unit = since[^1];
+            if (int.TryParse(since[..^1], out var value))
+            {
+                return unit switch
+                {
+                    's' => DateTime.Now.AddSeconds(-value),
+                    'm' => DateTime.Now.AddMinutes(-value),
+                    'h' => DateTime.Now.AddHours(-value),
+                    'd' => DateTime.Now.AddDays(-value),
+                    _ => null
+                };
+            }
+        }
+
+        // Try parsing as a datetime
+        if (DateTime.TryParse(since, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out var dateTime))
+        {
+            return dateTime;
+        }
+
+        return null;
+    }
+
+    private static bool LineMatchesSince(string line, DateTime sinceTime)
+    {
+        // Parse timestamp from line format: [HH:mm:ss.fff] ...
+        if (line.Length < 14 || line[0] != '[' || line[13] != ']')
+        {
+            return true;
+        }
+
+        var timestampStr = line[1..13];
+        if (TimeSpan.TryParseExact(timestampStr, "hh\\:mm\\:ss\\.fff", System.Globalization.CultureInfo.InvariantCulture, out var timeOfDay))
+        {
+            var lineTime = DateTime.Today.Add(timeOfDay);
+            if (lineTime > DateTime.Now)
+            {
+                lineTime = lineTime.AddDays(-1);
+            }
+
+            return lineTime >= sinceTime;
+        }
+
+        return true;
+    }
+
+    private static LogEntryDto ParseLogLine(string line)
+    {
+        // Parse: [HH:mm:ss.fff] level: category: message
+        var entry = new LogEntryDto { Raw = line };
+
+        if (line.Length < 14 || line[0] != '[' || line[13] != ']')
+        {
+            entry.Message = line;
+            return entry;
+        }
+
+        entry.Time = line[1..13];
+
+        if (line.Length < 16)
+        {
+            entry.Message = line;
+            return entry;
+        }
+
+        var rest = line[15..]; // Skip "] "
+        var colonIndex = rest.IndexOf(':', StringComparison.Ordinal);
+        if (colonIndex > 0)
+        {
+            entry.Level = rest[..colonIndex].Trim();
+            rest = rest[(colonIndex + 1)..].TrimStart();
+
+            colonIndex = rest.IndexOf(':', StringComparison.Ordinal);
+            if (colonIndex > 0)
+            {
+                entry.Category = rest[..colonIndex].Trim();
+                entry.Message = rest[(colonIndex + 1)..].TrimStart();
+            }
+            else
+            {
+                entry.Message = rest;
+            }
+        }
+        else
+        {
+            entry.Message = rest;
+        }
+
+        return entry;
+    }
+
+    private sealed class LogEntryDto
+    {
+        public string? Time { get; set; }
+        public string? Level { get; set; }
+        public string? Category { get; set; }
+        public string? Message { get; set; }
+        public string? Raw { get; set; }
+    }
+
+    private static async Task<List<string>> ReadAllLinesAsync(string filePath, CancellationToken cancellationToken)
+    {
+        var lines = new List<string>();
+        using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        using var reader = new StreamReader(fs);
+
+        string? line;
+        while ((line = await reader.ReadLineAsync(cancellationToken)) != null)
+        {
+            lines.Add(line);
+        }
+
+        return lines;
+    }
+}
\ No newline at end of file
diff --git a/DevProxy/Commands/DevProxyCommand.cs b/DevProxy/Commands/DevProxyCommand.cs
index c5c4b8b3..1740df9f 100644
--- a/DevProxy/Commands/DevProxyCommand.cs
+++ b/DevProxy/Commands/DevProxyCommand.cs
@@ -38,6 +38,8 @@ sealed class DevProxyCommand : RootCommand
     internal const string DiscoverOptionName = "--discover";
     internal const string EnvOptionName = "--env";
     internal const string LogForOptionName = "--log-for";
+    internal const string DetachedOptionName = "--detach";
+    internal const string InternalDaemonOptionName = "--_internal-daemon";
 
     private static readonly string[] globalOptions = ["--version"];
     private static readonly string[] helpOptions = ["--help", "-h", "/h", "-?", "/?"];
@@ -46,7 +48,10 @@ sealed class DevProxyCommand : RootCommand
     private static bool _isStdioCommandResolved;
     private static bool _isJwtCommandResolved;
     private static bool _isRootCommandResolved;
+    private static bool _isDetachedModeResolved;
+    private static bool _isInternalDaemonResolved;
     private static bool _stdioLogFilePathResolved;
+    private static bool _detachedLogFilePathResolved;
 
     public static bool HasGlobalOptions
     {
@@ -97,6 +102,22 @@ public static bool IsJwtCommand
         }
     }
 
+    public static bool IsDetachedMode
+    {
+        get
+        {
+            if (_isDetachedModeResolved)
+            {
+                return field;
+            }
+
+            var args = Environment.GetCommandLineArgs();
+            field = args.Contains("--detach") || args.Contains("-d");
+            _isDetachedModeResolved = 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).
@@ -122,6 +143,22 @@ public static bool IsRootCommand
         }
     }
 
+    public static bool IsInternalDaemon
+    {
+        get
+        {
+            if (_isInternalDaemonResolved)
+            {
+                return field;
+            }
+
+            var args = Environment.GetCommandLineArgs();
+            field = args.Contains("--_internal-daemon");
+            _isInternalDaemonResolved = true;
+            return field;
+        }
+    }
+
     public static string StdioLogFilePath
     {
         get
@@ -139,6 +176,21 @@ public static string StdioLogFilePath
         }
     }
 
+    public static string DetachedLogFilePath
+    {
+        get
+        {
+            if (_detachedLogFilePathResolved)
+            {
+                return field ?? string.Empty;
+            }
+
+            field = State.StateManager.GenerateLogFilePath();
+            _detachedLogFilePathResolved = true;
+            return field;
+        }
+    }
+
     public DevProxyCommand(
         IEnumerable<IPlugin> plugins,
         ISet<UrlToWatch> urlsToWatch,
@@ -415,14 +467,27 @@ private void ConfigureCommand()
             }
         });
 
+        var detachedOption = new Option<bool?>(DetachedOptionName, "-d")
+        {
+            Description = "Run Dev Proxy in the background"
+        };
+
+        var internalDaemonOption = new Option<bool?>(InternalDaemonOptionName)
+        {
+            Description = "Internal use only - do not use directly",
+            Hidden = true
+        };
+
         var options = new List<Option>
         {
             apiPortOption,
             asSystemProxyOption,
             ConfigFileOption,
+            detachedOption,
             discoverOption,
             envOption,
             installCertOption,
+            internalDaemonOption,
             ipAddressOption,
             logForOption,
             logLevelOption,
@@ -448,7 +513,10 @@ private void ConfigureCommand()
             ActivatorUtilities.CreateInstance<OutdatedCommand>(_serviceProvider),
             ActivatorUtilities.CreateInstance<JwtCommand>(_serviceProvider),
             ActivatorUtilities.CreateInstance<CertCommand>(_serviceProvider),
-            ActivatorUtilities.CreateInstance<StdioCommand>(_serviceProvider)
+            ActivatorUtilities.CreateInstance<StdioCommand>(_serviceProvider),
+            ActivatorUtilities.CreateInstance<StatusCommand>(_serviceProvider),
+            ActivatorUtilities.CreateInstance<StopCommand>(_serviceProvider),
+            ActivatorUtilities.CreateInstance<LogsCommand>(_serviceProvider)
         };
         commands.AddRange(_plugins.SelectMany(p => p.GetCommands()));
         this.AddCommands(commands.OrderByName());
diff --git a/DevProxy/Commands/DevProxyConfigOptions.cs b/DevProxy/Commands/DevProxyConfigOptions.cs
index d4c30377..5601c04a 100644
--- a/DevProxy/Commands/DevProxyConfigOptions.cs
+++ b/DevProxy/Commands/DevProxyConfigOptions.cs
@@ -19,6 +19,7 @@ public string? ConfigFile
     }
 
     public int? ApiPort => _parseResult?.GetValueOrDefault<int?>(DevProxyCommand.ApiPortOptionName);
+    public int? Port => _parseResult?.GetValueOrDefault<int?>(DevProxyCommand.PortOptionName);
     public bool Discover => _parseResult?.GetValueOrDefault<bool?>(DevProxyCommand.DiscoverOptionName) ?? false;
     public string? IPAddress => _parseResult?.GetValueOrDefault<string?>(DevProxyCommand.IpAddressOptionName);
     public bool IsStdioMode => _parseResult?.CommandResult.Command.Name == "stdio";
@@ -137,6 +138,7 @@ public DevProxyConfigOptions()
         };
 
         var apiPortOption = new Option<int?>(DevProxyCommand.ApiPortOptionName);
+        var portOption = new Option<int?>(DevProxyCommand.PortOptionName, "-p");
 
         var discoverOption = new Option<bool>(DevProxyCommand.DiscoverOptionName, "--discover")
         {
@@ -148,6 +150,7 @@ public DevProxyConfigOptions()
             apiPortOption,
             ipAddressOption,
             configFileOption,
+            portOption,
             urlsToWatchOption,
             logForOption,
             logLevelOption,
diff --git a/DevProxy/Commands/LogsCommand.cs b/DevProxy/Commands/LogsCommand.cs
new file mode 100644
index 00000000..56ada018
--- /dev/null
+++ b/DevProxy/Commands/LogsCommand.cs
@@ -0,0 +1,227 @@
+// 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.State;
+using System.CommandLine;
+using System.Globalization;
+
+namespace DevProxy.Commands;
+
+internal sealed class LogsCommand : Command
+{
+    private readonly Option<bool> _followOption = new("--follow", "-f")
+    {
+        Description = "Follow log output (tail -f style)"
+    };
+
+    private readonly Option<int> _linesOption = new("--lines", "-n")
+    {
+        Description = "Number of lines to show from the end of the log",
+        HelpName = "N",
+        DefaultValueFactory = _ => 50
+    };
+
+    private readonly Option<string?> _sinceOption = new("--since")
+    {
+        Description = "Show logs since timestamp (e.g., '2026-01-24T14:00:00' or '5m' for 5 minutes ago)",
+        HelpName = "time"
+    };
+
+    public LogsCommand() : base("logs", "Show logs from running Dev Proxy instance")
+    {
+        Add(_followOption);
+        Add(_linesOption);
+        Add(_sinceOption);
+
+        SetAction(RunAsync);
+    }
+
+    private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
+    {
+        var follow = parseResult.GetValue(_followOption);
+        var lines = parseResult.GetValue(_linesOption);
+        var since = parseResult.GetValue(_sinceOption);
+
+        var state = await StateManager.LoadStateAsync(cancellationToken);
+
+        if (state == null)
+        {
+            Console.WriteLine("Dev Proxy is not running.");
+            return 1;
+        }
+
+        var logFile = state.LogFile;
+
+        if (string.IsNullOrEmpty(logFile) || !File.Exists(logFile))
+        {
+            Console.WriteLine($"Log file not found: {logFile}");
+            return 1;
+        }
+
+        var sinceTime = ParseSinceOption(since);
+
+        if (follow)
+        {
+            await FollowLogFileAsync(logFile, lines, sinceTime, cancellationToken);
+        }
+        else
+        {
+            await ShowLastLinesAsync(logFile, lines, sinceTime);
+        }
+
+        return 0;
+    }
+
+    private static DateTime? ParseSinceOption(string? since)
+    {
+        if (string.IsNullOrEmpty(since))
+        {
+            return null;
+        }
+
+        // Try parsing as a duration (e.g., "5m", "1h", "30s")
+        if (since.Length >= 2)
+        {
+            var unit = since[^1];
+            if (int.TryParse(since[..^1], out var value))
+            {
+                return unit switch
+                {
+                    's' => DateTime.Now.AddSeconds(-value),
+                    'm' => DateTime.Now.AddMinutes(-value),
+                    'h' => DateTime.Now.AddHours(-value),
+                    'd' => DateTime.Now.AddDays(-value),
+                    _ => null
+                };
+            }
+        }
+
+        // Try parsing as a datetime
+        if (DateTime.TryParse(since, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dateTime))
+        {
+            return dateTime;
+        }
+
+        return null;
+    }
+
+    private static async Task ShowLastLinesAsync(string logFile, int lineCount, DateTime? sinceTime)
+    {
+        var lines = new List<string>();
+        await foreach (var line in File.ReadLinesAsync(logFile))
+        {
+            lines.Add(line);
+        }
+
+        var filteredLines = FilterLines(lines, sinceTime);
+        var linesToShow = filteredLines.TakeLast(lineCount);
+
+        foreach (var line in linesToShow)
+        {
+            Console.WriteLine(line);
+        }
+    }
+
+    private static async Task FollowLogFileAsync(string logFile, int initialLines, DateTime? sinceTime, CancellationToken cancellationToken)
+    {
+        // Show initial lines
+        await ShowLastLinesAsync(logFile, initialLines, sinceTime);
+
+        // Follow new lines using FileSystemWatcher and reading from last position
+        var lastPosition = new FileInfo(logFile).Length;
+
+        using var watcher = new FileSystemWatcher(Path.GetDirectoryName(logFile)!, Path.GetFileName(logFile))
+        {
+            NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size,
+            EnableRaisingEvents = true
+        };
+
+        var newLineEvent = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        watcher.Changed += (_, _) =>
+        {
+            _ = newLineEvent.TrySetResult(true);
+        };
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            try
+            {
+                // Wait for file change or cancellation
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+                cts.CancelAfter(1000); // Check every second even without file changes
+
+                try
+                {
+                    _ = await newLineEvent.Task.WaitAsync(cts.Token);
+                    newLineEvent = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+                }
+                catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+                {
+                    // Timeout - check for new content anyway
+                }
+
+                // Read new content
+                using var fs = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+                if (fs.Length > lastPosition)
+                {
+                    _ = fs.Seek(lastPosition, SeekOrigin.Begin);
+                    using var reader = new StreamReader(fs);
+
+                    string? line;
+                    while ((line = await reader.ReadLineAsync(cancellationToken)) != null)
+                    {
+                        if (sinceTime == null || LineMatchesSince(line, sinceTime.Value))
+                        {
+                            Console.WriteLine(line);
+                        }
+                    }
+
+                    lastPosition = fs.Length;
+                }
+            }
+            catch (IOException)
+            {
+                // File might be temporarily locked
+                await Task.Delay(100, cancellationToken);
+            }
+        }
+    }
+
+    private static IEnumerable<string> FilterLines(IEnumerable<string> lines, DateTime? sinceTime)
+    {
+        if (sinceTime == null)
+        {
+            return lines;
+        }
+
+        return lines.Where(line => LineMatchesSince(line, sinceTime.Value));
+    }
+
+    private static bool LineMatchesSince(string line, DateTime sinceTime)
+    {
+        // Parse timestamp from line format: [HH:mm:ss.fff] ...
+        if (line.Length < 14 || line[0] != '[' || line[13] != ']')
+        {
+            return true; // Include lines that don't match the expected format
+        }
+
+        var timestampStr = line[1..13]; // "HH:mm:ss.fff"
+        if (TimeSpan.TryParseExact(timestampStr, "hh\\:mm\\:ss\\.fff", CultureInfo.InvariantCulture, out var timeOfDay))
+        {
+            // Assume the log is from today
+            var lineTime = DateTime.Today.Add(timeOfDay);
+
+            // If line time is in the future, assume it's from yesterday
+            if (lineTime > DateTime.Now)
+            {
+                lineTime = lineTime.AddDays(-1);
+            }
+
+            return lineTime >= sinceTime;
+        }
+
+        return true; // Include lines with unparseable timestamps
+    }
+}
\ No newline at end of file
diff --git a/DevProxy/Commands/StatusCommand.cs b/DevProxy/Commands/StatusCommand.cs
new file mode 100644
index 00000000..9bea26c1
--- /dev/null
+++ b/DevProxy/Commands/StatusCommand.cs
@@ -0,0 +1,82 @@
+// 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.State;
+using System.CommandLine;
+using System.Text.Json.Serialization;
+
+namespace DevProxy.Commands;
+
+internal sealed class StatusCommand : Command
+{
+    public StatusCommand() : base("status", "Show status of running Dev Proxy instance")
+    {
+        SetAction(RunAsync);
+    }
+
+    private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
+    {
+        var state = await StateManager.LoadStateAsync(cancellationToken);
+
+        if (state == null)
+        {
+            Console.WriteLine("Dev Proxy is not running.");
+            return 1;
+        }
+
+        // Try to get live status from the API
+        try
+        {
+            using var httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(5) };
+            var response = await httpClient.GetAsync($"{state.ApiUrl}/proxy", cancellationToken);
+
+            if (response.IsSuccessStatusCode)
+            {
+                var proxyInfo = await response.Content.ReadFromJsonAsync<ProxyStatusInfo>(cancellationToken: cancellationToken);
+
+                Console.WriteLine("Dev Proxy is running.");
+                Console.WriteLine();
+                Console.WriteLine($"  PID:        {state.Pid}");
+                Console.WriteLine($"  API URL:    {state.ApiUrl}");
+                Console.WriteLine($"  Port:       {state.Port}");
+                Console.WriteLine($"  Recording:  {(proxyInfo?.Recording == true ? "Yes" : "No")}");
+                if (!string.IsNullOrEmpty(state.ConfigFile))
+                {
+                    Console.WriteLine($"  Config:     {state.ConfigFile}");
+                }
+                Console.WriteLine($"  Log file:   {state.LogFile}");
+                Console.WriteLine($"  Started:    {state.StartedAt.LocalDateTime:g}");
+
+                return 0;
+            }
+        }
+        catch (HttpRequestException)
+        {
+            // API not responding - instance might be starting up or crashed
+        }
+        catch (TaskCanceledException)
+        {
+            // Timeout - instance might be busy
+        }
+
+        // Fall back to state file info
+        Console.WriteLine("Dev Proxy appears to be running (API not responding).");
+        Console.WriteLine();
+        Console.WriteLine($"  PID:        {state.Pid}");
+        Console.WriteLine($"  API URL:    {state.ApiUrl}");
+        Console.WriteLine($"  Log file:   {state.LogFile}");
+        Console.WriteLine($"  Started:    {state.StartedAt.LocalDateTime:g}");
+
+        return 0;
+    }
+
+    private sealed class ProxyStatusInfo
+    {
+        [JsonPropertyName("recording")]
+        public bool? Recording { get; set; }
+
+        [JsonPropertyName("configFile")]
+        public string? ConfigFile { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/DevProxy/Commands/StopCommand.cs b/DevProxy/Commands/StopCommand.cs
new file mode 100644
index 00000000..0105fa18
--- /dev/null
+++ b/DevProxy/Commands/StopCommand.cs
@@ -0,0 +1,139 @@
+// 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.State;
+using System.CommandLine;
+using System.Diagnostics;
+
+namespace DevProxy.Commands;
+
+internal sealed class StopCommand : Command
+{
+    private readonly Option<bool> _forceOption = new("--force", "-f")
+    {
+        Description = "Force stop the proxy by killing the process"
+    };
+
+    public StopCommand() : base("stop", "Stop running Dev Proxy instance")
+    {
+        Add(_forceOption);
+        SetAction(RunAsync);
+    }
+
+    private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
+    {
+        var force = parseResult.GetValue(_forceOption);
+        var state = await StateManager.LoadStateAsync(cancellationToken);
+
+        if (state == null)
+        {
+            Console.WriteLine("Dev Proxy is not running.");
+            return 1;
+        }
+
+        if (force)
+        {
+            return await ForceStopAsync(state, cancellationToken);
+        }
+
+        // Try graceful shutdown via API
+        try
+        {
+            using var httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
+            var response = await httpClient.PostAsync($"{state.ApiUrl}/proxy/stopProxy", null, cancellationToken);
+
+            if (response.IsSuccessStatusCode || response.StatusCode == System.Net.HttpStatusCode.Accepted)
+            {
+                Console.WriteLine("Stopping Dev Proxy...");
+
+                // Wait for process to exit
+                var stopwatch = Stopwatch.StartNew();
+                while (stopwatch.Elapsed < TimeSpan.FromSeconds(10))
+                {
+                    try
+                    {
+                        var process = Process.GetProcessById(state.Pid);
+                        if (process.HasExited)
+                        {
+                            break;
+                        }
+                    }
+                    catch (ArgumentException)
+                    {
+                        // Process has exited
+                        break;
+                    }
+
+                    await Task.Delay(200, cancellationToken);
+                }
+
+                // Verify the process actually exited before cleaning up state
+                var exited = false;
+                try
+                {
+                    var proc = Process.GetProcessById(state.Pid);
+                    exited = proc.HasExited;
+                }
+                catch (ArgumentException)
+                {
+                    exited = true;
+                }
+
+                if (!exited)
+                {
+                    Console.WriteLine("Dev Proxy did not stop in time.");
+                    Console.WriteLine("Use --force to forcefully terminate the process.");
+                    return 1;
+                }
+
+                await StateManager.DeleteStateAsync(cancellationToken);
+                Console.WriteLine("Dev Proxy stopped.");
+                return 0;
+            }
+
+            Console.WriteLine($"Failed to stop Dev Proxy: {response.StatusCode}");
+            Console.WriteLine("Use --force to forcefully terminate the process.");
+            return 1;
+        }
+        catch (HttpRequestException ex)
+        {
+            Console.WriteLine($"Failed to connect to Dev Proxy API: {ex.Message}");
+            Console.WriteLine("Use --force to forcefully terminate the process.");
+            return 1;
+        }
+        catch (TaskCanceledException)
+        {
+            Console.WriteLine("Timeout waiting for Dev Proxy to respond.");
+            Console.WriteLine("Use --force to forcefully terminate the process.");
+            return 1;
+        }
+    }
+
+    private static async Task<int> ForceStopAsync(ProxyInstanceState state, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var process = Process.GetProcessById(state.Pid);
+            process.Kill();
+
+            Console.WriteLine($"Forcefully terminated Dev Proxy (PID: {state.Pid}).");
+        }
+        catch (ArgumentException)
+        {
+            Console.WriteLine("Dev Proxy process not found (already stopped).");
+        }
+        catch (InvalidOperationException)
+        {
+            Console.WriteLine("Dev Proxy process has already exited.");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Failed to kill process: {ex.Message}");
+            return 1;
+        }
+
+        await StateManager.DeleteStateAsync(cancellationToken);
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/DevProxy/Extensions/ILoggingBuilderExtensions.cs b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
index 7e3e6a20..011451c1 100644
--- a/DevProxy/Extensions/ILoggingBuilderExtensions.cs
+++ b/DevProxy/Extensions/ILoggingBuilderExtensions.cs
@@ -100,6 +100,7 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
 
         // 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)
@@ -130,4 +131,4 @@ public static ILoggingBuilder ConfigureDevProxyLogging(
 
         return builder;
     }
-}
+}
\ No newline at end of file
diff --git a/DevProxy/Program.cs b/DevProxy/Program.cs
index 435288c9..6daaec8c 100644
--- a/DevProxy/Program.cs
+++ b/DevProxy/Program.cs
@@ -5,7 +5,161 @@
 using DevProxy;
 using DevProxy.Commands;
 using DevProxy.Proxy;
+using DevProxy.State;
+using System.Diagnostics;
 using System.Net;
+using System.Runtime.InteropServices;
+using System.Text;
+
+// Handle detached mode - spawn a child process and exit
+// Only applies to root command (starting the proxy), not subcommands
+if (DevProxyCommand.IsRootCommand &&
+    DevProxyCommand.IsDetachedMode &&
+    !DevProxyCommand.IsInternalDaemon)
+{
+    var detachedExitCode = await StartDetachedProcessAsync(args);
+    Environment.Exit(detachedExitCode);
+    return;
+}
+
+// For daemon mode, redirect Console.Out/Error to the log file
+// so that the normal console formatters (ProxyConsoleFormatter,
+// MachineConsoleFormatter) write to the file instead of stdout.
+// Console.IsOutputRedirected becomes true, which automatically
+// strips ANSI color codes from human-readable output.
+StreamWriter? _detachedLogWriter = null;
+if (DevProxyCommand.IsInternalDaemon)
+{
+    var logFilePath = DevProxyCommand.DetachedLogFilePath;
+    var logDir = Path.GetDirectoryName(logFilePath);
+    if (!string.IsNullOrEmpty(logDir) && !Directory.Exists(logDir))
+    {
+        _ = Directory.CreateDirectory(logDir);
+    }
+
+#pragma warning disable CA2000 // Lifetime managed manually; disposed before Environment.Exit
+    _detachedLogWriter = new StreamWriter(logFilePath, append: false, Encoding.UTF8) { AutoFlush = true };
+#pragma warning restore CA2000
+    Console.SetOut(_detachedLogWriter);
+    Console.SetError(_detachedLogWriter);
+}
+
+static async Task<int> StartDetachedProcessAsync(string[] args)
+{
+    // Check if an instance is already running
+    if (await StateManager.IsInstanceRunningAsync())
+    {
+        var existingState = await StateManager.LoadStateAsync();
+        await Console.Error.WriteLineAsync($"Dev Proxy is already running (PID: {existingState?.Pid}).");
+        await Console.Error.WriteLineAsync("Use 'devproxy stop' to stop it first.");
+        return 1;
+    }
+
+    // Clean up old log files
+    StateManager.CleanupOldLogs();
+
+    // Build the arguments for the daemon process
+    // Replace --detach/-d with --_internal-daemon
+    var daemonArgs = args
+        .Where(a => a is not "--detach" and not "-d")
+        .Append("--_internal-daemon")
+        .ToArray();
+
+    var executablePath = Environment.ProcessPath;
+    if (string.IsNullOrEmpty(executablePath))
+    {
+        await Console.Error.WriteLineAsync("Could not determine executable path.");
+        return 1;
+    }
+
+    var startInfo = new ProcessStartInfo
+    {
+        FileName = executablePath,
+        Arguments = string.Join(" ", daemonArgs.Select(EscapeArgument)),
+        UseShellExecute = false,
+        CreateNoWindow = true,
+        RedirectStandardOutput = true,
+        RedirectStandardError = true,
+        WorkingDirectory = Directory.GetCurrentDirectory()
+    };
+
+    // On Windows, we need to detach from the console
+    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+    {
+        startInfo.WindowStyle = ProcessWindowStyle.Hidden;
+    }
+
+    try
+    {
+        var process = Process.Start(startInfo);
+        if (process == null)
+        {
+            await Console.Error.WriteLineAsync("Failed to start Dev Proxy process.");
+            return 1;
+        }
+
+        // Wait a moment for the proxy to start and write its state file
+        var timeout = TimeSpan.FromSeconds(10);
+        var stopwatch = Stopwatch.StartNew();
+
+        while (stopwatch.Elapsed < timeout)
+        {
+            await Task.Delay(200);
+
+            var state = await StateManager.LoadStateAsync();
+            if (state != null)
+            {
+                await Console.Out.WriteLineAsync("Dev Proxy started in background.");
+                await Console.Out.WriteLineAsync();
+                await Console.Out.WriteLineAsync($"  PID:       {state.Pid}");
+                await Console.Out.WriteLineAsync($"  API URL:   {state.ApiUrl}");
+                await Console.Out.WriteLineAsync($"  Log file:  {state.LogFile}");
+                await Console.Out.WriteLineAsync();
+                await Console.Out.WriteLineAsync("Use 'devproxy status' to check status.");
+                await Console.Out.WriteLineAsync("Use 'devproxy logs' to view logs.");
+                await Console.Out.WriteLineAsync("Use 'devproxy stop' to stop.");
+                return 0;
+            }
+
+            // Check if process exited prematurely
+            if (process.HasExited)
+            {
+                var errorOutput = await process.StandardError.ReadToEndAsync();
+                var standardOutput = await process.StandardOutput.ReadToEndAsync();
+
+                await Console.Error.WriteLineAsync("Dev Proxy failed to start.");
+                if (!string.IsNullOrEmpty(errorOutput))
+                {
+                    await Console.Error.WriteLineAsync(errorOutput);
+                }
+                if (!string.IsNullOrEmpty(standardOutput))
+                {
+                    await Console.Error.WriteLineAsync(standardOutput);
+                }
+                return process.ExitCode;
+            }
+        }
+
+        await Console.Error.WriteLineAsync("Timeout waiting for Dev Proxy to start.");
+        await Console.Error.WriteLineAsync($"Check the log folder: {StateManager.GetLogsFolder()}");
+        return 1;
+    }
+    catch (Exception ex)
+    {
+        await Console.Error.WriteLineAsync($"Failed to start Dev Proxy: {ex.Message}");
+        return 1;
+    }
+}
+
+static string EscapeArgument(string arg)
+{
+    // Simple escaping for command line arguments
+    if (arg.Contains(' ', StringComparison.Ordinal) || arg.Contains('"', StringComparison.Ordinal))
+    {
+        return $"\"{arg.Replace("\"", "\\\"", StringComparison.Ordinal)}\"";
+    }
+    return arg;
+}
 
 static WebApplication BuildApplication(DevProxyConfigOptions options)
 {
@@ -45,11 +199,37 @@ static async Task<int> RunProxyAsync(string[] args, DevProxyConfigOptions option
     var app = BuildApplication(options);
     try
     {
+        // If running as daemon, save state so other commands can find us
+        if (DevProxyCommand.IsInternalDaemon)
+        {
+            var ipAddress = options.IPAddress ?? app.Configuration.GetValue("ipAddress", "127.0.0.1") ?? "127.0.0.1";
+            var apiPort = options.ApiPort ?? app.Configuration.GetValue("apiPort", 8897);
+            var port = options.Port ?? app.Configuration.GetValue("port", 8000);
+
+            var state = new ProxyInstanceState
+            {
+                Pid = Environment.ProcessId,
+                ApiUrl = $"http://{(ipAddress is "0.0.0.0" or "::" ? "127.0.0.1" : ipAddress)}:{apiPort}",
+                LogFile = DevProxyCommand.DetachedLogFilePath,
+                StartedAt = DateTimeOffset.UtcNow,
+                ConfigFile = options.ConfigFile,
+                Port = port
+            };
+
+            await StateManager.SaveStateAsync(state);
+        }
+
         var devProxyCommand = app.Services.GetRequiredService<DevProxyCommand>();
         return await devProxyCommand.InvokeAsync(args, app);
     }
     finally
     {
+        // Clean up state file when daemon exits
+        if (DevProxyCommand.IsInternalDaemon)
+        {
+            await StateManager.DeleteStateAsync();
+        }
+
         // Dispose the app to clean up all services (including FileSystemWatchers in BaseLoader)
         await app.DisposeAsync();
     }
@@ -101,4 +281,9 @@ static async Task<int> RunProxyAsync(string[] args, DevProxyConfigOptions option
     }
 } while (shouldRestart);
 
-Environment.Exit(exitCode);
+if (_detachedLogWriter is not null)
+{
+    await _detachedLogWriter.DisposeAsync();
+}
+
+Environment.Exit(exitCode);
\ No newline at end of file
diff --git a/DevProxy/Proxy/ProxyEngine.cs b/DevProxy/Proxy/ProxyEngine.cs
index ca945033..ada46ea3 100755
--- a/DevProxy/Proxy/ProxyEngine.cs
+++ b/DevProxy/Proxy/ProxyEngine.cs
@@ -5,6 +5,7 @@
 using DevProxy.Abstractions.Plugins;
 using DevProxy.Abstractions.Proxy;
 using DevProxy.Abstractions.Utils;
+using DevProxy.Commands;
 using Microsoft.VisualStudio.Threading;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -170,6 +171,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         }
 
         var isInteractive = !Console.IsInputRedirected &&
+            !DevProxyCommand.IsInternalDaemon &&
             Environment.GetEnvironmentVariable("CI") is null;
 
         if (_config.LogFor == LogFor.Machine)
diff --git a/DevProxy/State/ProxyInstanceState.cs b/DevProxy/State/ProxyInstanceState.cs
new file mode 100644
index 00000000..658992f6
--- /dev/null
+++ b/DevProxy/State/ProxyInstanceState.cs
@@ -0,0 +1,32 @@
+// 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 System.Text.Json.Serialization;
+
+namespace DevProxy.State;
+
+/// <summary>
+/// Represents the state of a running Dev Proxy instance.
+/// Stored in the Dev Proxy configuration folder (see <see cref="StateManager.GetConfigFolder"/>).
+/// </summary>
+internal sealed class ProxyInstanceState
+{
+    [JsonPropertyName("pid")]
+    public int Pid { get; set; }
+
+    [JsonPropertyName("apiUrl")]
+    public string ApiUrl { get; set; } = string.Empty;
+
+    [JsonPropertyName("logFile")]
+    public string LogFile { get; set; } = string.Empty;
+
+    [JsonPropertyName("startedAt")]
+    public DateTimeOffset StartedAt { get; set; }
+
+    [JsonPropertyName("configFile")]
+    public string? ConfigFile { get; set; }
+
+    [JsonPropertyName("port")]
+    public int Port { get; set; }
+}
\ No newline at end of file
diff --git a/DevProxy/State/StateManager.cs b/DevProxy/State/StateManager.cs
new file mode 100644
index 00000000..033d324c
--- /dev/null
+++ b/DevProxy/State/StateManager.cs
@@ -0,0 +1,232 @@
+// 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 System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+
+namespace DevProxy.State;
+
+/// <summary>
+/// Manages the state file for detached Dev Proxy instances.
+/// </summary>
+internal static class StateManager
+{
+    private const string StateFileName = "state.json";
+    private const string LogsFolderName = "logs";
+    private const string ProxyConfigurationFolderName = "dev-proxy";
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        WriteIndented = true
+    };
+
+    /// <summary>
+    /// Gets the path to the Dev Proxy configuration folder.
+    /// On macOS: ~/Library/Application Support/dev-proxy/
+    /// On Linux: ~/.config/dev-proxy/ (or $XDG_CONFIG_HOME/dev-proxy/)
+    /// On Windows: %LocalAppData%\dev-proxy\
+    /// </summary>
+    public static string GetConfigFolder()
+    {
+        string basePath;
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            // Use LocalApplicationData on Windows for consistency with CertificateDiskCache
+            basePath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        }
+        else
+        {
+            // Use ApplicationData on macOS/Linux (~/.config)
+            basePath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+        }
+
+        return Path.Combine(basePath, ProxyConfigurationFolderName);
+    }
+
+    /// <summary>
+    /// Gets the path to the state file.
+    /// </summary>
+    public static string GetStateFilePath()
+    {
+        return Path.Combine(GetConfigFolder(), StateFileName);
+    }
+
+    /// <summary>
+    /// Gets the path to the logs folder.
+    /// </summary>
+    public static string GetLogsFolder()
+    {
+        return Path.Combine(GetConfigFolder(), LogsFolderName);
+    }
+
+    /// <summary>
+    /// Generates a log file path for a new detached instance.
+    /// </summary>
+    public static string GenerateLogFilePath()
+    {
+        var logsFolder = GetLogsFolder();
+        var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd-HH-mm-ss", System.Globalization.CultureInfo.InvariantCulture);
+        var pid = Environment.ProcessId;
+        return Path.Combine(logsFolder, $"devproxy-{pid}-{timestamp}.log");
+    }
+
+    /// <summary>
+    /// Saves the state of a running detached instance.
+    /// </summary>
+    public static async Task SaveStateAsync(ProxyInstanceState state, CancellationToken cancellationToken = default)
+    {
+        var stateFilePath = GetStateFilePath();
+        var directory = Path.GetDirectoryName(stateFilePath);
+
+        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
+        {
+            _ = Directory.CreateDirectory(directory);
+        }
+
+        var json = JsonSerializer.Serialize(state, _jsonOptions);
+        await File.WriteAllTextAsync(stateFilePath, json, cancellationToken);
+    }
+
+    /// <summary>
+    /// Loads the state of a running detached instance.
+    /// Returns null if no state file exists or if the state is stale (process not running).
+    /// </summary>
+    public static async Task<ProxyInstanceState?> LoadStateAsync(CancellationToken cancellationToken = default)
+    {
+        var stateFilePath = GetStateFilePath();
+
+        if (!File.Exists(stateFilePath))
+        {
+            return null;
+        }
+
+        try
+        {
+            var json = await File.ReadAllTextAsync(stateFilePath, cancellationToken);
+            var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+
+            if (state == null)
+            {
+                return null;
+            }
+
+            // Verify the process is still running
+            if (!IsProcessRunning(state.Pid))
+            {
+                // Clean up stale state file
+                await DeleteStateAsync(cancellationToken);
+                return null;
+            }
+
+            return state;
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+        catch (IOException)
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Deletes the state file.
+    /// </summary>
+    public static Task DeleteStateAsync(CancellationToken cancellationToken = default)
+    {
+        var stateFilePath = GetStateFilePath();
+
+        try
+        {
+            if (File.Exists(stateFilePath))
+            {
+                File.Delete(stateFilePath);
+            }
+        }
+        catch (IOException)
+        {
+            // Ignore - file might be locked or already deleted
+        }
+
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Checks if a detached instance is already running.
+    /// </summary>
+    public static async Task<bool> IsInstanceRunningAsync(CancellationToken cancellationToken = default)
+    {
+        var state = await LoadStateAsync(cancellationToken);
+        return state != null;
+    }
+
+    /// <summary>
+    /// Checks if a process with the given PID is running.
+    /// </summary>
+    private static bool IsProcessRunning(int pid)
+    {
+        try
+        {
+            var process = Process.GetProcessById(pid);
+            return !process.HasExited;
+        }
+        catch (ArgumentException)
+        {
+            // Process doesn't exist
+            return false;
+        }
+        catch (InvalidOperationException)
+        {
+            // Process has exited
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Cleans up old log files, keeping only the most recent ones.
+    /// </summary>
+    public static void CleanupOldLogs(int maxAgeDays = 7, int maxFiles = 10)
+    {
+        var logsFolder = GetLogsFolder();
+
+        if (!Directory.Exists(logsFolder))
+        {
+            return;
+        }
+
+        try
+        {
+            var cutoffDate = DateTime.UtcNow.AddDays(-maxAgeDays);
+            var logFiles = Directory.GetFiles(logsFolder, "devproxy-*.log")
+                .Select(f => new FileInfo(f))
+                .OrderByDescending(f => f.CreationTimeUtc)
+                .ToList();
+
+            // Keep the most recent maxFiles
+            var filesToDelete = logFiles.Skip(maxFiles)
+                .Union(logFiles.Where(f => f.CreationTimeUtc < cutoffDate))
+                .Distinct()
+                .ToList();
+
+            foreach (var file in filesToDelete)
+            {
+                try
+                {
+                    file.Delete();
+                }
+                catch (IOException)
+                {
+                    // Ignore - file might be in use
+                }
+            }
+        }
+        catch (IOException)
+        {
+            // Ignore cleanup errors
+        }
+    }
+}
\ No newline at end of file

From 049cd1d3c1bf3cad9734c94435112f0193ddd90f Mon Sep 17 00:00:00 2001
From: Waldek Mastykarz <waldek@mastykarz.nl>
Date: Wed, 25 Feb 2026 13:58:08 +0100
Subject: [PATCH 2/2] Fix system proxy cleanup on stop and timeout on toggle

- Add 10s timeout to ToggleSystemProxy to prevent indefinite hangs
  in daemon context (Problem 1)
- Add proxy cleanup in ForceStopAsync before killing the process
  to prevent orphaned system proxy settings (Problem 2)
---
 DevProxy/Commands/StopCommand.cs | 44 ++++++++++++++++++++++++++++++++
 DevProxy/Proxy/ProxyEngine.cs    |  5 +++-
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/DevProxy/Commands/StopCommand.cs b/DevProxy/Commands/StopCommand.cs
index 0105fa18..48d92117 100644
--- a/DevProxy/Commands/StopCommand.cs
+++ b/DevProxy/Commands/StopCommand.cs
@@ -112,6 +112,8 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
     private static async Task<int> ForceStopAsync(ProxyInstanceState state, CancellationToken cancellationToken)
     {
+        DisableSystemProxy();
+
         try
         {
             var process = Process.GetProcessById(state.Pid);
@@ -136,4 +138,46 @@ private static async Task<int> ForceStopAsync(ProxyInstanceState state, Cancella
         await StateManager.DeleteStateAsync(cancellationToken);
         return 0;
     }
+
+    /// <summary>
+    /// Disables the system proxy on macOS by calling toggle-proxy.sh off.
+    /// This ensures the system proxy settings are cleaned up even when the
+    /// daemon process is killed forcefully (SIGKILL cannot be caught).
+    /// </summary>
+    private static void DisableSystemProxy()
+    {
+        if (!OperatingSystem.IsMacOS())
+        {
+            return;
+        }
+
+        var bashScriptPath = Path.Join(AppContext.BaseDirectory, "toggle-proxy.sh");
+        if (!File.Exists(bashScriptPath))
+        {
+            return;
+        }
+
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = "/bin/bash",
+            Arguments = $"{bashScriptPath} off",
+            RedirectStandardOutput = true,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        try
+        {
+            using var process = new Process { StartInfo = startInfo };
+            process.Start();
+            if (!process.WaitForExit(TimeSpan.FromSeconds(10)))
+            {
+                process.Kill();
+            }
+        }
+        catch
+        {
+            // Best-effort cleanup — don't block the stop flow
+        }
+    }
 }
\ No newline at end of file
diff --git a/DevProxy/Proxy/ProxyEngine.cs b/DevProxy/Proxy/ProxyEngine.cs
index ada46ea3..851e74cb 100755
--- a/DevProxy/Proxy/ProxyEngine.cs
+++ b/DevProxy/Proxy/ProxyEngine.cs
@@ -697,7 +697,10 @@ private static void ToggleSystemProxy(ToggleSystemProxyAction toggle, string? ip
 
         using var process = new Process() { StartInfo = startInfo };
         _ = process.Start();
-        process.WaitForExit();
+        if (!process.WaitForExit(TimeSpan.FromSeconds(10)))
+        {
+            process.Kill();
+        }
     }
 
     private static int GetProcessId(TunnelConnectSessionEventArgs e)