thinkncollab-shell 0.0.1 → 0.0.2

package/bin/thinknsh.js

@@ -45,9 +45,10 @@ if (args.includes('--version') || args.includes('-v')) {
     process.exit(0);
 }
 
-// Create and start shell
 const shell = new ThinkNCollabShell({
-    serverUrl: process.env.THINKNCOLLAB_SERVER || 'https://api.thinkncollab.com',
+    serverUrl:   process.env.THINKNCOLLAB_SERVER    || 'http://localhost:3001',  // ← /thinknsh hata
+    apiUrl:      process.env.THINKNCOLLAB_API_URL   || 'http://localhost:3001',
+    wsUrl:       process.env.THINKNCOLLAB_WS_URL    || 'http://localhost:3001',
     autoConnect: process.env.THINKNCOLLAB_AUTO_CONNECT === 'true'
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkncollab-shell",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "ThinkNCollab Custom Shell with WebSocket collaboration",
   "main": "src/core/shell.js",
   "bin": {
@@ -23,13 +23,16 @@
   "author": "ThinkNCollab",
   "license": "MIT",
   "dependencies": {
-    "socket.io-client": "^4.7.2",
+    "@inquirer/prompts": "^2.3.1",
+    "blessed": "^0.1.81",
     "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "figlet": "^1.6.0",
     "fs-extra": "^11.1.1",
     "inquirer": "^8.2.6",
-    "os-locale": "^6.0.2",
     "node-machine-id": "^1.1.12",
-    "figlet": "^1.6.0"
+    "os-locale": "^6.0.2",
+    "socket.io-client": "^4.8.3"
   },
   "engines": {
     "node": ">=14.0.0"
@@ -39,4 +42,4 @@
     "src/",
     "README.md"
   ]
-}
+}

package/src/commands/auth/login.js

@@ -0,0 +1,77 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = {
+    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;
+            }
+
+            console.log(chalk.cyan('🔐 Logging in...'));
+
+            if (!shell.api) { console.log(chalk.red('❌ API not initialized')); return; }
+
+            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}`));
+            }
+
+        } catch (err) {
+            if (err.name === 'ExitPromptError' || err.message?.includes('force closed')) {
+                console.log(chalk.yellow('⚠️  Cancelled'));
+            } else {
+                console.log(chalk.red(`❌ Login failed: ${err.message}`));
+            }
+        }
+    }
+};

package/src/commands/auth/logout.js

@@ -0,0 +1,32 @@
+/**
+ * Logout Command
+ * 
+ * Usage: logout
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+
+module.exports = {
+    name: 'logout',
+    description: 'Logout from ThinkNCollab',
+    aliases: ['signout', 'exit'],
+    requiresAuth: true,
+    
+    async execute(args, shell) {
+        shell.printMessage(chalk.cyan('👋 Logging out...'));
+        
+        try {
+            await shell.api.logout();
+            
+            // Remove session file
+            const sessionPath = shell.getSessionPath();
+            await fs.remove(sessionPath);
+            
+            shell.printMessage(chalk.green('✅ Logged out successfully'));
+            
+        } catch (error) {
+            shell.printMessage(chalk.red(`❌ Logout failed: ${error.message}`));
+        }
+    }
+};

package/src/commands/auth/whoami.js

@@ -0,0 +1,47 @@
+/**
+ * Whoami Command
+ * 
+ * Usage: whoami
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name: 'whoami',
+    description: 'Show current user information',
+    aliases: ['user', 'me'],
+    requiresAuth: true,
+    
+    async execute(args, shell) {
+        const user = shell.api.getUser();
+        const room = shell.api.getCurrentRoom();
+        
+        console.log(chalk.cyan('\n👤 User Information:'));
+        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(`  ${chalk.yellow('Email:')}     ${user.email}`);
+        console.log(`  ${chalk.yellow('Name:')}      ${user.name || 'Not set'}`);
+        console.log(`  ${chalk.yellow('User ID:')}   ${user.id || 'N/A'}`);
+        
+        if (user.team) {
+            console.log(`  ${chalk.yellow('Team:')}      ${user.team}`);
+        }
+        
+        if (user.role) {
+            console.log(`  ${chalk.yellow('Role:')}      ${user.role}`);
+        }
+        
+        console.log(`  ${chalk.yellow('Status:')}    ${shell.api.isConnected() ? chalk.green('Online') : chalk.gray('Offline')}`);
+        
+        if (room) {
+            console.log(`  ${chalk.yellow('Room:')}      ${chalk.cyan(room.name)} (${room.id})`);
+        }
+        
+        // Show last login if available
+        if (user.lastLogin) {
+            const lastLogin = new Date(user.lastLogin).toLocaleString();
+            console.log(`  ${chalk.yellow('Last Login:')} ${lastLogin}`);
+        }
+        
+        console.log();
+    }
+};

package/src/commands/index.js

@@ -0,0 +1,104 @@
+/**
+ * Command Registry - Loads and manages all commands
+ */
+
+const chalk = require('chalk');
+
+class CommandRegistry {
+    constructor(shell) {
+        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);
+        }
+    }
+
+    register(command, category) {
+        this.commands.set(command.name, command);
+
+        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));
+        }
+    }
+
+    addAlias(alias, command) {
+        this.aliases.set(alias, command);
+    }
+
+    getCommand(name) {
+        if (this.aliases.has(name)) name = this.aliases.get(name);
+        return this.commands.get(name);
+    }
+
+    async execute(input, shell) {
+        const args    = shell.parseCommand(input);
+        const cmdName = args[0].toLowerCase();
+        const cmdArgs = args.slice(1);
+
+        const command = this.getCommand(cmdName);
+        if (!command) return false;
+
+        try {
+            if (command.requiresAuth && !shell.api?.isAuthenticated()) {
+                console.log(chalk.red('❌ Please login first: login <email> <password>'));
+                return true;
+            }
+
+            if (command.requiresRoom && !shell.api?.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}`));
+        }
+
+        return true;
+    }
+
+    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`;
+            });
+            help += '\n';
+        }
+
+        return help;
+    }
+}
+
+module.exports = CommandRegistry;

package/src/commands/message/say.js

@@ -0,0 +1,43 @@
+/**
+ * Say Command
+ * 
+ * Usage: say <message>
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name: 'say',
+    description: 'Send a message to the current room',
+    aliases: ['msg', 'm', 'send'],
+    requiresAuth: true,
+    requiresRoom: true,
+    
+    async execute(args, shell) {
+        const message = args.join(' ');
+        
+        if (!message) {
+            console.log(chalk.red('❌ Usage: say <message>'));
+            return;
+        }
+        
+        try {
+            await shell.api.sendMessage(message);
+            
+            // Clear typing indicator
+            if (shell.isTyping) {
+                shell.api.sendTyping(false);
+                shell.isTyping = false;
+                clearTimeout(shell.typingTimeout);
+            }
+            
+            // Echo locally (server will also broadcast)
+            const user = shell.api.getUser();
+            const time = new Date().toLocaleTimeString();
+            console.log(chalk.dim(`[${time}] `) + chalk.green(`You: ${message}`));
+            
+        } catch (error) {
+            console.log(chalk.red(`❌ Failed to send: ${error.message}`));
+        }
+    }
+};

package/src/commands/room/join.js

@@ -0,0 +1,68 @@
+/**
+ * Join Command
+ * 
+ * Usage: join <room-id>
+ *        join <room-name>
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    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 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}`);
+                });
+            }
+            
+            console.log(chalk.dim('\n💡 Type "say <message>" to chat'));
+            
+        } catch (error) {
+            if (error.message.includes('password')) {
+                console.log(chalk.red(`❌ Room requires password: join ${roomId} <password>`));
+            } else if (error.message.includes('not found')) {
+                console.log(chalk.red(`❌ Room not found: ${roomId}`));
+                console.log(chalk.dim('💡 Type "rooms" to see available rooms'));
+            } else {
+                console.log(chalk.red(`❌ Failed to join: ${error.message}`));
+            }
+        }
+    }
+};

