nothumanallowed 13.5.131 → 13.5.133

package/bin/nha

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * nha — NotHumanAllowed CLI
+ *
+ * Thin launcher for Legion (multi-agent deliberation) and PIF (agent social client).
+ * Zero dependencies. Downloads core files on first run to ~/.nha/.
+ *
+ * Usage:
+ *   npx nha run "Compare React vs Vue for enterprise"
+ *   npx nha agents
+ *   npx nha pif register
+ *   npx nha install nha-code-reviewer
+ *   npx nha config set provider anthropic
+ *   npx nha update
+ */
+
+import { fileURLToPath, pathToFileURL } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ── Node.js version gate ────────────────────────────────────────────────────
+const major = parseInt(process.version.slice(1), 10);
+if (major < 20) {
+  console.error(`\x1b[31mError: nha requires Node.js 20 or later (found ${process.version}).\x1b[0m`);
+  console.error('Install from https://nodejs.org');
+  process.exit(1);
+}
+
+// ── Launch CLI ──────────────────────────────────────────────────────────────
+// On Windows, dynamic import() requires file:// URLs, not raw paths like C:\...
+const cliPath = path.join(__dirname, '..', 'src', 'cli.mjs');
+const cliUrl = pathToFileURL(cliPath).href;
+const { main } = await import(cliUrl);
+await main(process.argv.slice(2));

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.131",
+  "version": "13.5.133",
   "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": {
-    "nha": "./bin/nha.mjs",
-    "nothumanallowed": "./bin/nha.mjs"
+    "nha": "./bin/nha",
+    "nothumanallowed": "./bin/nha"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/commands/ui.mjs

@@ -5445,48 +5445,70 @@ module.exports = { validateEmail, sanitizeText, validatePassword, validateUserna
 
           let _lastMissingModule = null;
           let _lastCrashError = null;
+          let _stderrBuffer = '';  // accumulate full stderr for rich error context
           proc.stdout.on('data', d => { const l = d.toString().trim(); if (l) sendLog('  [server] ' + l); });
           proc.stderr.on('data', d => {
             const raw = d.toString();
+            _stderrBuffer += raw;
             // MODULE_NOT_FOUND
             const modMatch = raw.match(/Cannot find module '([^']+)'/);
             if (modMatch) {
               const missingMod = modMatch[1];
               _lastMissingModule = missingMod;
-              _lastCrashError = "Cannot find module '" + missingMod + "'";
+              _lastCrashError = "Cannot find module '" + missingMod + "'\n" + _stderrBuffer.slice(0, 1500);
               sendLog('  ❌ Modulo mancante: ' + missingMod);
               if (!global._wcAutoFixQueue) global._wcAutoFixQueue = [];
               global._wcAutoFixQueue.push({ type: 'module_not_found', module: missingMod, dir: sandboxDir, ts: Date.now() });
               sendLog('  🤖 Avvio auto-fix...');
               return;
             }
-            // TypeError / SyntaxError / ReferenceError — capture for autofix
+            // TypeError / SyntaxError / ReferenceError / Error — capture with full stack
             const crashMatch = raw.match(/^(TypeError|SyntaxError|ReferenceError|Error):\s+(.+)/m);
             if (crashMatch) {
-              _lastCrashError = crashMatch[1] + ': ' + crashMatch[2].trim();
-              sendLog('  ❌ ' + _lastCrashError);
+              _lastCrashError = crashMatch[1] + ': ' + crashMatch[2].trim() + '\n' + _stderrBuffer.slice(0, 1500);
+              sendLog('  ❌ ' + crashMatch[1] + ': ' + crashMatch[2].trim());
               if (!global._wcAutoFixQueue) global._wcAutoFixQueue = [];
               global._wcAutoFixQueue.push({ type: 'crash_error', error: _lastCrashError, dir: sandboxDir, ts: Date.now() });
               sendLog('  🤖 Avvio auto-fix...');
               return;
             }
-            // Skip node internals noise
+            // Log everything else (including at-lines during crash) for visibility
             const l = raw.trim();
-            if (!l || l.startsWith('at ') || l.startsWith('(node:') || l === '^') return;
+            if (!l || l.startsWith('(node:') || l === '^') return;
             sendLog('  [server] ' + l);
           });
 
-          // Wait for server to be ready (max 10s)
+          // Wait for server to be ready (max 30s).
+          // If process exits early (crash), report the error immediately so the client
+          // can trigger auto-fix while the SSE connection is still open.
           await new Promise((resolve, reject) => {
             let attempts = 0;
+            const MAX_ATTEMPTS = 60; // 30s at 500ms intervals
+            let crashed = false;
+
+            proc.on('exit', (code) => {
+              if (crashed || code === 0) return;
+              crashed = true;
+              // Give stderr a moment to flush
+              setTimeout(() => {
+                const errMsg = _lastCrashError || (_lastMissingModule ? "Cannot find module '" + _lastMissingModule + "'" : 'Server crashed (exit code ' + code + ')');
+                reject(new Error(errMsg));
+              }, 300);
+            });
+
             const tryConnect = () => {
-                const s = netMod.createConnection(freePort, '127.0.0.1');
-                s.on('connect', () => { s.destroy(); resolve(); });
-                s.on('error', () => {
-                  s.destroy();
-                  if (++attempts > 20) reject(new Error(_lastMissingModule ? "Cannot find module '" + _lastMissingModule + "'" : 'Server non risponde dopo 10s'));
-                  else setTimeout(tryConnect, 500);
-                });
+              if (crashed) return;
+              const s = netMod.createConnection(freePort, '127.0.0.1');
+              s.on('connect', () => { s.destroy(); resolve(); });
+              s.on('error', () => {
+                s.destroy();
+                if (crashed) return;
+                if (++attempts > MAX_ATTEMPTS) {
+                  reject(new Error(_lastCrashError || (_lastMissingModule ? "Cannot find module '" + _lastMissingModule + "'" : 'Server non risponde dopo 30s')));
+                } else {
+                  setTimeout(tryConnect, 500);
+                }
+              });
             };
             setTimeout(tryConnect, 1000);
           });
@@ -5686,12 +5708,49 @@ REGOLE CRITICHE:
               const { callLLMVision } = await import('../services/llm.mjs');
               const va = visionAttachments[0];
               fullResponse = await callLLMVision(config, systemPrompt, userMsg, { base64: va.base64, mimeType: va.mimeType });
-              sendEv({ type: 'text', token: fullResponse });
+              // Strip <tool>...</tool> blocks before sending text to client
+              const visibleText = fullResponse.replace(/<tool>[\s\S]*?<\/tool>/g, '').trim();
+              if (visibleText) sendEv({ type: 'text', token: visibleText });
             } else {
+              // Stream tokens but suppress <tool>...</tool> blocks from the visible text
+              let _toolBuf = '';     // accumulates content inside a <tool> block
+              let _inTool = false;   // are we inside a <tool>...</tool>?
               await callLLMStream(config, systemPrompt, userMsg, (token) => {
                 fullResponse += token;
-                sendEv({ type: 'text', token });
+                // Feed token through tool-suppression filter
+                let remaining = (_inTool ? '' : '') + token; // process token char by char via buffer
+                // Simpler approach: buffer until we can decide
+                _toolBuf += token;
+                // Flush visible text up to next <tool> opening
+                while (true) {
+                  if (!_inTool) {
+                    const toolStart = _toolBuf.indexOf('<tool>');
+                    if (toolStart === -1) {
+                      // No tool block opening — safe to send everything except possible partial '<tool' at end
+                      const safeEnd = _toolBuf.length - 6; // keep last 6 chars in case '<tool>' spans tokens
+                      if (safeEnd > 0) {
+                        sendEv({ type: 'text', token: _toolBuf.slice(0, safeEnd) });
+                        _toolBuf = _toolBuf.slice(safeEnd);
+                      }
+                      break;
+                    } else {
+                      // Flush text before the <tool>
+                      if (toolStart > 0) {
+                        sendEv({ type: 'text', token: _toolBuf.slice(0, toolStart) });
+                      }
+                      _toolBuf = _toolBuf.slice(toolStart);
+                      _inTool = true;
+                    }
+                  } else {
+                    const toolEnd = _toolBuf.indexOf('</tool>');
+                    if (toolEnd === -1) break; // still accumulating tool block
+                    _toolBuf = _toolBuf.slice(toolEnd + 7); // discard the </tool> and move on
+                    _inTool = false;
+                  }
+                }
               }, { max_tokens: 4096 });
+              // Flush any remaining visible text after stream ends
+              if (!_inTool && _toolBuf.trim()) sendEv({ type: 'text', token: _toolBuf });
             }
           } catch (llmErr) {
             const errMsg = llmErr.message || String(llmErr);
@@ -5731,6 +5790,17 @@ REGOLE CRITICHE:
             return out;
           };
 
