thinkncollab-shell 0.0.5 → 0.0.7

package/src/commands/terminal/share.js

@@ -0,0 +1,252 @@
+/**
+ * commands/terminal/share.js
+ *
+ * Usage:
+ *   share start       — start sharing current terminal
+ *   share stop        — stop sharing
+ *   share status      — show who's viewing / requesting
+ *   share grant <uid> — grant write to a viewer
+ *   share revoke <uid>— revoke write
+ *   share kick <uid>  — kick a viewer
+ */
+
+const chalk = require('chalk');
+
+module.exports = {
+    name:         'share',
+    description:  'Share your terminal with room members',
+    aliases:      ['terminal-share', 'ts'],
+    requiresAuth: true,
+    requiresRoom: true,
+
+    async execute(args, shell) {
+        const sub = (args[0] || '').toLowerCase();
+
+        switch (sub) {
+            case 'start':  return cmdStart(shell);
+            case 'stop':   return cmdStop(shell);
+            case 'status': return cmdStatus(shell);
+            case 'grant':  return cmdGrant(args[1], shell);
+            case 'revoke': return cmdRevoke(args[1], shell);
+            case 'kick':   return cmdKick(args[1], shell);
+            default:
+                printHelp();
+        }
+    }
+};
+
+// ── start ─────────────────────────────────────────────────────────────────────
+async function cmdStart(shell) {
+    if (shell._shareActive) {
+        console.log(chalk.yellow('⚠️  Already sharing. Run "share stop" first.'));
+        return;
+    }
+
+    const roomId = shell.ws.getCurrentRoom();
+    if (!roomId) {
+        console.log(chalk.red('❌ Join a room first: join <room-id>'));
+        return;
+    }
+
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            shell.ws.socket.off('terminal:share:started', onStarted);
+            console.log(chalk.red('❌ Share start timeout'));
+            resolve();
+        }, 6000);
+
+        function onStarted(data) {
+            clearTimeout(timeout);
+            shell._shareActive    = true;
+            shell._shareSessionId = data.sessionId;
+
+            console.log(chalk.green(`\n✅ Terminal sharing started`));
+            console.log(chalk.dim(`   Session : ${data.sessionId}`));
+            console.log(chalk.dim(`   Room    : ${roomId}`));
+            console.log(chalk.dim(`   URL     : /terminal/${data.sessionId}`));
+            console.log(chalk.dim(`\n   Room members can now view your terminal.`));
+            console.log(chalk.dim(`   Use "share grant <userId>" to give write access.\n`));
+
+            // Hook into shell output to stream it
+            _hookOutput(shell, data.sessionId);
+
+            resolve();
+        }
+
+        shell.ws.socket.once('terminal:share:started', onStarted);
+        shell.ws.socket.emit('terminal:share:start', { roomId });
+    });
+}
+
+// ── stop ──────────────────────────────────────────────────────────────────────
+async function cmdStop(shell) {
+    if (!shell._shareActive) {
+        console.log(chalk.yellow('⚠️  No active share session.'));
+        return;
+    }
+
+    shell.ws.socket.emit('terminal:share:stop');
+    _unhookOutput(shell);
+    shell._shareActive    = false;
+    shell._shareSessionId = null;
+    console.log(chalk.green('✅ Terminal sharing stopped.'));
+}
+
+// ── status ────────────────────────────────────────────────────────────────────
+async function cmdStatus(shell) {
+    if (!shell._shareActive || !shell._shareSessionId) {
+        console.log(chalk.yellow('// No active share session'));
+        return;
+    }
+
+    const mem = shell._shareViewers || {};
+    const viewers = Object.values(mem);
+
+    console.log(chalk.cyan(`\n  Terminal Share — ${shell._shareSessionId}`));
+    console.log(chalk.dim('  ' + '─'.repeat(44)));
+
+    if (!viewers.length) {
+        console.log(chalk.dim('  No viewers yet.'));
+    } else {
+        viewers.forEach(v => {
+            const access = v.canWrite ? chalk.blue('[write]') : chalk.dim('[read]');
+            const req    = v.requested ? chalk.yellow(' ← requesting write') : '';
+            console.log(`  ${chalk.green('●')} ${chalk.white(v.name)} ${access}${req}`);
+            console.log(chalk.dim(`    userId: ${v.userId}`));
+        });
+    }
+    console.log();
+}
+
+// ── grant ─────────────────────────────────────────────────────────────────────
+async function cmdGrant(userId, shell) {
+    if (!userId) { console.log(chalk.red('Usage: share grant <userId>')); return; }
+    if (!shell._shareActive) { console.log(chalk.red('❌ No active share session')); return; }
+
+    shell.ws.socket.emit('terminal:grant', {
+        sessionId: shell._shareSessionId,
+        userId,
+    });
+
+    // Update local viewer state
+    if (shell._shareViewers?.[userId]) {
+        shell._shareViewers[userId].canWrite  = true;
+        shell._shareViewers[userId].requested = false;
+    }
+
+    console.log(chalk.green(`✅ Write access granted to ${userId}`));
+}
+
+// ── revoke ────────────────────────────────────────────────────────────────────
+async function cmdRevoke(userId, shell) {
+    if (!userId) { console.log(chalk.red('Usage: share revoke <userId>')); return; }
+    if (!shell._shareActive) { console.log(chalk.red('❌ No active share session')); return; }
+
+    shell.ws.socket.emit('terminal:revoke', {
+        sessionId: shell._shareSessionId,
+        userId,
+    });
+
+    if (shell._shareViewers?.[userId]) {
+        shell._shareViewers[userId].canWrite = false;
+    }
+
+    console.log(chalk.green(`✅ Write access revoked from ${userId}`));
+}
+
+// ── kick ──────────────────────────────────────────────────────────────────────
+async function cmdKick(userId, shell) {
+    if (!userId) { console.log(chalk.red('Usage: share kick <userId>')); return; }
+    if (!shell._shareActive) { console.log(chalk.red('❌ No active share session')); return; }
+
+    shell.ws.socket.emit('terminal:kick', {
+        sessionId: shell._shareSessionId,
+        userId,
+    });
+
+    if (shell._shareViewers) delete shell._shareViewers[userId];
+    console.log(chalk.green(`✅ ${userId} kicked from session`));
+}
+
+// ── Output hooking ────────────────────────────────────────────────────────────
+// Intercept process.stdout.write to stream output to viewers
+
+let _originalWrite = null;
+
+function _hookOutput(shell, sessionId) {
+    shell._shareViewers = {};
+    _originalWrite = process.stdout.write.bind(process.stdout);
+
+    // Remove any existing listeners to prevent duplicates on re-share
+    shell.ws.socket.off('terminal:viewerJoined');
+    shell.ws.socket.off('terminal:viewerLeft');
+    shell.ws.socket.off('terminal:writeRequest');
+    shell.ws.socket.off('terminal:input');
+
+    process.stdout.write = function(chunk, encoding, callback) {
+        const str = chunk.toString();
+        // Send to viewers — stream everything including ANSI colors
+        if (shell.ws.isConnected() && shell._shareActive) {
+            shell.ws.socket.emit('terminal:output', {
+                sessionId,
+                data: str,
+            });
+        }
+        // Still write to own terminal
+        return _originalWrite(chunk, encoding, callback);
+    };
+
+    // Listen for viewer events
+    shell.ws.socket.on('terminal:viewerJoined', (d) => {
+        if (!shell._shareViewers) shell._shareViewers = {};
+        shell._shareViewers[d.userId] = { userId: d.userId, name: d.name, canWrite: false, requested: false };
+        console.log(chalk.dim(`\n  👁️  ${d.name} is now viewing your terminal`));
+    });
+
+    shell.ws.socket.on('terminal:viewerLeft', (d) => {
+        if (shell._shareViewers) delete shell._shareViewers[d.userId];
+        console.log(chalk.dim(`\n  👁️  ${d.name} stopped viewing`));
+    });
+
+    shell.ws.socket.on('terminal:writeRequest', (d) => {
+        if (shell._shareViewers?.[d.userId]) shell._shareViewers[d.userId].requested = true;
+        console.log(chalk.yellow(`\n  ✍️  ${d.name} is requesting write access`));
+        console.log(chalk.dim(`     share grant ${d.userId}   or   share kick ${d.userId}\n`));
+    });
+
+    shell.ws.socket.on('terminal:input', (d) => {
+        // A writer sent input — execute it in the shell
+        console.log(chalk.blue(`\n  [${d.fromName}] → ${d.input}`));
+        // The shell will process this as if the user typed it
+        shell.execute(d.input.trim());
+    });
+}
+
+function _unhookOutput(shell) {
+    if (_originalWrite) {
+        process.stdout.write = _originalWrite;
+        _originalWrite = null;
+    }
+    shell.ws.socket.off('terminal:viewerJoined');
+    shell.ws.socket.off('terminal:viewerLeft');
+    shell.ws.socket.off('terminal:writeRequest');
+    shell.ws.socket.off('terminal:input');
+}
+
+// ── Help ──────────────────────────────────────────────────────────────────────
+function printHelp() {
+    console.log(chalk.cyan('\n  Terminal Share Commands'));
+    console.log(chalk.dim('  ' + '─'.repeat(40)));
+    const rows = [
+        ['share start',          'Start sharing your terminal'],
+        ['share stop',           'Stop sharing'],
+        ['share status',         'Show viewers and write requests'],
+        ['share grant <userId>', 'Give write access to a viewer'],
+        ['share revoke <userId>','Revoke write access'],
+        ['share kick <userId>',  'Remove a viewer'],
+    ];
+    rows.forEach(([cmd, desc]) => {
+        console.log(`  ${chalk.green(cmd.padEnd(26))} ${chalk.dim(desc)}`);
+    });
+    console.log();
+}

