sam-coder-cli 1.0.10 → 1.0.12

package/MULTIPLAYER.md

@@ -0,0 +1,112 @@
+# Multiplayer Mode for SAM-CODER
+
+This guide explains how to use the Multiplayer Mode to collaborate with multiple AI agents in real-time.
+
+## Features
+
+- Host or join multiplayer sessions
+- Connect 2-4 AI agents in a single session
+- Each agent can have a unique name and role
+- Real-time chat and task coordination
+- Shared work history and task assignment
+- Support for different models/endpoints per agent
+
+## Quick Start
+
+1. First, install the required dependencies:
+   ```bash
+   npm install
+   ```
+
+2. Start the multiplayer server in a separate terminal:
+   ```bash
+   node bin/multiplayer-server.js
+   ```
+
+3. In a new terminal, start the first agent (host):
+   ```bash
+   node bin/agi-cli.js --multiplayer
+   ```
+   - Press Enter to create a new session
+   - Note the session ID shown in the console
+
+4. In another terminal, start additional agents (up to 3 more):
+   ```bash
+   node bin/agi-cli.js --multiplayer
+   ```
+   - Enter the session ID from step 3 to join
+
+## Multiplayer Commands
+
+Once in a multiplayer session, you can use these commands:
+
+- `/name [new_name]` - Set or show your agent's name
+- `/role [role]` - Set or show your agent's role
+- `/work [description]` - Update your work status
+- `/task [agent_name] [task]` - Assign a task to another agent
+- `/list` - List all agents in the session
+- `/help` - Show available commands
+- `/exit` - Leave the session
+
+## Agent Coordination
+
+### Work History
+- All agents can see updates to the shared work history
+- Use `/work` to update what you're working on
+- The work history helps agents coordinate and avoid duplicate work
+
+### Task Assignment
+- Use `/task` to assign specific tasks to other agents
+- Example: `/task Coder1 Implement the login function`
+- Assigned tasks appear in the target agent's console
+
+### Chat
+- Type any message to send it to all agents in the session
+- Use this to coordinate, ask questions, or share information
+
+## Advanced Usage
+
+### Custom Server URL
+By default, the client connects to `ws://localhost:8080`. To use a different server:
+
+```bash
+MP_SERVER_URL=ws://your-server-address:port node bin/agi-cli.js --multiplayer
+```
+
+### Different Models per Agent
+Each agent can use a different model by setting the `MODEL` environment variable:
+
+```bash
+MODEL=anthropic/claude-2 node bin/agi-cli.js --multiplayer
+```
+
+## Troubleshooting
+
+### Connection Issues
+- Ensure the multiplayer server is running
+- Check that the server URL is correct
+- Verify that your firewall allows WebSocket connections on the specified port
+
+### Session Full
+- Each session supports up to 4 agents
+- Create a new session if you need more agents
+
+### Agent Names
+- Agent names must be unique within a session
+- Use `/name` to change your agent's name if needed
+
+## Example Workflow
+
+1. Agent 1 creates a session and becomes the host
+2. Agent 2 joins the session with `/join <session-id>`
+3. Agents assign roles:
+   - Agent 1: `/role Backend Developer`
+   - Agent 2: `/role Frontend Developer`
+4. They coordinate work:
+   - Agent 1: `/work Implementing user authentication API`
+   - Agent 2: `/work Creating login form UI`
+5. They can assign tasks to each other:
+   - Agent 1: `/task Frontend Add form validation`
+   - Agent 2: `/task Backend Add rate limiting to auth endpoint`
+
+Enjoy collaborating with multiple AI agents in real-time!

package/bin/agi-cli.js

@@ -8,6 +8,7 @@ const fs = require('fs').promises;
 const { exec } = require('child_process');
 const util = require('util');
 const execAsync = util.promisify(exec);
+const MultiplayerMode = require('./multiplayer-mode');
 
 // Configuration
 const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
