thinkncollab-shell 0.0.5 → 0.0.7

package/src/core/websocket.js

@@ -1,17 +1,16 @@
 /**
- * WebSocket Manager for ThinkNCollab Shell
- * Uses thinknsh: prefixed events for terminal-specific communication
+ * src/core/websocket.js — WebSocket Manager for ThinkNCollab Shell
  */
 
-const { io } = require('socket.io-client');
+const { io }   = require('socket.io-client');
 const EventEmitter = require('events');
 
 class WebSocketManager extends EventEmitter {
+
     constructor(config = {}) {
         super();
-
         this.config = {
-            serverUrl:         config.serverUrl         || 'https://thinkncollab.com',
+            serverUrl:         config.serverUrl         || 'http://localhost:3001',
             reconnectAttempts: config.reconnectAttempts || 5,
             reconnectDelay:    config.reconnectDelay    || 1000,
             ...config
@@ -19,12 +18,13 @@ class WebSocketManager extends EventEmitter {
 
         this.socket         = null;
         this.connected      = false;
-        this.currentUser    = null;
+        this.currentUser    = null;   // always { userId, name, userType }
         this.roomId         = null;
         this.reconnectCount = 0;
         this.messageQueue   = [];
         this._authToken     = null;
         this._handlersSetup = false;
+        this._serverReady   = false;
     }
 
     // ─── Connect ──────────────────────────────────────────────────────────────
@@ -32,40 +32,34 @@ class WebSocketManager extends EventEmitter {
     connect(authToken = null) {
         return new Promise((resolve, reject) => {
             try {
-                this._authToken = authToken;
+                if (authToken) this._authToken = authToken;
 
                 this.socket = io(this.config.serverUrl + '/thinknsh', {
                     transports:           ['websocket', 'polling'],
                     reconnection:         true,
                     reconnectionAttempts: this.config.reconnectAttempts,
                     reconnectionDelay:    this.config.reconnectDelay,
-                    auth: authToken ? { token: authToken } : {},
+                    auth: this._authToken ? { token: this._authToken } : {},
                 });
 
-                const timeout = setTimeout(() => reject(new Error('Connection timeout')), 10000);
+                const timeout = setTimeout(() => {
+                    reject(new Error('Connection timeout'));
+                }, 10000);
 
                 this.socket.on('connect', () => {
                     clearTimeout(timeout);
                     this.connected      = true;
                     this.reconnectCount = 0;
 
+                    // Announce user immediately on connect if we have one
                     if (this.currentUser) {
-                        console.log('🖥️  Emitting thinknsh:connected for', this.currentUser.userId);
-                        this.socket.emit('thinknsh:connected', {
-                            userId:     this.currentUser.userId,
-                            userName:   this.currentUser.name,
-                            shellToken: authToken,
-                        });
+                        this._announceUser();
                     }
 
                     this.processPendingMessages();
                     this.emit('connected', { socketId: this.socket.id });
                     resolve({ success: true, socketId: this.socket.id });
                 });
-                // One-time listener for confirmation
-// this.ws.once('notified', (data) => {
-//     console.log(chalk.green(`✅ Notification sent to ${data.sentTo} member(s) in "${data.roomName}"`));
-// });
 
                 this.socket.on('connect_error', (error) => {
                     clearTimeout(timeout);
@@ -81,26 +75,14 @@ class WebSocketManager extends EventEmitter {
                     this.emit('disconnected', { reason });
                 });
 
-                this.socket.on('reconnect', (attemptNumber) => {
+                this.socket.on('reconnect', () => {
                     this.connected = true;
-                    this.emit('reconnected', { attemptNumber });
-
-                    // Re-announce user after reconnect
-                    if (this.currentUser) {
-                        this.socket.emit('thinknsh:connected', {
-                            userId:     this.currentUser.userId,
-                            userName:   this.currentUser.name,
-                            shellToken: this._authToken,
-                        });
-                    }
+                    this.emit('reconnected', {});
 
-                    // Rejoin room after reconnect
-                    if (this.roomId && this.currentUser) {
-                        this._emitJoin(this.roomId);
-                    }
+                    if (this.currentUser) this._announceUser();
+                    if (this.roomId && this.currentUser) this._emitJoin(this.roomId);
                 });
 
-                // ✅ Setup handlers only ONCE per socket instance
                 if (!this._handlersSetup) {
                     this.setupEventHandlers();
                     this._handlersSetup = true;
@@ -112,39 +94,68 @@ class WebSocketManager extends EventEmitter {
         });
     }
 
-    // ─── Event Handlers (registered once) ────────────────────────────────────
+    // ─── Announce user to server (thinknsh:connected) ─────────────────────────
+
+    _announceUser() {
+        if (!this.socket || !this.currentUser) return;
+        this.socket.emit('thinknsh:connected', {
+            userId:     this.currentUser.userId,
+            userName:   this.currentUser.name,
+            shellToken: this._authToken,
+        });
+    }
+
+    // ─── Set user — called right after login ──────────────────────────────────
+
+    /**
+     * Accepts any of these shapes and normalises to { userId, name, userType }:
+     *   { _id, userId, name, email, userType }   ← from api-client.getUser()
+     *   { userId, name, userType }                ← legacy
+     */
+    setUser(user, token = null) {
+        if (!user) return;
+
+        if (token) this._authToken = token;
+
+        // Normalise — support both _id and userId
+        const id = (user.userId || user._id || '').toString();
+        this.currentUser = {
+            userId:   id,
+            name:     user.name  || user.email || 'Unknown',
+            userType: user.userType || user.model || user.role || 'User',
+        };
+
+        // If already connected, announce immediately
+        if (this.connected && this.socket) {
+            this._announceUser();
+        }
+    }
+
+    // ─── Event Handlers ───────────────────────────────────────────────────────
 
     setupEventHandlers() {
 
-        // Terminal ready confirmed by server
         this.socket.on('thinknsh:ready', (data) => {
+            this._serverReady = true;
             this.emit('ready', data);
         });
 
-        // ✅ Room join confirmed + history delivered
         this.socket.on('thinknsh:joined', (data) => {
             this.roomId = data.roomId;
-
-            // Emit history separately so shell.js can display it
-            if (data.history && data.history.length > 0) {
-                this.emit('messageHistory', data.history);
-            }
-
+            if (data.history?.length) this.emit('messageHistory', data.history);
             this.emit('roomJoined', data);
         });
 
-        // Incoming message from terminal users
         this.socket.on('thinknsh:message', (data) => {
             this.emit('message', {
                 username:  data.name,
                 userId:    data.userId,
                 message:   data.message,
-                source:    data.source || 'shell',
+                source:    'shell',
                 timestamp: data.timestamp,
             });
         });
 
-        // Incoming message from web users
         this.socket.on('chat-message', (data) => {
             this.emit('message', {
                 username:  data.name,
@@ -155,75 +166,55 @@ class WebSocketManager extends EventEmitter {
             });
         });
 
-        // User joined from terminal
         this.socket.on('thinknsh:userJoined', (data) => {
             this.emit('userJoined', { username: data.name, source: 'shell' });
         });
 
-        // ✅ User left from terminal
         this.socket.on('thinknsh:userLeft', (data) => {
             this.emit('userLeft', { username: data.name, source: 'shell' });
         });
 
-        // User joined from web
         this.socket.on('user-joined', (name) => {
             this.emit('userJoined', { username: name, source: 'web' });
         });
 
-        // User left from web
         this.socket.on('user-left', (name) => {
             this.emit('userLeft', { username: name, source: 'web' });
         });
 
-        // User list updated
         this.socket.on('user-list', (users) => {
             this.emit('userList', { users });
         });
 
-        // ✅ Manual history fetch response
         this.socket.on('thinknsh:history', (data) => {
-            if (data.messages && data.messages.length > 0) {
-                this.emit('messageHistory', data.messages);
-            } else {
-                this.emit('messageHistory', []);
-            }
+            this.emit('messageHistory', data.messages?.length ? data.messages : []);
         });
 
-        // Single new-notification listener
         this.socket.on('new-notification', (data) => {
             this.emit('notification', {
-                type:       data.type       || 'notification',
-                level:      data.type       || 'info',
-                title:      data.type       || 'Notification',
-                message:    data.message    || '',
-                meta:       data.meta       || {},
+                type:       data.type    || 'info',
+                level:      data.type    || 'info',
+                title:      data.title   || 'Notification',
+                message:    data.message || '',
+                meta:       data.meta    || {},
                 taskTitle:  data.taskTitle  || data.meta?.taskTitle  || '',
                 assignedBy: data.assignedBy || data.meta?.assignedBy || '',
             });
         });
 
-        // Room activity feed
         this.socket.on('room:activity', (data) => {
-            this.emit('roomActivity', {
-                action:    data.action,
-                label:     data.label,
-                userName:  data.userName,
-                meta:      data.meta      || {},
-                createdAt: data.createdAt || new Date(),
-            });
+            this.emit('roomActivity', data);
         });
 
-        // Terminal status (online/offline)
         this.socket.on('thinknsh:status', (data) => {
             this.emit('shellStatus', data);
         });
 
-        // Notification list response
         this.socket.on('thinknsh:notifications', (data) => {
             this.emit('notificationList', data.notifications);
         });
 
-        // Server errors
+        // Server errors — emit as 'serverError' so shell.js can handle separately
         this.socket.on('thinknsh:error', (data) => {
             this.emit('serverError', data);
         });
@@ -233,46 +224,64 @@ class WebSocketManager extends EventEmitter {
         });
     }
 
-    // ─── Set user (call after login) ──────────────────────────────────────────
-
-    setUser(user, token = null) {
-        this.currentUser = user;
-        if (token) this._authToken = token;
-
-        if (this.connected && this.socket) {
-            this.socket.emit('thinknsh:connected', {
-                userId:     user.userId,
-                userName:   user.name,
-                shellToken: token || this._authToken,
-            });
-        }
-    }
-
     // ─── Join room ────────────────────────────────────────────────────────────
 
     joinRoom(roomId) {
         return new Promise((resolve, reject) => {
-            if (!this.connected || !this.socket) return reject(new Error('Not connected'));
-            if (!this.currentUser)               return reject(new Error('Not logged in'));
-
-            const timeout = setTimeout(() => reject(new Error('Join timeout')), 5000);
-
-            this.socket.once('thinknsh:joined', (data) => {
+            if (!this.connected || !this.socket)
+                return reject(new Error('Not connected to server'));
+            if (!this.currentUser)
+                return reject(new Error('Not logged in — run: login'));
+
+            const timeout = setTimeout(() => {
+                this.socket.off('thinknsh:joined', onJoined);
+                this.socket.off('thinknsh:error',  onError);
+                this.socket.off('thinknsh:ready',  onReady);
+                reject(new Error('Join timeout'));
+            }, 8000);
+
+            const onJoined = (data) => {
                 clearTimeout(timeout);
+                this.socket.off('thinknsh:error', onError);
                 this.roomId = data.roomId;
                 resolve(data);
-            });
+            };
+
+            // onReady declared at top so onError can reference it regardless of branch
+            let onReady = null;
 
-            this._emitJoin(roomId);
+            const onError = (data) => {
+                clearTimeout(timeout);
+                this.socket.off('thinknsh:joined', onJoined);
+                if (onReady) this.socket.off('thinknsh:ready', onReady);
+                reject(new Error(data.message || 'Join error'));
+            };
+
+            const doJoin = () => {
+                this.socket.once('thinknsh:joined', onJoined);
+                this.socket.once('thinknsh:error',  onError);
+                this._emitJoin(roomId);
+            };
+
+            if (this._serverReady) {
+                doJoin();
+            } else {
+                onReady = () => {
+                    this._serverReady = true;
+                    doJoin();
+                };
+                this.socket.once('thinknsh:ready', onReady);
+            }
         });
     }
 
     _emitJoin(roomId) {
+        if (!this.socket || !this.currentUser) return;
         this.socket.emit('thinknsh:join', {
             roomId,
             userId:   this.currentUser.userId,
             name:     this.currentUser.name,
-            userType: this.currentUser.userType || 'User',
+            userType: this.currentUser.userType,
         });
     }
 
@@ -300,55 +309,43 @@ class WebSocketManager extends EventEmitter {
             roomId:   this.roomId,
             userId:   this.currentUser.userId,
             name:     this.currentUser.name,
-            userType: this.currentUser.userType || 'User',
+            userType: this.currentUser.userType,
             message,
         });
 
         return Promise.resolve({ success: true });
     }
 
-    // ─── Fetch message history manually ──────────────────────────────────────
+    // ─── History ──────────────────────────────────────────────────────────────
 
     getHistory(limit = 30, skip = 0) {
-        if (!this.connected || !this.socket) return;
-        if (!this.roomId) return;
-
-        this.socket.emit('thinknsh:getHistory', {
-            roomId: this.roomId,
-            limit,
-            skip,
-        });
+        if (!this.connected || !this.socket || !this.roomId) return;
+        this.socket.emit('thinknsh:getHistory', { roomId: this.roomId, limit, skip });
     }
 
     // ─── Notifications ────────────────────────────────────────────────────────
 
     getNotifications() {
         if (!this.connected || !this.currentUser) return;
-        this.socket.emit('thinknsh:getNotifications', {
-            userId: this.currentUser.userId
-        });
+        this.socket.emit('thinknsh:getNotifications', { userId: this.currentUser.userId });
     }
 
-    // ─── Send notification ────────────────────────────────────────────────────
+    sendNotification(notification, target = 'room') {
+        if (!this.connected || !this.socket)
+            return Promise.reject(new Error('Not connected'));
+
+        this.socket.emit('notification:send', {
+            type:      notification.type    || 'info',
+            title:     notification.title   || 'Notification',
+            message:   notification.message,
+            data:      notification.data    || {},
+            target:    target === 'room' ? this.roomId : target,
+            timestamp: new Date().toISOString()
+        });
 
-sendNotification(notification, target = 'room') {
-    if (!this.connected || !this.socket) {
-        return Promise.reject(new Error('Not connected'));
+        return Promise.resolve({ success: true });
     }
 
-    const payload = {
-        type:      notification.type    || 'info',
-        title:     notification.title   || 'Notification',
-        message:   notification.message,
-        data:      notification.data    || {},
-        target:    target === 'room' ? this.roomId : target,
-        timestamp: new Date().toISOString()
-    };
-
-    this.socket.emit('notification:send', payload);
-    return Promise.resolve({ success: true });
-}
-
     markNotificationsRead(notificationIds = []) {
         if (!this.connected || !this.currentUser) return;
         this.socket.emit('thinknsh:markRead', {
@@ -359,43 +356,33 @@ sendNotification(notification, target = 'room') {
 
     // ─── Helpers ──────────────────────────────────────────────────────────────
 
-    joinUserRoom(userId) {
-        if (!this.socket || !userId) return;
-        this.socket.emit('thinknsh:connected', {
-            userId,
-            userName:   this.currentUser?.name || '',
-            shellToken: this._authToken || null,
-        });
-    }
-
-    ping() {
-        if (this.connected && this.socket) this.socket.emit('ping');
-    }
-
     processPendingMessages() {
-        if (this.messageQueue.length > 0 && this.roomId && this.currentUser) {
+        if (this.messageQueue.length && this.roomId && this.currentUser) {
             this.messageQueue.forEach(msg => this.sendMessage(msg));
             this.messageQueue = [];
         }
     }
 
-    sendTyping() {} // add later if needed
-
     disconnect() {
         if (this.socket) {
+            this.socket.removeAllListeners();
             this.socket.disconnect();
             this.socket         = null;
             this.connected      = false;
             this.currentUser    = null;
             this.roomId         = null;
             this._handlersSetup = false;
+        this._serverReady   = false;
+            this._serverReady   = false;
         }
     }
 
-    isConnected()     { return this.connected && !!this.socket?.connected; }
-    getCurrentRoom()  { return this.roomId; }
-    getSocketId()     { return this.socket?.id || null; }
-    getParticipants() { return Promise.resolve([]); }
+    isConnected()    { return this.connected && !!this.socket?.connected; }
+    getCurrentRoom() { return this.roomId; }
+    getSocketId()    { return this.socket?.id || null; }
+    getParticipants(){ return Promise.resolve([]); }
+    sendTyping()     {}
+    ping()           { if (this.connected && this.socket) this.socket.emit('ping'); }
 }
 
 module.exports = WebSocketManager;