+          // Second-pass JSON repair: fix missing commas between object properties
+          // e.g. {"a":1\n"b":2} → {"a":1,"b":2}
+          const repairJson = (raw) => {
+            // Add missing commas between } or ] or "..." or number/bool/null and the next " or { or [
+            return raw
+              .replace(/([}\]"'0-9truefalsNullnull])\s*\n\s*(")/g, '$1,\n"')   // after value, before next key
+              .replace(/([}\]"'0-9truefalsNullnull])\s*\n\s*([{[])/g, '$1,\n$2') // after value, before { or [
+              // Remove trailing commas before } or ]
+              .replace(/,(\s*[}\]])/g, '$1');
+          };
+
           const toolRegex = /<tool>([\s\S]*?)<\/tool>/g;
           let toolMatch;
           const toolResults = [];
@@ -5738,7 +5808,13 @@ REGOLE CRITICHE:
             let toolCall;
             try {
               const raw = toolMatch[1].trim();
-              toolCall = JSON.parse(sanitizeToolJson(raw));
+              const sanitized = sanitizeToolJson(raw);
+              try {
+                toolCall = JSON.parse(sanitized);
+              } catch(_) {
+                // Second attempt: repair missing commas
+                toolCall = JSON.parse(repairJson(sanitized));
+              }
             } catch(e) {
               sendEv({ type: 'tool', op: 'parse_error', path: '?', result: 'JSON malformato: ' + e.message.slice(0, 80) });
               continue;

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 = '13.5.131';
+export const VERSION = '13.5.133';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/web-ui.mjs

@@ -9387,7 +9387,7 @@ async function wcFixSandboxError() {
         try {
           var ev4 = JSON.parse(line4);
           if (ev4.type === 'text') { agentMsg.text += ev4.token; renderWebCraft(document.getElementById('content')); wcScrollChatToBottom(); }
-          else if (ev4.type === 'tool') { agentMsg.tools.push({ op: ev4.op, path: ev4.path, result: ev4.result }); renderWebCraft(document.getElementById('content')); }
+          else if (ev4.type === 'tool') { agentMsg.tools.push({ op: ev4.op, path: ev4.path, result: ev4.result, oldSnippet: ev4.oldSnippet || '', newSnippet: ev4.newSnippet || '' }); renderWebCraft(document.getElementById('content')); }
           else if (ev4.type === 'done') {
             wcChatRunning = false;
             if (ev4.changed) {