@@ -382,6 +383,22 @@ function extractJsonFromMarkdown(text) {
 // Call OpenRouter API with tool calling
 async function callOpenRouter(messages, currentModel, useJson = false) {
   const apiKey = OPENROUTER_API_KEY;
+  const isCustomEndpoint = API_BASE_URL !== 'https://openrouter.ai/api/v1';
+
+  let body = {
+    model: currentModel,
+    messages: messages,
+  };
+
+  // For standard OpenRouter calls that are not legacy, add tool parameters.
+  if (!isCustomEndpoint && !useJson) {
+    body.tools = tools;
+    body.tool_choice = 'auto';
+  }
+  // For custom endpoints (like vllm), ensure no tool-related parameters are sent.
+  else if (isCustomEndpoint) {
+    // The body is already clean for vLLM, containing only model and messages.
+  }
 
   try {
     const response = await fetch(`${API_BASE_URL}/chat/completions`, {
@@ -390,12 +407,7 @@ async function callOpenRouter(messages, currentModel, useJson = false) {
         'Authorization': `Bearer ${apiKey}`,
         'Content-Type': 'application/json'
       },
-      body: JSON.stringify({
-        model: currentModel,
-        messages: messages,
-        tools: useJson ? undefined : tools,
-        tool_choice: useJson ? undefined : 'auto'
-      })
+      body: JSON.stringify(body)
     });
 
     if (!response.ok) {
@@ -661,10 +673,20 @@ async function chat(rl, useToolCalling, initialModel) {
   });
 }
 
-function askForMode(rl) {
+function askForMode(rl, includeMultiplayer = false) {
   return new Promise((resolve) => {
-    rl.question('Select mode (1 for tool calling, 2 for function calling): ', (answer) => {
-      resolve(answer.trim() === '1');
+    const prompt = includeMultiplayer 
+      ? 'Select mode (1 for tool calling, 2 for function calling, 3 for multiplayer): '
+      : 'Select mode (1 for tool calling, 2 for function calling): ';
+      
+    rl.question(prompt, (answer) => {
+      const choice = answer.trim();
+      if (includeMultiplayer) {
+        if (choice === '3') resolve('multiplayer');
+        else resolve(choice === '1' ? 'tool' : 'function');
+      } else {
+        resolve(choice === '1');
+      }
     });
   });
 }
@@ -737,20 +759,45 @@ async function start() {
     MODEL = config.MODEL || 'deepseek/deepseek-chat-v3-0324:free';
 
     OPENROUTER_API_KEY = config.OPENROUTER_API_KEY;
+    
     if (config.isPro && config.customApiBase) {
       API_BASE_URL = config.customApiBase;
       console.log(`🚀 Using Pro Plan custom endpoint: ${API_BASE_URL}`);
     }
 
     ui.showHeader();
+    
+    // Check for multiplayer mode flag
+    if (process.argv.includes('--multiplayer')) {
+      const multiplayerMode = new MultiplayerMode({
+        rl,
+        model: MODEL,
+        serverUrl: process.env.MP_SERVER_URL || 'ws://localhost:8080'
+      });
+      await multiplayerMode.start();
+      return;
+    }
+
+    // Standard single-agent mode
     console.log('Select Mode:');
     console.log('1. Tool Calling (for models that support it)');
     console.log('2. Function Calling (legacy)');
+    console.log('3. Multiplayer Mode (collaborate with other agents)');
     
-    const useToolCalling = await askForMode(rl);
-    ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
+    const mode = await askForMode(rl, true);
     
-    await chat(rl, useToolCalling, MODEL);
+    if (mode === 'multiplayer') {
+      const multiplayerMode = new MultiplayerMode({
+        rl,
+        model: MODEL,
+        serverUrl: process.env.MP_SERVER_URL || 'ws://localhost:8080'
+      });
+      await multiplayerMode.start();
+    } else {
+      const useToolCalling = mode === 'tool';
+      ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
+      await chat(rl, useToolCalling, MODEL);
+    }
   } catch (error) {
     ui.showError(error);
     rl.close();

package/bin/multiplayer-client.js

@@ -0,0 +1,222 @@
+const WebSocket = require('ws');
+const EventEmitter = require('events');
+const readline = require('readline');
+const chalk = require('chalk');
+const { v4: uuidv4 } = require('uuid');
+
+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
+    });
+  }
+
+  connect() {
+    this.ws = new WebSocket(this.serverUrl);
+
+    this.ws.on('open', () => {
+      this.emit('connected');
+    });
+
+    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.emit('disconnected');
+    });
+
+    this.ws.on('error', (error) => {
+      this.emit('error', error);
+    });
+  }
+
+  handleMessage(message) {
+    switch (message.type) {
+      case 'session_joined':
+        this.handleSessionJoined(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 'error':
+        this.handleError(message);
+        break;
+      default:
+        this.emit('message', message);
+    }
+  }
+
+  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.workHistory = message.workHistory || [];
+    this.emit('session_joined', message);
+  }
+
+  handleAgentJoined(message) {
+    this.clients.set(message.clientId, {
+      ...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 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);
+    }
+    this.emit('agent_left', message);
+  }
+
+  handleChatMessage(message) {
+    if (message.clientId === this.clientId) return;
+    
+    const sender = this.clients.get(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.get(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
+      }
+    });
+  }
+
+  joinSession(sessionId) {
+    this.sessionId = sessionId;
+    this.send({
+      type: 'join_session',
+      sessionId,
+      clientInfo: {
+        name: this.agentName,
+        model: this.model
+      }
+    });
+  }
+
+  sendChatMessage(content) {
+    this.send({
+      type: 'chat',
+      sessionId: this.sessionId,
+      content,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  updateWork(work) {
+    const workUpdate = {
+      id: uuidv4(),
+      description: work.description,
+      status: work.status || 'in_progress',
+      timestamp: new Date().toISOString()
+    };
+
+    this.send({
+      type: 'work_update',
+      sessionId: this.sessionId,
+      work: workUpdate
+    });
+  }
+
+  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();
+    }
+  }
+}
+
+module.exports = MultiplayerClient;

