thinkncollab-shell 0.0.1 → 0.0.3

package/src/commands/team/myteam.js

@@ -0,0 +1,78 @@
+/**
+ * MyTeam Command
+ * 
+ * Usage: myteam
+ *        myteam [team-id]
+ */
+
+const chalk = require('chalk');
+const Table = require('cli-table3');
+
+module.exports = {
+    name: 'myteam',
+    description: 'Show team information and members',
+    aliases: ['team', 'org'],
+    requiresAuth: true,
+    
+    async execute(args, shell) {
+        const teamId = args[0] || shell.api.getUser()?.team;
+        
+        if (!teamId) {
+            console.log(chalk.yellow('⚠️  You are not part of any team'));
+            console.log(chalk.dim('💡 Ask your team admin for an invite'));
+            return;
+        }
+        
+        console.log(chalk.cyan(`\n👥 Team Information: ${teamId}`));
+        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        
+        try {
+            const teamInfo = await shell.api.getTeamInfo(teamId);
+            
+            // Team details
+            console.log(`  ${chalk.yellow('Name:')}        ${teamInfo.name}`);
+            console.log(`  ${chalk.yellow('Members:')}     ${teamInfo.memberCount}`);
+            console.log(`  ${chalk.yellow('Rooms:')}       ${teamInfo.roomCount}`);
+            console.log(`  ${chalk.yellow('Created:')}     ${new Date(teamInfo.createdAt).toLocaleDateString()}`);
+            
+            if (teamInfo.description) {
+                console.log(`  ${chalk.yellow('Description:')} ${teamInfo.description}`);
+            }
+            
+            console.log();
+            
+            // Team members table
+            const table = new Table({
+                head: ['Status', 'Name', 'Email', 'Role', 'Current Room'],
+                colWidths: [8, 20, 25, 12, 20]
+            });
+            
+            teamInfo.members.forEach(member => {
+                const status = member.online ? chalk.green('●') : chalk.gray('○');
+                const room = member.currentRoom || '-';
+                table.push([
+                    status,
+                    member.name || member.email.split('@')[0],
+                    member.email,
+                    member.role || 'member',
+                    room
+                ]);
+            });
+            
+            console.log(table.toString());
+            console.log();
+            
+            // Team activity
+            if (teamInfo.recentActivity && teamInfo.recentActivity.length > 0) {
+                console.log(chalk.cyan('📊 Recent Activity:'));
+                teamInfo.recentActivity.slice(0, 5).forEach(activity => {
+                    const time = new Date(activity.timestamp).toLocaleTimeString();
+                    console.log(chalk.dim(`  [${time}] ${activity.user}: ${activity.action}`));
+                });
+            }
+            
+        } catch (error) {
+            console.log(chalk.red(`❌ Failed to fetch team info: ${error.message}`));
+        }
+    }
+};

package/src/commands/team/teammates.js

