thinkncollab-shell 0.0.13 → 0.0.15

package/Readme.md

@@ -22,7 +22,7 @@ A real-time collaborative terminal shell with WebSocket integration, built on to
   - [Notification Commands](#notification-commands)
   - [Shell Commands](#shell-commands)
   - [GitHub Integration Commands](#github-integration-commands)
-- [`.tncproject` Auto-Boot](#tncproject-auto-boot)
+- [`tncproject` Auto-Boot](#tncproject-auto-boot)
 - [Notification Window](#notification-window)
 - [Built-in Shell Features](#built-in-shell-features)
 - [Single-Command Mode](#single-command-mode)
@@ -38,7 +38,7 @@ A real-time collaborative terminal shell with WebSocket integration, built on to
 - 📋 **Task Management** — Accept, start, complete, and reject tasks from the CLI
 - 📺 **Terminal Sharing** — Share your live terminal session with teammates (read + write access)
 - 🔔 **Notification Window** — Background TCP-based popup window for live events
-- 🔑 **`.tncproject` Auto-Boot** — Drop a config file in your project root to auto-login and join a room on shell start
+- 🔑 **`tncproject` Auto-Boot** — Drop a config file in your project root to auto-login and join a room on shell start
 - 🛡️ **Shell Token Auth** — Secure HMAC-SHA256 token validation for shell connections
 - 📁 **File System** — Built-in `ls`, `cd`, `pwd`, plus passthrough to your system shell
 - 📜 **History** — Persisted command history at `~/.thinknsh_history`
@@ -443,9 +443,9 @@ Create a new issue in the linked GitHub repository. If arguments are missing, th
 
 ---
 
-## `.tncproject` Auto-Boot
+## `tncproject` Auto-Boot
 
-Place a `.tncproject` file in your project root to auto-login and auto-join a room when `thinknsh` starts in that directory — no manual `login` or `join` needed.
+Place a `tncproject` file in your project root to auto-login and auto-join a room when `thinknsh` starts in that directory — no manual `login` or `join` needed.
 
 ```
 .tncproject
@@ -456,12 +456,12 @@ On startup the shell sends the encrypted config to the server, receives a shell
 ```
   📄 tncproject found
      Room : room-abc123
-     File : /home/user/myproject/.tncproject
+     File : /home/user/myproject/tncproject
 
   ✅ Raman Singh → room "My Project Room"
 ```
 
-If `.tncproject` auth fails, the shell falls back to manual login.
+If `tncproject` auth fails, the shell falls back to manual login.
 
 ---
 
@@ -560,8 +560,8 @@ thinknsh> notify "Daily standup in 5 mins"
 thinknsh> status
 thinknsh> exit
 
-# .tncproject auto-boot (no login needed)
-cd ~/myproject         # contains .tncproject
+# tncproject auto-boot (no login needed)
+cd ~/myproject         # contains tncproject
 thinknsh               # auto-logs in + auto-joins room
 
 # Quick one-liners from CI / scripts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkncollab-shell",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "ThinkNCollab Custom Shell with WebSocket collaboration",
   "main": "src/core/shell.js",
   "bin": {

package/src/commands/tasks/complete.js

@@ -497,6 +497,14 @@ function judgeLocally(testConfig, result) {
         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}` };
     }
@@ -718,6 +726,178 @@ const authConfig = { ...boardAuth, ...(testConfig.auth || {}) };
           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/task.js

@@ -140,6 +140,9 @@ console.log(`  ${chalk.dim('id      ')}  ${chalk.dim(task._id)}${task.taskID ? c
       if (tc.type === 'regex')
         console.log(`  ${chalk.dim('expect  ')}  regex ${chalk.green(tc.expect?.regex || '')}`);
 
+      if (tc.type === 'tnc-build')
+        console.log(`  ${chalk.dim('runner  ')}  ${chalk.green('Local tnc-ci.yml workflow execution')}`);
+
     } else {
       console.log(chalk.yellow('\n  ⚠️  No test config — task will need manual completion'));
       console.log(chalk.dim('   Use: complete <task-id>'));

package/src/core/local-runner.js

@@ -0,0 +1,226 @@
+/**
+ * src/core/local-runner.js
+ * Executes the local .tnc/workflows/*.yml when triggered from browser via thinknsh socket.
+ * Reads workflow from process.cwd() (user's project directory), runs each step,
+ * streams logs to terminal, and submits verdict back to TNC via webhook.
+ */
+
+const fs      = require('fs');
+const path    = require('path');
+const { spawn } = require('child_process');
+const crypto  = require('crypto');
+
+function getFetch() {
+  return globalThis.fetch || require('node-fetch');
+}
+
+/**
+ * Parse .tnc/workflows/*.yml into an array of { name, run } step objects.
+ */
+function parseWorkflow(ymlContent) {
+  const lines = ymlContent.split('\n');
+  let workflowName = 'TNC Local CI';
+  let steps = [];
+  let currentStepName = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+
+    if (!line || line.startsWith('#') || line.startsWith('on:') ||
+        line.startsWith('jobs:') || line.startsWith('build:') ||
+        line.startsWith('runs-on:') || line.startsWith('uses:')) continue;
+
+    if (line.startsWith('name:') && !currentStepName) {
+      workflowName = line.slice(5).trim().replace(/['"]/g, '');
+      continue;
+    }
+
+    if (line.startsWith('- name:')) {
+      currentStepName = line.slice(7).trim().replace(/['"]/g, '');
+      continue;
+    }
+
+    if (line.startsWith('name:') && currentStepName === '') {
+      currentStepName = line.slice(5).trim().replace(/['"]/g, '');
+      continue;
+    }
+
+    if (line.startsWith('- run:') || line.startsWith('run:')) {
+      const prefix = line.startsWith('- run:') ? '- run:' : 'run:';
+      let runCmd = line.slice(prefix.length).trim();
+
+      if (runCmd === '|') {
+        // Multiline block
+        const block = [];
+        let j = i + 1;
+        while (j < lines.length) {
+          const next = lines[j];
+          const m = next.match(/^(\s+)(.*)/);
+          if (m && m[1].length >= 10) { block.push(next.trim()); j++; }
+          else break;
+        }
+        runCmd = block.join('\n');
+        i = j - 1;
+      }
+
+      if (runCmd) {
+        steps.push({ name: currentStepName || runCmd.slice(0, 40), run: runCmd });
+        currentStepName = '';
+      }
+    }
+  }
+
+  return { workflowName, steps };
+}
+
+/**
+ * Run a single shell command, stream output to terminal, resolve with exitCode.
+ */
+function runStep(cmd, cwd, onData) {
+  return new Promise((resolve) => {
+    const isWin   = process.platform === 'win32';
+    const shell   = isWin ? 'cmd.exe' : '/bin/sh';
+    const args    = isWin ? ['/s', '/c', cmd] : ['-c', cmd];
+    const proc    = spawn(shell, args, {
+      cwd,
+      env: { ...process.env, PUPPETEER_SKIP_DOWNLOAD: 'true' }
+    });
+
+    proc.stdout.on('data', d => onData(d.toString()));
+    proc.stderr.on('data', d => onData(d.toString()));
+    proc.on('close', code => resolve(code ?? 0));
+  });
+}
+
+/**
+ * Submit result back to TNC via webhook.
+ */
+async function submitResult(apiUrl, taskId, webhookSecret, result) {
+  const fetch = getFetch();
+  const body  = JSON.stringify(result);
+  const sig   = 'sha256=' + crypto.createHmac('sha256', webhookSecret).update(body).digest('hex');
+  const res   = await fetch(`${apiUrl}/webhooks/tasks/${taskId}/judge`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json', 'x-tnc-signature': sig },
+    body,
+  });
+  if (!res.ok) {
+    const e = await res.json().catch(() => ({}));
+    throw new Error(e.error || `Webhook ${res.status}`);
+  }
+  return res.json();
+}
+
+/**
+ * Main entry — triggered when server emits task:run-local to CLI socket.
+ * @param {Object} opts  { taskId, webhookSecret, apiUrl, chalk, shell }
+ */
+async function runLocal({ taskId, webhookSecret, apiUrl, chalk, shell }) {
+  const projectRoot  = process.cwd();
+  const workflowsDir = path.join(projectRoot, '.tnc', 'workflows');
+
+  console.log(chalk.cyan(`\n📡 TNC Build triggered for task: ${taskId}`));
+  console.log(chalk.dim(`   Project: ${projectRoot}`));
+
+  // 1. Find workflow file
+  if (!fs.existsSync(workflowsDir)) {
+    console.log(chalk.red(`❌ No .tnc/workflows/ directory found in ${projectRoot}`));
+    console.log(chalk.yellow(`   Create one: mkdir -p .tnc/workflows && touch .tnc/workflows/tnc-ci.yml`));
+    return;
+  }
+
+  const files = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+  if (!files.length) {
+    console.log(chalk.red('❌ No .yml workflow files found in .tnc/workflows/'));
+    return;
+  }
+
+  const workflowFile = files[0];
+  const content      = fs.readFileSync(path.join(workflowsDir, workflowFile), 'utf8');
+  const { workflowName, steps } = parseWorkflow(content);
+
+  if (!steps.length) {
+    console.log(chalk.red(`❌ No runnable steps found in ${workflowFile}`));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n🚀 [TNC Actions] Running: "${workflowName}" (${workflowFile})`));
+  console.log(chalk.dim(`   ${steps.length} step(s)\n`));
+
+  // 2. Execute each step
+  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}\n`));
+
+    const onData = chunk => {
+      process.stdout.write(chunk);
+      logsBuffer += chunk;
+    };
+
+    const exitCode  = await runStep(step.run, projectRoot, onData);
+    const stepPassed = exitCode === 0;
+
+    stepResults.push({ name: step.name, command: step.run, exitCode, passed: stepPassed });
+
+    if (stepPassed) {
+      console.log(chalk.green(`\n✅ "${step.name}" passed\n`));
+    } else {
+      overallPassed = false;
+      console.log(chalk.red(`\n❌ "${step.name}" failed (exit ${exitCode}). Aborting.\n`));
+      break;
+    }
+  }
+
+  // 3. Print summary
+  const border = overallPassed ? chalk.green('─'.repeat(50)) : chalk.red('─'.repeat(50));
+  const badge  = overallPassed ? chalk.bgGreen.black(' PASS ') : chalk.bgRed.white(' FAIL ');
+  console.log(border);
+  console.log(`  ${badge}  ${workflowName}`);
+  console.log(border + '\n');
+
+  // 4. Submit verdict to TNC via webhook
+  const 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
+    }
+  };
+
+  try {
+    console.log(chalk.dim('  Syncing verdict with TNC...'));
+    await submitResult(apiUrl, taskId, webhookSecret, result);
+    console.log(chalk.green('  ✓ Verdict saved — task updated on TNC!\n'));
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠️  Sync failed: ${err.message}\n`));
+  }
+
+  // 5. Push notification
+  if (shell && shell.pushNotification) {
+    shell.pushNotification({
+      type:   'verdict',
+      passed: overallPassed,
+      title:  workflowName,
+      reason: overallPassed ? 'TNC Local CI pipeline passed' : `Failed at: ${stepResults[stepResults.length - 1]?.name}`,
+      taskId,
+      at:     new Date().toISOString(),
+    });
+  }
+}
+
+module.exports = { runLocal };

package/src/core/shell.js

@@ -43,7 +43,7 @@ class ThinkNCollabShell extends EventEmitter {
 
         fs.ensureDirSync(this.config.configDir);
 
-        this.ws = new WebSocketManager(this.config.websocket);
+        this.ws = new WebSocketManager({ ...this.config.websocket, _shellRef: this });
         this.currentDir = process.cwd();
         this.username = os.userInfo().username;
         this.history = [];

package/src/core/websocket.js

@@ -25,6 +25,7 @@ class WebSocketManager extends EventEmitter {
         this._authToken     = null;
         this._handlersSetup = false;
         this._serverReady   = false;
+        this._shellRef      = config._shellRef || null;  // ref to Shell instance for api access
     }
 
     // ─── Connect ──────────────────────────────────────────────────────────────
@@ -78,6 +79,47 @@ class WebSocketManager extends EventEmitter {
                     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',
+                            chalk,
+                            shell: shellRef,
+                        });
+                    } catch (err) {
+                        console.error('task:run-local error:', err.message);
+                    }
+                });
+
                 this.socket.on('reconnect', () => {
                     this.connected = true;
                     this.emit('reconnected', {});