thinkncollab-shell 0.0.1 → 0.0.2

package/src/core/shell.js

@@ -1,972 +1,533 @@
 /**
  * ThinkNCollab Shell Core
- * Main shell class with WebSocket integration
+ * Inquirer REPL + TCP IPC for notification window
  */
 
-const readline = require('readline');
-const path = require('path');
-const fs = require('fs-extra');
-const os = require('os');
-const chalk = require('chalk');
-const { exec, spawn } = require('child_process');
+const path   = require('path');
+const fs     = require('fs-extra');
+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 EventEmitter     = require('events');
+const CommandRegistry  = require('../commands');
+const ThinkNCollabAPI  = require('./api-client');
+
+// Find an available port starting from 7379
+function getAvailablePort(startPort) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(startPort, '127.0.0.1', () => {
+            const port = server.address().port;
+            server.close(() => resolve(port));
+        });
+        server.on('error', () => resolve(getAvailablePort(startPort + 1)));
+    });
+}
 
 class ThinkNCollabShell extends EventEmitter {
+
     constructor(options = {}) {
         super();
-        
-        // Configuration
+
         this.config = {
             historyFile: path.join(os.homedir(), '.thinknsh_history'),
-            configDir: path.join(os.homedir(), '.thinkncollab'),
-            maxHistory: 1000,
-            prompt: options.prompt || 'thinknsh> ',
+            configDir:   path.join(os.homedir(), '.thinkncollab'),
+            maxHistory:  1000,
             websocket: {
-                serverUrl: options.serverUrl || 'https://api.thinkncollab.com',
+                serverUrl:   options.serverUrl   || 'https://thinkncollab.com/thinknsh',
                 autoConnect: options.autoConnect || false
             },
             ...options
         };
-        
-        // Ensure config directory exists
+
         fs.ensureDirSync(this.config.configDir);
-        
-        // Initialize components
-        this.ws = new WebSocketManager(this.config.websocket);
-        this.rl = null;
+
+        this.ws         = new WebSocketManager(this.config.websocket);
         this.currentDir = process.cwd();
-        this.username = os.userInfo().username;
-        this.hostname = os.hostname();
-        this.history = [];
-        this.commands = new Map();
-        this.aliases = new Map();
+        this.username   = os.userInfo().username;
+        this.history    = [];
+        this.running    = false;
+
+        // TCP notification clients
+        this.notifyClients = new Set();
+        this.tcpServer     = null;
+
+        this.api = new ThinkNCollabAPI({
+            apiUrl: options.apiUrl || 'https://thinkncollab.com',
+            wsUrl:  options.wsUrl  || 'https://thinkncollab.com'
+        });
+
+        this.commands  = new Map();
+        this.aliases   = new Map();
         this.variables = new Map();
-        this.isTyping = false;
+        this.isTyping  = false;
         this.typingTimeout = null;
-        
-        // Load history
+
         this.loadHistory();
-        
-        // Register built-in commands
         this.registerBuiltinCommands();
-        
-        // Setup WebSocket event handlers
+        this.commandRegistry = new CommandRegistry(this);
         this.setupWebSocketHandlers();
     }
-    
-    /**
-     * Setup WebSocket event handlers
-     */
-    setupWebSocketHandlers() {
-        this.ws.on('connected', (data) => {
-            this.printMessage(chalk.green(`✅ Connected to ThinkNCollab server (ID: ${data.socketId})`));
-            this.emit('ws:connected', data);
-        });
-        
-        this.ws.on('disconnected', (data) => {
-            this.printMessage(chalk.yellow(`⚠️ Disconnected: ${data.reason}`));
-            this.emit('ws:disconnected', data);
-        });
-        
-        this.ws.on('reconnected', (data) => {
-            this.printMessage(chalk.green(`✅ Reconnected after ${data.attemptNumber} attempts`));
-            this.emit('ws:reconnected', data);
-        });
-        
-        this.ws.on('message', (data) => {
-            this.handleIncomingMessage(data);
-        });
-        
-        this.ws.on('notification', (data) => {
-            this.handleNotification(data);
-        });
-        
-        this.ws.on('userJoined', (data) => {
-            this.printMessage(chalk.cyan(`👤 ${data.username} joined the room`));
-            this.emit('user:joined', data);
-        });
-        
-        this.ws.on('userLeft', (data) => {
-            this.printMessage(chalk.yellow(`👤 ${data.username} left the room`));
-            this.emit('user:left', data);
+
+    // ─── TCP Notification Server ──────────────────────────────────────────────
+
+    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.on('error', (err) => {
+                console.log(chalk.yellow(`⚠️  Notification server: ${err.message}`));
+                resolve();
+            });
         });
-        
-        this.ws.on('userTyping', (data) => {
-            if (data.isTyping) {
-                this.showTypingIndicator(data.username);
+    }
+
+    // Send notification event to all connected notification windows
+    pushNotification(data) {
+        if (this.notifyClients.size === 0) return;
+        const line = JSON.stringify(data) + '\n';
+        for (const client of this.notifyClients) {
+            try { client.write(line); } catch {}
+        }
+    }
+
+    // ─── Spawn notification window (cross-platform) ───────────────────────────
+
+    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) };
+
+        try {
+            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.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();
+                }
+
+            } else if (process.platform === 'darwin') {
+                // macOS — Terminal.app
+                const script = `tell application "Terminal" to do script "THINKNSH_NOTIFY_PORT=${NOTIFY_PORT} node '${notifyScript}'"`;
+                spawn('osascript', ['-e', script], { detached: true, stdio: 'ignore' }).unref();
+
             } else {
-                this.hideTypingIndicator(data.username);
+                // 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}`));
+                }
             }
