sam-coder-cli 1.0.13 → 1.0.15

package/bin/multiplayer-client.js

@@ -1,57 +1,310 @@
 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');
 
-class MultiplayerClient extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.serverUrl = options.serverUrl || 'ws://localhost:8080';
-    this.clientId = uuidv4();
-    this.sessionId = null;
-    this.agentName = options.agentName || `Agent-${Math.floor(Math.random() * 1000)}`;
-    this.model = options.model || 'default';
-    this.isHost = false;
-    this.clients = new Map();
-    this.workHistory = [];
-    this.ws = null;
-    this.rl = options.rl || readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
+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 ensureServerRunning(port = 8080) {
+  const portInUse = await isPortInUse(port);
+  if (!portInUse) {
+    console.log('Starting local multiplayer server...');
+    // Start server in a detached process
+    const serverProcess = spawn('node', [__filename, '--server', '--port', port.toString()], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true
     });
+    
+    serverProcess.unref();
+    
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('Local multiplayer server started');
   }
+  return `ws://localhost:${port}`;
+}
+
+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 = {};
 
-  connect() {
-    this.ws = new WebSocket(this.serverUrl);
+      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);
+    }
+  }
 
-    this.ws.on('open', () => {
-      this.emit('connected');
+  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;
+    }
 
-    this.ws.on('message', (data) => {
-      try {
-        const message = JSON.parse(data);
-        this.handleMessage(message);
-      } catch (error) {
-        console.error('Error parsing message:', error);
+    // 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);
       }
     });
+  }
 
-    this.ws.on('close', () => {
-      this.emit('disconnected');
+  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);
+}
 
-    this.ws.on('error', (error) => {
-      this.emit('error', error);
+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.rl = options.rl || readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
     });
   }
 
+  async connect() {
+    try {
+      // Ensure server is running and get the correct URL
+      const url = new URL(this.serverUrl);
+      const serverPort = url.port || 8080;
+      this.serverUrl = await ensureServerRunning(serverPort);
+      
+      return new Promise((resolve, reject) => {
+        this.ws = new WebSocket(this.serverUrl);
+        
+        this.ws.on('open', () => {
+          this.connected = true;
+          // Send client info immediately after connection
+          this.send({
+            type: 'client_info',
+            clientInfo: {
+              name: this.name || `Agent-${Math.random().toString(36).substr(2, 4)}`,
+              role: this.role || 'Assistant',
+              model: this.model || 'default'
+            }
+          });
+          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');
+        });
+        
+        this.ws.on('error', (error) => {
+          this.connected = false;
+          reject(error);
+        });
+      });
+    } catch (error) {
+      console.error('Failed to start multiplayer server:', error);
+      throw error;
+    }
+  }
+
   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;
@@ -67,30 +320,45 @@ class MultiplayerClient extends EventEmitter {
       case 'task_assigned':
         this.handleTaskAssigned(message);
         break;
+      case 'task_completed':
+        this.handleTaskCompleted(message);
+        break;
+      case 'task_update':
+        this.handleTaskUpdate(message);
+        break;
       case 'error':
-        this.handleError(message);
+        console.error('Error:', message.message);
         break;
       default:
-        this.emit('message', message);
+        console.log('Unknown message type:', message.type);
     }
   }
 
   handleSessionJoined(message) {
     this.sessionId = message.sessionId;
-    this.isHost = message.clients.find(c => c.clientId === this.clientId)?.isHost || false;
-    
-    // Update local client list
-    this.clients.clear();
-    message.clients.forEach(client => {
-      this.clients.set(client.clientId, client);
-    });
-
+    this.clients = message.clients || [];
     this.workHistory = message.workHistory || [];
+    
+    // Process any pending tasks
+    if (message.pendingTasks && message.pendingTasks.length > 0) {
+      message.pendingTasks.forEach(task => {
+        this.emit('task_assigned', task);
+      });
+    }
+    
     this.emit('session_joined', message);
   }
 
