Initial commit
This commit is contained in:
456
src/lib/connection/MudConnection.ts
Normal file
456
src/lib/connection/MudConnection.ts
Normal file
@@ -0,0 +1,456 @@
|
||||
import { EventEmitter } from '$lib/utils/EventEmitter';
|
||||
import type { GmcpHandler } from '$lib/gmcp/GmcpHandler';
|
||||
|
||||
// IAC codes for telnet negotiation
|
||||
enum TelnetCommand {
|
||||
IAC = 255, // Interpret As Command
|
||||
DONT = 254,
|
||||
DO = 253,
|
||||
WONT = 252,
|
||||
WILL = 251,
|
||||
SB = 250, // Subnegotiation Begin
|
||||
SE = 240, // Subnegotiation End
|
||||
GMCP = 201, // Generic MUD Communication Protocol
|
||||
}
|
||||
|
||||
interface MudConnectionOptions {
|
||||
host: string;
|
||||
port: number;
|
||||
gmcpHandler?: GmcpHandler;
|
||||
useSSL?: boolean;
|
||||
}
|
||||
|
||||
export class MudConnection extends EventEmitter {
|
||||
private host: string;
|
||||
private port: number;
|
||||
private useSSL: boolean;
|
||||
private webSocket: WebSocket | null = null;
|
||||
private gmcpHandler: GmcpHandler | null = null;
|
||||
private buffer: number[] = [];
|
||||
private connected: boolean = false;
|
||||
private negotiationBuffer: number[] = [];
|
||||
private isInIAC: boolean = false;
|
||||
private inSubnegotiation: boolean = false;
|
||||
private simulationMode: boolean = false; // Disable simulation mode to use real connections
|
||||
|
||||
constructor(options: MudConnectionOptions) {
|
||||
super();
|
||||
this.host = options.host;
|
||||
this.port = options.port;
|
||||
this.useSSL = options.useSSL || false;
|
||||
this.gmcpHandler = options.gmcpHandler || null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to the MUD server
|
||||
*/
|
||||
public connect(): void {
|
||||
// For development/testing purposes, we'll use a simulated connection
|
||||
if (this.simulationMode) {
|
||||
this.connectSimulated();
|
||||
return;
|
||||
}
|
||||
|
||||
// Connect through the standalone WebSocket server on port 3001
|
||||
const wsProtocol = window.location.protocol === 'https:' ? 'wss' : 'ws';
|
||||
const wsHost = `${window.location.hostname}:3001`;
|
||||
|
||||
const url = `${wsProtocol}://${wsHost}/mud-ws?host=${encodeURIComponent(this.host)}&port=${this.port}&useSSL=${this.useSSL}`;
|
||||
console.log('Connecting to WebSocket server:', url);
|
||||
|
||||
this.webSocket = new WebSocket(url);
|
||||
|
||||
this.webSocket.binaryType = 'arraybuffer';
|
||||
|
||||
this.webSocket.onopen = () => {
|
||||
this.connected = true;
|
||||
this.emit('connected');
|
||||
|
||||
// Send GMCP negotiation upon connection
|
||||
if (this.gmcpHandler) {
|
||||
this.sendIAC(TelnetCommand.WILL, TelnetCommand.GMCP);
|
||||
}
|
||||
};
|
||||
|
||||
this.webSocket.onclose = () => {
|
||||
this.connected = false;
|
||||
this.emit('disconnected');
|
||||
};
|
||||
|
||||
this.webSocket.onerror = (error) => {
|
||||
console.error('WebSocket error:', error);
|
||||
this.emit('error', `WebSocket error: Connection to ${this.host}:${this.port} failed. Please check your settings and ensure the MUD server is running.`);
|
||||
};
|
||||
|
||||
this.webSocket.onmessage = (event) => {
|
||||
if (event.data instanceof ArrayBuffer) {
|
||||
// Binary data
|
||||
this.handleIncomingData(new Uint8Array(event.data));
|
||||
} else if (typeof event.data === 'string') {
|
||||
// Text data
|
||||
this.emit('received', event.data);
|
||||
} else if (event.data instanceof Blob) {
|
||||
// Blob data (sometimes WebSockets send this instead of ArrayBuffer)
|
||||
const reader = new FileReader();
|
||||
reader.onload = () => {
|
||||
if (reader.result instanceof ArrayBuffer) {
|
||||
this.handleIncomingData(new Uint8Array(reader.result));
|
||||
}
|
||||
};
|
||||
reader.readAsArrayBuffer(event.data);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to a simulated MUD server for testing
|
||||
*/
|
||||
private connectSimulated(): void {
|
||||
console.log('Using simulated MUD connection');
|
||||
|
||||
// Simulate connection delay
|
||||
setTimeout(() => {
|
||||
this.connected = true;
|
||||
this.emit('connected');
|
||||
|
||||
// Send welcome message
|
||||
const welcomeMessage = `
|
||||
============================================================
|
||||
| Welcome to ${this.host} |
|
||||
============================================================
|
||||
|
||||
This is a simulated connection for testing purposes.
|
||||
Commands you type will be echoed back to the terminal.
|
||||
|
||||
Type 'help' for a list of available commands.
|
||||
Type 'look' to see the current room.
|
||||
`;
|
||||
setTimeout(() => {
|
||||
this.emit('received', welcomeMessage);
|
||||
}, 500);
|
||||
}, 1000);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send text to the MUD server
|
||||
*/
|
||||
public send(text: string): void {
|
||||
if (!this.connected) {
|
||||
throw new Error('Not connected to MUD server');
|
||||
}
|
||||
|
||||
// In simulation mode, generate appropriate responses
|
||||
if (this.simulationMode) {
|
||||
this.handleSimulatedCommand(text);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!this.webSocket) {
|
||||
throw new Error('WebSocket not initialized');
|
||||
}
|
||||
|
||||
// Check if the WebSocket is in a valid state for sending
|
||||
if (this.webSocket.readyState !== WebSocket.OPEN) {
|
||||
this.emit('error', `Cannot send message: WebSocket is not open (state: ${this.webSocket.readyState})`);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
// Append newline to the text
|
||||
const data = new TextEncoder().encode(text + '\n');
|
||||
this.webSocket.send(data);
|
||||
|
||||
// Emit the data for possible triggers
|
||||
this.emit('sent', text);
|
||||
} catch (error) {
|
||||
console.error('Error sending data:', error);
|
||||
this.emit('error', `Failed to send message: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle commands in simulation mode
|
||||
*/
|
||||
private handleSimulatedCommand(command: string): void {
|
||||
// Emit that we sent the command
|
||||
this.emit('sent', command);
|
||||
|
||||
// Process command with a small delay to simulate network latency
|
||||
setTimeout(() => {
|
||||
const cmd = command.trim().toLowerCase();
|
||||
|
||||
if (cmd === 'help') {
|
||||
this.emit('received', `
|
||||
Available commands:
|
||||
- help: Show this help message
|
||||
- look: Look at the current room
|
||||
- say <message>: Say something
|
||||
- who: Show who's online
|
||||
- inventory: Show your inventory
|
||||
- quit: Disconnect
|
||||
`);
|
||||
} else if (cmd === 'look') {
|
||||
this.emit('received', `
|
||||
The Testing Room
|
||||
================
|
||||
You are in a simple testing room. The walls are white and featureless,
|
||||
with a single door to the north. A sign on the wall reads "Simulation Mode".
|
||||
|
||||
Obvious exits: north
|
||||
|
||||
You see a test object here.
|
||||
`);
|
||||
} else if (cmd.startsWith('say ')) {
|
||||
const message = command.substring(4);
|
||||
this.emit('received', `You say, "${message}"\n`);
|
||||
} else if (cmd === 'who') {
|
||||
this.emit('received', `
|
||||
Players online:
|
||||
- TestPlayer1 (Idle)
|
||||
- TestPlayer2 (AFK)
|
||||
- You
|
||||
|
||||
Total: 3 players
|
||||
`);
|
||||
} else if (cmd === 'inventory' || cmd === 'i') {
|
||||
this.emit('received', `
|
||||
You are carrying:
|
||||
- a test item
|
||||
- a notebook
|
||||
- some coins (15)
|
||||
`);
|
||||
} else if (cmd === 'quit' || cmd === 'exit') {
|
||||
this.emit('received', 'Goodbye! Thanks for testing.\n');
|
||||
setTimeout(() => this.disconnect(), 1000);
|
||||
} else {
|
||||
this.emit('received', `Unknown command: ${command}\nType 'help' for a list of commands.\n`);
|
||||
}
|
||||
}, 200);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disconnect from the MUD server
|
||||
*/
|
||||
public disconnect(): void {
|
||||
if (this.simulationMode) {
|
||||
this.connected = false;
|
||||
this.emit('disconnected');
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.webSocket) {
|
||||
this.webSocket.close();
|
||||
this.webSocket = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle incoming data from the MUD server
|
||||
*/
|
||||
private handleIncomingData(data: Uint8Array): void {
|
||||
console.log(`Received ${data.length} bytes from server`);
|
||||
|
||||
// Quickly check if we need to handle telnet negotiation
|
||||
let containsIAC = false;
|
||||
for (let i = 0; i < data.length; i++) {
|
||||
if (data[i] === TelnetCommand.IAC) {
|
||||
containsIAC = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Fast path if no IAC codes
|
||||
if (!containsIAC && !this.isInIAC) {
|
||||
const text = new TextDecoder().decode(data);
|
||||
this.emit('received', text);
|
||||
return;
|
||||
}
|
||||
|
||||
// Debug: Log the raw bytes if IAC is present
|
||||
if (containsIAC) {
|
||||
const hexData = Array.from(data).map(b => b.toString(16).padStart(2, '0')).join(' ');
|
||||
console.log(`Data with IAC: ${hexData}`);
|
||||
}
|
||||
|
||||
// Process each byte in the incoming data
|
||||
for (let i = 0; i < data.length; i++) {
|
||||
const byte = data[i];
|
||||
|
||||
if (this.isInIAC) {
|
||||
// Add byte to negotiation buffer
|
||||
this.negotiationBuffer.push(byte);
|
||||
|
||||
// Check for special sequences
|
||||
if (this.inSubnegotiation) {
|
||||
// Inside subnegotiation - look for IAC SE
|
||||
if (byte === TelnetCommand.SE &&
|
||||
this.negotiationBuffer.length > 0 &&
|
||||
this.negotiationBuffer[this.negotiationBuffer.length - 2] === TelnetCommand.IAC) {
|
||||
|
||||
console.log('FOUND IAC SE SEQUENCE - End of subnegotiation');
|
||||
|
||||
// Process the complete subnegotiation
|
||||
this.handleCompleteSubnegotiation();
|
||||
|
||||
// Reset state
|
||||
this.isInIAC = false;
|
||||
this.inSubnegotiation = false;
|
||||
this.negotiationBuffer = [];
|
||||
}
|
||||
} else if (this.negotiationBuffer.length === 2) {
|
||||
// After IAC, check what command it is
|
||||
if (byte === TelnetCommand.SB) {
|
||||
// Start of subnegotiation
|
||||
this.inSubnegotiation = true;
|
||||
console.log('Started subnegotiation - waiting for option code');
|
||||
} else if (byte === TelnetCommand.WILL || byte === TelnetCommand.DO) {
|
||||
// Need one more byte for option
|
||||
console.log(`Telnet WILL/DO command, waiting for option`);
|
||||
} else {
|
||||
// Simple 3-byte command
|
||||
this.processSimpleTelnetCommand();
|
||||
this.isInIAC = false;
|
||||
this.negotiationBuffer = [];
|
||||
}
|
||||
} else if (this.negotiationBuffer.length === 3 && !this.inSubnegotiation) {
|
||||
// Complete 3-byte command like IAC WILL X or IAC DO X
|
||||
this.processSimpleTelnetCommand();
|
||||
this.isInIAC = false;
|
||||
this.negotiationBuffer = [];
|
||||
}
|
||||
} else if (byte === TelnetCommand.IAC) {
|
||||
// Start of telnet command
|
||||
this.isInIAC = true;
|
||||
this.negotiationBuffer = [byte];
|
||||
console.log('Found IAC - start of telnet command');
|
||||
} else {
|
||||
// Normal data byte, add to buffer
|
||||
this.buffer.push(byte);
|
||||
}
|
||||
}
|
||||
|
||||
// Process any complete text in the buffer
|
||||
if (this.buffer.length > 0) {
|
||||
const text = new TextDecoder().decode(new Uint8Array(this.buffer));
|
||||
this.buffer = [];
|
||||
|
||||
// Emit the received text for display and trigger processing
|
||||
this.emit('received', text);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a simple telnet command (3 bytes: IAC CMD OPTION)
|
||||
*/
|
||||
private processSimpleTelnetCommand(): void {
|
||||
try {
|
||||
const [iac, command, option] = this.negotiationBuffer;
|
||||
|
||||
console.log(`Processing telnet command: IAC(${iac}) ${command} ${option}`);
|
||||
|
||||
// Handle specific commands
|
||||
if ((command === TelnetCommand.WILL || command === TelnetCommand.DO) && option === TelnetCommand.GMCP) {
|
||||
console.log('Server indicates WILL/DO GMCP, responding with DO GMCP');
|
||||
// Server wants to use GMCP, we'll respond with IAC DO GMCP
|
||||
this.sendIAC(TelnetCommand.DO, TelnetCommand.GMCP);
|
||||
|
||||
// And request Core.Hello
|
||||
if (this.gmcpHandler) {
|
||||
console.log('Requesting GMCP capabilities');
|
||||
this.gmcpHandler.requestCapabilities();
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error processing telnet command:', error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle a complete telnet subnegotiation sequence
|
||||
*/
|
||||
private handleCompleteSubnegotiation(): void {
|
||||
try {
|
||||
console.log(`Handling subnegotiation, buffer length: ${this.negotiationBuffer.length}`);
|
||||
|
||||
// Check if this is a GMCP subnegotiation
|
||||
// IAC SB GMCP ... IAC SE
|
||||
// Indexes: 0 1 2 ... -2 -1
|
||||
if (this.negotiationBuffer.length >= 5 && this.negotiationBuffer[2] === TelnetCommand.GMCP) {
|
||||
console.log('Processing complete GMCP subnegotiation');
|
||||
|
||||
try {
|
||||
// Extract the GMCP data (skip IAC SB GMCP, and the final IAC SE)
|
||||
const gmcpData = this.negotiationBuffer.slice(3, -2);
|
||||
const gmcpText = new TextDecoder().decode(new Uint8Array(gmcpData));
|
||||
|
||||
console.log('RECEIVED GMCP DATA:', gmcpText);
|
||||
|
||||
// Process the GMCP message
|
||||
if (this.gmcpHandler) {
|
||||
setTimeout(() => {
|
||||
try {
|
||||
console.log('Passing GMCP to handler:', gmcpText);
|
||||
this.gmcpHandler?.handleGmcpMessage(gmcpText);
|
||||
} catch (error) {
|
||||
console.error('Error in GMCP handler:', error);
|
||||
}
|
||||
}, 0);
|
||||
} else {
|
||||
console.warn('No GMCP handler available for message:', gmcpText);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error processing GMCP data:', error, 'Buffer:', this.negotiationBuffer);
|
||||
}
|
||||
} else {
|
||||
console.log(`Non-GMCP subnegotiation complete, option: ${this.negotiationBuffer[2]}`);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error handling subnegotiation:', error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a telnet IAC sequence
|
||||
*/
|
||||
private sendIAC(command: TelnetCommand, option: TelnetCommand): void {
|
||||
if (!this.connected || !this.webSocket) {
|
||||
return;
|
||||
}
|
||||
|
||||
const data = new Uint8Array([TelnetCommand.IAC, command, option]);
|
||||
this.webSocket.send(data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a GMCP message
|
||||
*/
|
||||
public sendGmcp(module: string, data: any): void {
|
||||
if (!this.connected) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.simulationMode) {
|
||||
console.log(`GMCP send (simulated): ${module}`, data);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!this.webSocket) {
|
||||
return;
|
||||
}
|
||||
|
||||
const gmcpString = `${module} ${JSON.stringify(data)}`;
|
||||
const gmcpData = new TextEncoder().encode(gmcpString);
|
||||
|
||||
// Create the IAC SB GMCP <data> IAC SE sequence
|
||||
const telnetSequence = new Uint8Array([
|
||||
TelnetCommand.IAC,
|
||||
TelnetCommand.SB,
|
||||
TelnetCommand.GMCP,
|
||||
...gmcpData,
|
||||
TelnetCommand.IAC,
|
||||
TelnetCommand.SE
|
||||
]);
|
||||
|
||||
this.webSocket.send(telnetSequence);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user