package/src/commands/room/leave.js

@@ -0,0 +1,33 @@
+/**
+ * Leave Command
+ * 
+ * Usage: leave
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name: 'leave',
+    description: 'Leave current room',
+    aliases: ['exit-room', 'part'],
+    requiresAuth: true,
+    requiresRoom: true,
+    
+    async execute(args, shell) {
+        const room = shell.api.getCurrentRoom();
+        
+        if (!room) {
+            console.log(chalk.yellow('⚠️  Not in any room'));
+            return;
+        }
+        
+        console.log(chalk.cyan(`👋 Leaving room: ${room.name}...`));
+        
+        try {
+            await shell.api.leaveRoom();
+            console.log(chalk.green(`✅ Left room: ${room.name}`));
+        } catch (error) {
+            console.log(chalk.red(`❌ Failed to leave: ${error.message}`));
+        }
+    }
+};

package/src/commands/room/rooms.js

@@ -0,0 +1,66 @@
+/**
+ * Rooms Command
+ * 
+ * Usage: rooms
+ *        rooms --all
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name: 'rooms',
+    description: 'List available rooms',
+    aliases: ['channels', 'ls'],
+    requiresAuth: true,
+    
+    async execute(args, shell) {
+        const showAll = args.includes('--all') || args.includes('-a');
+        
+        console.log(chalk.cyan('\n📋 Available Rooms:'));
+        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        
+        try {
+            const rooms = await shell.api.getRooms();
+            const currentRoom = shell.api.getCurrentRoom();
+            
+            if (rooms.length === 0) {
+                console.log(chalk.yellow('  No rooms available'));
+                console.log(chalk.dim('💡 Create a room with: join <new-room-name>'));
+                return;
+            }
+            
+            // Separate my rooms and other rooms
+            const myRooms = rooms.filter(r => r.isMember);
+            const otherRooms = rooms.filter(r => !r.isMember);
+            
+            if (myRooms.length > 0) {
+                console.log(chalk.yellow('\n  YOUR ROOMS:'));
+                myRooms.forEach(room => {
+                    const current = currentRoom && currentRoom.id === room.id ? chalk.green(' (current)') : '';
+                    const active = room.active ? chalk.green('●') : chalk.gray('○');
+                    console.log(`  ${active} ${chalk.white(room.name)}${current}`);
+                    console.log(chalk.dim(`     ${room.participants} online · ${room.description || ''}`));
+                });
+            }
+            
+            if (otherRooms.length > 0 && showAll) {
+                console.log(chalk.yellow('\n  PUBLIC ROOMS:'));
+                otherRooms.slice(0, 10).forEach(room => {
+                    console.log(`  ○ ${chalk.white(room.name)}`);
+                    console.log(chalk.dim(`     ${room.participants} online · ${room.description || ''}`));
+                });
+                
+                if (otherRooms.length > 10) {
+                    console.log(chalk.dim(`  ... and ${otherRooms.length - 10} more (use --all to see all)`));
+                }
+            } else if (otherRooms.length > 0) {
+                console.log(chalk.dim(`\n  📌 ${otherRooms.length} other rooms available (use --all to see)`));
+            }
+            
+            console.log(chalk.dim('\n💡 Type "join <room-name>" to join a room'));
+            
+        } catch (error) {
+            console.log(chalk.red(`❌ Failed to fetch rooms: ${error.message}`));
+        }
+    }
+};

package/src/commands/shell/status.js

@@ -0,0 +1,73 @@
+/**
+ * Status Command
+ * 
+ * Usage: status
+ */
+
+const chalk = require('chalk');
+const os = require('os');
+
+module.exports = {
+    name: 'status',
+    description: 'Show shell and connection status',
+    aliases: ['stats', 'info'],
+    requiresAuth: false,
+    
+    async execute(args, shell) {
+        const user = shell.api.getUser();
+        const room = shell.api.getCurrentRoom();
+        const connected = shell.api.isConnected();
+        
+        console.log(chalk.cyan('\n📊 ThinkNCollab Shell Status'));
+        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        
+        // Connection status
+        console.log(`  ${chalk.yellow('Connection:')}    ${connected ? chalk.green('● Online') : chalk.red('○ Offline')}`);
+        
+        if (connected) {
+            console.log(`  ${chalk.yellow('Server:')}        ${shell.api.config.wsUrl}`);
+            console.log(`  ${chalk.yellow('Socket ID:')}      ${shell.api.getSocketId() || 'N/A'}`);
+        }
+        
+        // Authentication
+        console.log(`  ${chalk.yellow('Auth:')}           ${user ? chalk.green(`✓ ${user.email}`) : chalk.red('✗ Not logged in')}`);
+        
+        if (user) {
+            console.log(`  ${chalk.yellow('User:')}           ${user.name || user.email}`);
+            if (user.team) {
+                console.log(`  ${chalk.yellow('Team:')}           ${user.team}`);
+            }
+        }
+        
+        // Room
+        if (room) {
+            console.log(`  ${chalk.yellow('Current Room:')}    ${chalk.cyan(room.name)} (${room.id})`);
+            console.log(`  ${chalk.yellow('Participants:')}     ${room.participants?.length || 0}`);
+        } else {
+            console.log(`  ${chalk.yellow('Current Room:')}    ${chalk.gray('None')}`);
+        }
+        
+        // Shell info
+        console.log(`\n  ${chalk.yellow('Shell Version:')}  ${require('../../../package.json').version}`);
+        console.log(`  ${chalk.yellow('Node Version:')}    ${process.version}`);
+        console.log(`  ${chalk.yellow('Platform:')}        ${os.platform()} ${os.arch()}`);
+        console.log(`  ${chalk.yellow('Uptime:')}          ${Math.floor(process.uptime() / 60)}m`);
+        console.log(`  ${chalk.yellow('Memory:')}          ${Math.round(process.memoryUsage().rss / 1024 / 1024)} MB`);
+        console.log(`  ${chalk.yellow('History:')}         ${shell.history.length} commands`);
+        
+        // Suggestions
+        console.log(chalk.dim('\n💡 Tips:'));
+        if (!user) {
+            console.log(chalk.dim('   • Login with: login <email> <password>'));
+        } else if (!room) {
+            console.log(chalk.dim('   • Join a room with: join <room-id>'));
+            console.log(chalk.dim('   • See available rooms: rooms'));
+        } else {
+            console.log(chalk.dim('   • Send messages with: say <message>'));
+            console.log(chalk.dim('   • See teammates: teammates'));
+            console.log(chalk.dim('   • Leave room: leave'));
+        }
+        
+        console.log();
+    }
+};

