thinkncollab-shell 0.0.4 → 0.0.6

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}`));
+        }
+    }
+};

package/src/commands/tasks/complete.js

@@ -0,0 +1,47 @@
+/**
+ * src/commands/tasks/complete.js — Mark your task assignment as completed
+ */
+const chalk = require('chalk');
+
+module.exports = {
+    name:         'complete',
+    description:  'Mark a task as completed',
+    aliases:      ['done', 'finish'],
+    requiresAuth: true,
+
+    async execute(args, shell) {
+        if (!args[0]) {
+            console.log(chalk.red('Usage: complete <task-id>'));
+            return;
+        }
+
+        const taskId = args[0];
+
+        try {
+            const result = await shell.api._request('POST', `/thinknsh/${taskId}/cli/complete`);
+
+            console.log(chalk.green(`✅ Task completed: "${result.task?.title || taskId}"`));
+
+            if (result.allCompleted)
+                console.log(chalk.green('  🎉 All assignees have completed this task!'));
+
+            // Push to notification window
+            shell.pushNotification({
+                type:    'notification',
+                level:   'success',
+                title:   'Task Completed',
+                message: result.task?.title || taskId,
+            });
+
+        } catch (err) {
+            if (err.message?.includes('403'))
+                console.log(chalk.red('❌ You are not assigned to this task'));
+            else if (err.message?.includes('404'))
+                console.log(chalk.red('❌ Task not found'));
+            else if (err.message?.includes('already'))
+                console.log(chalk.yellow('⚠️  Task already completed'));
+            else
+                console.log(chalk.red(`❌ ${err.message}`));
+        }
+    }
+};

package/src/commands/tasks/create-task.js

@@ -0,0 +1,101 @@
+/**
+ * src/commands/tasks/create-task.js — Create a new task interactively
+ */
+const chalk = require('chalk');
+
+module.exports = {
+    name:         'create-task',
+    description:  'Create a new task in current room',
+    aliases:      ['newtask', 'addtask'],
+    requiresAuth: true,
+    requiresRoom: true,
+
+    async execute(args, shell) {
+        const { input, select, confirm } = require('@inquirer/prompts');
+        const roomId = shell.ws.getCurrentRoom();
+
+        try {
+            // Fetch columns of current room's board
+            const { columns } = await shell.api._request('GET', `/rooms/${roomId}/cli/columns`);
+            if (!columns?.length) {
+                console.log(chalk.red('❌ No columns found in this room\'s board'));
+                return;
+            }
+
+            console.log(chalk.cyan('\n  // create-task\n'));
+
+            const title = await input({
+                message: 'Task title:',
+                validate: v => v.trim().length >= 3 || 'Min 3 characters'
+            });
+
+            const description = await input({ message: 'Description (optional):' });
+
+            const columnId = await select({
+                message: 'Column:',
+                choices: columns.map(c => ({ name: c.title, value: c._id }))
+            });
+
+            const priority = await select({
+                message: 'Priority:',
+                choices: [
+                    { name: 'low',    value: 'low' },
+                    { name: 'medium', value: 'medium' },
+                    { name: 'high',   value: 'high' },
+                ],
+                default: 'medium'
+            });
+
+            const categories = [
+                'Bugs', 'Feature Requests', 'Improvements / Enhancements',
+                'Production Critical Issues', 'Security Issues', 'Performance Issues',
+                'UI/UX Issues', 'Testing & QA', 'DevOps & Infrastructure',
+                'Refactoring & Code Quality', 'Documentation', 'Other'
+            ];
+            const category = await select({
+                message: 'Category:',
+                choices: categories.map(c => ({ name: c, value: c }))
+            });
+
+            const dueDateStr = await input({
+                message: 'Due date (YYYY-MM-DD, optional):',
+                validate: v => {
+                    if (!v) return true;
+                    return !isNaN(Date.parse(v)) || 'Invalid date format';
+                }
+            });
+
+            const confirmed = await confirm({ message: 'Create task?', default: true });
+            if (!confirmed) { console.log(chalk.dim('  Cancelled.')); return; }
+
+            const payload = {
+                title:       title.trim(),
+                description: description.trim() || undefined,
+                columnId,
+                priority,
+                category:    category === 'Other' ? undefined : category,
+                dueDate:     dueDateStr ? new Date(dueDateStr).toISOString() : undefined,
+                source:      'cli',
+            };
+
+            const result = await shell.api._request('POST', `/${roomId}/cli/tasks`, payload);
+
+            console.log(chalk.green(`\n✅ Task created: "${result.task.title}"`));
+            console.log(chalk.dim(`   ID: ${result.task._id}`));
+            console.log(chalk.dim(`   Column: ${result.task.columnId?.title || columnId}\n`));
+
+            shell.pushNotification({
+                type:    'notification',
+                level:   'success',
+                title:   'Task Created',
+                message: result.task.title,
+            });
+
+        } catch (err) {
+            if (err.message?.includes('403'))
+                console.log(chalk.red('❌ You are not a member of this room'));
+            else
+                console.log(chalk.red(`❌ ${err.message}`));
+        }
+    }
+};

package/src/commands/tasks/task.js

@@ -0,0 +1,75 @@
+/**
+ * src/commands/tasks/task.js — View single task detail
+ */
+const chalk = require('chalk');
+
+module.exports = {
+    name:         'task',
+    description:  'View task details by ID',
+    aliases:      ['t'],
+    requiresAuth: true,
+
+    async execute(args, shell) {
+        if (!args[0]) {
+            console.log(chalk.red('Usage: task <task-id>'));
+            return;
+        }
+
+        const taskId = args[0];
+
+        try {
+            const task = await shell.api._request('GET', `/thinknsh/${taskId}/cli`);
+
+            const stColors = {
+                pending:   chalk.yellow,
+                inprogress: chalk.blue,
+                review:    chalk.magenta,
+                completed: chalk.green,
+                reopened:  chalk.cyan,
+            };
+            const prColors = { high: chalk.red, medium: chalk.yellow, low: chalk.green };
+            const stColor  = stColors[task.status]  || chalk.white;
+            const prColor  = prColors[task.priority] || chalk.white;
+
+            console.log(chalk.cyan('\n  ─── Task ────────────────────────────────────────'));
+            console.log(`  ${chalk.dim('id')}       ${chalk.dim(task._id)}`);
+            console.log(`  ${chalk.dim('title')}    ${chalk.bold(task.title)}`);
+            console.log(`  ${chalk.dim('status')}   ${stColor(task.status)}`);
+            console.log(`  ${chalk.dim('priority')} ${prColor(task.priority)}`);
+            if (task.category)
+                console.log(`  ${chalk.dim('category')} ${chalk.dim(task.category)}`);
+            if (task.dueDate)
+                console.log(`  ${chalk.dim('due')}      ${chalk.yellow(new Date(task.dueDate).toLocaleDateString())}`);
+            if (task.description) {
+                console.log(chalk.dim('\n  description:'));
+                task.description.split('\n').forEach(l => console.log(`    ${chalk.white(l)}`));
+            }
+
+            if (task.assignedTo?.length) {
+                console.log(chalk.dim('\n  assignees:'));
+                task.assignedTo.forEach(a => {
+                    const name   = a.userId?.name || 'Unknown';
+                    const stBadge = a.status === 'completed' ? chalk.green('✓') :
+                                    a.status === 'accepted'  ? chalk.blue('●') :
+                                    a.status === 'rejected'  ? chalk.red('✗') : chalk.dim('○');
+                    console.log(`    ${stBadge} ${name} ${chalk.dim(`[${a.status}]`)}`);
+                });
+            }
+
+            if (task.columnId?.name || task.columnName)
+                console.log(`\n  ${chalk.dim('column')}   ${task.columnId?.name || task.columnName}`);
+            if (task.boardName)
+                console.log(`  ${chalk.dim('board')}    ${task.boardName}`);
+
+            console.log(chalk.cyan('  ─────────────────────────────────────────────────\n'));
+
+        } catch (err) {
+            if (err.message?.includes('403'))
+                console.log(chalk.red('❌ Access denied — you are not a member of this room'));
+            else if (err.message?.includes('404'))
+                console.log(chalk.red('❌ Task not found'));
+            else
+                console.log(chalk.red(`❌ ${err.message}`));
+        }
+    }
+};