From f08d91bcf282ce031897e24626e2133e55c9be9b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:07:55 +0000
Subject: [PATCH 1/3] Initial plan


From 689f734e3630a7af6fc355911787da9bf4b46b07 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:13:15 +0000
Subject: [PATCH 2/3] =?UTF-8?q?refactor(api):=20=E2=99=BB=EF=B8=8F=20added?=
 =?UTF-8?q?=20StringExtensions=20with=20SplitByDelimiters=20method?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Created centralized extension method for delimited string parsing with escape character support.

Co-authored-by: caunt <5324218+caunt@users.noreply.github.com>
---
 src/Api/Extensions/StringExtensions.cs        |  63 ++++++++
 .../Nuget/NuGetDependencyResolver.cs          |   8 +-
 src/Platform/Plugins/PluginService.cs         |   3 +-
 .../ExtensionsTests/StringExtensionsTests.cs  | 135 ++++++++++++++++++
 4 files changed, 203 insertions(+), 6 deletions(-)
 create mode 100644 src/Api/Extensions/StringExtensions.cs
 create mode 100644 src/Tests/ExtensionsTests/StringExtensionsTests.cs

diff --git a/src/Api/Extensions/StringExtensions.cs b/src/Api/Extensions/StringExtensions.cs
new file mode 100644
index 00000000..de9c6e38
--- /dev/null
+++ b/src/Api/Extensions/StringExtensions.cs
@@ -0,0 +1,63 @@
+using System.Text.RegularExpressions;
+
+namespace Void.Proxy.Api.Extensions;
+
+public static partial class StringExtensions
+{
+    private static readonly char[] DefaultDelimiters = [',', ';', '\n'];
+
+    /// <summary>
+    /// Splits a string by multiple delimiters with optional escape character support.
+    /// </summary>
+    /// <param name="input">The string to split.</param>
+    /// <param name="delimiters">Custom delimiters to use. If null, uses default delimiters: comma, semicolon, and newline.</param>
+    /// <param name="escapeCharacter">Optional escape character (e.g., '\') to allow escaped delimiters in the input.</param>
+    /// <param name="removeEmptyEntries">Whether to remove empty entries from the result. Defaults to true.</param>
+    /// <returns>An array of strings split by the delimiters.</returns>
+    public static string[] SplitByDelimiters(this string input, char[]? delimiters = null, char? escapeCharacter = null, bool removeEmptyEntries = true)
+    {
+        if (string.IsNullOrWhiteSpace(input))
+            return [];
+
+        delimiters ??= DefaultDelimiters;
+
+        if (escapeCharacter is not null)
+        {
+            return SplitByDelimitersWithEscape(input, delimiters, escapeCharacter.Value, removeEmptyEntries);
+        }
+
+        var options = removeEmptyEntries ? StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries : StringSplitOptions.TrimEntries;
+        return input.Split(delimiters, options);
+    }
+
+    private static string[] SplitByDelimitersWithEscape(string input, char[] delimiters, char escapeCharacter, bool removeEmptyEntries)
+    {
+        var pattern = BuildEscapedDelimiterPattern(delimiters, escapeCharacter);
+        var regex = new Regex(pattern);
+        var parts = regex.Split(input);
+
+        var result = parts.Select(part => UnescapeDelimiters(part, delimiters, escapeCharacter).Trim()).ToArray();
+
+        if (removeEmptyEntries)
+            result = result.Where(part => !string.IsNullOrWhiteSpace(part)).ToArray();
+
+        return result;
+    }
+
+    private static string BuildEscapedDelimiterPattern(char[] delimiters, char escapeCharacter)
+    {
+        var escapedChar = Regex.Escape(escapeCharacter.ToString());
+        var delimiterPattern = string.Join("|", delimiters.Select(d => Regex.Escape(d.ToString())));
+        return $"(?<!{escapedChar})(?:{delimiterPattern})";
+    }
+
+    private static string UnescapeDelimiters(string input, char[] delimiters, char escapeCharacter)
+    {
+        foreach (var delimiter in delimiters)
+        {
+            input = input.Replace($"{escapeCharacter}{delimiter}", delimiter.ToString());
+        }
+
+        return input;
+    }
+}
diff --git a/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs b/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs
index afc3b7a9..7e37cc44 100644
--- a/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs
+++ b/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs
@@ -17,11 +17,12 @@
 using Void.Proxy.Api.Console;
 using Void.Proxy.Api.Events;
 using Void.Proxy.Api.Events.Proxy;
