Reject commands on closed transports

Author: ctoth

src/client.test.ts

@@ -146,6 +146,7 @@ vi.mock('./mcp', () => ({
 import MudClient from './client';
 import { GMCPClientFileTransfer } from './gmcp';
 import { useOutputStore } from './stores/outputStore';
+import type { Stream } from './telnet';
 
 class MockWebSocket {
   static CONNECTING = 0;
@@ -212,6 +213,7 @@ describe('MudClient lifecycle cleanup', () => {
     mockFileTransferManagerInstances.length = 0;
     mockPreferenceListeners.clear();
     mockPreferenceSubscribe.mockClear();
+    mockPreferencesState.general.localEcho = false;
     mockPreferencesState.sound.muteInBackground = false;
     mockWebSocketInstances.length = 0;
     useOutputStore.getState().reset();
@@ -337,6 +339,86 @@ describe('MudClient lifecycle cleanup', () => {
     expect(mcpPackage.reset).toHaveBeenCalledOnce();
   });
 
+  it('clears a closed local transport and rejects later sends', () => {
+    const client = new MudClient('example.test', 443);
+    const closeListeners: Array<() => void> = [];
+    const stream = {
+      close: vi.fn(() => {
+        closeListeners.forEach((listener) => {
+          listener();
+        });
+      }),
+      on: vi.fn((event: string, callback: () => void) => {
+        if (event === 'close') closeListeners.push(callback);
+      }),
+      write: vi.fn(),
+    } as unknown as Stream & { close(): void };
+    client.connectLocal(stream);
+
+    client.send('look\r\n');
+    expect(stream.write).toHaveBeenCalledOnce();
+
+    client.close();
+
+    expect(stream.close).toHaveBeenCalledOnce();
+    expect(client.connected).toBe(false);
+    expect(
+      client as unknown as { localMode: boolean; localStream?: Stream },
+    ).toMatchObject({
+      localMode: false,
+      localStream: undefined,
+    });
+    expect(() => client.send('look\r\n')).toThrow(
+      new Error('Cannot send while disconnected'),
+    );
+    expect(stream.write).toHaveBeenCalledOnce();
+  });
+
+  it.each([
+    ['CONNECTING', MockWebSocket.CONNECTING],
+    ['CLOSING', MockWebSocket.CLOSING],
+    ['CLOSED', MockWebSocket.CLOSED],
+  ])('rejects sends while the WebSocket is %s', (_label, readyState) => {
+    const client = new MudClient('example.test', 443);
+    client.connect();
+    const socket = mockWebSocketInstances[0];
+    socket.onopen?.(new Event('open'));
+    socket.readyState = readyState;
+
+    expect(() => client.send('look\r\n')).toThrow(
+      new Error('Cannot send while disconnected'),
+    );
+    expect(socket.send).not.toHaveBeenCalled();
+    client.close();
+  });
+
+  it('sends through a connected open WebSocket', () => {
+    const client = new MudClient('example.test', 443);
+    client.connect();
+    const socket = mockWebSocketInstances[0];
+    socket.onopen?.(new Event('open'));
+
+    client.send('look\r\n');
+
+    expect(socket.send).toHaveBeenCalledWith('look\r\n');
+  });
+
+  it('reports a disconnected command without adding local echo', () => {
+    mockPreferencesState.general.localEcho = true;
+    const client = new MudClient('example.test', 443);
+
+    expect(() => client.sendCommand('look')).not.toThrow();
+
+    expect(useOutputStore.getState().entries).toEqual([
+      {
+        id: 1,
+        type: 'error',
+        error: new Error('Cannot send while disconnected'),
+      },
+    ]);
+    expect(mockWebSocketInstances).toEqual([]);
+  });
+
   it('buffers text split across frames until the line is complete', () => {
     const client = new MudClient('example.test', 443);
     client.connect();

src/client.ts

@@ -260,12 +260,20 @@ class MudClient {
   }
 
   public send(data: string) {
-    if (this.localMode && this.localStream) {
+    if (this._connected && this.localMode && this.localStream) {
       // In local mode, write through the stream (WorkerStream -> Worker)
       this.localStream.write(Buffer.from(data));
-    } else {
-      this.ws.send(data);
+      return;
     }
+    if (
+      this._connected &&
+      this.ws &&
+      this.ws.readyState === WebSocket.OPEN
+    ) {
+      this.ws.send(data);
+      return;
+    }
+    throw new Error("Cannot send while disconnected");
   }
 
   registerCleanup(callback: () => void): void {
@@ -291,6 +299,8 @@ class MudClient {
     this.decoder = new TextDecoder("utf8");
     this.telnetBuffer = "";
     this.gmcp.reset();
+    this.localMode = false;
+    this.localStream = undefined;
     useConnectionStore.getState().setConnected(false);
   }
 
@@ -313,17 +323,23 @@ class MudClient {
     this.cleanupConnection();
   }
 
-  public sendCommand(command: string): void {
-    const localEchoEnabled = usePreferences.getState().general.localEcho;
-    if (localEchoEnabled) {
+  public sendCommand(command: string): void {
+    if (this.autosay && !command.startsWith("-") && !command.startsWith("'")) {
+      command = `say ${command}`;
+    }
+    try {
+      this.send(`${command}\r\n`);
+    } catch (error) {
+      useOutputStore
+        .getState()
+        .addError(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    if (usePreferences.getState().general.localEcho) {
       useOutputStore.getState().addCommand(command);
     }
-    if (this.autosay && !command.startsWith("-") && !command.startsWith("'")) {
-      command = `say ${command}`;
-    }
-    this.send(`${command}\r\n`);
-    console.log(`> ${command}`);
-  }
+    console.log(`> ${command}`);
+  }
 
   /*
 <message> ::= <message-start>