package/src/commands/team/invite.js

@@ -0,0 +1,46 @@
+/**
+ * Invite Command
+ * 
+ * Usage: invite <email>
+ *        invite <email> --role <role>
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name: 'invite',
+    description: 'Invite someone to your team',
+    aliases: ['inv'],
+    requiresAuth: true,
+    
+    async execute(args, shell) {
+        if (args.length === 0) {
+            console.log(chalk.red('❌ Usage: invite <email> [--role <role>]'));
+            console.log(chalk.dim('  Roles: admin, member, viewer'));
+            return;
+        }
+        
+        const email = args[0];
+        const roleIndex = args.indexOf('--role');
+        const role = roleIndex !== -1 && args[roleIndex + 1] ? args[roleIndex + 1] : 'member';
+        
+        console.log(chalk.cyan(`📧 Inviting ${email} as ${role}...`));
+        
+        try {
+            const result = await shell.api.inviteTeammate(email, role);
+            
+            console.log(chalk.green(`✅ Invitation sent to ${email}`));
+            
+            if (result.inviteLink) {
+                console.log(chalk.dim(`📎 Invite link: ${result.inviteLink}`));
+            }
+            
+        } catch (error) {
+            if (error.message.includes('already')) {
+                console.log(chalk.yellow(`⚠️  ${email} is already a team member`));
+            } else {
+                console.log(chalk.red(`❌ Invitation failed: ${error.message}`));
+            }
+        }
+    }
+};