nothumanallowed 13.5.152 → 13.5.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.152",
+  "version": "13.5.153",
   "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

@@ -4652,6 +4652,39 @@ ${completedHeadings ? `## SECTIONS ALREADY WRITTEN (headings only):\n${completed
         return;
       }
 
+      // POST /api/studio/webcraft/stream  { system, user, max_tokens }  → SSE token stream
+      // Used by WebCraft generation for live typewriter effect per file
+      if (pathname === '/api/studio/webcraft/stream' && method === 'POST') {
+        const body = await parseBody(req, 131072);
+        if (!body.system || !body.user) {
+          sendJSON(res, 400, { error: 'system and user required' });
+          logRequest(method, pathname, 400, Date.now() - start);
+          return;
+        }
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+        });
+        let fullText = '';
+        let tokIn = 0, tokOut = 0;
+        try {
+          await callLLMStream(config, body.system, body.user, (token) => {
+            fullText += token;
+            tokOut++;
+            res.write('data: ' + JSON.stringify({ type: 'token', token }) + '\n\n');
+          }, { max_tokens: body.max_tokens || 16384, temperature: 0.3 });
+          tokIn = Math.round((body.system.length + body.user.length) / 4);
+          res.write('data: ' + JSON.stringify({ type: 'done', text: fullText, usage: { prompt_tokens: tokIn, completion_tokens: tokOut } }) + '\n\n');
+        } catch (e) {
+          res.write('data: ' + JSON.stringify({ type: 'error', message: e.message }) + '\n\n');
+        }
+        res.end();
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
       // ── WebCraft Projects — list and delete saved projects ──────────────────
       // GET  /api/studio/webcraft/projects         → { projects: [{name, description, fileCount, createdAt, dir}] }
       // DELETE /api/studio/webcraft/projects/:name → { ok }

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

package/src/services/web-ui.mjs

@@ -8864,19 +8864,20 @@ async function wcGenerate() {
   }
 
   // Helper: generate one file (with two-pass split for large CSS files)
-  async function wcGenOneFile(fp, signal) {
+  // onLiveUpdate(partialContent) is called on each token for live display
+  async function wcGenOneFile(fp, signal, onLiveUpdate) {
     var _nl2 = String.fromCharCode(10);
     var splitPrompts = WC_CSS_SPLIT[fp.name];
     if (splitPrompts) {
-      // Two-pass generation: call LLM twice and concatenate
-      var part1 = await wcCallLLM(sysPreamble, splitPrompts[0] + _nl2 + _nl2 + 'File: ' + fp.name, signal, fp.lang, 8192);
+      // Two-pass generation: streaming on first pass only
+      var part1 = await wcCallLLM(sysPreamble, splitPrompts[0] + _nl2 + _nl2 + 'File: ' + fp.name, signal, fp.lang, 8192, onLiveUpdate);
       part1 = wcStripFences(part1);
       if (signal && signal.aborted) return part1;
-      var part2 = await wcCallLLM(sysPreamble, splitPrompts[1] + _nl2 + _nl2 + 'File: ' + fp.name, signal, fp.lang, 8192);
+      var part2 = await wcCallLLM(sysPreamble, splitPrompts[1] + _nl2 + _nl2 + 'File: ' + fp.name, signal, fp.lang, 8192, function(p2) { if (onLiveUpdate) onLiveUpdate(part1 + _nl2 + _nl2 + p2); });
       part2 = wcStripFences(part2);
       return part1 + _nl2 + _nl2 + part2;
     }
-    var content = await wcCallLLM(sysPreamble, fp.prompt + _nl2 + _nl2 + 'File to generate: ' + fp.name, signal, fp.lang);
+    var content = await wcCallLLM(sysPreamble, fp.prompt + _nl2 + _nl2 + 'File to generate: ' + fp.name, signal, fp.lang, undefined, onLiveUpdate);
     return wcStripFences(content);
   }
 
@@ -8889,6 +8890,23 @@ async function wcGenerate() {
   wcState.activeFile = 0;
   renderWebCraft(document.getElementById('content'));
 
+  // Live render throttle — update UI at most every 120ms per file during streaming
+  var _wcLiveRenderTimers = {};
+  function wcLiveUpdateFile(fpName, fpLang, partialContent) {
+    for (var li = 0; li < wcState.generatedFiles.length; li++) {
+      if (wcState.generatedFiles[li].name === fpName) {
+        wcState.generatedFiles[li].content = partialContent;
+        wcState.generatedFiles[li]._pending = false;
+        break;
+      }
+    }
+    if (_wcLiveRenderTimers[fpName]) return; // throttle
+    _wcLiveRenderTimers[fpName] = setTimeout(function() {
+      delete _wcLiveRenderTimers[fpName];
+      renderWebCraft(document.getElementById('content'));
+    }, 120);
+  }
+
   // Generate in parallel batches of 4 — each call is independent/fresh to Liara
   var BATCH = 4;
   var doneCount = 0;
@@ -8897,7 +8915,8 @@ async function wcGenerate() {
     var batch = filePlan.slice(bi, bi + BATCH);
     wcUpdateGenOverlay(doneCount, filePlan.length, batch.map(function(f){ return f.name; }).join(', '));
     var results = await Promise.allSettled(batch.map(function(fp) {
-      return wcGenOneFile(fp, _wcGenAbortCtrl ? _wcGenAbortCtrl.signal : null).then(function(c){ return { fp: fp, content: c }; });
+      var liveCallback = function(partial) { wcLiveUpdateFile(fp.name, fp.lang, partial); };
+      return wcGenOneFile(fp, _wcGenAbortCtrl ? _wcGenAbortCtrl.signal : null, liveCallback).then(function(c){ return { fp: fp, content: c }; });
     }));
     results.forEach(function(r) {
       if (r.status === 'fulfilled') {
@@ -9120,7 +9139,57 @@ function wcIsTruncated(content, lang) {
   return false;
 }
 
-async function wcCallLLMRaw(sys, user, signal, maxTok) {
+async function wcCallLLMRaw(sys, user, signal, maxTok, onToken) {
+  // Streaming path: use SSE endpoint so tokens appear live in the file editor
+  if (onToken) {
+    var streamOpts = {
+      method: 'POST',
+      headers: {'Content-Type':'application/json'},
+      body: JSON.stringify({system: sys, user: user, max_tokens: maxTok || 16384})
+    };
+    if (signal) streamOpts.signal = signal;
+    for (var sa = 0; sa < 3; sa++) {
+      if (signal && signal.aborted) throw new DOMException('Aborted', 'AbortError');
+      var sr = await fetch(API + '/api/studio/webcraft/stream', streamOpts);
+      if (!sr.ok) {
+        if (sr.status < 500 || sa === 2) throw new Error('LLM stream error ' + sr.status);
+        await new Promise(function(resolve) { setTimeout(resolve, 2000); });
+        continue;
+      }
+      var sreader = sr.body.getReader();
+      var sdec = new TextDecoder();
+      var sbuf = '';
+      var fullText = '';
+      while (true) {
+        var sres = await sreader.read();
+        if (sres.done) break;
+        sbuf += sdec.decode(sres.value, {stream: true});
+        var sparts = sbuf.split(String.fromCharCode(10) + String.fromCharCode(10));
+        sbuf = sparts.pop();
+        for (var si = 0; si < sparts.length; si++) {
+          var sline = sparts[si].replace(/^data: /, '').trim();
+          if (!sline) continue;
+          try {
+            var sev = JSON.parse(sline);
+            if (sev.type === 'token') {
+              fullText += sev.token;
+              onToken(fullText);
+            } else if (sev.type === 'done') {
+              if (sev.usage) {
+                _wcTokIn  += (sev.usage.prompt_tokens || 0);
+                _wcTokOut += (sev.usage.completion_tokens || 0);
+              }
+            } else if (sev.type === 'error') {
+              throw new Error(sev.message || 'Stream error');
+            }
+          } catch(_) {}
+        }
+      }
+      return fullText;
+    }
+  }
+
+  // Non-streaming fallback (used by repair and continuation passes)
   var fetchOpts = {
     method: 'POST',
     headers: {'Content-Type':'application/json'},
@@ -9132,12 +9201,10 @@ async function wcCallLLMRaw(sys, user, signal, maxTok) {
     var r = await fetch(API + '/api/studio/webcraft', fetchOpts);
     if (r.ok) {
       var d = await r.json();
-      // Accumulate token counts if the server returns usage data
       if (d && d.usage) {
         _wcTokIn  += (d.usage.prompt_tokens || d.usage.input_tokens || 0);
         _wcTokOut += (d.usage.completion_tokens || d.usage.output_tokens || 0);
       } else if (d && d.text) {
-        // Estimate from char count (4 chars ≈ 1 token)
         _wcTokIn  += Math.round((sys.length + user.length) / 4);
         _wcTokOut += Math.round((d.text || '').length / 4);
       }
@@ -9153,9 +9220,9 @@ async function wcCallLLMRaw(sys, user, signal, maxTok) {
   }
 }
 
-async function wcCallLLM(sys, user, signal, lang, maxTok) {
-  var content = await wcCallLLMRaw(sys, user, signal, maxTok);
-  // Continuation loop: if response is truncated, ask model to continue
+async function wcCallLLM(sys, user, signal, lang, maxTok, onToken) {
+  var content = await wcCallLLMRaw(sys, user, signal, maxTok, onToken);
+  // Continuation loop: if response is truncated, ask model to continue (no streaming for continuations)
   var maxContinuations = 2;
   for (var ci = 0; ci < maxContinuations; ci++) {
     if (!wcIsTruncated(content, lang || 'text')) break;
@@ -9166,6 +9233,7 @@ async function wcCallLLM(sys, user, signal, lang, maxTok) {
     var continuation = await wcCallLLMRaw(sys, continuePrompt, signal, maxTok);
     if (!continuation || continuation.trim().length < 5) break;
     content = content + String.fromCharCode(10) + continuation;
+    if (onToken) onToken(content);
   }
   return content;
 }