sam-coder-cli 1.0.29 → 1.0.31

package/bin/multiplayer-client.js

@@ -779,44 +779,50 @@ class MultiplayerClient extends EventEmitter {
     if (!sessionId) {
       throw new Error('Session ID is required');
     }
-    
     if (!this.connected) {
-      try {
-        await this.connect();
-      } catch (error) {
-        throw new Error(`Failed to connect to server: ${error.message}`);
-      }
+      await this.connect();
     }
     
     return new Promise((resolve, reject) => {
-      this.sessionId = sessionId;
-      this.isHost = false;
+      if (!this.ws) {
+        reject(new Error('Not connected to server'));
+        return;
+      }
+      
+      const timeout = setTimeout(() => {
+        this.off('session_joined', onSessionJoined);
+        this.off('error', onError);
+        reject(new Error('Session join timed out'));
+      }, 10000); // 10 second timeout
       
       const onSessionJoined = (data) => {
-        if (data.sessionId === this.sessionId) {
+        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('error', onError);
-          resolve();
+          resolve(data);
         }
       };
       
       const onError = (error) => {
+        clearTimeout(timeout);
         this.off('session_joined', onSessionJoined);
         this.off('error', onError);
         reject(error);
       };
       
-      this.once('session_joined', onSessionJoined);
-      this.once('error', onError);
+      this.on('session_joined', onSessionJoined);
+      this.on('error', onError);
       
       this.send({
         type: 'join_session',
-        sessionId: this.sessionId,
-        clientInfo: {
-          name: this.name,
-          role: this.role,
-          model: this.model
-        }
+        sessionId: sessionId,
+        clientId: this.clientId,
+        name: this.name,
+        role: this.role
       });
     });
   }

package/bin/multiplayer-server.js

@@ -263,17 +263,23 @@ class MultiplayerServer {
   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'
-      }));
-      return;
+    
+    // If session doesn't exist, create it (this allows for reconnection)
+    if (!this.sessions.has(sessionId)) {
+      console.log(`Session ${sessionId} not found, creating new session`);
+      this.sessions.set(sessionId, {
+        id: sessionId,
+        clients: {},
+        createdAt: new Date().toISOString(),
+        hostId: clientId,  // First joiner becomes host if session didn't exist
+        tasks: []
+      });
     }
 
-    if (Object.keys(session.clients).length >= 4) {
+    const session = this.sessions.get(sessionId);
+    
+    // Check if session is full (max 4 agents)
+    if (Object.keys(session.clients).length >= 4 && !session.clients[clientId]) {
       ws.send(JSON.stringify({
         type: 'error',
         message: 'Session is full (max 4 agents)'
@@ -292,45 +298,37 @@ class MultiplayerServer {
       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'
+      model: data.model || existingClient?.model || 'default',
+      joinedAt: new Date().toISOString(),
+      lastSeen: new Date().toISOString()
     };
 
+    // Add client to session
+    session.clients[clientId] = clientInfo;
     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
+    // Send session joined confirmation
     ws.send(JSON.stringify({
       type: 'session_joined',
       sessionId,
       clientId,
+      clientInfo,
       isHost: clientInfo.isHost,
-      clients: sessionClients,
-      workHistory: session.workHistory,
-      pendingTasks: Array.from(this.tasks.values())
-        .filter(t => t.sessionId === sessionId && t.status === 'in_progress')
+      sessionInfo: {
+        id: session.id,
+        createdAt: session.createdAt,
+        clientCount: Object.keys(session.clients).length,
+        hostId: session.hostId
+      }
     }));
 
-    // Notify other clients
+    // Notify other clients in the session
     this.broadcastToSession(sessionId, {
       type: 'agent_joined',
       clientId,
-      clientInfo: {
-        id: clientId,
-        name: clientInfo.name,
-        role: clientInfo.role,
-        isHost: clientInfo.isHost
-      }
-    }, ws);
+      clientInfo,
+      timestamp: new Date().toISOString()
+    }, clientId);
   }
 
   broadcastToSession(sessionId, message, excludeClientId = null) {
@@ -340,15 +338,27 @@ class MultiplayerServer {
     const messageStr = JSON.stringify(message);
 
     Object.entries(session.clients).forEach(([id, client]) => {
-      if (id !== excludeClientId && client.ws.readyState === WebSocket.OPEN) {
+      if (id !== excludeClientId && client.ws && 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}`);
+    return new Promise((resolve, reject) => {
+      this.httpServer = http.createServer();
+      this.wss = new WebSocket.Server({ server: this.httpServer });
+      this.setupEventHandlers();
+
+      this.httpServer.on('error', (error) => {
+        console.error(chalk.red('HTTP server error:'), error);
+        reject(error);
+      });
+      
+      this.httpServer.listen(this.port, () => {
+        console.log(chalk.green(`Multiplayer server started on port ${this.port}`));
+        resolve(this.port);
+      });
     });
   }
 }

package/package.json

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