+using Void.Proxy.Api.Extensions;
 using Void.Proxy.Api.Plugins.Dependencies;
 
 namespace Void.Proxy.Plugins.Dependencies.Nuget;
 
-public partial class NuGetDependencyResolver(ILogger<NuGetDependencyResolver> logger, IRunOptions runOptions, IConsoleService console, HttpClient httpClient) : INuGetDependencyResolver, IEventListener
+public class NuGetDependencyResolver(ILogger<NuGetDependencyResolver> logger, IRunOptions runOptions, IConsoleService console, HttpClient httpClient) : INuGetDependencyResolver, IEventListener
 {
     private static readonly Option<string[]> RepositoryOption = new("--repository", "-r")
     {
@@ -42,7 +43,7 @@ public partial class NuGetDependencyResolver(ILogger<NuGetDependencyResolver> lo
     private readonly NuGet.Common.ILogger _nugetLogger = console.GetOptionValue(EnableNugetLoggingOption) ? new NuGetLogger(logger) : NullLogger.Instance;
     private readonly HashSet<string> _repositories = [];
 
-    private IEnumerable<string> UriRepositories => UnescapedSemicolonRegex().Split(Environment.GetEnvironmentVariable("VOID_NUGET_REPOSITORIES") ?? "").Select(repo => repo.Replace(@"\;", ";")).Concat(_repositories.Concat(console.GetOptionValue(RepositoryOption) ?? [])).Where(uri => !string.IsNullOrWhiteSpace(uri));
+    private IEnumerable<string> UriRepositories => (Environment.GetEnvironmentVariable("VOID_NUGET_REPOSITORIES") ?? "").SplitByDelimiters([';'], escapeCharacter: '\\').Concat(_repositories.Concat(console.GetOptionValue(RepositoryOption) ?? [])).Where(uri => !string.IsNullOrWhiteSpace(uri));
     private IEnumerable<SourceRepository> Repositories
     {
         get
@@ -543,7 +544,4 @@ private async Task ProbeRepositoriesAsync(CancellationToken cancellationToken =
         foreach (var (url, status) in statuses)
             logger.LogInformation(" - {Url} [{Status}]", url, status);
     }
-
-    [GeneratedRegex(@"(?<!\\);")]
-    private static partial Regex UnescapedSemicolonRegex();
 }
diff --git a/src/Platform/Plugins/PluginService.cs b/src/Platform/Plugins/PluginService.cs
index 5e48782a..046c5826 100644
--- a/src/Platform/Plugins/PluginService.cs
+++ b/src/Platform/Plugins/PluginService.cs
@@ -8,6 +8,7 @@
 using Void.Proxy.Api.Events;
 using Void.Proxy.Api.Events.Plugins;
 using Void.Proxy.Api.Events.Services;
+using Void.Proxy.Api.Extensions;
 using Void.Proxy.Api.Plugins;
 using Void.Proxy.Api.Plugins.Dependencies;
 using Void.Proxy.Plugins.Containers;
@@ -125,7 +126,7 @@ static string[] GetVariablesPlugins()
             if (string.IsNullOrWhiteSpace(args))
                 return [];
 
-            return args.Split(',', ';');
+            return args.SplitByDelimiters();
         }
     }
 
diff --git a/src/Tests/ExtensionsTests/StringExtensionsTests.cs b/src/Tests/ExtensionsTests/StringExtensionsTests.cs
new file mode 100644
index 00000000..745c4cb6
--- /dev/null
+++ b/src/Tests/ExtensionsTests/StringExtensionsTests.cs
@@ -0,0 +1,135 @@
+using Void.Proxy.Api.Extensions;
+using Xunit;
+
+namespace Void.Tests.ExtensionsTests;
+
+public class StringExtensionsTests
+{
+    [Fact]
+    public void SplitByDelimiters_WithDefaultDelimiters_SplitsByComma()
+    {
+        const string input = "a,b,c";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithDefaultDelimiters_SplitsBySemicolon()
+    {
+        const string input = "a;b;c";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithDefaultDelimiters_SplitsByNewline()
+    {
+        const string input = "a\nb\nc";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithDefaultDelimiters_SplitsByMixedDelimiters()
+    {
+        const string input = "a,b;c\nd";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["a", "b", "c", "d"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithDefaultDelimiters_RemovesEmptyEntries()
+    {
+        const string input = "a,,b;c";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithDefaultDelimiters_TrimsEntries()
+    {
+        const string input = " a , b ; c ";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithEmptyString_ReturnsEmptyArray()
+    {
+        const string input = "";
+        var result = input.SplitByDelimiters();
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithWhitespaceString_ReturnsEmptyArray()
+    {
+        const string input = "   ";
+        var result = input.SplitByDelimiters();
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithCustomDelimiters_SplitsCorrectly()
+    {
+        const string input = "a|b|c";
+        var result = input.SplitByDelimiters(['|']);
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithEscapeCharacter_HandlesEscapedDelimiters()
+    {
+        const string input = @"a\;b;c";
+        var result = input.SplitByDelimiters([';'], escapeCharacter: '\\');
+        Assert.Equal(["a;b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithEscapeCharacter_HandlesMultipleEscapedDelimiters()
+    {
+        const string input = @"a\;b\;c;d";
+        var result = input.SplitByDelimiters([';'], escapeCharacter: '\\');
+        Assert.Equal(["a;b;c", "d"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithEscapeCharacter_HandlesUnescapedDelimiters()
+    {
+        const string input = "a;b;c";
+        var result = input.SplitByDelimiters([';'], escapeCharacter: '\\');
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_WithEscapeCharacter_HandlesComplexCase()
+    {
+        const string input = @"https://user:pass@repo1.com\;https://user:pass@repo2.com;https://repo3.com";
+        var result = input.SplitByDelimiters([';'], escapeCharacter: '\\');
+        Assert.Equal(["https://user:pass@repo1.com;https://user:pass@repo2.com", "https://repo3.com"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_RemoveEmptyEntriesFalse_KeepsEmptyEntries()
+    {
+        const string input = "a,,b;c";
+        var result = input.SplitByDelimiters(removeEmptyEntries: false);
+        Assert.Equal(["a", "", "b", "c"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_VoidPluginsScenario_WorksCorrectly()
+    {
+        const string input = "plugin1.dll,plugin2.dll;plugin3.dll";
+        var result = input.SplitByDelimiters();
+        Assert.Equal(["plugin1.dll", "plugin2.dll", "plugin3.dll"], result);
+    }
+
+    [Fact]
+    public void SplitByDelimiters_VoidNugetRepositoriesScenario_WorksCorrectly()
+    {
+        const string input = @"https://user1:pass1@repo1.com\;extra;https://repo2.com";
+        var result = input.SplitByDelimiters([';'], escapeCharacter: '\\');
+        Assert.Equal(["https://user1:pass1@repo1.com;extra", "https://repo2.com"], result);
+    }
+}

From 4bd772dbceeb689dc605262bcf94ec5fef53372a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 11 Feb 2026 00:22:54 +0000
Subject: [PATCH 3/3] =?UTF-8?q?refactor(api):=20=F0=9F=94=A5=20addressed?=
 =?UTF-8?q?=20code=20review=20feedback?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Removed unused System.Text.RegularExpressions import from NuGetDependencyResolver
- Added RegexOptions.Compiled for better performance in StringExtensions

Co-authored-by: caunt <5324218+caunt@users.noreply.github.com>
---
 src/Api/Extensions/StringExtensions.cs                          | 2 +-
 .../Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs       | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Api/Extensions/StringExtensions.cs b/src/Api/Extensions/StringExtensions.cs
index de9c6e38..f7c43667 100644
--- a/src/Api/Extensions/StringExtensions.cs
+++ b/src/Api/Extensions/StringExtensions.cs
@@ -33,7 +33,7 @@ public static string[] SplitByDelimiters(this string input, char[]? delimiters =
     private static string[] SplitByDelimitersWithEscape(string input, char[] delimiters, char escapeCharacter, bool removeEmptyEntries)
     {
         var pattern = BuildEscapedDelimiterPattern(delimiters, escapeCharacter);
-        var regex = new Regex(pattern);
+        var regex = new Regex(pattern, RegexOptions.Compiled);
         var parts = regex.Split(input);
 
         var result = parts.Select(part => UnescapeDelimiters(part, delimiters, escapeCharacter).Trim()).ToArray();
diff --git a/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs b/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs
index 7e37cc44..5cc1be04 100644
--- a/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs
+++ b/src/Platform/Plugins/Dependencies/Nuget/NuGetDependencyResolver.cs
@@ -2,7 +2,6 @@
 using System.Reflection;
 using System.Runtime.Loader;
 using System.Runtime.Versioning;
-using System.Text.RegularExpressions;
 using Nito.Disposables.Internals;
 using NuGet.Common;
 using NuGet.Configuration;