package/src/core/api-client.js

@@ -1,6 +1,5 @@
 /**
- * ThinkNCollab API Client
- * Handles HTTP requests to the backend
+ * src/core/api-client.js
  */
 
 const https = require('https');
@@ -12,22 +11,19 @@ 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.apiUrl      = (options.apiUrl || 'http://localhost:3001').replace(/\/$/, '');
+        this.wsUrl       = (options.wsUrl  || 'http://localhost:3001').replace(/\/$/, '');
+        this.session     = null;
         this.sessionPath = path.join(os.homedir(), '.thinkncollab', 'session.json');
-
-        // Load existing session on startup
         this._loadSession();
     }
 
-    // ─── Session management ───────────────────────────────────────────────────
+    // ─── Session ──────────────────────────────────────────────────────────────
 
     _loadSession() {
         try {
-            if (fs.existsSync(this.sessionPath)) {
+            if (fs.existsSync(this.sessionPath))
                 this.session = fs.readJsonSync(this.sessionPath);
-            }
         } catch {}
     }
 
@@ -40,33 +36,40 @@ class ThinkNCollabAPI {
     }
 
     _clearSession() {
-        try {
-            fs.removeSync(this.sessionPath);
-            this.session = null;
-        } catch {}
-    }
-
-    isAuthenticated() {
-        return !!(this.session?.token);
+        try { fs.removeSync(this.sessionPath); } catch {}
+        this.session = null;
     }
 