@@ -0,0 +1,52 @@
+/**
+ * Teammates Command
+ * 
+ * Usage: teammates
+ *        teammates [name]
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name: 'teammates',
+    description: 'List online teammates',
+    aliases: ['members', 'online'],
+    requiresAuth: true,
+    
+    async execute(args, shell) {
+        const filter = args[0] ? args[0].toLowerCase() : null;
+        
+        console.log(chalk.cyan('\n👥 Online Teammates:'));
+        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        
+        try {
+            const teammates = await shell.api.getTeammates();
+            
+            const online = teammates.filter(t => t.online);
+            const offline = teammates.filter(t => !t.online);
+            
+            if (online.length === 0) {
+                console.log(chalk.yellow('  No teammates online'));
+            } else {
+                online
+                    .filter(t => !filter || t.name.toLowerCase().includes(filter) || t.email.toLowerCase().includes(filter))
+                    .forEach(t => {
+                        const typing = t.typing ? chalk.green(' (typing...)') : '';
+                        const room = t.currentRoom ? chalk.dim(` in ${t.currentRoom}`) : '';
+                        console.log(`  ${chalk.green('●')} ${chalk.white(t.name || t.email)}${typing}${room}`);
+                        
+                        if (t.status && t.status !== 'online') {
+                            console.log(chalk.dim(`    ${t.status}`));
+                        }
+                    });
+            }
+            
+            if (offline.length > 0 && !filter) {
+                console.log(chalk.dim(`\n  ... and ${offline.length} offline`));
+            }
+            
+        } catch (error) {
+            console.log(chalk.red(`❌ Failed to fetch teammates: ${error.message}`));
+        }
+    }
+};

package/src/core/api-client.js

@@ -0,0 +1,156 @@
+/**
+ * ThinkNCollab API Client
+ * Handles HTTP requests to the backend
+ */
+
+const https = require('https');
+const http  = require('http');
+const path  = require('path');
+const fs    = require('fs-extra');
+const os    = require('os');
+
+class ThinkNCollabAPI {
+
+    constructor(options = {}) {
+        this.apiUrl   = (options.apiUrl || 'https://thinkncollab.com').replace(/\/$/, '');
+        this.wsUrl    = (options.wsUrl  || 'https://thinkncollab.com').replace(/\/$/, '');
+        this.session  = null;
+        this.sessionPath = path.join(os.homedir(), '.thinkncollab', 'session.json');
+
+        // Load existing session on startup
+        this._loadSession();
+    }
+
+    // ─── Session management ───────────────────────────────────────────────────
+
+    _loadSession() {
+        try {
+            if (fs.existsSync(this.sessionPath)) {
+                this.session = fs.readJsonSync(this.sessionPath);
+            }
+        } catch {}
+    }
+
+    _saveSession(session) {
+        try {
+            fs.ensureDirSync(path.dirname(this.sessionPath));
+            fs.writeJsonSync(this.sessionPath, session);
+            this.session = session;
+        } catch {}
+    }
+
+    _clearSession() {
+        try {
+            fs.removeSync(this.sessionPath);
+            this.session = null;
+        } catch {}
+    }
+
+    isAuthenticated() {
+        return !!(this.session?.token);
+    }
+
+    getToken() {
+        return this.session?.token || null;
+    }
+
+    getUser() {
+        return this.session?.user || null;
+    }
+
+    // ─── HTTP helper ──────────────────────────────────────────────────────────
+
+    _request(method, endpoint, body = null, headers = {}) {
+        return new Promise((resolve, reject) => {
+            const url      = new URL(this.apiUrl + endpoint);
+            const isHttps  = url.protocol === 'https:';
+            const lib      = isHttps ? https : http;
+
+            const bodyStr  = body ? JSON.stringify(body) : null;
+
+            const options = {
+                hostname: url.hostname,
+                port:     url.port || (isHttps ? 443 : 80),
+                path:     url.pathname + url.search,
+                method,
+                headers: {
+                    'Content-Type':  'application/json',
+                    'Accept':        'application/json',
+                    ...headers,
+                    ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr) } : {})
+                }
+            };
+
+            const req = lib.request(options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (res.statusCode >= 400) {
+                            reject(new Error(parsed.error || parsed.message || `HTTP ${res.statusCode}`));
+                        } else {
+                            resolve(parsed);
+                        }
+                    } catch {
+                        reject(new Error(`Invalid response: ${data}`));
+                    }
+                });
+            });
+
+            req.on('error', (err) => {
+                if (err.code === 'ECONNREFUSED') {
+                    reject(new Error(`Cannot connect to server at ${this.apiUrl} — is it running?`));
+                } else {
+                    reject(err);
+                }
+            });
+
+            if (bodyStr) req.write(bodyStr);
+            req.end();
+        });
+    }
+
+    // ─── Auth API ─────────────────────────────────────────────────────────────
+
+    async login(email, password) {
+        // Your backend reads from headers
+        const result = await this._request('POST', '/thinknsh/login', null, {
+            'x-email':    email,
+            'x-password': password,
+            'x-machine-id': require('os').hostname()
+        });
+
+        // Save session
+        this._saveSession({
+            token: result.shellToken,
+            user: {
+                _id:   result._id,
+                email: result.email,
+                name:  result.name,
+            },
+            timestamp: new Date().toISOString()
+        });
+
+        return {
+            token: result.shellToken,
+            user: {
+                _id:   result._id,
+                email: result.email,
+                name:  result.name,
+            }
+        };
+    }
+
+    async logout() {
+        this._clearSession();
+        return { success: true };
+    }
+
+    async whoami() {
+        if (!this.isAuthenticated()) throw new Error('Not logged in');
+        return this.getUser();
+    }
+}
+
+module.exports = ThinkNCollabAPI;

