fixup! Add MSDP status bar and protocol negotiation to mud.tin

fixup! Add MSDP status bar and protocol negotiation to mud.tin

Remove manual IAC WILL event handlers that were killing the connection.
TinTin++ auto-negotiates GMCP and MSDP natively (responds DO to WILL).
The raw #send bytes were corrupting the telnet stream.

mud.tin

@@ -1,8 +1,28 @@
-#NOP TinTin++ config for connecting to the MUD server
+#NOP TinTin++ config for the MUD server
+#NOP usage: tt++ mud.tin
 #split 0 1
+
+#NOP initialize MSDP variables for status bar (before connection)
+#variable {MSDP_HEALTH} {-}
+#variable {MSDP_HEALTH_MAX} {-}
+#variable {MSDP_STAMINA} {-}
+#variable {MSDP_STAMINA_MAX} {-}
+
+#NOP MSDP: tintin++ auto-negotiates (responds DO to server's WILL).
+#NOP store variables as they arrive and refresh the status bar.
+
+#EVENT {IAC SB MSDP} {
+    #variable {MSDP_%0} {%1};
+    #showme {[HP: $MSDP_HEALTH/$MSDP_HEALTH_MAX] [ST: $MSDP_STAMINA/$MSDP_STAMINA_MAX]} {-2}
+}
+
+#NOP reconnect after disconnect. defined before #session so it
+#NOP persists in the startup session when the mud session dies.
+#alias {reconnect} {#session mud localhost 6789}
+
 #session mud localhost 6789
 
-#NOP fly aliases: f<direction> = fly 5 in that direction
+#NOP fly shortcuts: f + direction
 #alias {fn} {fly north}
 #alias {fs} {fly south}
 #alias {fe} {fly east}
@@ -12,10 +32,6 @@
 #alias {fse} {fly southeast}
 #alias {fsw} {fly southwest}
 
+#NOP combat shortcuts
 #alias {o} {sweep}
 #alias {r} {roundhouse}
-
-#alias {reconnect} {
- #zap mud;
- #session mud localhost 6789;
-}

src/mudlib/commands/help.py

@@ -260,6 +260,69 @@ async def cmd_skills(player: Player, args: str) -> None:
     await player.send("  ".join(names) + "\r\n")
 
 
