From 2ff434a7416d89c1b8d683209e9a6c4d0ee6f570 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:27:44 +0000
Subject: [PATCH 1/5] Initial plan


From 5bd30d1c10b3f59a71a7003196db4290a399fcc7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:33:03 +0000
Subject: [PATCH 2/5] Allow multiple Dev Proxy instances when asSystemProxy is
 false

When asSystemProxy is false, the single-instance check is skipped
so multiple Dev Proxy instances can run simultaneously.

The AsSystemProxy value is now stored in the state file so the
detached mode launch check can determine if the existing instance
is acting as the system proxy.

Closes dotnet/dev-proxy#1586

Co-authored-by: waldekmastykarz <11164679+waldekmastykarz@users.noreply.github.com>
---
 DevProxy/Commands/DevProxyConfigOptions.cs |  3 +++
 DevProxy/Program.cs                        | 13 ++++++++-----
 DevProxy/State/ProxyInstanceState.cs       |  3 +++
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/DevProxy/Commands/DevProxyConfigOptions.cs b/DevProxy/Commands/DevProxyConfigOptions.cs
index 89015fa6..0abaf3ea 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 bool? AsSystemProxy => _parseResult?.GetValueOrDefault<bool?>(DevProxyCommand.AsSystemProxyOptionName);
     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);
@@ -138,6 +139,7 @@ public DevProxyConfigOptions()
         };
 
         var apiPortOption = new Option<int?>(DevProxyCommand.ApiPortOptionName);
+        var asSystemProxyOption = new Option<bool?>(DevProxyCommand.AsSystemProxyOptionName);
         var portOption = new Option<int?>(DevProxyCommand.PortOptionName, "-p");
 
         var discoverOption = new Option<bool>(DevProxyCommand.DiscoverOptionName, "--discover")
@@ -153,6 +155,7 @@ public DevProxyConfigOptions()
         var options = new List<Option>
         {
             apiPortOption,
+            asSystemProxyOption,
             ipAddressOption,
             configFileOption,
             portOption,
diff --git a/DevProxy/Program.cs b/DevProxy/Program.cs
index 78912573..09fe0c31 100644
--- a/DevProxy/Program.cs
+++ b/DevProxy/Program.cs
@@ -46,11 +46,11 @@
 
 static async Task<int> StartDetachedProcessAsync(string[] args)
 {
-    // Check if an instance is already running
-    if (await StateManager.IsInstanceRunningAsync())
+    // Check if an instance is already running as system proxy
+    var existingState = await StateManager.LoadStateAsync();
+    if (existingState is not null && existingState.AsSystemProxy)
     {
-        var existingState = await StateManager.LoadStateAsync();
-        await Console.Error.WriteLineAsync($"Dev Proxy is already running (PID: {existingState?.Pid}).");
+        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;
     }
@@ -206,6 +206,8 @@ static async Task<int> RunProxyAsync(string[] args, DevProxyConfigOptions option
             var apiPort = options.ApiPort ?? app.Configuration.GetValue("apiPort", 8897);
             var port = options.Port ?? app.Configuration.GetValue("port", 8000);
 
+            var asSystemProxy = options.AsSystemProxy ?? app.Configuration.GetValue("asSystemProxy", true);
+
             var state = new ProxyInstanceState
             {
                 Pid = Environment.ProcessId,
@@ -213,7 +215,8 @@ static async Task<int> RunProxyAsync(string[] args, DevProxyConfigOptions option
                 LogFile = DevProxyCommand.DetachedLogFilePath,
                 StartedAt = DateTimeOffset.UtcNow,
                 ConfigFile = options.ConfigFile,
-                Port = port
+                Port = port,
+                AsSystemProxy = asSystemProxy
             };
 
             await StateManager.SaveStateAsync(state);
diff --git a/DevProxy/State/ProxyInstanceState.cs b/DevProxy/State/ProxyInstanceState.cs
index 658992f6..be1f80df 100644
--- a/DevProxy/State/ProxyInstanceState.cs
+++ b/DevProxy/State/ProxyInstanceState.cs
@@ -29,4 +29,7 @@ internal sealed class ProxyInstanceState
 
     [JsonPropertyName("port")]
     public int Port { get; set; }
+
+    [JsonPropertyName("asSystemProxy")]
+    public bool AsSystemProxy { get; set; } = true;
 }
\ No newline at end of file

From 0170b3dde1555f1037d63b7c54f8b74906259d15 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 15:08:03 +0000
Subject: [PATCH 3/5] Switch to per-instance state files to avoid
 cross-instance interference

Each detached instance now stores its state in a separate file keyed
by PID (e.g. state-1234.json) instead of a single shared state.json.

This ensures that:
- Multiple non-system-proxy instances don't overwrite each other's state
- Deleting state on exit only removes the current instance's file
- devproxy stop/status/logs still work by preferring the system-proxy
  instance, then falling back to the most recently started one
- Legacy state.json files are still read for backward compatibility

StopCommand now passes the specific PID when deleting state to avoid
accidentally removing another instance's state file.

Co-authored-by: waldekmastykarz <11164679+waldekmastykarz@users.noreply.github.com>
---
 DevProxy/Commands/StopCommand.cs |   4 +-
 DevProxy/Program.cs              |   8 +-
 DevProxy/State/StateManager.cs   | 200 ++++++++++++++++++++++++-------
 3 files changed, 166 insertions(+), 46 deletions(-)

diff --git a/DevProxy/Commands/StopCommand.cs b/DevProxy/Commands/StopCommand.cs
index 48d92117..f97d59a5 100644
--- a/DevProxy/Commands/StopCommand.cs
+++ b/DevProxy/Commands/StopCommand.cs
@@ -87,7 +87,7 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
                     return 1;
                 }
 
-                await StateManager.DeleteStateAsync(cancellationToken);
+                await StateManager.DeleteStateAsync(state.Pid, cancellationToken);
                 Console.WriteLine("Dev Proxy stopped.");
                 return 0;
             }
@@ -135,7 +135,7 @@ private static async Task<int> ForceStopAsync(ProxyInstanceState state, Cancella
             return 1;
         }
 
-        await StateManager.DeleteStateAsync(cancellationToken);
+        await StateManager.DeleteStateAsync(state.Pid, cancellationToken);
         return 0;
     }
 