package/src/core/notification-window.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * ThinkNCollab — Notification Window
+ * Spawned automatically by the main shell as a separate terminal process.
+ * Connects to the main shell via TCP and displays live notifications.
+ */
+
+const net   = require('net');
+const chalk = require('chalk');
+
+const PORT = parseInt(process.env.THINKNSH_NOTIFY_PORT || '7379');
+const HOST = '127.0.0.1';
+
+// ── UI ────────────────────────────────────────────────────────────────────────
+
+function clearScreen() { process.stdout.write('\x1Bc'); }
+
+function drawHeader() {
+    const width = process.stdout.columns || 80;
+    const title = ' 🔔 ThinkNCollab — Live Notifications ';
+    const line  = '━'.repeat(width);
+    console.log(chalk.cyan(line));
+    console.log(chalk.cyan.bold(title.padStart(Math.floor((width + title.length) / 2))));
+    console.log(chalk.cyan(line));
+    console.log(chalk.dim(`  Port: ${PORT}  |  Notifications will appear here in real time.`));
+    console.log(chalk.dim('  Close this window or press Ctrl+C to stop.\n'));
+}
+
+function beep() {
+    // Terminal bell — works on Windows CMD, macOS Terminal, Linux
+    process.stdout.write('\x07');
+}
+
+function printNotification(data) {
+    const timestamp = new Date().toLocaleTimeString();
+    const ts        = chalk.dim(`[${timestamp}]`);
+
+    switch (data.type) {
+        case 'task_assigned':
+            beep();
+            console.log(`${ts} 📋 ${chalk.yellow('Task assigned →')} ${chalk.white(data.taskTitle)} ${chalk.dim('by')} ${chalk.cyan(data.assignedBy)}`);
+            break;
+        case 'task_started':
+            console.log(`${ts} ⚡ ${chalk.green(data.userName)} started working on ${chalk.white(data.taskTitle)}`);
+            break;
+        case 'task_completed':
+            beep();
+            console.log(`${ts} ✅ ${chalk.green(data.userName)} completed ${chalk.white(data.taskTitle)}`);
+            break;
+        case 'message':
+            beep();
+            console.log(`${ts} 💬 ${chalk.cyan(data.from)}: ${data.text}`);
+            break;
+        case 'userJoined':
+            console.log(`${ts} 👤 ${chalk.green(data.username)} joined`);
+            break;
+        case 'userLeft':
+            console.log(`${ts} 👤 ${chalk.yellow(data.username)} left`);
+            break;
+        case 'connected':
+            console.log(`${ts} ${chalk.green('✅ Shell connected')}`);
+            break;
+        case 'disconnected':
+            console.log(`${ts} ${chalk.yellow('⚠️  Shell disconnected')}`);
+            break;
+        case 'notification': {
+            beep();
+            const colors = { success: chalk.green, warning: chalk.yellow, error: chalk.red, info: chalk.blue };
+            const color  = colors[data.level] || chalk.blue;
+            console.log(`${ts} 📢 ${color(`${data.title}: ${data.message}`)}`);
+            break;
+        }
+        case 'typing':
+            process.stdout.write(`\r${chalk.dim(`✏️  ${data.username} is typing...    `)}`);
+            break;
+        case 'stoppedTyping':
+            process.stdout.write('\r' + ' '.repeat(40) + '\r');
+            break;
+        default:
+            console.log(`${ts} ${chalk.white(JSON.stringify(data))}`);
+    }
+}
+
+// ── TCP Client ────────────────────────────────────────────────────────────────
+
+function connect() {
+    clearScreen();
+    drawHeader();
+    console.log(chalk.dim(`  Connecting to shell on port ${PORT}...`));
+
+    const client = new net.Socket();
+    let buffer   = '';
+
+    client.connect(PORT, HOST, () => {
+        console.log(chalk.green('  ✅ Connected to shell!\n'));
+    });
+
+    client.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop(); 
+
+        lines.forEach(line => {
+            if (!line.trim()) return;
+            try {
+                const data = JSON.parse(line);
+                printNotification(data);
+            } catch {
+                console.log(chalk.dim(line));
+            }
+        });
+    });
+
+    client.on('close', () => {
+        console.log(chalk.yellow('\n  Shell disconnected. Retrying in 3s...'));
+        setTimeout(connect, 3000);
+    });
+
+    client.on('error', (err) => {
+        if (err.code === 'ECONNREFUSED') {
+            console.log(chalk.dim(`  Waiting for shell on port ${PORT}...`));
+        } else {
+            console.log(chalk.dim(`  Connection error: ${err.message}`));
+        }
+        setTimeout(connect, 3000);
+    });
+}
+
+// ── Ctrl+C ────────────────────────────────────────────────────────────────────
+process.on('SIGINT', () => {
+    console.log(chalk.yellow('\n  Notification window closed.'));
+    process.exit(0);
+});
+
+connect();