thinkncollab-shell 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkncollab-shell",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "ThinkNCollab Custom Shell with WebSocket collaboration",
   "main": "src/core/shell.js",
   "bin": {

package/src/commands/auth/login.js

@@ -1,74 +1,74 @@
-const chalk = require('chalk');
-const fs = require('fs-extra');
-const path = require('path');
+/**
+ * commands/auth/login.js
+ */
+
+const chalk    = require('chalk');
+const inquirer = require('inquirer');
 
 module.exports = {
-    name: 'login',
-    description: 'Login to ThinkNCollab',
-    aliases: ['signin'],
+    name:         'login',
+    description:  'Login to ThinkNCollab',
+    aliases:      ['signin'],
     requiresAuth: false,
 
     async execute(args, shell) {
-        let email, password;
-
-        try {
-            if (args.length === 0) {
-                const { input, password: pwdFn } = require('@inquirer/prompts');
-                email    = await input({ message: 'Email:' });
-                password = await pwdFn({ message: 'Password:', mask: '*' });
-
-            } else if (args.length >= 2) {
-                email    = args[0];
-                password = args[1];
-            } else {
-                console.log(chalk.red('❌ Usage: login <email> <password>'));
-                console.log(chalk.dim('   or:  login (interactive)'));
-                return;
-            }
-
-            if (!email || !password) {
-                console.log(chalk.red('❌ Email and password required'));
-                return;
-            }
+        // Already logged in?
+        if (shell.api.isAuthenticated()) {
+            const u = shell.api.getUser();
+            console.log(chalk.green(`✅ Already logged in as ${u.name} (${u.email})`));
+            console.log(chalk.dim('   Run "logout" first to switch accounts.'));
+            return;
+        }
 
-            console.log(chalk.cyan('🔐 Logging in...'));
+        // Collect credentials
+        let email    = args[0];
+        let password = args[1];
+
+        if (!email || !password) {
+            const answers = await inquirer.prompt([
+                !email    && { type: 'input',    name: 'email',    message: 'Email:',    validate: v => v.includes('@') || 'Enter a valid email' },
+                !password && { type: 'password', name: 'password', message: 'Password:', mask: '*', validate: v => v.length >= 1 || 'Password required' },
+            ].filter(Boolean));
+            email    = email    || answers.email;
+            password = password || answers.password;
+        }
 
-            if (!shell.api) { console.log(chalk.red('❌ API not initialized')); return; }
+        console.log(chalk.blue('🔐 Logging in...'));
 
+        try {
             const result = await shell.api.login(email, password);
 
-            await fs.writeJson(path.join(shell.config.configDir, 'session.json'), {
-                user:      result.user,
-                token:     result.token,
-                timestamp: new Date().toISOString()
-            });
-
-            console.log(chalk.green(`✅ Welcome, ${result.user.name || result.user.email}!`));
-
-            // Auto-connect to WebSocket + join personal notification room
-            try {
-                const token  = result.token;
-                const userId = result.user._id ;
-                const name   = result.user.name || result.user.email;
-
-                // Set user in websocket manager
-                shell.ws._token = token;
-                shell.ws.setUser({ userId, name, userType: 'User' }, token);
-
-                // Connect to backend
-                await shell.ws.connect(token);
-
-                // Join personal notification room (for task assignments etc.)
-                shell.ws.joinUserRoom(userId);
-
-                console.log(chalk.green('🔌 Connected to ThinkNCollab server'));
-            } catch (wsErr) {
-                console.log(chalk.yellow(`⚠️  Could not connect to server: ${wsErr.message}`));
+            // result.user is already normalised by api-client.getUser()
+            // shape: { _id, userId, email, name, userType }
+            const user = result.user;
+
+            // ★ Tell the WebSocket manager who the user is + pass the token
+            // This must happen BEFORE any join attempt
+            shell.ws.setUser(user, result.token);
+
+            // Connect WebSocket if not already connected
+            if (!shell.ws.isConnected()) {
+                try {
+                    await shell.ws.connect(result.token);
+                    console.log(chalk.dim('   🔌 Connected to ThinkNCollab server'));
+                } catch (wsErr) {
+                    // Non-fatal — user can still use REST commands
+                    console.log(chalk.yellow(`   ⚠️  WebSocket unavailable: ${wsErr.message}`));
+                }
+            } else {
+                // Already connected — re-announce with new user identity
+                shell.ws._announceUser?.();
             }
 
+            console.log(chalk.green(`✅ Welcome, ${user.name}!`));
+            console.log(chalk.dim(`   Logged in as ${user.email}`));
+
         } catch (err) {
-            if (err.name === 'ExitPromptError' || err.message?.includes('force closed')) {
-                console.log(chalk.yellow('⚠️  Cancelled'));
+            if (err.message.includes('401') || err.message.toLowerCase().includes('invalid') ||
+                err.message.toLowerCase().includes('unauthorized')) {
+                console.log(chalk.red('❌ Invalid email or password'));
+            } else if (err.message.includes('connect') || err.message.includes('ECONNREFUSED')) {
+                console.log(chalk.red(`❌ Cannot reach server — is it running?`));
             } else {
                 console.log(chalk.red(`❌ Login failed: ${err.message}`));
             }

package/src/commands/auth/register.js

@@ -0,0 +1,52 @@
+/**
+ * src/commands/auth/register.js
+ * Register new account — opens browser with pre-auth session
+ */
+
+const chalk = require('chalk');
+const { exec } = require('child_process');
+
+module.exports = {
+    name: 'register',
+    description: 'Create a new ThinkNCollab account',
+    aliases: ['signup', 'reg'],
+    requiresAuth: false,
+
+    async execute(args, shell) {
+        try {
+            console.log(chalk.cyan('🌐 Opening registration in browser...'));
+
+            const baseUrl = shell.api.apiUrl || 'http://localhost:3001';
+
+            // Generate a CLI source token so backend knows it came from terminal
+            const crypto  = require('crypto');
+            const cliRef  = crypto.randomBytes(8).toString('hex');
+
+            const url = `${baseUrl}/register?ref=cli&cliRef=${cliRef}`;
+
+            // Open browser cross-platform
+            const openCmd = process.platform === 'win32'
+                ? `start "" "${url}"`
+                : process.platform === 'darwin'
+                    ? `open "${url}"`
+                    : `xdg-open "${url}"`;
+
+            exec(openCmd, (err) => {
+                if (err) {
+                    console.log(chalk.yellow('⚠️  Could not open browser automatically.'));
+                    console.log(chalk.dim('   Open this URL manually:'));
+                    console.log(chalk.cyan(`   ${url}`));
+                }
+            });
+
+            console.log(chalk.green(`✅ Registration page opened!`));
+            console.log(chalk.dim(`   URL: ${url}`));
+            console.log('');
+            console.log(chalk.dim('   After registering, come back and run:'));
+            console.log(chalk.cyan('   login'));
+
+        } catch (err) {
+            console.log(chalk.red(`❌ Error: ${err.message}`));
+        }
+    }
+};

package/src/commands/index.js

@@ -1,54 +1,77 @@
 /**
- * Command Registry - Loads and manages all commands
+ * src/commands/index.js — Command Registry
  */
-
 const chalk = require('chalk');
 
 class CommandRegistry {
     constructor(shell) {
-        this.shell = shell;
-        this.commands = new Map();
-        this.aliases = new Map();
+        this.shell      = shell;
+        this.commands   = new Map();
+        this.aliases    = new Map();
         this.categories = new Map();
-
         this.loadCommands();
     }
 
     loadCommands() {
-        try {
-            this.register(require('./auth/login'),        'auth');
-            this.register(require('./auth/logout'),       'auth');
-            this.register(require('./auth/whoami'),       'auth');
-            this.register(require('./team/myteam'),       'team');
-            this.register(require('./team/teammates'),    'team');
-            this.register(require('./team/invite'),       'team');
-            this.register(require('./room/join'),         'room');
-            this.register(require('./room/leave'),        'room');
-            this.register(require('./room/rooms'),        'room');
-            this.register(require('./message/say'),       'message');
-            this.register(require('./shell/status'),      'shell');
-        } catch (error) {
-            console.error(chalk.red(`❌ Failed to load command: ${error.message}`));
-            console.error(error.stack);
+const load = (path, category) => {
+    try {
+        const cmd = require(path);
+        if (!cmd || !cmd.name) {
+            console.error(chalk.red(`❌ BAD COMMAND (no name): ${path}`));
+            return;
         }
+        this.register(cmd, category);
+    }
+    catch (e) { console.error(chalk.red(`❌ Failed to load ${path}: ${e.message}`)); }
+};
+
+        // Auth
+        load('./auth/login',    'auth');
+        load('./auth/logout',   'auth');
+        load('./auth/whoami',   'auth');
+        load('./auth/register', 'auth');
+
+        // Team
+        load('./team/myteam',    'team');
+        load('./team/teammates', 'team');
+        load('./team/invite',    'team');
+
+        // Room
+        load('./room/join',   'room');
+        load('./room/leave',  'room');
+        load('./room/rooms',  'room');
+
+        // Message
+        load('./message/say', 'message');
+
+        // Shell
+        load('./shell/status', 'shell');
+        load('./shell/notify', 'shell');
+
+        // Tasks
+        load('./tasks/tasks',       'tasks');
+        load('./tasks/task',        'tasks');
+        // load('./tasks/start',       'tasks');
+        load('./tasks/complete',    'tasks');
+        // load('./tasks/comment',     'tasks');
+        load('./tasks/create-task', 'tasks');
+
+        // Terminal
+        load('./terminal/share', 'terminal');
     }
 
     register(command, category) {
+         if (!command || !command.name) {
+        console.error(chalk.yellow(`⚠️  Skipping invalid command in category: ${category}`));
+        return;
+    }
         this.commands.set(command.name, command);
-
-        if (!this.categories.has(category)) {
-            this.categories.set(category, []);
-        }
+        if (!this.categories.has(category)) this.categories.set(category, []);
         this.categories.get(category).push(command.name);
-
-        if (command.aliases) {
-            command.aliases.forEach(alias => this.aliases.set(alias, command.name));
-        }
+        if (command.aliases) command.aliases.forEach(a => this.aliases.set(a, command.name));
     }
 
-    addAlias(alias, command) {
-        this.aliases.set(alias, command);
-    }
+    addAlias(alias, command) { this.aliases.set(alias, command); }
 
     getCommand(name) {
         if (this.aliases.has(name)) name = this.aliases.get(name);
@@ -65,17 +88,14 @@ class CommandRegistry {
 
         try {
             if (command.requiresAuth && !shell.api?.isAuthenticated()) {
-                console.log(chalk.red('❌ Please login first: login <email> <password>'));
+                console.log(chalk.red('❌ Please login first: login'));
                 return true;
             }
-
-            if (command.requiresRoom && !shell.api?.getCurrentRoom()) {
+            if (command.requiresRoom && !shell.ws?.getCurrentRoom()) {
                 console.log(chalk.red('❌ Please join a room first: join <room-id>'));
                 return true;
             }
-
             await command.execute(cmdArgs, shell);
-
         } catch (error) {
             console.log(chalk.red(`❌ Command error: ${error.message}`));
         }
@@ -86,17 +106,16 @@ class CommandRegistry {
     getHelpText() {
         let help = chalk.cyan('\n📚 Available Commands:\n');
         help += chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n');
-
         for (const [category, commands] of this.categories) {
             help += chalk.yellow(`${category.toUpperCase()}:\n`);
             commands.forEach(cmdName => {
-                const cmd     = this.commands.get(cmdName);
-                const aliases = cmd.aliases ? chalk.dim(` (${cmd.aliases.join(', ')})`) : '';
-                help += `  ${chalk.green(cmdName.padEnd(12))}${aliases} - ${cmd.description}\n`;
-            });
+    const cmd = this.commands.get(cmdName);
+    if (!cmd || !cmdName) return;  // ← ye line add karo
+    const aliases = cmd.aliases ? chalk.dim(` (${cmd.aliases.join(', ')})`) : '';
+    help += `  ${chalk.green(cmdName.padEnd(14))}${aliases} - ${cmd.description || ''}\n`;
+});
             help += '\n';
         }
-
         return help;
     }
 }

package/src/commands/room/join.js

@@ -1,68 +1,142 @@
 /**
  * Join Command
- * 
- * Usage: join <room-id>
- *        join <room-name>
+ *
+ * Usage: join <room-id> [password]
+ *
+ * Flow:
+ *   1. REST call  → shell.api.joinRoom()  — validates membership + fetches room info
+ *   2. WebSocket  → thinknsh:join         — registers socket in the room on the server
+ *   3. Wait for   → thinknsh:joined       — server confirms + sends message history
  */
 
 const chalk = require('chalk');
 
+// How long to wait for thinknsh:joined after emitting thinknsh:join (ms)
+const JOIN_TIMEOUT_MS = 8000;
+
 module.exports = {
-    name: 'join',
-    description: 'Join a collaboration room',
-    aliases: ['enter', 'goto'],
+    name:         'join',
+    description:  'Join a collaboration room',
+    aliases:      ['enter', 'goto'],
     requiresAuth: true,
-    
+
     async execute(args, shell) {
         if (args.length === 0) {
             console.log(chalk.red('❌ Usage: join <room-id> [password]'));
             return;
         }
-        
-        const roomId = args[0];
+
+        const roomId   = args[0];
         const password = args[1];
-        
-        console.log(chalk.cyan(`🔗 Joining room: ${roomId}...`));
-        
-        try {
-            const result = await shell.api.joinRoom(roomId, password);
-            
-            console.log(chalk.green(`✅ Joined ${result.room.name}`));
-            
-            // Show room info
-            console.log(chalk.dim(`  📝 ${result.room.description || 'No description'}`));
-            console.log(chalk.dim(`  👥 ${result.participants.length} participants`));
-            
-            // Show recent messages
-            if (result.recentMessages && result.recentMessages.length > 0) {
-                console.log(chalk.cyan('\n📜 Recent messages:'));
-                result.recentMessages.slice(-3).forEach(msg => {
-                    const time = new Date(msg.timestamp).toLocaleTimeString();
-                    console.log(chalk.dim(`  [${time}] ${msg.username}: ${msg.message}`));
-                });
-            }
-            
-            // Show participants
-            if (result.participants.length > 0) {
-                console.log(chalk.cyan('\n👥 In room:'));
-                const online = result.participants.filter(p => p.online);
-                online.forEach(p => {
-                    const you = p.email === shell.api.getUser().email ? chalk.green(' (you)') : '';
-                    console.log(`  ${chalk.green('●')} ${p.name || p.email}${you}`);
-                });
+
+        // ── Step 1: auto-connect WebSocket if needed ──────────────────────
+        if (!shell.ws.isConnected()) {
+            console.log(chalk.dim('  Connecting...'));
+            try {
+                await shell.ws.connect();
+            } catch (err) {
+                console.log(chalk.red(`❌ WebSocket connect failed: ${err.message}`));
+                return;
             }
-            
-            console.log(chalk.dim('\n💡 Type "say <message>" to chat'));
-            
+        }
+
+        console.log(chalk.cyan(`🔗 Joining room ${chalk.bold(roomId)}...`));
+
+        // ── Step 2: REST call — validates membership, returns room meta ───
+        let result;
+        try {
+            result = await shell.api.joinRoom(roomId, password);
         } catch (error) {
-            if (error.message.includes('password')) {
-                console.log(chalk.red(`❌ Room requires password: join ${roomId} <password>`));
-            } else if (error.message.includes('not found')) {
+            if (error.message?.toLowerCase().includes('password')) {
+                console.log(chalk.red(`❌ Room requires a password: join ${roomId} <password>`));
+            } else if (error.message?.toLowerCase().includes('not found')) {
                 console.log(chalk.red(`❌ Room not found: ${roomId}`));
-                console.log(chalk.dim('💡 Type "rooms" to see available rooms'));
+                console.log(chalk.dim('   Type "rooms" to see available rooms'));
+            } else if (error.message?.toLowerCase().includes('not a member') ||
+                       error.message?.toLowerCase().includes('unauthorized')) {
+                console.log(chalk.red(`❌ You are not a member of this room`));
             } else {
                 console.log(chalk.red(`❌ Failed to join: ${error.message}`));
             }
+            return;
         }
+
+        const room = result.room || result;
+        const user = shell.api.getUser?.() || {};
+
+        // ── Step 3: emit thinknsh:join and wait for thinknsh:joined ──────
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                shell.ws.socket?.off('thinknsh:joined', onJoined);
+                shell.ws.socket?.off('thinknsh:error',  onError);
+                console.log(chalk.red('❌ Join timeout — server did not confirm. Try again.'));
+                resolve();
+            }, JOIN_TIMEOUT_MS);
+
+            function onJoined(data) {
+                clearTimeout(timer);
+                shell.ws.socket?.off('thinknsh:error', onError);
+
+                if (!data.success) {
+                    console.log(chalk.red(`❌ Join rejected: ${data.message || 'unknown error'}`));
+                    resolve();
+                    return;
+                }
+
+                // ── Success output ────────────────────────────────────────
+                console.log(chalk.green(`✅ Joined ${chalk.bold(room.name || roomId)}`));
+
+                if (room.description)
+                    console.log(chalk.dim(`   📝 ${room.description}`));
+
+                const participants = result.participants || [];
+                if (participants.length)
+                    console.log(chalk.dim(`   👥 ${participants.length} participant(s)`));
+
+                // Recent message history from thinknsh:joined payload
+                const history = data.history || [];
+                if (history.length) {
+                    console.log(chalk.cyan('\n📜 Recent messages:'));
+                    history.slice(-5).forEach(msg => {
+                        const time  = new Date(msg.timestamp).toLocaleTimeString();
+                        const isYou = msg.userId === user._id?.toString() || msg.userId === user.id?.toString();
+                        const who   = isYou ? chalk.green('you') : chalk.cyan(msg.name || 'Unknown');
+                        const src   = msg.source === 'shell' ? chalk.dim('[shell]') : '';
+                        console.log(`  ${chalk.dim(`[${time}]`)} ${who}${src}: ${msg.message}`);
+                    });
+                }
+
+                // Online participants
+                const online = participants.filter(p => p.online);
+                if (online.length) {
+                    console.log(chalk.cyan('\n👥 Online:'));
+                    online.forEach(p => {
+                        const isYou = p.email === user.email ? chalk.green(' (you)') : '';
+                        console.log(`  ${chalk.green('●')} ${p.name || p.email}${isYou}`);
+                    });
+                }
+
+                console.log(chalk.dim('\n💡 say <message> to chat  |  leave to exit\n'));
+                resolve();
+            }
+
+            function onError(data) {
+                clearTimeout(timer);
+                shell.ws.socket?.off('thinknsh:joined', onJoined);
+                console.log(chalk.red(`❌ ${data.message || 'Join error'}`));
+                resolve();
+            }
+
+            shell.ws.socket.once('thinknsh:joined', onJoined);
+            shell.ws.socket.once('thinknsh:error',  onError);
+
+            // Emit the WebSocket join event
+            shell.ws.socket.emit('thinknsh:join', {
+                roomId,
+                userId:   user._id?.toString() || user.id?.toString(),
+                name:     user.name || user.username || 'Unknown',
+                userType: user.model || user.role || 'User',
+            });
+        });
     }
 };

package/src/commands/shell/notify.js

@@ -0,0 +1,88 @@
+/**
+ * src/commands/shell/notify.js — Send notifications to room
+ */
+const chalk = require('chalk');
+
+module.exports = {
+    name:        'notify',
+    description: 'Send a notification to the current room',
+    aliases:     ['notif'],
+    requiresAuth: true,
+    requiresRoom: true,
+
+    // Usage:
+    //   notify info  <message>
+    //   notify warn  <message>
+    //   notify error <message>
+    //   notify success <message>
+    //   notify <message>          ← defaults to 'info'
+
+    async execute(args, shell) {
+        if (!args.length) {
+            console.log(chalk.yellow('Usage: notify <level> <message>'));
+            console.log(chalk.dim('  Levels: info | warn | error | success'));
+            console.log(chalk.dim('  Example: notify info deployment done'));
+            return;
+        }
+
+        const levels = ['info', 'warn', 'warning', 'error', 'success'];
+        let level, message;
+
+        if (levels.includes(args[0].toLowerCase())) {
+            level   = args[0].toLowerCase() === 'warning' ? 'warn' : args[0].toLowerCase();
+            message = args.slice(1).join(' ');
+        } else {
+            level   = 'info';
+            message = args.join(' ');
+        }
+
+        if (!message.trim()) {
+            console.log(chalk.red('❌ Message cannot be empty'));
+            return;
+        }
+
+        const levelColors = {
+            info:    chalk.blue,
+            warn:    chalk.yellow,
+            error:   chalk.red,
+            success: chalk.green,
+        };
+        const levelIcons = {
+            info:    'ℹ️ ',
+            warn:    '⚠️ ',
+            error:   '❌',
+            success: '✅',
+        };
+
+        const color = levelColors[level] || chalk.blue;
+        const icon  = levelIcons[level]  || 'ℹ️ ';
+
+        try {
+            await shell.ws.sendNotification(
+                {
+                    type:    level,
+                    title:   `${level.charAt(0).toUpperCase() + level.slice(1)} from terminal`,
+                    message: message,
+                    data:    {
+                        sentBy: shell.api.getUser()?.name || 'unknown',
+                        via:    'thinknsh',
+                    },
+                },
+                'room'
+            );
+
+            // Also push to local notification window
+            shell.pushNotification({
+                type:    'notification',
+                level:   level,
+                title:   `Notify — ${level}`,
+                message: message,
+            });
+
+            console.log(color(`${icon}  Notification sent → [${level}] ${message}`));
+
+        } catch (err) {
+            console.log(chalk.red(`❌ Failed to send notification: ${err.message}`));
+        }
+    }
+};