From 74a93bae48c7563ec69ac1911c0cb2d3901c33bd Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 2 Nov 2026 22:28:12 +0000
Subject: [PATCH 1/3] Answer a server's MXP <SUPPORT> question, so the screen
 it holds back is the banner

CoffeeMud asks <SUPPORT IMAGE IMAGE.URL> and <SUPPORT> on connect and holds
its connect screen up to three seconds for the reply. Unanswered, the probe
settled on the questions and stored them as the game's connect screen
(24.138.50.103:5555), and the real screen arrived in the WHO phase.

Watched.Mxp now answers through TelnetNegotiationCore's capability exchange
(4.3.0+): every entry asked about is refused, since the probe renders nothing,
and a bare <SUPPORT> gets a reply that claims nothing. TelnetNegotiationCore
goes from 4.0.0 to 4.5.3 to get it.

CoffeeMud itself never sends IAC SB MXP IAC SE, so answering it also needs
HarryCordewener/TelnetNegotiationCore#174 released; the version bump for that
follows once it is.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Rqqt7TucGdYhFwbzK7RHR5
---
 Directory.Packages.props                      |   2 +-
 src/MUI.Crawl/Telnet/WatchedProtocols.cs      |  21 +-
 .../MUI.Crawl.Tests/Telnet/MxpSupportTests.cs | 212 ++++++++++++++++++
 3 files changed, 232 insertions(+), 3 deletions(-)
 create mode 100644 tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 71af5f96..ad919b3e 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -19,7 +19,7 @@
       send in answer to DO COMPRESS2; before it, everything after their connect screens, MSSP report
       included, arrived as zlib read as text.
     -->
-    <PackageVersion Include="TelnetNegotiationCore" Version="4.0.0" />
+    <PackageVersion Include="TelnetNegotiationCore" Version="4.5.3" />
 
     <!--
       No logging, hosting or DI *abstractions* here. The crawler is an in-process BackgroundService in
diff --git a/src/MUI.Crawl/Telnet/WatchedProtocols.cs b/src/MUI.Crawl/Telnet/WatchedProtocols.cs
index 8bef5615..b3358af5 100644
--- a/src/MUI.Crawl/Telnet/WatchedProtocols.cs
+++ b/src/MUI.Crawl/Telnet/WatchedProtocols.cs
@@ -91,11 +91,28 @@ public override ValueTask OnEnabledAsync()
         }
     }
 
-    internal sealed class Mxp(Action<string> note) : MXPProtocol
+    /// <remarks>
+    /// The one plugin here that also answers. A server's <c>&lt;SUPPORT&gt;</c> is a question asked of
+    /// this client, and CoffeeMud holds its connect screen for three seconds waiting for the reply
+    /// (<c>DefaultSession.HandshakeCallback</c>, <c>HANDSHAKE_MXPPAUSE</c>). Unanswered, the probe
+    /// settled on the questions themselves, stored them as the game's connect screen, and read the
+    /// real screen into the WHO phase. The answer is the truth: this client renders nothing, so every
+    /// entry asked about is refused, and a bare <c>&lt;SUPPORT&gt;</c> gets a reply that claims nothing.
+    /// It goes out on a secure line, which a server reads as protocol rather than as typing.
+    /// </remarks>
+    internal sealed class Mxp : MXPProtocol
     {
+        private readonly Action<string> _note;
+
+        public Mxp(Action<string> note)
+        {
+            _note = note;
+            OnMxpSupportRequested(asked => SendSupportsAsync([], asked));
+        }
+
         public override ValueTask OnEnabledAsync()
         {
-            note(ProtocolName);
+            _note(ProtocolName);
             return base.OnEnabledAsync();
         }
     }