+async def cmd_client(player: Player, args: str) -> None:
+    """Show client protocol negotiation and terminal capabilities."""
+    lines = ["client protocols"]
+
+    # Protocol status
+    gmcp = "active" if player.gmcp_enabled else "not active"
+    msdp = "active" if player.msdp_enabled else "not active"
+    lines.append(f"  GMCP: {gmcp}")
+    lines.append(f"  MSDP: {msdp}")
+
+    # Terminal info
+    lines.append("terminal")
+
+    # Terminal type from TTYPE negotiation
+    ttype = None
+    if player.writer is not None:
+        ttype = player.writer.get_extra_info("TERM") or None
+    lines.append(f"  type: {ttype or 'unknown'}")
+
+    # Terminal size from NAWS
+    cols, rows = 80, 24
+    if player.writer is not None:
+        cols = player.writer.get_extra_info("cols") or 80
+        rows = player.writer.get_extra_info("rows") or 24
+    lines.append(f"  size: {cols}x{rows}")
+
+    # Color depth
+    lines.append(f"  colors: {player.color_depth}")
+
+    # MTTS capabilities
+    caps = player.caps
+    mtts_flags = []
+    if caps.ansi:
+        mtts_flags.append("ANSI")
+    if caps.vt100:
+        mtts_flags.append("VT100")
+    if caps.utf8:
+        mtts_flags.append("UTF-8")
+    if caps.colors_256:
+        mtts_flags.append("256 colors")
+    if caps.truecolor:
+        mtts_flags.append("truecolor")
+    if caps.mouse_tracking:
+        mtts_flags.append("mouse tracking")
+    if caps.screen_reader:
+        mtts_flags.append("screen reader")
+    if caps.proxy:
+        mtts_flags.append("proxy")
+    if caps.mnes:
+        mtts_flags.append("MNES")
+    if caps.mslp:
+        mtts_flags.append("MSLP")
+    if caps.ssl:
+        mtts_flags.append("SSL")
+
+    if mtts_flags:
+        lines.append(f"  MTTS: {', '.join(mtts_flags)}")
+    else:
+        lines.append("  MTTS: none detected")
+
+    await player.send("\r\n".join(lines) + "\r\n")
+
+
 # Register the commands command
 register(
     CommandDefinition(
@@ -282,6 +345,17 @@ register(
     )
 )
 
+# Register the client command
+register(
+    CommandDefinition(
+        "client",
+        cmd_client,
+        aliases=[],
+        mode="*",
+        help="show client protocol and terminal info",
+    )
+)
+
 
 async def cmd_help(player: Player, args: str) -> None:
     """Show help for a command or skill.
@@ -293,7 +367,7 @@ async def cmd_help(player: Player, args: str) -> None:
     args = args.strip()
     if not args:
         await player.send(
-            "type help <command> for details. see also: commands, skills\r\n"
+            "type help <command> for details. see also: commands, skills, client\r\n"
         )
         return
     await _show_command_detail(player, args)

src/mudlib/gmcp.py

@@ -108,6 +108,8 @@ def send_map_data(player: Player) -> None:
 
 def send_msdp_vitals(player: Player) -> None:
     """Send MSDP variable updates for real-time gauges."""
+    if not player.msdp_enabled:
+        return
     player.send_msdp(
         {
             "HEALTH": str(round(player.pl, 1)),

src/mudlib/player.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
+from telnetlib3 import GMCP, MSDP
+
 from mudlib.caps import ClientCaps
 from mudlib.entity import Entity
 
@@ -54,6 +56,26 @@ class Player(Entity):
         if self.writer is not None:
             self.writer.send_msdp(variables)
 
+    @property
+    def gmcp_enabled(self) -> bool:
+        """Whether this client has GMCP negotiated."""
+        if self.writer is None:
+            return False
+        return bool(
+            self.writer.local_option.enabled(GMCP)
+            or self.writer.remote_option.enabled(GMCP)
+        )
+
+    @property
+    def msdp_enabled(self) -> bool:
+        """Whether this client has MSDP negotiated."""
+        if self.writer is None:
+            return False
+        return bool(
+            self.writer.local_option.enabled(MSDP)
+            or self.writer.remote_option.enabled(MSDP)
+        )
+
 
 # Global registry of connected players
 players: dict[str, Player] = {}

src/mudlib/server.py

@@ -9,6 +9,7 @@ import tomllib
 from typing import cast
 
 import telnetlib3
+from telnetlib3 import GMCP, MSDP, WILL
 from telnetlib3.server_shell import readline2
 
 import mudlib.combat.commands
@@ -238,6 +239,10 @@ async def shell(
 
     log.debug("new connection from %s", _writer.get_extra_info("peername"))
 
+    # Offer GMCP and MSDP so clients can negotiate
+    _writer.iac(WILL, GMCP)
+    _writer.iac(WILL, MSDP)
+
     _writer.write("Welcome to the MUD!\r\n")
     _writer.write("What is your name? ")
     await _writer.drain()

tests/test_embedded_if.py

@@ -17,6 +17,15 @@ requires_zork = pytest.mark.skipif(not ZORK_PATH.exists(), reason="zork1.z3 not
 
 @dataclass
 class MockWriter:
+    def __post_init__(self):
+        # Mock option negotiation state
+        from unittest.mock import MagicMock
+
+        self.local_option = MagicMock()
+        self.local_option.enabled = MagicMock(return_value=False)
+        self.remote_option = MagicMock()
+        self.remote_option.enabled = MagicMock(return_value=False)
+
     def write(self, data):
         pass
 

tests/test_gmcp.py

@@ -47,6 +47,11 @@ def mock_writer():
     writer.drain = AsyncMock()
     writer.send_gmcp = MagicMock()
     writer.send_msdp = MagicMock()
+    # Option negotiation state (for gmcp_enabled/msdp_enabled checks)
+    writer.local_option = MagicMock()
+    writer.local_option.enabled = MagicMock(return_value=True)
+    writer.remote_option = MagicMock()
+    writer.remote_option.enabled = MagicMock(return_value=True)
     return writer
 
 
@@ -502,3 +507,45 @@ async def test_char_status_sent_on_rest_complete(player):
     ]
     assert len(status_calls) == 1
     assert status_calls[0][0][1]["resting"] is False
+
+
+def test_msdp_vitals_skipped_when_not_negotiated(player):
+    """Test send_msdp_vitals skips when MSDP is not negotiated."""
+    player.writer.local_option.enabled.return_value = False
+    player.writer.remote_option.enabled.return_value = False
+
+    send_msdp_vitals(player)
+
+    player.writer.send_msdp.assert_not_called()
+
+
+def test_msdp_enabled_property(player):
+    """Test msdp_enabled reflects negotiation state."""
+    player.writer.local_option.enabled.return_value = False
+    player.writer.remote_option.enabled.return_value = False
+    assert not player.msdp_enabled
+
+    player.writer.local_option.enabled.return_value = True
+    assert player.msdp_enabled
+
+
+def test_gmcp_enabled_property(player):
+    """Test gmcp_enabled reflects negotiation state."""
+    player.writer.local_option.enabled.return_value = False
+    player.writer.remote_option.enabled.return_value = False
+    assert not player.gmcp_enabled
+
+    player.writer.remote_option.enabled.return_value = True
+    assert player.gmcp_enabled
+
+
+def test_msdp_enabled_no_writer():
+    """Test msdp_enabled with no writer returns False."""
+    p = Player(name="NoWriter", writer=None)
+    assert not p.msdp_enabled
+
+
+def test_gmcp_enabled_no_writer():
+    """Test gmcp_enabled with no writer returns False."""
+    p = Player(name="NoWriter", writer=None)
+    assert not p.gmcp_enabled

tests/test_help.py

@@ -0,0 +1,122 @@
+"""Tests for client command."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from mudlib.caps import ClientCaps
+from mudlib.commands.help import cmd_client
+from mudlib.player import Player, players
+
+
+@pytest.fixture(autouse=True)
+def clear_state():
+    players.clear()
+    yield
+    players.clear()
+
+
+@pytest.fixture
+def mock_writer():
+    writer = MagicMock()
+    writer.write = MagicMock()
+    writer.drain = AsyncMock()
+    writer.send_gmcp = MagicMock()
+    writer.send_msdp = MagicMock()
+    writer.local_option = MagicMock()
+    writer.local_option.enabled = MagicMock(return_value=True)
+    writer.remote_option = MagicMock()
+    writer.remote_option.enabled = MagicMock(return_value=True)
+    writer.get_extra_info = MagicMock(
+        side_effect=lambda key: {
+            "TERM": "TINTIN",
+            "cols": 191,
+            "rows": 54,
+        }.get(key)
+    )
+    return writer
+
+
+@pytest.mark.asyncio
+async def test_client_shows_protocols(mock_writer):
+    """Test client command shows GMCP and MSDP status."""
+    p = Player(name="Test", writer=mock_writer)
+    p.caps = ClientCaps(ansi=True, truecolor=True)
+    await cmd_client(p, "")
+
+    output = mock_writer.write.call_args[0][0]
+    assert "GMCP: active" in output
+    assert "MSDP: active" in output
+
+
+@pytest.mark.asyncio
+async def test_client_shows_terminal_info(mock_writer):
+    """Test client command shows terminal type and size."""
+    p = Player(name="Test", writer=mock_writer)
+    p.caps = ClientCaps(ansi=True)
+    await cmd_client(p, "")
+
+    output = mock_writer.write.call_args[0][0]
+    assert "type: TINTIN" in output
+    assert "size: 191x54" in output
+
+
+@pytest.mark.asyncio
+async def test_client_shows_color_depth(mock_writer):
+    """Test client command shows color depth."""
+    p = Player(name="Test", writer=mock_writer)
+    p.caps = ClientCaps(ansi=True, truecolor=True, colors_256=True)
+    await cmd_client(p, "")
+
+    output = mock_writer.write.call_args[0][0]
+    assert "colors: truecolor" in output
+
+
+@pytest.mark.asyncio
+async def test_client_shows_mtts_flags(mock_writer):
+    """Test client command shows MTTS capabilities."""
+    p = Player(name="Test", writer=mock_writer)
+    p.caps = ClientCaps(ansi=True, vt100=True, utf8=True, colors_256=True)
+    await cmd_client(p, "")
+
+    output = mock_writer.write.call_args[0][0]
+    assert "ANSI" in output
+    assert "VT100" in output
+    assert "UTF-8" in output
+    assert "256 colors" in output
+
+
+@pytest.mark.asyncio
+async def test_client_not_negotiated(mock_writer):
+    """Test client command when protocols not negotiated."""
+    mock_writer.local_option.enabled.return_value = False
+    mock_writer.remote_option.enabled.return_value = False
+
+    p = Player(name="Test", writer=mock_writer)
+    p.caps = ClientCaps()
+    await cmd_client(p, "")
+
+    output = mock_writer.write.call_args[0][0]
+    assert "GMCP: not active" in output
+    assert "MSDP: not active" in output
+
+
+@pytest.mark.asyncio
+async def test_client_no_mtts():
+    """Test client command with no MTTS capabilities."""
+    writer = MagicMock()
+    writer.write = MagicMock()
+    writer.drain = AsyncMock()
+    writer.local_option = MagicMock()
+    writer.local_option.enabled = MagicMock(return_value=False)
+    writer.remote_option = MagicMock()
+    writer.remote_option.enabled = MagicMock(return_value=False)
+    writer.get_extra_info = MagicMock(return_value=None)
+
+    p = Player(name="Test", writer=writer)
+    p.caps = ClientCaps()
+    await cmd_client(p, "")
+
+    output = writer.write.call_args[0][0]
+    assert "type: unknown" in output
+    assert "MTTS: none detected" in output

tests/test_paint_mode.py

@@ -35,6 +35,13 @@ class MockWriter:
 
     def __init__(self):
         self.messages = []
+        # Mock option negotiation state
+        from unittest.mock import MagicMock
+
+        self.local_option = MagicMock()
+        self.local_option.enabled = MagicMock(return_value=False)
+        self.remote_option = MagicMock()
+        self.remote_option.enabled = MagicMock(return_value=False)
 
     def write(self, message: str):
         self.messages.append(message)