diff --git a/DevProxy/Program.cs b/DevProxy/Program.cs
index 09fe0c31..489f630d 100644
--- a/DevProxy/Program.cs
+++ b/DevProxy/Program.cs
@@ -47,10 +47,10 @@
 static async Task<int> StartDetachedProcessAsync(string[] args)
 {
     // Check if an instance is already running as system proxy
-    var existingState = await StateManager.LoadStateAsync();
-    if (existingState is not null && existingState.AsSystemProxy)
+    var systemProxyInstance = await StateManager.FindSystemProxyInstanceAsync();
+    if (systemProxyInstance is not null)
     {
-        await Console.Error.WriteLineAsync($"Dev Proxy is already running (PID: {existingState.Pid}).");
+        await Console.Error.WriteLineAsync($"Dev Proxy is already running (PID: {systemProxyInstance.Pid}).");
         await Console.Error.WriteLineAsync("Use 'devproxy stop' to stop it first.");
         return 1;
     }
@@ -106,7 +106,7 @@ static async Task<int> StartDetachedProcessAsync(string[] args)
         {
             await Task.Delay(200);
 
-            var state = await StateManager.LoadStateAsync();
+            var state = await StateManager.LoadStateByPidAsync(process.Id);
             if (state != null)
             {
                 await Console.Out.WriteLineAsync("Dev Proxy started in background.");
diff --git a/DevProxy/State/StateManager.cs b/DevProxy/State/StateManager.cs
index 033d324c..183892b2 100644
--- a/DevProxy/State/StateManager.cs
+++ b/DevProxy/State/StateManager.cs
@@ -9,11 +9,15 @@
 namespace DevProxy.State;
 
 /// <summary>
-/// Manages the state file for detached Dev Proxy instances.
+/// Manages per-instance state files for detached Dev Proxy instances.
+/// Each instance stores its state in a separate file keyed by PID
+/// (e.g. state-1234.json) to avoid cross-instance interference.
 /// </summary>
 internal static class StateManager
 {
-    private const string StateFileName = "state.json";
+    private const string LegacyStateFileName = "state.json";
+    private const string StateFilePrefix = "state-";
+    private const string StateFileExtension = ".json";
     private const string LogsFolderName = "logs";
     private const string ProxyConfigurationFolderName = "dev-proxy";
 
@@ -47,11 +51,19 @@ public static string GetConfigFolder()
     }
 
     /// <summary>
-    /// Gets the path to the state file.
+    /// Gets the per-instance state file path for the given PID.
+    /// </summary>
+    public static string GetInstanceStateFilePath(int pid)
+    {
+        return Path.Combine(GetConfigFolder(), $"{StateFilePrefix}{pid}{StateFileExtension}");
+    }
+
+    /// <summary>
+    /// Gets the path to the legacy single state file (for backward compatibility).
     /// </summary>
     public static string GetStateFilePath()
     {
-        return Path.Combine(GetConfigFolder(), StateFileName);
+        return Path.Combine(GetConfigFolder(), LegacyStateFileName);
     }
 
     /// <summary>
@@ -74,11 +86,11 @@ public static string GenerateLogFilePath()
     }
 
     /// <summary>
-    /// Saves the state of a running detached instance.
+    /// Saves the state of a running detached instance to a per-PID state file.
     /// </summary>
     public static async Task SaveStateAsync(ProxyInstanceState state, CancellationToken cancellationToken = default)
     {
-        var stateFilePath = GetStateFilePath();
+        var stateFilePath = GetInstanceStateFilePath(state.Pid);
         var directory = Path.GetDirectoryName(stateFilePath);
 
         if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
@@ -91,68 +103,116 @@ public static async Task SaveStateAsync(ProxyInstanceState state, CancellationTo
     }
 
     /// <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).
+    /// Loads the primary running instance's state.
+    /// Prefers the system-proxy instance, then falls back to the most recently
+    /// started instance. Returns null if no live instance is found.
     /// </summary>
     public static async Task<ProxyInstanceState?> LoadStateAsync(CancellationToken cancellationToken = default)
     {
-        var stateFilePath = GetStateFilePath();
+        var states = await LoadAllStatesAsync(cancellationToken);
+        return states
+            .OrderByDescending(s => s.AsSystemProxy)
+            .ThenByDescending(s => s.StartedAt)
+            .FirstOrDefault();
+    }
 
-        if (!File.Exists(stateFilePath))
+    /// <summary>
+    /// Loads the state of a specific instance by PID.
+    /// Returns null if no state file exists or the process is no longer running.
+    /// </summary>
+    public static async Task<ProxyInstanceState?> LoadStateByPidAsync(int pid, CancellationToken cancellationToken = default)
+    {
+        return await LoadStateFromFileAsync(GetInstanceStateFilePath(pid), cancellationToken);
+    }
+
+    /// <summary>
+    /// Loads all live detached instance states, cleaning up stale state files.
+    /// Also checks the legacy state.json for backward compatibility.
+    /// </summary>
+    public static async Task<List<ProxyInstanceState>> LoadAllStatesAsync(CancellationToken cancellationToken = default)
+    {
+        var configFolder = GetConfigFolder();
+        if (!Directory.Exists(configFolder))
         {
-            return null;
+            return [];
         }
 
-        try
-        {
-            var json = await File.ReadAllTextAsync(stateFilePath, cancellationToken);
-            var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+        var states = new List<ProxyInstanceState>();
+        var seenPids = new HashSet<int>();
 
-            if (state == null)
+        // Check per-instance state files
+        var stateFiles = Directory.GetFiles(configFolder, $"{StateFilePrefix}*{StateFileExtension}");
+        foreach (var filePath in stateFiles)
+        {
+            var state = await LoadStateFromFileAsync(filePath, cancellationToken);
+            if (state is not null && seenPids.Add(state.Pid))
             {
-                return null;
+                states.Add(state);
             }
+        }
 
-            // Verify the process is still running
-            if (!IsProcessRunning(state.Pid))
+        // Also check legacy state file for backward compatibility
+        var legacyPath = GetStateFilePath();
+        if (File.Exists(legacyPath))
+        {
+            var legacyState = await LoadStateFromFileAsync(legacyPath, cancellationToken);
+            if (legacyState is not null && seenPids.Add(legacyState.Pid))
             {
-                // Clean up stale state file
-                await DeleteStateAsync(cancellationToken);
-                return null;
+                states.Add(legacyState);
             }
-
-            return state;
-        }
-        catch (JsonException)
-        {
-            return null;
-        }
-        catch (IOException)
-        {
-            return null;
         }
+
+        return states;
     }
 
     /// <summary>
-    /// Deletes the state file.
+    /// Finds a running detached instance that owns the system proxy.
+    /// Returns null if no system-proxy instance is running.
     /// </summary>
-    public static Task DeleteStateAsync(CancellationToken cancellationToken = default)
+    public static async Task<ProxyInstanceState?> FindSystemProxyInstanceAsync(CancellationToken cancellationToken = default)
     {
-        var stateFilePath = GetStateFilePath();
+        var states = await LoadAllStatesAsync(cancellationToken);
+        return states.Find(s => s.AsSystemProxy);
+    }
+
+    /// <summary>
+    /// Deletes the state file for a specific PID.
+    /// Also cleans up the legacy state file if it belongs to this PID.
+    /// </summary>
+    public static async Task DeleteStateAsync(int pid, CancellationToken cancellationToken = default)
+    {
+        DeleteFile(GetInstanceStateFilePath(pid));
 
+        // Also clean up legacy state file if it belongs to this PID
+        var legacyPath = GetStateFilePath();
         try
         {
-            if (File.Exists(stateFilePath))
+            if (File.Exists(legacyPath))
             {
-                File.Delete(stateFilePath);
+                var json = await File.ReadAllTextAsync(legacyPath, cancellationToken);
+                var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+                if (state?.Pid == pid)
+                {
+                    DeleteFile(legacyPath);
+                }
             }
         }
+        catch (JsonException)
+        {
+            // Ignore corrupt legacy file
+        }
         catch (IOException)
         {
-            // Ignore - file might be locked or already deleted
+            // Ignore I/O errors
         }
+    }
 
-        return Task.CompletedTask;
+    /// <summary>
+    /// Deletes the state file for the current process.
+    /// </summary>
+    public static Task DeleteStateAsync(CancellationToken cancellationToken = default)
+    {
+        return DeleteStateAsync(Environment.ProcessId, cancellationToken);
     }
 
     /// <summary>
@@ -161,7 +221,7 @@ public static Task DeleteStateAsync(CancellationToken cancellationToken = defaul
     public static async Task<bool> IsInstanceRunningAsync(CancellationToken cancellationToken = default)
     {
         var state = await LoadStateAsync(cancellationToken);
-        return state != null;
+        return state is not null;
     }
 
     /// <summary>
@@ -186,6 +246,66 @@ private static bool IsProcessRunning(int pid)
         }
     }
 
+    /// <summary>
+    /// Loads a state from a specific file path.
+    /// Returns null if the file doesn't exist, can't be parsed,
+    /// or refers to a process that's no longer running.
+    /// Cleans up the file if the process is stale.
+    /// </summary>
+    private static async Task<ProxyInstanceState?> LoadStateFromFileAsync(
+        string filePath,
+        CancellationToken cancellationToken)
+    {
+        if (!File.Exists(filePath))
+        {
+            return null;
+        }
+
+        try
+        {
+            var json = await File.ReadAllTextAsync(filePath, cancellationToken);
+            var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+
+            if (state is null)
+            {
+                return null;
+            }
+
+            // Verify the process is still running
+            if (!IsProcessRunning(state.Pid))
+            {
+                // Clean up stale state file
+                DeleteFile(filePath);
+                return null;
+            }
+
+            return state;
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+        catch (IOException)
+        {
+            return null;
+        }
+    }
+
+    private static void DeleteFile(string path)
+    {
+        try
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+        catch (IOException)
+        {
+            // Ignore - file might be locked or already deleted
+        }
+    }
+
     /// <summary>
     /// Cleans up old log files, keeping only the most recent ones.
     /// </summary>

From c9a5f80a6c7d89f604c5b14a67bca21c07f94326 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 15:09:15 +0000
Subject: [PATCH 4/5] Clarify boolean sort order in LoadStateAsync

Co-authored-by: waldekmastykarz <11164679+waldekmastykarz@users.noreply.github.com>
---
 DevProxy/State/StateManager.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DevProxy/State/StateManager.cs b/DevProxy/State/StateManager.cs
index 183892b2..c73b3785 100644
--- a/DevProxy/State/StateManager.cs
+++ b/DevProxy/State/StateManager.cs
@@ -111,7 +111,7 @@ public static async Task SaveStateAsync(ProxyInstanceState state, CancellationTo
     {
         var states = await LoadAllStatesAsync(cancellationToken);
         return states
-            .OrderByDescending(s => s.AsSystemProxy)
+            .OrderByDescending(s => s.AsSystemProxy ? 1 : 0)
             .ThenByDescending(s => s.StartedAt)
             .FirstOrDefault();
     }

From 9a15ce9e19f77b8a90cd4021b78eacd6487c0294 Mon Sep 17 00:00:00 2001
From: Waldek Mastykarz <waldek@mastykarz.nl>
Date: Fri, 6 Mar 2026 13:52:34 +0100
Subject: [PATCH 5/5] Add PID option to logs, status, and stop commands;
 enhance instance management

---
 DevProxy/Commands/LogsCommand.cs   | 29 ++++++++++---
 DevProxy/Commands/StatusCommand.cs | 69 ++++++++++++++++++++++--------
 DevProxy/Commands/StopCommand.cs   | 60 ++++++++++++++++++++------
 DevProxy/Program.cs                | 52 +++++++++++-----------
 DevProxy/Proxy/ProxyEngine.cs      | 37 +++++++++++++++-
 5 files changed, 187 insertions(+), 60 deletions(-)

diff --git a/DevProxy/Commands/LogsCommand.cs b/DevProxy/Commands/LogsCommand.cs
index 56ada018..652ce783 100644
--- a/DevProxy/Commands/LogsCommand.cs
+++ b/DevProxy/Commands/LogsCommand.cs
@@ -28,11 +28,17 @@ internal sealed class LogsCommand : Command
         HelpName = "time"
     };
 
+    private readonly Option<int?> _pidOption = new("--pid")
+    {
+        Description = "Show logs from a specific Dev Proxy instance by PID"
+    };
+
     public LogsCommand() : base("logs", "Show logs from running Dev Proxy instance")
     {
         Add(_followOption);
         Add(_linesOption);
         Add(_sinceOption);
+        Add(_pidOption);
 
         SetAction(RunAsync);
     }
@@ -42,13 +48,26 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
         var follow = parseResult.GetValue(_followOption);
         var lines = parseResult.GetValue(_linesOption);
         var since = parseResult.GetValue(_sinceOption);
+        var pid = parseResult.GetValue(_pidOption);
 
-        var state = await StateManager.LoadStateAsync(cancellationToken);
-
-        if (state == null)
+        ProxyInstanceState? state;
+        if (pid is not null)
         {
-            Console.WriteLine("Dev Proxy is not running.");
-            return 1;
+            state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
+                return 1;
+            }
+        }
+        else
+        {
+            state = await StateManager.LoadStateAsync(cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine("Dev Proxy is not running.");
+                return 1;
+            }
         }
 
         var logFile = state.LogFile;
diff --git a/DevProxy/Commands/StatusCommand.cs b/DevProxy/Commands/StatusCommand.cs
index 9bea26c1..1d76570d 100644
--- a/DevProxy/Commands/StatusCommand.cs
+++ b/DevProxy/Commands/StatusCommand.cs
@@ -10,21 +10,56 @@ namespace DevProxy.Commands;
 
 internal sealed class StatusCommand : Command
 {
-    public StatusCommand() : base("status", "Show status of running Dev Proxy instance")
+    private readonly Option<int?> _pidOption = new("--pid")
     {
+        Description = "Show status of a specific Dev Proxy instance by PID"
+    };
+
+    public StatusCommand() : base("status", "Show status of running Dev Proxy instances")
+    {
+        Add(_pidOption);
         SetAction(RunAsync);
     }
 
     private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
     {
-        var state = await StateManager.LoadStateAsync(cancellationToken);
+        var pid = parseResult.GetValue(_pidOption);
 
-        if (state == null)
+        if (pid is not null)
+        {
+            var state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
+                return 1;
+            }
+
+            await PrintInstanceStatusAsync(state, cancellationToken);
+            return 0;
+        }
+
+        var states = await StateManager.LoadAllStatesAsync(cancellationToken);
+        if (states.Count == 0)
         {
             Console.WriteLine("Dev Proxy is not running.");
             return 1;
         }
 
+        for (var i = 0; i < states.Count; i++)
+        {
+            if (i > 0)
+            {
+                Console.WriteLine();
+            }
+
+            await PrintInstanceStatusAsync(states[i], cancellationToken);
+        }
+
+        return 0;
+    }
+
+    private static async Task PrintInstanceStatusAsync(ProxyInstanceState state, CancellationToken cancellationToken)
+    {
         // Try to get live status from the API
         try
         {
@@ -37,18 +72,19 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
                 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")}");
+                Console.WriteLine($"  PID:              {state.Pid}");
+                Console.WriteLine($"  API URL:          {state.ApiUrl}");
+                Console.WriteLine($"  Port:             {state.Port}");
+                Console.WriteLine($"  System proxy:     {(state.AsSystemProxy ? "Yes" : "No")}");
+                Console.WriteLine($"  Recording:        {(proxyInfo?.Recording == true ? "Yes" : "No")}");
                 if (!string.IsNullOrEmpty(state.ConfigFile))
                 {
-                    Console.WriteLine($"  Config:     {state.ConfigFile}");
+                    Console.WriteLine($"  Config:           {state.ConfigFile}");
                 }
-                Console.WriteLine($"  Log file:   {state.LogFile}");
-                Console.WriteLine($"  Started:    {state.StartedAt.LocalDateTime:g}");
+                Console.WriteLine($"  Log file:         {state.LogFile}");
+                Console.WriteLine($"  Started:          {state.StartedAt.LocalDateTime:g}");
 
-                return 0;
+                return;
             }
         }
         catch (HttpRequestException)
@@ -63,12 +99,11 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
         // 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;
+        Console.WriteLine($"  PID:              {state.Pid}");
+        Console.WriteLine($"  API URL:          {state.ApiUrl}");
+        Console.WriteLine($"  System proxy:     {(state.AsSystemProxy ? "Yes" : "No")}");
+        Console.WriteLine($"  Log file:         {state.LogFile}");
+        Console.WriteLine($"  Started:          {state.StartedAt.LocalDateTime:g}");
     }
 
     private sealed class ProxyStatusInfo
diff --git a/DevProxy/Commands/StopCommand.cs b/DevProxy/Commands/StopCommand.cs
index f97d59a5..5767f34d 100644
--- a/DevProxy/Commands/StopCommand.cs
+++ b/DevProxy/Commands/StopCommand.cs
@@ -15,23 +15,57 @@ internal sealed class StopCommand : Command
         Description = "Force stop the proxy by killing the process"
     };
 