-    getToken() {
-        return this.session?.token || null;
-    }
+    isAuthenticated() { return !!(this.session?.token); }
+    getToken()        { return this.session?.token || null; }
 
+    /**
+     * Returns user in a CONSISTENT shape used everywhere:
+     *   { _id, userId, email, name, userType }
+     *
+     * Both _id and userId are the same string so callers can use either.
+     */
     getUser() {
-        return this.session?.user || null;
+        const u = this.session?.user;
+        if (!u) return null;
+        const id = (u._id || u.userId || '').toString();
+        return {
+            _id:      id,
+            userId:   id,           // ws.setUser / _emitJoin use userId
+            email:    u.email  || '',
+            name:     u.name   || '',
+            userType: u.userType || u.model || 'User',
+        };
     }
 
     // ─── 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 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,
@@ -74,8 +77,9 @@ class ThinkNCollabAPI {
                 path:     url.pathname + url.search,
                 method,
                 headers: {
-                    'Content-Type':  'application/json',
-                    'Accept':        'application/json',
+                    'Content-Type': 'application/json',
+                    'Accept':       'application/json',
+                    ...(this.session?.token ? { 'x-shell-token': this.session.token } : {}),
                     ...headers,
                     ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr) } : {})
                 }
@@ -87,23 +91,21 @@ class ThinkNCollabAPI {
                 res.on('end', () => {
                     try {
                         const parsed = JSON.parse(data);
-                        if (res.statusCode >= 400) {
+                        if (res.statusCode >= 400)
                             reject(new Error(parsed.error || parsed.message || `HTTP ${res.statusCode}`));
-                        } else {
+                        else
                             resolve(parsed);
-                        }
                     } catch {
-                        reject(new Error(`Invalid response: ${data}`));
+                        reject(new Error(`Invalid response: ${data.slice(0, 100)}`));
                     }
                 });
             });
 
             req.on('error', (err) => {
-                if (err.code === 'ECONNREFUSED') {
+                if (err.code === 'ECONNREFUSED')
                     reject(new Error(`Cannot connect to server at ${this.apiUrl} — is it running?`));
-                } else {
+                else
                     reject(err);
-                }
             });
 
             if (bodyStr) req.write(bodyStr);
