thinkncollab-shell 0.0.20 → 2.0.0-beta.1.1

package/src/core/websocket.js

@@ -1,657 +0,0 @@
-/*
-  src/core/websocket.js — WebSocket Manager for ThinkNCollab Shell
- */
-
-const { io }   = require('socket.io-client');
-const EventEmitter = require('events');
-
-class WebSocketManager extends EventEmitter {
-
-    constructor(config = {}) {
-        super();
-        this.config = {
-            serverUrl:         config.serverUrl         || 'https://thinkncollab.com',
-            reconnectAttempts: config.reconnectAttempts || 5,
-            reconnectDelay:    config.reconnectDelay    || 1000,
-            ...config
-        };
-
-        this.socket         = null;
-        this.connected      = false;
-        this.currentUser    = null;   // always { userId, name, userType }
-        this.roomId         = null;
-        this.reconnectCount = 0;
-        this.messageQueue   = [];
-        this._authToken     = null;
-        this._handlersSetup = false;
-        this._serverReady   = false;
-        this._shellRef      = config._shellRef || null;  // ref to Shell instance for api access
-    }
-
-    // ─── Connect ──────────────────────────────────────────────────────────────
-
-    connect(authToken = null) {
-        return new Promise((resolve, reject) => {
-            try {
-                if (authToken) this._authToken = authToken;
-
-                this.socket = io(this.config.serverUrl + '/thinknsh', {
-                    transports:           ['websocket', 'polling'],
-                    reconnection:         true,
-                    reconnectionAttempts: this.config.reconnectAttempts,
-                    reconnectionDelay:    this.config.reconnectDelay,
-                    auth: this._authToken ? { token: this._authToken } : {},
-                });
-
-                const timeout = setTimeout(() => {
-                    reject(new Error('Connection timeout'));
-                }, 10000);
-
-                this.socket.on('connect', () => {
-                    clearTimeout(timeout);
-                    this.connected      = true;
-                    this.reconnectCount = 0;
-
-                    // Announce user immediately on connect if we have one
-                    if (this.currentUser) {
-                        this._announceUser();
-                    }
-
-                    this.processPendingMessages();
-                    this.emit('connected', { socketId: this.socket.id });
-                    resolve({ success: true, socketId: this.socket.id });
-                });
-
-                this.socket.on('connect_error', (error) => {
-                    clearTimeout(timeout);
-                    if (this.reconnectCount === 0) {
-                        reject(new Error(`Cannot connect to ${this.config.serverUrl}`));
-                    }
-                    this.reconnectCount++;
-                    this.emit('error', { message: error.message });
-                });
-
-                this.socket.on('disconnect', (reason) => {
-                    this.connected = false;
-                    this.emit('disconnected', { reason });
-                });
-                this.socket.on('task:verdict', (data) => {
-                    this.emit('task:verdict', data);
-                });
-
-                // Triggered by TNC server when user clicks "run test" on browser (production)
-                // CLI reads .tnc/workflows/*.yml from process.cwd() (client's project dir) and runs it locally
-                this.socket.on('task:run-local', async (data) => {
-                    try {
-                        const chalk        = require('chalk');
-                        const { runLocal } = require('./local-runner');
-                        const taskId       = data.taskId;
-                        const shellRef     = this._shellRef;
-                        const api          = shellRef ? shellRef.api : null;
-
-                        if (!api) {
-                            console.log(chalk.red('\n❌ CLI not authenticated. Run: login\n'));
-                            return;
-                        }
-
-                        // Fetch task info (webhookSecret) from TNC API
-                        let task;
-                        try {
-                            task = await api._request('GET', `/thinknsh/${taskId}/cli`);
-                        } catch (e) {
-                            console.log(chalk.red(`\n❌ Could not fetch task info: ${e.message}\n`));
-                            return;
-                        }
-
-                        if (!task || !task.webhookSecret) {
-                            console.log(chalk.red('\n❌ Task has no webhookSecret — cannot submit result.\n'));
-                            return;
-                        }
-
-                        await runLocal({
-                            taskId,
-                            webhookSecret: task.webhookSecret,
-                            apiUrl:        this.config.serverUrl || 'https://thinkncollab.com',
-                            // Pass repo info from TNC task — runner will clone this exact repo
-                            repoUrl:       task.repoUrl      || task.githubUrl || task.repo_url || null,
-                            repoBranch:    task.branch       || task.repoBranch || 'main',
-                            workflowFile:  task.workflowFile || task.workflow   || null,
-                            chalk,
-                            shell: shellRef,
-                            onLog: (logData) => {
-                                // Emit log stream to server via the terminal socket
-                                this.socket.emit('task:log', {
-                                    taskId,
-                                    boardId: task.boardId,
-                                    ...logData
-                                });
-                            }
-                        });
-
-                    } catch (err) {
-                        console.error('task:run-local error:', err.message);
-                    }
-                });
-
-                this.socket.on('reconnect', () => {
-                    this.connected = true;
-                    this.emit('reconnected', {});
-
-                    if (this.currentUser) this._announceUser();
-                    if (this.roomId && this.currentUser) this._emitJoin(this.roomId);
-                });
-
-                if (!this._handlersSetup) {
-                    this.setupEventHandlers();
-                    this._handlersSetup = true;
-                }
-
-            } catch (error) {
-                reject(error);
-            }
-        });
-    }
-
-    // ─── Announce user to server (thinknsh:connected) ─────────────────────────
-
-    _announceUser() {
-        if (!this.socket || !this.currentUser) return;
-        this.socket.emit('thinknsh:connected', {
-            userId:     this.currentUser.userId,
-            userName:   this.currentUser.name,
-            shellToken: this._authToken,
-        });
-    }
-
-    // ─── Set user — called right after login ──────────────────────────────────
-
-    /**
-     * Accepts any of these shapes and normalises to { userId, name, userType }:
-     *   { _id, userId, name, email, userType }   ← from api-client.getUser()
-     *   { userId, name, userType }                ← legacy
-     */
-    setUser(user, token = null) {
-        this._user = user;
-        if (!user) return;
-
-        if (token) this._authToken = token;
-
-        // Normalise — support both _id and userId
-        const id = (user.userId || user._id || '').toString();
-        this.currentUser = {
-            userId:   id,
-            name:     user.name  || user.email || 'Unknown',
-            userType: user.userType || user.model || user.role || 'User',
-        };
-
-        // If already connected, announce immediately
-        if (this.connected && this.socket) {
-            this._announceUser();
-        }
-    }
-
-    // ─── Event Handlers ───────────────────────────────────────────────────────
-
-    setupEventHandlers() {
-
-        this.socket.on('thinknsh:ready', (data) => {
-            this._serverReady = true;
-            this.emit('ready', data);
-        });
-
-        this.socket.on('thinknsh:joined', (data) => {
-            this.roomId = data.roomId;
-            if (data.history?.length) this.emit('messageHistory', data.history);
-            this.emit('roomJoined', data);
-        });
-
-        this.socket.on('thinknsh:message', (data) => {
-            this.emit('message', {
-                username:  data.name,
-                userId:    data.userId,
-                message:   data.message,
-                source:    'shell',
-                timestamp: data.timestamp,
-            });
-        });
-
-        this.socket.on('chat-message', (data) => {
-            this.emit('message', {
-                username:  data.name,
-                userId:    data.userId,
-                message:   data.message,
-                source:    data.source || 'web',
-                timestamp: data.timestamp,
-            });
-        });
-
-        this.socket.on('thinknsh:userJoined', (data) => {
-            this.emit('userJoined', { username: data.name, source: 'shell' });
-        });
-
-        this.socket.on('thinknsh:userLeft', (data) => {
-            this.emit('userLeft', { username: data.name, source: 'shell' });
-        });
-
-        this.socket.on('user-joined', (name) => {
-            this.emit('userJoined', { username: name, source: 'web' });
-        });
-
-        this.socket.on('user-left', (name) => {
-            this.emit('userLeft', { username: name, source: 'web' });
-        });
-
-        this.socket.on('user-list', (users) => {
-            this.emit('userList', { users });
-        });
-
-        this.socket.on('thinknsh:history', (data) => {
-            this.emit('messageHistory', data.messages?.length ? data.messages : []);
-        });
-
-        this.socket.on('new-notification', (data) => {
-            this.emit('notification', {
-                type:       data.type    || 'info',
-                level:      data.type    || 'info',
-                title:      data.title   || 'Notification',
-                message:    data.message || '',
-                meta:       data.meta    || {},
-                taskTitle:  data.taskTitle  || data.meta?.taskTitle  || '',
-                assignedBy: data.assignedBy || data.meta?.assignedBy || '',
-            });
-        });
-
-        this.socket.on('room:activity', (data) => {
-            this.emit('roomActivity', data);
-        });
-
-        this.socket.on('thinknsh:status', (data) => {
-            this.emit('shellStatus', data);
-        });
-
-        this.socket.on('thinknsh:notifications', (data) => {
-            this.emit('notificationList', data.notifications);
-        });
-
-        // Server errors — emit as 'serverError' so shell.js can handle separately
-        this.socket.on('thinknsh:error', (data) => {
-            this.emit('serverError', data);
-        });
-
-        this.socket.on('error', (data) => {
-            this.emit('serverError', data);
-        });
-
-        // Triggered by TNC server when user clicks "Run in Browser" or triggers CI/CD pipeline
-        const activeRunIds = new Set();
-        const handleCicdRun = async (data) => {
-            if (!data || !data.runId) return;
-            if (activeRunIds.has(data.runId)) return;
-            activeRunIds.add(data.runId);
-
-            try {
-                const chalk        = require('chalk');
-                const { runCicdLocal } = require('./local-runner');
-                const shellRef     = this._shellRef;
-                const api          = shellRef ? shellRef.api : null;
-                
-                console.log(chalk.cyan(`\n🚀 [thinkncollab-shell] CI/CD execution request received for room: ${data.roomId || this.roomId}`));
-
-                await runCicdLocal({
-                    runId: data.runId,
-                    roomId: data.roomId || this.roomId,
-                    workflowFile: data.workflowFile || 'universal-polyglot-ci.yml',
-                    workflowYaml: data.workflowYaml || '',
-                    localPath: data.localPath || '',
-                    apiUrl: api ? api.baseURL : this.config.serverUrl,
-                    chalk,
-                    api,
-                    socket: this.socket
-                });
-            } catch (err) {
-                console.error('\n❌ Error in CI/CD local execution:', err);
-            } finally {
-                setTimeout(() => activeRunIds.delete(data.runId), 30000);
-            }
-        };
-
-        this.socket.on('cicd:run-dispatch', handleCicdRun);
-
-        // ── Task Test Dispatch — async local execution ────────────────────────
-        // Server sends this when GitHub webhook fires and assigned user's shell is active,
-        // OR when user connects and there are waiting_for_shell TestRuns queued.
-        // Test runs fully async using spawn — never blocks the shell.
-        const activeTestRunIds = new Set();
-
-        const handleTestDispatch = async (data) => {
-            if (!data || !data.runId || !data.taskId) return;
-            if (activeTestRunIds.has(data.runId)) return;
-            activeTestRunIds.add(data.runId);
-
-            try {
-                const chalk    = require('chalk');
-                const { spawn } = require('child_process');
-                const http     = require('http');
-                const https    = require('https');
-                const crypto   = require('crypto');
-
-                const encryptPayload = (dataObj, keySecret) => {
-                    if (!keySecret) return null;
-                    const key = crypto.createHash('sha256').update(keySecret).digest();
-                    const iv  = crypto.randomBytes(12);
-                    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-                    const json   = JSON.stringify(dataObj || {});
-                    const encrypted = Buffer.concat([cipher.update(json, 'utf8'), cipher.final()]);
-                    const tag    = cipher.getAuthTag();
-                    return { iv: iv.toString('hex'), tag: tag.toString('hex'), cipherText: encrypted.toString('hex') };
-                };
-
-                const decryptPayload = (encryptedObj, keySecret) => {
-                    if (!encryptedObj || !encryptedObj.cipherText || !encryptedObj.iv || !encryptedObj.tag) return null;
-                    try {
-                        const key = crypto.createHash('sha256').update(keySecret).digest();
-                        const iv  = Buffer.from(encryptedObj.iv, 'hex');
-                        const tag = Buffer.from(encryptedObj.tag, 'hex');
-                        const encryptedText = Buffer.from(encryptedObj.cipherText, 'hex');
-                        const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
-                        decipher.setAuthTag(tag);
-                        const decrypted = Buffer.concat([decipher.update(encryptedText), decipher.final()]);
-                        return JSON.parse(decrypted.toString('utf8'));
-                    } catch (_) { return null; }
-                };
-
-                const { runId, taskId, runResultToken, encryptedPayload } = data;
-                let testConfig = data.testConfig;
-                let commit     = data.commit;
-                let taskTitle  = data.taskTitle;
-
-                // Decrypt payload using AES-256-GCM if encrypted
-                if (encryptedPayload && runResultToken) {
-                    const decrypted = decryptPayload(encryptedPayload, runResultToken);
-                    if (decrypted) {
-                        testConfig = decrypted.testConfig || testConfig;
-                        commit     = decrypted.commit || commit;
-                        taskTitle  = decrypted.taskTitle || taskTitle;
-                    }
-                }
-
-                console.log(chalk.cyan(`\n🧪 [TNC TestRunner - AES-256-GCM Secure] Task: "${taskTitle}"`));
-                console.log(chalk.gray(`   Run ID  : ${runId}`));
-                console.log(chalk.gray(`   Type    : ${testConfig?.type}`));
-                console.log(chalk.gray(`   Commit  : ${commit?.sha?.slice(0, 7) || 'N/A'} — ${commit?.message || ''}`));
-
-                let result = { exitCode: 1, stdout: '', stderr: '', status: null, body: null, url: null };
-
-                if (testConfig.type === 'exitCode' || testConfig.type === 'stdout' || testConfig.type === 'regex') {
-                    // ── Async shell command via spawn ─────────────────────────
-                    const command = testConfig.command || testConfig.script;
-                    if (!command) {
-                        result.stderr = 'No command specified in testConfig';
-                    } else {
-                        console.log(chalk.yellow(`   Running : ${command}`));
-                        result = await new Promise((resolve) => {
-                            const proc = spawn(command, [], {
-                                shell:   true,
-                                cwd:     process.cwd(),
-                                timeout: 60000
-                            });
-
-                            let stdout = '';
-                            let stderr = '';
-
-                            proc.stdout.on('data', (chunk) => {
-                                stdout += chunk.toString();
-                                process.stdout.write(chalk.gray('   │ ') + chunk.toString());
-                            });
-                            proc.stderr.on('data', (chunk) => {
-                                stderr += chunk.toString();
-                                process.stderr.write(chalk.red('   │ ') + chunk.toString());
-                            });
-
-                            proc.on('close', (code) => {
-                                resolve({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim(), status: null, body: null, url: null });
-                            });
-
-                            proc.on('error', (err) => {
-                                resolve({ exitCode: 1, stdout: '', stderr: err.message, status: null, body: null, url: null });
-                            });
-                        });
-                        console.log(result.exitCode === 0
-                            ? chalk.green(`   ✅ Exit 0`)
-                            : chalk.red(`   ❌ Exit ${result.exitCode} — ${result.stderr.slice(0, 100)}`));
-                    }
-
-                } else if (testConfig.type === 'http') {
-                    // ── Async HTTP test ───────────────────────────────────────
-                    const endpoint = testConfig.endpoint || testConfig.url;
-                    const method   = (testConfig.method || 'GET').toUpperCase();
-                    console.log(chalk.yellow(`   Hitting : ${method} ${endpoint}`));
-
-                    result = await new Promise((resolve) => {
-                        const lib = endpoint?.startsWith('https') ? https : http;
-                        const url = new URL(endpoint);
-                        const options = { hostname: url.hostname, port: url.port || (url.protocol === 'https:' ? 443 : 80), path: url.pathname + url.search, method };
-
-                        const req = lib.request(options, (res) => {
-                            let body = '';
-                            res.on('data', chunk => body += chunk.toString());
-                            res.on('end', () => {
-                                let parsed = body;
-                                try { parsed = JSON.parse(body); } catch (_) {}
-                                console.log(chalk.green(`   ✅ HTTP ${res.statusCode}`));
-                                resolve({ exitCode: 0, stdout: body.slice(0, 500), stderr: '', status: res.statusCode, body: parsed, url: endpoint });
-                            });
-                        });
-
-                        req.on('error', (err) => {
-                            console.log(chalk.red(`   ❌ HTTP error: ${err.message}`));
-                            resolve({ exitCode: 1, stdout: '', stderr: err.message, status: null, body: null, url: endpoint });
-                        });
-
-                        req.setTimeout(15000, () => {
-                            req.destroy();
-                            resolve({ exitCode: 1, stdout: '', stderr: 'Request timeout (15s)', status: null, body: null, url: endpoint });
-                        });
-
-                        req.end();
-                    });
-
-                } else {
-                    // ── Fallback: run testConfig.command if available ─────────
-                    const command = testConfig.command || testConfig.script;
-                    if (command) {
-                        result = await new Promise((resolve) => {
-                            const proc = spawn(command, [], { shell: true, cwd: process.cwd(), timeout: 60000 });
-                            let stdout = '', stderr = '';
-                            proc.stdout.on('data', c => stdout += c.toString());
-                            proc.stderr.on('data', c => stderr += c.toString());
-                            proc.on('close', code => resolve({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim(), status: null, body: null, url: null }));
-                            proc.on('error', err  => resolve({ exitCode: 1, stdout: '', stderr: err.message, status: null, body: null, url: null }));
-                        });
-                    } else {
-                        result.stderr = `Unsupported testConfig type: ${testConfig.type}`;
-                    }
-                }
-
-                // ── AES-256-GCM Encrypt result back to server ─────────────────
-                const encryptedResult = runResultToken ? encryptPayload(result, runResultToken) : null;
-                const resultPayload   = { runId, taskId, runResultToken, encryptedResult, ...result };
-
-                // Primary: via socket (instant, zero overhead)
-                this.socket.emit('thinknsh:test-result', resultPayload);
-                console.log(chalk.cyan(`   🔒 [AES-256-GCM] Encrypted result dispatched to TNC server.\n`));
-
-            } catch (err) {
-                console.error('thinknsh:test-dispatch error:', err.message);
-            } finally {
-                // Clean up after 60s so same runId can be retried if needed
-                setTimeout(() => activeTestRunIds.delete(data.runId), 60000);
-            }
-        };
-
-        this.socket.on('thinknsh:test-dispatch', handleTestDispatch);
-    }
-
-
-    // ─── Join room ────────────────────────────────────────────────────────────
-
-    joinRoom(roomId) {
-        return new Promise((resolve, reject) => {
-            if (!this.connected || !this.socket)
-                return reject(new Error('Not connected to server'));
-            if (!this.currentUser)
-                return reject(new Error('Not logged in — run: login'));
-
-            const timeout = setTimeout(() => {
-                this.socket.off('thinknsh:joined', onJoined);
-                this.socket.off('thinknsh:error',  onError);
-                this.socket.off('thinknsh:ready',  onReady);
-                reject(new Error('Join timeout'));
-            }, 8000);
-
-            const onJoined = (data) => {
-                clearTimeout(timeout);
-                this.socket.off('thinknsh:error', onError);
-                this.roomId = data.roomId;
-                resolve(data);
-            };
-
-            // onReady declared at top so onError can reference it regardless of branch
-            let onReady = null;
-
-            const onError = (data) => {
-                clearTimeout(timeout);
-                this.socket.off('thinknsh:joined', onJoined);
-                if (onReady) this.socket.off('thinknsh:ready', onReady);
-                reject(new Error(data.message || 'Join error'));
-            };
-
-            const doJoin = () => {
-                this.socket.once('thinknsh:joined', onJoined);
-                this.socket.once('thinknsh:error',  onError);
-                this._emitJoin(roomId);
-            };
-
-            if (this._serverReady) {
-                doJoin();
-            } else {
-                onReady = () => {
-                    this._serverReady = true;
-                    doJoin();
-                };
-                this.socket.once('thinknsh:ready', onReady);
-            }
-        });
-    }
-
-    _emitJoin(roomId) {
-        if (!this.socket || !this.currentUser) return;
-        this.socket.emit('thinknsh:join', {
-            roomId,
-            userId:   this.currentUser.userId,
-            name:     this.currentUser.name,
-            userType: this.currentUser.userType,
-        });
-    }
-
-    // ─── Leave room ───────────────────────────────────────────────────────────
-
-    leaveRoom() {
-        if (this.socket && this.roomId) {
-            this.socket.emit('leave-room', { roomId: this.roomId });
-            this.roomId = null;
-        }
-        return Promise.resolve({ success: true });
-    }
-
- sendMessage(message, replyTo = null) {
-    return new Promise((resolve, reject) => {
-        if (!this.socket?.connected) return reject(new Error('Not connected'));
-
-        const roomId = this.roomId;
-        if (!roomId) return reject(new Error('Not in any room. Use: join <room-id>'));
-
-        if (!this.currentUser) return reject(new Error('Not authenticated. Run: login'));
-
-        this.socket.emit('thinknsh:message', {
-            roomId,
-            userId:   this.currentUser.userId,
-            name:     this.currentUser.name,
-            userType: this.currentUser.userType || 'User',
-            message,
-            replyTo:  replyTo || null
-        });
-
-        resolve();
-    });
-}
-    // ─── History ──────────────────────────────────────────────────────────────
-
-    getHistory(limit = 30, skip = 0) {
-        if (!this.connected || !this.socket || !this.roomId) return;
-        this.socket.emit('thinknsh:getHistory', { roomId: this.roomId, limit, skip });
-    }
-
-    // ─── Notifications ────────────────────────────────────────────────────────
-
-    getNotifications() {
-        if (!this.connected || !this.currentUser) return;
-        this.socket.emit('thinknsh:getNotifications', { userId: this.currentUser.userId });
-    }
-
-    sendNotification(notification, target = 'room') {
-        if (!this.connected || !this.socket)
-            return Promise.reject(new Error('Not connected'));
-
-        this.socket.emit('notification:send', {
-            type:      notification.type    || 'info',
-            title:     notification.title   || 'Notification',
-            message:   notification.message,
-            data:      notification.data    || {},
-            target:    target === 'room' ? this.roomId : target,
-            timestamp: new Date().toISOString()
-        });
-
-        return Promise.resolve({ success: true });
-    }
-
-    markNotificationsRead(notificationIds = []) {
-        if (!this.connected || !this.currentUser) return;
-        this.socket.emit('thinknsh:markRead', {
-            userId: this.currentUser.userId,
-            notificationIds,
-        });
-    }
-
-    // ─── Helpers ──────────────────────────────────────────────────────────────
-
-    processPendingMessages() {
-        if (this.messageQueue.length && this.roomId && this.currentUser) {
-            this.messageQueue.forEach(msg => this.sendMessage(msg));
-            this.messageQueue = [];
-        }
-    }
-
-    disconnect() {
-        if (this.socket) {
-            this.socket.removeAllListeners();
-            this.socket.disconnect();
-            this.socket         = null;
-            this.connected      = false;
-            this.currentUser    = null;
-            this.roomId         = null;
-            this._handlersSetup = false;
-        this._serverReady   = false;
-            this._serverReady   = false;
-        }
-    }
-
-    isConnected()    { return this.connected && !!this.socket?.connected; }
-    getCurrentRoom() { return this.roomId; }
-    getSocketId()    { return this.socket?.id || null; }
-    getParticipants(){ return Promise.resolve([]); }
-    sendTyping()     {}
-    ping()           { if (this.connected && this.socket) this.socket.emit('ping'); }
-}
-
-module.exports = WebSocketManager;