diff --git a/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs b/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs
new file mode 100644
index 00000000..05023b18
--- /dev/null
+++ b/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs
@@ -0,0 +1,212 @@
+using System.Diagnostics;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using MUI.Crawl;
+
+namespace MUI.Crawl.Tests;
+
+/// <summary>
+/// A server's MXP <c>&lt;SUPPORT&gt;</c> question is answered, and the screen it was holding back is
+/// the one stored.
+/// </summary>
+/// <remarks>
+/// CoffeeMud asks on connect and holds its connect screen up to three seconds for the reply
+/// (<c>DefaultSession.HandshakeCallback</c>, <c>HANDSHAKE_MXPPAUSE</c>). Unanswered, the probe settled
+/// on the questions, stored <c>&lt;SUPPORT IMAGE IMAGE.URL&gt;</c> as the game's connect screen
+/// (<c>24.138.50.103:5555</c>, 2026-11-02), and the real screen arrived in the phases after it.
+/// </remarks>
+public class MxpSupportTests
+{
+    private static ProbeOptions Fast() => new()
+    {
+        QuietPeriod = TimeSpan.FromMilliseconds(120),
+        SilenceGrace = TimeSpan.FromMilliseconds(300),
+        MaxPhase = TimeSpan.FromSeconds(3),
+        BannerPatience = TimeSpan.FromMilliseconds(300),
+        WhoGrace = TimeSpan.FromMilliseconds(700),
+        PollInterval = TimeSpan.FromMilliseconds(15),
+        Timeout = TimeSpan.FromSeconds(20),
+        MsspSettleGrace = TimeSpan.FromMilliseconds(400),
+        PromptHold = TimeSpan.FromMilliseconds(120),
+    };
+
+    [Test]
+    public async Task ASupportQuestionIsAnsweredAndTheScreenBehindItIsTheBanner()
+    {
+        await using var game = new HoldingGame();
+
+        var result = await new TelnetProbe(Fast()).ProbeAsync(game.Target);
+
+        await Assert.That(result.Outcome).IsEqualTo(ProbeOutcome.Answered);
+        await Assert.That(game.Answer).IsNotNull().Because("the server asked, and was waiting");
+        await Assert.That(game.Answer!.ToUpperInvariant()).Contains("-IMAGE.URL")
+            .Because("this client renders nothing, so it refuses what it was asked about");
+        await Assert.That(game.Answer!).DoesNotContain("+")
+            .Because("nothing is claimed that the probe does not do");
+        await Assert.That(result.Banner).Contains("Welcome to the Holding Pattern");
+        await Assert.That(result.Banner).DoesNotContain("<SUPPORT");
+        await Assert.That(result.MxpObserved).IsTrue();
+    }
+
+    /// <summary>
+    /// Speaks just enough telnet to agree MXP, start it, and ask; then holds its real screen until it
+    /// is answered or the hold runs out, as CoffeeMud does.
+    /// </summary>
+    private sealed class HoldingGame : IAsyncDisposable
+    {
+        private const byte Iac = 255, Sb = 250, Se = 240, Will = 251, Do = 253, Mxp = 91;
+
+        private static readonly TimeSpan Hold = TimeSpan.FromSeconds(3);
+
+        private readonly TcpListener _listener;
+        private readonly CancellationTokenSource _stopping = new();
+        private readonly Task _serving;
+        private volatile string? _answer;
+
+        public HoldingGame()
+        {
+            _listener = new TcpListener(IPAddress.Loopback, 0);
+            _listener.Start();
+            _serving = ServeAsync();
+        }
+
+        public ProbeTarget Target => new(
+            IPAddress.Loopback.ToString(),
+            ((IPEndPoint)_listener.LocalEndpoint).Port);
+
+        /// <summary>The client's <c>&lt;SUPPORTS&gt;</c> line, if it sent one before the hold ran out.</summary>
+        public string? Answer => _answer;
+
+        private async Task ServeAsync()
+        {
+            try
+            {
+                using var client = await _listener.AcceptTcpClientAsync(_stopping.Token);
+                await using var stream = client.GetStream();
+                var heard = new List<byte>();
+                var listening = ListenAsync(stream, heard);
+
+                await stream.WriteAsync(new byte[] { Iac, Will, Mxp }, _stopping.Token);
+                await SendAsync(stream, "\r\nConnecting to the Holding Pattern...\r\n");
+
+                var agreed = Stopwatch.StartNew();
+                while (!Contains(heard, [Iac, Do, Mxp]) && agreed.Elapsed < Hold)
+                {
+                    await Task.Delay(20, _stopping.Token);
+                }
+
+                await stream.WriteAsync(new byte[] { Iac, Sb, Mxp, Iac, Se }, _stopping.Token);
+                await SendAsync(stream, "\n\u001b[6z\n\u001b[6z<SUPPORT IMAGE IMAGE.URL>\n");
+                await SendAsync(stream, "\n\u001b[6z\n\u001b[6z<SUPPORT>\n");
+
+                var holding = Stopwatch.StartNew();
+                while (holding.Elapsed < Hold && _answer is null)
+                {
+                    _answer = FindAnswer(heard);
+                    await Task.Delay(20, _stopping.Token);
+                }
+
+                await SendAsync(stream, "Welcome to the Holding Pattern\r\nAccount name: ");
+                await listening;
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (IOException)
+            {
+            }
+            catch (SocketException)
+            {
+            }
+        }
+
+        /// <summary>Everything the client sends, until it closes or the game is disposed.</summary>
+        private async Task ListenAsync(NetworkStream stream, List<byte> heard)
+        {
+            var buffer = new byte[4096];
+
+            try
+            {
+                while (true)
+                {
+                    var read = await stream.ReadAsync(buffer, _stopping.Token);
+                    if (read == 0)
+                    {
+                        return;
+                    }
+
+                    lock (heard)
+                    {
+                        heard.AddRange(buffer.AsSpan(0, read).ToArray());
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (IOException)
+            {
+            }
+        }
+
+        private static string? FindAnswer(List<byte> heard)
+        {
+            string text;
+            lock (heard)
+            {
+                text = Encoding.Latin1.GetString(heard.ToArray());
+            }
+
+            var at = text.IndexOf("<SUPPORTS", StringComparison.OrdinalIgnoreCase);
+            var end = at < 0 ? -1 : text.IndexOf('>', at);
+            return end > 0 ? text[at..(end + 1)] : null;
+        }
+
+        private static bool Contains(List<byte> heard, byte[] sequence)
+        {
+            lock (heard)
+            {
+                return IndexOf(heard, sequence) >= 0;
+            }
+        }
+
+        private static int IndexOf(List<byte> heard, byte[] sequence)
+        {
+            for (var i = 0; i + sequence.Length <= heard.Count; i++)
+            {
+                var match = true;
+                for (var j = 0; j < sequence.Length && match; j++)
+                {
+                    match = heard[i + j] == sequence[j];
+                }
+
+                if (match)
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        private Task SendAsync(NetworkStream stream, string text) =>
+            stream.WriteAsync(Encoding.Latin1.GetBytes(text), _stopping.Token).AsTask();
+
+        public async ValueTask DisposeAsync()
+        {
+            await _stopping.CancelAsync();
+            _listener.Stop();
+
+            try
+            {
+                await _serving;
+            }
+            catch (OperationCanceledException)
+            {
+            }
+
+            _stopping.Dispose();
+        }
+    }
+}

From 1af73da6349d8fe731361154deb48f32204cc219 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 2 Nov 2026 22:42:25 +0000
Subject: [PATCH 2/3] Test the CoffeeMud shape: a SUPPORT question with no IAC
 SB MXP start marker

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Rqqt7TucGdYhFwbzK7RHR5
---
 .../MUI.Crawl.Tests/Telnet/MxpSupportTests.cs | 31 ++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs b/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs
index 05023b18..7e26a941 100644
--- a/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs
+++ b/tests/MUI.Crawl.Tests/Telnet/MxpSupportTests.cs
@@ -49,6 +49,25 @@ await Assert.That(game.Answer!).DoesNotContain("+")
         await Assert.That(result.MxpObserved).IsTrue();
     }
 
+    /// <summary>
+    /// The same, as CoffeeMud actually does it: the option is agreed, no start marker follows, and the
+    /// question arrives on a lock-secure line.
+    /// </summary>
+    [Test]
+    public async Task ASupportQuestionWithNoStartMarkerIsStillAnswered()
+    {
+        await using var game = new HoldingGame { SendsStartMarker = false };
+
+        var result = await new TelnetProbe(Fast()).ProbeAsync(game.Target);
+
+        await Assert.That(result.Outcome).IsEqualTo(ProbeOutcome.Answered);
+        await Assert.That(game.Answer).IsNotNull().Because("the server asked, and was waiting");
+        await Assert.That(game.Answer!.ToUpperInvariant()).Contains("-IMAGE.URL");
+        await Assert.That(result.Banner).Contains("Welcome to the Holding Pattern");
+        await Assert.That(result.Banner).DoesNotContain("<SUPPORT");
+        await Assert.That(result.MxpObserved).IsTrue();
+    }
+
     /// <summary>
     /// Speaks just enough telnet to agree MXP, start it, and ask; then holds its real screen until it
     /// is answered or the hold runs out, as CoffeeMud does.
@@ -71,6 +90,12 @@ public HoldingGame()
             _serving = ServeAsync();
         }
 
+        /// <summary>
+        /// Whether MXP mode is started with <c>IAC SB MXP IAC SE</c>. CoffeeMud never sends it and
+        /// goes straight to its line-mode sequences.
+        /// </summary>
+        public bool SendsStartMarker { get; init; } = true;
+
         public ProbeTarget Target => new(
             IPAddress.Loopback.ToString(),
             ((IPEndPoint)_listener.LocalEndpoint).Port);
@@ -96,7 +121,11 @@ private async Task ServeAsync()
                     await Task.Delay(20, _stopping.Token);
                 }
 
-                await stream.WriteAsync(new byte[] { Iac, Sb, Mxp, Iac, Se }, _stopping.Token);
+                if (SendsStartMarker)
+                {
+                    await stream.WriteAsync(new byte[] { Iac, Sb, Mxp, Iac, Se }, _stopping.Token);
+                }
+
                 await SendAsync(stream, "\n\u001b[6z\n\u001b[6z<SUPPORT IMAGE IMAGE.URL>\n");
                 await SendAsync(stream, "\n\u001b[6z\n\u001b[6z<SUPPORT>\n");
 

From f497a4d435dc611683101a7e1122c58c6c2e6e21 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 2 Nov 2026 22:51:42 +0000
Subject: [PATCH 3/3] Take TelnetNegotiationCore 4.6.0, which starts MXP mode
 on a line-mode sequence

CoffeeMud never sends IAC SB MXP IAC SE; 4.6.0 (#174) takes its first
ESC[6z as the start of MXP mode, so its <SUPPORT> reaches OnMxpSupportRequested.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Rqqt7TucGdYhFwbzK7RHR5
---
 Directory.Packages.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Directory.Packages.props b/Directory.Packages.props
index ad919b3e..33e51b4b 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -19,7 +19,7 @@
       send in answer to DO COMPRESS2; before it, everything after their connect screens, MSSP report
       included, arrived as zlib read as text.
     -->
-    <PackageVersion Include="TelnetNegotiationCore" Version="4.5.3" />
+    <PackageVersion Include="TelnetNegotiationCore" Version="4.6.0" />
 
     <!--
       No logging, hosting or DI *abstractions* here. The crawler is an in-process BackgroundService in