thinkncollab-shell 0.0.12 → 0.0.14

package/src/commands/tasks/complete.js

@@ -2,6 +2,8 @@
 
 const chalk  = require('chalk');
 const crypto = require('crypto');
+const cp     = require('child_process');
+const path   = require('path');
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -381,46 +383,177 @@ async function runBrowserTest(testConfig, testUser, boardAuth = {}) {
   }
 }
 
+// Helper to run a local command and capture exitCode & stdout/stderr
+function runLocalCommand(command) {
+  return new Promise((resolve) => {
+    cp.exec(command, (error, stdout, stderr) => {
+      const exitCode = error ? (error.code || 1) : 0;
+      resolve({
+        exitCode,
+        stdout: stdout.toString(),
+        stderr: stderr.toString()
+      });
+    });
+  });
+}
+
 // ─── Local Judge ──────────────────────────────────────────────────────────────
 function judgeLocally(testConfig, result) {
-  const { type, expect } = testConfig;
+  const { type, value, condition, expect } = testConfig;
   const failures = [];
 
-  if (type === 'http') {
-    if (expect?.status !== undefined && result.status !== expect.status)
-      failures.push(`Status: expected ${expect.status}, got ${result.status}`);
-
-    if (expect?.body) {
-      for (const [key, condition] of Object.entries(expect.body)) {
-        const actual = getNestedValue(result.body, key);
-        if      (condition?.exists && (actual === undefined || actual === null))
-          failures.push(`body.${key}: expected to exist`);
-        else if (condition?.eq !== undefined && actual !== condition.eq)
-          failures.push(`body.${key}: expected "${condition.eq}", got "${actual}"`);
-        else if (condition?.contains !== undefined && !String(actual).includes(String(condition.contains)))
-          failures.push(`body.${key}: expected to contain "${condition.contains}"`);
+  try {
+    switch (type) {
+      case 'exitCode': {
+        const passed = result.exitCode === value;
+        return {
+          passed,
+          reason: passed
+            ? `Exit code matched: ${value}`
+            : `Expected exit code ${value}, got ${result.exitCode}`
+        };
+      }
+
+      case 'stdout': {
+        const actualOut = (result.stdout || '').trim();
+        const expectedOut = (value || '').trim();
+        const passed = actualOut === expectedOut;
+        return {
+          passed,
+          reason: passed ? `Output matched` : `Output mismatch`,
+          diff: passed ? undefined : { expected: expectedOut, actual: actualOut }
+        };
       }
+
+      case 'regex': {
+        const pattern = new RegExp(value);
+        const target = result.stdout || result.output || '';
+        const passed = pattern.test(target);
+        return {
+          passed,
+          reason: passed ? `Regex matched: ${value}` : `Regex did not match: ${value}`
+        };
+      }
+
+      case 'http': {
+        if (expect?.status !== undefined && result.status !== expect.status) {
+          failures.push(`Status: expected ${expect.status}, got ${result.status}`);
+        }
+        if (expect?.body) {
+          for (const [key, condition] of Object.entries(expect.body)) {
+            const actualVal = getNestedValue(result.body || {}, key);
+            if (condition?.exists) {
+              if (actualVal === undefined || actualVal === null)
+                failures.push(`body.${key}: expected to exist`);
+            } else if (condition?.eq !== undefined) {
+              if (actualVal !== condition.eq)
+                failures.push(`body.${key}: expected "${condition.eq}", got "${actualVal}"`);
+            } else if (condition?.contains !== undefined) {
+              if (!String(actualVal).includes(String(condition.contains)))
+                failures.push(`body.${key}: expected to contain "${condition.contains}"`);
+            }
+          }
+        }
+        break;
+      }
+
+      case 'json': {
+        const actualData = result.output || result.json || {};
+        if (condition) {
+          return judgeWithConditions(condition, actualData);
+        } else {
+          const passed = JSON.stringify(value) === JSON.stringify(actualData);
+          return {
+            passed,
+            reason: passed ? `JSON matched` : `JSON mismatch`,
+            diff: passed ? undefined : { expected: value, actual: actualData }
+          };
+        }
+      }
+      case 'loadtest':
+      case 'geekload': {
+        const actualData = result.output || result.json || {};
+        const cond = condition || expect?.condition || expect || {};
+        return judgeWithConditions(cond, actualData);
+      }
+
+      case 'browser': {
+        if (expect?.element && !result.elementExists) {
+          failures.push(`Element "${expect.element}" not found on page`);
+        }
+        if (expect?.text && result.elementText) {
+          if (!result.elementText.includes(expect.text))
+            failures.push(`Element text: expected to contain "${expect.text}", got "${result.elementText}"`);
+        }
+        if (expect?.redirectUrl) {
+          try {
+            const actualPath = new URL(result.url).pathname;
+            if (!actualPath.includes(expect.redirectUrl))
+              failures.push(`URL: expected "${expect.redirectUrl}", got "${actualPath}"`);
+          } catch {
+            failures.push(`Invalid URL in result: "${result.url}"`);
+          }
+        }
+        break;
+      }
+
+      case 'tnc-build': {
+        const passed = result.exitCode === 0;
+        return {
+          passed,
+          reason: passed ? 'TNC Local CI pipeline passed' : 'TNC Local CI pipeline failed'
+        };
+      }
+
+      default:
+        return { passed: false, reason: `Unknown test type: ${type}` };
     }
+
+    return {
+      passed: failures.length === 0,
+      reason: failures.length === 0 ? 'All checks passed' : failures.join(' | '),
+      failures,
+    };
+  } catch (err) {
+    return { passed: false, reason: `Judge error: ${err.message}` };
   }
+}
 
-  if (type === 'browser') {
-    if (expect?.element && !result.elementExists)
-      failures.push(`Element "${expect.element}" not found on page`);
+function judgeWithConditions(conditions, actual) {
+  const failures = [];
 
-    if (expect?.text && result.elementText && !result.elementText.includes(expect.text))
-      failures.push(`Element text: expected "${expect.text}", got "${result.elementText}"`);
+  for (const [key, ops] of Object.entries(conditions)) {
+    const actualVal = actual[key];
 
-    if (expect?.redirectUrl) {
-      const actualPath = new URL(result.url).pathname;
-      if (!actualPath.includes(expect.redirectUrl))
-        failures.push(`URL: expected "${expect.redirectUrl}", got "${actualPath}"`);
+    if (actualVal === undefined) {
+      failures.push(`Missing key: "${key}"`);
+      continue;
+    }
+
+    for (const [op, expected] of Object.entries(ops)) {
+      let pass = false;
+      switch (op) {
+        case 'gte':     pass = actualVal >= expected; break;
+        case 'lte':     pass = actualVal <= expected; break;
+        case 'gt':      pass = actualVal > expected;  break;
+        case 'lt':      pass = actualVal < expected;  break;
+        case 'eq':      pass = actualVal === expected; break;
+        case 'contains': pass = String(actualVal).includes(String(expected)); break;
+        case 'regex':   pass = new RegExp(expected).test(String(actualVal)); break;
+        default:        pass = false;
+      }
+      if (!pass) {
+        failures.push(`"${key}" failed: ${actualVal} ${op} ${expected}`);
+      }
     }
   }
 
   return {
-    passed:  failures.length === 0,
-    reason:  failures.length === 0 ? 'All checks passed' : failures.join(' | '),
-    failures,
+    passed: failures.length === 0,
+    reason: failures.length === 0
+      ? `All conditions passed`
+      : `Failed conditions: ${failures.join('; ')}`,
+    diff: failures.length > 0 ? { conditions, actual } : undefined
   };
 }
 
@@ -525,6 +658,246 @@ const authConfig = { ...boardAuth, ...(testConfig.auth || {}) };
         if (result.elementText)
           console.log(chalk.dim(`  → Text   : "${result.elementText.trim().slice(0, 60)}"`));
 
+      } else if (testConfig.type === 'exitCode' || testConfig.type === 'stdout' || testConfig.type === 'regex') {
+        const cmd = testConfig.command || testConfig.script;
+        if (!cmd) {
+          throw new Error(`testConfig type "${testConfig.type}" requires a "command" or "script" to execute.`);
+        }
+        console.log(chalk.dim(`  → Executing local command: "${cmd}"`));
+        const runRes = await runLocalCommand(cmd);
+        result = {
+          exitCode: runRes.exitCode,
+          stdout: runRes.stdout,
+          stderr: runRes.stderr
+        };
+        console.log(chalk.dim(`  → Exit Code: ${result.exitCode}`));
+        if (result.stdout) console.log(chalk.dim(`  → Stdout   : ${result.stdout.trim().slice(0, 80)}`));
+
+      } else if (testConfig.type === 'json') {
+        const cmd = testConfig.command || testConfig.script;
+        if (cmd) {
+          console.log(chalk.dim(`  → Executing local command: "${cmd}"`));
+          const runRes = await runLocalCommand(cmd);
+          let parsedJson = {};
+          try {
+            parsedJson = JSON.parse(runRes.stdout.trim());
+          } catch (e) {
+            throw new Error(`Command executed but stdout was not valid JSON: ${runRes.stdout}`);
+          }
+          result = {
+            exitCode: runRes.exitCode,
+            stdout: runRes.stdout,
+            stderr: runRes.stderr,
+            json: parsedJson,
+            output: parsedJson
+          };
+        } else {
+          throw new Error('testConfig type "json" requires a "command" or "script" to output JSON.');
+        }
+
+      } else if (testConfig.type === 'loadtest' || testConfig.type === 'geekload') {
+        const script = testConfig.script || testConfig.command;
+        if (!script) {
+          throw new Error(`testConfig type "${testConfig.type}" requires a "script" or "command" specifying the load test script path.`);
+        }
+        const scriptPath = path.resolve(process.cwd(), script);
+        console.log(chalk.dim(`  → Running GeekLoad test script: ${script}`));
+        const { runLoadTest } = require('../../core/geekload');
+        const loadtestResult = await runLoadTest(scriptPath);
+
+        const Table = require('cli-table3');
+        const table = new Table({
+          head: [chalk.cyan('Metric'), chalk.cyan('Value')],
+          colWidths: [25, 20]
+        });
+        table.push(
+          ['Virtual Users', loadtestResult.virtual_users],
+          ['Duration (sec)', loadtestResult.duration_sec],
+          ['Total Requests', loadtestResult.total_requests],
+          ['Failed Requests', loadtestResult.failed_requests],
+          ['Failure Rate', `${(loadtestResult.failure_rate * 100).toFixed(2)}%`],
+          ['p95 Latency (ms)', loadtestResult.p95_latency_ms]
+        );
+        console.log('\n' + table.toString() + '\n');
+
+        result = {
+          exitCode: loadtestResult.failed_requests > 0 ? 1 : 0,
+          output: loadtestResult,
+          json: loadtestResult
+        };
+
+      } else if (testConfig.type === 'tnc-build') {
+        const fs = require('fs');
+        const path = require('path');
+        const { spawn } = require('child_process');
+
+        const projectRoot = process.cwd();
+        const workflowsDir = path.join(projectRoot, '.tnc/workflows');
+
+        if (!fs.existsSync(workflowsDir)) {
+          throw new Error('No .tnc/workflows directory found in project root.');
+        }
+
+        const files = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+        if (files.length === 0) {
+          throw new Error('No workflow files found in .tnc/workflows/');
+        }
+
+        const workflowFile = files[0];
+        console.log(chalk.dim(`  → Found workflow file: ${workflowFile}`));
+        const content = fs.readFileSync(path.join(workflowsDir, workflowFile), 'utf8');
+
+        // Parse steps
+        const lines = content.split('\n');
+        let workflowName = workflowFile;
+        let steps = [];
+        let currentStepName = '';
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i].trim();
+          if (line.startsWith('name:')) {
+            workflowName = line.substring(5).trim().replace(/['"]/g, '');
+            continue;
+          }
+          if (line.startsWith('-')) {
+            const cleaned = line.substring(1).trim();
+            if (cleaned.startsWith('name:')) {
+              currentStepName = cleaned.substring(5).trim().replace(/['"]/g, '');
+            } else if (cleaned.startsWith('run:')) {
+              let runCmd = cleaned.substring(4).trim();
+              if ((runCmd.startsWith('"') && runCmd.endsWith('"')) || (runCmd.startsWith("'") && runCmd.endsWith("'"))) {
+                runCmd = runCmd.substring(1, runCmd.length - 1);
+              }
+              if (runCmd === '|') {
+                let block = [];
+                let j = i + 1;
+                while (j < lines.length) {
+                  const next = lines[j];
+                  const match = next.match(/^(\s+)(.*)/);
+                  if (match && match[1].length > 4) {
+                    block.push(next.trim());
+                    j++;
+                  } else {
+                    break;
+                  }
+                }
+                runCmd = block.join('\n');
+                i = j - 1;
+              }
+              steps.push({
+                name: currentStepName || `run: ${runCmd.substring(0, 30)}`,
+                run: runCmd
+              });
+              currentStepName = '';
+            }
+          } else if (line.startsWith('name:')) {
+            currentStepName = line.substring(5).trim().replace(/['"]/g, '');
+          } else if (line.startsWith('run:')) {
+            let runCmd = line.substring(4).trim();
+            if ((runCmd.startsWith('"') && runCmd.endsWith('"')) || (runCmd.startsWith("'") && runCmd.endsWith("'"))) {
+              runCmd = runCmd.substring(1, runCmd.length - 1);
+            }
+            if (runCmd === '|') {
+              let block = [];
+              let j = i + 1;
+              while (j < lines.length) {
+                const next = lines[j];
+                const match = next.match(/^(\s+)(.*)/);
+                if (match && match[1].length > 4) {
+                  block.push(next.trim());
+                  j++;
+                } else {
+                  break;
+                }
+              }
+              runCmd = block.join('\n');
+              i = j - 1;
+            }
+            steps.push({
+              name: currentStepName || `run: ${runCmd.substring(0, 30)}`,
+              run: runCmd
+            });
+            currentStepName = '';
+          }
+        }
+
+        if (steps.length === 0) {
+          throw new Error('No steps found in the workflow file.');
+        }
+
+        console.log(chalk.cyan(`\n🚀 [TNC Actions] Starting Local Workflow: "${workflowName}"\n`));
+
+        const stepResults = [];
+        let overallPassed = true;
+        let logsBuffer = '';
+
+        for (let s = 0; s < steps.length; s++) {
+          const step = steps[s];
+          console.log(chalk.cyan(`⚙️ [Step ${s+1}/${steps.length}] "${step.name}"`));
+          console.log(chalk.gray(`$ ${step.run}`));
+
+          // Run command shell execution
+          const exitCode = await new Promise((resolve) => {
+            const shellCmd = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+            const shellArgs = process.platform === 'win32' ? ['/s', '/c', step.run] : ['-c', step.run];
+            
+            const proc = spawn(shellCmd, shellArgs, {
+              cwd: projectRoot,
+              env: { ...process.env, PATH: process.env.PATH, PUPPETEER_SKIP_DOWNLOAD: 'true' }
+            });
+
+            proc.stdout.on('data', (chunk) => {
+              const chunkStr = chunk.toString();
+              process.stdout.write(chunkStr);
+              logsBuffer += chunkStr;
+            });
+
+            proc.stderr.on('data', (chunk) => {
+              const chunkStr = chunk.toString();
+              process.stderr.write(chalk.red(chunkStr));
+              logsBuffer += chunkStr;
+            });
+
+            proc.on('close', (code) => {
+              resolve(code);
+            });
+          });
+
+          const stepPassed = (exitCode === 0);
+          stepResults.push({
+            name: step.name,
+            command: step.run,
+            exitCode,
+            passed: stepPassed
+          });
+
+          if (!stepPassed) {
+            overallPassed = false;
+            console.log(chalk.red(`\n❌ Step "${step.name}" failed with exit code: ${exitCode}. Aborting.\n`));
+            break;
+          } else {
+            console.log(chalk.green(`\n✅ Step "${step.name}" passed successfully.\n`));
+          }
+        }
+
+        result = {
+          exitCode: overallPassed ? 0 : 1,
+          stdout: logsBuffer,
+          stderr: '',
+          output: {
+            workflow: workflowName,
+            status: overallPassed ? 'passed' : 'failed',
+            stepsCount: steps.length,
+            stepsRun: stepResults
+          },
+          json: {
+            workflow: workflowName,
+            status: overallPassed ? 'passed' : 'failed',
+            stepsCount: steps.length,
+            stepsRun: stepResults
+          }
+        };
+
       } else {
         console.log(chalk.red(`❌ Unsupported test type: ${testConfig.type}`));
         return;

package/src/commands/tasks/loadtest.js

@@ -0,0 +1,73 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const { runLoadTest } = require('../../core/geekload');
+const Table = require('cli-table3');
+
+module.exports = {
+  name: 'loadtest',
+  description: 'Run a local load test script using GeekLoad',
+  aliases: ['geekload'],
+  requiresAuth: false,
+
+  async execute(args, shell) {
+    if (!args[0]) {
+      console.log(chalk.red('Usage: loadtest <script-path>'));
+      return;
+    }
+
+    const scriptPath = path.resolve(process.cwd(), args[0]);
+    if (!fs.existsSync(scriptPath)) {
+      console.log(chalk.red(`❌ Script not found: ${args[0]}`));
+      return;
+    }
+
+    console.log(chalk.cyan(`\n📋 Loading test script: ${args[0]}`));
+
+    try {
+      const results = await runLoadTest(scriptPath);
+
+      const table = new Table({
+        head: [chalk.green('Metric'), chalk.green('Value')],
+        colWidths: [25, 20]
+      });
+
+      table.push(
+        ['Virtual Users', results.virtual_users],
+        ['Duration (sec)', results.duration_sec],
+        ['Total Requests', results.total_requests],
+        ['Failed Requests', results.failed_requests],
+        ['Requests/sec (RPS)', results.requests_per_sec],
+        ['Failure Rate', `${(results.failure_rate * 100).toFixed(2)}%`],
+        ['Average Latency (ms)', results.avg_latency_ms],
+        ['p95 Latency (ms)', results.p95_latency_ms],
+        ['p99 Latency (ms)', results.p99_latency_ms]
+      );
+
+      console.log(table.toString());
+
+      if (results.failures.length > 0) {
+        console.log(chalk.yellow(`\n⚠️  Recorded Failures (${results.failures.length}):`));
+        results.failures.slice(0, 5).forEach((f, idx) => {
+          console.log(chalk.dim(`   ${idx + 1}. [${f.method}] ${f.url}`));
+          f.failures.forEach(msg => {
+            console.log(chalk.red(`      - ${msg}`));
+          });
+        });
+        if (results.failures.length > 5) {
+          console.log(chalk.dim(`   ... and ${results.failures.length - 5} more failures`));
+        }
+      }
+
+      if (results.errors.length > 0) {
+        console.log(chalk.red(`\n❌ Execution Errors (${results.errors.length}):`));
+        results.errors.slice(0, 5).forEach((e, idx) => {
+          console.log(chalk.red(`   VU ${e.vuId} Error: ${e.message}`));
+        });
+      }
+
+    } catch (err) {
+      console.log(chalk.red(`❌ Load test execution failed: ${err.message}`));
+    }
+  }
+};

package/src/commands/tasks/task-status.js

@@ -2,60 +2,71 @@
 const chalk = require('chalk');
 
 const STATUS_MAP = {
-    accept:   'accepted',
-    start:    'inprogress',
-    complete: 'completed',
-    reject:   'rejected',
-    done:     'completed',
+  accept:       'accepted',
+  start:        'inprogress',
+  complete:     'completed',
+  reject:       'rejected',
+  done:         'completed',
+  'task-status': null, // requires explicit arg
 };
 
 module.exports = {
-    name:         'task-status',
-    description:  'Update your task status',
-    aliases:      ['accept', 'start', 'complete', 'reject', 'done'],
-    requiresAuth: true,
-    requiresRoom: true,
-
-    async execute(args, shell) {
-        const roomId  = shell.ws.getCurrentRoom();
-        const taskId  = args[0];
-        // invoked as 'accept <id>', 'start <id>', etc.
-        const verb    = shell._lastCommand || 'task-status';
-        const status  = STATUS_MAP[verb] || args[1];
-
-        if (!taskId) {
-            console.log(chalk.yellow('  Usage: accept <taskId> | start <taskId> | complete <taskId>'));
-            return;
-        }
-        if (!status) {
-            console.log(chalk.yellow('  Usage: task-status <taskId> <accepted|inprogress|completed|rejected>'));
-            return;
-        }
-
-        const statusColors = {
-            accepted:   chalk.green,
-            inprogress: chalk.blue,
-            completed:  chalk.green,
-            rejected:   chalk.red,
-        };
-        const col = statusColors[status] || chalk.white;
-
-        try {
-            const result = await shell.api._request(
-                'POST',
-                `/thinknsh/${roomId}/tasks/${taskId}/status`,
-                { status }
-            );
-
-            console.log(col(`\n  ✓ Task "${result.taskTitle}" → ${status}`));
-            if (result.allCompleted) {
-                console.log(chalk.green('  🎉 All assignees done — task fully completed!\n'));
-            } else {
-                console.log('');
-            }
-
-        } catch (err) {
-            console.log(chalk.red(`\n  ❌ ${err.message}\n`));
-        }
+  name:         'task-status',
+  description:  'Update your task status',
+  aliases:      ['accept', 'start', 'complete', 'reject', 'done'],
+  requiresAuth: true,
+  requiresRoom: true,
+
+  async execute(args, shell, invokedAs) {
+  const roomId = shell.ws.getCurrentRoom(); // ← top pe, ek baar
+  const taskId = args[0];
+  const verb   = invokedAs || shell._lastCommand || 'task-status';
+  const status = STATUS_MAP[verb] ?? args[1];
+
+  if (!taskId) {
+    console.log(chalk.yellow('  Usage: accept <taskId> | start <taskId> | complete <taskId>'));
+    return;
+  }
+  if (!status) {
+    console.log(chalk.yellow('  Usage: task-status <taskId> <accepted|inprogress|completed|rejected>'));
+    return;
+  }
+
+  try {
+    const result = await shell.api._request(
+      'POST',
+      `/thinknsh/${roomId}/tasks/${taskId}/status`,
+      { status }
+    );
+
+    const statusColors = {
+      accepted:   chalk.green,
+      inprogress: chalk.blue,
+      completed:  chalk.green,
+      rejected:   chalk.red,
+    };
+
+    const col = statusColors[status] || chalk.white;
+    console.log(col(`\n  ✓ Task "${result.taskTitle}" → ${status}`));
+
+    if (result.allCompleted) {
+      console.log(chalk.green('  🎉 All assignees done — task fully completed!\n'));
+    } else {
+      console.log('');
+    }
+
+    // Socket emit
+    if (shell.ws.isConnected?.() && shell.ws.socket) {
+      shell.ws.socket.emit('task:' + (status === 'inprogress' ? 'started' : status), {
+        roomId,
+        taskId,
+        taskTitle: result.taskTitle,
+        userId:    shell.api.getUser()?._id,
+      });
     }
+
+  } catch (err) {
+    console.log(chalk.red(`\n  ❌ ${err.message}\n`));
+  }
+  }
 };