docs/how/protocols.rst

@@ -1,169 +0,0 @@
-protocol negotiation — GMCP, MSDP, and client detection
-========================================================
-
-how the server offers GMCP and MSDP to connecting clients, how clients
-accept or reject them, and how the game guards against sending data to
-clients that don't support it.
-
-see also: ``mud.tin`` (tintin++ client config), ``docs/lessons/charset-vs-mtts.txt``
-(related telnet negotiation gotcha).
-
-
-the lifecycle
--------------
-
-1. client connects via telnet
-2. telnetlib3 calls ``begin_negotiation()`` on our ``MudTelnetServer``
-3. server sends ``IAC WILL GMCP`` and ``IAC WILL MSDP``
-4. client replies ``IAC DO <option>`` (accept) or ``IAC DONT <option>`` (reject)
-5. telnetlib3 updates its internal option state tables
-6. ``Player.gmcp_enabled`` / ``Player.msdp_enabled`` check those tables
-7. every send function guards on the relevant property before transmitting
-
-all of this happens during the telnet handshake, before the player sees the
-name prompt. by the time game code runs, the protocol state is settled.
-
-
-server side — MudTelnetServer
------------------------------
-
-``server.py`` subclasses telnetlib3's ``TelnetServer``::
-
-    class MudTelnetServer(TelnetServer):
-        def begin_negotiation(self) -> None:
-            super().begin_negotiation()
-            self.writer.iac(WILL, GMCP)
-            self.writer.iac(WILL, MSDP)
-
-``begin_negotiation()`` is called once by telnetlib3 right after the TCP
-connection is established. the parent handles baseline telnet options (TTYPE,
-NAWS, etc). we add GMCP and MSDP offers on top.
-
-there's no ``begin_advanced_negotiation()`` override — GMCP/MSDP offers go
-in the initial phase because clients need to know about them before the game
-starts sending data.
-
-
-player properties
------------------
-
-``player.py`` exposes two boolean properties::
-
-    @property
-    def gmcp_enabled(self) -> bool:
-        if self.writer is None:
-            return False
-        return bool(
-            self.writer.local_option.enabled(GMCP)
-            or self.writer.remote_option.enabled(GMCP)
-        )
-
-checks both ``local_option`` and ``remote_option`` because telnet negotiation
-is symmetric — either side can initiate. ``local_option`` reflects our ``WILL``
-offer being accepted (client sent ``DO``). ``remote_option`` would reflect a
-client-initiated ``DO`` that we accepted with ``WILL``. in practice the server
-always offers first, but checking both is correct per the telnet spec.
-
-same pattern for ``msdp_enabled``.
-
-
-the guard pattern
------------------
-
-every function in ``gmcp.py`` that sends data checks the property first::
-
-    def send_char_vitals(player: Player) -> None:
-        if not player.gmcp_enabled:
-            return
-        player.send_gmcp("Char.Vitals", { ... })
-
-    def send_msdp_vitals(player: Player) -> None:
-        if not player.msdp_enabled:
-            return
-        player.send_msdp("HEALTH", ...)
-
-this is the only guard needed. the game loop calls these functions
-unconditionally for all players; the functions themselves decide whether to
-actually send. simple clients that don't negotiate GMCP/MSDP just never
-receive the data.
-
-
-what gets sent over each protocol
----------------------------------
-
-**GMCP** (Generic MUD Communication Protocol) — structured JSON packages:
-
-- ``Char.Vitals`` — hp, max_hp, stamina, max_stamina
-- ``Char.Status`` — name, level, location name
-- ``Room.Info`` — room id, coordinates, exits
-- ``Room.Map`` — ASCII map fragment for client-side rendering
-
-sent on-demand when state changes (room enter, damage taken, etc).
-
-**MSDP** (MUD Server Data Protocol) — key/value variable updates:
-
-- ``HEALTH``, ``HEALTH_MAX``, ``STAMINA``, ``STAMINA_MAX``
-
-sent on a timer, once per second (every ``TICK_RATE`` ticks in the game loop).
-intended for status bar gauges.
-
-
-client side — tintin++ example
-------------------------------
-
-tintin++ does NOT auto-negotiate GMCP or MSDP. it sends ``IAC DONT`` by
-default, rejecting the server's offer. the ``CATCH`` event intercepts the
-incoming ``IAC WILL`` before tintin's default handler runs::
-
-    #EVENT {CATCH IAC WILL GMCP} {#send {\xFF\xFD\xC9\}}
-    #EVENT {CATCH IAC WILL MSDP} {#send {\xFF\xFD\x45\}}
-
-the hex bytes:
-
-- ``\xFF\xFD\xC9`` = ``IAC DO GMCP`` (255, 253, 201)
-- ``\xFF\xFD\x45`` = ``IAC DO MSDP`` (255, 253, 69)
-
-MSDP variables arrive as subnegotiation events and get stored in tintin
-variables for the status bar::
-
-    #EVENT {IAC SB MSDP} {
-        #variable {MSDP_%0} {%1};
-        #showme {[HP: $MSDP_HEALTH/$MSDP_HEALTH_MAX] ...} {-2}
-    }
-
-``{-2}`` puts the status bar on the split line at the bottom of the terminal.
-
-this was the trickiest part of the integration — the CATCH mechanism is
-not well-documented in tintin++ and the raw byte sending syntax changed
-across versions.
-
-
-the client command
-------------------
-
-players can type ``client`` in-game to see what got negotiated::
-
-    client protocols
-      GMCP: active
-      MSDP: active
-    terminal
-      type: xterm-256color
-      size: 120x40
-      color: 256
-      ...
-
-useful for debugging connection issues — if a player reports missing status
-bars, ``client`` shows whether MSDP actually negotiated.
-
-
-adding a protocol
------------------
-
-to add support for another telnet option:
-
-1. import the option byte constant (or define it)
-2. add ``self.writer.iac(WILL, NEW_OPTION)`` in ``MudTelnetServer.begin_negotiation()``
-3. add a ``new_option_enabled`` property on ``Player``
-4. guard all send functions on that property
-5. add it to the ``client`` command output
-6. add CATCH handler in ``mud.tin`` if tintin++ doesn't auto-negotiate it

