nothumanallowed 15.1.19 → 15.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.19",
+  "version": "15.1.20",
   "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/constants.mjs

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

package/src/server/routes/webcraft.mjs

@@ -289,19 +289,99 @@ class SandboxManager {
 
     const matchedPattern = runtimePatterns.find(p => p.re.test(stderrBuf));
     if (matchedPattern && _attempt < MAX_RETRIES) {
-      // Extract the file path from the stack trace.
-      // Patterns: "at /abs/path/file.js:N:M", "at file:///abs/path/file.js:N:M",
-      // "at Object.<anonymous> (/path/file.js:N:M)", or simply at start of stderr.
-      const fileMatches = [...stderrBuf.matchAll(/(?:at\s+(?:[\w<>\.\s]+\s+)?\(?)?(?:file:\/\/)?(\/[^\s:()'"]+\.(?:m?js|cjs|jsx?|tsx?)):\d+(?::\d+)?/g)];
-      const projectFiles = fileMatches
-        .map(m => m[1])
-        .filter(p => p && p.startsWith(projectDir))
-        .map(p => path.relative(projectDir, p))
+      emit({ type: 'phase', phase: 'autofix', msg: `Runtime error detected: ${matchedPattern.name} — analyzing...` });
+
+      // ── Special pre-fix for require/import mismatches ──
+      // For "require is not defined" the project is ESM but uses CJS syntax.
+      // Easiest fix: flip package.json — REMOVE "type":"module" so CJS works,
+      // OR rewrite files. We try the package.json toggle FIRST (cheaper) only
+      // when the failing files clearly use `require()`. For the inverse case
+      // ("Cannot use import statement outside a module") we ADD "type":"module".
+      const pkgPath = path.join(projectDir, 'package.json');
+      const isRequireError = /require is not defined/i.test(stderrBuf);
+      const isImportError  = /Cannot use import statement outside a module/i.test(stderrBuf);
+
+      if ((isRequireError || isImportError) && fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+          if (isImportError && pkg.type !== 'module') {
+            pkg.type = 'module';
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+            emit({ type: 'status', msg: 'Auto-fix: added "type":"module" to package.json — retrying...' });
+            return this.start(projectName, projectDir, emit, _attempt + 1);
+          }
+          if (isRequireError && pkg.type === 'module') {
+            // Flip OFF "type":"module" so require() works again
+            delete pkg.type;
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+            emit({ type: 'status', msg: 'Auto-fix: removed "type":"module" from package.json — retrying...' });
+            return this.start(projectName, projectDir, emit, _attempt + 1);
+          }
+        } catch (e) {
+          emit({ type: 'warn', msg: `package.json toggle failed: ${e.message.slice(0, 200)}` });
+        }
+      }
+
+      // ── Extract file path from stack trace (multiple patterns) ──
+      // Try several regex forms to be robust against various Node stack formats.
+      const allPaths = new Set();
+      // Form A: "at /abs/path/file.js:N:M" or "at file:///abs/path/file.js:N:M"
+      for (const m of stderrBuf.matchAll(/(?:file:\/\/)?(\/[^\s:()'"]+\.(?:m?js|cjs|jsx?|tsx?)):\d+(?::\d+)?/g)) {
+        allPaths.add(m[1]);
+      }
+      // Form B: ESM error header "file:///path/file.js:N"
+      for (const m of stderrBuf.matchAll(/file:\/\/(\/[^\s:'"]+\.(?:m?js|cjs|jsx?|tsx?)):?\d*/g)) {
+        allPaths.add(m[1]);
+      }
+      // Form C: bare absolute path at start of line (Node prints this for CJS syntax)
+      for (const m of stderrBuf.matchAll(/^(\/[^\s:'"]+\.(?:m?js|cjs|jsx?|tsx?))(?::\d+)?$/gm)) {
+        allPaths.add(m[1]);
+      }
+
+      // First filter: paths that look like they live in this project
+      let projectFiles = [...allPaths]
+        .filter(p => p.startsWith(projectDir) || p.includes('/' + path.basename(projectDir) + '/'))
+        .map(p => p.startsWith(projectDir) ? path.relative(projectDir, p) : null)
+        .filter(Boolean)
         .filter((v, i, a) => a.indexOf(v) === i)
-        .slice(0, 3);
+        .slice(0, 5);
+
+      // FALLBACK: if no stack-trace files matched, scan the project directory
+      // for all .js / .mjs / .cjs files (excluding node_modules) and pick the
+      // ones that contain `require(` or `import` — those are the candidates.
+      if (projectFiles.length === 0) {
+        emit({ type: 'status', msg: `Stack trace did not reveal a file in project — scanning project files...` });
+        try {
+          const _walk = (dir, out = []) => {
+            for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+              if (ent.name === 'node_modules' || ent.name.startsWith('.')) continue;
+              const abs = path.join(dir, ent.name);
+              if (ent.isDirectory()) _walk(abs, out);
+              else if (/\.(m?js|cjs)$/.test(ent.name)) out.push(abs);
+            }
+            return out;
+          };
+          const allJs = _walk(projectDir);
+          // Heuristic — pick files matching the error semantics
+          const triggers = isRequireError
+            ? /\brequire\s*\(/
+            : isImportError ? /^\s*import\s+/m
+            : /\brequire\s*\(|^\s*import\s+/m;
+          const candidates = allJs
+            .filter(abs => {
+              try { return triggers.test(fs.readFileSync(abs, 'utf-8')); } catch { return false; }
+            })
+            .slice(0, 3);
+          projectFiles = candidates.map(abs => path.relative(projectDir, abs));
+        } catch (e) {
+          emit({ type: 'warn', msg: `Project scan failed: ${e.message.slice(0, 200)}` });
+        }
+      }
 
-      if (projectFiles.length > 0) {
-        emit({ type: 'phase', phase: 'autofix', msg: `Runtime error (${matchedPattern.name}) — repairing ${projectFiles.length} file(s)...` });
+      if (projectFiles.length === 0) {
+        emit({ type: 'warn', msg: `Auto-fix: could not identify a target file to repair. Stack trace shown above.` });
+      } else {
+        emit({ type: 'phase', phase: 'autofix', msg: `Auto-fix repairing ${projectFiles.length} file(s): ${projectFiles.join(', ')}` });
         let anyFixed = false;
         for (const rel of projectFiles) {
           const abs = path.join(projectDir, rel);
@@ -309,8 +389,6 @@ class SandboxManager {
           try { original = fs.readFileSync(abs, 'utf-8'); } catch { continue; }
           if (!original) continue;
 
-          // Build a focused repair prompt — include the runtime error so the
-          // model knows exactly what to fix.
           const errSnippet = stderrBuf.split('\n').slice(0, 30).join('\n');
           const fixPrompt =
 `A Node.js sandbox crashed with this runtime error:
@@ -327,40 +405,26 @@ Current file content:
 ${original.slice(0, 12_000)}`;
 
           try {
+            emit({ type: 'status', msg: `Auto-fix: rewriting ${rel}...` });
             let fixed = '';
             await callLLMStream(loadConfig(), 'You are a precise code repair assistant. Output only the corrected file, no explanation.', fixPrompt, (c) => { fixed += c; }, { max_tokens: 16384 });
             fixed = fixed.replace(/^```[\w]*\n/, '').replace(/\n```$/, '').trim();
             if (fixed.length > 20 && fixed !== original) {
               fs.writeFileSync(abs, fixed, 'utf-8');
-              emit({ type: 'status', msg: `Repaired ${rel} (${fixed.length} chars)` });
+              emit({ type: 'status', msg: `Auto-fix: ✓ repaired ${rel} (${fixed.length} chars)` });
               anyFixed = true;
+            } else {
+              emit({ type: 'warn', msg: `Auto-fix: LLM returned no useful change for ${rel}` });
             }
           } catch (e) {
-            emit({ type: 'warn', msg: `LLM repair of ${rel} failed: ${(e.message || '').slice(0, 200)}` });
+            emit({ type: 'warn', msg: `Auto-fix: LLM repair of ${rel} failed — ${(e.message || '').slice(0, 200)}` });
           }
         }
         if (anyFixed) {
-          emit({ type: 'status', msg: `Restarting sandbox (attempt ${_attempt + 1}/${MAX_RETRIES})...` });
+          emit({ type: 'status', msg: `Auto-fix: restarting sandbox (attempt ${_attempt + 1}/${MAX_RETRIES})...` });
           return this.start(projectName, projectDir, emit, _attempt + 1);
         }
       }
-
-      // Special fallback for CJS/ESM mismatches: try flipping package.json "type"
-      if (matchedPattern.name.includes('CJS/ESM') || matchedPattern.name.includes('ESM/CJS')) {
-        const pkgPath = path.join(projectDir, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-          try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            const isCjsError = /Cannot use import statement outside a module/i.test(stderrBuf);
-            if (isCjsError && pkg.type !== 'module') {
-              pkg.type = 'module';
-              fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
-              emit({ type: 'status', msg: 'Added "type":"module" to package.json — retrying...' });
-              return this.start(projectName, projectDir, emit, _attempt + 1);
-            }
-          } catch { /* ignore */ }
-        }
-      }
     }
 
     // Show the actual error from stderr — include full trace for debugging