nothumanallowed 14.4.2 → 14.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "14.4.2",
+  "version": "14.4.4",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/commands/ui.mjs

@@ -50,18 +50,37 @@ export async function cmdUI(args) {
         console.log(`  \x1b[33m!\x1b[0m Killed previous process on port ${port} (PID ${pid})`);
       }
     } else {
-      // Unix/Mac: lsof to find and kill
-      const out = execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: 'utf-8', timeout: 3000 }).trim();
-      if (out) {
-        const pids = out.split('\n').filter((p) => p && p !== String(process.pid));
-        for (const pid of pids) {
-          try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
-        }
-        if (pids.length > 0) {
-          console.log(`  \x1b[33m!\x1b[0m Killed previous process on port ${port} (PID ${pids.join(', ')})`);
-          await new Promise((r) => setTimeout(r, 500)); // wait for port to free
+      // Unix/Mac: try lsof first, then fuser, then ss+kill as fallbacks
+      let killed = false;
+      // Method 1: lsof
+      try {
+        const out = execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: 'utf-8', timeout: 3000 }).trim();
+        if (out) {
+          const pids = out.split('\n').filter((p) => p && p !== String(process.pid));
+          for (const pid of pids) { try { process.kill(parseInt(pid), 'SIGTERM'); } catch {} }
+          if (pids.length > 0) { killed = true; console.log(`  \x1b[33m!\x1b[0m Killed previous process on port ${port} (PID ${pids.join(', ')})`); }
         }
+      } catch {}
+      // Method 2: fuser (Linux without lsof)
+      if (!killed) {
+        try {
+          execSync(`fuser -k ${port}/tcp 2>/dev/null`, { timeout: 3000, stdio: 'ignore' });
+          killed = true;
+          console.log(`  \x1b[33m!\x1b[0m Killed previous process on port ${port} (via fuser)`);
+        } catch {}
+      }
+      // Method 3: ss + kill (minimal Linux)
+      if (!killed) {
+        try {
+          const out = execSync(`ss -tlnp 2>/dev/null | grep :${port}`, { encoding: 'utf-8', timeout: 3000 }).trim();
+          const pidMatch = out.match(/pid=(\d+)/);
+          if (pidMatch) {
+            try { process.kill(parseInt(pidMatch[1]), 'SIGTERM'); killed = true; } catch {}
+            if (killed) console.log(`  \x1b[33m!\x1b[0m Killed previous process on port ${port} (PID ${pidMatch[1]})`);
+          }
+        } catch {}
       }
+      if (killed) await new Promise((r) => setTimeout(r, 500));
     }
   } catch { /* port is free */ }
 

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '14.4.2';
+export const VERSION = '14.4.4';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/ws.mjs

@@ -1,41 +1,107 @@
 /**
- * WebSocket handler — broadcasts daemon events to the React UI.
+ * WebSocket handler — broadcasts daemon events + interactive terminal.
  * Uses the `ws` package already bundled in nha-cli.
  */
 
 import { createRequire } from 'module';
 import path from 'path';
+import os from 'os';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { NHA_DIR } from '../constants.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Resolve `ws` from nha-cli's node_modules
 const require = createRequire(import.meta.url);
-// __dirname = packages/nha-cli/src/server/ → ../../ = packages/nha-cli/
 const { WebSocketServer } = require(
   path.resolve(__dirname, '../../node_modules/ws/index.js')
 );
 
 let wss = null;
+let wssTerminal = null;
 
 export function setupWebSocket(server) {
+  // ── Main WS — daemon events + version ──
   wss = new WebSocketServer({ server, path: '/api' });
 
   wss.on('connection', async (ws) => {
     const { VERSION } = await import('../constants.mjs');
     ws.send(JSON.stringify({ type: 'connected', ts: Date.now() }));
-    // Send current server version so UI can detect updates
     ws.send(JSON.stringify({ type: 'version', version: VERSION }));
 
     ws.on('message', (data) => {
       try {
         const msg = JSON.parse(data.toString());
-        // Echo back for now — route-specific handlers can call broadcast()
         broadcast({ type: 'echo', payload: msg });
-      } catch { /* ignore malformed */ }
+      } catch {}
     });
 
     ws.on('error', () => {});
   });
+
+  // ── Terminal WS — interactive shell ──
+  wssTerminal = new WebSocketServer({ server, path: '/api/terminal' });
+
+  wssTerminal.on('connection', (ws, req) => {
+    // Parse project from query: /api/terminal?cwd=ProjectName
+    const url = new URL(req.url || '', 'http://localhost');
+    const cwdParam = url.searchParams.get('cwd') || '';
+    let cwd;
+    if (cwdParam && !cwdParam.includes('/') && !cwdParam.includes('\\')) {
+      // Project name → resolve to webcraft dir
+      cwd = path.join(NHA_DIR, 'webcraft', cwdParam);
+    } else if (cwdParam) {
+      cwd = cwdParam;
+    } else {
+      cwd = path.join(NHA_DIR, 'webcraft');
+    }
+    // Security: ensure cwd is under NHA_DIR or home
+    const home = os.homedir();
+    if (!cwd.startsWith(NHA_DIR) && !cwd.startsWith(home)) cwd = home;
+    // Ensure dir exists
+    const fs = await import('fs');
+    if (!fs.default.existsSync(cwd)) cwd = home;
+
+    const shell = process.platform === 'win32' ? 'cmd.exe' : (process.env.SHELL || '/bin/sh');
+    const shellArgs = process.platform === 'win32' ? [] : ['-i']; // interactive
+
+    const proc = spawn(shell, shellArgs, {
+      cwd,
+      env: { ...process.env, TERM: 'xterm-256color', LANG: 'en_US.UTF-8' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // Shell stdout → WS
+    proc.stdout.on('data', (data) => {
+      if (ws.readyState === 1) ws.send(data);
+    });
+
+    // Shell stderr → WS
+    proc.stderr.on('data', (data) => {
+      if (ws.readyState === 1) ws.send(data);
+    });
+
+    // WS → Shell stdin
+    ws.on('message', (data) => {
+      if (proc.stdin.writable) proc.stdin.write(data);
+    });
+
+    // Cleanup
+    proc.on('exit', () => {
+      if (ws.readyState === 1) ws.send('\r\n[shell exited]\r\n');
+      ws.close();
+    });
+
+    ws.on('close', () => {
+      try { proc.kill(); } catch {}
+    });
+
+    ws.on('error', () => {
+      try { proc.kill(); } catch {}
+    });
+
+    // Welcome message
+    ws.send(`\x1b[32mNHA Terminal\x1b[0m — ${cwd}\r\n`);
+  });
 }
 
 export function broadcast(msg) {