docs/index.rst

@@ -27,7 +27,6 @@ mostly standalone subsystems.
 - ``docs/how/terrain-generation.txt`` — perlin noise, elevation thresholds, river tracing
 - ``docs/how/persistence.txt`` — SQLite storage, what's persisted vs runtime
 - ``docs/how/prompt-system.txt`` — modal prompts, color markup, per-player customization
-- ``docs/how/protocols.rst`` — GMCP/MSDP negotiation, client detection, guard pattern
 
 combat
 ------

mud.tin

@@ -1,32 +1,8 @@
-#NOP TinTin++ config for the MUD server
+#NOP TinTin++ config for connecting to 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 protocol negotiation: tintin++ does NOT auto-negotiate MSDP or
-#NOP GMCP. CATCH intercepts before the default DONT response, and
-#NOP #send handles hex escapes natively (no raw option needed).
-#EVENT {CATCH IAC WILL GMCP} {#send {\xFF\xFD\xC9\}}
-#EVENT {CATCH IAC WILL MSDP} {#send {\xFF\xFD\x45\}}
-
-#NOP store incoming MSDP variables and refresh 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 shortcuts: f + direction
+#NOP fly aliases: f<direction> = fly 5 in that direction
 #alias {fn} {fly north}
 #alias {fs} {fly south}
 #alias {fe} {fly east}
@@ -36,6 +12,10 @@
 #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,69 +260,6 @@ 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(
@@ -345,17 +282,6 @@ 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.
@@ -367,7 +293,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, client\r\n"
+            "type help <command> for details. see also: commands, skills\r\n"
         )
         return
     await _show_command_detail(player, args)

src/mudlib/gmcp.py

@@ -13,8 +13,6 @@ log = logging.getLogger(__name__)
 
 def send_char_vitals(player: Player) -> None:
     """Send Char.Vitals — pl, max_pl, stamina, max_stamina."""