-    public StopCommand() : base("stop", "Stop running Dev Proxy instance")
+    private readonly Option<int?> _pidOption = new("--pid")
+    {
+        Description = "Stop a specific Dev Proxy instance by PID"
+    };
+
+    public StopCommand() : base("stop", "Stop running Dev Proxy instances")
     {
         Add(_forceOption);
+        Add(_pidOption);
         SetAction(RunAsync);
     }
 
     private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
     {
         var force = parseResult.GetValue(_forceOption);
-        var state = await StateManager.LoadStateAsync(cancellationToken);
+        var pid = parseResult.GetValue(_pidOption);
+
+        if (pid is not null)
+        {
+            var state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
+                return 1;
+            }
+
+            return await StopInstanceAsync(state, force, cancellationToken);
+        }
 
-        if (state == null)
+        var states = await StateManager.LoadAllStatesAsync(cancellationToken);
+        if (states.Count == 0)
         {
             Console.WriteLine("Dev Proxy is not running.");
             return 1;
         }
 
+        var exitCode = 0;
+        foreach (var state in states)
+        {
+            var result = await StopInstanceAsync(state, force, cancellationToken);
+            if (result != 0)
+            {
+                exitCode = result;
+            }
+        }
+
+        return exitCode;
+    }
+
+    private static async Task<int> StopInstanceAsync(ProxyInstanceState state, bool force, CancellationToken cancellationToken)
+    {
         if (force)
         {
             return await ForceStopAsync(state, cancellationToken);
@@ -45,7 +79,7 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
             if (response.IsSuccessStatusCode || response.StatusCode == System.Net.HttpStatusCode.Accepted)
             {
-                Console.WriteLine("Stopping Dev Proxy...");
+                Console.WriteLine($"Stopping Dev Proxy (PID: {state.Pid})...");
 
                 // Wait for process to exit
                 var stopwatch = Stopwatch.StartNew();
@@ -82,30 +116,30 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
                 if (!exited)
                 {
-                    Console.WriteLine("Dev Proxy did not stop in time.");
-                    Console.WriteLine("Use --force to forcefully terminate the process.");
+                    Console.WriteLine($"Dev Proxy (PID: {state.Pid}) did not stop in time.");
+                    Console.WriteLine($"Use --force --pid {state.Pid} to forcefully terminate the process.");
                     return 1;
                 }
 
                 await StateManager.DeleteStateAsync(state.Pid, cancellationToken);
-                Console.WriteLine("Dev Proxy stopped.");
+                Console.WriteLine($"Dev Proxy (PID: {state.Pid}) stopped.");
                 return 0;
             }
 
-            Console.WriteLine($"Failed to stop Dev Proxy: {response.StatusCode}");
-            Console.WriteLine("Use --force to forcefully terminate the process.");
+            Console.WriteLine($"Failed to stop Dev Proxy (PID: {state.Pid}): {response.StatusCode}");
+            Console.WriteLine($"Use --force --pid {state.Pid} 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.");
+            Console.WriteLine($"Failed to connect to Dev Proxy API (PID: {state.Pid}): {ex.Message}");
+            Console.WriteLine($"Use --force --pid {state.Pid} 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.");
+            Console.WriteLine($"Timeout waiting for Dev Proxy (PID: {state.Pid}) to respond.");
+            Console.WriteLine($"Use --force --pid {state.Pid} to forcefully terminate the process.");
             return 1;
         }
     }