@@ -111,46 +113,134 @@ class ThinkNCollabAPI {
         });
     }
 
-    // ─── Auth API ─────────────────────────────────────────────────────────────
+    // ─── Auth ─────────────────────────────────────────────────────────────────
+
+async login(email, password) {
+    const result = await this._request('POST', '/thinknsh/login', null, {
+        'x-email':      email,
+        'x-password':   password,
+        'x-machine-id': os.hostname()
+    });
+
+    this._saveSession({
+        token:          result.shellToken,
+        shellSessionId: result.shellSessionId,  // ✅ add karo
+        user: {
+            _id:      result._id,
+            userId:   result._id,
+            email:    result.email,
+            name:     result.name,
+            userType: result.userType || result.model || 'User',
+        },
+        timestamp: new Date().toISOString()
+    });
+
+    return {
+        token: result.shellToken,
+        user:  this.getUser()
+    };
+}
 
-    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()
-        });
+// ─── Session event logger ─────────────────────────────────────────────────
 
-        // Save session
-        this._saveSession({
-            token: result.shellToken,
-            user: {
-                _id:   result._id,
-                email: result.email,
-                name:  result.name,
-            },
-            timestamp: new Date().toISOString()
-        });
+async logEvent(type, roomId = null, meta = {}) {
+    const sessionId = this.session?.shellSessionId;
+    if (!sessionId) return;
+    await this._request('POST', '/thinknsh/session/event', {
+        sessionId, type, roomId, meta
+    }).catch(() => {}); // silently fail — never block shell
+}
 
-        return {
-            token: result.shellToken,
-            user: {
-                _id:   result._id,
-                email: result.email,
-                name:  result.name,
-            }
-        };
-    }
+// ─── Heartbeat — keeps lastSeenAt fresh while shell is open ──────────────
+
+startHeartbeat(intervalMs = 60000) {
+    if (this._heartbeatTimer) return; // already running
+    this._heartbeatTimer = setInterval(() => {
+        const sessionId = this.session?.shellSessionId;
+        if (!sessionId) return;
+        this._request('POST', '/thinknsh/session/event', {
+            sessionId,
+            type: 'heartbeat',
+            meta: { ts: new Date().toISOString() }
+        }).catch(() => {});
+    }, intervalMs);
+}
 
-    async logout() {
-        this._clearSession();
-        return { success: true };
+stopHeartbeat() {
+    if (this._heartbeatTimer) {
+        clearInterval(this._heartbeatTimer);
+        this._heartbeatTimer = null;
     }
+}
 
+async logout() {
+    const sessionId = this.session?.shellSessionId;
+    if (sessionId) {
+        await this._request('POST', '/thinknsh/session/end', { sessionId }).catch(() => {});
+    }
+    this.stopHeartbeat();
+    this._clearSession();
+    return { success: true };
+}
     async whoami() {
         if (!this.isAuthenticated()) throw new Error('Not logged in');
         return this.getUser();
     }
+
+    // ─── Rooms ────────────────────────────────────────────────────────────────
+
+    /**
+     * joinRoom — validates membership server-side and returns room meta.
+     * Called by commands/room/join.js BEFORE the WebSocket thinknsh:join emit.
+     */
+    async joinRoom(roomId, password) {
+        if (!roomId) throw new Error('roomId is required');
+
+        const result = await this._request('POST', `/thinknsh/rooms/${roomId}/join`,
+            password ? { password } : null
+        );
+
+        // Normalise response — server may return different shapes
+        return {
+            room: result.room || result,
+            participants: result.participants || result.members || [],
+            recentMessages: result.recentMessages || result.history || [],
+        };
+    }
+
+    /**
+     * getRooms — list rooms the user belongs to
+     */
+    async getRooms() {
+        return this._request('GET', '/thinknsh/rooms');
+    }
+
+    // ─── Tasks ────────────────────────────────────────────────────────────────
+
+    async mytasks(roomId, limit) {
+        if (!roomId) throw new Error('roomId is required');
+        const user = this.getUser();
+        let ep = `/thinknsh/tasks?roomId=${encodeURIComponent(roomId)}`;
+        if (user?._id) ep += `&userId=${encodeURIComponent(user._id)}`;
+        if (limit)     ep += `&n=${limit}`;
+        return this._request('GET', ep);
+    }
+
+    /**
+     * Generic request wrapper for task command modules that call
+     * shell.api.request(method, path, { params, body })
+     */
+    async request(method, endpoint, options = {}) {
+        let ep = endpoint;
+
+        // Append query params
+        if (options.params && Object.keys(options.params).length) {
+            const qs = new URLSearchParams(options.params).toString();
+            ep += (ep.includes('?') ? '&' : '?') + qs;
+        }
+
+        return this._request(method.toUpperCase(), ep, options.body || null);
+    }
 }
 
 module.exports = ThinkNCollabAPI;

