thinkncollab-shell 0.0.18 → 0.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkncollab-shell",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "ThinkNCollab Custom Shell with WebSocket collaboration",
   "main": "src/core/shell.js",
   "bin": {
@@ -20,7 +20,7 @@
     "collaboration",
     "cli"
   ],
-  "author": "ThinkNCollab",
+  "author": "Raman Singh <raman@thinkncollab.com>",
   "license": "MIT",
   "dependencies": {
     "@inquirer/prompts": "^2.3.1",

package/src/core/websocket.js

@@ -316,8 +316,183 @@ class WebSocketManager extends EventEmitter {
         };
 
         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) {