-    if not player.gmcp_enabled:
-        return
     player.send_gmcp(
         "Char.Vitals",
         {
@@ -28,8 +26,6 @@ def send_char_vitals(player: Player) -> None:
 
 def send_char_status(player: Player) -> None:
     """Send Char.Status — flying, resting, mode, in_combat."""
-    if not player.gmcp_enabled:
-        return
     player.send_gmcp(
         "Char.Status",
         {
@@ -43,8 +39,6 @@ def send_char_status(player: Player) -> None:
 
 def send_room_info(player: Player) -> None:
     """Send Room.Info — zone, coordinates, terrain, exits."""
-    if not player.gmcp_enabled:
-        return
     from mudlib.zone import Zone
 
     zone = player.location
@@ -84,8 +78,6 @@ def send_room_info(player: Player) -> None:
 
 def send_map_data(player: Player) -> None:
     """Send Room.Map — terrain viewport around player for client rendering."""
-    if not player.gmcp_enabled:
-        return
     from mudlib.zone import Zone
 
     zone = player.location
@@ -115,19 +107,12 @@ def send_map_data(player: Player) -> None:
 
 
 def send_msdp_vitals(player: Player) -> None:
-    """Send MSDP variable updates for real-time gauges.
+    """Send MSDP variable updates for real-time gauges."""
-
+    player.send_msdp(
-    Skips sending if values haven't changed since last send.
+        {
-    """
-    if not player.msdp_enabled:
-        return
-    data = {
             "HEALTH": str(round(player.pl, 1)),
             "HEALTH_MAX": str(round(player.max_pl, 1)),
             "STAMINA": str(round(player.stamina, 1)),
             "STAMINA_MAX": str(round(player.max_stamina, 1)),
         }
-    if data == player._last_msdp:
+    )
-        return
-    player._last_msdp = data
-    player.send_msdp(data)

src/mudlib/player.py

@@ -5,8 +5,6 @@ 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
 
@@ -30,7 +28,6 @@ class Player(Entity):
     paint_mode: bool = False
     painting: bool = False
     paint_brush: str = "."
-    _last_msdp: dict = field(default_factory=dict, repr=False)
 
     @property
     def mode(self) -> str:
@@ -57,26 +54,6 @@ 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,8 +9,6 @@ import tomllib
 from typing import cast
 
 import telnetlib3
-from telnetlib3 import GMCP, MSDP, WILL
-from telnetlib3.server import TelnetServer
 from telnetlib3.server_shell import readline2
 
 import mudlib.combat.commands
@@ -226,18 +224,6 @@ async def handle_login(
             return {"success": False, "player_data": None}
 
 
-class MudTelnetServer(TelnetServer):
-    """Telnet server that offers GMCP and MSDP during negotiation."""
-
-    def begin_negotiation(self) -> None:
-        """Offer GMCP and MSDP as part of initial negotiation."""
-        super().begin_negotiation()
-        assert self.writer is not None
-        gmcp_ok = self.writer.iac(WILL, GMCP)
-        msdp_ok = self.writer.iac(WILL, MSDP)
-        log.debug("offered GMCP=%s MSDP=%s", gmcp_ok, msdp_ok)
-
-
 async def shell(
     reader: telnetlib3.TelnetReader | telnetlib3.TelnetReaderUnicode,
     writer: telnetlib3.TelnetWriter | telnetlib3.TelnetWriterUnicode,
@@ -256,14 +242,10 @@ async def shell(
     _writer.write("What is your name? ")
     await _writer.drain()
 
-    # Skip empty lines from client negotiation bytes, only close on actual disconnect
-    while True:
     name_input = await readline2(_reader, _writer)
-        if name_input is None:
+    if name_input is None or not name_input.strip():
         _writer.close()
         return
-        if name_input.strip():
-            break
 
     player_name = name_input.strip()
 
@@ -545,11 +527,7 @@ async def run_server() -> None:
     # MUD clients like tintin++ reject CHARSET immediately via MTTS, but
     # telnetlib3 still waits for the full timeout. 0.5s is plenty.
     server = await telnetlib3.create_server(
-        host=HOST,
+        host=HOST, port=PORT, shell=shell, connect_maxwait=0.5
-        port=PORT,
-        shell=shell,
-        connect_maxwait=0.5,
-        protocol_factory=MudTelnetServer,
     )
     log.info("listening on %s:%d", HOST, PORT)
 

tests/test_embedded_if.py

@@ -17,15 +17,6 @@ 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,11 +47,6 @@ 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
 
 
@@ -231,21 +226,6 @@ def test_send_msdp_vitals(player):
     )
 
 
-def test_send_msdp_vitals_dedup(player):
-    """Test MSDP skips sending when values haven't changed."""
-    send_msdp_vitals(player)
-    assert player.writer.send_msdp.call_count == 1
-
-    # second call with same values — should be suppressed
-    send_msdp_vitals(player)
-    assert player.writer.send_msdp.call_count == 1
-
-    # change a value — should send again
-    player.pl = 80.0
-    send_msdp_vitals(player)
-    assert player.writer.send_msdp.call_count == 2
-
-
 def test_player_send_gmcp(player):
     """Test Player.send_gmcp convenience method."""
     player.send_gmcp("Test.Package", {"key": "value"})
@@ -522,58 +502,3 @@ 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
-
-
-def test_gmcp_sends_skipped_when_not_negotiated(player):
-    """Test all GMCP send functions skip when GMCP is not negotiated."""
-    player.writer.local_option.enabled.return_value = False
-    player.writer.remote_option.enabled.return_value = False
-
-    send_char_vitals(player)
-    send_char_status(player)
-    send_room_info(player)
-    send_map_data(player)
-
-    player.writer.send_gmcp.assert_not_called()

tests/test_help.py

@@ -1,122 +0,0 @@
-"""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,13 +35,6 @@ 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)

uv.lock

@@ -245,11 +245,8 @@ wheels = [
 
 [[package]]
 name = "telnetlib3"
-version = "2.4.0"
+version = "2.3.0"
 source = { directory = "../../src/telnetlib3" }
-dependencies = [
-    { name = "wcwidth" },
-]
 
 [package.metadata]
 requires-dist = [
@@ -258,7 +255,6 @@ requires-dist = [
     { name = "sphinx-autodoc-typehints", marker = "extra == 'docs'" },
     { name = "sphinx-rtd-theme", marker = "extra == 'docs'" },
     { name = "ucs-detect", marker = "extra == 'extras'", specifier = ">=2" },
-    { name = "wcwidth", specifier = ">=0.2.13" },
 ]
 provides-extras = ["docs", "extras"]
 
@@ -270,12 +266,3 @@ sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac8
 wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
-
-[[package]]
-name = "wcwidth"
-version = "0.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
-]