package/src/core/notification-window.js

@@ -93,7 +93,7 @@ function connect() {
     let buffer   = '';
 
     client.connect(PORT, HOST, () => {
-        console.log(chalk.green('  ✅ Connected to shell!\n'));
+        console.log(chalk.green('   Connected to shell!\n'));
     });
 
     client.on('data', (chunk) => {

package/src/core/project-config.js

@@ -0,0 +1,100 @@
+/**
+ * src/core/project-config.js
+ *
+ * Shell-side reader for .tncproject binary files.
+ * NO crypto code — shell only reads the plaintext roomId prefix,
+ * then sends the raw file to the server for decryption.
+ *
+ * File layout (written by server):
+ *   [4  bytes] "TNCP" magic
+ *   [1  byte]  version 0x01
+ *   [24 bytes] roomId ASCII hex  ← only readable part
+ *   [12 bytes] AES-GCM IV        ← opaque
+ *   [16 bytes] AES-GCM auth tag  ← opaque
+ *   [N  bytes] encrypted payload ← opaque
+ */
+
+const fs   = require('fs-extra');
+const path = require('path');
+const os   = require('os');
+
+const CONFIG_FILE  = 'tncproject';
+const MAGIC        = Buffer.from('TNCP');
+const ROOM_ID_SIZE = 24;
+const MIN_SIZE     = 4 + 1 + ROOM_ID_SIZE + 12 + 16 + 2;  // 59 bytes minimum
+
+function findConfigFile(startDir = process.cwd()) {
+    let dir    = path.resolve(startDir);
+    const root = path.parse(dir).root;
+
+    while (true) {
+        const candidate = path.join(dir, CONFIG_FILE);
+        if (fs.existsSync(candidate)) return candidate;
+        if (dir === root || dir === os.homedir()) break;
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+
+/**
+ * Read and lightly validate a .tncproject file.
+ * Returns { filePath, roomId, fileBase64 } — no decryption.
+ *
+ * @throws if file is missing, wrong format, or roomId looks wrong
+ */
+function loadProjectConfig(startDir = process.cwd()) {
+    const filePath = findConfigFile(startDir);
+
+    if (!filePath) {
+        throw new Error(
+            'No .tncproject file found in this directory or any parent.\n' +
+            '  Download it from: ThinkNCollab → Room → Project Config'
+        );
+    }
+
+    const buf = fs.readFileSync(filePath);
+
+    if (buf.length < MIN_SIZE) {
+        throw new Error(
+            'Invalid .tncproject — file too small or corrupted.\n' +
+            '  Re-download it from the dashboard.'
+        );
+    }
+
+    if (!buf.slice(0, 4).equals(MAGIC)) {
+        throw new Error(
+            'Not a ThinkNCollab project config file.\n' +
+            '  Re-download from the dashboard.'
+        );
+    }
+
+    const version = buf.readUInt8(4);
+    if (version !== 0x01) {
+        throw new Error(
+            `Unsupported .tncproject version (${version}).\n` +
+            '  Update thinkncollab-shell: npm update -g thinkncollab-shell'
+        );
+    }
+
+    // Read roomId from plaintext prefix — bytes 5..28
+    const roomId = buf.slice(5, 5 + ROOM_ID_SIZE).toString('ascii').trim();
+
+    if (!/^[a-f0-9]{24}$/i.test(roomId)) {
+        throw new Error(
+            'Corrupted .tncproject — invalid roomId.\n' +
+            '  Re-download it from the dashboard.'
+        );
+    }
+
+    return {
+        filePath,
+        roomId,
+        fileBase64: buf.toString('base64'),   // sent as-is to server
+    };
+}
+
+function hasProjectConfig(startDir = process.cwd()) {
+    return !!findConfigFile(startDir);
+}
+
+module.exports = { loadProjectConfig, hasProjectConfig, CONFIG_FILE };