sam-coder-cli 1.0.13 → 1.0.14

package/bin/multiplayer-client.js

@@ -1,8 +1,210 @@
 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 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 = {};
+
+      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 {
   constructor(options = {}) {
@@ -22,29 +224,44 @@ class MultiplayerClient extends EventEmitter {
     });
   }
 
-  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);
-    });
+  async connect() {
+    try {
+      // Ensure server is running and get the correct URL
+      const serverPort = new URL(this.serverUrl).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;
+          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) {

package/package.json

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