nothumanallowed 15.1.17 → 15.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.17",
+  "version": "15.1.19",
   "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.17';
+export const VERSION = '15.1.19';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/webcraft.mjs

@@ -246,11 +246,10 @@ class SandboxManager {
     if (this._stoppedByUser) return;
     emit({ type: 'status', msg: `Process exited with code ${exitCode}` });
 
-    // Extract missing module name from stderr
+    // ── Tier 1: missing module → npm install + retry ─────────────────────
     const missingMatch = stderrBuf.match(/Cannot find module ['"]([^'"]+)['"]/);
     if (missingMatch && _attempt < MAX_RETRIES) {
       const missingMod = missingMatch[1];
-      // Skip shim-able or built-in modules
       if (!missingMod.startsWith('.') && !missingMod.startsWith('/') && !missingMod.startsWith('node:')) {
         const pkgName = missingMod.startsWith('@') ? missingMod.split('/').slice(0, 2).join('/') : missingMod.split('/')[0];
         emit({ type: 'phase', phase: 'autofix', msg: `Missing module "${pkgName}" — installing...` });
@@ -268,6 +267,102 @@ class SandboxManager {
       }
     }
 
+    // ── Tier 2: runtime errors that need code fix (require/import mismatch,
+    //   SyntaxError, ReferenceError, TypeError) — extract failing file from
+    //   stack trace and ask LLM to repair it. This is the bug the user hit:
+    //   "require is not defined" inside an ESM project should auto-rewrite
+    //   require() → import statements, or flip package.json "type" field. ───
+    const runtimePatterns = [
+      { name: 'CJS/ESM mismatch',   re: /require is not defined/i,
+        hint: 'The file uses CommonJS `require()` but the project is ESM ("type":"module" in package.json or .mjs extension). Convert all `require(\'X\')` to ES module `import` statements. Convert `module.exports = ...` to `export default ...`. Keep all logic identical.' },
+      { name: 'ESM/CJS mismatch',   re: /Cannot use import statement outside a module/i,
+        hint: 'The file uses ES module `import` but the project is CommonJS. Either add `"type":"module"` to package.json (preferred for new projects) or convert imports to `require()`.' },
+      { name: 'import.meta misuse', re: /import\.meta(?:\.url)? is only valid in/i,
+        hint: 'The file uses `import.meta` in a CommonJS context. Either switch the project to ESM (add `"type":"module"` to package.json) or replace `import.meta.url` with `__filename` / `__dirname`.' },
+      { name: 'SyntaxError',        re: /SyntaxError:.+/i,
+        hint: 'The file has a JavaScript syntax error. Fix the syntax issue — unclosed brackets, missing commas, invalid tokens. Output the complete corrected file.' },
+      { name: 'ReferenceError',     re: /ReferenceError: (\w+) is not defined/i,
+        hint: 'A variable is referenced but never declared/imported. Either import it from the correct module or declare it. Common missing globals: "require" (use import), "process" (Node only — add `import process from \'node:process\'` in ESM), "__dirname" (in ESM use `import.meta.url` + fileURLToPath).' },
+      { name: 'TypeError null/undefined', re: /TypeError: Cannot read prop(?:erties|erty)? .+ of (?:undefined|null)/i,
+        hint: 'Null/undefined access. Add a null-check or optional chaining (?.) before the failing access.' },
+    ];
+
+    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))
+        .filter((v, i, a) => a.indexOf(v) === i)
+        .slice(0, 3);
+
+      if (projectFiles.length > 0) {
+        emit({ type: 'phase', phase: 'autofix', msg: `Runtime error (${matchedPattern.name}) — repairing ${projectFiles.length} file(s)...` });
+        let anyFixed = false;
+        for (const rel of projectFiles) {
+          const abs = path.join(projectDir, rel);
+          let original = '';
+          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:
+
+${errSnippet.slice(0, 1500)}
+
+The failing file is: ${rel}
+
+What to fix: ${matchedPattern.hint}
+
+CRITICAL: Output ONLY the complete corrected file content. No commentary, no markdown fences. Keep all working logic intact — only change what's necessary to fix the error.
+
+Current file content:
+${original.slice(0, 12_000)}`;
+
+          try {
+            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)` });
+              anyFixed = true;
+            }
+          } catch (e) {
+            emit({ type: 'warn', msg: `LLM repair of ${rel} failed: ${(e.message || '').slice(0, 200)}` });
+          }
+        }
+        if (anyFixed) {
+          emit({ type: 'status', msg: `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
     const stderrLines = stderrBuf.split('\n').filter(l => l.trim());
     const errLine = stderrLines.find((l) => l.includes('Error') || l.includes('error'));
@@ -2679,22 +2774,138 @@ export function register(router) {
 
   // ── Sandbox runtime errors (reported by injected script in iframe) ────────
   const sandboxErrors = [];
+  // Debounce: only autofix the same source URL once every 8s to avoid loops
+  const _autofixCooldown = new Map();
+
+  // Browser-side runtime error patterns that we know how to fix.
+  // Each one maps to an LLM repair hint specific to the failure mode.
+  const BROWSER_FIX_PATTERNS = [
+    { name: 'require is not defined',  re: /require is not defined/i,
+      hint: 'The file uses CommonJS `require()` in a browser context where it does NOT exist. Convert all `require("X")` to ES module `import X from "X"` (or named imports as appropriate). Convert `module.exports = ...` to `export default ...`. Ensure the HTML loads the script with `<script type="module" src="...">`. Keep all logic identical.' },
+    { name: 'module is not defined',   re: /\bmodule is not defined/i,
+      hint: 'The file references the CommonJS `module` global which does not exist in browsers. Replace `module.exports = X` with `export default X` (or `export { X }`).' },
+    { name: 'exports is not defined',  re: /\bexports is not defined/i,
+      hint: 'The file uses CommonJS `exports` in a browser context. Replace `exports.X = Y` with `export const X = Y`.' },
+    { name: 'process is not defined',  re: /\bprocess is not defined/i,
+      hint: 'The code references Node.js `process` global in the browser. Either remove the reference (e.g. delete `process.env.X` checks) or stub it: `const process = { env: {} };` at top of file. Prefer removal.' },
+    { name: 'SyntaxError',             re: /SyntaxError:.+|Unexpected (token|identifier|string|end)/i,
+      hint: 'JavaScript syntax error in the file. Fix the syntax — unclosed brackets, missing commas, invalid token. Output the complete corrected file.' },
+    { name: 'ReferenceError',          re: /(?:Uncaught )?ReferenceError: (\w+) is not defined/i,
+      hint: 'A variable is referenced but never declared/imported. Either import it from the correct module, define it, or remove the dead reference.' },
+    { name: 'TypeError null/undefined', re: /(?:Uncaught )?TypeError: (?:Cannot read prop(?:erties|erty)? .+ of (?:undefined|null)|null is not an object|undefined is not (?:a function|an object))/i,
+      hint: 'Null/undefined access. Add a null-check or optional chaining (?.) before the failing access. If the failure is on DOM element lookup, the script may be running before the DOM is ready — wrap in DOMContentLoaded.' },
+  ];
+
   router.post('/api/studio/webcraft/sandbox/errors', async (req, res) => {
     try {
       const body = await parseBody(req);
-      if (body.error) {
+      if (!body.error) return sendJSON(res, 200, { ok: true });
+
+      const message = String(body.error).slice(0, 500);
+      const source  = String(body.source || '').slice(0, 200);
+      const stack   = String(body.stack || '').slice(0, 1000);
+
+      sandboxErrors.push({
+        ts: new Date().toISOString(),
+        message,
+        source,
+        line: body.line || 0,
+        col: body.col || 0,
+        stack,
+      });
+      if (sandboxErrors.length > 20) sandboxErrors.splice(0, sandboxErrors.length - 20);
+
+      // Respond to the iframe immediately — autofix runs async after.
+      sendJSON(res, 200, { ok: true });
+
+      // ── Autofix path ────────────────────────────────────────────────
+      const sb = sandbox._sandbox;
+      if (!sb || !sb.projectName) return; // no project — can't fix
+      const projectDir = ProjectStore.dir(sb.projectName);
+      if (!fs.existsSync(projectDir)) return;
+
+      const matched = BROWSER_FIX_PATTERNS.find(p => p.re.test(message) || p.re.test(stack));
+      if (!matched) return;
+
+      // Resolve the failing file from the source URL.
+      // source is typically "http://localhost:NNNN/path/to/file.js?..." or
+      // a bare filename. We strip the origin and query, then map under projectDir.
+      let relFile = '';
+      try {
+        if (source && source.includes('://')) {
+          const u = new URL(source);
+          relFile = u.pathname.replace(/^\/+/, '').split('?')[0];
+        } else if (source) {
+          relFile = source.replace(/^\/+/, '').split('?')[0];
+        }
+        // Fallback: extract from stack trace
+        if (!relFile && stack) {
+          const m = stack.match(/(?:https?:\/\/[^\s)]+\/)([^\s:?)]+\.(?:m?js|jsx?|tsx?|cjs|html))/);
+          if (m) relFile = m[1];
+        }
+      } catch { /* ignore parse errors */ }
+
+      // Strip leading "static/" or asset prefixes that Vite/Webpack add
+      relFile = relFile.replace(/^(static|assets|dist|public|build|out)\//, '');
+
+      if (!relFile) return;
+
+      const absFile = path.join(projectDir, relFile);
+      // Safety: must be inside projectDir
+      if (!absFile.startsWith(projectDir + path.sep)) return;
+      if (!fs.existsSync(absFile)) return;
+
+      // Cooldown: don't autofix the same file more than once every 8s
+      const cdKey = absFile;
+      const now = Date.now();
+      const last = _autofixCooldown.get(cdKey) || 0;
+      if (now - last < 8_000) return;
+      _autofixCooldown.set(cdKey, now);
+
+      const original = fs.readFileSync(absFile, 'utf-8');
+      if (!original || original.length < 5) return;
+
+      const fixPrompt =
+`A browser sandbox preview crashed with this runtime error:
+
+Error: ${message}
+Source: ${source}
+Stack (first lines):
+${stack.slice(0, 800)}
+
+The failing file is: ${relFile}
+
+What to fix: ${matched.hint}
+
+CRITICAL: Output ONLY the complete corrected file content. No commentary, no markdown fences. Keep all working logic intact — only change what's necessary to fix the runtime error.
+
+Current file content:
+${original.slice(0, 12_000)}`;
+
+      try {
+        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: 16_384 });
+        fixed = fixed.replace(/^```[\w]*\n/, '').replace(/\n```$/, '').trim();
+        if (fixed.length > 20 && fixed !== original) {
+          fs.writeFileSync(absFile, fixed, 'utf-8');
+          // Notify connected WebSocket clients so the iframe can be reloaded.
+          // The Studio/WebCraft UI polls these errors and will surface the fix.
+          sandboxErrors.push({
+            ts: new Date().toISOString(),
+            message: `✓ Auto-fix applied to ${relFile} (${matched.name}) — reload the preview to test.`,
+            source: '__autofix__',
+            line: 0, col: 0, stack: '',
+          });
+          if (sandboxErrors.length > 20) sandboxErrors.splice(0, sandboxErrors.length - 20);
+        }
+      } catch (e) {
         sandboxErrors.push({
           ts: new Date().toISOString(),
-          message: String(body.error).slice(0, 500),
-          source: String(body.source || '').slice(0, 200),
-          line: body.line || 0,
-          col: body.col || 0,
-          stack: String(body.stack || '').slice(0, 1000),
+          message: `✗ Auto-fix failed for ${relFile}: ${(e.message || '').slice(0, 200)}`,
+          source: '__autofix__',
+          line: 0, col: 0, stack: '',
         });
-        // Keep only last 20 errors
-        if (sandboxErrors.length > 20) sandboxErrors.splice(0, sandboxErrors.length - 20);
       }
-      sendJSON(res, 200, { ok: true });
     } catch { sendJSON(res, 200, { ok: true }); }
   });