-        });
-        
-        this.ws.on('terminalOutput', (data) => {
-            this.printMessage(chalk.dim(`[${data.username}] $ ${data.command}`));
-            this.printMessage(chalk.gray(data.output));
-        });
-        
-        this.ws.on('error', (error) => {
-            this.printMessage(chalk.red(`❌ WebSocket error: ${error.message}`));
-        });
+        } catch (err) {
+            console.log(chalk.yellow(`⚠️  Could not spawn notification window: ${err.message}`));
+            console.log(chalk.dim(`   Run manually: node "${notifyScript}"`));
+        }
     }
-    
-    /**
-     * Start the shell
-     */
+
+    // ─── 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 }));
+    }
+
+    // ─── Start ────────────────────────────────────────────────────────────────
+
     async start() {
         this.showWelcome();
-        
-        this.rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            prompt: this.getPrompt(),
-            completer: this.completer.bind(this)
-        });
-        
-        // Handle input
-        this.rl.on('line', async (line) => {
-            const input = line.trim();
-            
-            if (input) {
-                this.history.push(input);
-                this.saveHistory();
-                await this.execute(input);
-            }
-            
-            this.rl.setPrompt(this.getPrompt());
-            this.rl.prompt();
-        });
-        
-        // Handle exit
-        this.rl.on('close', () => {
-            this.cleanup();
-            process.exit(0);
-        });
-        
-        // Handle signals
+
+        // 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', () => {
-            this.handleInterrupt();
+            console.log(chalk.yellow('\nUse "exit" to quit'));
         });
-        
-        this.rl.prompt();
-        
-        // Auto-connect if configured
+
         if (this.config.websocket.autoConnect) {
             await this.ws.connect();
         }
