thinkncollab-shell 0.0.5 → 0.0.7

package/src/core/shell.js

@@ -1,6 +1,5 @@
 /**
- * ThinkNCollab Shell Core
- * Inquirer REPL + TCP IPC for notification window
+ * src/core/shell.js — ThinkNCollab Shell Core
  */
 
 const path   = require('path');
@@ -9,12 +8,12 @@ const os     = require('os');
 const chalk  = require('chalk');
 const net    = require('net');
 const { spawn } = require('child_process');
-const WebSocketManager = require('./websocket');
 const EventEmitter     = require('events');
+const WebSocketManager = require('./websocket');
 const CommandRegistry  = require('../commands');
 const ThinkNCollabAPI  = require('./api-client');
+const { loadProjectConfig, hasProjectConfig } = require('./project-config');
 
-// Find an available port starting from 7379
 function getAvailablePort(startPort) {
     return new Promise((resolve) => {
         const server = net.createServer();
@@ -36,7 +35,7 @@ class ThinkNCollabShell extends EventEmitter {
             configDir:   path.join(os.homedir(), '.thinkncollab'),
             maxHistory:  1000,
             websocket: {
-                serverUrl:   options.serverUrl   || 'https://thinkncollab.com/thinknsh',
+                serverUrl:   options.serverUrl   || 'http://localhost:3001',
                 autoConnect: options.autoConnect || false
             },
             ...options
@@ -50,20 +49,24 @@ class ThinkNCollabShell extends EventEmitter {
         this.history    = [];
         this.running    = false;
 
-        // TCP notification clients
+        // TCP notification IPC
         this.notifyClients = new Set();
         this.tcpServer     = null;
 
         this.api = new ThinkNCollabAPI({
-            apiUrl: options.apiUrl || 'https://thinkncollab.com',
-            wsUrl:  options.wsUrl  || 'https://thinkncollab.com'
+            apiUrl: options.apiUrl || 'http://localhost:3001',
+            wsUrl:  options.wsUrl  || 'http://localhost:3001'
         });
 
         this.commands  = new Map();
         this.aliases   = new Map();
         this.variables = new Map();
-        this.isTyping  = false;
-        this.typingTimeout = null;
+
+        // ★ Restore persisted session on startup
+        // Handles both .tncproject boot AND manual login from a previous session
+        if (this.api.isAuthenticated()) {
+            this.ws.setUser(this.api.getUser(), this.api.getToken());
+        }
 
         this.loadHistory();
         this.registerBuiltinCommands();
@@ -75,18 +78,13 @@ class ThinkNCollabShell extends EventEmitter {
 
     async startTCPServer() {
         this.notifyPort = await getAvailablePort(7379);
-
         return new Promise((resolve) => {
             this.tcpServer = net.createServer((socket) => {
                 this.notifyClients.add(socket);
                 socket.on('close', () => this.notifyClients.delete(socket));
                 socket.on('error', () => this.notifyClients.delete(socket));
             });
-
-            this.tcpServer.listen(this.notifyPort, '127.0.0.1', () => {
-                resolve();
-            });
-
+            this.tcpServer.listen(this.notifyPort, '127.0.0.1', () => resolve());
             this.tcpServer.on('error', (err) => {
                 console.log(chalk.yellow(`⚠️  Notification server: ${err.message}`));
                 resolve();
@@ -94,7 +92,6 @@ class ThinkNCollabShell extends EventEmitter {
         });
     }
 
-    // Send notification event to all connected notification windows
     pushNotification(data) {
         if (this.notifyClients.size === 0) return;
         const line = JSON.stringify(data) + '\n';
@@ -103,10 +100,9 @@ class ThinkNCollabShell extends EventEmitter {
         }
     }
 
-    // ─── Spawn notification window (cross-platform) ───────────────────────────
+    // ─── Spawn notification window ────────────────────────────────────────────
 
     spawnNotificationWindow() {
-        // Path to notification-window.js (same dir as this file)
         const notifyScript = path.join(__dirname, 'notification-window.js');
         const env = { ...process.env, THINKNSH_NOTIFY_PORT: String(this.notifyPort) };
 
@@ -114,43 +110,24 @@ class ThinkNCollabShell extends EventEmitter {
             if (process.platform === 'win32') {
                 const isVSCode = process.env.TERM_PROGRAM === 'vscode';
                 if (isVSCode) {
-                    console.log(chalk.yellow('\n  VS Code detected — cannot auto-open new window.'));
-                    console.log(chalk.dim('  Open a new terminal tab and run:'));
+                    console.log(chalk.yellow('\n  VS Code detected — open a new terminal tab and run:'));
                     console.log(chalk.cyan(`  $env:THINKNSH_NOTIFY_PORT=${this.notifyPort}; node "${notifyScript}"\n`));
                 } else {
-                    // Use array args so cmd handles spaces in path correctly
                     const nodeExe = process.execPath;
-                    spawn('cmd.exe', [
-                        '/c', 'start', 'cmd.exe', '/k',
-                        `"${nodeExe}" "${notifyScript}"`
-                    ], { detached: true, stdio: 'ignore', env, shell: false }).unref();
+                    spawn('cmd.exe', ['/c', 'start', 'cmd.exe', '/k', `"${nodeExe}" "${notifyScript}"`],
+                        { detached: true, stdio: 'ignore', env, shell: false }).unref();
                 }
-
             } else if (process.platform === 'darwin') {
-                // macOS — Terminal.app
-                const script = `tell application "Terminal" to do script "THINKNSH_NOTIFY_PORT=${NOTIFY_PORT} node '${notifyScript}'"`;
+                const script = `tell application "Terminal" to do script "THINKNSH_NOTIFY_PORT=${this.notifyPort} node '${notifyScript}'"`;
                 spawn('osascript', ['-e', script], { detached: true, stdio: 'ignore' }).unref();
-
             } else {
-                // Linux — try common terminal emulators in order
                 const terminals = [
                     ['gnome-terminal', ['--', 'node', notifyScript]],
                     ['xterm',          ['-e', `node "${notifyScript}"`]],
                     ['konsole',        ['--noclose', '-e', 'node', notifyScript]],
-                    ['xfce4-terminal', ['-e', `node "${notifyScript}"`]],
-                    ['x-terminal-emulator', ['-e', `node "${notifyScript}"`]],
                 ];
-                let spawned = false;
-                for (const [cmd, cmdArgs] of terminals) {
-                    try {
-                        spawn(cmd, cmdArgs, { detached: true, stdio: 'ignore', env }).unref();
-                        spawned = true;
-                        break;
-                    } catch {}
-                }
-                if (!spawned) {
-                    console.log(chalk.yellow('⚠️  Could not auto-open notification window.'));
-                    console.log(chalk.dim(`   Run manually: node ${notifyScript}`));
+                for (const [cmd, args] of terminals) {
+                    try { spawn(cmd, args, { detached: true, stdio: 'ignore', env }).unref(); break; } catch {}
                 }
             }
         } catch (err) {
@@ -159,109 +136,218 @@ class ThinkNCollabShell extends EventEmitter {
         }
     }
 
-    // ─── WebSocket → push to notification window ──────────────────────────────
-
-    setupWebSocketHandlers() {
-        this.ws.on('connected',    (d) => this.pushNotification({ type: 'connected', socketId: d.socketId }));
-        this.ws.on('disconnected', (d) => this.pushNotification({ type: 'disconnected', reason: d.reason }));
-        this.ws.on('reconnected',  (d) => this.pushNotification({ type: 'connected', socketId: 'reconnected' }));
-        this.ws.on('message',      (d) => this.pushNotification({ type: 'message', from: d.username, text: d.message }));
-        this.ws.on('userJoined',   (d) => this.pushNotification({ type: 'userJoined', username: d.username }));
-        this.ws.on('userLeft',     (d) => this.pushNotification({ type: 'userLeft',   username: d.username }));
-        this.ws.on('userTyping',   (d) => this.pushNotification({ type: d.isTyping ? 'typing' : 'stoppedTyping', username: d.username }));
-        this.ws.on('notification', (d) => this.pushNotification({ type: 'notification', level: d.type, title: d.title, message: d.message }));
-        this.ws.on('error',        (e) => this.pushNotification({ type: 'notification', level: 'error', title: 'WebSocket Error', message: e.message }));
-    }
+    // ─── WebSocket → Shell + TCP bridge ──────────────────────────────────────
+
+setupWebSocketHandlers() {
+    this.ws.on('connected', (d) => {
+        this.api.logEvent('connected', null, { socketId: d?.socketId });
+        this.api.startHeartbeat();
+        this.pushNotification({ type: 'connected', socketId: d?.socketId });
+    });
+
+    this.ws.on('disconnected', (d) => {
+        this.api.logEvent('disconnected', null, { reason: d?.reason });
+        this.api.stopHeartbeat();
+        this.pushNotification({ type: 'disconnected', reason: d?.reason });
+    });
+
+    this.ws.on('reconnected', () => {
+        this.api.logEvent('reconnected');
+        this.api.startHeartbeat();
+        this.pushNotification({ type: 'connected', socketId: 'reconnected' });
+    });
+
+    this.ws.on('message', (d) => {
+        const myId = this.api.getUser()?._id;
+        if (myId && d.userId === myId) return;
+        this.pushNotification({ type: 'message', from: d.username, text: d.message });
+    });
+
+    this.ws.on('messageHistory', (messages) => {
+        if (!messages?.length) return;
+        console.log(chalk.dim('\n  ─── Room History ───────────────────────────────'));
+        messages.forEach(msg => {
+            const from    = msg.name || msg.username || msg.sender?.name || 'Unknown';
+            const text    = msg.message || msg.content || msg.text || '';
+            const ts      = msg.timestamp || msg.createdAt;
+            const timeStr = ts ? chalk.dim(`[${new Date(ts).toLocaleTimeString()}]`) : '';
+            console.log(`  ${timeStr} ${chalk.cyan(from + ':')} ${chalk.white(text)}`);
+        });
+        console.log(chalk.dim('  ────────────────────────────────────────────────\n'));
+    });
+
+    this.ws.on('userJoined', (d) => this.pushNotification({ type: 'userJoined', username: d.username }));
+    this.ws.on('userLeft',   (d) => this.pushNotification({ type: 'userLeft',   username: d.username }));
+
+    // room join/leave events
+    this.ws.on('joined', (roomId) => this.api.logEvent('room_join',  roomId));
+    this.ws.on('left',   (roomId) => this.api.logEvent('room_leave', roomId));
+
+    this.ws.on('notification', (d) => {
+        this.pushNotification({
+            type:       'notification',
+            level:      d.type,
+            title:      d.title,
+            message:    d.message,
+            taskTitle:  d.taskTitle,
+            assignedBy: d.assignedBy,
+        });
+    });
+
+    this.ws.on('error', (e) => {
+        console.log(chalk.red(`⚠️  WebSocket error: ${e.message}`));
+        this.pushNotification({ type: 'notification', level: 'error', title: 'WebSocket Error', message: e.message });
+    });
+}
 
     // ─── Start ────────────────────────────────────────────────────────────────
 
     async start() {
         this.showWelcome();
 
-        // 1. Start TCP server for notification IPC
         await this.startTCPServer();
         console.log(chalk.dim(`  Notification server ready on port ${this.notifyPort}`));
 
-        // 2. Spawn notification window
         this.spawnNotificationWindow();
         console.log(chalk.dim('  Notification window opening...\n'));
 
         this.running = true;
+        process.on('SIGINT', () => console.log(chalk.yellow('\nUse "exit" to quit')));
 
-        process.on('SIGINT', () => {
-            console.log(chalk.yellow('\nUse "exit" to quit'));
-        });
+        // Try .tncproject auto-boot first
+        const booted = await this._bootFromProjectConfig();
 
-        if (this.config.websocket.autoConnect) {
-            await this.ws.connect();
+        // If no .tncproject but autoConnect is set, connect WS anyway
+        if (!booted && this.config.websocket.autoConnect) {
+            await this.ws.connect().catch(() => {});
         }
 
         const { input } = require('@inquirer/prompts');
 
         while (this.running) {
             try {
-                const line = await input({
-                    message:  this.getPromptText(),
-                    required: false,
-                }).catch(() => null);
-
-                if (line === null) {
-                    console.log(chalk.yellow('Use "exit" to quit'));
-                    continue;
-                }
-
+                const line = await input({ message: this.getPromptText(), required: false }).catch(() => null);
+                if (line === null) { console.log(chalk.yellow('Use "exit" to quit')); continue; }
                 const trimmed = line.trim();
                 if (!trimmed) continue;
-
                 this.history.push(trimmed);
                 this.saveHistory();
                 await this.execute(trimmed);
-
             } catch (err) {
-                if (err.name === 'ExitPromptError' || err.message?.includes('force closed')) {
+                if (err.name === 'ExitPromptError' || err.message?.includes('force closed'))
                     console.log(chalk.yellow('Use "exit" to quit'));
-                } else {
+                else
                     console.log(chalk.red(`Shell error: ${err.message}`));
-                }
             }
         }
     }
 
-    restoreReadline() {}
+    // ─── Boot from .tncproject ────────────────────────────────────────────────
 
-    // ─── Execute ──────────────────────────────────────────────────────────────
+    async _bootFromProjectConfig() {
+        if (!hasProjectConfig()) return false;
 
-    async execute(input) {
-        if (!input.trim()) return;
+        let cfg;
+        try {
+            cfg = loadProjectConfig();
+        } catch (err) {
+            console.log(chalk.yellow(`⚠️  tncproject: ${err.message}\n`));
+            return false;
+        }
 
-        const args    = this.parseCommand(input);
-        const cmdName = args[0].toLowerCase();
-        const cmdArgs = args.slice(1);
+        console.log(chalk.dim(`  📄 tncproject found`));
+        console.log(chalk.dim(`     Room : ${cfg.roomId}`));
+        console.log(chalk.dim(`     File : ${cfg.filePath}\n`));
 
-        if (this.commands.has(cmdName)) {
-            const cmd = this.commands.get(cmdName);
-            try {
-                const result = await cmd.handler(cmdArgs, this);
-                if (result !== undefined) console.log(result);
-            } catch (err) {
-                console.log(chalk.red(`Error: ${err.message}`));
-            }
-            return;
+        // Send raw encrypted file to server — server decrypts, returns shellToken
+        let result;
+        try {
+            result = await this.api._request('POST', '/config/verify-config', {
+                fileBase64: cfg.fileBase64,
+                roomId:     cfg.roomId,
+            });
+        } catch (err) {
+            console.log(chalk.red(`❌ tncproject auth failed: ${err.message}`));
+            console.log(chalk.dim('   Falling back to manual login.\n'));
+            return false;
         }
 
-        if (this.commandRegistry) {
-            const handled = await this.commandRegistry.execute(input, this);
-            if (handled) return;
+        // Save session exactly like manual login
+        this.api._saveSession({
+            token: result.shellToken,
+            user: {
+                _id:      result._id.toString(),
+                userId:   result._id.toString(),
+                email:    result.email,
+                name:     result.name,
+                userType: 'User',
+            },
+            timestamp: new Date().toISOString(),
+        });
+
+        this.ws.setUser(this.api.getUser(), result.shellToken);
+
+        // Connect WebSocket
+        try {
+            await this.ws.connect(result.shellToken);
+        } catch (err) {
+            console.log(chalk.yellow(`⚠️  WebSocket: ${err.message}`));
+            console.log(chalk.green(`✅ ${result.name} logged in (offline mode)\n`));
+            return true;
         }
 
-        await this.executeSystemCommand(input);
+        // Auto-join the project room
+        try {
+            await this.ws.joinRoom(result.roomId.toString());
+            console.log(chalk.green(`✅ ${result.name} → room "${result.roomName || result.roomId}"\n`));
+        } catch (err) {
+            console.log(chalk.yellow(`⚠️  Could not auto-join room: ${err.message}`));
+            console.log(chalk.dim('   Use "join <room-id>" manually.\n'));
+        }
+
+        return true;
     }
 
+    // ─── Execute ──────────────────────────────────────────────────────────────
+// shell.js — execute() mein ye change karo
+async execute(input) {
+    if (!input.trim()) return;
+
+    const args    = this.parseCommand(input);
+    const cmdName = args[0].toLowerCase();
+    const cmdArgs = args.slice(1);
+
+    if (this.commands.has(cmdName)) {
+        try { await this.commands.get(cmdName).handler(cmdArgs, this); }
+        catch (err) { console.log(chalk.red(`Error: ${err.message}`)); }
+        process.stdout.write('\r\n');
+        return;
+    }
+
+    if (this.commandRegistry) {
+        const handled = await this.commandRegistry.execute(input, this);
+        if (handled) {
+            process.stdout.write('\r\n');
+            return;
+        }
+    }
+
+    // ★ Windows pe known-useless OS commands block karo
+    const blockedOnWindows = [ 'open', 'which', 'grep', 'touch', 'cat'];
+    if (process.platform === 'win32' && blockedOnWindows.includes(cmdName)) {
+        console.log(chalk.red(`'${cmdName}' is not a thinknsh command.`));
+        console.log(chalk.dim(`  Type 'help' to see available commands.`));
+        process.stdout.write('\r\n');
+        return;
+    }
+
+    await this.executeSystemCommand(input);
+}
     // ─── Prompt ───────────────────────────────────────────────────────────────
 
     getPromptText() {
         let p = '';
-        const room  = this.ws.getCurrentRoom?.();
+        const room = this.ws.getCurrentRoom?.();
         if (room) p += `[${room}] `;
         if (this.ws.isConnected?.()) p += '● ';
 
@@ -277,43 +363,38 @@ class ThinkNCollabShell extends EventEmitter {
             displayPath = displayPath.replace(homeDir, '~');
         }
 
-        p += `${this.username}@thinknsh:${displayPath} $`;
-        return p;
+        return `${this.username}@thinknsh:${displayPath} $`;
     }
 
-    getPrompt() { return this.getPromptText(); }
-
+    getPrompt()       { return this.getPromptText(); }
     printMessage(msg) { console.log(msg); }
 
     // ─── Built-ins ────────────────────────────────────────────────────────────
 
     registerBuiltinCommands() {
-        this.registerCommand('help',       this.helpCommand.bind(this),      'Show available commands');
-        this.registerCommand('exit',       () => { this.cleanup(); process.exit(0); }, 'Exit the shell');
-        this.registerCommand('quit',       () => { this.cleanup(); process.exit(0); }, 'Exit the shell');
-        this.registerCommand('clear',      () => console.clear(),            'Clear screen');
-        this.registerCommand('history',    this.historyCommand.bind(this),   'Show command history');
-        this.registerCommand('cd',         this.cdCommand.bind(this),        'Change directory');
-        this.registerCommand('pwd',        () => console.log(process.cwd()), 'Print working directory');
-        this.registerCommand('ls',         this.lsCommand.bind(this),        'List files');
-        this.registerCommand('connect',    this.connectCommand.bind(this),   'Connect to WebSocket');
-        this.registerCommand('disconnect', () => this.ws.disconnect(),       'Disconnect WebSocket');
-        this.registerCommand('status',     this.statusCommand.bind(this),    'Show status');
-        this.registerCommand('join',       this.joinCommand.bind(this),      'Join a room');
-        this.registerCommand('leave',      () => this.ws.leaveRoom?.(),      'Leave current room');
-        this.registerCommand('rooms',      this.roomsCommand.bind(this),     'List rooms');
-        this.registerCommand('users',      this.usersCommand.bind(this),     'List users in room');
-        this.registerCommand('say',        this.sayCommand.bind(this),       'Send a message');
-        this.registerCommand('msg',        this.sayCommand.bind(this),       'Send a message (alias)');
-        this.registerCommand('notify',     this.notifyCommand.bind(this),    'Send a notification');
-        this.registerCommand('alias',      this.aliasCommand.bind(this),     'Create an alias');
-        this.registerCommand('unalias',    this.unaliasCommand.bind(this),   'Remove an alias');
-        this.registerCommand('set',        this.setCommand.bind(this),       'Set a variable');
-        this.registerCommand('unset',      this.unsetCommand.bind(this),     'Unset a variable');
+        const r = (name, handler, desc) => this.commands.set(name, { handler, description: desc });
+
+        r('help',       this.helpCommand.bind(this),      'Show available commands');
+        r('exit',       () => { this.cleanup(); process.exit(0); }, 'Exit the shell');
+        r('quit',       () => { this.cleanup(); process.exit(0); }, 'Exit the shell');
+        r('clear',      () => console.clear(),            'Clear screen');
+        r('history',    this.historyCommand.bind(this),   'Show command history');
+        r('cd',         this.cdCommand.bind(this),        'Change directory');
+        r('pwd',        () => console.log(process.cwd()), 'Print working directory');
+        r('ls',         this.lsCommand.bind(this),        'List files');
+        r('connect',    this.connectCommand.bind(this),   'Connect to WebSocket');
+        r('disconnect', () => this.ws.disconnect(),       'Disconnect WebSocket');
+        r('status',     this.statusCommand.bind(this),    'Show connection status');
+        r('join',       this.joinCommand.bind(this),      'Join a room');
+        r('leave',      () => this.ws.leaveRoom?.(),      'Leave current room');
+        r('rooms',      this.roomsCommand.bind(this),     'List rooms');
+        r('say',        this.sayCommand.bind(this),       'Send a message');
+        r('msg',        this.sayCommand.bind(this),       'Send a message');
+        r('set',        this.setCommand.bind(this),       'Set a variable');
+        r('unset',      this.unsetCommand.bind(this),     'Unset a variable');
 
         this.addAlias('ll',  'ls -la');
         this.addAlias('..',  'cd ..');
-        this.addAlias('...', 'cd ../..');
         this.addAlias('~',   'cd ~');
     }
 
@@ -321,26 +402,8 @@ class ThinkNCollabShell extends EventEmitter {
     addAlias(alias, command) { this.aliases.set(alias, command); }
 
     async helpCommand() {
-        const categories = {
-            'Core':          ['help', 'exit', 'quit', 'clear', 'history'],
-            'Filesystem':    ['cd', 'pwd', 'ls'],
-            'WebSocket':     ['connect', 'disconnect', 'status'],
-            'Rooms':         ['join', 'leave', 'rooms', 'users'],
-            'Messages':      ['say', 'msg'],
-            'Notifications': ['notify'],
-            'Aliases':       ['alias', 'unalias'],
-            'Variables':     ['set', 'unset']
-        };
-        console.log(chalk.cyan('\n📚 Available Commands:'));
-        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        for (const [category, cmds] of Object.entries(categories)) {
-            console.log(chalk.yellow(`\n${category}:`));
-            cmds.forEach(cmd => {
-                const c = this.commands.get(cmd);
-                if (c) console.log(`  ${chalk.green(cmd.padEnd(12))} - ${c.description}`);
-            });
-        }
-        console.log(chalk.dim('\nAny other command runs in your system shell\n'));
+        if (this.commandRegistry) console.log(this.commandRegistry.getHelpText());
+        console.log(chalk.dim('  Any unrecognised command runs in your system shell\n'));
     }
 
     historyCommand() {
@@ -351,11 +414,8 @@ class ThinkNCollabShell extends EventEmitter {
         const target = args.join(' ').trim() || os.homedir();
         try {
             let newPath;
-            if (target === '~' || target === '~/' || target === '~\\') newPath = os.homedir();
-            else if (target.startsWith('~/') || target.startsWith('~\\')) newPath = path.join(os.homedir(), target.slice(2));
+            if (target === '~')   newPath = os.homedir();
             else if (target === '..') newPath = path.dirname(this.currentDir);
-            else if (target === '-') newPath = this.previousDir || this.currentDir;
-            else if (process.platform === 'win32' && target.match(/^[a-zA-Z]:[\\/]/)) newPath = target;
             else newPath = path.resolve(this.currentDir, target);
             newPath = path.normalize(newPath);
             const stats = await fs.stat(newPath);
@@ -369,22 +429,18 @@ class ThinkNCollabShell extends EventEmitter {
     async lsCommand(args) {
         try {
             const files    = await fs.readdir(this.currentDir);
-            const showAll  = args.includes('-a') || args.includes('--all');
+            const showAll  = args.includes('-a');
             const filtered = showAll ? files : files.filter(f => !f.startsWith('.'));
             const fileList = await Promise.all(filtered.map(async (file) => {
                 const stat = await fs.stat(path.join(this.currentDir, file));
-                return { name: file, isDir: stat.isDirectory(), mode: stat.mode };
+                return { name: file, isDir: stat.isDirectory() };
             }));
-            fileList.forEach(f => {
-                if (f.isDir)             console.log(chalk.blue(f.name + '/'));
-                else if (f.mode & 0o111) console.log(chalk.green(f.name + '*'));
-                else                     console.log(f.name);
-            });
+            fileList.forEach(f => f.isDir ? console.log(chalk.blue(f.name + '/')) : console.log(f.name));
         } catch (err) { console.log(chalk.red(`ls: ${err.message}`)); }
     }
 
-    async connectCommand(args) {
-        console.log(chalk.cyan(`🔌 Connecting...`));
+    async connectCommand() {
+        console.log(chalk.cyan('🔌 Connecting...'));
         try { await this.ws.connect(); }
         catch (err) { console.log(chalk.red(`❌ ${err.message}`)); }
     }
@@ -392,23 +448,22 @@ class ThinkNCollabShell extends EventEmitter {
     async statusCommand() {
         const connected = this.ws.isConnected();
         console.log(chalk.cyan('\n📊 Status:'));
-        console.log(`WebSocket: ${connected ? chalk.green('✓ Connected') : chalk.red('✗ Disconnected')}`);
-        if (connected) {
-            console.log(`Socket ID: ${chalk.dim(this.ws.getSocketId())}`);
-            console.log(`Server:    ${chalk.dim(this.ws.config.serverUrl)}`);
-        }
+        console.log(`  WebSocket : ${connected ? chalk.green('✓ Connected') : chalk.red('✗ Disconnected')}`);
+        if (connected) console.log(`  Socket ID : ${chalk.dim(this.ws.getSocketId())}`);
         const room = this.ws.getCurrentRoom();
-        console.log(`Room:      ${room ? chalk.green(room) : chalk.yellow('None')}`);
-        console.log(`Directory: ${chalk.blue(this.currentDir)}`);
+        console.log(`  Room      : ${room ? chalk.green(room) : chalk.yellow('None')}`);
+        console.log(`  Auth      : ${this.api.isAuthenticated() ? chalk.green('✓ Logged in') : chalk.yellow('Not logged in')}`);
+        const user = this.api.getUser();
+        if (user) console.log(`  User      : ${chalk.dim(user.name || user.email)}`);
+        console.log('');
     }
 
     async joinCommand(args) {
-        if (!args[0]) { console.log(chalk.red('Usage: join <room-id> [password]')); return; }
+        if (!args[0]) { console.log(chalk.red('Usage: join <room-id>')); return; }
         if (!this.ws.isConnected()) { console.log(chalk.yellow('Connecting...')); await this.ws.connect(); }
-        console.log(chalk.cyan(`🔗 Joining: ${args[0]}...`));
         try {
-            const result = await this.ws.joinRoom(args[0], args[1]);
-            console.log(chalk.green(`Joined: ${result.roomName || args[0]}`));
+            const result = await this.ws.joinRoom(args[0]);
+            console.log(chalk.green(`✅ Joined: ${result.roomName || args[0]}`));
         } catch (err) { console.log(chalk.red(`❌ ${err.message}`)); }
     }
 
@@ -417,61 +472,30 @@ class ThinkNCollabShell extends EventEmitter {
         this.ws.socket.emit('rooms:list');
         this.ws.socket.once('rooms:list', (data) => {
             if (data.rooms?.length) data.rooms.forEach(r => console.log(`  ${chalk.cyan(r.name || r.id)} — 👥 ${r.participantCount || 0}`));
-            else console.log('  No rooms available');
+            else console.log('  No rooms');
         });
     }
 
-    async usersCommand() {
-        if (!this.ws.isConnected()) { console.log(chalk.yellow('Not connected')); return; }
-        const room = this.ws.getCurrentRoom();
-        if (!room) { console.log(chalk.yellow('Not in a room')); return; }
-        try {
-            const users = await this.ws.getParticipants();
-            users.forEach(u => console.log(`  ${chalk.green('●')} ${u.username}${u.isTyping ? chalk.dim(' (typing...)') : ''}`));
-        } catch (err) { console.log(chalk.red(`Failed: ${err.message}`)); }
-    }
-
     async sayCommand(args) {
         const message = args.join(' ');
         if (!message) { console.log(chalk.red('Usage: say <message>')); return; }
         try {
             await this.ws.sendMessage(message);
+            const displayName = this.api.getUser()?.name || this.username;
             console.log(chalk.green(`You: ${message}`));
+            this.pushNotification({ type: 'message', from: `You (${displayName})`, text: message });
         } catch (err) { console.log(chalk.red(`Failed: ${err.message}`)); }
     }
 
-    async notifyCommand(args) {
-        const type = args[0] || 'info';
-        const msg  = args.slice(1).join(' ');
-        if (!msg) { console.log(chalk.red('Usage: notify <type> <message>')); return; }
-        try {
-            await this.ws.sendNotification({ type, title: 'Shell Notification', message: msg });
-            console.log(chalk.green('Notification sent'));
-        } catch (err) { console.log(chalk.red(`Failed: ${err.message}`)); }
-    }
-
-    async aliasCommand(args) {
-        if (!args.length) { for (const [a, c] of this.aliases) console.log(`  ${chalk.green(a.padEnd(12))} → ${chalk.dim(c)}`); return; }
-        if (args.length < 2) { console.log(chalk.red('Usage: alias <n> <cmd>')); return; }
-        this.addAlias(args[0], args.slice(1).join(' '));
-        console.log(chalk.green(`${args[0]} → ${args.slice(1).join(' ')}`));
-    }
-
-    async unaliasCommand(args) {
-        if (!args[0]) { console.log(chalk.red('Usage: unalias <n>')); return; }
-        this.aliases.delete(args[0]) ? console.log(chalk.green(`Removed: ${args[0]}`)) : console.log(chalk.red(`Not found: ${args[0]}`));
-    }
-
     async setCommand(args) {
         if (!args.length) { for (const [k, v] of this.variables) console.log(`  ${chalk.green(k.padEnd(12))} = ${v}`); return; }
-        if (args.length < 2) { console.log(chalk.red('Usage: set <n> <value>')); return; }
         this.variables.set(args[0], args.slice(1).join(' '));
         console.log(chalk.green(`${args[0]} = ${args.slice(1).join(' ')}`));
     }
 
     async unsetCommand(args) {
-        if (!args[0]) { console.log(chalk.red('Usage: unset <n>')); return; }
-        this.variables.delete(args[0]) ? console.log(chalk.green(`Removed`)) : console.log(chalk.red(`Not found`));
+        if (!args[0]) return;
+        this.variables.delete(args[0]);
     }
 
     getSessionPath() { return path.join(this.config.configDir, 'session.json'); }
@@ -494,22 +518,28 @@ class ThinkNCollabShell extends EventEmitter {
     executeSystemCommand(command) {
         return new Promise((resolve) => {
             const child = spawn(command, [], {
-                cwd: this.currentDir, shell: true, stdio: 'inherit',
-                env: { ...process.env, THINKNCOLLAB_SHELL: '1' }
+                cwd:   this.currentDir,
+                shell: true,
+                stdio: 'inherit'
+            });
+            child.on('close', (code) => {
+                // Update currentDir in case command changed it (cd won't but others might)
+                try { this.currentDir = process.cwd(); } catch {}
+                process.stdout.write('\r\n');
+                resolve();
+            });
+            child.on('error', () => {
+                console.log(chalk.red(`Command not found: ${command}`));
+                resolve();
             });
-            child.on('close', () => resolve());
-            child.on('error', () => { console.log(chalk.red(`Command not found: ${command}`)); resolve(); });
         });
     }
 
     showWelcome() {
-        try {
-            const figlet = require('figlet');
-            console.log(chalk.cyan(figlet.textSync('ThinkNCollab', { font: 'Standard' })));
-        } catch {}
+        try { const figlet = require('figlet'); console.log(chalk.cyan(figlet.textSync('ThinkNCollab', { font: 'Standard' }))); } catch {}
         console.log(chalk.cyan(`
 ╔══════════════════════════════════════════════════════╗
-║     ThinkNCollab Shell v0.0.05                       ║
+║     ThinkNCollab Shell v0.0.6                        ║
 ║     Type 'help' for commands                         ║
 ╚══════════════════════════════════════════════════════╝`));
     }
@@ -525,11 +555,12 @@ class ThinkNCollabShell extends EventEmitter {
         try { fs.writeFileSync(this.config.historyFile, this.history.slice(-this.config.maxHistory).join('\n')); } catch {}
     }
 
-    cleanup() {
-        if (this.tcpServer) { try { this.tcpServer.close(); } catch {} }
-        if (this.ws) this.ws.disconnect();
-        this.saveHistory();
-    }
+cleanup() {
+    this.api.logout();  // session end + heartbeat stop + lastSeen update
+    if (this.tcpServer) { try { this.tcpServer.close(); } catch {} }
+    if (this.ws) this.ws.disconnect();
+    this.saveHistory();
+}
 }
 
 module.exports = ThinkNCollabShell;