thinkncollab-shell 0.0.12 → 0.0.13

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,169 @@ 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;
+      }
+
+      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 = [];
+
+  for (const [key, ops] of Object.entries(conditions)) {
+    const actualVal = actual[key];
 
-    if (expect?.text && result.elementText && !result.elementText.includes(expect.text))
-      failures.push(`Element text: expected "${expect.text}", got "${result.elementText}"`);
+    if (actualVal === undefined) {
+      failures.push(`Missing key: "${key}"`);
+      continue;
+    }
 
-    if (expect?.redirectUrl) {
-      const actualPath = new URL(result.url).pathname;
-      if (!actualPath.includes(expect.redirectUrl))
-        failures.push(`URL: expected "${expect.redirectUrl}", got "${actualPath}"`);
+    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 +650,74 @@ 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 {
         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`));
+  }
+  }
 };

package/src/commands/tasks/task.js

@@ -1,6 +1,6 @@
 /*
   src/commands/tasks/task-info.js — View task details + testConfig + webhook URL
-  Usage: task-info <taskId>  OR  info <taskId>
+  Usage: task-info <taskId>  OR  info <taskId> load
 */
 const chalk = require('chalk');
 
@@ -55,6 +55,13 @@ console.log(`  ${chalk.dim('id      ')}  ${chalk.dim(task._id)}${task.taskID ? c
       task.description.split('\n').forEach(l => console.log(`    ${chalk.white(l)}`));
     }
 
+    if (task.referenceLinks && task.referenceLinks.length > 0) {
+      console.log(chalk.cyan('\n  ─── Supported Links ─────────────────────────────'));
+      task.referenceLinks.forEach(link => {
+        console.log(`  ${chalk.dim(link.title.padEnd(12))}  ${chalk.blue(link.url)}`);
+      });
+    }
+
     // ── Assignees ─────────────────────────────────────────────────────────────
     if (task.assignedTo?.length) {
       console.log(chalk.dim('\n  assignees:'));

package/src/commands/terminal/share.js

@@ -63,7 +63,7 @@ async function cmdStart(shell) {
             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(`   URL     : https://thinkncollab.com/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`));