package/bin/multiplayer-mode.js

@@ -0,0 +1,228 @@
+const MultiplayerClient = require('./multiplayer-client');
+const chalk = require('chalk');
+const readline = require('readline');
+const { v4: uuidv4 } = require('uuid');
+
+class MultiplayerMode {
+  constructor(options = {}) {
+    this.rl = options.rl || readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    this.client = new MultiplayerClient({
+      rl: this.rl,
+      agentName: options.agentName || this.generateAgentName(),
+      model: options.model || 'default',
+      serverUrl: options.serverUrl
+    });
+    
+    this.setupEventListeners();
+    this.agentRole = '';
+    this.isWorking = false;
+  }
+
+  generateAgentName() {
+    const adjectives = ['Swift', 'Clever', 'Wise', 'Agile', 'Smart', 'Quick', 'Bright', 'Sharp'];
+    const nouns = ['Coder', 'Thinker', 'Solver', 'Creator', 'Builder', 'Planner', 'Strategist'];
+    const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+    const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
+    return `${randomAdjective}${randomNoun}${Math.floor(100 + Math.random() * 900)}`;
+  }
+
+  setupEventListeners() {
+    this.client.on('connected', () => {
+      console.log(chalk.green('Connected to multiplayer server'));
+    });
+
+    this.client.on('disconnected', () => {
+      console.log(chalk.yellow('Disconnected from multiplayer server'));
+    });
+
+    this.client.on('session_joined', (data) => {
+      console.log(chalk.green(`\nJoined session: ${data.sessionId}`));
+      console.log(chalk.blue(`You are: ${this.client.agentName}`));
+      console.log(chalk.blue(`Model: ${this.client.model}`));
+      console.log(chalk.blue(`Clients in session: ${Array.from(this.client.clients.values()).map(c => c.name).join(', ')}`));
+      
+      if (this.client.isHost) {
+        console.log(chalk.yellow('\nYou are the host. Type /help for available commands.'));
+      }
+      
+      this.prompt();
+    });
+
+    this.client.on('agent_joined', (data) => {
+      console.log(chalk.blue(`\n${data.clientInfo.name} joined the session`));
+      this.prompt();
+    });
+
+    this.client.on('agent_left', (data) => {
+      const client = this.client.clients.get(data.clientId);
+      if (client) {
+        console.log(chalk.yellow(`\n${client.name} left the session`));
+        this.prompt();
+      }
+    });
+
+    this.client.on('chat', (message) => {
+      // Chat messages are already handled by the client
+      this.prompt();
+    });
+
+    this.client.on('work_updated', (data) => {
+      this.prompt();
+    });
+
+    this.client.on('task_assigned', (task) => {
+      console.log(chalk.magenta(`\n[New Task] ${task.description}`));
+      this.prompt();
+    });
+
+    this.client.on('error', (error) => {
+      console.error(chalk.red(`\nError: ${error.message}`));
+      this.prompt();
+    });
+  }
+
+  async start() {
+    this.client.connect();
+    
+    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();
+      }
+    });
+  }
+
+  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();
+      }
+    });
+  }
+
+  async handleCommand(command) {
+    const [cmd, ...args] = command.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(' ');
+          
+          // Find client by name
+          const targetClient = Array.from(this.client.clients.values())
+            .find(c => c.name.toLowerCase() === targetName.toLowerCase());
+            
+          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}`));
+          }
+        } 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.'));
+    }
+    
+    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');
+  }
+
+  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('');
+  }
+}
+
+module.exports = MultiplayerMode;

package/bin/multiplayer-server.js

@@ -0,0 +1,160 @@
+const WebSocket = require('ws');
+const http = require('http');
+const uuid = require('uuid');
+
+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.setupEventHandlers();
+  }
+
+  setupEventHandlers() {
+    this.wss.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);
+        }
+      });
+
+      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 = uuid.v4();
+    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() {
+    this.server.listen(this.port, () => {
+      console.log(`Multiplayer server running on ws://localhost:${this.port}`);
+    });
+  }
+}
+
+// Start server if run directly
+if (require.main === module) {
+  const server = new MultiplayerServer();
+  server.start();
+}
+
+module.exports = MultiplayerServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {
@@ -20,7 +20,10 @@
   "license": "MIT",
   "dependencies": {
     "chalk": "^4.1.2",
-    "ora": "^5.4.1"
+    "node-fetch": "^2.6.7",
+    "ora": "^5.4.1",
+    "uuid": "^9.0.0",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
     "eslint": "^7.27.0"