sam-coder-cli 1.0.43 → 1.0.45

package/bin/multiplayer-client.js

@@ -1,905 +0,0 @@
-const WebSocket = require('ws');
-const http = require('http');
-const EventEmitter = require('events');
-const readline = require('readline');
-const chalk = require('chalk');
-const { v4: uuidv4 } = require('uuid');
-const { spawn, execSync } = require('child_process');
-
-async function isPortInUse(port) {
-  return new Promise((resolve) => {
-    const net = require('net');
-    const server = net.createServer()
-      .once('error', () => resolve(true))
-      .once('listening', () => {
-        server.close();
-        resolve(false);
-      })
-      .listen(port);
-  });
-}
-
-async function findAvailablePort(startPort = 8080, maxAttempts = 10) {
-  let port = startPort;
-  let attempts = 0;
-  
-  while (attempts < maxAttempts) {
-    const inUse = await isPortInUse(port);
-    if (!inUse) {
-      return port;
-    }
-    port++;
-    attempts++;
-  }
-  throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
-}
-
-async function ensureServerRunning(port = 8080, serverId = null) {
-  // First try to connect to an existing server by ID if provided
-  if (serverId) {
-    try {
-      console.log(chalk.blue(`Attempting to connect to existing server ${serverId}...`));
-      // Try to connect to the server
-      const ws = new WebSocket(`ws://${serverId}`);
-      
-      // Wait for connection or timeout
-      const connectionResult = await Promise.race([
-        new Promise(resolve => ws.once('open', () => resolve(true))),
-        new Promise(resolve => setTimeout(() => resolve(false), 2000))
-      ]);
-      
-      if (connectionResult) {
-        console.log(chalk.green(`✅ Connected to existing server at ${serverId}`));
-        ws.terminate();
-        return `ws://${serverId}`;
-      }
-      ws.terminate();
-    } catch (error) {
-      console.log(chalk.yellow(`Could not connect to server ${serverId}, starting a new server...`));
-    }
-  }
-  
-  // If no server ID provided or connection failed, start a new server
-  try {
-    const availablePort = await findAvailablePort(port);
-    const isDefaultPort = (availablePort === port);
-    
-    if (!isDefaultPort) {
-      console.log(chalk.yellow(`Port ${port} is in use, trying port ${availablePort}...`));
-    }
-    
-    console.log('Starting local multiplayer server...');
-    // Start server in a detached process
-    const serverProcess = spawn('node', [__filename, '--server', '--port', availablePort.toString()], {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true
-    });
-    
-    serverProcess.unref();
-    
-    // Wait for server to start
-    await new Promise(resolve => setTimeout(resolve, 1000));
-    console.log(chalk.green(`Local multiplayer server started on port ${availablePort}`));
-    return `ws://localhost:${availablePort}`;
-  } catch (error) {
-    console.error(chalk.red('Failed to start multiplayer server:'), error.message);
-    throw error;
-  }
-}
-
-class MultiplayerServer {
-  constructor(port = 8080, isChildProcess = false) {
-    this.port = port;
-    this.sessions = new Map();
-    this.server = http.createServer();
-    this.wss = new WebSocket.Server({ server: this.server });
-    this.setupEventHandlers();
-  }
-
-  setupEventHandlers() {
-    this.wss.on('connection', (ws) => {
-      let clientId = uuidv4();
-      let sessionId = null;
-      let clientInfo = {};
-
-      ws.on('message', (message) => {
-        try {
-          const data = JSON.parse(message);
-          this.handleMessage(ws, clientId, data);
-        } catch (error) {
-          console.error('Error parsing message:', error);
-        }
-      });
-
-      ws.on('close', () => {
-        if (sessionId && this.sessions.has(sessionId)) {
-          const session = this.sessions.get(sessionId);
-          delete session.clients[clientId];
-          this.broadcastToSession(sessionId, {
-            type: 'agent_left',
-            clientId,
-            clientInfo
-          });
-          
-          if (Object.keys(session.clients).length === 0) {
-            this.sessions.delete(sessionId);
-          }
-        }
-      });
-    });
-  }
-
-  handleMessage(ws, clientId, data) {
-    switch (data.type) {
-      case 'create_session':
-        this.handleCreateSession(ws, clientId, data);
-        break;
-      case 'join_session':
-        this.handleJoinSession(ws, clientId, data);
-        break;
-      case 'update_work':
-      case 'chat':
-      case 'task_update':
-        this.broadcastToSession(data.sessionId, {
-          ...data,
-          clientId,
-          timestamp: new Date().toISOString()
-        });
-        break;
-      default:
-        console.log('Unknown message type:', data.type);
-    }
-  }
-
-  handleCreateSession(ws, clientId, data) {
-    const sessionId = uuidv4();
-    this.sessions.set(sessionId, {
-      id: sessionId,
-      clients: {},
-      workHistory: [],
-      createdAt: new Date().toISOString()
-    });
-    
-    this.handleJoinSession(ws, clientId, {
-      ...data,
-      sessionId,
-      isHost: true
-    });
-  }
-
-  handleJoinSession(ws, clientId, data) {
-    const { sessionId, clientInfo } = data;
-    
-    if (!this.sessions.has(sessionId)) {
-      ws.send(JSON.stringify({
-        type: 'error',
-        message: 'Session not found'
-      }));
-      return;
-    }
-
-    const session = this.sessions.get(sessionId);
-    
-    if (Object.keys(session.clients).length >= 4) {
-      ws.send(JSON.stringify({
-        type: 'error',
-        message: 'Session is full (max 4 agents)'
-      }));
-      return;
-    }
-
-    // Add client to session
-    session.clients[clientId] = {
-      ws,
-      clientId,
-      clientInfo: {
-        ...clientInfo,
-        joinedAt: new Date().toISOString(),
-        isHost: data.isHost || false
-      }
-    };
-
-    // Send welcome message with session info
-    ws.send(JSON.stringify({
-      type: 'session_joined',
-      sessionId,
-      clientId,
-      clients: Object.values(session.clients).map(c => c.clientInfo),
-      workHistory: session.workHistory
-    }));
-
-    // Notify other clients
-    this.broadcastToSession(sessionId, {
-      type: 'agent_joined',
-      clientId,
-      clientInfo: session.clients[clientId].clientInfo
-    }, clientId);
-  }
-
-  broadcastToSession(sessionId, message, excludeClientId = null) {
-    if (!this.sessions.has(sessionId)) return;
-    
-    const session = this.sessions.get(sessionId);
-    const messageStr = JSON.stringify(message);
-    
-    Object.entries(session.clients).forEach(([id, client]) => {
-      if (id !== excludeClientId && client.ws.readyState === WebSocket.OPEN) {
-        client.ws.send(messageStr);
-      }
-    });
-  }
-
-  start() {
-    return new Promise((resolve) => {
-      this.server.listen(this.port, () => {
-        if (!this.isChildProcess) {
-          console.log(`Multiplayer server running on ws://localhost:${this.port}`);
-        }
-        resolve();
-      });
-    });
-  }
-  
-  static async startAsChildProcess(port = 8080) {
-    const server = new MultiplayerServer(port, true);
-    await server.start();
-    // Keep process alive
-    process.on('SIGINT', () => process.exit());
-  }
-}
-
-// Start server if this file is run directly
-if (require.main === module && process.argv.includes('--server')) {
-  const port = parseInt(process.argv[process.argv.indexOf('--port') + 1]) || 8080;
-  MultiplayerServer.startAsChildProcess(port);
-}
-
-class MultiplayerClient extends EventEmitter {
-  static TASK_TYPES = {
-    RESEARCH: 'research',
-    CODE: 'code',
-    DEBUG: 'debug',
-    DOCUMENT: 'document'
-  };
-  
-  static AGENT_ROLES = {
-    LEAD: 'Lead',
-    DEVELOPER: 'Developer',
-    RESEARCHER: 'Researcher',
-    REVIEWER: 'Reviewer'
-  };
-  constructor(options = {}) {
-    super();
-    this.serverUrl = options.serverUrl || 'ws://localhost:8080';
-    this.clientId = options.clientId || uuidv4();
-    this.name = options.name || `Agent-${this.clientId.substr(0, 4)}`;
-    this.role = options.role || MultiplayerClient.AGENT_ROLES.DEVELOPER;
-    this.model = options.model || 'default';
-    this.sessionId = options.sessionId || null;
-    this.isHost = options.isHost || false;
-    this.connected = false;
-    this.ws = null;
-    this.workHistory = [];
-    this.clients = [];
-    this.currentTask = null;
-    this.taskQueue = [];
-    this.pendingTasks = new Map();
-    this.taskResults = new Map();
-    this.rl = options.rl || readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    
-    // Bind methods
-    this.processTaskQueue = this.processTaskQueue.bind(this);
-    this.completeTask = this.completeTask.bind(this);
-  }
-
-  async connect(serverId = null) {
-    return new Promise((resolve, reject) => {
-      const connectWithRetry = async () => {
-        try {
-          // If no server URL is provided, try to start a local server or connect to the specified server ID
-          if (this.serverUrl === 'ws://localhost:8080') {
-            try {
-              this.serverUrl = await ensureServerRunning(8080, serverId);
-            } catch (error) {
-              console.error(chalk.red('Failed to start local server:'), error.message);
-              reject(error);
-              return;
-            }
-          }
-          
-          console.log(chalk.blue(`Connecting to ${this.serverUrl}...`));
-          this.ws = new WebSocket(this.serverUrl);
-          
-          const connectionTimeout = setTimeout(() => {
-            this.ws.terminate();
-            reject(new Error('Connection timeout'));
-          }, 10000); // 10 seconds timeout
-          
-          this.ws.on('open', () => {
-            clearTimeout(connectionTimeout);
-            this.connected = true;
-            console.log(chalk.green('✅ Connected to multiplayer server'));
-            
-            // Send client info
-            this.send({
-              type: 'client_info',
-              clientId: this.clientId,
-              name: this.name,
-              role: this.role,
-              model: this.model
-            });
-            
-            this.emit('connected');
-            resolve();
-          });
-          
-          this.ws.on('message', (data) => {
-            try {
-              const message = JSON.parse(data);
-              this.handleMessage(message);
-            } catch (error) {
-              console.error('Error parsing message:', error);
-            }
-          });
-          
-          this.ws.on('close', () => {
-            this.connected = false;
-            this.emit('disconnected');
-            console.log(chalk.yellow('\n🔌 Disconnected from multiplayer server'));
-          });
-          
-          this.ws.on('error', (error) => {
-            clearTimeout(connectionTimeout);
-            console.error('WebSocket error:', error.message);
-            if (!this.connected) {
-              reject(error);
-            }
-            this.emit('error', error);
-          });
-          
-        } catch (error) {
-          console.error('Connection error:', error.message);
-          reject(error);
-        }
-      };
-      
-      connectWithRetry();
-    });
-  }
-
-  handleMessage(message) {
-    switch (message.type) {
-      case 'session_joined':
-        this.handleSessionJoined(message);
-        break;
-      case 'session_created':
-        this.sessionId = message.sessionId;
-        this.clientId = message.clientId;
-        this.isHost = message.isHost;
-        this.emit('session_created', message);
-        break;
-      case 'client_updated':
-        this.handleClientUpdated(message);
-        break;
-      case 'agent_joined':
-        this.handleAgentJoined(message);
-        break;
-      case 'agent_left':
-        this.handleAgentLeft(message);
-        break;
-      case 'chat':
-        this.handleChatMessage(message);
-        break;
-      case 'work_update':
-        this.handleWorkUpdate(message);
-        break;
-      case 'task_assigned':
-        this.handleTaskAssigned(message);
-        break;
-      case 'task_completed':
-        this.handleTaskCompleted(message);
-        break;
-      case 'task_update':
-        this.handleTaskUpdate(message);
-        break;
-      case 'error':
-        console.error('Error:', message.message);
-        break;
-      default:
-        console.log('Unknown message type:', message.type);
-    }
-  }
-
-  handleSessionJoined(message) {
-    this.sessionId = message.sessionId;
-    this.clients = message.clients || [];
-    this.workHistory = message.workHistory || [];
-    
-    // Update host status if this client is the host
-    if (message.isHost !== undefined) {
-      this.isHost = message.isHost;
-    }
-    
-    // Process any pending tasks
-    if (message.pendingTasks && message.pendingTasks.length > 0) {
-      message.pendingTasks.forEach(task => {
-        this.emit('task_assigned', task);
-      });
-    }
-    
-    // Emit session_joined with host status
-    this.emit('session_joined', {
-      ...message,
-      isHost: this.isHost
-    });
-  }
-
-  handleClientUpdated(data) {
-    const clientIndex = this.clients.findIndex(c => c.id === data.clientId);
-    if (clientIndex !== -1) {
-      this.clients[clientIndex] = { ...this.clients[clientIndex], ...data.clientInfo };
-    }
-    this.emit('client_updated', data);
-  }
-
-  handleAgentJoined(message) {
-    this.clients.push({
-      ...message.clientInfo,
-      clientId: message.clientId
-    });
-    
-    if (message.clientId !== this.clientId) {
-      console.log(chalk.blue(`\n${message.clientInfo.name || 'Agent'} has joined the session`));
-    }
-    this.emit('agent_joined', message);
-  }
-
-  handleAgentLeft(message) {
-    const clientIndex = this.clients.findIndex(c => c.clientId === message.clientId);
-    if (clientIndex !== -1) {
-      console.log(chalk.yellow(`\n${this.clients[clientIndex].name || 'Agent'} has left the session`));
-      this.clients.splice(clientIndex, 1);
-    }
-    this.emit('agent_left', message);
-  }
-
-  handleChatMessage(message) {
-    if (message.clientId === this.clientId) return;
-    
-    const sender = this.clients.find(c => c.clientId === message.clientId) || { name: 'Unknown' };
-    console.log(chalk.cyan(`\n[${sender.name}]: ${message.content}`));
-    this.emit('chat', message);
-  }
-
-  handleWorkUpdate(message) {
-    this.workHistory.push({
-      ...message.work,
-      timestamp: message.timestamp,
-      clientId: message.clientId
-    });
-    
-    const client = this.clients.find(c => c.clientId === message.clientId) || { name: 'Unknown' };
-    console.log(chalk.green(`\n[Work Update] ${client.name}: ${message.work.description}`));
-    this.emit('work_updated', message);
-  }
-
-  async handleTaskAssigned(task) {
-    console.log(chalk.magenta(`\n📋 New Task: ${task.prompt}`));
-    console.log(chalk.dim(`Type: ${task.taskType} | Assigned by: ${this.getClientName(task.assignedBy)}\n`));
-    
-    // Store task in pending tasks
-    this.pendingTasks.set(task.id, {
-      ...task,
-      status: 'pending',
-      assignedAt: new Date().toISOString()
-    });
-    
-    // Add to task queue if it's assigned to this client or to all
-    if (!task.assignedTo || task.assignedTo === this.clientId) {
-      this.taskQueue.push(task);
-      this.processTaskQueue();
-    }
-    
-    this.emit('task_assigned', task);
-  }
-
-  async processTaskQueue() {
-    if (this.currentTask || this.taskQueue.length === 0) return;
-    
-    this.currentTask = this.taskQueue.shift();
-    const taskId = this.currentTask.id;
-    
-    try {
-      // Update task status to in-progress
-      this.pendingTasks.set(taskId, {
-        ...this.pendingTasks.get(taskId),
-        status: 'in_progress',
-        startedAt: new Date().toISOString()
-      });
-      
-      // Notify others about task progress
-      this.send({
-        type: 'task_progress',
-        sessionId: this.sessionId,
-        taskId,
-        status: 'in_progress',
-        progress: 0,
-        timestamp: new Date().toISOString()
-      });
-      
-      console.log(chalk.blue(`\n🔄 [${this.role}] Working on: ${this.currentTask.prompt}`));
-      
-      // Process the task using the completeTask method
-      const completedTask = await this.completeTask(taskId);
-      
-      if (completedTask) {
-        // Task completed successfully
-        this.send({
-          type: 'task_progress',
-          sessionId: this.sessionId,
-          taskId,
-          status: 'completed',
-          progress: 100,
-          timestamp: new Date().toISOString()
-        });
-        
-        console.log(chalk.green(`\n✅ [${this.role}] Completed task: ${this.currentTask.prompt}`));
-      }
-      if (this.taskQueue.length > 0) {
-        this.processTaskQueue();
-      }
-    } catch (error) {
-      console.error('Error processing task:', error);
-      this.send({
-        type: 'task_failed',
-        sessionId: this.sessionId,
-        taskId,
-        error: error.message,
-        timestamp: new Date().toISOString()
-      });
-    } finally {
-      this.currentTask = null;
-    }
-  }
-  
-  async completeTask(taskId) {
-    const task = this.pendingTasks.get(taskId);
-    if (!task) {
-      console.error('Task not found:', taskId);
-      return null;
-    }
-
-    try {
-      // Process the task using the same logic as the normal mode
-      const { processQuery } = require('./agi-cli');
-      const result = await processQuery(task.prompt, [], this.model);
-      
-      // Update task status
-      const completedTask = {
-        ...task,
-        status: 'completed',
-        completedAt: new Date().toISOString(),
-        result: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
-      };
-      
-      this.pendingTasks.set(taskId, completedTask);
-      this.taskResults.set(taskId, completedTask.result);
-      
-      // Notify server and other clients
-      this.send({
-        type: 'task_completed',
-        sessionId: this.sessionId,
-        taskId,
-        result: completedTask.result,
-        timestamp: new Date().toISOString()
-      });
-      
-      console.log(chalk.green(`\n✅ [${this.role}] Completed: ${task.prompt}`));
-      this.emit('task_completed', completedTask);
-      
-      return completedTask;
-    } catch (error) {
-      console.error('Error completing task:', error);
-      
-      // Update task with error status
-      const failedTask = {
-        ...task,
-        status: 'failed',
-        completedAt: new Date().toISOString(),
-        error: error.message
-      };
-      
-      this.pendingTasks.set(taskId, failedTask);
-      this.emit('task_failed', { taskId, error: error.message });
-      
-      return null;
-    }
-  }
-
-  handleTaskCompleted(data) {
-    const task = this.pendingTasks.get(data.taskId);
-    if (!task) {
-      console.error('Task not found for completion:', data.taskId);
-      return;
-    }
-    
-    console.log(chalk.green(`\n✅ Task completed by all agents!`));
-    console.log(chalk.blue(`Task: ${task.prompt || 'Unknown task'}`));
-    
-    if (data.results && data.results.length > 0) {
-      console.log(chalk.cyan('Results:'));
-      data.results.forEach(result => {
-        console.log(chalk.yellow(`- ${this.getClientName(result.clientId) || 'Unknown'}:`));
-        console.log(result.result);
-      });
-    } else if (data.result) {
-      console.log(chalk.cyan('Result:'));
-      console.log(data.result);
-    }
-    
-    // Update the task with the final result
-    const completedTask = {
-      ...task,
-      status: 'completed',
-      completedAt: new Date().toISOString(),
-      result: data.result || 'No result provided'
-    };
-    
-    this.pendingTasks.set(data.taskId, completedTask);
-    this.taskResults.set(data.taskId, completedTask.result);
-    
-    this.emit('task_completed', completedTask);
-  }
-
-  async updateWork(work) {
-    const workItem = {
-      id: uuidv4(),
-      ...work,
-      clientId: this.clientId,
-      clientName: this.name,
-      timestamp: new Date().toISOString(),
-      status: work.status || 'in_progress'
-    };
-    
-    this.workHistory.push(workItem);
-    
-    // Keep only the last 10 work items
-    if (this.workHistory.length > 10) {
-      this.workHistory = this.workHistory.slice(-10);
-    }
-    
-    this.send({
-      type: 'work_update',
-      sessionId: this.sessionId,
-      ...workItem
-    });
-    
-    this.emit('work_updated', workItem);
-    return workItem;
-  }
-  
-  async updateClientInfo(updates) {
-    // Update local client info
-    Object.assign(this, updates);
-    
-    // Notify server about the update
-    if (this.connected) {
-      this.send({
-        type: 'client_update',
-        sessionId: this.sessionId,
-        clientId: this.clientId,
-        updates: {
-          name: this.name,
-          role: this.role,
-          model: this.model,
-          updatedAt: new Date().toISOString()
-        },
-        timestamp: new Date().toISOString()
-      });
-    }
-  }
-
-  assignTask(task, assigneeClientId) {
-    this.send({
-      type: 'task_assigned',
-      sessionId: this.sessionId,
-      task: {
-        ...task,
-        assignedBy: this.clientId,
-        assignedAt: new Date().toISOString()
-      },
-      assignedTo: assigneeClientId
-    });
-  }
-
-  send(message) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({
-        ...message,
-        clientId: this.clientId,
-        timestamp: new Date().toISOString()
-      }));
-    }
-  }
-
-  disconnect() {
-    if (this.ws) {
-      this.ws.close();
-      this.connected = false;
-      this.ws = null;
-    }
-    if (this.rl) {
-      this.rl.close();
-    }
-  }
-  
-  sendChatMessage(message) {
-    if (!this.connected || !this.ws) {
-      console.error('Not connected to server');
-      return false;
-    }
-    
-    try {
-      const chatMessage = {
-        type: 'chat_message',
-        sessionId: this.sessionId,
-        clientId: this.clientId,
-        sender: this.name,
-        message: message,
-        timestamp: new Date().toISOString()
-      };
-      
-      this.ws.send(JSON.stringify(chatMessage));
-      return true;
-    } catch (error) {
-      console.error('Error sending chat message:', error);
-      return false;
-    }
-  }
-
-  getClientName(clientId) {
-    if (!clientId) return 'Unknown';
-    const client = this.clients.find(c => c.clientId === clientId || c.id === clientId);
-    return client ? (client.name || client.clientInfo?.name || 'Unknown') : 'Unknown';
-  }
-  
-  async createSession(sessionId = null) {
-    if (!this.connected) {
-      await this.connect();
-    }
-    
-    this.sessionId = sessionId || uuidv4();
-    this.isHost = true;
-    
-    return new Promise((resolve, reject) => {
-      if (!this.ws) {
-        reject(new Error('Not connected to server'));
-        return;
-      }
-      
-      const onSessionCreated = (data) => {
-        if (data.sessionId === this.sessionId) {
-          this.off('session_created', onSessionCreated);
-          this.off('error', onError);
-          console.log(`✅ Session ${this.sessionId} created successfully`);
-          resolve(this.sessionId);
-        }
-      };
-      
-      const onError = (error) => {
-        this.off('session_created', onSessionCreated);
-        this.off('error', onError);
-        console.error('Error creating session:', error.message);
-        reject(error);
-      };
-      
-      this.once('session_created', onSessionCreated);
-      this.once('error', onError);
-      
-      console.log(`Creating new session ${this.sessionId}...`);
-      this.send({
-        type: 'create_session',
-        sessionId: this.sessionId,
-        clientInfo: {
-          name: this.name,
-          role: this.role,
-          model: this.model
-        }
-      });
-    });
-  }
-  
-  async joinSession(sessionId, createIfNotExists = true) {
-    if (!sessionId) {
-      throw new Error('Session ID is required');
-    }
-    if (!this.connected) {
-      await this.connect();
-    }
-    
-    return new Promise((resolve, reject) => {
-      if (!this.ws) {
-        reject(new Error('Not connected to server'));
-        return;
-      }
-      
-      const timeout = setTimeout(() => {
-        this.off('session_joined', onSessionJoined);
-        this.off('session_created', onSessionCreated);
-        this.off('error', onError);
-        reject(new Error('Session join timed out'));
-      }, 15000); // Increased timeout to 15 seconds
-      
-      const onSessionJoined = (data) => {
-        if (data.sessionId === sessionId) {
-          clearTimeout(timeout);
-          this.sessionId = sessionId;
-          this.isHost = data.isHost || false;
-          this.emit('session_joined', data);
-          this.off('session_joined', onSessionJoined);
-          this.off('session_created', onSessionCreated);
-          this.off('error', onError);
-          console.log(`✅ Successfully joined session ${sessionId}`);
-          resolve(data);
-        }
-      };
-      
-      const onSessionCreated = (data) => {
-        if (data.sessionId === sessionId) {
-          clearTimeout(timeout);
-          this.sessionId = sessionId;
-          this.isHost = true;
-          this.emit('session_joined', { ...data, isHost: true });
-          this.off('session_joined', onSessionJoined);
-          this.off('session_created', onSessionCreated);
-          this.off('error', onError);
-          console.log(`✅ Created and joined new session ${sessionId}`);
-          resolve({ ...data, isHost: true });
-        }
-      };
-      
-      const onError = (error) => {
-        if (error.message === 'Session not found' && createIfNotExists) {
-          // If session doesn't exist and we're allowed to create it
-          this.off('session_joined', onSessionJoined);
-          this.off('error', onError);
-          console.log(`Session ${sessionId} not found, creating new session...`);
-          this.createSession(sessionId)
-            .then(() => {
-              this.once('session_created', onSessionCreated);
-              this.once('error', onError);
-            })
-            .catch(reject);
-          return;
-        }
-        
-        clearTimeout(timeout);
-        this.off('session_joined', onSessionJoined);
-        this.off('session_created', onSessionCreated);
-        this.off('error', onError);
-        console.error('Error joining session:', error.message);
-        reject(error);
-      };
-      
-      this.on('session_joined', onSessionJoined);
-      this.on('error', onError);
-      
-      console.log(`Attempting to join session ${sessionId}...`);
-      this.send({
-        type: 'join_session',
-        sessionId: sessionId,
-        clientId: this.clientId,
-        name: this.name,
-        role: this.role
-      });
-    });
-  }
-}
-
-// Export MultiplayerClient and MultiplayerServer as direct properties of module.exports
-module.exports.MultiplayerClient = MultiplayerClient;
-module.exports.MultiplayerServer = MultiplayerServer;