thinkncollab-shell 0.0.4 → 0.0.6

package/src/core/websocket.js

@@ -1,15 +1,14 @@
 /**
- * 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',
             reconnectAttempts: config.reconnectAttempts || 5,
@@ -19,10 +18,13 @@ class WebSocketManager extends EventEmitter {
 
         this.socket         = null;
         this.connected      = false;
-        this.currentUser    = null;  // { userId, name, userType }
+        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 ──────────────────────────────────────────────────────────────
@@ -30,31 +32,28 @@ class WebSocketManager extends EventEmitter {
     connect(authToken = null) {
         return new Promise((resolve, reject) => {
             try {
-                // Connect to /thinknsh namespace — isolated from web
+                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;
-                    this._authToken     = authToken;
 
-                    // Announce terminal to backend — join personal notification room
+                    // 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();
@@ -76,16 +75,18 @@ class WebSocketManager extends EventEmitter {
                     this.emit('disconnected', { reason });
                 });
 
-                this.socket.on('reconnect', (attemptNumber) => {
+                this.socket.on('reconnect', () => {
                     this.connected = true;
-                    this.emit('reconnected', { attemptNumber });
-                    // Rejoin room after reconnect
-                    if (this.roomId && this.currentUser) {
-                        this._emitJoin(this.roomId);
-                    }
+                    this.emit('reconnected', {});
+
+                    if (this.currentUser) this._announceUser();
+                    if (this.roomId && this.currentUser) this._emitJoin(this.roomId);
                 });
 
-                this.setupEventHandlers(authToken);
+                if (!this._handlersSetup) {
+                    this.setupEventHandlers();
+                    this._handlersSetup = true;
+                }
 
             } catch (error) {
                 reject(error);
@@ -93,33 +94,68 @@ class WebSocketManager extends EventEmitter {
         });
     }
 
-    // ─── thinknsh: event handlers ─────────────────────────────────────────────
+    // ─── 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(authToken) {
+    setupEventHandlers() {
 
-        // Terminal ready confirmed by server
         this.socket.on('thinknsh:ready', (data) => {
+            this._serverReady = true;
             this.emit('ready', data);
         });
 
-        // Room join confirmed
         this.socket.on('thinknsh:joined', (data) => {
             this.roomId = data.roomId;
+            if (data.history?.length) this.emit('messageHistory', data.history);
             this.emit('roomJoined', data);
         });
 
-        // Incoming message from terminal or web
         this.socket.on('thinknsh:message', (data) => {
             this.emit('message', {
                 username:  data.name,
                 userId:    data.userId,
                 message:   data.message,
-                source:    data.source || 'web',
+                source:    'shell',
                 timestamp: data.timestamp,
             });
         });
 
-        // Also listen to standard chat-message (from web users)
         this.socket.on('chat-message', (data) => {
             this.emit('message', {
                 username:  data.name,
@@ -130,60 +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 joined from web
+        this.socket.on('thinknsh:userLeft', (data) => {
+            this.emit('userLeft', { username: data.name, source: 'shell' });
+        });
+
         this.socket.on('user-joined', (name) => {
             this.emit('userJoined', { username: name, source: 'web' });
         });
 
-        // User left
         this.socket.on('user-left', (name) => {
-            this.emit('userLeft', { username: name });
+            this.emit('userLeft', { username: name, source: 'web' });
         });
 
-        // User list updated
         this.socket.on('user-list', (users) => {
             this.emit('userList', { users });
         });
 
-        // Notifications from NotificationEngine
-        this.socket.on('new-notification', (notification) => {
-            this.emit('notification', {
-                type:    notification.type    || 'info',
-                title:   notification.type    || 'Notification',
-                message: notification.message || '',
-                meta:    notification.meta    || {},
-            });
-        });
-
-        // Terminal status (online/offline) — website sends this
-        this.socket.on('thinknsh:status', (data) => {
-            this.emit('shellStatus', data);
+        this.socket.on('thinknsh:history', (data) => {
+            this.emit('messageHistory', data.messages?.length ? data.messages : []);
         });
 
-        // ── new-notification from NotificationEngine → forward to TCP window ──
         this.socket.on('new-notification', (data) => {
-            // This goes to shell.js pushNotification → TCP → notification window
             this.emit('notification', {
-                type:    data.type    || 'notification',
-                level:   data.type   || 'info',
-                title:   data.type   || 'Notification',
-                message: data.message || '',
+                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 || '',
             });
         });
 
-        // Notification list response
+        this.socket.on('room:activity', (data) => {
+            this.emit('roomActivity', data);
+        });
+
+        this.socket.on('thinknsh:status', (data) => {
+            this.emit('shellStatus', data);
+        });
+
         this.socket.on('thinknsh:notifications', (data) => {
             this.emit('notificationList', data.notifications);
         });
 
-        // Error from server
+        // Server errors — emit as 'serverError' so shell.js can handle separately
         this.socket.on('thinknsh:error', (data) => {
             this.emit('serverError', data);
         });
@@ -193,44 +224,64 @@ class WebSocketManager extends EventEmitter {
         });
     }
 
-    // ─── Set user (call after login) ──────────────────────────────────────────
-
-    setUser(user, token = null) {
-        this.currentUser = user;
-        // If already connected, announce now
-        if (this.connected && this.socket) {
-            this.socket.emit('thinknsh:connected', {
-                userId:     user.userId,
-                shellToken: token,
-            });
-        }
-    }
-
     // ─── 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,
         });
     }
 
@@ -258,20 +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 });
     }
 
-    // ─── Get unread notifications ─────────────────────────────────────────────
+    // ─── History ──────────────────────────────────────────────────────────────
+
+    getHistory(limit = 30, skip = 0) {
+        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 });
     }
 
+    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()
+        });
+
+        return Promise.resolve({ success: true });
+    }
+
     markNotificationsRead(notificationIds = []) {
         if (!this.connected || !this.currentUser) return;
         this.socket.emit('thinknsh:markRead', {
@@ -282,23 +356,8 @@ class WebSocketManager extends EventEmitter {
 
     // ─── Helpers ──────────────────────────────────────────────────────────────
 
-    joinUserRoom(userId) {
-        if (!this.socket || !userId) return;
-        this.socket.emit('thinknsh:connected', {
-            userId,
-            userName:   this.currentUser?.name || '',
-            shellToken: this._token || null,
-        });
-    }
-
-    sendTyping() {}  // add later if needed
-
-    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 = [];
         }
@@ -306,18 +365,24 @@ class WebSocketManager extends EventEmitter {
 
     disconnect() {
         if (this.socket) {
+            this.socket.removeAllListeners();
             this.socket.disconnect();
-            this.socket      = null;
-            this.connected   = false;
-            this.currentUser = null;
-            this.roomId      = null;
+            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([]); }
+    getParticipants(){ return Promise.resolve([]); }
+    sendTyping()     {}
+    ping()           { if (this.connected && this.socket) this.socket.emit('ping'); }
 }
 
 module.exports = WebSocketManager;