-    }
-    
-    /**
-     * Execute a command
-     */
-async execute(input) {
-    if (!input.trim()) return;
-    
-    // Parse command with quote support
-    const args = this.parseCommand(input);
-    const command = args[0].toLowerCase();
-    const commandArgs = args.slice(1);
-    
-    // Add to history
-    this.history.push(input);
-    this.saveHistory();
-    
-    // Handle typing indicator
-    this.handleTyping();
-    
-    // Check for variable assignment (e.g., VAR=value)
-    if (command.includes('=') && args.length === 1) {
-        this.setVariable(command);
-        return;
-    }
-    
-    // Check for alias
-    if (this.aliases.has(command)) {
-        const aliasCmd = this.aliases.get(command);
-        // Preserve original args when expanding alias
-        return this.execute(aliasCmd + (commandArgs.length ? ' ' + commandArgs.join(' ') : ''));
-    }
-    
-    // Check built-in commands
-    if (this.commands.has(command)) {
-        try {
-            const cmd = this.commands.get(command);
-            const result = await cmd.handler(commandArgs, this);
-            if (result !== undefined) {
-                console.log(result);
+
+        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 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')) {
+                    console.log(chalk.yellow('Use "exit" to quit'));
+                } else {
+                    console.log(chalk.red(`Shell error: ${err.message}`));
+                }
             }
-        } catch (error) {
-            console.log(chalk.red(`Error: ${error.message}`));
-        }
-        return;
-    }
-    
-    // Execute system command
-    await this.executeSystemCommand(input);
-}
-    /**
-     * Register built-in commands
-     */
-    registerBuiltinCommands() {
-        // Core shell commands
-        this.registerCommand('help', this.helpCommand.bind(this), 'Show this help');
-        this.registerCommand('exit', () => process.exit(0), 'Exit the shell');
-        this.registerCommand('quit', () => process.exit(0), 'Exit the shell');
-        this.registerCommand('clear', () => console.clear(), 'Clear the screen');
-        this.registerCommand('history', this.historyCommand.bind(this), 'Show command history');
-        
-        // Directory commands
-        this.registerCommand('cd', this.cdCommand.bind(this), 'Change directory');
-        this.registerCommand('pwd', () => process.cwd(), 'Print working directory');
-        this.registerCommand('ls', this.lsCommand.bind(this), 'List files');
-        
-        // WebSocket commands
-        this.registerCommand('connect', this.connectCommand.bind(this), 'Connect to WebSocket server');
-        this.registerCommand('disconnect', () => this.ws.disconnect(), 'Disconnect from WebSocket');
-        this.registerCommand('status', this.statusCommand.bind(this), 'Show connection status');
-        
-        // Room commands
-        this.registerCommand('join', this.joinCommand.bind(this), 'Join a collaboration room');
-        this.registerCommand('leave', () => this.ws.leaveRoom(), 'Leave current room');
-        this.registerCommand('rooms', this.roomsCommand.bind(this), 'List available rooms');
-        this.registerCommand('users', this.usersCommand.bind(this), 'List users in room');
-        
-        // Message commands
-        this.registerCommand('say', this.sayCommand.bind(this), 'Send a message to the room');
-        this.registerCommand('msg', this.sayCommand.bind(this), 'Send a message (alias)');
-        
-        // Notification commands
-        this.registerCommand('notify', this.notifyCommand.bind(this), 'Send a notification');
-        
-        // Alias commands
-        this.registerCommand('alias', this.aliasCommand.bind(this), 'Create an alias');
-        this.registerCommand('unalias', this.unaliasCommand.bind(this), 'Remove an alias');
-        
-        // Variable commands
-        this.registerCommand('set', this.setCommand.bind(this), 'Set a variable');
-        this.registerCommand('unset', this.unsetCommand.bind(this), 'Unset a variable');
-        
-        // Add aliases
-        this.addAlias('ll', 'ls -la');
-        this.addAlias('..', 'cd ..');
-        this.addAlias('...', 'cd ../..');
-        this.addAlias('~', 'cd ~');
-    }
-    
-    /**
-     * Register a command
-     */
-    registerCommand(name, handler, description = '') {
-        this.commands.set(name, { handler, description });
-    }
-    
-    /**
-     * Add an alias
-     */
-    addAlias(alias, command) {
-        this.aliases.set(alias, command);
-    }
-    
-    /**
-     * Get formatted prompt
-     */
-getPrompt() {
-    let prompt = '';
-    
-    // Add room indicator if in a room
-    const room = this.ws.getCurrentRoom();
-    if (room) {
-        prompt += chalk.magenta(`[${room}] `);
-    }
-    
-    // Add connection indicator
-    if (this.ws.isConnected()) {
-        prompt += chalk.green('● ');
-    }
-    
-    // FIX: Better path display for Windows
-    let displayPath = this.currentDir;
-    const homeDir = os.homedir();
-    
-    if (process.platform === 'win32') {
-        // Windows: Show clean path without C:\Users\username
-        if (displayPath.toLowerCase() === homeDir.toLowerCase()) {
-            displayPath = '~';  // At home directory
-        } else if (displayPath.toLowerCase().startsWith(homeDir.toLowerCase())) {
-            // In subdirectory of home
-            const relativePath = displayPath.slice(homeDir.length);
-            displayPath = '~' + relativePath.replace(/\\/g, '/');
-        } else {
-            // Outside home, show full path with forward slashes for consistency
-            displayPath = displayPath.replace(/\\/g, '/');
         }
-    } else {
-        // Unix: Use ~ for home
-        displayPath = displayPath.replace(homeDir, '~');
     }
-    
-    prompt += chalk.cyan(`${this.username}@thinknsh`) + ':';
-    prompt += chalk.blue(displayPath) + ' ';
-    
-    // Add prompt symbol
-    prompt += chalk.green('$ ');
-    
-    return prompt;
-}
-    
-    /**
-     * Parse command with quotes
-     */
-/**
- * Parse command with support for quoted strings and escaped spaces
- */
-parseCommand(input) {
-    const args = [];
-    let current = '';
-    let inQuotes = false;
-    let quoteChar = '';
-    let escapeNext = false;
-    
-    for (let i = 0; i < input.length; i++) {
-        const char = input[i];
-        
-        // Handle escape character
-        if (char === '\\' && !escapeNext && !inQuotes) {
-            escapeNext = true;
-            continue;
-        }
-        
-        if (escapeNext) {
-            current += char;
-            escapeNext = false;
-            continue;
-        }
-        
-        // Handle quotes
-        if ((char === '"' || char === "'") && !inQuotes) {
-            inQuotes = true;
-            quoteChar = char;
-            continue;
-        } else if (char === quoteChar && inQuotes) {
-            inQuotes = false;
-            quoteChar = '';
-            continue;
-        }
-        
-        // Handle spaces (argument separator)
-        if (char === ' ' && !inQuotes) {
-            if (current) {
-                args.push(current);
-                current = '';
+
+    restoreReadline() {}
+
+    // ─── Execute ──────────────────────────────────────────────────────────────
+
+    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)) {
+            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}`));
             }
-            continue;
+            return;
+        }
+
+        if (this.commandRegistry) {
+            const handled = await this.commandRegistry.execute(input, this);
+            if (handled) return;
         }
-        
-        // Add character to current argument
-        current += char;
+
+        await this.executeSystemCommand(input);
     }
-    
-    // Add last argument
-    if (current) {
-        args.push(current);
+
+    // ─── Prompt ───────────────────────────────────────────────────────────────
+
+    getPromptText() {
+        let p = '';
+        const room  = this.ws.getCurrentRoom?.();
+        if (room) p += `[${room}] `;
+        if (this.ws.isConnected?.()) p += '● ';
+
+        let displayPath = this.currentDir;
+        const homeDir   = os.homedir();
+
+        if (process.platform === 'win32') {
+            if (displayPath.toLowerCase() === homeDir.toLowerCase()) displayPath = '~';
+            else if (displayPath.toLowerCase().startsWith(homeDir.toLowerCase()))
+                displayPath = '~' + displayPath.slice(homeDir.length).replace(/\\/g, '/');
+            else displayPath = displayPath.replace(/\\/g, '/');
+        } else {
+            displayPath = displayPath.replace(homeDir, '~');
+        }
+
+        p += `${this.username}@thinknsh:${displayPath} $`;
+        return p;
     }
-    
-    return args;
-}
-    
-    /**
-     * Execute system command
-     */
-    executeSystemCommand(command) {
-        return new Promise((resolve) => {
-            const child = spawn(command, [], {
-                cwd: this.currentDir,
-                shell: true,
-                stdio: 'inherit',
-                env: {
-                    ...process.env,
-                    THINKNCOLLAB_SHELL: '1'
-                }
-            });
-            
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    // Command failed, but we don't show error for normal commands
-                }
-                resolve();
-            });
-            
-            child.on('error', (error) => {
-                console.log(chalk.red(`Command not found: ${command}`));
-                resolve();
-            });
-        });
+
+    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');
+
+        this.addAlias('ll',  'ls -la');
+        this.addAlias('..',  'cd ..');
+        this.addAlias('...', 'cd ../..');
+        this.addAlias('~',   'cd ~');
     }
-    
-    /**
-     * Command handlers
-     */
-    async helpCommand(args) {
-        console.log(chalk.cyan('\n📚 Available Commands:'));
-        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        
+
+    registerCommand(name, handler, description = '') { this.commands.set(name, { handler, description }); }
+    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'],
+            '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']
+            '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 command = this.commands.get(cmd);
-                if (command) {
-                    console.log(`  ${chalk.green(cmd.padEnd(12))} - ${command.description}`);
-                }
+                const c = this.commands.get(cmd);
+                if (c) console.log(`  ${chalk.green(cmd.padEnd(12))} - ${c.description}`);
             });
         }
-        
-        console.log(chalk.dim('\nAny other command is passed to your system shell\n'));
+        console.log(chalk.dim('\nAny other command runs in your system shell\n'));
+    }
+
+    historyCommand() {
+        this.history.forEach((cmd, i) => console.log(`${(i + 1).toString().padStart(4)}  ${cmd}`));
     }
-    
-async cdCommand(args) {
-    // Join all args to handle paths with spaces
-    const target = args.join(' ').trim() || os.homedir();
-    
-    if (!target) {
-        // No args, go home
+
+    async cdCommand(args) {
+        const target = args.join(' ').trim() || os.homedir();
         try {
-            process.chdir(os.homedir());
+            let newPath;
+            if (target === '~' || target === '~/' || target === '~\\') newPath = os.homedir();
+            else if (target.startsWith('~/') || target.startsWith('~\\')) newPath = path.join(os.homedir(), target.slice(2));
+            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);
+            if (!stats.isDirectory()) { console.log(chalk.red(`cd: not a directory: ${target}`)); return; }
+            this.previousDir = this.currentDir;
+            process.chdir(newPath);
             this.currentDir = process.cwd();
-        } catch (error) {
-            console.log(chalk.red(`cd: ${error.message}`));
-        }
-        return;
-    }
-    
-    try {
-        let newPath;
-        
-        // Handle special cases
-        if (target === '~' || target === '~/' || target === '~\\') {
-            newPath = os.homedir();
-        } else if (target.startsWith('~/') || target.startsWith('~\\')) {
-            // Handle ~/path with possible spaces
-            const rest = target.slice(2);
-            newPath = path.join(os.homedir(), rest);
-        } else if (target === '..') {
-            newPath = path.dirname(this.currentDir);
-        } else if (target === '.') {
-            newPath = this.currentDir;
-        } else if (target === '-') {
-            // Go to previous directory
-            newPath = this.previousDir || this.currentDir;
-        } else {
-            // Handle Windows paths with spaces
-            if (process.platform === 'win32') {
-                // Check if it's an absolute path (with drive letter)
-                if (target.match(/^[a-zA-Z]:[\\/]/) || target.match(/^[a-zA-Z]:$/)) {
-                    newPath = target;
-                } else {
-                    // Relative path - resolve from current directory
-                    newPath = path.resolve(this.currentDir, target);
-                }
-            } else {
-                newPath = path.resolve(this.currentDir, target);
-            }
-        }
-        
-        // Normalize path (fixes any // or \/ issues)
-        newPath = path.normalize(newPath);
-        
-        // Check if directory exists
-        await fs.access(newPath);
-        const stats = await fs.stat(newPath);
-        
-        if (!stats.isDirectory()) {
-            console.log(chalk.red(`cd: ${target}: Not a directory`));
-            return;
-        }
-        
-        // Store previous directory
-        this.previousDir = this.currentDir;
-        
-        // Change directory
-        process.chdir(newPath);
-        this.currentDir = process.cwd();
-        
-    } catch (error) {
-        console.log(chalk.red(`cd: ${target}: No such directory`));
+        } catch { console.log(chalk.red(`cd: no such directory: ${target}`)); }
     }
-}
-    
+
     async lsCommand(args) {
         try {
-            const files = await fs.readdir(this.currentDir);
-            const showAll = args.includes('-a') || args.includes('--all');
-            
+            const files    = await fs.readdir(this.currentDir);
+            const showAll  = args.includes('-a') || args.includes('--all');
             const filtered = showAll ? files : files.filter(f => !f.startsWith('.'));
-            
-            // Get file stats
-            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(),
-                        size: stat.size,
-                        mode: stat.mode
-                    };
-                })
-            );
-            
-            // Colorize output
-            fileList.forEach(file => {
-                if (file.isDir) {
-                    console.log(chalk.blue(file.name + '/'));
-                } else if (file.mode & 0o111) {
-                    console.log(chalk.green(file.name + '*'));
-                } else {
-                    console.log(file.name);
-                }
+            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 };
+            }));
+            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);
             });
-        } catch (error) {
-            console.log(chalk.red(`ls: ${error.message}`));
-        }
+        } catch (err) { console.log(chalk.red(`ls: ${err.message}`)); }
     }
-    
+
     async connectCommand(args) {
-        const serverUrl = args[0] || this.config.websocket.serverUrl;
-        
-        console.log(chalk.cyan(`🔌 Connecting to ${serverUrl}...`));
-        
-        try {
-            await this.ws.connect();
-        } catch (error) {
-            console.log(chalk.red(`❌ Connection failed: ${error.message}`));
-        }
+        console.log(chalk.cyan(`🔌 Connecting...`));
+        try { await this.ws.connect(); }
+        catch (err) { console.log(chalk.red(`❌ ${err.message}`)); }
     }
-    
+
     async statusCommand() {
-        console.log(chalk.cyan('\n📊 Status:'));
-        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        
         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(`Server:    ${chalk.dim(this.ws.config.serverUrl)}`);
         }
-        
         const room = this.ws.getCurrentRoom();
-        console.log(`Room: ${room ? chalk.green(room) : chalk.yellow('None')}`);
-        
-        console.log(`Current Directory: ${chalk.blue(this.currentDir)}`);
-        console.log(`History: ${chalk.yellow(this.history.length)} commands`);
-        console.log(`Commands: ${chalk.green(this.commands.size)} registered`);
-        console.log(`Aliases: ${chalk.green(this.aliases.size)} defined`);
+        console.log(`Room:      ${room ? chalk.green(room) : chalk.yellow('None')}`);
+        console.log(`Directory: ${chalk.blue(this.currentDir)}`);
     }
-    
+
     async joinCommand(args) {
-        const roomId = args[0];
-        
-        if (!roomId) {
-            console.log(chalk.red('Usage: join <room-id> [password]'));
-            return;
-        }
-        
-        const password = args[1];
-        
-        if (!this.ws.isConnected()) {
-            console.log(chalk.yellow('Not connected. Connecting first...'));
-            await this.ws.connect();
-        }
-        
-        console.log(chalk.cyan(`🔗 Joining room: ${roomId}...`));
-        
+        if (!args[0]) { console.log(chalk.red('Usage: join <room-id> [password]')); 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(roomId, password);
-            console.log(chalk.green(`✅ Joined room: ${result.roomName || roomId}`));
-            console.log(chalk.dim(`Participants: ${result.participantCount || '?'}`));
-        } catch (error) {
-            console.log(chalk.red(`❌ Failed to join: ${error.message}`));
-        }
+            const result = await this.ws.joinRoom(args[0], args[1]);
+            console.log(chalk.green(`✅ Joined: ${result.roomName || args[0]}`));
+        } catch (err) { console.log(chalk.red(`❌ ${err.message}`)); }
     }
-    
+
     async roomsCommand() {
-        if (!this.ws.isConnected()) {
-            console.log(chalk.yellow('Not connected to WebSocket server'));
-            return;
-        }
-        
-        console.log(chalk.cyan('\n📋 Available Rooms:'));
-        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        
-        // Request rooms list
+        if (!this.ws.isConnected()) { console.log(chalk.yellow('Not connected')); return; }
         this.ws.socket.emit('rooms:list');
-        
         this.ws.socket.once('rooms:list', (data) => {
-            if (data.rooms && data.rooms.length > 0) {
-                data.rooms.forEach(room => {
-                    const current = room.id === this.ws.getCurrentRoom() ? chalk.green(' (current)') : '';
-                    console.log(`  ${chalk.cyan(room.name || room.id)}${current}`);
-                    if (room.description) {
-                        console.log(`    ${chalk.dim(room.description)}`);
-                    }
-                    console.log(`    ${chalk.yellow('👥 ' + (room.participantCount || 0))} participants`);
-                });
-            } else {
-                console.log('  No rooms available');
-            }
+            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');
         });
     }
-    
+
     async usersCommand() {
-        if (!this.ws.isConnected()) {
-            console.log(chalk.yellow('Not connected'));
-            return;
-        }
-        
+        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;
-        }
-        
-        console.log(chalk.cyan(`\n👥 Users in ${room}:`));
-        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        
+        if (!room) { console.log(chalk.yellow('Not in a room')); return; }
         try {
-            const participants = await this.ws.getParticipants();
-            participants.forEach(user => {
-                const typing = user.isTyping ? chalk.green(' (typing...)') : '';
-                console.log(`  ${chalk.green('●')} ${user.username}${typing}`);
-                if (user.status) {
-                    console.log(`    ${chalk.dim(user.status)}`);
-                }
-            });
-        } catch (error) {
-            console.log(chalk.red(`Failed to get users: ${error.message}`));
-        }
+            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;
-        }
-        
+        if (!message) { console.log(chalk.red('Usage: say <message>')); return; }
         try {
             await this.ws.sendMessage(message);
-            
-            // Clear typing indicator
-            if (this.isTyping) {
-                this.ws.sendTyping(false);
-                this.isTyping = false;
-                clearTimeout(this.typingTimeout);
-            }
-            
-            // Echo locally
             console.log(chalk.green(`You: ${message}`));
-        } catch (error) {
-            console.log(chalk.red(`Failed to send: ${error.message}`));
-        }
+        } catch (err) { console.log(chalk.red(`Failed: ${err.message}`)); }
     }
-    
+
     async notifyCommand(args) {
         const type = args[0] || 'info';
-        const message = args.slice(1).join(' ');
-        
-        if (!message) {
-            console.log(chalk.red('Usage: notify <type> <message>'));
-            console.log(chalk.dim('Types: info, success, warning, error'));
-            return;
-        }
-        
+        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
-            });
-            
+            await this.ws.sendNotification({ type, title: 'Shell Notification', message: msg });
             console.log(chalk.green('✅ Notification sent'));
-        } catch (error) {
-            console.log(chalk.red(`Failed to send notification: ${error.message}`));
-        }
+        } catch (err) { console.log(chalk.red(`Failed: ${err.message}`)); }
     }
-    
+
     async aliasCommand(args) {
-        if (args.length === 0) {
-            // List aliases
-            console.log(chalk.cyan('\n🔧 Current Aliases:'));
-            console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-            
-            if (this.aliases.size === 0) {
-                console.log('  No aliases defined');
-            } else {
-                for (const [alias, cmd] of this.aliases) {
-                    console.log(`  ${chalk.green(alias.padEnd(12))} → ${chalk.dim(cmd)}`);
-                }
-            }
-            return;
-        }
-        
-        if (args.length < 2) {
-            console.log(chalk.red('Usage: alias <name> <command>'));
-            return;
-        }
-        
-        const name = args[0];
-        const command = args.slice(1).join(' ');
-        
-        this.addAlias(name, command);
-        console.log(chalk.green(`✅ Alias created: ${name} → ${command}`));
+        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.length === 0) {
-            console.log(chalk.red('Usage: unalias <name>'));
-            return;
-        }
-        
-        const name = args[0];
-        
-        if (this.aliases.delete(name)) {
-            console.log(chalk.green(`✅ Alias removed: ${name}`));
-        } else {
-            console.log(chalk.red(`Alias not found: ${name}`));
-        }
+        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 === 0) {
-            // List variables
-            console.log(chalk.cyan('\n📋 Variables:'));
-            console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-            
-            if (this.variables.size === 0) {
-                console.log('  No variables set');
-            } else {
-                for (const [key, value] of this.variables) {
-                    console.log(`  ${chalk.green(key.padEnd(12))} = ${chalk.yellow(JSON.stringify(value))}`);
-                }
-            }
-            return;
-        }
-        
-        if (args.length < 2) {
-            console.log(chalk.red('Usage: set <name> <value>'));
-            return;
-        }
-        
-        const name = args[0];
-        const value = args.slice(1).join(' ');
-        
-        this.variables.set(name, value);
-        console.log(chalk.green(`✅ Variable set: ${name} = ${value}`));
+        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.length === 0) {
-            console.log(chalk.red('Usage: unset <name>'));
-            return;
-        }
-        
-        const name = args[0];
-        
-        if (this.variables.delete(name)) {
-            console.log(chalk.green(`✅ Variable removed: ${name}`));
-        } else {
-            console.log(chalk.red(`Variable not found: ${name}`));
-        }
+        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`));
     }