+  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.set(message.clientId, {
+    this.clients.push({
       ...message.clientInfo,
       clientId: message.clientId
     });
@@ -102,10 +370,10 @@ class MultiplayerClient extends EventEmitter {
   }
 
   handleAgentLeft(message) {
-    const client = this.clients.get(message.clientId);
-    if (client) {
-      console.log(chalk.yellow(`\n${client.name || 'Agent'} has left the session`));
-      this.clients.delete(message.clientId);
+    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);
   }
@@ -113,7 +381,7 @@ class MultiplayerClient extends EventEmitter {
   handleChatMessage(message) {
     if (message.clientId === this.clientId) return;
     
-    const sender = this.clients.get(message.clientId) || { name: 'Unknown' };
+    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);
   }
@@ -125,59 +393,79 @@ class MultiplayerClient extends EventEmitter {
       clientId: message.clientId
     });
     
-    const client = this.clients.get(message.clientId) || { name: 'Unknown' };
+    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);
   }
 
-  handleTaskAssigned(message) {
-    if (message.assignedTo === this.clientId) {
-      console.log(chalk.magenta(`\n[Task Assigned] ${message.task.description}`));
-      this.emit('task_assigned', message.task);
-    }
-  }
-
-  handleError(message) {
-    console.error(chalk.red(`\n[Error] ${message.message}`));
-    this.emit('error', new Error(message.message));
-  }
-
-  createSession() {
-    this.send({
-      type: 'create_session',
-      clientInfo: {
-        name: this.agentName,
-        model: this.model,
-        isHost: true
-      }
-    });
+  handleTaskAssigned(task) {
+    console.log(`\n New task assigned: ${task.prompt}`);
+    console.log(`Type: ${task.taskType} | Assigned by: ${this.getClientName(task.assignedBy)}\n`);
+    
+    // Add to task queue
+    this.taskQueue.push(task);
+    this.processTaskQueue();
+    
+    this.emit('task_assigned', task);
   }
 
-  joinSession(sessionId) {
-    this.sessionId = sessionId;
-    this.send({
-      type: 'join_session',
-      sessionId,
-      clientInfo: {
-        name: this.agentName,
-        model: this.model
+  async processTaskQueue() {
+    if (this.currentTask || this.taskQueue.length === 0) return;
+    
+    this.currentTask = this.taskQueue.shift();
+    
+    try {
+      // Simulate working on the task
+      console.log(`\n Working on task: ${this.currentTask.prompt}`);
+      
+      // Here you would integrate with your AI to process the task
+      // For now, we'll just simulate work
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      
+      const result = {
+        taskId: this.currentTask.id,
+        result: `Completed task: ${this.currentTask.prompt}`,
+        timestamp: new Date().toISOString()
+      };
+      
+      // Send result back to server
+      this.send({
+        type: 'task_result',
+        sessionId: this.sessionId,
+        taskId: this.currentTask.id,
+        result: result.result,
+        timestamp: result.timestamp
+      });
+      
+      console.log(` Completed task: ${this.currentTask.prompt}`);
+      
+    } catch (error) {
+      console.error('Error processing task:', error);
+    } finally {
+      this.currentTask = null;
+      // Process next task if available
+      if (this.taskQueue.length > 0) {
+        this.processTaskQueue();
       }
-    });
+    }
   }
 
-  sendChatMessage(content) {
-    this.send({
-      type: 'chat',
-      sessionId: this.sessionId,
-      content,
-      timestamp: new Date().toISOString()
+  handleTaskCompleted(data) {
+    console.log(`\n Task completed by all agents!`);
+    console.log(`Task: ${this.tasks.get(data.taskId)?.prompt || 'Unknown task'}`);
+    console.log('Results:');
+    
+    data.results.forEach(result => {
+      console.log(`- ${this.getClientName(result.clientId)}: ${result.result}`);
     });
+    
+    this.emit('task_completed', data);
   }
 
   updateWork(work) {
-    const workUpdate = {
-      id: uuidv4(),
-      description: work.description,
+    const workItem = {
+      ...work,
+      clientId: this.clientId,
       status: work.status || 'in_progress',
       timestamp: new Date().toISOString()
     };

package/bin/multiplayer-mode.js

@@ -1,6 +1,6 @@
 const MultiplayerClient = require('./multiplayer-client');
-const chalk = require('chalk');
 const readline = require('readline');
+const chalk = require('chalk');
 const { v4: uuidv4 } = require('uuid');
 
 class MultiplayerMode {
@@ -86,142 +86,245 @@ class MultiplayerMode {
   }
 
   async start() {
-    this.client.connect();
+    console.clear();
+    this.printHeader();
     
-    this.rl.question(chalk.blue('Enter session ID to join or press Enter to create a new session: '), (sessionId) => {
-      if (sessionId && sessionId.trim()) {
-        this.client.joinSession(sessionId.trim());
-      } else {
-        console.log(chalk.yellow('Creating a new session...'));
-        this.client.createSession();
-      }
+    // Set agent name
+    this.client.name = await this.askQuestion('Enter your name (or press Enter for a random one): ') || 
+      `Agent-${Math.random().toString(36).substr(2, 4)}`;
+    
+    // Set agent role
+    console.log('\nAvailable roles:');
+    Object.entries(MultiplayerClient.AGENT_ROLES).forEach(([key, value]) => {
+      console.log(`- ${key}: ${value}`);
     });
+    this.client.role = await this.askQuestion('\nChoose your role (or press Enter for Developer): ') || 
+      MultiplayerClient.AGENT_ROLES.DEVELOPER;
+    
+    // Get session ID from user
+    const sessionId = await this.askQuestion('\nEnter session ID to join or press Enter to create a new session: ');
+    
+    if (sessionId) {
+      await this.joinSession(sessionId);
+    } else {
+      await this.createSession();
+    }
+    
+    this.setupCommandHandlers();
+    this.prompt();
   }
 
-  prompt() {
-    if (this.isWorking) return;
-    
-    this.rl.question(chalk.blue('> '), async (input) => {
-      if (!input.trim()) {
-        this.prompt();
-        return;
-      }
+  async askQuestion(question) {
+    return new Promise((resolve) => {
+      this.rl.question(question, (answer) => {
+        resolve(answer.trim());
+      });
+    });
+  }
 
-      // Handle commands
-      if (input.startsWith('/')) {
-        await this.handleCommand(input);
-      } else {
-        // Regular chat message
-        this.client.sendChatMessage(input);
-        this.prompt();
-      }
+  async joinSession(sessionId) {
+    this.client.joinSession(sessionId);
+  }
+
+  async createSession() {
+    console.log(chalk.yellow('Creating a new session...'));
+    this.client.createSession();
+  }
+
+  setupCommandHandlers() {
+    this.client.on('command', async (command) => {
+      await this.handleCommand(command);
     });
   }
 
-  async handleCommand(command) {
-    const [cmd, ...args] = command.slice(1).split(' ');
+  async handleCommand(input) {
+    const [command, ...args] = input.slice(1).split(' ');
     
-    switch (cmd.toLowerCase()) {
-      case 'help':
-        this.showHelp();
-        break;
-        
-      case 'name':
-        if (args.length > 0) {
-          const newName = args.join(' ');
-          this.client.agentName = newName;
-          console.log(chalk.green(`Name changed to: ${newName}`));
-          // Notify others about the name change
-          this.client.sendChatMessage(`I am now known as ${newName}`);
-        } else {
-          console.log(chalk.yellow('Current name:'), this.client.agentName);
-        }
-        break;
-        
-      case 'role':
-        if (args.length > 0) {
-          this.agentRole = args.join(' ');
-          console.log(chalk.green(`Role set to: ${this.agentRole}`));
-          this.client.sendChatMessage(`My role is: ${this.agentRole}`);
-        } else {
-          console.log(chalk.yellow('Current role:'), this.agentRole || 'Not set');
-        }
-        break;
-        
-      case 'work':
-        if (args.length > 0) {
-          const workDescription = args.join(' ');
-          this.client.updateWork({
-            description: workDescription,
-            status: 'in_progress'
-          });
-          console.log(chalk.green('Work update sent'));
-        } else {
-          console.log(chalk.yellow('Please provide a work description'));
-        }
-        break;
-        
-      case 'task':
-        if (args.length > 1) {
-          const [targetName, ...taskParts] = args;
-          const taskDescription = taskParts.join(' ');
+    try {
+      switch (command.toLowerCase()) {
+        case 'name':
+          if (args.length > 0) {
+            const newName = args.join(' ');
+            this.client.name = newName;
+            await this.client.updateClientInfo({ name: newName });
+            console.log(chalk.green(`✅ Name updated to: ${newName}`));
+          } else {
+            console.log(chalk.yellow(`Current name: ${this.client.name}`));
+          }
+          break;
+          
+        case 'role':
+          if (args.length > 0) {
+            const newRole = args.join(' ');
+            this.client.role = newRole;
+            await this.client.updateClientInfo({ role: newRole });
+            console.log(chalk.green(`✅ Role updated to: ${newRole}`));
+          } else {
+            console.log(chalk.yellow(`Current role: ${this.client.role}`));
+          }
+          break;
+          
+        case 'model':
+          if (args.length > 0) {
+            this.client.model = args[0];
+            await this.client.updateClientInfo({ model: this.client.model });
+            console.log(chalk.green(`✅ Model updated to: ${this.client.model}`));
+          } else {
+            console.log(chalk.yellow(`Current model: ${this.client.model}`));
+          }
+          break;
+          
+        case 'work':
+          if (args.length > 0) {
+            const workDesc = args.join(' ');
+            this.client.updateWork({
+              description: workDesc,
+              status: 'in_progress',
+              timestamp: new Date().toISOString()
+            });
+            console.log(chalk.green(`✅ Work updated: ${workDesc}`));
+          } else {
+            console.log(chalk.yellow('Please provide a work description. Example: /work Fixing bugs'));
+          }
+          break;
           
-          // Find client by name
-          const targetClient = Array.from(this.client.clients.values())
-            .find(c => c.name.toLowerCase() === targetName.toLowerCase());
+        case 'collab':
+        case 'collaborate':
+          if (args.length > 0) {
+            if (!this.client.isHost) {
+              console.log(chalk.yellow('Only the session host can initiate collaboration'));
+              break;
+            }
+            const taskType = args[0].toLowerCase();
+            const prompt = args.slice(1).join(' ');
+            
+            if (!Object.values(MultiplayerClient.TASK_TYPES).includes(taskType)) {
+              console.log(chalk.yellow(`Invalid task type. Available types: ${Object.values(MultiplayerClient.TASK_TYPES).join(', ')}`));
+              break;
+            }
+            
+            if (!prompt) {
+              console.log(chalk.yellow('Please provide a task prompt. Example: /collab research How does quantum computing work?'));
+              break;
+            }
+            
+            console.log(chalk.blue(`\n🤝 Starting collaborative ${taskType} task: ${prompt}`));
+            await this.client.collaborate(prompt, taskType);
+            
+          } else {
+            console.log(chalk.yellow('Usage: /collab <type> <prompt>'));
+            console.log(chalk.yellow('Types: ' + Object.values(MultiplayerClient.TASK_TYPES).join(', ')));
+          }
+          break;
+          
+        case 'task':
+          if (args.length > 1) {
+            const [target, ...taskArgs] = args;
+            const taskDesc = taskArgs.join(' ');
+            
+            // Find the target client
+            const targetClient = this.client.clients.find(c => 
+              c.name.toLowerCase() === target.toLowerCase() || 
+              c.clientId === target
+            );
+            
+            if (!targetClient) {
+              console.log(chalk.red(`❌ Could not find agent: ${target}`));
+              break;
+            }
+            
+            // In a real implementation, you would send this to the server
+            // and the server would route it to the appropriate client
+            console.log(chalk.blue(`\n📝 Task assigned to ${targetClient.name}: ${taskDesc}`));
             
-          if (targetClient) {
-            this.client.assignTask({
-              description: taskDescription,
-              status: 'pending'
-            }, targetClient.clientId);
-            console.log(chalk.green(`Task assigned to ${targetClient.name}`));
           } else {
-            console.log(chalk.red(`No agent found with name: ${targetName}`));
+            console.log(chalk.yellow('Usage: /task <agent> <task description>'));
+            console.log(chalk.yellow('Example: /task alice Please review the latest changes'));
           }
-        } else {
-          console.log(chalk.yellow('Usage: /task <agent_name> <task_description>'));
-        }
-        break;
-        
-      case 'list':
-        this.listAgents();
-        break;
-        
-      case 'exit':
-        console.log(chalk.yellow('Disconnecting...'));
-        this.client.disconnect();
-        process.exit(0);
-        break;
-        
-      default:
-        console.log(chalk.red('Unknown command. Type /help for available commands.'));
+          break;
+          
+        case 'list':
+          this.listAgents();
+          break;
+          
+        case 'exit':
+          console.log(chalk.yellow('\n👋 Disconnecting...'));
+          process.exit(0);
+          break;
+          
+        case 'help':
+          this.showHelp();
+          break;
+          
+        default:
+          console.log(chalk.red(`❌ Unknown command: ${command}. Type /help for available commands.`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error: ${error.message}`));
     }
     
     this.prompt();
   }
 
   showHelp() {
-    console.log(chalk.cyan('\nMultiplayer Mode Commands:'));
-    console.log('  /help                 - Show this help message');
-    console.log('  /name [new_name]      - Set or show your agent\'s name');
-    console.log('  /role [role]          - Set or show your agent\'s role');
-    console.log('  /work [description]   - Update your work status');
-    console.log('  /task [name] [task]   - Assign a task to another agent');
-    console.log('  /list                 - List all agents in the session');
-    console.log('  /exit                 - Leave the session and exit\n');
+    console.log('\n=== 🆘 Available Commands ===');
+    console.log('\n👤 Agent Management:');
+    console.log('  /name [new_name]    - Set or show your name');
+    console.log('  /role [role]        - Set or show your role');
+    console.log('  /model [model_name] - Set or show your AI model');
+    
+    console.log('\n🤝 Collaboration:');
+    console.log('  /work [description] - Update your work status');
+    console.log('  /collab <type> <prompt> - Start a collaborative task');
+    console.log('    Types: ' + Object.values(MultiplayerClient.TASK_TYPES).join(', '));
+    console.log('  /task [agent] [task] - Assign a task to another agent');
+    
+    console.log('\n📋 Session:');
+    console.log('  /list - List all agents in the session');
+    console.log('  /exit - Leave the session');
+    console.log('  /help - Show this help message');
+    
+    console.log('\n💡 Example:');
+    console.log('  /collab research How does quantum computing work?');
+    console.log('  /work Implementing user authentication');
+    console.log('  /task bob Please review my latest changes');
   }
 
   listAgents() {
-    console.log(chalk.cyan('\nAgents in session:'));
-    let index = 1;
-    for (const [id, client] of this.client.clients) {
-      const roleInfo = client.role ? ` (${client.role})` : '';
-      const hostInfo = client.isHost ? ' [HOST]' : '';
-      console.log(`  ${index}. ${chalk.green(client.name)}${roleInfo}${hostInfo}`);
-      index++;
+    console.log('\n=== 🧑‍💻 Agents in Session ===');
+    if (this.client.clients.length === 0) {
+      console.log('No other agents in the session');
+      return;
     }
-    console.log('');
+    
+    this.client.clients.forEach(client => {
+      const role = client.role ? ` (${client.role})` : '';
+      const status = client.isHost ? '👑 ' : '👤 ';
+      console.log(`${status}${client.name}${role} [${client.model}]`);
+      if (client.work) {
+        console.log(`   ${client.work.status === 'completed' ? '✅' : '🔄'} ${client.work.description}`);
+      }
+    });
+  }
+
+  prompt() {
+    if (this.isWorking) return;
+    
+    this.rl.question(chalk.blue('> '), async (input) => {
+      if (!input.trim()) {
+        this.prompt();
+        return;
+      }
+
+      // Handle commands
+      if (input.startsWith('/')) {
+        await this.handleCommand(input);
+      } else {
+        // Regular chat message
+        this.client.sendChatMessage(input);
+        this.prompt();
+      }
+    });
   }
 }
 

package/bin/multiplayer-server.js

@@ -6,24 +6,20 @@ class MultiplayerServer {
   constructor(port = 8080) {
     this.port = port;
     this.sessions = new Map();
-    this.server = http.createServer();
-    this.wss = new WebSocket.Server({ server: this.server });
+    this.clients = new Map();
+    this.tasks = new Map();
+    this.server = new WebSocket.Server({ port });
     this.setupEventHandlers();
   }
 
   setupEventHandlers() {
-    this.wss.on('connection', (ws) => {
+    this.server.on('connection', (ws) => {
       let clientId = uuid.v4();
       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);
-        }
+        this.handleMessage(ws, message);
       });
 
       ws.on('close', () => {
@@ -35,7 +31,7 @@ class MultiplayerServer {
             clientId,
             clientInfo
           });
-          
+
           if (Object.keys(session.clients).length === 0) {
             this.sessions.delete(sessionId);
           }
@@ -44,48 +40,129 @@ class MultiplayerServer {
     });
   }
 
-  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);
+  handleMessage(ws, message) {
+    try {
+      const data = typeof message === 'string' ? JSON.parse(message) : message;
+      const client = this.clients.get(ws);
+
+      switch (data.type) {
+        case 'client_info':
+          if (client) {
+            Object.assign(client, data.clientInfo);
+            this.broadcastToSession(client.sessionId, {
+              type: 'client_updated',
+              clientId: client.id,
+              clientInfo: data.clientInfo
+            }, ws);
+          }
+          break;
+
+        case 'create_session':
+          this.handleCreateSession(ws, data);
+          break;
+
+        case 'join_session':
+          this.handleJoinSession(ws, data);
+          break;
+
+        case 'collaborate':
+          if (client && client.sessionId) {
+            const taskId = uuid.v4();
+            this.tasks.set(taskId, {
+              id: taskId,
+              sessionId: client.sessionId,
+              prompt: data.prompt,
+              status: 'in_progress',
+              createdBy: client.id,
+              createdAt: new Date().toISOString(),
+              results: []
+            });
+
+            this.broadcastToSession(client.sessionId, {
+              type: 'task_assigned',
+              taskId,
+              prompt: data.prompt,
+              assignedBy: client.id
+            });
+          }
+          break;
+
+        case 'task_result':
+          if (client && client.sessionId && data.taskId) {
+            const task = this.tasks.get(data.taskId);
+            if (task) {
+              task.results.push({
+                clientId: client.id,
+                result: data.result,
+                timestamp: new Date().toISOString()
+              });
+
+              // Check if all clients have responded
+              const session = this.sessions.get(client.sessionId);
+              if (session && task.results.length >= Object.keys(session.clients).length) {
+                task.status = 'completed';
+                this.broadcastToSession(client.sessionId, {
+                  type: 'task_completed',
+                  taskId: task.id,
+                  results: task.results
+                });
+              }
+            }
+          }
+          break;
+
+        case 'chat':
+        case 'work_update':
+        case 'task_update':
+          this.broadcastToSession(data.sessionId, data);
+          break;
+
+        default:
+          console.log('Unknown message type:', data.type);
+      }
+    } catch (error) {
+      console.error('Error handling message:', error);
     }
   }
 
-  handleCreateSession(ws, clientId, data) {
+  handleCreateSession(ws, data) {
     const sessionId = uuid.v4();
+    const clientId = uuid.v4();
+
+    // Store client info
+    this.clients.set(ws, {
+      id: clientId,
+      sessionId,
+      ws,
+      isHost: true,
+      name: data.name || `Agent-${Math.random().toString(36).substr(2, 4)}`,
+      role: data.role || 'Assistant',
+      model: data.model || 'default'
+    });
+
     this.sessions.set(sessionId, {
       id: sessionId,
-      clients: {},
+      clients: { [clientId]: true },
       workHistory: [],
-      createdAt: new Date().toISOString()
+      createdAt: new Date().toISOString(),
+      hostId: clientId
     });
-    
-    this.handleJoinSession(ws, clientId, {
-      ...data,
+
+    // Send session created confirmation
+    ws.send(JSON.stringify({
+      type: 'session_created',
       sessionId,
+      clientId,
       isHost: true
-    });
+    }));
   }
 
-  handleJoinSession(ws, clientId, data) {
-    const { sessionId, clientInfo } = data;
-    
-    if (!this.sessions.has(sessionId)) {
+  handleJoinSession(ws, data) {
+    const { sessionId } = data;
+    const clientId = data.clientId || uuid.v4();
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
       ws.send(JSON.stringify({
         type: 'error',
         message: 'Session not found'
@@ -93,8 +170,6 @@ class MultiplayerServer {
       return;
     }
 
-    const session = this.sessions.get(sessionId);
-    
     if (Object.keys(session.clients).length >= 4) {
       ws.send(JSON.stringify({
         type: 'error',
@@ -103,40 +178,64 @@ class MultiplayerServer {
       return;
     }
 
-    // Add client to session
-    session.clients[clientId] = {
+    // Store/update client info
+    const existingClient = Array.from(this.clients.entries())
+      .find(([_, c]) => c.id === clientId)?.[1];
+
+    const clientInfo = {
+      id: clientId,
+      sessionId,
       ws,
-      clientId,
-      clientInfo: {
-        ...clientInfo,
-        joinedAt: new Date().toISOString(),
-        isHost: data.isHost || false
-      }
+      isHost: session.hostId === clientId,
+      name: data.name || existingClient?.name || `Agent-${clientId.substr(0, 4)}`,
+      role: data.role || existingClient?.role || 'Assistant',
+      model: data.model || existingClient?.model || 'default'
     };
 
+    this.clients.set(ws, clientInfo);
+    session.clients[clientId] = true;
+
+    // Get all client infos for the session
+    const sessionClients = Array.from(this.clients.values())
+      .filter(c => c.sessionId === sessionId)
+      .map(({ id, name, role, isHost }) => ({
+        id,
+        name,
+        role,
+        isHost
+      }));
+
     // 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
+      isHost: clientInfo.isHost,
+      clients: sessionClients,
+      workHistory: session.workHistory,
+      pendingTasks: Array.from(this.tasks.values())
+        .filter(t => t.sessionId === sessionId && t.status === 'in_progress')
     }));
 
     // Notify other clients
     this.broadcastToSession(sessionId, {
       type: 'agent_joined',
       clientId,
-      clientInfo: session.clients[clientId].clientInfo
-    }, clientId);
+      clientInfo: {
+        id: clientId,
+        name: clientInfo.name,
+        role: clientInfo.role,
+        isHost: clientInfo.isHost
+      }
+    }, ws);
   }
 
   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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {