nothumanallowed 15.0.12 → 15.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.0.12",
+  "version": "15.0.14",
   "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/server/routes/webcraft.mjs

@@ -738,14 +738,20 @@ WORKFLOW:
     while ((match = toolRegex.exec(stepResponse)) !== null) {
       let toolCall;
       try {
-        // Fix common JSON issues from LLM
         let raw = match[1].trim();
         raw = raw.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
         toolCall = JSON.parse(raw);
       } catch {
-        toolResults.push({ op: 'error', result: 'JSON parse failed' });
-        emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
-        continue;
+        // LLM often puts raw HTML/code inside JSON values without proper escaping.
+        // Extract fields manually using a robust regex-based parser.
+        try {
+          toolCall = _parseToolCallRobust(match[1].trim());
+        } catch (parseErr2) {
+          console.error('[TOOL-PARSE] JSON parse failed even after robust parse:', parseErr2.message, 'raw:', match[1].slice(0, 200));
+          toolResults.push({ op: 'error', result: 'JSON parse failed' });
+          emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
+          continue;
+        }
       }
 
       const { op, path: relPath, old: oldStr, new: newStr, content, newPath, query, glob: globPat, cmd } = toolCall;
@@ -817,11 +823,14 @@ WORKFLOW:
 
       // ── edit ──
       } else if (op === 'edit') {
+        console.log(`[EDIT-DEBUG] path=${relPath} oldStr.length=${oldStr?.length ?? 'null'} newStr.length=${newStr?.length ?? 'null'}`);
+        if (oldStr) console.log(`[EDIT-DEBUG] old first 100: ${JSON.stringify(oldStr.slice(0, 100))}`);
         const src = ProjectStore.readFile(projectName, relPath);
         if (src === null) {
           toolResults.push({ op: 'edit', path: relPath, result: 'file_not_found' });
           emit({ type: 'tool', op: 'edit', path: relPath, result: 'file_not_found' });
         } else if (src.includes(oldStr)) {
+          console.log(`[EDIT-DEBUG] EXACT MATCH found — applying edit`);
           // Exact match — apply directly
           const newSrc = src.replace(oldStr, newStr ?? '');
           ProjectStore.writeFile(projectName, relPath, newSrc);
@@ -830,6 +839,7 @@ WORKFLOW:
           toolResults.push({ op: 'edit', path: relPath, result: 'ok' });
           emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 2000), newSnippet: newStr?.slice(0, 2000) ?? '' });
         } else {
+          console.log(`[EDIT-DEBUG] NO exact match — trying fuzzy. src.length=${src.length} oldStr.length=${oldStr?.length}`);
           // Fuzzy match: compare lines ignoring leading/trailing whitespace
           const oldLines = oldStr.split('\n').map(l => l.trim());
           const srcLines = src.split('\n');
@@ -2651,6 +2661,93 @@ function _safeName(name) {
   return (name ?? '').replace(/[^a-zA-Z0-9_\-. ]/g, '_').trim() || 'unnamed';
 }
 
+/**
+ * Robust tool call parser for when JSON.parse fails.
+ * The LLM often puts raw HTML/code with unescaped quotes, newlines, < > inside JSON values.
+ * This extracts "op", "path", "old", "new", "content", "query", "cmd" etc. by finding
+ * the key-value boundaries manually.
+ */
+function _parseToolCallRobust(raw) {
+  const result = {};
+
+  // Extract "op" — always a simple string
+  const opMatch = raw.match(/"op"\s*[:>]\s*"([^"]+)"/);
+  if (opMatch) result.op = opMatch[1];
+
+  // Extract "path" — simple string
+  const pathMatch = raw.match(/"path"\s*[:>]\s*"([^"]+)"/);
+  if (pathMatch) result.path = pathMatch[1];
+
+  // Extract "newPath" — simple string
+  const newPathMatch = raw.match(/"newPath"\s*[:>]\s*"([^"]+)"/);
+  if (newPathMatch) result.newPath = newPathMatch[1];
+
+  // Extract "query" — simple string (fix \| to |)
+  const queryMatch = raw.match(/"query"\s*[:>]\s*"([^"]+)"/);
+  if (queryMatch) result.query = queryMatch[1].replace(/\\\|/g, '|');
+
+  // Extract "glob" — simple string
+  const globMatch = raw.match(/"glob"\s*[:>]\s*"([^"]+)"/);
+  if (globMatch) result.glob = globMatch[1];
+
+  // Extract "cmd" — simple string
+  const cmdMatch = raw.match(/"cmd"\s*[:>]\s*"([^"]+)"/);
+  if (cmdMatch) result.cmd = cmdMatch[1];
+
+  // For edit: extract "old" and "new" — these can be HUGE multiline strings with HTML
+  // Strategy: find "old" key, then grab everything until we hit ","new" or the end
+  if (result.op === 'edit') {
+    const oldIdx = raw.indexOf('"old"');
+    const newIdx = raw.indexOf('"new"');
+    if (oldIdx >= 0 && newIdx > oldIdx) {
+      // old value is between "old":"/>" and ","new"
+      let oldStart = raw.indexOf('"', oldIdx + 5); // find opening quote after "old":
+      if (oldStart < 0) oldStart = raw.indexOf('>', oldIdx + 5); // handle "old">
+      if (oldStart >= 0) {
+        oldStart++; // skip the opening quote/bracket
+        // Find the end — look for ","new" pattern
+        const oldEnd = raw.lastIndexOf('"', newIdx - 1);
+        if (oldEnd > oldStart) {
+          result.old = raw.slice(oldStart, oldEnd);
+        }
+      }
+      // new value is after "new":"
+      let newStart = raw.indexOf('"', newIdx + 5);
+      if (newStart < 0) newStart = raw.indexOf('>', newIdx + 5);
+      if (newStart >= 0) {
+        newStart++;
+        // Find end — last " before the closing }
+        const lastBrace = raw.lastIndexOf('}');
+        const newEnd = raw.lastIndexOf('"', lastBrace);
+        if (newEnd > newStart) {
+          result.new = raw.slice(newStart, newEnd);
+        }
+      }
+    }
+  }
+
+  // For write: extract "content"
+  if (result.op === 'write') {
+    const contentIdx = raw.indexOf('"content"');
+    if (contentIdx >= 0) {
+      let contentStart = raw.indexOf('"', contentIdx + 9);
+      if (contentStart < 0) contentStart = raw.indexOf('>', contentIdx + 9);
+      if (contentStart >= 0) {
+        contentStart++;
+        const lastBrace = raw.lastIndexOf('}');
+        const contentEnd = raw.lastIndexOf('"', lastBrace);
+        if (contentEnd > contentStart) {
+          result.content = raw.slice(contentStart, contentEnd);
+        }
+      }
+    }
+  }
+
+  if (!result.op) throw new Error('Could not extract op from tool call');
+  console.log(`[TOOL-PARSE] Robust parse recovered: op=${result.op} path=${result.path} old.len=${result.old?.length ?? 0} new.len=${result.new?.length ?? 0}`);
+  return result;
+}
+
 function _isSafePath(relPath) {
   if (!relPath || typeof relPath !== 'string') return false;
   if (relPath.includes('..') || path.isAbsolute(relPath)) return false;