-    
-    setVariable(assignment) {
-        const parts = assignment.split('=');
-        const name = parts[0].trim();
-        const value = parts.slice(1).join('=').trim();
-        
-        // Remove quotes if present
-        const cleanValue = value.replace(/^["']|["']$/g, '');
-        
-        this.variables.set(name, cleanValue);
-        console.log(chalk.dim(`Variable set: ${name}=${cleanValue}`));
-    }
-    
-    historyCommand() {
-        this.history.forEach((cmd, i) => {
-            console.log(`${(i + 1).toString().padStart(4)}  ${cmd}`);
-        });
-    }
-    
-    /**
-     * Handle incoming messages
-     */
-    handleIncomingMessage(data) {
-        // Clear current line
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        
-        // Show message
-        const prefix = data.username === this.username ? 'You' : data.username;
-        console.log(`${chalk.cyan(`[${prefix}]`)} ${data.message}`);
-        
-        // Redraw prompt
-        this.rl.prompt(true);
-    }
-    
-    /**
-     * Handle notifications
-     */
-    handleNotification(data) {
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        
-        let color = chalk.blue;
-        switch (data.type) {
-            case 'success': color = chalk.green; break;
-            case 'warning': color = chalk.yellow; break;
-            case 'error': color = chalk.red; break;
-            default: color = chalk.blue;
-        }
-        
-        console.log(color(`📢 ${data.title}: ${data.message}`));
-        this.rl.prompt(true);
-    }
-    
-    /**
-     * Show typing indicator
-     */
-    showTypingIndicator(username) {
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        console.log(chalk.dim(`👤 ${username} is typing...`));
-        this.rl.prompt(true);
-    }
-    
-    /**
-     * Hide typing indicator
-     */
-    hideTypingIndicator(username) {
-        // Just redraw prompt
-        this.rl.prompt(true);
-    }
-    
-    /**
-     * Handle typing detection
-     */
-    handleTyping() {
-        if (!this.isTyping && this.ws.getCurrentRoom()) {
-            this.isTyping = true;
-            this.ws.sendTyping(true);
+
+    getSessionPath() { return path.join(this.config.configDir, 'session.json'); }
+
+    parseCommand(input) {
+        const args = [];
+        let current = '', inQuotes = false, quoteChar = '', escapeNext = false;
+        for (const char of input) {
+            if (char === '\\' && !escapeNext && !inQuotes) { escapeNext = true; continue; }
+            if (escapeNext) { current += char; escapeNext = false; continue; }
+            if ((char === '"' || char === "'") && !inQuotes) { inQuotes = true; quoteChar = char; continue; }
+            if (char === quoteChar && inQuotes) { inQuotes = false; quoteChar = ''; continue; }
+            if (char === ' ' && !inQuotes) { if (current) { args.push(current); current = ''; } continue; }
+            current += char;
         }
-        
-        clearTimeout(this.typingTimeout);
-        this.typingTimeout = setTimeout(() => {
-            if (this.isTyping) {
-                this.isTyping = false;
-                this.ws.sendTyping(false);
-            }
-        }, 2000);
+        if (current) args.push(current);
+        return args;
     }
-    
-    /**
-     * Print message without breaking prompt
-     */
-    printMessage(message) {
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        console.log(message);
-        this.rl.prompt(true);
+
+    executeSystemCommand(command) {
+        return new Promise((resolve) => {
+            const child = spawn(command, [], {
+                cwd: this.currentDir, shell: true, stdio: 'inherit',
+                env: { ...process.env, THINKNCOLLAB_SHELL: '1' }
+            });
+            child.on('close', () => resolve());
+            child.on('error', () => { console.log(chalk.red(`Command not found: ${command}`)); resolve(); });
+        });
     }
-    
-    /**
-     * Show welcome message
-     */
+
     showWelcome() {
-        const figlet = require('figlet');
-        
-        console.log(chalk.cyan(figlet.textSync('ThinkNCollab', {
-            font: 'Standard',
-            horizontalLayout: 'default',
-            verticalLayout: 'default'
-        })));
-        
+        try {
+            const figlet = require('figlet');
+            console.log(chalk.cyan(figlet.textSync('ThinkNCollab', { font: 'Standard' })));
+        } catch {}
         console.log(chalk.cyan(`
 ╔══════════════════════════════════════════════════════╗
-║     ThinkNCollab Shell v1.0.0                        ║
+║     ThinkNCollab Shell v0.0.02                        ║
 ║     Type 'help' for commands                          ║
-╚══════════════════════════════════════════════════════╝
-        `));
-    }
-    
-    /**
-     * Command completer
-     */
-    completer(line) {
-        const commands = Array.from(this.commands.keys());
-        const aliases = Array.from(this.aliases.keys());
-        const all = [...commands, ...aliases];
-        
-        const hits = all.filter(cmd => cmd.startsWith(line));
-        return [hits.length ? hits : all, line];
-    }
-    
-    /**
-     * Handle interrupt (Ctrl+C)
-     */
-    handleInterrupt() {
-        if (this.isTyping) {
-            this.isTyping = false;
-            this.ws.sendTyping(false);
-            clearTimeout(this.typingTimeout);
-        }
-        
-        console.log(chalk.yellow('\nUse "exit" to quit, or press Ctrl+C again'));
+╚══════════════════════════════════════════════════════╝`));
     }
-    
-    /**
-     * Load command history
-     */
+
     loadHistory() {
         try {
-            if (fs.existsSync(this.config.historyFile)) {
-                const data = fs.readFileSync(this.config.historyFile, 'utf8');
-                this.history = data.split('\n').filter(line => line.trim());
-            }
-        } catch (error) {
-            // Ignore
-        }
+            if (fs.existsSync(this.config.historyFile))
+                this.history = fs.readFileSync(this.config.historyFile, 'utf8').split('\n').filter(l => l.trim());
+        } catch {}
     }
-    
-    /**
-     * Save command history
-     */
+
     saveHistory() {
-        try {
-            const toSave = this.history.slice(-this.config.maxHistory);
-            fs.writeFileSync(this.config.historyFile, toSave.join('\n'));
-        } catch (error) {
-            // Ignore
-        }
+        try { fs.writeFileSync(this.config.historyFile, this.history.slice(-this.config.maxHistory).join('\n')); } catch {}
     }
-    
-    /**
-     * Cleanup before exit
-     */
+
     cleanup() {
-        if (this.ws) {
-            this.ws.disconnect();
-        }
+        if (this.tcpServer) { try { this.tcpServer.close(); } catch {} }
+        if (this.ws) this.ws.disconnect();
         this.saveHistory();
     }
 }