diff --git a/DevProxy/Program.cs b/DevProxy/Program.cs
index 489f630d..c280d87f 100644
--- a/DevProxy/Program.cs
+++ b/DevProxy/Program.cs
@@ -50,11 +50,38 @@ static async Task<int> StartDetachedProcessAsync(string[] args)
     var systemProxyInstance = await StateManager.FindSystemProxyInstanceAsync();
     if (systemProxyInstance is not null)
     {
-        await Console.Error.WriteLineAsync($"Dev Proxy is already running (PID: {systemProxyInstance.Pid}).");
+        await Console.Error.WriteLineAsync($"Dev Proxy is already running as system proxy (PID: {systemProxyInstance.Pid}).");
         await Console.Error.WriteLineAsync("Use 'devproxy stop' to stop it first.");
         return 1;
     }
 
+    // Check for port conflicts with existing instances
+    var existingStates = await StateManager.LoadAllStatesAsync();
+    if (existingStates.Count > 0)
+    {
+        var earlyOptions = new DevProxyConfigOptions();
+        earlyOptions.ParseOptions(args);
+        var requestedPort = earlyOptions.Port ?? 8000;
+        var requestedApiPort = earlyOptions.ApiPort ?? 8897;
+
+        foreach (var existing in existingStates)
+        {
+            if (requestedPort != 0 && existing.Port == requestedPort)
+            {
+                await Console.Error.WriteLineAsync($"Port {requestedPort} is already in use by Dev Proxy instance (PID: {existing.Pid}).");
+                await Console.Error.WriteLineAsync("Use a different --port or stop the existing instance first.");
+                return 1;
+            }
+
+            if (requestedApiPort != 0 && existing.ApiUrl.EndsWith($":{requestedApiPort}", StringComparison.Ordinal))
+            {
+                await Console.Error.WriteLineAsync($"API port {requestedApiPort} is already in use by Dev Proxy instance (PID: {existing.Pid}).");
+                await Console.Error.WriteLineAsync("Use a different --api-port or stop the existing instance first.");
+                return 1;
+            }
+        }
+    }
+
     // Clean up old log files
     StateManager.CleanupOldLogs();
 
@@ -199,29 +226,6 @@ 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 asSystemProxy = options.AsSystemProxy ?? app.Configuration.GetValue("asSystemProxy", true);
-
-            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,
-                AsSystemProxy = asSystemProxy
-            };
-
-            await StateManager.SaveStateAsync(state);
-        }
-
         var devProxyCommand = app.Services.GetRequiredService<DevProxyCommand>();
         return await devProxyCommand.InvokeAsync(args, app);
     }
diff --git a/DevProxy/Proxy/ProxyEngine.cs b/DevProxy/Proxy/ProxyEngine.cs
index 6f353a8f..c4c25751 100755
--- a/DevProxy/Proxy/ProxyEngine.cs
+++ b/DevProxy/Proxy/ProxyEngine.cs
@@ -6,6 +6,9 @@
 using DevProxy.Abstractions.Proxy;
 using DevProxy.Abstractions.Utils;
 using DevProxy.Commands;
+using DevProxy.State;
+using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Hosting.Server.Features;
 using Microsoft.VisualStudio.Threading;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -32,7 +35,8 @@ sealed class ProxyEngine(
     ISet<UrlToWatch> urlsToWatch,
     IProxyStateController proxyController,
     ILogger<ProxyEngine> logger,
-    ILoggerFactory loggerFactory) : BackgroundService, IDisposable
+    ILoggerFactory loggerFactory,
+    IServer server) : BackgroundService, IDisposable
 {
     private readonly IEnumerable<IPlugin> _plugins = plugins;
     private readonly ILogger _logger = logger;
@@ -141,6 +145,12 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         ProxyServer.AddEndPoint(_explicitEndPoint);
         await ProxyServer.StartAsync(cancellationToken: stoppingToken);
 
+        // Save state with actual bound ports so other commands can find us
+        if (DevProxyCommand.IsInternalDaemon)
+        {
+            await SaveInstanceStateAsync();
+        }
+
         // run first-run setup on macOS
         FirstRunSetup();
 
@@ -219,6 +229,31 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         }
     }
 
+    private async Task SaveInstanceStateAsync()
+    {
+        var proxyPort = _explicitEndPoint?.Port ?? _config.Port;
+        var ipAddress = _config.IPAddress;
+        var loopbackAddress = ipAddress is "0.0.0.0" or "::" ? "127.0.0.1" : ipAddress;
+
+        // Get real API port from Kestrel
+        var serverAddresses = server.Features.Get<IServerAddressesFeature>();
+        var apiAddress = serverAddresses?.Addresses.FirstOrDefault();
+        var apiUrl = apiAddress ?? $"http://{loopbackAddress}:{_config.ApiPort}";
+
+        var state = new ProxyInstanceState
+        {
+            Pid = Environment.ProcessId,
+            ApiUrl = apiUrl,
+            LogFile = DevProxyCommand.DetachedLogFilePath,
+            StartedAt = DateTimeOffset.UtcNow,
+            ConfigFile = _config.ConfigFile,
+            Port = proxyPort,
+            AsSystemProxy = _config.AsSystemProxy
+        };
+
+        await StateManager.SaveStateAsync(state);
+    }
+
     private void FirstRunSetup()
     {
         if (!RunTime.IsMac ||